From 0ce5541bb5c92b87e2425efceee1aad53f415128 Mon Sep 17 00:00:00 2001 From: Benjamin Bentmann Date: Sat, 11 Sep 2010 20:19:40 +0000 Subject: [PATCH] [MNG-4795] [regression] Dependencies in forked reactor projects are not resolved when aggregator bound to lifecycle forks git-svn-id: https://svn.apache.org/repos/asf/maven/maven-3/trunk@996206 13f79535-47bb-0310-9956-ffa450edef68 --- .../maven/project/EmptyLifecycleExecutor.java | 2 +- .../lifecycle/DefaultLifecycleExecutor.java | 19 +-- .../maven/lifecycle/MavenExecutionPlan.java | 28 +--- .../lifecycle/internal/BuilderCommon.java | 17 +-- ...faultLifecycleExecutionPlanCalculator.java | 50 +------ .../lifecycle/internal/DependencyContext.java | 102 +++++++------- .../internal/LifecycleDebugLogger.java | 42 +++++- .../internal/LifecycleDependencyResolver.java | 43 +----- .../internal/LifecycleModuleBuilder.java | 6 +- .../internal/LifecycleWeaveBuilder.java | 3 +- .../lifecycle/internal/MojoExecutor.java | 132 +++++++++++++++--- .../lifecycle/LifecycleExecutorTest.java | 4 - .../lifecycle/internal/BuilderCommonTest.java | 5 +- .../internal/LifecycleWeaveBuilderTest.java | 5 +- .../LifecycleExecutionPlanCalculatorStub.java | 3 +- .../internal/stub/MojoExecutorStub.java | 3 +- .../maven/project/EmptyLifecycleExecutor.java | 2 +- 17 files changed, 224 insertions(+), 242 deletions(-) diff --git a/maven-compat/src/test/java/org/apache/maven/project/EmptyLifecycleExecutor.java b/maven-compat/src/test/java/org/apache/maven/project/EmptyLifecycleExecutor.java index fd7542230f..c8fdddf938 100644 --- a/maven-compat/src/test/java/org/apache/maven/project/EmptyLifecycleExecutor.java +++ b/maven-compat/src/test/java/org/apache/maven/project/EmptyLifecycleExecutor.java @@ -42,7 +42,7 @@ public class EmptyLifecycleExecutor public MavenExecutionPlan calculateExecutionPlan( MavenSession session, String... tasks ) { - return new MavenExecutionPlan(null, null, null, new DefaultLifecycles() ); + return new MavenExecutionPlan( null, new DefaultLifecycles() ); } public void execute( MavenSession session ) diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/DefaultLifecycleExecutor.java b/maven-core/src/main/java/org/apache/maven/lifecycle/DefaultLifecycleExecutor.java index 34ef03b0f8..5acaefd56d 100644 --- a/maven-core/src/main/java/org/apache/maven/lifecycle/DefaultLifecycleExecutor.java +++ b/maven-core/src/main/java/org/apache/maven/lifecycle/DefaultLifecycleExecutor.java @@ -20,9 +20,7 @@ */ import org.apache.maven.execution.MavenSession; -import org.apache.maven.lifecycle.internal.DependencyContext; import org.apache.maven.lifecycle.internal.LifecycleExecutionPlanCalculator; -import org.apache.maven.lifecycle.internal.DefaultLifecycleExecutionPlanCalculator; import org.apache.maven.lifecycle.internal.LifecycleStarter; import org.apache.maven.lifecycle.internal.LifecycleTaskSegmentCalculator; import org.apache.maven.lifecycle.internal.MojoDescriptorCreator; @@ -44,11 +42,9 @@ import org.codehaus.plexus.component.annotations.Component; import org.codehaus.plexus.component.annotations.Requirement; -import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Set; -import java.util.TreeSet; /** * A facade that provides lifecycle services to components outside maven core. @@ -166,20 +162,7 @@ public void calculateForkedExecutions( MojoExecution mojoExecution, MavenSession public List executeForkedExecutions( MojoExecution mojoExecution, MavenSession session ) throws LifecycleExecutionException { - Set requiredDependencyResolutionScopes = new TreeSet(); - Set requiredDependencyCollectionScopes = new TreeSet(); - // Ok, so this method could probably have a better location. - DefaultLifecycleExecutionPlanCalculator.collectDependencyRequirements( requiredDependencyResolutionScopes, - requiredDependencyCollectionScopes, - mojoExecution ); - - final DependencyContext context = - new DependencyContext( requiredDependencyCollectionScopes, requiredDependencyResolutionScopes, - mojoExecution.getMojoDescriptor().isAggregator() ); - mojoExecutor.executeForkedExecutions( mojoExecution, session, new ProjectIndex( session.getProjects() ), - context ); - return Collections.emptyList(); + return mojoExecutor.executeForkedExecutions( mojoExecution, session, new ProjectIndex( session.getProjects() ) ); } - } diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/MavenExecutionPlan.java b/maven-core/src/main/java/org/apache/maven/lifecycle/MavenExecutionPlan.java index 8bb83bdd37..a8c5da46a8 100644 --- a/maven-core/src/main/java/org/apache/maven/lifecycle/MavenExecutionPlan.java +++ b/maven-core/src/main/java/org/apache/maven/lifecycle/MavenExecutionPlan.java @@ -54,16 +54,6 @@ public class MavenExecutionPlan */ - /** - * For project dependency resolution, the scopes of resolution required if any. - */ - private final Set requiredDependencyResolutionScopes; - - /** - * For project dependency collection, the scopes of collection required if any. - */ - private final Set requiredDependencyCollectionScopes; - private final List planItem; private final Map lastMojoExecutionForAllPhases; @@ -71,13 +61,10 @@ public class MavenExecutionPlan final List phasesInExecutionPlan; - public MavenExecutionPlan( Set requiredDependencyResolutionScopes, - Set requiredDependencyCollectionScopes, List planItem, - DefaultLifecycles defaultLifecycles ) + public MavenExecutionPlan( List planItem, DefaultLifecycles defaultLifecycles ) { - this.requiredDependencyResolutionScopes = requiredDependencyResolutionScopes; - this.requiredDependencyCollectionScopes = requiredDependencyCollectionScopes; this.planItem = planItem; + lastMojoExecutionForAllPhases = new LinkedHashMap(); LinkedHashSet totalPhaseSet = new LinkedHashSet(); @@ -115,7 +102,6 @@ public MavenExecutionPlan( Set requiredDependencyResolutionScopes, } } - public Iterator iterator() { return getExecutionPlanItems().iterator(); @@ -177,16 +163,6 @@ public boolean containsPhase( String phase ) return phasesInExecutionPlan.contains( phase ); } - public Set getRequiredResolutionScopes() - { - return requiredDependencyResolutionScopes; - } - - public Set getRequiredCollectionScopes() - { - return requiredDependencyCollectionScopes; - } - public List getMojoExecutions() { List result = new ArrayList(); diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/BuilderCommon.java b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/BuilderCommon.java index e50523d778..7501190fe2 100644 --- a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/BuilderCommon.java +++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/BuilderCommon.java @@ -62,9 +62,6 @@ public class BuilderCommon @Requirement private LifecycleExecutionPlanCalculator lifeCycleExecutionPlanCalculator; - @Requirement - private LifecycleDependencyResolver lifecycleDependencyResolver; - @Requirement private ExecutionEventCatapult eventCatapult; @@ -72,19 +69,16 @@ public class BuilderCommon private Logger logger; - @SuppressWarnings( { "UnusedDeclaration" } ) public BuilderCommon() { } public BuilderCommon( LifecycleDebugLogger lifecycleDebugLogger, - LifecycleExecutionPlanCalculator lifeCycleExecutionPlanCalculator, - LifecycleDependencyResolver lifecycleDependencyResolver, Logger logger ) + LifecycleExecutionPlanCalculator lifeCycleExecutionPlanCalculator, Logger logger ) { this.lifecycleDebugLogger = lifecycleDebugLogger; this.lifeCycleExecutionPlanCalculator = lifeCycleExecutionPlanCalculator; - this.lifecycleDependencyResolver = lifecycleDependencyResolver; this.logger = logger; } @@ -97,6 +91,7 @@ public MavenExecutionPlan resolveBuildPlan( MavenSession session, MavenProject p { MavenExecutionPlan executionPlan = lifeCycleExecutionPlanCalculator.calculateExecutionPlan( session, project, taskSegment.getTasks() ); + lifecycleDebugLogger.debugProjectPlan( project, executionPlan ); if ( session.getRequest().isThreadConfigurationPresent() ) @@ -122,17 +117,9 @@ public MavenExecutionPlan resolveBuildPlan( MavenSession session, MavenProject p } } - // TODO: once we have calculated the build plan then we should accurately be able to download - // the project dependencies. Having it happen in the plugin manager is a tangled mess. We can optimize - // this later by looking at the build plan. Would be better to just batch download everything required - // by the reactor. - - lifecycleDependencyResolver.resolveDependencies( taskSegment.isAggregating(), project, session, executionPlan, - projectArtifacts ); return executionPlan; } - public void handleBuildError( final ReactorContext buildContext, final MavenSession rootSession, final MavenProject mavenProject, Exception e, final long buildStartTime ) { diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleExecutionPlanCalculator.java b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleExecutionPlanCalculator.java index 176ded8154..6038e14b56 100644 --- a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleExecutionPlanCalculator.java +++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DefaultLifecycleExecutionPlanCalculator.java @@ -109,28 +109,18 @@ public MavenExecutionPlan calculateExecutionPlan( MavenSession session, MavenPro PluginDescriptorParsingException, MojoNotFoundException, InvalidPluginDescriptorException, NoPluginFoundForPrefixException, LifecycleNotFoundException, PluginVersionResolutionException { - Set requiredDependencyResolutionScopes = new TreeSet(); - Set requiredDependencyCollectionScopes = new TreeSet(); - lifecyclePluginResolver.resolveMissingPluginVersions( project, session ); final List executions = calculateMojoExecutions( session, project, tasks ); - setupMojoExections( session, project, requiredDependencyResolutionScopes, requiredDependencyCollectionScopes, - executions ); + setupMojoExections( session, project, executions ); final List planItem = defaultSchedules.createExecutionPlanItem( project, executions ); - return new MavenExecutionPlan( requiredDependencyResolutionScopes, requiredDependencyCollectionScopes, planItem, - defaultLifeCycles ); - - + return new MavenExecutionPlan( planItem, defaultLifeCycles ); } - private void setupMojoExections( MavenSession session, MavenProject project, - Set requiredDependencyResolutionScopes, - Set requiredDependencyCollectionScopes, - List mojoExecutions ) + private void setupMojoExections( MavenSession session, MavenProject project, List mojoExecutions ) throws PluginNotFoundException, PluginResolutionException, PluginDescriptorParsingException, MojoNotFoundException, InvalidPluginDescriptorException, NoPluginFoundForPrefixException, LifecyclePhaseNotFoundException, LifecycleNotFoundException, PluginVersionResolutionException @@ -155,9 +145,6 @@ private void setupMojoExections( MavenSession session, MavenProject project, finalizeMojoConfiguration( mojoExecution ); calculateForkedExecutions( mojoExecution, session, project, new HashSet() ); - - collectDependencyRequirements( requiredDependencyResolutionScopes, requiredDependencyCollectionScopes, - mojoExecution ); } } @@ -202,37 +189,6 @@ else if ( task instanceof LifecycleTask ) return mojoExecutions; } - public static void collectDependencyRequirements( Collection requiredDependencyResolutionScopes, - Collection requiredDependencyCollectionScopes, - MojoExecution mojoExecution ) - { - MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor(); - - String requiredDependencyResolutionScope = mojoDescriptor.getDependencyResolutionRequired(); - - if ( StringUtils.isNotEmpty( requiredDependencyResolutionScope ) ) - { - requiredDependencyResolutionScopes.add( requiredDependencyResolutionScope ); - } - - String requiredDependencyCollectionScope = mojoDescriptor.getDependencyCollectionRequired(); - - if ( StringUtils.isNotEmpty( requiredDependencyCollectionScope ) ) - { - requiredDependencyCollectionScopes.add( requiredDependencyCollectionScope ); - } - - for ( List forkedExecutions : mojoExecution.getForkedExecutions().values() ) - { - for ( MojoExecution forkedExecution : forkedExecutions ) - { - collectDependencyRequirements( requiredDependencyResolutionScopes, requiredDependencyCollectionScopes, - forkedExecution ); - } - } - } - - private Map> calculateLifecycleMappings( MavenSession session, MavenProject project, String lifecyclePhase ) throws LifecyclePhaseNotFoundException, PluginNotFoundException, PluginResolutionException, diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DependencyContext.java b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DependencyContext.java index 8d75f8bf8d..54e5756889 100644 --- a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DependencyContext.java +++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/DependencyContext.java @@ -19,14 +19,15 @@ * under the License. */ -import org.apache.maven.execution.MavenSession; -import org.apache.maven.lifecycle.MavenExecutionPlan; import org.apache.maven.project.MavenProject; +import java.util.Arrays; import java.util.Collection; +import java.util.Collections; +import java.util.TreeSet; /** - * Context of dependency artifacts for the entire build. + * Context of dependency artifacts for a particular project. * * @since 3.0 * @author Benjamin Bentmann @@ -38,84 +39,81 @@ public class DependencyContext { - private final Collection scopesToCollect; + private static final Collection UNRESOLVED = Arrays.asList(); - private final Collection scopesToResolve; + private final MavenProject project; - private final boolean aggregating; + private final Collection scopesToCollectForCurrentProject; - private volatile MavenProject lastProject; + private final Collection scopesToResolveForCurrentProject; - private volatile Collection lastDependencyArtifacts; + private final Collection scopesToCollectForAggregatedProjects; - private volatile int lastDependencyArtifactCount; + private final Collection scopesToResolveForAggregatedProjects; - public DependencyContext( Collection scopesToCollect, Collection scopesToResolve, - boolean aggregating ) + private volatile Collection lastDependencyArtifacts = UNRESOLVED; + + private volatile int lastDependencyArtifactCount = -1; + + public DependencyContext( MavenProject project, Collection scopesToCollect, + Collection scopesToResolve ) { - this.scopesToCollect = scopesToCollect; - this.scopesToResolve = scopesToResolve; - this.aggregating = aggregating; + this.project = project; + scopesToCollectForCurrentProject = scopesToCollect; + scopesToResolveForCurrentProject = scopesToResolve; + scopesToCollectForAggregatedProjects = Collections.synchronizedSet( new TreeSet() ); + scopesToResolveForAggregatedProjects = Collections.synchronizedSet( new TreeSet() ); } - public DependencyContext( MavenExecutionPlan executionPlan, boolean aggregating ) + public MavenProject getProject() { - this( executionPlan.getRequiredCollectionScopes(), executionPlan.getRequiredResolutionScopes(), aggregating ); + return project; } - public void setLastDependencyArtifacts( Collection lastDependencyArtifacts ) + public Collection getScopesToCollectForCurrentProject() { - this.lastDependencyArtifacts = lastDependencyArtifacts; - lastDependencyArtifactCount = ( lastDependencyArtifacts != null ) ? lastDependencyArtifacts.size() : 0; + return scopesToCollectForCurrentProject; } - public MavenProject getLastProject() + public Collection getScopesToResolveForCurrentProject() { - return lastProject; + return scopesToResolveForCurrentProject; } - public void setLastProject( MavenProject lastProject ) + public Collection getScopesToCollectForAggregatedProjects() { - this.lastProject = lastProject; + return scopesToCollectForAggregatedProjects; } - public Collection getScopesToCollect() + public Collection getScopesToResolveForAggregatedProjects() { - return scopesToCollect; + return scopesToResolveForAggregatedProjects; } - public Collection getScopesToResolve() + public boolean isResolutionRequiredForCurrentProject() { - return scopesToResolve; - } - - public boolean isAggregating() - { - return aggregating; - } - - public DependencyContext clone() - { - return new DependencyContext( scopesToCollect, scopesToResolve, aggregating ); - } - - public boolean isSameProject( MavenSession session ) - { - return ( lastProject == session.getCurrentProject() ); - } - - public boolean isSameButUpdatedProject( MavenSession session ) - { - if ( isSameProject( session ) ) + if ( lastDependencyArtifacts != project.getDependencyArtifacts() + || ( lastDependencyArtifacts != null && lastDependencyArtifactCount != lastDependencyArtifacts.size() ) ) { - if ( lastDependencyArtifacts != lastProject.getDependencyArtifacts() - || ( lastDependencyArtifacts != null && lastDependencyArtifactCount != lastDependencyArtifacts.size() ) ) - { - return true; + return true; - } } return false; } + public boolean isResolutionRequiredForAggregatedProjects( Collection scopesToCollect, + Collection scopesToResolve ) + { + boolean required = + scopesToCollectForAggregatedProjects.addAll( scopesToCollect ) + || scopesToResolveForAggregatedProjects.addAll( scopesToResolve ); + return required; + } + + public void synchronizeWithProjectState() + { + lastDependencyArtifacts = project.getDependencyArtifacts(); + lastDependencyArtifactCount = ( lastDependencyArtifacts != null ) ? lastDependencyArtifacts.size() : 0; + } + } diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDebugLogger.java b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDebugLogger.java index 01388b8e69..5802606ac9 100644 --- a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDebugLogger.java +++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDebugLogger.java @@ -23,14 +23,18 @@ import org.apache.maven.execution.ProjectDependencyGraph; import org.apache.maven.lifecycle.MavenExecutionPlan; import org.apache.maven.plugin.MojoExecution; +import org.apache.maven.plugin.descriptor.MojoDescriptor; import org.apache.maven.project.MavenProject; import org.codehaus.plexus.component.annotations.Component; import org.codehaus.plexus.component.annotations.Requirement; import org.codehaus.plexus.logging.Logger; +import org.codehaus.plexus.util.StringUtils; import java.util.Iterator; import java.util.List; import java.util.Map; +import java.util.Set; +import java.util.TreeSet; /** * Logs debug output from the various lifecycle phases. @@ -76,6 +80,7 @@ public void debugReactorPlan( ProjectBuildList projectBuilds ) { return; } + logger.debug( "=== REACTOR BUILD PLAN ================================================" ); for ( Iterator it = projectBuilds.iterator(); it.hasNext(); ) @@ -98,10 +103,15 @@ public void debugReactorPlan( ProjectBuildList projectBuilds ) public void debugProjectPlan( MavenProject currentProject, MavenExecutionPlan executionPlan ) { + if ( !logger.isDebugEnabled() ) + { + return; + } + logger.debug( "=== PROJECT BUILD PLAN ================================================" ); logger.debug( "Project: " + BuilderCommon.getKey( currentProject ) ); - logger.debug( "Dependencies (collect): " + executionPlan.getRequiredCollectionScopes() ); - logger.debug( "Dependencies (resolve): " + executionPlan.getRequiredResolutionScopes() ); + + debugDependencyRequirements( executionPlan.getMojoExecutions() ); for ( ExecutionPlanItem mojoExecution : executionPlan ) { @@ -124,6 +134,8 @@ private void debugMojoExecution( MojoExecution mojoExecution ) { logger.debug( "--- init fork of " + fork.getKey() + " for " + mojoExecId + " ---" ); + debugDependencyRequirements( fork.getValue() ); + for ( MojoExecution forkedExecution : fork.getValue() ) { debugMojoExecution( forkedExecution ); @@ -140,6 +152,32 @@ private void debugMojoExecution( MojoExecution mojoExecution ) logger.debug( "Configuration: " + mojoExecution.getConfiguration() ); } + private void debugDependencyRequirements( List mojoExecutions ) + { + Set scopesToCollect = new TreeSet(); + Set scopesToResolve = new TreeSet(); + + for ( MojoExecution mojoExecution : mojoExecutions ) + { + MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor(); + + String scopeToCollect = mojoDescriptor.getDependencyCollectionRequired(); + if ( StringUtils.isNotEmpty( scopeToCollect ) ) + { + scopesToCollect.add( scopeToCollect ); + } + + String scopeToResolve = mojoDescriptor.getDependencyResolutionRequired(); + if ( StringUtils.isNotEmpty( scopeToResolve ) ) + { + scopesToResolve.add( scopeToResolve ); + } + } + + logger.debug( "Dependencies (collect): " + scopesToCollect ); + logger.debug( "Dependencies (resolve): " + scopesToResolve ); + } + public void logWeavePlan( MavenSession session ) { if ( !logger.isInfoEnabled() ) diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDependencyResolver.java b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDependencyResolver.java index e5707f6a03..33cae8ae29 100644 --- a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDependencyResolver.java +++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDependencyResolver.java @@ -21,7 +21,6 @@ import org.apache.maven.artifact.factory.ArtifactFactory; import org.apache.maven.execution.MavenSession; import org.apache.maven.lifecycle.LifecycleExecutionException; -import org.apache.maven.lifecycle.MavenExecutionPlan; import org.apache.maven.project.DefaultDependencyResolutionRequest; import org.apache.maven.project.DependencyResolutionException; import org.apache.maven.project.DependencyResolutionResult; @@ -73,15 +72,6 @@ public LifecycleDependencyResolver( ProjectDependenciesResolver projectDependenc this.logger = logger; } - public void resolveDependencies( boolean aggregating, MavenProject currentProject, - MavenSession sessionForThisModule, MavenExecutionPlan executionPlan, - Set projectArtifacts ) - throws LifecycleExecutionException - { - List projectsToResolve = getProjects( currentProject, sessionForThisModule, aggregating ); - resolveDependencies( aggregating, sessionForThisModule, executionPlan, projectsToResolve, projectArtifacts ); - } - public static List getProjects( MavenProject project, MavenSession session, boolean aggregator ) { if ( aggregator ) @@ -94,36 +84,9 @@ public static List getProjects( MavenProject project, MavenSession } } - public void checkForUpdate( MavenSession session, DependencyContext dependenctContext ) - throws LifecycleExecutionException - { - - if ( dependenctContext.isSameButUpdatedProject( session ) ) - { - resolveProjectDependencies( dependenctContext.getLastProject(), dependenctContext.getScopesToCollect(), - dependenctContext.getScopesToResolve(), session, - dependenctContext.isAggregating(), new HashSet() ); - } - - dependenctContext.setLastProject( session.getCurrentProject() ); - dependenctContext.setLastDependencyArtifacts( session.getCurrentProject().getDependencyArtifacts() ); - } - - private void resolveDependencies( boolean aggregating, MavenSession session, MavenExecutionPlan executionPlan, - List projectsToResolve, Set projectArtifacts ) - throws LifecycleExecutionException - { - for ( MavenProject project : projectsToResolve ) - { - resolveProjectDependencies( project, executionPlan.getRequiredCollectionScopes(), - executionPlan.getRequiredResolutionScopes(), session, aggregating, - projectArtifacts ); - } - } - - private void resolveProjectDependencies( MavenProject project, Collection scopesToCollect, - Collection scopesToResolve, MavenSession session, - boolean aggregating, Set projectArtifacts ) + public void resolveProjectDependencies( MavenProject project, Collection scopesToCollect, + Collection scopesToResolve, MavenSession session, + boolean aggregating, Set projectArtifacts ) throws LifecycleExecutionException { if ( project.getDependencyArtifacts() == null ) diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleModuleBuilder.java b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleModuleBuilder.java index 02eb1b26c2..fe69c0a120 100644 --- a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleModuleBuilder.java +++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleModuleBuilder.java @@ -62,8 +62,6 @@ public void buildProject( MavenSession session, ReactorContext reactorContext, M public void buildProject( MavenSession session, MavenSession rootSession, ReactorContext reactorContext, MavenProject currentProject, TaskSegment taskSegment ) { - boolean isAggregating = taskSegment.isAggregating(); - session.setCurrentProject( currentProject ); long buildStartTime = System.currentTimeMillis(); @@ -83,9 +81,7 @@ public void buildProject( MavenSession session, MavenSession rootSession, Reacto MavenExecutionPlan executionPlan = builderCommon.resolveBuildPlan( session, currentProject, taskSegment, new HashSet() ); - DependencyContext dependencyContext = new DependencyContext( executionPlan, isAggregating ); - mojoExecutor.execute( session, executionPlan.getMojoExecutions(), reactorContext.getProjectIndex(), - dependencyContext ); + mojoExecutor.execute( session, executionPlan.getMojoExecutions(), reactorContext.getProjectIndex() ); long buildEndTime = System.currentTimeMillis(); diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleWeaveBuilder.java b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleWeaveBuilder.java index fe993d2034..1e43dd60fd 100644 --- a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleWeaveBuilder.java +++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleWeaveBuilder.java @@ -151,8 +151,9 @@ public void build( ProjectBuildList projectBuilds, ReactorContext buildContext, try { final MavenExecutionPlan executionPlan = plans.get( projectBuild ).get(); + DependencyContext dependencyContext = - new DependencyContext( executionPlan, projectBuild.getTaskSegment().isAggregating() ); + mojoExecutor.newDependencyContext( session, executionPlan.getMojoExecutions() ); final Callable projectBuilder = createCallableForBuildingOneFullModule( buildContext, session, reactorBuildStatus, diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/MojoExecutor.java b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/MojoExecutor.java index 31480514f4..3f8985df8e 100644 --- a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/MojoExecutor.java +++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/MojoExecutor.java @@ -19,6 +19,7 @@ * under the License. */ +import org.apache.maven.artifact.Artifact; import org.apache.maven.artifact.resolver.filter.ArtifactFilter; import org.apache.maven.artifact.resolver.filter.CumulativeScopeArtifactFilter; import org.apache.maven.execution.ExecutionEvent; @@ -38,9 +39,13 @@ import org.codehaus.plexus.util.StringUtils; import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Map; +import java.util.Set; +import java.util.TreeSet; /** * Executes an individual mojo @@ -69,12 +74,67 @@ public MojoExecutor() { } - public void execute( MavenSession session, List mojoExecutions, ProjectIndex projectIndex, - DependencyContext dependencyContext ) + public DependencyContext newDependencyContext( MavenSession session, List mojoExecutions ) + { + Set scopesToCollect = new TreeSet(); + Set scopesToResolve = new TreeSet(); + + collectDependencyRequirements( scopesToResolve, scopesToCollect, mojoExecutions ); + + return new DependencyContext( session.getCurrentProject(), scopesToCollect, scopesToResolve ); + } + + private void collectDependencyRequirements( Set scopesToResolve, Set scopesToCollect, + Collection mojoExecutions ) + { + for ( MojoExecution mojoExecution : mojoExecutions ) + { + MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor(); + + scopesToResolve.addAll( toScopes( mojoDescriptor.getDependencyResolutionRequired() ) ); + + scopesToCollect.addAll( toScopes( mojoDescriptor.getDependencyCollectionRequired() ) ); + } + } + + private Collection toScopes( String classpath ) + { + if ( StringUtils.isNotEmpty( classpath ) ) + { + if ( Artifact.SCOPE_COMPILE.equals( classpath ) ) + { + return Arrays.asList( Artifact.SCOPE_COMPILE, Artifact.SCOPE_SYSTEM, Artifact.SCOPE_PROVIDED ); + } + else if ( Artifact.SCOPE_RUNTIME.equals( classpath ) ) + { + return Arrays.asList( Artifact.SCOPE_COMPILE, Artifact.SCOPE_RUNTIME ); + } + else if ( Artifact.SCOPE_COMPILE_PLUS_RUNTIME.equals( classpath ) ) + { + return Arrays.asList( Artifact.SCOPE_COMPILE, Artifact.SCOPE_SYSTEM, Artifact.SCOPE_PROVIDED, + Artifact.SCOPE_RUNTIME ); + } + else if ( Artifact.SCOPE_RUNTIME_PLUS_SYSTEM.equals( classpath ) ) + { + return Arrays.asList( Artifact.SCOPE_COMPILE, Artifact.SCOPE_SYSTEM, Artifact.SCOPE_RUNTIME ); + } + else if ( Artifact.SCOPE_TEST.equals( classpath ) ) + { + return Arrays.asList( Artifact.SCOPE_COMPILE, Artifact.SCOPE_SYSTEM, Artifact.SCOPE_PROVIDED, + Artifact.SCOPE_RUNTIME, Artifact.SCOPE_TEST ); + } + } + return Collections.emptyList(); + } + + public void execute( MavenSession session, List mojoExecutions, ProjectIndex projectIndex ) throws LifecycleExecutionException { + DependencyContext dependencyContext = newDependencyContext( session, mojoExecutions ); + PhaseRecorder phaseRecorder = new PhaseRecorder( session.getCurrentProject() ); + for ( MojoExecution mojoExecution : mojoExecutions ) { execute( session, mojoExecution, projectIndex, dependencyContext, phaseRecorder ); @@ -122,22 +182,12 @@ private void execute( MavenSession session, MojoExecution mojoExecution, Project } } - lifeCycleDependencyResolver.checkForUpdate( session, dependencyContext ); + List forkedProjects = executeForkedExecutions( mojoExecution, session, projectIndex ); - List forkedProjects = - executeForkedExecutions( mojoExecution, session, projectIndex, dependencyContext ); + ensureDependenciesAreResolved( mojoDescriptor, session, dependencyContext ); eventCatapult.fire( ExecutionEvent.Type.MojoStarted, session, mojoExecution ); - ArtifactFilter artifactFilter = getArtifactFilter( mojoDescriptor ); - List resolvedProjects = - LifecycleDependencyResolver.getProjects( session.getCurrentProject(), session, - mojoDescriptor.isAggregator() ); - for ( MavenProject project : resolvedProjects ) - { - project.setArtifactFilter( artifactFilter ); - } - try { try @@ -178,6 +228,54 @@ private void execute( MavenSession session, MojoExecution mojoExecution, Project } } + private void ensureDependenciesAreResolved( MojoDescriptor mojoDescriptor, MavenSession session, + DependencyContext dependencyContext ) + throws LifecycleExecutionException + + { + MavenProject project = dependencyContext.getProject(); + boolean aggregating = mojoDescriptor.isAggregator(); + + if ( dependencyContext.isResolutionRequiredForCurrentProject() ) + { + Collection scopesToCollect = dependencyContext.getScopesToCollectForCurrentProject(); + Collection scopesToResolve = dependencyContext.getScopesToResolveForCurrentProject(); + + lifeCycleDependencyResolver.resolveProjectDependencies( project, scopesToCollect, scopesToResolve, session, + aggregating, Collections. emptySet() ); + + dependencyContext.synchronizeWithProjectState(); + } + + if ( aggregating ) + { + Collection scopesToCollect = toScopes( mojoDescriptor.getDependencyCollectionRequired() ); + Collection scopesToResolve = toScopes( mojoDescriptor.getDependencyResolutionRequired() ); + + if ( dependencyContext.isResolutionRequiredForAggregatedProjects( scopesToCollect, scopesToResolve ) ) + { + for ( MavenProject aggregatedProject : session.getProjects() ) + { + if ( aggregatedProject != project ) + { + lifeCycleDependencyResolver.resolveProjectDependencies( aggregatedProject, scopesToCollect, + scopesToResolve, session, aggregating, + Collections. emptySet() ); + } + } + } + } + + ArtifactFilter artifactFilter = getArtifactFilter( mojoDescriptor ); + List projectsToResolve = + LifecycleDependencyResolver.getProjects( session.getCurrentProject(), session, + mojoDescriptor.isAggregator() ); + for ( MavenProject projectToResolve : projectsToResolve ) + { + projectToResolve.setArtifactFilter( artifactFilter ); + } + } + private ArtifactFilter getArtifactFilter( MojoDescriptor mojoDescriptor ) { String scopeToResolve = mojoDescriptor.getDependencyResolutionRequired(); @@ -204,7 +302,7 @@ private ArtifactFilter getArtifactFilter( MojoDescriptor mojoDescriptor ) } public List executeForkedExecutions( MojoExecution mojoExecution, MavenSession session, - ProjectIndex projectIndex, DependencyContext dependencyContext ) + ProjectIndex projectIndex ) throws LifecycleExecutionException { List forkedProjects = Collections.emptyList(); @@ -219,8 +317,6 @@ public List executeForkedExecutions( MojoExecution mojoExecution, forkedProjects = new ArrayList( forkedExecutions.size() ); - dependencyContext = dependencyContext.clone(); - try { for ( Map.Entry> fork : forkedExecutions.entrySet() ) @@ -252,7 +348,7 @@ public List executeForkedExecutions( MojoExecution mojoExecution, eventCatapult.fire( ExecutionEvent.Type.ForkedProjectStarted, session, mojoExecution ); - execute( session, mojoExecutions, projectIndex, dependencyContext ); + execute( session, mojoExecutions, projectIndex ); eventCatapult.fire( ExecutionEvent.Type.ForkedProjectSucceeded, session, mojoExecution ); } diff --git a/maven-core/src/test/java/org/apache/maven/lifecycle/LifecycleExecutorTest.java b/maven-core/src/test/java/org/apache/maven/lifecycle/LifecycleExecutorTest.java index b33649028f..58dd0e699a 100644 --- a/maven-core/src/test/java/org/apache/maven/lifecycle/LifecycleExecutorTest.java +++ b/maven-core/src/test/java/org/apache/maven/lifecycle/LifecycleExecutorTest.java @@ -195,10 +195,6 @@ public void testCalculationOfBuildPlanWithMultipleExecutionsOfModello() MavenExecutionPlan plan = calculateExecutionPlan( session, "clean", "install" ); - assertTrue( plan.getRequiredResolutionScopes().contains( Artifact.SCOPE_COMPILE ) ); - assertTrue( plan.getRequiredResolutionScopes().contains( Artifact.SCOPE_RUNTIME ) ); - assertTrue( plan.getRequiredResolutionScopes().contains( Artifact.SCOPE_TEST ) ); - List executions = getExecutions( plan ); //[01] clean:clean diff --git a/maven-core/src/test/java/org/apache/maven/lifecycle/internal/BuilderCommonTest.java b/maven-core/src/test/java/org/apache/maven/lifecycle/internal/BuilderCommonTest.java index a5f50655d7..21f0fc7915 100644 --- a/maven-core/src/test/java/org/apache/maven/lifecycle/internal/BuilderCommonTest.java +++ b/maven-core/src/test/java/org/apache/maven/lifecycle/internal/BuilderCommonTest.java @@ -21,7 +21,6 @@ import org.apache.maven.lifecycle.MavenExecutionPlan; import org.apache.maven.lifecycle.internal.stub.LifecycleExecutionPlanCalculatorStub; import org.apache.maven.lifecycle.internal.stub.LoggerStub; -import org.apache.maven.lifecycle.internal.stub.ProjectDependenciesResolverStub; import org.apache.maven.lifecycle.internal.stub.ProjectDependencyGraphStub; import java.util.HashSet; @@ -68,9 +67,7 @@ public void testGetKey() public static BuilderCommon getBuilderCommon() { final LifecycleDebugLogger logger = new LifecycleDebugLogger( new LoggerStub() ); - final LifecycleDependencyResolver lifecycleDependencyResolver = - new LifecycleDependencyResolver( new ProjectDependenciesResolverStub(), new LoggerStub() ); - return new BuilderCommon( logger, new LifecycleExecutionPlanCalculatorStub(), lifecycleDependencyResolver, + return new BuilderCommon( logger, new LifecycleExecutionPlanCalculatorStub(), new LoggerStub() ); } diff --git a/maven-core/src/test/java/org/apache/maven/lifecycle/internal/LifecycleWeaveBuilderTest.java b/maven-core/src/test/java/org/apache/maven/lifecycle/internal/LifecycleWeaveBuilderTest.java index 531933c81a..fa777f950d 100644 --- a/maven-core/src/test/java/org/apache/maven/lifecycle/internal/LifecycleWeaveBuilderTest.java +++ b/maven-core/src/test/java/org/apache/maven/lifecycle/internal/LifecycleWeaveBuilderTest.java @@ -25,7 +25,6 @@ import org.apache.maven.lifecycle.internal.stub.LifecycleTaskSegmentCalculatorStub; import org.apache.maven.lifecycle.internal.stub.LoggerStub; import org.apache.maven.lifecycle.internal.stub.MojoExecutorStub; -import org.apache.maven.lifecycle.internal.stub.ProjectDependenciesResolverStub; import org.apache.maven.lifecycle.internal.stub.ProjectDependencyGraphStub; import org.apache.maven.plugin.InvalidPluginDescriptorException; import org.apache.maven.plugin.MojoNotFoundException; @@ -131,9 +130,7 @@ private LifecycleWeaveBuilder getWeaveBuilder( MojoExecutor mojoExecutor ) private BuilderCommon getBuilderCommon() { final LifecycleDebugLogger logger = new LifecycleDebugLogger( new LoggerStub() ); - final LifecycleDependencyResolver lifecycleDependencyResolver = - new LifecycleDependencyResolver( new ProjectDependenciesResolverStub(), new LoggerStub() ); - return new BuilderCommon( logger, new LifecycleExecutionPlanCalculatorStub(), lifecycleDependencyResolver, + return new BuilderCommon( logger, new LifecycleExecutionPlanCalculatorStub(), new LoggerStub() ); } } diff --git a/maven-core/src/test/java/org/apache/maven/lifecycle/internal/stub/LifecycleExecutionPlanCalculatorStub.java b/maven-core/src/test/java/org/apache/maven/lifecycle/internal/stub/LifecycleExecutionPlanCalculatorStub.java index fcf0a6ebfa..ffdff9c5d6 100644 --- a/maven-core/src/test/java/org/apache/maven/lifecycle/internal/stub/LifecycleExecutionPlanCalculatorStub.java +++ b/maven-core/src/test/java/org/apache/maven/lifecycle/internal/stub/LifecycleExecutionPlanCalculatorStub.java @@ -171,8 +171,7 @@ private static MavenExecutionPlan createExecutionPlan( MavenProject project, Lis { final List planItemList = DefaultSchedulesStub.createDefaultSchedules().createExecutionPlanItem( project, mojoExecutions ); - return new MavenExecutionPlan( getScopes(), getScopes(), planItemList, - DefaultLifecyclesStub.createDefaultLifecycles() ); + return new MavenExecutionPlan( planItemList, DefaultLifecyclesStub.createDefaultLifecycles() ); } private static MojoExecution createMojoExecution( String goal, String executionId, MojoDescriptor mojoDescriptor ) diff --git a/maven-core/src/test/java/org/apache/maven/lifecycle/internal/stub/MojoExecutorStub.java b/maven-core/src/test/java/org/apache/maven/lifecycle/internal/stub/MojoExecutorStub.java index 64f3e6c206..a8572ffc9f 100644 --- a/maven-core/src/test/java/org/apache/maven/lifecycle/internal/stub/MojoExecutorStub.java +++ b/maven-core/src/test/java/org/apache/maven/lifecycle/internal/stub/MojoExecutorStub.java @@ -47,8 +47,7 @@ public void execute( MavenSession session, MojoExecution mojoExecution, ProjectI } @Override - public void execute( MavenSession session, List mojoExecutions, ProjectIndex projectIndex, - DependencyContext dependencyContext ) + public void execute( MavenSession session, List mojoExecutions, ProjectIndex projectIndex ) throws LifecycleExecutionException { for ( MojoExecution mojoExecution : mojoExecutions ) diff --git a/maven-core/src/test/java/org/apache/maven/project/EmptyLifecycleExecutor.java b/maven-core/src/test/java/org/apache/maven/project/EmptyLifecycleExecutor.java index f396cdca9d..2436ff742b 100644 --- a/maven-core/src/test/java/org/apache/maven/project/EmptyLifecycleExecutor.java +++ b/maven-core/src/test/java/org/apache/maven/project/EmptyLifecycleExecutor.java @@ -43,7 +43,7 @@ public class EmptyLifecycleExecutor public MavenExecutionPlan calculateExecutionPlan( MavenSession session, String... tasks ) { - return new MavenExecutionPlan(null, null, null, null ); + return new MavenExecutionPlan( null, null ); } public void execute( MavenSession session )