[MNG-6869] New flag to verify Maven installation status

maven-core/src/main/java/org/apache/maven/internal/impl/DefaultArtifactCoordinate.java

@@ -21,6 +21,7 @@
 import java.util.Objects;
 
 import org.apache.maven.api.ArtifactCoordinate;
+import org.apache.maven.api.Session;
 import org.apache.maven.api.VersionRange;
 import org.apache.maven.api.annotations.Nonnull;
 
@@ -30,11 +31,11 @@
  * A wrapper class around a maven resolver artifact.
  */
 public class DefaultArtifactCoordinate implements ArtifactCoordinate {
-    private final @Nonnull AbstractSession session;
+    private final @Nonnull Session session;
     private final @Nonnull org.eclipse.aether.artifact.Artifact coordinate;
 
     public DefaultArtifactCoordinate(
-            @Nonnull AbstractSession session, @Nonnull org.eclipse.aether.artifact.Artifact coordinate) {
+            @Nonnull Session session, @Nonnull org.eclipse.aether.artifact.Artifact coordinate) {
         this.session = nonNull(session, "session can not be null");
         this.coordinate = nonNull(coordinate, "coordinate can not be null");
     }

maven-embedder/src/main/java/org/apache/maven/cli/CLIManager.java

@@ -114,6 +114,8 @@ public class CLIManager {
 
     public static final String COLOR = "color";
 
+    public static final String INSTALLATION_STATUS = "status";
+
     /** This option is deprecated and may be repurposed as Java debug in a future version.
      * Use {@code -X/--verbose} instead. */
     @Deprecated
@@ -296,6 +298,10 @@ public CLIManager() {
                 .optionalArg(true)
                 .desc("Defines the color mode of the output. Supported are 'auto', 'always', 'never'.")
                 .build());
+        options.addOption(Option.builder()
+                .longOpt(INSTALLATION_STATUS)
+                .desc("Display Maven installation status")
+                .build());
 
         // Deprecated
         options.addOption(Option.builder()

maven-embedder/src/main/java/org/apache/maven/cli/MavenCli.java

@@ -41,6 +41,7 @@
 import java.util.function.Consumer;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 import com.google.inject.AbstractModule;
@@ -176,6 +177,8 @@ public class MavenCli {
 
     private CLIManager cliManager;
 
+    private PlexusContainer plexusContainer;
+
     private static final Pattern NEXT_LINE = Pattern.compile("\r?\n");
 
     public MavenCli() {
@@ -280,6 +283,7 @@ public int doMain(CliRequest cliRequest) {
             configure(cliRequest);
             toolchains(cliRequest);
             populateRequest(cliRequest);
+            status(cliRequest);
             encryption(cliRequest);
             repository(cliRequest);
             return execute(cliRequest);
@@ -393,6 +397,23 @@ private void informativeCommands(CliRequest cliRequest) throws ExitException {
         }
     }
 
+    private void status(CliRequest cliRequest) throws Exception {
+        slf4jLoggerFactory = LoggerFactory.getILoggerFactory();
+        if (cliRequest.commandLine.hasOption(CLIManager.INSTALLATION_STATUS)) {
+            MavenStatusCommand mavenStatusCommand = new MavenStatusCommand(plexusContainer);
+            final List<String> issues = mavenStatusCommand.verify(cliRequest.getRequest());
+            if (!issues.isEmpty()) {
+                slf4jLogger.info("");
+                slf4jLogger.error("The following issues where found");
+                IntStream.range(0, issues.size()).forEach(i -> slf4jLogger.error("{}.  {}", i + 1, issues.get(i)));
+                throw new ExitException(1);
+            }
+
+            slf4jLogger.info("No installation issues found.");
+            throw new ExitException(0);
+        }
+    }
+
     private CommandLine cliMerge(CommandLine mavenConfig, CommandLine mavenCli) {
         CommandLine.Builder commandLineBuilder = new CommandLine.Builder();
 
@@ -641,6 +662,8 @@ protected void configure() {
 
         dispatcher = (DefaultSecDispatcher) container.lookup(SecDispatcher.class, "maven");
 
+        plexusContainer = container;
+
         return container;
     }
 

maven-embedder/src/main/java/org/apache/maven/cli/MavenStatusCommand.java

@@ -0,0 +1,214 @@
+/*
+ * 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.cli;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.apache.maven.api.ArtifactCoordinate;
+import org.apache.maven.api.Session;
+import org.apache.maven.api.services.ArtifactResolver;
+import org.apache.maven.api.services.ArtifactResolverException;
+import org.apache.maven.api.services.ArtifactResolverResult;
+import org.apache.maven.artifact.repository.ArtifactRepository;
+import org.apache.maven.bridge.MavenRepositorySystem;
+import org.apache.maven.execution.DefaultMavenExecutionResult;
+import org.apache.maven.execution.MavenExecutionRequest;
+import org.apache.maven.execution.MavenExecutionRequestPopulationException;
+import org.apache.maven.execution.MavenExecutionRequestPopulator;
+import org.apache.maven.execution.MavenSession;
+import org.apache.maven.internal.aether.DefaultRepositorySystemSessionFactory;
+import org.apache.maven.internal.impl.DefaultArtifactCoordinate;
+import org.apache.maven.internal.impl.DefaultSession;
+import org.apache.maven.internal.impl.DefaultSessionFactory;
+import org.apache.maven.session.scope.internal.SessionScope;
+import org.codehaus.plexus.PlexusContainer;
+import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
+import org.eclipse.aether.RepositorySystemSession;
+import org.eclipse.aether.artifact.Artifact;
+import org.eclipse.aether.artifact.DefaultArtifact;
+import org.eclipse.aether.resolution.ArtifactResolutionException;
+import org.eclipse.aether.resolution.ArtifactResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class MavenStatusCommand {
+    private static final Logger LOGGER = LoggerFactory.getLogger(MavenStatusCommand.class);
+
+    /**
+     * In order to verify artifacts can be downloaded from the remote repositories we want to resolve an actual
+     * artifact. The Apache Maven artifact was chosen as it eventually, be it by proxy, mirror or directly, will be
+     * gathered from the central repository. The version is chosen arbitrarily since any listed should work.
+     */
+    public static final Artifact APACHE_MAVEN_ARTIFACT =
+            new DefaultArtifact("org.apache.maven", "apache-maven", null, "pom", "3.8.6");
+
+    private final MavenExecutionRequestPopulator mavenExecutionRequestPopulator;
+    private final ArtifactResolver artifactResolver;
+    private final RemoteRepositoryConnectionVerifier remoteRepositoryConnectionVerifier;
+    private final DefaultSessionFactory defaultSessionFactory;
+    private final DefaultRepositorySystemSessionFactory repoSession;
+    private final MavenRepositorySystem repositorySystem;
+    private final PlexusContainer container;
+    private final SessionScope sessionScope;
+    private Path tempLocalRepository;
+
+    public MavenStatusCommand(final PlexusContainer container) throws ComponentLookupException {
+        this.container = container;
+        this.remoteRepositoryConnectionVerifier = new RemoteRepositoryConnectionVerifier(container);
+        this.mavenExecutionRequestPopulator = container.lookup(MavenExecutionRequestPopulator.class);
+        this.artifactResolver = container.lookup(ArtifactResolver.class);
+        this.defaultSessionFactory = container.lookup(DefaultSessionFactory.class);
+        this.repoSession = container.lookup(DefaultRepositorySystemSessionFactory.class);
+        this.sessionScope = container.lookup(SessionScope.class);
+        this.repositorySystem = container.lookup(MavenRepositorySystem.class);
+    }
+
+    public List<String> verify(final MavenExecutionRequest cliRequest) throws MavenExecutionRequestPopulationException {
+        final MavenExecutionRequest mavenExecutionRequest = mavenExecutionRequestPopulator.populateDefaults(cliRequest);
+
+        final ArtifactRepository localRepository = cliRequest.getLocalRepository();
+
+        final List<String> localRepositoryIssues =
+                verifyLocalRepository(Paths.get(URI.create(localRepository.getUrl())));
+
+        // We overwrite the local repository with a temporary directory to avoid using a cached version of the artifact.
+        setTemporaryLocalRepositoryPathOnRequest(cliRequest);
+
+        final List<String> remoteRepositoryIssues =
+                verifyRemoteRepositoryConnections(cliRequest.getRemoteRepositories(), mavenExecutionRequest);
+        final List<String> artifactResolutionIssues = verifyArtifactResolution(mavenExecutionRequest);
+
+        cleanupTempFiles();
+
+        // Collect all issues into a single list
+        return Stream.of(localRepositoryIssues, remoteRepositoryIssues, artifactResolutionIssues)
+                .flatMap(Collection::stream)
+                .collect(Collectors.toList());
+    }
+
+    private void cleanupTempFiles() {
+        if (tempLocalRepository != null) {
+            try (Stream<Path> files = Files.walk(tempLocalRepository)) {
+                files.sorted(Comparator.reverseOrder()) // Sort in reverse order so that directories are deleted last
+                        .map(Path::toFile)
+                        .forEach(File::delete);
+            } catch (IOException ioe) {
+                LOGGER.debug("Failed to delete temporary local repository", ioe);
+            }
+        }
+    }
+
+    private void setTemporaryLocalRepositoryPathOnRequest(final MavenExecutionRequest request) {
+        try {
+            tempLocalRepository = Files.createTempDirectory("mvn-status").toAbsolutePath();
+            request.setLocalRepositoryPath(tempLocalRepository.toString());
+            request.setLocalRepository(repositorySystem.createLocalRepository(request, tempLocalRepository.toFile()));
+        } catch (Exception ex) {
+            LOGGER.debug("Could not create temporary local repository", ex);
+            LOGGER.warn("Artifact resolution test is less accurate as it may use earlier resolution results.");
+        }
+    }
+
+    private List<String> verifyRemoteRepositoryConnections(
+            final List<ArtifactRepository> remoteRepositories, final MavenExecutionRequest mavenExecutionRequest) {
+        final List<String> issues = new ArrayList<>();
+
+        for (ArtifactRepository remoteRepository : remoteRepositories) {
+            final RepositorySystemSession repositorySession = repoSession.newRepositorySession(mavenExecutionRequest);
+            remoteRepositoryConnectionVerifier
+                    .verifyConnectionToRemoteRepository(repositorySession, remoteRepository)
+                    .ifPresent(issues::add);
+        }
+
+        return issues;
+    }
+
+    private List<String> verifyArtifactResolution(final MavenExecutionRequest mavenExecutionRequest) {
+        final Session session = this.defaultSessionFactory.getSession(new MavenSession(
+                container,
+                repoSession.newRepositorySession(mavenExecutionRequest),
+                mavenExecutionRequest,
+                new DefaultMavenExecutionResult()));
+
+        sessionScope.enter();
+        try {
+            sessionScope.seed(DefaultSession.class, (DefaultSession) session);
+
+            ArtifactCoordinate artifactCoordinate = new DefaultArtifactCoordinate(session, APACHE_MAVEN_ARTIFACT);
+            ArtifactResolverResult resolverResult =
+                    artifactResolver.resolve(session, Collections.singleton(artifactCoordinate));
+
+            resolverResult
+                    .getArtifacts()
+                    .forEach((key, value) -> LOGGER.debug("Successfully resolved {} to {}", key, value));
+
+            return Collections.emptyList();
+        } catch (ArtifactResolverException are) {
+            return extractIssuesFromArtifactResolverException(are);
+        } finally {
+            sessionScope.exit();
+            LOGGER.info("Artifact resolution check completed");
+        }
+    }
+
+    private List<String> extractIssuesFromArtifactResolverException(final Exception exception) {
+        final boolean isArtifactResolutionException = exception.getCause() instanceof ArtifactResolutionException;
+        if (isArtifactResolutionException) {
+            final ArtifactResolutionException are = (ArtifactResolutionException) exception.getCause();
+            return are.getResults().stream()
+                    .map(ArtifactResult::getExceptions)
+                    .flatMap(List::stream)
+                    .map(Throwable::getMessage)
+                    .collect(Collectors.toList());
+        } else {
+            return Collections.singletonList(exception.getMessage());
+        }
+    }
+
+    private List<String> verifyLocalRepository(final Path localRepositoryPath) {
+        final List<String> issues = new ArrayList<>();
+
+        if (!Files.isDirectory(localRepositoryPath)) {
+            issues.add(String.format("Local repository path '%s' is not a directory.", localRepositoryPath));
+        }
+
+        if (!Files.isReadable(localRepositoryPath)) {
+            issues.add(String.format("No read permissions on local repository '%s'.", localRepositoryPath));
+        }
+
+        if (!Files.isWritable(localRepositoryPath)) {
+            issues.add(String.format("No write permissions on local repository '%s'.", localRepositoryPath));
+        }
+
+        LOGGER.info("Local repository setup check completed");
+        return issues;
+    }
+}