14645240231

Committed 24 Apr 2025 03:15PM UTC coverage: 67.429% (-0.02%) from 67.446%

Build # 14645240231

Build Type

push

github

Committed by

web-flow

Commit Message

#1231: Prevent automatic IDEasy uninstall (#1248)

Co-authored-by: Jörg Hohwiller <hohwille@users.noreply.github.com>

Run Details

3076 of 4966 branches covered (61.94%)

Branch coverage included in aggregate %.

7915 of 11334 relevant lines covered (69.83%)

3.05 hits per line

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

86.78

cli/src/main/java/com/devonfw/tools/ide/tool/LocalToolCommandlet.java

package com.devonfw.tools.ide.tool;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.Collection;
import java.util.Set;

import com.devonfw.tools.ide.common.Tag;
import com.devonfw.tools.ide.context.IdeContext;
import com.devonfw.tools.ide.environment.EnvironmentVariables;
import com.devonfw.tools.ide.io.FileAccess;
import com.devonfw.tools.ide.io.FileCopyMode;
import com.devonfw.tools.ide.process.EnvironmentContext;
import com.devonfw.tools.ide.process.ProcessContext;
import com.devonfw.tools.ide.step.Step;
import com.devonfw.tools.ide.tool.repository.ToolRepository;
import com.devonfw.tools.ide.url.model.file.json.ToolDependency;
import com.devonfw.tools.ide.version.GenericVersionRange;
import com.devonfw.tools.ide.version.VersionIdentifier;
import com.devonfw.tools.ide.version.VersionRange;

/**
 * {@link ToolCommandlet} that is installed locally into the IDEasy.
 */
public abstract class LocalToolCommandlet extends ToolCommandlet {

  /**
   * The constructor.
   *
   * @param context the {@link IdeContext}.
   * @param tool the {@link #getName() tool name}.
   * @param tags the {@link #getTags() tags} classifying the tool. Should be created via {@link Set#of(Object) Set.of} method.
   */
  public LocalToolCommandlet(IdeContext context, String tool, Set<Tag> tags) {

    super(context, tool, tags);
  }

  /**
   * @return the {@link Path} where the tool is located (installed).
   */
  public Path getToolPath() {

    return this.context.getSoftwarePath().resolve(getName());
  }

  /**
   * @return the {@link Path} where the executables of the tool can be found. Typically a "bin" folder inside {@link #getToolPath() tool path}.
   */
  public Path getToolBinPath() {

    Path toolPath = getToolPath();
    Path binPath = this.context.getFileAccess().findFirst(toolPath, path -> path.getFileName().toString().equals("bin"), false);
    if ((binPath != null) && Files.isDirectory(binPath)) {
      return binPath;
    }
    return toolPath;
  }

  /**
   * @deprecated will be removed once all "dependencies.json" are created in ide-urls.
   */
  @Deprecated
  protected void installDependencies() {

  }

  @Override
  public boolean install(boolean silent, ProcessContext processContext) {

    installDependencies();
    VersionIdentifier configuredVersion = getConfiguredVersion();
    // get installed version before installInRepo actually may install the software
    VersionIdentifier installedVersion = getInstalledVersion();
    Step step = this.context.newStep(silent, "Install " + this.tool, configuredVersion);
    try {
      // install configured version of our tool in the software repository if not already installed
      ToolInstallation installation = installTool(configuredVersion, processContext);

      // check if we already have this version installed (linked) locally in IDE_HOME/software
      VersionIdentifier resolvedVersion = installation.resolvedVersion();
      if ((resolvedVersion.equals(installedVersion) && !installation.newInstallation())
          || (configuredVersion.matches(installedVersion) && context.isSkipUpdatesMode())) {
        return toolAlreadyInstalled(silent, installedVersion, step, processContext);
      }
      if (!isIgnoreSoftwareRepo()) {
        // we need to link the version or update the link.
        Path toolPath = getToolPath();
        FileAccess fileAccess = this.context.getFileAccess();
        if (Files.exists(toolPath, LinkOption.NOFOLLOW_LINKS)) {
          fileAccess.backup(toolPath);
        }
        fileAccess.mkdirs(toolPath.getParent());
        fileAccess.symlink(installation.linkDir(), toolPath);
      }
      this.context.getPath().setPath(this.tool, installation.binDir());
      postInstall(true, processContext);
      if (installedVersion == null) {
        step.success("Successfully installed {} in version {}", this.tool, resolvedVersion);
      } else {
        step.success("Successfully installed {} in version {} replacing previous version {}", this.tool, resolvedVersion, installedVersion);
      }
      return true;
    } catch (RuntimeException e) {
      step.error(e, true);
      throw e;
    } finally {
      step.close();
    }

  }

  /**
   * This method is called after a tool was requested to be installed or updated.
   *
   * @param newlyInstalled {@code true} if the tool was installed or updated (at least link to software folder was created/updated), {@code false} otherwise
   *     (configured version was already installed and nothing changed).
   * @param pc the {@link ProcessContext} to use.
   */
  protected void postInstall(boolean newlyInstalled, ProcessContext pc) {

    if (newlyInstalled) {
      postInstall();
    }
  }

  /**
   * This method is called after the tool has been newly installed or updated to a new version.
   */
  protected void postInstall() {

    // nothing to do by default
  }

  private boolean toolAlreadyInstalled(boolean silent, VersionIdentifier installedVersion, Step step, ProcessContext pc) {
    if (!silent) {
      this.context.info("Version {} of tool {} is already installed", installedVersion, getToolWithEdition());
    }
    postInstall(false, pc);
    step.success();
    return false;
  }

  /**
   * Determines whether this tool should be installed directly in the software folder or in the software repository.
   *
   * @return {@code true} if the tool should be installed directly in the software folder, ignoring the central software repository; {@code false} if the tool
   *     should be installed in the central software repository (default behavior).
   */
  protected boolean isIgnoreSoftwareRepo() {

    return false;
  }

  /**
   * Performs the installation of the {@link #getName() tool} together with the environment context, managed by this
   * {@link com.devonfw.tools.ide.commandlet.Commandlet}.
   *
   * @param version the {@link GenericVersionRange} requested to be installed.
   * @param processContext the {@link ProcessContext} used to
   *     {@link #setEnvironment(EnvironmentContext, ToolInstallation, boolean) configure environment variables}.
   * @return the {@link ToolInstallation} matching the given {@code version}.
   */
  public ToolInstallation installTool(GenericVersionRange version, ProcessContext processContext) {

    return installTool(version, processContext, getConfiguredEdition());
  }

  /**
   * Performs the installation of the {@link #getName() tool} together with the environment context  managed by this
   * {@link com.devonfw.tools.ide.commandlet.Commandlet}.
   *
   * @param version the {@link GenericVersionRange} requested to be installed.
   * @param processContext the {@link ProcessContext} used to
   *     {@link #setEnvironment(EnvironmentContext, ToolInstallation, boolean) configure environment variables}.
   * @param edition the specific {@link #getConfiguredEdition() edition} to install.
   * @return the {@link ToolInstallation} matching the given {@code version}.
   */
  public ToolInstallation installTool(GenericVersionRange version, ProcessContext processContext, String edition) {

    // if version is a VersionRange, we are not called from install() but directly from installAsDependency() due to a version conflict of a dependency
    boolean extraInstallation = (version instanceof VersionRange);
    ToolRepository toolRepository = getToolRepository();
    VersionIdentifier resolvedVersion = toolRepository.resolveVersion(this.tool, edition, version, this);
    installToolDependencies(resolvedVersion, edition, processContext);

    Path installationPath;
    boolean ignoreSoftwareRepo = isIgnoreSoftwareRepo();
    if (ignoreSoftwareRepo) {
      installationPath = getToolPath();
    } else {
      Path softwareRepoPath = this.context.getSoftwareRepositoryPath().resolve(toolRepository.getId()).resolve(this.tool).resolve(edition);
      installationPath = softwareRepoPath.resolve(resolvedVersion.toString());
    }
    Path toolVersionFile = installationPath.resolve(IdeContext.FILE_SOFTWARE_VERSION);
    FileAccess fileAccess = this.context.getFileAccess();
    if (Files.isDirectory(installationPath)) {
      if (Files.exists(toolVersionFile)) {
        if (!ignoreSoftwareRepo || resolvedVersion.equals(getInstalledVersion())) {
          this.context.debug("Version {} of tool {} is already installed at {}", resolvedVersion, getToolWithEdition(this.tool, edition), installationPath);
          return createToolInstallation(installationPath, resolvedVersion, toolVersionFile, false, processContext, extraInstallation);
        }
      } else {
        // Makes sure that IDEasy will not delete itself
        if (this.tool.equals(IdeasyCommandlet.TOOL_NAME)) {
          this.context.warning("Your IDEasy installation is missing the version file at {}", toolVersionFile);
        } else {
          this.context.warning("Deleting corrupted installation at {}", installationPath);
          fileAccess.delete(installationPath);
        }
      }
    }
    Path downloadedToolFile = downloadTool(edition, toolRepository, resolvedVersion);
    boolean extract = isExtract();
    if (!extract) {
      this.context.trace("Extraction is disabled for '{}' hence just moving the downloaded file {}.", this.tool, downloadedToolFile);
    }
    if (Files.exists(installationPath)) {
      fileAccess.backup(installationPath);
    }
    fileAccess.mkdirs(installationPath.getParent());
    fileAccess.extract(downloadedToolFile, installationPath, this::postExtract, extract);
    try {
      Files.writeString(toolVersionFile, resolvedVersion.toString(), StandardOpenOption.CREATE_NEW);
    } catch (IOException e) {
      throw new IllegalStateException("Failed to write version file " + toolVersionFile, e);
    }
    this.context.debug("Installed {} in version {} at {}", this.tool, resolvedVersion, installationPath);
    return createToolInstallation(installationPath, resolvedVersion, toolVersionFile, true, processContext, extraInstallation);
  }

  /**
   * @param edition the {@link #getConfiguredEdition() tool edition} to download.
   * @param toolRepository the {@link ToolRepository} to use.
   * @param resolvedVersion the resolved {@link VersionIdentifier version} to download.
   * @return the {@link Path} to the downloaded release file.
   */
  protected Path downloadTool(String edition, ToolRepository toolRepository, VersionIdentifier resolvedVersion) {
    return toolRepository.download(this.tool, edition, resolvedVersion, this);
  }

  /**
   * Install this tool as dependency of another tool.
   *
   * @param version the required {@link VersionRange}. See {@link ToolDependency#versionRange()}.
   * @param processContext the {@link ProcessContext}.
   * @return {@code true} if the tool was newly installed, {@code false} otherwise (installation was already present).
   */
  public boolean installAsDependency(VersionRange version, ProcessContext processContext) {

    VersionIdentifier configuredVersion = getConfiguredVersion();
    if (version.contains(configuredVersion)) {
      // prefer configured version if contained in version range
      return install(false, processContext);
    } else {
      if (isIgnoreSoftwareRepo()) {
        throw new IllegalStateException(
            "Cannot satisfy dependency to " + this.tool + " in version " + version + " since it is conflicting with configured version " + configuredVersion
                + " and this tool does not support the software repository.");
      }
      this.context.info(
          "Configured version of tool {} is {} but does not match version to install {} - need to use different version from software repository.",
          this.tool, configuredVersion, version);
    }
    ToolInstallation toolInstallation = installTool(version, processContext);
    return toolInstallation.newInstallation();
  }

  private void installToolDependencies(VersionIdentifier version, String edition, ProcessContext processContext) {
    Collection<ToolDependency> dependencies = getToolRepository().findDependencies(this.tool, edition, version);
    String toolWithEdition = getToolWithEdition(this.tool, edition);
    int size = dependencies.size();
    this.context.debug("Tool {} has {} other tool(s) as dependency", toolWithEdition, size);
    for (ToolDependency dependency : dependencies) {
      this.context.trace("Ensuring dependency {} for tool {}", dependency.tool(), toolWithEdition);
      LocalToolCommandlet dependencyTool = this.context.getCommandletManager().getRequiredLocalToolCommandlet(dependency.tool());
      dependencyTool.installAsDependency(dependency.versionRange(), processContext);
    }
  }

  /**
   * Post-extraction hook that can be overridden to add custom processing after unpacking and before moving to the final destination folder.
   *
   * @param extractedDir the {@link Path} to the folder with the unpacked tool.
   */
  protected void postExtract(Path extractedDir) {

  }

  @Override
  public VersionIdentifier getInstalledVersion() {

    return getInstalledVersion(this.context.getSoftwarePath().resolve(getName()));
  }

  /**
   * @param toolPath the installation {@link Path} where to find the version file.
   * @return the currently installed {@link VersionIdentifier version} of this tool or {@code null} if not installed.
   */
  protected VersionIdentifier getInstalledVersion(Path toolPath) {

    if (!Files.isDirectory(toolPath)) {
      this.context.debug("Tool {} not installed in {}", getName(), toolPath);
      return null;
    }
    Path toolVersionFile = toolPath.resolve(IdeContext.FILE_SOFTWARE_VERSION);
    if (!Files.exists(toolVersionFile)) {
      Path legacyToolVersionFile = toolPath.resolve(IdeContext.FILE_LEGACY_SOFTWARE_VERSION);
      if (Files.exists(legacyToolVersionFile)) {
        toolVersionFile = legacyToolVersionFile;
      } else {
        this.context.warning("Tool {} is missing version file in {}", getName(), toolVersionFile);
        return null;
      }
    }
    String version = this.context.getFileAccess().readFileContent(toolVersionFile).trim();
    return VersionIdentifier.of(version);
  }

  @Override
  public String getInstalledEdition() {

    if (this.context.getSoftwarePath() == null) {
      return "";
    }
    return getInstalledEdition(this.context.getSoftwarePath().resolve(this.tool));
  }

  /**
   * @param toolPath the installation {@link Path} where to find currently installed tool. The name of the parent directory of the real path corresponding
   *     to the passed {@link Path path} must be the name of the edition.
   * @return the installed edition of this tool or {@code null} if not installed.
   */
  private String getInstalledEdition(Path toolPath) {

    if (!Files.isDirectory(toolPath)) {
      this.context.debug("Tool {} not installed in {}", this.tool, toolPath);
      return null;
    }
    Path realPath = this.context.getFileAccess().toRealPath(toolPath);
    // if the realPath changed, a link has been resolved
    if (realPath.equals(toolPath)) {
      if (!isIgnoreSoftwareRepo()) {
        this.context.warning("Tool {} is not installed via software repository (maybe from devonfw-ide). Please consider reinstalling it.", this.tool);
      }
      // I do not see any reliable way how we could determine the edition of a tool that does not use software repo or that was installed by devonfw-ide
      return getConfiguredEdition();
    }
    Path toolRepoFolder = context.getSoftwareRepositoryPath().resolve(ToolRepository.ID_DEFAULT).resolve(this.tool);
    String edition = getEdition(toolRepoFolder, realPath);
    if (!getToolRepository().getSortedEditions(this.tool).contains(edition)) {
      this.context.warning("Undefined edition {} of tool {}", edition, this.tool);
    }
    return edition;
  }

  private String getEdition(Path toolRepoFolder, Path toolInstallFolder) {

    int toolRepoNameCount = toolRepoFolder.getNameCount();
    int toolInstallNameCount = toolInstallFolder.getNameCount();
    if (toolRepoNameCount < toolInstallNameCount) {
      // ensure toolInstallFolder starts with $IDE_ROOT/_ide/software/default/«tool»
      for (int i = 0; i < toolRepoNameCount; i++) {
        if (!toolRepoFolder.getName(i).toString().equals(toolInstallFolder.getName(i).toString())) {
          return null;
        }
      }
      return toolInstallFolder.getName(toolRepoNameCount).toString();
    }
    return null;
  }

  @Override
  public void uninstall() {

    try {
      Path softwarePath = getToolPath();
      if (Files.exists(softwarePath)) {
        try {
          this.context.getFileAccess().delete(softwarePath);
          this.context.success("Successfully uninstalled " + this.tool);
        } catch (Exception e) {
          this.context.error("Couldn't uninstall " + this.tool);
        }
      } else {
        this.context.warning("An installed version of " + this.tool + " does not exist");
      }
    } catch (Exception e) {
      this.context.error(e.getMessage());
    }
  }

  private ToolInstallation createToolInstallation(Path rootDir, VersionIdentifier resolvedVersion, Path toolVersionFile,
      boolean newInstallation, EnvironmentContext environmentContext, boolean extraInstallation) {

    Path linkDir = getMacOsHelper().findLinkDir(rootDir, getBinaryName());
    Path binDir = linkDir;
    Path binFolder = binDir.resolve(IdeContext.FOLDER_BIN);
    if (Files.isDirectory(binFolder)) {
      binDir = binFolder;
    }
    if (linkDir != rootDir) {
      assert (!linkDir.equals(rootDir));
      this.context.getFileAccess().copy(toolVersionFile, linkDir, FileCopyMode.COPY_FILE_OVERRIDE);
    }
    ToolInstallation toolInstallation = new ToolInstallation(rootDir, linkDir, binDir, resolvedVersion, newInstallation);
    setEnvironment(environmentContext, toolInstallation, extraInstallation);
    return toolInstallation;
  }

  /**
   * Method to set environment variables for the process context.
   *
   * @param environmentContext the {@link EnvironmentContext} where to {@link EnvironmentContext#withEnvVar(String, String) set environment variables} for
   *     this tool.
   * @param toolInstallation the {@link ToolInstallation}.
   * @param extraInstallation {@code true} if the {@link ToolInstallation} is an additional installation to the
   *     {@link #getConfiguredVersion() configured version} due to a conflicting version of a {@link ToolDependency}, {@code false} otherwise.
   */
  public void setEnvironment(EnvironmentContext environmentContext, ToolInstallation toolInstallation, boolean extraInstallation) {

    String pathVariable = EnvironmentVariables.getToolVariablePrefix(this.tool) + "_HOME";
    environmentContext.withEnvVar(pathVariable, toolInstallation.linkDir().toString());
    if (extraInstallation) {
      environmentContext.withPathEntry(toolInstallation.binDir());
    }
  }


}

1	package com.devonfw.tools.ide.tool;
2
3	import java.io.IOException;
4	import java.nio.file.Files;
5	import java.nio.file.LinkOption;
6	import java.nio.file.Path;
7	import java.nio.file.StandardOpenOption;
8	import java.util.Collection;
9	import java.util.Set;
10
11	import com.devonfw.tools.ide.common.Tag;
12	import com.devonfw.tools.ide.context.IdeContext;
13	import com.devonfw.tools.ide.environment.EnvironmentVariables;
14	import com.devonfw.tools.ide.io.FileAccess;
15	import com.devonfw.tools.ide.io.FileCopyMode;
16	import com.devonfw.tools.ide.process.EnvironmentContext;
17	import com.devonfw.tools.ide.process.ProcessContext;
18	import com.devonfw.tools.ide.step.Step;
19	import com.devonfw.tools.ide.tool.repository.ToolRepository;
20	import com.devonfw.tools.ide.url.model.file.json.ToolDependency;
21	import com.devonfw.tools.ide.version.GenericVersionRange;
22	import com.devonfw.tools.ide.version.VersionIdentifier;
23	import com.devonfw.tools.ide.version.VersionRange;
24
25	/**
26	* {@link ToolCommandlet} that is installed locally into the IDEasy.
27	*/
28	public abstract class LocalToolCommandlet extends ToolCommandlet {	1✔
29
30	/**
31	* The constructor.
32	*
33	* @param context the {@link IdeContext}.
34	* @param tool the {@link #getName() tool name}.
35	* @param tags the {@link #getTags() tags} classifying the tool. Should be created via {@link Set#of(Object) Set.of} method.
36	*/
37	public LocalToolCommandlet(IdeContext context, String tool, Set<Tag> tags) {
38
39	super(context, tool, tags);	5✔
40	}	1✔
41
42	/**
43	* @return the {@link Path} where the tool is located (installed).
44	*/
45	public Path getToolPath() {
46
47	return this.context.getSoftwarePath().resolve(getName());	7✔
48	}
49
50	/**
51	* @return the {@link Path} where the executables of the tool can be found. Typically a "bin" folder inside {@link #getToolPath() tool path}.
52	*/
53	public Path getToolBinPath() {
54
55	Path toolPath = getToolPath();	3✔
56	Path binPath = this.context.getFileAccess().findFirst(toolPath, path -> path.getFileName().toString().equals("bin"), false);	14✔
57	if ((binPath != null) && Files.isDirectory(binPath)) {	7!
58	return binPath;	2✔
59	}
60	return toolPath;	2✔
61	}
62
63	/**
64	* @deprecated will be removed once all "dependencies.json" are created in ide-urls.
65	*/
66	@Deprecated
67	protected void installDependencies() {
68
69	}	1✔
70
71	@Override
72	public boolean install(boolean silent, ProcessContext processContext) {
73
74	installDependencies();	2✔
75	VersionIdentifier configuredVersion = getConfiguredVersion();	3✔
76	// get installed version before installInRepo actually may install the software
77	VersionIdentifier installedVersion = getInstalledVersion();	3✔
78	Step step = this.context.newStep(silent, "Install " + this.tool, configuredVersion);	14✔
79	try {
80	// install configured version of our tool in the software repository if not already installed
81	ToolInstallation installation = installTool(configuredVersion, processContext);	5✔
82
83	// check if we already have this version installed (linked) locally in IDE_HOME/software
84	VersionIdentifier resolvedVersion = installation.resolvedVersion();	3✔
85	if ((resolvedVersion.equals(installedVersion) && !installation.newInstallation())	9✔
86	\|\| (configuredVersion.matches(installedVersion) && context.isSkipUpdatesMode())) {	6!
87	return toolAlreadyInstalled(silent, installedVersion, step, processContext);	9✔
88	}
89	if (!isIgnoreSoftwareRepo()) {	3✔
90	// we need to link the version or update the link.
91	Path toolPath = getToolPath();	3✔
92	FileAccess fileAccess = this.context.getFileAccess();	4✔
93	if (Files.exists(toolPath, LinkOption.NOFOLLOW_LINKS)) {	9✔
94	fileAccess.backup(toolPath);	4✔
95	}
96	fileAccess.mkdirs(toolPath.getParent());	4✔
97	fileAccess.symlink(installation.linkDir(), toolPath);	5✔
98	}
99	this.context.getPath().setPath(this.tool, installation.binDir());	8✔
100	postInstall(true, processContext);	4✔
101	if (installedVersion == null) {	2✔
102	step.success("Successfully installed {} in version {}", this.tool, resolvedVersion);	15✔
103	} else {
104	step.success("Successfully installed {} in version {} replacing previous version {}", this.tool, resolvedVersion, installedVersion);	18✔
105	}
106	return true;	4✔
107	} catch (RuntimeException e) {	1✔
108	step.error(e, true);	4✔
109	throw e;	2✔
110	} finally {
111	step.close();	2✔
112	}
113
114	}
115
116	/**
117	* This method is called after a tool was requested to be installed or updated.
118	*
119	* @param newlyInstalled {@code true} if the tool was installed or updated (at least link to software folder was created/updated), {@code false} otherwise
120	* (configured version was already installed and nothing changed).
121	* @param pc the {@link ProcessContext} to use.
122	*/
123	protected void postInstall(boolean newlyInstalled, ProcessContext pc) {
124
125	if (newlyInstalled) {	2✔
126	postInstall();	2✔
127	}
128	}	1✔
129
130	/**
131	* This method is called after the tool has been newly installed or updated to a new version.
132	*/
133	protected void postInstall() {
134
135	// nothing to do by default
136	}	1✔
137
138	private boolean toolAlreadyInstalled(boolean silent, VersionIdentifier installedVersion, Step step, ProcessContext pc) {
139	if (!silent) {	2✔
140	this.context.info("Version {} of tool {} is already installed", installedVersion, getToolWithEdition());	15✔
141	}
142	postInstall(false, pc);	4✔
143	step.success();	2✔
144	return false;	2✔
145	}
146
147	/**
148	* Determines whether this tool should be installed directly in the software folder or in the software repository.
149	*
150	* @return {@code true} if the tool should be installed directly in the software folder, ignoring the central software repository; {@code false} if the tool
151	* should be installed in the central software repository (default behavior).
152	*/
153	protected boolean isIgnoreSoftwareRepo() {
154
155	return false;	2✔
156	}
157
158	/**
159	* Performs the installation of the {@link #getName() tool} together with the environment context, managed by this
160	* {@link com.devonfw.tools.ide.commandlet.Commandlet}.
161	*
162	* @param version the {@link GenericVersionRange} requested to be installed.
163	* @param processContext the {@link ProcessContext} used to
164	* {@link #setEnvironment(EnvironmentContext, ToolInstallation, boolean) configure environment variables}.
165	* @return the {@link ToolInstallation} matching the given {@code version}.
166	*/
167	public ToolInstallation installTool(GenericVersionRange version, ProcessContext processContext) {
168
169	return installTool(version, processContext, getConfiguredEdition());	7✔
170	}
171
172	/**
173	* Performs the installation of the {@link #getName() tool} together with the environment context managed by this
174	* {@link com.devonfw.tools.ide.commandlet.Commandlet}.
175	*
176	* @param version the {@link GenericVersionRange} requested to be installed.
177	* @param processContext the {@link ProcessContext} used to
178	* {@link #setEnvironment(EnvironmentContext, ToolInstallation, boolean) configure environment variables}.
179	* @param edition the specific {@link #getConfiguredEdition() edition} to install.
180	* @return the {@link ToolInstallation} matching the given {@code version}.
181	*/
182	public ToolInstallation installTool(GenericVersionRange version, ProcessContext processContext, String edition) {
183
184	// if version is a VersionRange, we are not called from install() but directly from installAsDependency() due to a version conflict of a dependency
185	boolean extraInstallation = (version instanceof VersionRange);	3✔
186	ToolRepository toolRepository = getToolRepository();	3✔
187	VersionIdentifier resolvedVersion = toolRepository.resolveVersion(this.tool, edition, version, this);	8✔
188	installToolDependencies(resolvedVersion, edition, processContext);	5✔
189
190	Path installationPath;
191	boolean ignoreSoftwareRepo = isIgnoreSoftwareRepo();	3✔
192	if (ignoreSoftwareRepo) {	2✔
193	installationPath = getToolPath();	4✔
194	} else {
195	Path softwareRepoPath = this.context.getSoftwareRepositoryPath().resolve(toolRepository.getId()).resolve(this.tool).resolve(edition);	12✔
196	installationPath = softwareRepoPath.resolve(resolvedVersion.toString());	5✔
197	}
198	Path toolVersionFile = installationPath.resolve(IdeContext.FILE_SOFTWARE_VERSION);	4✔
199	FileAccess fileAccess = this.context.getFileAccess();	4✔
200	if (Files.isDirectory(installationPath)) {	5✔
201	if (Files.exists(toolVersionFile)) {	5!
202	if (!ignoreSoftwareRepo \|\| resolvedVersion.equals(getInstalledVersion())) {	2!
203	this.context.debug("Version {} of tool {} is already installed at {}", resolvedVersion, getToolWithEdition(this.tool, edition), installationPath);	21✔
204	return createToolInstallation(installationPath, resolvedVersion, toolVersionFile, false, processContext, extraInstallation);	9✔
205	}
206	} else {
207	// Makes sure that IDEasy will not delete itself
208	if (this.tool.equals(IdeasyCommandlet.TOOL_NAME)) {	×
209	this.context.warning("Your IDEasy installation is missing the version file at {}", toolVersionFile);	×
210	} else {
211	this.context.warning("Deleting corrupted installation at {}", installationPath);	×
212	fileAccess.delete(installationPath);	×
213	}
214	}
215	}
216	Path downloadedToolFile = downloadTool(edition, toolRepository, resolvedVersion);	6✔
217	boolean extract = isExtract();	3✔
218	if (!extract) {	2✔
219	this.context.trace("Extraction is disabled for '{}' hence just moving the downloaded file {}.", this.tool, downloadedToolFile);	15✔
220	}
221	if (Files.exists(installationPath)) {	5!
222	fileAccess.backup(installationPath);	×
223	}
224	fileAccess.mkdirs(installationPath.getParent());	4✔
225	fileAccess.extract(downloadedToolFile, installationPath, this::postExtract, extract);	7✔
226	try {
227	Files.writeString(toolVersionFile, resolvedVersion.toString(), StandardOpenOption.CREATE_NEW);	11✔
228	} catch (IOException e) {	×
229	throw new IllegalStateException("Failed to write version file " + toolVersionFile, e);	×
230	}	1✔
231	this.context.debug("Installed {} in version {} at {}", this.tool, resolvedVersion, installationPath);	19✔
232	return createToolInstallation(installationPath, resolvedVersion, toolVersionFile, true, processContext, extraInstallation);	9✔
233	}
234
235	/**
236	* @param edition the {@link #getConfiguredEdition() tool edition} to download.
237	* @param toolRepository the {@link ToolRepository} to use.
238	* @param resolvedVersion the resolved {@link VersionIdentifier version} to download.
239	* @return the {@link Path} to the downloaded release file.
240	*/
241	protected Path downloadTool(String edition, ToolRepository toolRepository, VersionIdentifier resolvedVersion) {
242	return toolRepository.download(this.tool, edition, resolvedVersion, this);	8✔
243	}
244
245	/**
246	* Install this tool as dependency of another tool.
247	*
248	* @param version the required {@link VersionRange}. See {@link ToolDependency#versionRange()}.
249	* @param processContext the {@link ProcessContext}.
250	* @return {@code true} if the tool was newly installed, {@code false} otherwise (installation was already present).
251	*/
252	public boolean installAsDependency(VersionRange version, ProcessContext processContext) {
253
254	VersionIdentifier configuredVersion = getConfiguredVersion();	3✔
255	if (version.contains(configuredVersion)) {	4✔
256	// prefer configured version if contained in version range
257	return install(false, processContext);	5✔
258	} else {
259	if (isIgnoreSoftwareRepo()) {	3!
260	throw new IllegalStateException(	×
261	"Cannot satisfy dependency to " + this.tool + " in version " + version + " since it is conflicting with configured version " + configuredVersion
262	+ " and this tool does not support the software repository.");
263	}
264	this.context.info(	19✔
265	"Configured version of tool {} is {} but does not match version to install {} - need to use different version from software repository.",
266	this.tool, configuredVersion, version);
267	}
268	ToolInstallation toolInstallation = installTool(version, processContext);	5✔
269	return toolInstallation.newInstallation();	3✔
270	}
271
272	private void installToolDependencies(VersionIdentifier version, String edition, ProcessContext processContext) {
273	Collection<ToolDependency> dependencies = getToolRepository().findDependencies(this.tool, edition, version);	8✔
274	String toolWithEdition = getToolWithEdition(this.tool, edition);	5✔
275	int size = dependencies.size();	3✔
276	this.context.debug("Tool {} has {} other tool(s) as dependency", toolWithEdition, size);	15✔
277	for (ToolDependency dependency : dependencies) {	10✔
278	this.context.trace("Ensuring dependency {} for tool {}", dependency.tool(), toolWithEdition);	15✔
279	LocalToolCommandlet dependencyTool = this.context.getCommandletManager().getRequiredLocalToolCommandlet(dependency.tool());	7✔
280	dependencyTool.installAsDependency(dependency.versionRange(), processContext);	6✔
281	}	1✔
282	}	1✔
283
284	/**
285	* Post-extraction hook that can be overridden to add custom processing after unpacking and before moving to the final destination folder.
286	*
287	* @param extractedDir the {@link Path} to the folder with the unpacked tool.
288	*/
289	protected void postExtract(Path extractedDir) {
290
291	}	1✔
292
293	@Override
294	public VersionIdentifier getInstalledVersion() {
295
296	return getInstalledVersion(this.context.getSoftwarePath().resolve(getName()));	9✔
297	}
298
299	/**
300	* @param toolPath the installation {@link Path} where to find the version file.
301	* @return the currently installed {@link VersionIdentifier version} of this tool or {@code null} if not installed.
302	*/
303	protected VersionIdentifier getInstalledVersion(Path toolPath) {
304
305	if (!Files.isDirectory(toolPath)) {	5✔
306	this.context.debug("Tool {} not installed in {}", getName(), toolPath);	15✔
307	return null;	2✔
308	}
309	Path toolVersionFile = toolPath.resolve(IdeContext.FILE_SOFTWARE_VERSION);	4✔
310	if (!Files.exists(toolVersionFile)) {	5✔
311	Path legacyToolVersionFile = toolPath.resolve(IdeContext.FILE_LEGACY_SOFTWARE_VERSION);	4✔
312	if (Files.exists(legacyToolVersionFile)) {	5✔
313	toolVersionFile = legacyToolVersionFile;	3✔
314	} else {
315	this.context.warning("Tool {} is missing version file in {}", getName(), toolVersionFile);	15✔
316	return null;	2✔
317	}
318	}
319	String version = this.context.getFileAccess().readFileContent(toolVersionFile).trim();	7✔
320	return VersionIdentifier.of(version);	3✔
321	}
322
323	@Override
324	public String getInstalledEdition() {
325
326	if (this.context.getSoftwarePath() == null) {	4!
327	return "";	×
328	}
329	return getInstalledEdition(this.context.getSoftwarePath().resolve(this.tool));	9✔
330	}
331
332	/**
333	* @param toolPath the installation {@link Path} where to find currently installed tool. The name of the parent directory of the real path corresponding
334	* to the passed {@link Path path} must be the name of the edition.
335	* @return the installed edition of this tool or {@code null} if not installed.
336	*/
337	private String getInstalledEdition(Path toolPath) {
338
339	if (!Files.isDirectory(toolPath)) {	5✔
340	this.context.debug("Tool {} not installed in {}", this.tool, toolPath);	15✔
341	return null;	2✔
342	}
343	Path realPath = this.context.getFileAccess().toRealPath(toolPath);	6✔
344	// if the realPath changed, a link has been resolved
345	if (realPath.equals(toolPath)) {	4✔
346	if (!isIgnoreSoftwareRepo()) {	3!
347	this.context.warning("Tool {} is not installed via software repository (maybe from devonfw-ide). Please consider reinstalling it.", this.tool);	11✔
348	}
349	// I do not see any reliable way how we could determine the edition of a tool that does not use software repo or that was installed by devonfw-ide
350	return getConfiguredEdition();	3✔
351	}
352	Path toolRepoFolder = context.getSoftwareRepositoryPath().resolve(ToolRepository.ID_DEFAULT).resolve(this.tool);	9✔
353	String edition = getEdition(toolRepoFolder, realPath);	5✔
354	if (!getToolRepository().getSortedEditions(this.tool).contains(edition)) {	8✔
355	this.context.warning("Undefined edition {} of tool {}", edition, this.tool);	15✔
356	}
357	return edition;	2✔
358	}
359
360	private String getEdition(Path toolRepoFolder, Path toolInstallFolder) {
361
362	int toolRepoNameCount = toolRepoFolder.getNameCount();	3✔
363	int toolInstallNameCount = toolInstallFolder.getNameCount();	3✔
364	if (toolRepoNameCount < toolInstallNameCount) {	3!
365	// ensure toolInstallFolder starts with $IDE_ROOT/_ide/software/default/«tool»
366	for (int i = 0; i < toolRepoNameCount; i++) {	7✔
367	if (!toolRepoFolder.getName(i).toString().equals(toolInstallFolder.getName(i).toString())) {	10!
368	return null;	×
369	}
370	}
371	return toolInstallFolder.getName(toolRepoNameCount).toString();	5✔
372	}
373	return null;	×
374	}
375
376	@Override
377	public void uninstall() {
378
379	try {
380	Path softwarePath = getToolPath();	3✔
381	if (Files.exists(softwarePath)) {	5!
382	try {
383	this.context.getFileAccess().delete(softwarePath);	5✔
384	this.context.success("Successfully uninstalled " + this.tool);	6✔
385	} catch (Exception e) {	×
386	this.context.error("Couldn't uninstall " + this.tool);	×
387	}	1✔
388	} else {
389	this.context.warning("An installed version of " + this.tool + " does not exist");	×
390	}
391	} catch (Exception e) {	×
392	this.context.error(e.getMessage());	×
393	}	1✔
394	}	1✔
395
396	private ToolInstallation createToolInstallation(Path rootDir, VersionIdentifier resolvedVersion, Path toolVersionFile,
397	boolean newInstallation, EnvironmentContext environmentContext, boolean extraInstallation) {
398
399	Path linkDir = getMacOsHelper().findLinkDir(rootDir, getBinaryName());	7✔
400	Path binDir = linkDir;	2✔
401	Path binFolder = binDir.resolve(IdeContext.FOLDER_BIN);	4✔
402	if (Files.isDirectory(binFolder)) {	5✔
403	binDir = binFolder;	2✔
404	}
405	if (linkDir != rootDir) {	3✔
406	assert (!linkDir.equals(rootDir));	5!
407	this.context.getFileAccess().copy(toolVersionFile, linkDir, FileCopyMode.COPY_FILE_OVERRIDE);	7✔
408	}
409	ToolInstallation toolInstallation = new ToolInstallation(rootDir, linkDir, binDir, resolvedVersion, newInstallation);	9✔
410	setEnvironment(environmentContext, toolInstallation, extraInstallation);	5✔
411	return toolInstallation;	2✔
412	}
413
414	/**
415	* Method to set environment variables for the process context.
416	*
417	* @param environmentContext the {@link EnvironmentContext} where to {@link EnvironmentContext#withEnvVar(String, String) set environment variables} for
418	* this tool.
419	* @param toolInstallation the {@link ToolInstallation}.
420	* @param extraInstallation {@code true} if the {@link ToolInstallation} is an additional installation to the
421	* {@link #getConfiguredVersion() configured version} due to a conflicting version of a {@link ToolDependency}, {@code false} otherwise.
422	*/
423	public void setEnvironment(EnvironmentContext environmentContext, ToolInstallation toolInstallation, boolean extraInstallation) {
424
425	String pathVariable = EnvironmentVariables.getToolVariablePrefix(this.tool) + "_HOME";	5✔
426	environmentContext.withEnvVar(pathVariable, toolInstallation.linkDir().toString());	7✔
427	if (extraInstallation) {	2✔
428	environmentContext.withPathEntry(toolInstallation.binDir());	5✔
429	}
430	}	1✔
431
432
433	}

devonfw / IDEasy / 14645240231

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