[
https://issues.apache.org/jira/browse/MTOOLCHAINS-49?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17821666#comment-17821666
]
ASF GitHub Bot commented on MTOOLCHAINS-49:
-------------------------------------------
gnodet commented on code in PR #14:
URL:
https://github.com/apache/maven-toolchains-plugin/pull/14#discussion_r1505950697
##########
src/main/java/org/apache/maven/plugins/toolchain/jdk/ToolchainDiscoverer.java:
##########
@@ -0,0 +1,433 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.plugins.toolchain.jdk;
+
+import javax.inject.Named;
+import javax.inject.Singleton;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.apache.maven.toolchain.model.PersistedToolchains;
+import org.apache.maven.toolchain.model.ToolchainModel;
+import org.apache.maven.toolchain.model.io.xpp3.MavenToolchainsXpp3Reader;
+import org.apache.maven.toolchain.model.io.xpp3.MavenToolchainsXpp3Writer;
+import org.codehaus.plexus.util.xml.Xpp3Dom;
+import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static
org.apache.maven.plugins.toolchain.jdk.SelectJdkToolchainMojo.TOOLCHAIN_TYPE_JDK;
+
+/**
+ * Toolchain discoverer service
+ */
+@Named
+@Singleton
+public class ToolchainDiscoverer {
+
+ public static final String JAVA = "java.";
+ public static final String VERSION = "version";
+ public static final String RUNTIME_NAME = "runtime.name";
+ public static final String RUNTIME_VERSION = "runtime.version";
+ public static final String VENDOR = "vendor";
+ public static final String VENDOR_VERSION = "vendor.version";
+ public static final String[] PROPERTIES = {VERSION, RUNTIME_NAME,
RUNTIME_VERSION, VENDOR, VENDOR_VERSION};
+
+ public static final String DISCOVERED_TOOLCHAINS_CACHE_XML =
".m2/discovered-toolchains-cache.xml";
+
+ public static final String CURRENT = "current";
+ public static final String ENV = "env";
+ public static final String LTS = "lts";
+
+ public static final String JDK_HOME = "jdkHome";
+ public static final String JAVA_HOME = "java.home";
+
+ private static final String COMMA = ",";
+ public static final String USER_HOME = "user.home";
+
+ private final Logger log = LoggerFactory.getLogger(getClass());
+
+ private Map<Path, ToolchainModel> cache;
+ private boolean cacheModified;
+
+ /**
+ * Build the model for the current JDK toolchain
+ */
+ public Optional<ToolchainModel> getCurrentJdkToolchain() {
+ Path currentJdkHome =
getCanonicalPath(Paths.get(System.getProperty(JAVA_HOME)));
+ if (hasJavaC(currentJdkHome)) {
+ // in case the current JVM is not a JDK
+ return Optional.empty();
+ }
+ ToolchainModel model = new ToolchainModel();
+ model.setType(TOOLCHAIN_TYPE_JDK);
+ Stream.of(PROPERTIES).forEach(k -> {
+ String v = System.getProperty(JAVA + k);
+ if (v != null) {
+ model.addProvide(k.substring(JAVA.length()), v);
+ }
+ });
+ model.addProvide(CURRENT, "true");
+ Xpp3Dom config = new Xpp3Dom("configuration");
+ Xpp3Dom jdkHome = new Xpp3Dom(JDK_HOME);
+ jdkHome.setValue(currentJdkHome.toString());
+ config.addChild(jdkHome);
+ model.setConfiguration(config);
+ return Optional.of(model);
+ }
+
+ public PersistedToolchains discoverToolchains() {
+ return discoverToolchains(LTS + COMMA + VERSION + COMMA + VENDOR);
+ }
+
+ /**
+ * Returns a PersistedToolchains object containing a list of discovered
toolchains,
+ * never <code>null</code>.
+ */
+ public PersistedToolchains discoverToolchains(String comparator) {
+ try {
+ Set<Path> jdks = findJdks();
+ log.info("Found " + jdks.size() + " possible jdks: " + jdks);
+ cacheModified = false;
+ readCache();
+ Map<Path, Map<String, String>> flags = new HashMap<>();
+ Path currentJdkHome =
getCanonicalPath(Paths.get(System.getProperty(JAVA_HOME)));
+ flags.computeIfAbsent(currentJdkHome, p -> new
HashMap<>()).put(CURRENT, "true");
+ // check environment variables for JAVA{xx}_HOME
+ System.getenv().entrySet().stream()
+ .filter(e -> e.getKey().startsWith("JAVA") &&
e.getKey().endsWith("_HOME"))
+ .forEach(e -> {
+ Path path = getCanonicalPath(Paths.get(e.getValue()));
+ Map<String, String> f = flags.computeIfAbsent(path, p
-> new HashMap<>());
+ String val = f.getOrDefault(ENV, "");
+ f.put(ENV, (val.isEmpty() ? "" : val + ",") +
e.getKey());
+ });
+
+ List<ToolchainModel> tcs = jdks.parallelStream()
+ .map(s -> {
+ ToolchainModel tc = getToolchainModel(s);
+ flags.getOrDefault(s, Collections.emptyMap())
+ .forEach((k, v) ->
tc.getProvides().setProperty(k, v));
+ String version = tc.getProvides().getProperty(VERSION);
+ if (isLts(version)) {
+ tc.getProvides().setProperty(LTS, "true");
+ }
+ return tc;
+ })
+ .sorted(getToolchainModelComparator(comparator))
+ .collect(Collectors.toList());
+ if (this.cacheModified) {
+ writeCache();
+ }
+ PersistedToolchains ps = new PersistedToolchains();
+ ps.setToolchains(tcs);
+ return ps;
+ } catch (Exception e) {
+ if (log.isDebugEnabled()) {
+ log.warn("Error discovering toolchains: " + e, e);
+ } else {
+ log.warn("Error discovering toolchains (enable debug level for
more information): " + e);
+ }
+ return new PersistedToolchains();
+ }
+ }
+
+ private static boolean isLts(String version) {
+ return version.startsWith("1.8.")
+ || version.startsWith("11.")
+ || version.startsWith("17.")
+ || version.startsWith("21.")
+ || version.startsWith("25.");
+ }
+
+ private void readCache() {
+ try {
+ cache = new ConcurrentHashMap<>();
+ Path cacheFile = getCacheFile();
+ if (Files.isRegularFile(cacheFile)) {
+ try (Reader r = Files.newBufferedReader(cacheFile)) {
+ PersistedToolchains pt = new
MavenToolchainsXpp3Reader().read(r, false);
+ cache = pt.getToolchains().stream()
+ // Remove stale entries
+ .filter(tc -> {
+ // If the bin/java executable is not available
anymore, remove this TC
+ if (!hasJavaC(getJdkHome(tc))) {
+ cacheModified = false;
+ return false;
+ } else {
+ return true;
+ }
+ })
+
.collect(Collectors.toConcurrentMap(this::getJdkHome, Function.identity()));
+ }
+ }
+ } catch (IOException | XmlPullParserException e) {
+ log.warn("Error reading toolchains cache: " + e);
Review Comment:
Note that the cache does not cache discovered toolchains (i.e. paths which
contain a JDK), but rather the information related to each found JDK.
> Automatic discovery of JDK toolchains
> -------------------------------------
>
> Key: MTOOLCHAINS-49
> URL: https://issues.apache.org/jira/browse/MTOOLCHAINS-49
> Project: Maven Toolchains Plugin
> Issue Type: Improvement
> Reporter: Guillaume Nodet
> Assignee: Guillaume Nodet
> Priority: Major
>
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
