26876438778

Committed 03 Jun 2026 09:37AM UTC coverage: 71.113% (+0.02%) from 71.092%

Build # 26876438778

Build Type

push

github

Committed by

web-flow

Commit Message

#1985: install commandlet test fails (#2001)

Coverage Stats

4522 of 7040 branches covered (64.23%)

Branch coverage included in aggregate %.

11711 of 15787 relevant lines covered (74.18%)

3.14 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.01

cli/src/main/java/com/devonfw/tools/ide/io/FileAccessImpl.java

package com.devonfw.tools.ide.io;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.net.http.HttpClient.Version;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.FileSystemException;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.DosFileAttributeView;
import java.nio.file.attribute.FileTime;
import java.nio.file.attribute.PosixFileAttributeView;
import java.nio.file.attribute.PosixFilePermission;
import java.security.DigestInputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.Properties;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

import org.apache.commons.compress.archivers.ArchiveEntry;
import org.apache.commons.compress.archivers.ArchiveInputStream;
import org.apache.commons.compress.archivers.ArchiveOutputStream;
import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream;
import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream;
import org.apache.commons.compress.archivers.zip.ZipFile;
import org.apache.commons.compress.compressors.bzip2.BZip2CompressorOutputStream;
import org.apache.commons.compress.compressors.gzip.GzipCompressorOutputStream;
import org.apache.commons.compress.compressors.gzip.GzipParameters;
import org.apache.commons.io.IOUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.devonfw.tools.ide.cli.CliException;
import com.devonfw.tools.ide.context.IdeContext;
import com.devonfw.tools.ide.io.ini.IniComment;
import com.devonfw.tools.ide.io.ini.IniFile;
import com.devonfw.tools.ide.io.ini.IniSection;
import com.devonfw.tools.ide.os.SystemInfoImpl;
import com.devonfw.tools.ide.process.ProcessContext;
import com.devonfw.tools.ide.process.ProcessMode;
import com.devonfw.tools.ide.process.ProcessResult;
import com.devonfw.tools.ide.util.DateTimeUtil;
import com.devonfw.tools.ide.util.FilenameUtil;
import com.devonfw.tools.ide.util.HexUtil;
import com.devonfw.tools.ide.variable.IdeVariables;

/**
 * Implementation of {@link FileAccess}.
 */
public class FileAccessImpl extends HttpDownloader implements FileAccess {

  private static final Logger LOG = LoggerFactory.getLogger(FileAccessImpl.class);

  private static final String WINDOWS_FILE_LOCK_DOCUMENTATION_PAGE = "https://github.com/devonfw/IDEasy/blob/main/documentation/windows-file-lock.adoc";

  private static final String WINDOWS_FILE_LOCK_WARNING =
      "On Windows, file operations could fail due to file locks. Please ensure the files in the moved directory are not in use. For further details, see: \n"
          + WINDOWS_FILE_LOCK_DOCUMENTATION_PAGE;

  private final IdeContext context;

  /**
   * The constructor.
   *
   * @param context the {@link IdeContext} to use.
   */
  public FileAccessImpl(IdeContext context) {

    super();
    this.context = context;
  }

  @Override
  public void download(String url, Path target) {

    if (url.startsWith("http")) {
      downloadViaHttp(url, target);
    } else if (url.startsWith("ftp") || url.startsWith("sftp")) {
      throw new IllegalArgumentException("Unsupported download URL: " + url);
    } else {
      Path source = Path.of(url);
      if (isFile(source)) {
        // network drive
        copyFileWithProgressBar(source, target);
      } else {
        throw new IllegalArgumentException("Download path does not point to a downloadable file: " + url);
      }
    }
  }

  private void downloadViaHttp(String url, Path target) {

    List<Version> httpProtocols = IdeVariables.HTTP_VERSIONS.get(this.context);
    Exception lastException = null;
    if (httpProtocols.isEmpty()) {
      try {
        downloadWithHttpVersion(url, target, null);
        return;
      } catch (Exception e) {
        lastException = e;
      }
    } else {
      for (Version version : httpProtocols) {
        try {
          downloadWithHttpVersion(url, target, version);
          return;
        } catch (Exception ex) {
          lastException = ex;
        }
      }
    }
    throw new IllegalStateException("Failed to download file from URL " + url + " to " + target, lastException);
  }

  private void downloadWithHttpVersion(String url, Path target, Version httpVersion) throws Exception {

    if (httpVersion == null) {
      LOG.info("Trying to download {} from {}", target.getFileName(), url);
    } else {
      LOG.info("Trying to download {} from {} with HTTP protocol version {}", target.getFileName(), url, httpVersion);
    }
    mkdirs(target.getParent());
    this.context.getNetworkStatus().invokeNetworkTask(() ->
    {
      httpGet(url, httpVersion, (response) -> downloadFileWithProgressBar(url, target, response));
      return null;
    }, url);
  }

  /**
   * Downloads a file while showing a {@link IdeProgressBar}.
   *
   * @param url the url to download.
   * @param target Path of the target directory.
   * @param response the {@link HttpResponse} to use.
   */
  private void downloadFileWithProgressBar(String url, Path target, HttpResponse<InputStream> response) {

    long contentLength = response.headers().firstValueAsLong("content-length").orElse(-1);
    if (contentLength < 0) {
      LOG.warn("Content-Length was not provided by download from {}", url);
    }

    byte[] data = new byte[1024];
    boolean fileComplete = false;
    int count;

    try (InputStream body = response.body();
        FileOutputStream fileOutput = new FileOutputStream(target.toFile());
        BufferedOutputStream bufferedOut = new BufferedOutputStream(fileOutput, data.length);
        IdeProgressBar pb = this.context.newProgressBarForDownload(contentLength)) {
      while (!fileComplete) {
        count = body.read(data);
        if (count <= 0) {
          fileComplete = true;
        } else {
          bufferedOut.write(data, 0, count);
          pb.stepBy(count);
        }
      }
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  private void copyFileWithProgressBar(Path source, Path target) {

    long size = getFileSize(source);
    if (size < 100_000) {
      copy(source, target, FileCopyMode.COPY_FILE_TO_TARGET_OVERRIDE);
      return;
    }
    try (InputStream in = Files.newInputStream(source); OutputStream out = Files.newOutputStream(target)) {
      byte[] buf = new byte[1024];
      try (IdeProgressBar pb = this.context.newProgressbarForCopying(size)) {
        int readBytes;
        while ((readBytes = in.read(buf)) > 0) {
          out.write(buf, 0, readBytes);
          pb.stepBy(readBytes);
        }
      } catch (Exception e) {
        throw new RuntimeException(e);
      }
    } catch (IOException e) {
      throw new RuntimeException("Failed to copy from " + source + " to " + target, e);
    }
  }

  @Override
  public String download(String url) {

    LOG.debug("Downloading text body from {}", url);
    return httpGetAsString(url);
  }

  @Override
  public void mkdirs(Path directory) {

    if (Files.isDirectory(directory)) {
      return;
    }
    LOG.trace("Creating directory {}", directory);
    try {
      Files.createDirectories(directory);
    } catch (IOException e) {
      throw new IllegalStateException("Failed to create directory " + directory, e);
    }
  }

  @Override
  public boolean isFile(Path file) {

    if (!Files.exists(file)) {
      LOG.trace("File {} does not exist", file);
      return false;
    }
    if (Files.isDirectory(file)) {
      LOG.trace("Path {} is a directory but a regular file was expected", file);
      return false;
    }
    return true;
  }

  @Override
  public boolean isExpectedFolder(Path folder) {

    if (Files.isDirectory(folder)) {
      return true;
    }
    LOG.warn("Expected folder was not found at {}", folder);
    return false;
  }

  @Override
  public String checksum(Path file, String hashAlgorithm) {

    MessageDigest md;
    try {
      md = MessageDigest.getInstance(hashAlgorithm);
    } catch (NoSuchAlgorithmException e) {
      throw new IllegalStateException("No such hash algorithm " + hashAlgorithm, e);
    }
    byte[] buffer = new byte[1024];
    try (InputStream is = Files.newInputStream(file); DigestInputStream dis = new DigestInputStream(is, md)) {
      int read = 0;
      while (read >= 0) {
        read = dis.read(buffer);
      }
    } catch (Exception e) {
      throw new IllegalStateException("Failed to read and hash file " + file, e);
    }
    byte[] digestBytes = md.digest();
    return HexUtil.toHexString(digestBytes);
  }

  @Override
  public boolean isJunction(Path path) {

    if (!SystemInfoImpl.INSTANCE.isWindows()) {
      return false;
    }
    try {
      BasicFileAttributes attr = Files.readAttributes(path, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS);
      return attr.isOther() && attr.isDirectory();
    } catch (NoSuchFileException e) {
      return false; // file doesn't exist
    } catch (IOException e) {
      // For broken junctions, reading attributes might fail with various IOExceptions.
      // In such cases, we should check if the path exists without following links.
      // If it exists but we can't read its attributes, it's likely a broken junction.
      if (Files.exists(path, LinkOption.NOFOLLOW_LINKS)) {
        LOG.debug("Path {} exists but attributes cannot be read, likely a broken junction: {}", path, e.getMessage());
        return true; // Assume it's a broken junction
      }
      // If it doesn't exist at all, it's not a junction
      return false;
    }
  }

  @Override
  public Path backup(Path fileOrFolder) {

    if ((fileOrFolder != null) && (Files.isSymbolicLink(fileOrFolder) || isJunction(fileOrFolder))) {
      delete(fileOrFolder);
    } else if ((fileOrFolder != null) && Files.exists(fileOrFolder)) {
      LOG.trace("Going to backup {}", fileOrFolder);
      LocalDateTime now = LocalDateTime.now();
      String date = DateTimeUtil.formatDate(now, true);
      String time = DateTimeUtil.formatTime(now);
      String filename = fileOrFolder.getFileName().toString();
      Path backupBaseDir = this.context.getIdeHome();
      if (backupBaseDir == null) {
        backupBaseDir = this.context.getIdePath();
      }
      Path backupPath = backupBaseDir.resolve(IdeContext.FOLDER_BACKUPS).resolve(date).resolve(time + "_" + filename);
      backupPath = appendParentPath(backupPath, fileOrFolder.getParent(), 2);
      mkdirs(backupPath);
      Path target = backupPath.resolve(filename);
      LOG.info("Creating backup by moving {} to {}", fileOrFolder, target);
      move(fileOrFolder, target);
      return target;
    } else {
      LOG.trace("Backup of {} skipped as the path does not exist.", fileOrFolder);
    }
    return fileOrFolder;
  }

  private static Path appendParentPath(Path path, Path parent, int max) {

    if ((parent == null) || (max <= 0)) {
      return path;
    }
    return appendParentPath(path, parent.getParent(), max - 1).resolve(parent.getFileName());
  }

  @Override
  public void move(Path source, Path targetDir, StandardCopyOption... copyOptions) {

    LOG.trace("Moving {} to {}", source, targetDir);
    try {
      Files.move(source, targetDir, copyOptions);
    } catch (IOException e) {
      String fileType = Files.isSymbolicLink(source) ? "symlink" : isJunction(source) ? "junction" : Files.isDirectory(source) ? "directory" : "file";
      String message = "Failed to move " + fileType + ": " + source + " to " + targetDir + ".";
      if (this.context.getSystemInfo().isWindows()) {
        message = message + "\n" + WINDOWS_FILE_LOCK_WARNING;
      }
      throw new IllegalStateException(message, e);
    }
  }

  @Override
  public void copy(Path source, Path target, FileCopyMode mode, PathCopyListener listener) {

    if (mode.isUseSourceFilename()) {
      // if we want to copy the file or folder "source" to the existing folder "target" in a shell this will copy
      // source into that folder so that we as a result have a copy in "target/source".
      // With Java NIO the raw copy method will fail as we cannot copy "source" to the path of the "target" folder.
      // For folders we want the same behavior as the linux "cp -r" command so that the "source" folder is copied
      // and not only its content what also makes it consistent with the move method that also behaves this way.
      // Therefore we need to add the filename (foldername) of "source" to the "target" path before.
      // For the rare cases, where we want to copy the content of a folder (cp -r source/* target) we support
      // it via the COPY_TREE_CONTENT mode.
      Path fileName = source.getFileName();
      if (fileName != null) { // if filename is null, we are copying the root of a (virtual filesystem)
        target = target.resolve(fileName.toString());
      }
    }
    boolean fileOnly = mode.isFileOnly();
    String operation = mode.getOperation();
    if (mode.isExtract()) {
      LOG.debug("Starting to {} to {}", operation, target);
    } else {
      if (fileOnly) {
        LOG.debug("Starting to {} file {} to {}", operation, source, target);
      } else {
        LOG.debug("Starting to {} {} recursively to {}", operation, source, target);
      }
    }
    if (fileOnly && Files.isDirectory(source)) {
      throw new IllegalStateException("Expected file but found a directory to copy at " + source);
    }
    if (mode.isFailIfExists()) {
      if (Files.exists(target)) {
        throw new IllegalStateException("Failed to " + operation + " " + source + " to already existing target " + target);
      }
    } else if (mode == FileCopyMode.COPY_TREE_OVERRIDE_TREE) {
      delete(target);
    }
    try {
      copyRecursive(source, target, mode, listener);
    } catch (IOException e) {
      throw new IllegalStateException("Failed to " + operation + " " + source + " to " + target, e);
    }
  }

  private void copyRecursive(Path source, Path target, FileCopyMode mode, PathCopyListener listener) throws IOException {

    if (Files.isDirectory(source)) {
      mkdirs(target);
      try (Stream<Path> childStream = Files.list(source)) {
        Iterator<Path> iterator = childStream.iterator();
        while (iterator.hasNext()) {
          Path child = iterator.next();
          copyRecursive(child, target.resolve(child.getFileName().toString()), mode, listener);
        }
      }
      listener.onCopy(source, target, true);
    } else if (Files.exists(source)) {
      if (mode.isOverride()) {
        delete(target);
      }
      LOG.trace("Starting to {} {} to {}", mode.getOperation(), source, target);
      Files.copy(source, target);
      listener.onCopy(source, target, false);
    } else {
      throw new IOException("Path " + source + " does not exist.");
    }
  }

  /**
   * Deletes the given {@link Path} if it is a symbolic link or a Windows junction or hard link. And throws an {@link IllegalStateException} if it fails to
   * delete the file at the given {@link Path}.
   *
   * @param path the {@link Path} to delete.
   */
  private void deleteLinkIfExists(Path path) {

    boolean isJunction = isJunction(path); // since broken junctions are not detected by Files.exists()
    boolean exists = Files.exists(path, LinkOption.NOFOLLOW_LINKS);

    if (isJunction || exists) {
      LOG.info("Deleting previous link or file at " + path);
      try {
        Files.delete(path);
      } catch (IOException e) {
        throw new IllegalStateException("Failed to delete link or file at " + path, e);
      }
    }
  }

  /**
   * Adapts the given {@link Path} to be relative or absolute depending on the given {@code relative} flag. Additionally, {@link Path#toRealPath(LinkOption...)}
   * is applied to {@code target}.
   *
   * @param link the {@link Path} the link should point to and that is to be adapted.
   * @param source the {@link Path} to the link. It is used to calculate the relative path to the {@code target} if {@code relative} is set to
   *     {@code true}.
   * @param relative the {@code relative} flag.
   * @return the adapted {@link Path}.
   * @see #symlink(Path, Path, boolean)
   */
  private Path adaptPath(Path source, Path link, boolean relative) {

    if (!source.isAbsolute()) {
      source = link.resolveSibling(source);
    }
    try {
      source = source.toRealPath(LinkOption.NOFOLLOW_LINKS); // to transform ../d1/../d2 to ../d2
    } catch (IOException e) {
      throw new RuntimeException("Failed to get real path of " + source, e);
    }
    if (relative) {
      source = link.getParent().relativize(source);
      // to make relative links like this work: dir/link -> dir
      source = (source.toString().isEmpty()) ? Path.of(".") : source;
    }
    return source;
  }

  /**
   * Creates a Windows link using mklink at {@code link} pointing to {@code target}.
   *
   * @param source the {@link Path} the link will point to.
   * @param link the {@link Path} where to create the link.
   * @param type the {@link PathLinkType}.
   */
  private void mklinkOnWindows(Path source, Path absoluteSource, Path link, PathLinkType type, boolean relative) {

    Path finalSource = source;
    Path finalLink = link;
    Path cwd = null;
    if (relative) {
      int count = getCommonNameCount(absoluteSource, link);
      if (count < 1) {
        LOG.error("Cannot create relative link at {} pointing to {} - falling back to absolute link", link, absoluteSource);
      } else {
        cwd = getPathStart(absoluteSource, count - 1);
        finalSource = getPathEnd(absoluteSource, count);
        finalLink = getPathEnd(link, count);
      }
    }

    String option = type.getMklinkOption();
    if (type == PathLinkType.SYMBOLIC_LINK) {
      boolean directoryTarget = Files.isDirectory(absoluteSource);
      option = directoryTarget ? "/j" : "/d";
    }

    if (!runMklink(finalSource, finalLink, cwd, option)) {
      throw new IllegalStateException("Failed to create Windows link at " + link + " pointing to " + source);
    }
  }

  private boolean runMklink(Path source, Path link, Path cwd, String option) {

    LOG.trace("Creating a Windows link with mklink {} at {} pointing to {}", option, link, source);
    ProcessContext pc = this.context.newProcess().executable("cmd").addArgs("/c", "mklink", option);
    if (cwd != null) {
      pc.directory(cwd);
    }
    ProcessResult result = pc.addArgs(link.toString(), source.toString()).run(ProcessMode.DEFAULT);
    try {
      result.failOnError();
      return true;
    } catch (RuntimeException e) {
      LOG.debug("mklink {} failed for {} -> {}: {}", option, link, source, e.getMessage());
      return false;
    }
  }

  @Override
  public void link(Path source, Path link, boolean relative, PathLinkType type) {

    Path finalLink = link.toAbsolutePath().normalize();
    Path finalSource;
    try {
      finalSource = adaptPath(source, finalLink, relative);
    } catch (Exception e) {
      throw new IllegalStateException("Failed to adapt target (" + source + ") for link (" + finalLink + ") and relative (" + relative + ")", e);
    }
    Path absoluteSource = finalSource.isAbsolute() ? finalSource : finalLink.getParent().resolve(finalSource).normalize();
    String relativeOrAbsolute = relative ? "relative" : "absolute";
    LOG.debug("Creating {} {} at {} pointing to {}", relativeOrAbsolute, type, finalLink, finalSource);
    deleteLinkIfExists(finalLink);
    try {
      // Attention: JavaDoc and position of path arguments can be very confusing - see comment in #1736
      if (type == PathLinkType.SYMBOLIC_LINK) {
        Files.createSymbolicLink(finalLink, finalSource);
      } else if (type == PathLinkType.HARD_LINK) {
        createHardLink(finalSource, finalLink);
      } else {
        throw new IllegalStateException("" + type);
      }
    } catch (FileSystemException e) {
      if (SystemInfoImpl.INSTANCE.isWindows()) {
        LOG.info(
            "Due to lack of permissions, Microsoft's mklink with junction had to be used to create a Symlink. See\n"
                + "https://github.com/devonfw/IDEasy/blob/main/documentation/symlink.adoc for further details. Error was: "
                + e.getMessage());

        try {
          mklinkOnWindows(finalSource, absoluteSource, finalLink, type, relative);
        } catch (IllegalStateException mkEx) {
          LOG.info("Creating a hard link as a fallback for the failed mklink attempt.");
          createHardLink(absoluteSource, finalLink);
        }
      } else {
        throw new RuntimeException(e);
      }
    } catch (IOException e) {
      throw new IllegalStateException("Failed to create a " + relativeOrAbsolute + " " + type + " at " + finalLink + " pointing to " + source, e);
    }
  }


  /**
   * Creates a hard link at {@code link} pointing to {@code source}.
   *
   * @param source the {@link Path} the hard link will point to.
   * @param link the {@link Path} where to create the hard link.
   */
  void createHardLink(Path source, Path link) {
    try {
      Files.createLink(link, source);
      LOG.trace("Created hard link at {} pointing to {}", link, source);
    } catch (IOException e) {
      throw new RuntimeException("Failed to create a hardlink for " + source + " at " + link, e);
    }
  }

  @Override
  public Path getPathStart(Path path, int nameEnd) {

    int count = path.getNameCount();
    int delta = count - nameEnd - 1;
    if (delta < 0) {
      throw new IllegalArgumentException("Cannot get start before segment " + nameEnd + " from path " + path + " that has only " + count + " segments.");
    }
    Path result = path;
    while (delta > 0) {
      result = result.getParent();
      delta--;
    }
    return result;
  }

  @Override
  public Path getPathEnd(Path path, int nameStart) {

    int count = path.getNameCount();
    if (nameStart > count) {
      throw new IllegalArgumentException("Cannot get end after segment " + nameStart + " from path " + path + " that has only " + count + " segments.");
    } else if (nameStart == count) {
      return Path.of(".");
    }
    Path result = path.getName(nameStart++);
    while (nameStart < count) {
      result = result.resolve(path.getName(nameStart++));
    }
    return result;
  }

  @Override
  public int getCommonNameCount(Path path1, Path path2) {

    if ((path1 == null) || (path2 == null) || !Objects.equals(path1.getRoot(), path2.getRoot())) {
      return -1;
    }
    int minNameCount = Math.min(path1.getNameCount(), path2.getNameCount());
    int i = 0;
    while (i < minNameCount) {
      Path segment1 = path1.getName(i);
      Path segment2 = path2.getName(i);
      if (!segment1.equals(segment2)) {
        break;
      }
      i++;
    }
    return i;
  }

  @Override
  public Path toRealPath(Path path) {

    return toRealPath(path, true);
  }

  @Override
  public Path toCanonicalPath(Path path) {

    return toRealPath(path, false);
  }

  private Path toRealPath(Path path, boolean resolveLinks) {

    try {
      Path realPath;
      if (resolveLinks) {
        realPath = path.toRealPath();
      } else {
        realPath = path.toRealPath(LinkOption.NOFOLLOW_LINKS);
      }
      if (!realPath.equals(path)) {
        LOG.trace("Resolved path {} to {}", path, realPath);
      }
      return realPath;
    } catch (IOException e) {
      throw new IllegalStateException("Failed to get real path for " + path, e);
    }
  }

  @Override
  public Path createTempDir(String name) {

    try {
      Path tmp = this.context.getTempPath();
      Path tempDir = tmp.resolve(name);
      int tries = 1;
      while (Files.exists(tempDir)) {
        long id = System.nanoTime() & 0xFFFF;
        tempDir = tmp.resolve(name + "-" + id);
        tries++;
        if (tries > 200) {
          throw new IOException("Unable to create unique name!");
        }
      }
      return Files.createDirectory(tempDir);
    } catch (IOException e) {
      throw new IllegalStateException("Failed to create temporary directory with prefix '" + name + "'!", e);
    }
  }

  @Override
  public void extract(Path archiveFile, Path targetDir, Consumer<Path> postExtractHook, boolean extract) {

    if (Files.isDirectory(archiveFile)) {
      LOG.warn("Found directory for download at {} hence copying without extraction!", archiveFile);
      copy(archiveFile, targetDir, FileCopyMode.COPY_TREE_CONTENT);
      postExtractHook(postExtractHook, targetDir);
      return;
    } else if (!extract) {
      mkdirs(targetDir);
      move(archiveFile, targetDir.resolve(archiveFile.getFileName()));
      return;
    }
    Path tmpDir = createTempDir("extract-" + archiveFile.getFileName());
    LOG.trace("Trying to extract the file {} to {} and move it to {}.", archiveFile, tmpDir, targetDir);
    String filename = archiveFile.getFileName().toString();
    TarCompression tarCompression = TarCompression.of(filename);
    if (tarCompression != null) {
      extractTar(archiveFile, tmpDir, tarCompression);
    } else {
      String extension = FilenameUtil.getExtension(filename);
      if (extension == null) {
        throw new IllegalStateException("Unknown archive format without extension - can not extract " + archiveFile);
      } else {
        LOG.trace("Determined file extension {}", extension);
      }
      switch (extension) {
        case "zip" -> extractZip(archiveFile, tmpDir);
        case "jar" -> extractJar(archiveFile, tmpDir);
        case "dmg" -> extractDmg(archiveFile, tmpDir);
        case "msi" -> extractMsi(archiveFile, tmpDir);
        case "pkg" -> extractPkg(archiveFile, tmpDir);
        default -> throw new IllegalStateException("Unknown archive format " + extension + ". Can not extract " + archiveFile);
      }
    }
    Path properInstallDir = getProperInstallationSubDirOf(tmpDir, archiveFile);
    postExtractHook(postExtractHook, properInstallDir);
    move(properInstallDir, targetDir);
    delete(tmpDir);
  }

  private void postExtractHook(Consumer<Path> postExtractHook, Path properInstallDir) {

    if (postExtractHook != null) {
      postExtractHook.accept(properInstallDir);
    }
  }

  /**
   * @param path the {@link Path} to start the recursive search from.
   * @return the deepest subdir {@code s} of the passed path such that all directories between {@code s} and the passed path (including {@code s}) are the sole
   *     item in their respective directory and {@code s} is not named "bin".
   */
  private Path getProperInstallationSubDirOf(Path path, Path archiveFile) {

    try (Stream<Path> stream = Files.list(path)) {
      Path[] subFiles = stream.toArray(Path[]::new);
      if (subFiles.length == 0) {
        throw new CliException("The downloaded package " + archiveFile + " seems to be empty as you can check in the extracted folder " + path);
      } else if (subFiles.length == 1) {
        String filename = subFiles[0].getFileName().toString();
        if (!filename.equals(IdeContext.FOLDER_BIN) && !filename.equals(IdeContext.FOLDER_CONTENTS) && !filename.endsWith(".app") && Files.isDirectory(
            subFiles[0])) {
          return getProperInstallationSubDirOf(subFiles[0], archiveFile);
        }
      }
      return path;
    } catch (IOException e) {
      throw new IllegalStateException("Failed to get sub-files of " + path);
    }
  }

  @Override
  public void extractZip(Path file, Path targetDir) {

    LOG.info("Extracting ZIP file {} to {}", file, targetDir);
    extractZipWithJava(file, targetDir);
  }

  /**
   * Extracts a ZIP archive to the given target directory using Java (commons-compress {@link ZipFile}).
   * <p>
   * Symlinks are handled in a two-phase approach: all regular files and directories are written first, and symlinks are collected and created afterwards. This
   * ensures every symlink target already exists on disk before the link is made.
   * <p>
   * {@link ZipFile} is used instead of {@link org.apache.commons.compress.archivers.zip.ZipArchiveInputStream} because Unix file attributes (needed for symlink
   * detection and permission restoration) are stored in the ZIP central directory at the end of the file. A sequential stream only sees the local file headers,
   * where external attributes are always zero. {@link ZipFile} reads the central directory via random access, so attributes are always correct.
   *
   * @param file the ZIP archive to extract.
   * @param targetDir the directory to extract into.
   */
  private void extractZipWithJava(Path file, Path targetDir) {

    final List<PathLink> links = new ArrayList<>();
    try (ZipFile zipFile = ZipFile.builder().setPath(file).get();
        IdeProgressBar pb = this.context.newProgressbarForExtracting(getFileSize(file))) {

      final Path root = targetDir.toAbsolutePath().normalize();
      Enumeration<ZipArchiveEntry> entries = zipFile.getEntries();

      while (entries.hasMoreElements()) {
        ZipArchiveEntry entry = entries.nextElement();
        String entryName = entry.getName();
        Path entryPath = resolveRelativePathSecure(entryName, root);

        if (isZipSymlink(entry)) {
          try (InputStream entryStream = zipFile.getInputStream(entry)) {
            // For symlink entries the file content IS the link target path (Unix zip convention).
            String linkTarget = IOUtils.toString(entryStream, StandardCharsets.UTF_8);
            Path parent = entryPath.getParent();
            Path source = parent.resolve(linkTarget).normalize();
            resolveRelativePathSecure(source, root, linkTarget);
            links.add(new PathLink(source, entryPath, PathLinkType.SYMBOLIC_LINK));
            mkdirs(parent);
          }
        } else if (entry.isDirectory()) {
          mkdirs(entryPath);
        } else {
          mkdirs(entryPath.getParent());
          try (InputStream entryStream = zipFile.getInputStream(entry)) {
            Files.copy(entryStream, entryPath, StandardCopyOption.REPLACE_EXISTING);
          }
          onFileCopiedFromZip(entry, entryPath);
        }
        pb.stepBy(Math.max(0L, entry.getSize()));
      }

      // Phase 2: create all symlinks now that their targets are guaranteed to exist.
      for (PathLink link : links) {
        link(link);
      }
    } catch (IOException e) {
      throw new IllegalStateException("Failed to extract " + file + " to " + targetDir, e);
    }
  }

  /**
   * Returns the Unix file mode stored in the external file attributes of the given ZIP entry.
   * <p>
   * The ZIP specification stores platform-specific metadata in a 32-bit external-attributes field. When the archive was created on a Unix system the layout
   * is:
   * <ul>
   *   <li>bits 31–16 (upper 16 bits): Unix file mode (same bit layout as {@code stat.st_mode})</li>
   *   <li>bits 15–0 (lower 16 bits): MS-DOS attributes (read-only, hidden, …)</li>
   * </ul>
   * Shifting right by 16 and masking with {@code 0xFFFF} isolates the Unix mode.
   *
   * @param entry the ZIP entry to read.
   * @return the Unix file mode, or {@code 0} if no Unix attributes are present.
   */
  private static int getZipUnixMode(ZipArchiveEntry entry) {

    // Right-shift by 16 to move the upper 16 bits (Unix mode) into the lower 16 bits, then
    // mask with 0xFFFF to discard any sign-extended bits introduced by the cast.
    return (int) ((entry.getExternalAttributes() >> 16) & 0xFFFF);
  }

  /**
   * Returns {@code true} if the given ZIP entry represents a symbolic link.
   * <p>
   * Unix file modes encode the file type in the top 4 bits (bits 15–12) of the mode word. The possible file-type values are defined in {@code <sys/stat.h>}:
   * <ul>
   *   <li>{@code 0x8000} – regular file ({@code S_IFREG})</li>
   *   <li>{@code 0x4000} – directory ({@code S_IFDIR})</li>
   *   <li>{@code 0xA000} – symbolic link ({@code S_IFLNK})</li>
   * </ul>
   * Masking with {@code 0xF000} isolates those top 4 bits and comparing against {@code 0xA000} identifies symlinks.
   *
   * @param entry the ZIP entry to test.
   * @return {@code true} if the entry is a symbolic link, {@code false} otherwise.
   */
  private static boolean isZipSymlink(ZipArchiveEntry entry) {

    // 0xF000 masks the file-type nibble; 0xA000 is the Unix S_IFLNK constant.
    return (getZipUnixMode(entry) & 0xF000) == 0xA000;
  }

  /**
   * Applies Unix file permissions stored in a ZIP entry to the extracted file.
   * <p>
   * Permissions are only applied on non-Windows systems because POSIX permission bits have no equivalent on Windows. If the entry carries no Unix attributes
   * (mode is {@code 0}), the call is a no-op.
   *
   * @param entry the source ZIP entry carrying the Unix mode.
   * @param target the extracted file whose permissions should be updated.
   */
  private void onFileCopiedFromZip(ZipArchiveEntry entry, Path target) {

    if (!this.context.getSystemInfo().isWindows()) {
      try {
        int unixMode = getZipUnixMode(entry);
        if (unixMode != 0) {
          Files.setPosixFilePermissions(target, PathPermissions.of(unixMode).toPosix());
        }
      } catch (Exception e) {
        LOG.error("Failed to transfer zip permissions for {}", target, e);
      }
    }
  }

  @Override
  public void extractTar(Path file, Path targetDir, TarCompression compression) {

    extractArchive(file, targetDir, in -> new TarArchiveInputStream(compression.unpack(in)));
  }

  @Override
  public void extractJar(Path file, Path targetDir) {

    extractZip(file, targetDir);
  }

  /**
   * @param permissions The integer as returned by {@link TarArchiveEntry#getMode()} that represents the file permissions of a file on a Unix file system.
   * @return A String representing the file permissions. E.g. "rwxrwxr-x" or "rw-rw-r--"
   */
  public static String generatePermissionString(int permissions) {

    // Ensure that only the last 9 bits are considered
    permissions &= 0b111111111;

    StringBuilder permissionStringBuilder = new StringBuilder("rwxrwxrwx");
    for (int i = 0; i < 9; i++) {
      int mask = 1 << i;
      char currentChar = ((permissions & mask) != 0) ? permissionStringBuilder.charAt(8 - i) : '-';
      permissionStringBuilder.setCharAt(8 - i, currentChar);
    }

    return permissionStringBuilder.toString();
  }

  private void extractArchive(Path file, Path targetDir, Function<InputStream, ArchiveInputStream<?>> unpacker) {

    LOG.info("Extracting TAR file {} to {}", file, targetDir);

    final List<PathLink> links = new ArrayList<>();
    try (InputStream is = Files.newInputStream(file);
        ArchiveInputStream<?> ais = unpacker.apply(is);
        IdeProgressBar pb = this.context.newProgressbarForExtracting(getFileSize(file))) {

      final Path root = targetDir.toAbsolutePath().normalize();

      ArchiveEntry entry = ais.getNextEntry();
      while (entry != null) {
        String entryName = entry.getName();
        Path entryPath = resolveRelativePathSecure(entryName, root);
        PathPermissions permissions = null;
        PathLinkType linkType = null;
        if (entry instanceof TarArchiveEntry tae) {
          if (tae.isSymbolicLink()) {
            linkType = PathLinkType.SYMBOLIC_LINK;
          } else if (tae.isLink()) {
            linkType = PathLinkType.HARD_LINK;
          }
          if (linkType == null) {
            permissions = PathPermissions.of(tae.getMode());
          } else {
            Path parent = entryPath.getParent();
            String sourcePathString = tae.getLinkName();
            Path source = parent.resolve(sourcePathString).normalize();
            source = resolveRelativePathSecure(source, root, sourcePathString);
            links.add(new PathLink(source, entryPath, linkType));
            mkdirs(parent);
          }
        }
        if (entry.isDirectory()) {
          mkdirs(entryPath);
        } else if (linkType == null) { // regular file
          mkdirs(entryPath.getParent());
          Files.copy(ais, entryPath, StandardCopyOption.REPLACE_EXISTING);
          // POSIX perms on non-Windows
          if (permissions != null) {
            setFilePermissions(entryPath, permissions, false);
          }
        }
        pb.stepBy(Math.max(0L, entry.getSize()));
        entry = ais.getNextEntry();
      }
      // post process links
      for (PathLink link : links) {
        link(link);
      }
    } catch (Exception e) {
      throw new IllegalStateException("Failed to extract " + file + " to " + targetDir, e);
    }
  }

  private Path resolveRelativePathSecure(String entryName, Path root) {
    // Handle ZIP entries with absolute paths (e.g. "/bin/java") by converting them to relative paths
    if (entryName != null && entryName.startsWith("/")) {
      entryName = entryName.substring(1);
    }

    Path entryPath = root.resolve(entryName).normalize();
    return resolveRelativePathSecure(entryPath, root, entryName);
  }

  private Path resolveRelativePathSecure(Path entryPath, Path root, String entryName) {

    if (!entryPath.startsWith(root)) {
      throw new IllegalStateException("Preventing path traversal attack from " + entryName + " to " + entryPath + " leaving " + root);
    }
    return entryPath;
  }

  @Override
  public void extractDmg(Path file, Path targetDir) {

    LOG.info("Extracting DMG file {} to {}", file, targetDir);
    assert this.context.getSystemInfo().isMac();

    Path mountPath = this.context.getIdeHome().resolve(IdeContext.FOLDER_UPDATES).resolve(IdeContext.FOLDER_VOLUME);
    mkdirs(mountPath);
    ProcessContext pc = this.context.newProcess();
    pc.executable("hdiutil");
    pc.addArgs("attach", "-quiet", "-nobrowse", "-mountpoint", mountPath, file);
    pc.run();
    Path appPath = findFirst(mountPath, p -> p.getFileName().toString().endsWith(".app"), false);
    if (appPath == null) {
      throw new IllegalStateException("Failed to unpack DMG as no MacOS *.app was found in file " + file);
    }

    copy(appPath, targetDir, FileCopyMode.COPY_TREE_OVERRIDE_TREE);
    pc.addArgs("detach", "-force", mountPath);
    pc.run();
  }

  @Override
  public void extractMsi(Path file, Path targetDir) {

    LOG.info("Extracting MSI file {} to {}", file, targetDir);
    this.context.newProcess().executable("msiexec").addArgs("/a", file, "/qn", "TARGETDIR=" + targetDir).run();
    // msiexec also creates a copy of the MSI
    Path msiCopy = targetDir.resolve(file.getFileName());
    delete(msiCopy);
  }

  @Override
  public void extractPkg(Path file, Path targetDir) {

    LOG.info("Extracting PKG file {} to {}", file, targetDir);
    assert this.context.getSystemInfo().isMac();
    Path tmpDirPkg = createTempDir("ide-pkg-");
    ProcessContext pc = this.context.newProcess();
    pc.executable("xar").addArgs("-C", tmpDirPkg, "-xf", file).run();
    Path contentPath = findFirst(tmpDirPkg, p -> p.getFileName().toString().equals("Payload"), true);
    extractPkgPayloadWithSystemTar(contentPath, targetDir);
    delete(tmpDirPkg);
  }

  private void extractPkgPayloadWithSystemTar(Path payload, Path targetDir) {

    mkdirs(targetDir);
    ProcessContext pc = this.context.newProcess();
    pc.executable("/usr/bin/tar");
    pc.addArgs("-xf", payload, "-C", targetDir);
    pc.run();
  }

  @Override
  public void compress(Path dir, OutputStream out, String path) {

    String extension = FilenameUtil.getExtension(path);
    TarCompression tarCompression = TarCompression.of(extension);
    if (tarCompression != null) {
      compressTar(dir, out, tarCompression);
    } else if (extension.equals("zip")) {
      compressZip(dir, out);
    } else {
      throw new IllegalArgumentException("Unsupported extension: " + extension);
    }
  }

  @Override
  public void compressTar(Path dir, OutputStream out, TarCompression tarCompression) {

    switch (tarCompression) {
      case null -> compressTar(dir, out);
      case NONE -> compressTar(dir, out);
      case GZ -> compressTarGz(dir, out);
      case BZIP2 -> compressTarBzip2(dir, out);
      default -> throw new IllegalArgumentException("Unsupported tar compression: " + tarCompression);
    }
  }

  @Override
  public void compressTarGz(Path dir, OutputStream out) {

    GzipParameters parameters = new GzipParameters();
    parameters.setModificationTime(0);
    try (GzipCompressorOutputStream gzOut = new GzipCompressorOutputStream(out, parameters)) {
      compressTarOrThrow(dir, gzOut);
    } catch (IOException e) {
      throw new IllegalStateException("Failed to compress directory " + dir + " to tar.gz file.", e);
    }
  }

  @Override
  public void compressTarBzip2(Path dir, OutputStream out) {

    try (BZip2CompressorOutputStream bzip2Out = new BZip2CompressorOutputStream(out)) {
      compressTarOrThrow(dir, bzip2Out);
    } catch (IOException e) {
      throw new IllegalStateException("Failed to compress directory " + dir + " to tar.bz2 file.", e);
    }
  }

  @Override
  public void compressTar(Path dir, OutputStream out) {

    try {
      compressTarOrThrow(dir, out);
    } catch (IOException e) {
      throw new IllegalStateException("Failed to compress directory " + dir + " to tar file.", e);
    }
  }

  private void compressTarOrThrow(Path dir, OutputStream out) throws IOException {

    try (TarArchiveOutputStream tarOut = new TarArchiveOutputStream(out)) {
      compressRecursive(dir, tarOut, "");
      tarOut.finish();
    }
  }

  @Override
  public void compressZip(Path dir, OutputStream out) {

    try (ZipArchiveOutputStream zipOut = new ZipArchiveOutputStream(out)) {
      compressRecursive(dir, zipOut, "");
      zipOut.finish();
    } catch (IOException e) {
      throw new IllegalStateException("Failed to compress directory " + dir + " to zip file.", e);
    }
  }

  private <E extends ArchiveEntry> void compressRecursive(Path path, ArchiveOutputStream<E> out, String relativePath) {

    try (Stream<Path> childStream = Files.list(path).sorted()) {
      Iterator<Path> iterator = childStream.iterator();
      while (iterator.hasNext()) {
        Path child = iterator.next();
        String relativeChildPath = relativePath + "/" + child.getFileName().toString();
        boolean isDirectory = Files.isDirectory(child);
        E archiveEntry = out.createArchiveEntry(child, relativeChildPath);
        FileTime none = FileTime.fromMillis(0);
        if (archiveEntry instanceof TarArchiveEntry tarEntry) {
          tarEntry.setCreationTime(none);
          tarEntry.setModTime(none);
          tarEntry.setLastAccessTime(none);
          tarEntry.setLastModifiedTime(none);
          tarEntry.setUserId(0);
          tarEntry.setUserName("user");
          tarEntry.setGroupId(0);
          tarEntry.setGroupName("group");
          PathPermissions filePermissions = getFilePermissions(child);
          tarEntry.setMode(filePermissions.toMode());
        } else if (archiveEntry instanceof ZipArchiveEntry zipEntry) {
          zipEntry.setCreationTime(none);
          zipEntry.setLastAccessTime(none);
          zipEntry.setLastModifiedTime(none);
          zipEntry.setTime(none);
        }
        out.putArchiveEntry(archiveEntry);
        if (!isDirectory) {
          try (InputStream in = Files.newInputStream(child)) {
            IOUtils.copy(in, out);
          }
        }
        out.closeArchiveEntry();
        if (isDirectory) {
          compressRecursive(child, out, relativeChildPath);
        }
      }
    } catch (IOException e) {
      throw new IllegalStateException("Failed to compress " + path, e);
    }
  }

  @Override
  public void delete(Path path) {

    if (!Files.exists(path, LinkOption.NOFOLLOW_LINKS)) {
      LOG.trace("Deleting {} skipped as the path does not exist.", path);
      return;
    }
    LOG.debug("Deleting {} ...", path);
    try {
      if (isLink(path)) {
        deletePath(path);
      } else {
        deleteRecursive(path);
      }
    } catch (IOException e) {
      throw new IllegalStateException("Failed to delete " + path, e);
    }
  }

  private void deleteRecursive(Path path) throws IOException {

    if (Files.isSymbolicLink(path) || isJunction(path)) {
      LOG.trace("Deleting link {} ...", path);
      Files.delete(path);
      return;
    }
    if (Files.isDirectory(path, LinkOption.NOFOLLOW_LINKS)) {
      try (Stream<Path> childStream = Files.list(path)) {
        Iterator<Path> iterator = childStream.iterator();
        while (iterator.hasNext()) {
          Path child = iterator.next();
          deleteRecursive(child);
        }
      }
    }
    deletePath(path);
  }

  private boolean isLink(Path path) {

    return Files.isSymbolicLink(path) || isJunction(path);
  }

  private void deletePath(Path path) throws IOException {

    LOG.trace("Deleting {} ...", path);
    boolean isSetWritable = setWritable(path, true);
    if (!isSetWritable) {
      LOG.debug("Couldn't give write access to file: {}", path);
    }
    Files.delete(path);
  }

  @Override
  public Path findFirst(Path dir, Predicate<Path> filter, boolean recursive) {

    try {
      if (!Files.isDirectory(dir)) {
        return null;
      }
      return findFirstRecursive(dir, filter, recursive);
    } catch (IOException e) {
      throw new IllegalStateException("Failed to search for file in " + dir, e);
    }
  }

  private Path findFirstRecursive(Path dir, Predicate<Path> filter, boolean recursive) throws IOException {

    List<Path> folders = null;
    try (Stream<Path> childStream = Files.list(dir)) {
      Iterator<Path> iterator = childStream.iterator();
      while (iterator.hasNext()) {
        Path child = iterator.next();
        if (filter.test(child)) {
          return child;
        } else if (recursive && Files.isDirectory(child)) {
          if (folders == null) {
            folders = new ArrayList<>();
          }
          folders.add(child);
        }
      }
    }
    if (folders != null) {
      for (Path child : folders) {
        Path match = findFirstRecursive(child, filter, recursive);
        if (match != null) {
          return match;
        }
      }
    }
    return null;
  }

  @Override
  public Path findAncestor(Path path, Path baseDir, int subfolderCount) {

    if ((path == null) || (baseDir == null)) {
      LOG.debug("Path should not be null for findAncestor.");
      return null;
    }
    if (subfolderCount <= 0) {
      throw new IllegalArgumentException("Subfolder count: " + subfolderCount);
    }
    // 1. option relativize
    // 2. recursive getParent
    // 3. loop getParent???
    // 4. getName + getNameCount
    path = path.toAbsolutePath().normalize();
    baseDir = baseDir.toAbsolutePath().normalize();
    int directoryNameCount = path.getNameCount();
    int baseDirNameCount = baseDir.getNameCount();
    int delta = directoryNameCount - baseDirNameCount - subfolderCount;
    if (delta < 0) {
      return null;
    }
    // ensure directory is a sub-folder of baseDir
    for (int i = 0; i < baseDirNameCount; i++) {
      if (!path.getName(i).toString().equals(baseDir.getName(i).toString())) {
        return null;
      }
    }
    Path result = path;
    while (delta > 0) {
      result = result.getParent();
      delta--;
    }
    return result;
  }

  @Override
  public List<Path> listChildrenMapped(Path dir, Function<Path, Path> filter) {

    if (!Files.isDirectory(dir)) {
      return List.of();
    }
    List<Path> children = new ArrayList<>();
    try (Stream<Path> childStream = Files.list(dir)) {
      Iterator<Path> iterator = childStream.iterator();
      while (iterator.hasNext()) {
        Path child = iterator.next();
        Path filteredChild = filter.apply(child);
        if (filteredChild != null) {
          if (filteredChild == child) {
            LOG.trace("Accepted file {}", child);
          } else {
            LOG.trace("Accepted file {} and mapped to {}", child, filteredChild);
          }
          children.add(filteredChild);
        } else {
          LOG.trace("Ignoring file {} according to filter", child);
        }
      }
    } catch (IOException e) {
      throw new IllegalStateException("Failed to find children of directory " + dir, e);
    }
    return children;
  }

  @Override
  public boolean isEmptyDir(Path dir) {

    return listChildren(dir, f -> true).isEmpty();
  }

  @Override
  public boolean isNonEmptyFile(Path file) {

    if (Files.isRegularFile(file)) {
      return (getFileSize(file) > 0);
    }
    return false;
  }

  private long getFileSize(Path file) {

    try {
      return Files.size(file);
    } catch (IOException e) {
      LOG.warn("Failed to determine size of file {}: {}", file, e.toString(), e);
      return 0;
    }
  }


  @Override
  public Path findExistingFile(String fileName, List<Path> searchDirs) {

    for (Path dir : searchDirs) {
      Path filePath = dir.resolve(fileName);
      try {
        if (Files.exists(filePath)) {
          return filePath;
        }
      } catch (Exception e) {
        throw new IllegalStateException("Unexpected error while checking existence of file " + filePath + " .", e);
      }
    }
    return null;
  }

  @Override
  public boolean setWritable(Path file, boolean writable) {

    if (!Files.exists(file)) {
      return false;
    }
    try {
      // POSIX
      PosixFileAttributeView posix = Files.getFileAttributeView(file, PosixFileAttributeView.class);
      if (posix != null) {
        Set<PosixFilePermission> permissions = new HashSet<>(posix.readAttributes().permissions());
        boolean changed;
        if (writable) {
          changed = permissions.add(PosixFilePermission.OWNER_WRITE);
        } else {
          changed = permissions.remove(PosixFilePermission.OWNER_WRITE);
        }
        if (changed) {
          posix.setPermissions(permissions);
        }
        return true;
      }

      // Windows
      DosFileAttributeView dos = Files.getFileAttributeView(file, DosFileAttributeView.class);
      if (dos != null) {
        dos.setReadOnly(!writable);
        return true;
      }

      LOG.debug("Failed to set writing permission for file {}", file);
      return false;

    } catch (IOException e) {
      LOG.debug("Error occurred when trying to set writing permission for file {}: {}", file, e.toString(), e);
      return false;
    }
  }

  @Override
  public void makeExecutable(Path path, boolean confirm) {

    if (Files.exists(path)) {
      if (skipPermissionsIfWindows(path)) {
        return;
      }
      PathPermissions existingPermissions = getFilePermissions(path);
      PathPermissions executablePermissions = existingPermissions.makeExecutable();
      boolean update = (executablePermissions != existingPermissions);
      if (update) {
        if (confirm) {
          boolean yesContinue = this.context.question(
              "We want to execute {} but this command seems to lack executable permissions!\n"
                  + "Most probably the tool vendor did forget to add x-flags in the binary release package.\n"
                  + "Before running the command, we suggest to set executable permissions to the file:\n"
                  + "{}\n"
                  + "For security reasons we ask for your confirmation so please check this request.\n"
                  + "Changing permissions from {} to {}.\n"
                  + "Do you confirm to make the command executable before running it?", path.getFileName(), path, existingPermissions, executablePermissions);
          if (!yesContinue) {
            return;
          }
        }
        setFilePermissions(path, executablePermissions, false);
      } else {
        LOG.trace("Executable flags already present so no need to set them for file {}", path);
      }
    } else {
      LOG.warn("Cannot set executable flag on file that does not exist: {}", path);
    }
  }

  @Override
  public PathPermissions getFilePermissions(Path path) {

    PathPermissions pathPermissions;
    String info = "";
    if (SystemInfoImpl.INSTANCE.isWindows()) {
      info = "mocked-";
      if (Files.isDirectory(path)) {
        pathPermissions = PathPermissions.MODE_RWX_RX_RX;
      } else {
        Path parent = path.getParent();
        if ((parent != null) && (parent.getFileName().toString().equals("bin"))) {
          pathPermissions = PathPermissions.MODE_RWX_RX_RX;
        } else {
          pathPermissions = PathPermissions.MODE_RW_R_R;
        }
      }
    } else {
      Set<PosixFilePermission> permissions;
      try {
        // Read the current file permissions
        permissions = Files.getPosixFilePermissions(path);
      } catch (IOException e) {
        throw new RuntimeException("Failed to get permissions for " + path, e);
      }
      pathPermissions = PathPermissions.of(permissions);
    }
    LOG.trace("Read {}permissions of {} as {}.", info, path, pathPermissions);
    return pathPermissions;
  }

  @Override
  public void setFilePermissions(Path path, PathPermissions permissions, boolean logErrorAndContinue) {

    if (skipPermissionsIfWindows(path)) {
      return;
    }
    try {
      LOG.debug("Setting permissions for {} to {}", path, permissions);
      // Set the new permissions
      Files.setPosixFilePermissions(path, permissions.toPosix());
    } catch (IOException e) {
      String message = "Failed to set permissions to " + permissions + " for path " + path;
      if (logErrorAndContinue) {
        LOG.warn(message, e);
      } else {
        throw new RuntimeException(message, e);
      }
    }
  }

  private boolean skipPermissionsIfWindows(Path path) {

    if (SystemInfoImpl.INSTANCE.isWindows()) {
      LOG.trace("Windows does not have file permissions hence omitting for {}", path);
      return true;
    }
    return false;
  }

  @Override
  public void touch(Path file) {

    if (Files.exists(file)) {
      try {
        Files.setLastModifiedTime(file, FileTime.fromMillis(System.currentTimeMillis()));
      } catch (IOException e) {
        throw new IllegalStateException("Could not update modification-time of " + file, e);
      }
    } else {
      try {
        Files.createFile(file);
      } catch (IOException e) {
        throw new IllegalStateException("Could not create empty file " + file, e);
      }
    }
  }

  @Override
  public String readFileContent(Path file) {

    LOG.trace("Reading content of file from {}", file);
    if (!Files.exists((file))) {
      LOG.debug("File {} does not exist", file);
      return null;
    }
    try {
      String content = Files.readString(file);
      LOG.trace("Completed reading {} character(s) from file {}", content.length(), file);
      return content;
    } catch (IOException e) {
      throw new IllegalStateException("Failed to read file " + file, e);
    }
  }

  @Override
  public void writeFileContent(String content, Path file, boolean createParentDir) {

    if (createParentDir) {
      mkdirs(file.getParent());
    }
    if (content == null) {
      content = "";
    }
    LOG.trace("Writing content with {} character(s) to file {}", content.length(), file);
    if (Files.exists(file)) {
      LOG.info("Overriding content of file {}", file);
    }
    try {
      Files.writeString(file, content);
      LOG.trace("Wrote content to file {}", file);
    } catch (IOException e) {
      throw new RuntimeException("Failed to write file " + file, e);
    }
  }

  @Override
  public List<String> readFileLines(Path file) {

    LOG.trace("Reading lines of file from {}", file);
    if (!Files.exists(file)) {
      LOG.warn("File {} does not exist", file);
      return null;
    }
    try {
      List<String> content = Files.readAllLines(file);
      LOG.trace("Completed reading {} lines from file {}", content.size(), file);
      return content;
    } catch (IOException e) {
      throw new IllegalStateException("Failed to read file " + file, e);
    }
  }

  @Override
  public void writeFileLines(List<String> content, Path file, boolean createParentDir) {

    if (createParentDir) {
      mkdirs(file.getParent());
    }
    if (content == null) {
      content = List.of();
    }
    LOG.trace("Writing content with {} lines to file {}", content.size(), file);
    if (Files.exists(file)) {
      LOG.debug("Overriding content of file {}", file);
    }
    try {
      Files.write(file, content);
      LOG.trace("Wrote lines to file {}", file);
    } catch (IOException e) {
      throw new RuntimeException("Failed to write file " + file, e);
    }
  }

  @Override
  public void readProperties(Path file, Properties properties) {

    try (Reader reader = Files.newBufferedReader(file)) {
      properties.load(reader);
      LOG.debug("Successfully loaded {} properties from {}", properties.size(), file);
    } catch (IOException e) {
      throw new IllegalStateException("Failed to read properties file: " + file, e);
    }
  }

  @Override
  public void writeProperties(Properties properties, Path file, boolean createParentDir) {

    if (createParentDir) {
      mkdirs(file.getParent());
    }
    try (Writer writer = Files.newBufferedWriter(file)) {
      properties.store(writer, null); // do not get confused - Java still writes a date/time header that cannot be omitted
      LOG.debug("Successfully saved {} properties to {}", properties.size(), file);
    } catch (IOException e) {
      throw new IllegalStateException("Failed to save properties file during tests.", e);
    }
  }

  @Override
  public void readIniFile(Path file, IniFile iniFile) {

    if (!Files.exists(file)) {
      LOG.debug("INI file {} does not exist.", iniFile);
      return;
    }
    List<String> iniLines = readFileLines(file);
    IniSection currentIniSection = iniFile.getInitialSection();
    for (String line : iniLines) {
      if (line.trim().startsWith("[")) {
        currentIniSection = iniFile.getOrCreateSection(line);
      } else if (line.isBlank() || IniComment.COMMENT_SYMBOLS.contains(line.trim().charAt(0))) {
        currentIniSection.addComment(line);
      } else {
        int index = line.indexOf('=');
        if (index > 0) {
          currentIniSection.setPropertyLine(line);
        }
      }
    }
  }

  @Override
  public void writeIniFile(IniFile iniFile, Path file, boolean createParentDir) {

    String iniString = iniFile.toString();
    writeFileContent(iniString, file, createParentDir);
  }

  @Override
  public Duration getFileAge(Path path) {

    if (Files.exists(path)) {
      try {
        long currentTime = System.currentTimeMillis();
        long fileModifiedTime = Files.getLastModifiedTime(path).toMillis();
        return Duration.ofMillis(currentTime - fileModifiedTime);
      } catch (IOException e) {
        LOG.warn("Could not get modification-time of {}.", path, e);
      }
    } else {
      LOG.debug("Path {} is missing - skipping modification-time and file age check.", path);
    }
    return null;
  }

  @Override
  public boolean isFileAgeRecent(Path path, Duration cacheDuration) {

    Duration age = getFileAge(path);
    if (age == null) {
      return false;
    }
    LOG.debug("The path {} was last updated {} ago and caching duration is {}.", path, age, cacheDuration);
    return (age.toMillis() <= cacheDuration.toMillis());
  }
}

devonfw / IDEasy / 26876438778

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous