You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by rf...@apache.org on 2020/06/20 08:40:08 UTC

[maven] 01/30: When a build fails, write file with properties to resume the next build from.

This is an automated email from the ASF dual-hosted git repository.

rfscholte pushed a commit to branch MNG-5760
in repository https://gitbox.apache.org/repos/asf/maven.git

commit bb894634b5c9900c5efbe78a586aa34d4612448b
Author: Martin Kanters <Ma...@infosupport.com>
AuthorDate: Mon May 4 15:39:41 2020 +0200

    When a build fails, write file with properties to resume the next build from.
---
 .../apache/maven/cli/BuildResumptionManager.java   | 238 +++++++++++++++++++++
 .../main/java/org/apache/maven/cli/MavenCli.java   |  22 +-
 .../maven/cli/BuildResumptionManagerTest.java      | 126 +++++++++++
 3 files changed, 381 insertions(+), 5 deletions(-)

diff --git a/maven-embedder/src/main/java/org/apache/maven/cli/BuildResumptionManager.java b/maven-embedder/src/main/java/org/apache/maven/cli/BuildResumptionManager.java
new file mode 100644
index 0000000..7820c0a
--- /dev/null
+++ b/maven-embedder/src/main/java/org/apache/maven/cli/BuildResumptionManager.java
@@ -0,0 +1,238 @@
+package org.apache.maven.cli;
+
+/*
+ * 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.
+ */
+
+import com.google.common.annotations.VisibleForTesting;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.maven.execution.MavenExecutionResult;
+import org.apache.maven.lifecycle.LifecycleExecutionException;
+import org.apache.maven.model.Dependency;
+import org.apache.maven.project.MavenProject;
+import org.codehaus.plexus.logging.Logger;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+import javax.inject.Singleton;
+import java.io.IOException;
+import java.io.Writer;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Properties;
+import java.util.stream.Collectors;
+
+import static java.util.Comparator.comparing;
+
+@Named
+@Singleton
+class BuildResumptionManager
+{
+    private static final String RESUME_PROPERTIES_FILENAME = "resume.properties";
+
+    @Inject
+    private Logger logger;
+
+    public boolean createResumptionFile( MavenExecutionResult result )
+    {
+        Properties properties = determineResumptionProperties( result );
+
+        if ( properties.isEmpty() )
+        {
+            logger.debug( "Will not create " + RESUME_PROPERTIES_FILENAME + " file: nothing to resume from" );
+            return false;
+        }
+
+        return writeResumptionFile( result, properties );
+    }
+
+    @VisibleForTesting
+    Properties determineResumptionProperties( MavenExecutionResult result )
+    {
+        Properties properties = new Properties();
+
+        List<MavenProject> failedProjects = getFailedProjectsInOrder( result );
+        if ( !failedProjects.isEmpty() )
+        {
+            MavenProject resumeFromProject = failedProjects.get( 0 );
+            Optional<String> resumeFrom = getResumeFrom( result, resumeFromProject );
+            Optional<String> projectsToSkip = determineProjectsToSkip( result, failedProjects, resumeFromProject );
+
+            resumeFrom.ifPresent( value -> properties.setProperty( "resumeFrom", value ) );
+            projectsToSkip.ifPresent( value -> properties.setProperty( "excludedProjects", value ) );
+        }
+        else
+        {
+            logger.warn( "Could not create " + RESUME_PROPERTIES_FILENAME + " file: no failed projects found" );
+        }
+
+        return properties;
+    }
+
+    private List<MavenProject> getFailedProjectsInOrder( MavenExecutionResult result )
+    {
+        List<MavenProject> sortedProjects = result.getTopologicallySortedProjects();
+
+        return result.getExceptions().stream()
+                .filter( LifecycleExecutionException.class::isInstance )
+                .map( LifecycleExecutionException.class::cast )
+                .map( LifecycleExecutionException::getProject )
+                .sorted( comparing( sortedProjects::indexOf ) )
+                .collect( Collectors.toList() );
+    }
+
+    private Optional<String> getResumeFrom( MavenExecutionResult result, MavenProject failedProject )
+    {
+        List<MavenProject> allSortedProjects = result.getTopologicallySortedProjects();
+        if ( !allSortedProjects.get( 0 ).equals( failedProject ) )
+        {
+            return Optional.of( String.format( "%s:%s", failedProject.getGroupId(), failedProject.getArtifactId() ) );
+        }
+
+        return Optional.empty();
+    }
+
+    /**
+     * Projects after the first failed project could have succeeded by using -T or --fail-at-end.
+     * These projects can be skipped from later builds.
+     * This is not the case these projects are dependent on one of the failed projects.
+     * @param result The result of the Maven build.
+     * @param failedProjects The list of failed projects in the build.
+     * @param resumeFromProject The project where the build will be resumed with in the next run.
+     * @return An optional containing a comma separated list of projects which can be skipped,
+     *   or an empty optional if no projects can be skipped.
+     */
+    private Optional<String> determineProjectsToSkip( MavenExecutionResult result, List<MavenProject> failedProjects,
+                                                      MavenProject resumeFromProject )
+    {
+        List<MavenProject> allProjects = result.getTopologicallySortedProjects();
+        int resumeFromProjectIndex = allProjects.indexOf( resumeFromProject );
+        List<MavenProject> remainingProjects = allProjects.subList( resumeFromProjectIndex + 1, allProjects.size() );
+
+        List<GroupArtifactPair> failedProjectsGAList = failedProjects.stream()
+                .map( GroupArtifactPair::new )
+                .collect( Collectors.toList() );
+
+        String projectsToSkip = remainingProjects.stream()
+                .filter( project -> result.getBuildSummary( project ) != null )
+                .filter( project -> hasNoDependencyOnProjects( project, failedProjectsGAList ) )
+                .map( project -> String.format( "%s:%s", project.getGroupId(), project.getArtifactId() ) )
+                .collect( Collectors.joining( ", " ) );
+
+        if ( !StringUtils.isEmpty( projectsToSkip ) )
+        {
+            return Optional.of( projectsToSkip );
+        }
+
+        return Optional.empty();
+    }
+
+    private boolean hasNoDependencyOnProjects( MavenProject project, List<GroupArtifactPair> projectsGAs )
+    {
+        return project.getDependencies().stream()
+                .map( GroupArtifactPair::new )
+                .noneMatch( projectsGAs::contains );
+    }
+
+    /**
+     * A helper method to determine the value to resume the build with {@code -rf} taking into account the edge case where multiple modules in the reactor have the same artifactId.
+     * <p>
+     * {@code -rf :artifactId} will pick up the first module which matches, but when multiple modules in the reactor have the same artifactId, effective failed module might be later in build reactor.
+     * This means that developer will either have to type groupId or wait for build execution of all modules which were fine, but they are still before one which reported errors.
+     * <p>Then the returned value is {@code groupId:artifactId} when there is a name clash and
+     * {@code :artifactId} if there is no conflict.
+     *
+     * @param mavenProjects Maven projects which are part of build execution.
+     * @param failedProject Project which has failed.
+     * @return Value for -rf flag to resume build exactly from place where it failed ({@code :artifactId} in general and {@code groupId:artifactId} when there is a name clash).
+     */
+    public String getResumeFromSelector( List<MavenProject> mavenProjects, MavenProject failedProject )
+    {
+        for ( MavenProject buildProject : mavenProjects )
+        {
+            if ( failedProject.getArtifactId().equals( buildProject.getArtifactId() ) && !failedProject.equals( buildProject ) )
+            {
+                return failedProject.getGroupId() + ":" + failedProject.getArtifactId();
+            }
+        }
+        return ":" + failedProject.getArtifactId();
+    }
+
+    private boolean writeResumptionFile( MavenExecutionResult result, Properties properties )
+    {
+        Path resumeProperties = Paths.get( result.getProject().getBuild().getDirectory(), RESUME_PROPERTIES_FILENAME );
+        try
+        {
+            Files.createDirectories( resumeProperties.getParent() );
+            try ( Writer writer = Files.newBufferedWriter( resumeProperties ) )
+            {
+                properties.store( writer, null );
+            }
+        }
+        catch ( IOException e )
+        {
+            logger.warn( "Could not create " + RESUME_PROPERTIES_FILENAME + " file. ", e );
+            return false;
+        }
+
+        return true;
+    }
+
+    private static class GroupArtifactPair
+    {
+        private final String groupId;
+        private final String artifactId;
+
+        GroupArtifactPair( MavenProject project )
+        {
+            this.groupId = project.getGroupId();
+            this.artifactId = project.getArtifactId();
+        }
+
+        GroupArtifactPair( Dependency dependency )
+        {
+            this.groupId = dependency.getGroupId();
+            this.artifactId = dependency.getArtifactId();
+        }
+
+        @Override
+        public boolean equals( Object o )
+        {
+            if ( this == o )
+            {
+                return true;
+            }
+            if ( o == null || getClass() != o.getClass() )
+            {
+                return false;
+            }
+            GroupArtifactPair that = (GroupArtifactPair) o;
+            return Objects.equals( groupId, that.groupId ) && Objects.equals( artifactId, that.artifactId );
+        }
+
+        @Override
+        public int hashCode()
+        {
+            return Objects.hash( groupId, artifactId );
+        }
+    }
+}
diff --git a/maven-embedder/src/main/java/org/apache/maven/cli/MavenCli.java b/maven-embedder/src/main/java/org/apache/maven/cli/MavenCli.java
index cbdf47f..9dd127a 100644
--- a/maven-embedder/src/main/java/org/apache/maven/cli/MavenCli.java
+++ b/maven-embedder/src/main/java/org/apache/maven/cli/MavenCli.java
@@ -168,6 +168,8 @@ public class MavenCli
 
     private Map<String, ConfigurationProcessor> configurationProcessors;
 
+    private BuildResumptionManager buildResumptionManager;
+
     public MavenCli()
     {
         this( null );
@@ -705,6 +707,8 @@ public class MavenCli
 
         dispatcher = (DefaultSecDispatcher) container.lookup( SecDispatcher.class, "maven" );
 
+        buildResumptionManager = container.lookup( BuildResumptionManager.class );
+
         return container;
     }
 
@@ -1025,12 +1029,20 @@ public class MavenCli
                 }
             }
 
-            if ( project != null && !project.equals( result.getTopologicallySortedProjects().get( 0 ) ) )
+            boolean resumeFileCreated = buildResumptionManager.createResumptionFile( result );
+
+            slf4jLogger.error( "" );
+            slf4jLogger.error( "After correcting the problems, you can resume the build with the command" );
+
+            List<MavenProject> sortedProjects = result.getTopologicallySortedProjects();
+            if ( resumeFileCreated )
             {
-                slf4jLogger.error( "" );
-                slf4jLogger.error( "After correcting the problems, you can resume the build with the command" );
-                slf4jLogger.error( buffer().a( "  " ).strong( "mvn <args> -rf "
-                    + getResumeFrom( result.getTopologicallySortedProjects(), project ) ).toString() );
+                slf4jLogger.error( buffer().a( "  " ).strong( "mvn <args> -r " ).toString() );
+            }
+            else if ( project != null && !project.equals( sortedProjects.get( 0 ) ) )
+            {
+                String resumeFromSelector = buildResumptionManager.getResumeFromSelector( sortedProjects, project );
+                slf4jLogger.error( buffer().a( "  " ).strong( "mvn <args> -rf " + resumeFromSelector ).toString() );
             }
 
             if ( MavenExecutionRequest.REACTOR_FAIL_NEVER.equals( cliRequest.request.getReactorFailureBehavior() ) )
diff --git a/maven-embedder/src/test/java/org/apache/maven/cli/BuildResumptionManagerTest.java b/maven-embedder/src/test/java/org/apache/maven/cli/BuildResumptionManagerTest.java
new file mode 100644
index 0000000..a70da32
--- /dev/null
+++ b/maven-embedder/src/test/java/org/apache/maven/cli/BuildResumptionManagerTest.java
@@ -0,0 +1,126 @@
+package org.apache.maven.cli;
+
+import org.apache.maven.execution.BuildFailure;
+import org.apache.maven.execution.BuildSuccess;
+import org.apache.maven.execution.DefaultMavenExecutionResult;
+import org.apache.maven.execution.MavenExecutionResult;
+import org.apache.maven.lifecycle.LifecycleExecutionException;
+import org.apache.maven.model.Dependency;
+import org.apache.maven.project.MavenProject;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Properties;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+public class BuildResumptionManagerTest
+{
+    private final BuildResumptionManager buildResumptionManager = new BuildResumptionManager();
+
+    private MavenExecutionResult result;
+
+    @Before
+    public void before() {
+        result = new DefaultMavenExecutionResult();
+    }
+
+    @Test
+    public void resumeFromGetsDetermined()
+    {
+        MavenProject projectA = createSucceededMavenProject( "A" );
+        MavenProject projectB = createFailedMavenProject( "B" );
+        result.setTopologicallySortedProjects( asList( projectA, projectB ) );
+
+        Properties properties = buildResumptionManager.determineResumptionProperties( result );
+
+        assertThat( properties.get( "resumeFrom" ), is( "test:B" ) );
+    }
+
+    @Test
+    public void resumeFromIsIgnoredWhenFirstProjectFails()
+    {
+        MavenProject projectA = createFailedMavenProject( "A" );
+        MavenProject projectB = createMavenProject( "B" );
+        result.setTopologicallySortedProjects( asList( projectA, projectB ) );
+
+        Properties properties = buildResumptionManager.determineResumptionProperties( result );
+
+        assertThat( properties.containsKey( "resumeFrom" ), is(false) );
+    }
+
+    @Test
+    public void projectsSucceedingAfterFailedProjectsAreExcluded()
+    {
+        MavenProject projectA = createSucceededMavenProject( "A" );
+        MavenProject projectB = createFailedMavenProject( "B" );
+        MavenProject projectC = createSucceededMavenProject( "C" );
+        result.setTopologicallySortedProjects( asList( projectA, projectB, projectC ) );
+
+        Properties properties = buildResumptionManager.determineResumptionProperties( result );
+
+        assertThat( properties.get( "excludedProjects" ), is("test:C") );
+    }
+
+    @Test
+    public void projectsDependingOnFailedProjectsAreNotExcluded()
+    {
+        MavenProject projectA = createSucceededMavenProject( "A" );
+        MavenProject projectB = createFailedMavenProject( "B" );
+        MavenProject projectC = createSucceededMavenProject( "C" );
+        projectC.setDependencies( singletonList( toDependency( projectB ) ) );
+        result.setTopologicallySortedProjects( asList( projectA, projectB, projectC ) );
+
+        Properties properties = buildResumptionManager.determineResumptionProperties( result );
+
+        assertThat( properties.containsKey( "excludedProjects" ), is(false) );
+    }
+
+    @Test
+    public void multipleExcludedProjectsAreCommaSeparated()
+    {
+        MavenProject projectA = createFailedMavenProject( "A" );
+        MavenProject projectB = createSucceededMavenProject( "B" );
+        MavenProject projectC = createSucceededMavenProject( "C" );
+        result.setTopologicallySortedProjects( asList( projectA, projectB, projectC ) );
+
+        Properties properties = buildResumptionManager.determineResumptionProperties( result );
+
+        assertThat( properties.get( "excludedProjects" ), is( "test:B, test:C" ) );
+    }
+
+    private MavenProject createMavenProject( String artifactId )
+    {
+        MavenProject project = new MavenProject();
+        project.setGroupId( "test" );
+        project.setArtifactId( artifactId );
+        return project;
+    }
+
+    private Dependency toDependency( MavenProject mavenProject )
+    {
+        Dependency dependency = new Dependency();
+        dependency.setGroupId( mavenProject.getGroupId() );
+        dependency.setArtifactId( mavenProject.getArtifactId() );
+        dependency.setVersion( mavenProject.getVersion() );
+        return dependency;
+    }
+
+    private MavenProject createSucceededMavenProject( String artifactId )
+    {
+        MavenProject project = createMavenProject( artifactId );
+        result.addBuildSummary( new BuildSuccess( project, 0 ) );
+        return project;
+    }
+
+    private MavenProject createFailedMavenProject( String artifactId )
+    {
+        MavenProject project = createMavenProject( artifactId );
+        result.addBuildSummary( new BuildFailure( project, 0, new Exception() ) );
+        result.addException( new LifecycleExecutionException( "", project ) );
+        return project;
+    }
+}