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;
+ }
+}