| package org.apache.maven.lifecycle; |
| |
| /* |
| * 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 org.apache.maven.BuildFailureException; |
| import org.apache.maven.ConfigurationInterpolationException; |
| import org.apache.maven.ConfigurationInterpolator; |
| import org.apache.maven.artifact.handler.ArtifactHandler; |
| import org.apache.maven.artifact.handler.manager.ArtifactHandlerManager; |
| import org.apache.maven.artifact.resolver.ArtifactNotFoundException; |
| import org.apache.maven.artifact.resolver.ArtifactResolutionException; |
| import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException; |
| import org.apache.maven.execution.MavenSession; |
| import org.apache.maven.execution.ReactorManager; |
| import org.apache.maven.extension.ExtensionManager; |
| import org.apache.maven.lifecycle.mapping.LifecycleMapping; |
| import org.apache.maven.model.Extension; |
| import org.apache.maven.model.Plugin; |
| import org.apache.maven.model.PluginExecution; |
| import org.apache.maven.model.ReportPlugin; |
| import org.apache.maven.model.ReportSet; |
| import org.apache.maven.monitor.event.EventDispatcher; |
| import org.apache.maven.monitor.event.MavenEvents; |
| import org.apache.maven.plugin.InvalidPluginException; |
| import org.apache.maven.plugin.MojoExecution; |
| import org.apache.maven.plugin.MojoExecutionException; |
| import org.apache.maven.plugin.MojoFailureException; |
| import org.apache.maven.plugin.PluginConfigurationException; |
| import org.apache.maven.plugin.PluginManager; |
| import org.apache.maven.plugin.PluginManagerException; |
| import org.apache.maven.plugin.PluginNotFoundException; |
| import org.apache.maven.plugin.descriptor.MojoDescriptor; |
| import org.apache.maven.plugin.descriptor.PluginDescriptor; |
| import org.apache.maven.plugin.lifecycle.Execution; |
| import org.apache.maven.plugin.lifecycle.Phase; |
| import org.apache.maven.plugin.version.PluginVersionNotFoundException; |
| import org.apache.maven.plugin.version.PluginVersionResolutionException; |
| import org.apache.maven.project.MavenProject; |
| import org.apache.maven.project.MavenProjectBuilder; |
| import org.apache.maven.project.artifact.InvalidDependencyVersionException; |
| import org.apache.maven.project.interpolation.ModelInterpolationException; |
| import org.apache.maven.project.interpolation.ModelInterpolator; |
| import org.apache.maven.reporting.MavenReport; |
| import org.apache.maven.settings.Settings; |
| import org.codehaus.plexus.PlexusConstants; |
| import org.codehaus.plexus.PlexusContainer; |
| import org.codehaus.plexus.PlexusContainerException; |
| import org.codehaus.plexus.component.repository.exception.ComponentLookupException; |
| import org.codehaus.plexus.configuration.PlexusConfiguration; |
| import org.codehaus.plexus.context.Context; |
| import org.codehaus.plexus.context.ContextException; |
| import org.codehaus.plexus.logging.AbstractLogEnabled; |
| import org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable; |
| import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable; |
| import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException; |
| import org.codehaus.plexus.util.StringUtils; |
| import org.codehaus.plexus.util.xml.Xpp3Dom; |
| import org.codehaus.plexus.util.xml.pull.XmlPullParserException; |
| |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Stack; |
| import java.util.StringTokenizer; |
| |
| /** |
| * @author <a href="mailto:jason@maven.org">Jason van Zyl</a> |
| * @author <a href="mailto:brett@apache.org">Brett Porter</a> |
| * @version $Id$ |
| * @todo because of aggregation, we ended up with cli-ish stuff in here (like line() and the project logging, without much of the event handling) |
| */ |
| public class DefaultLifecycleExecutor |
| extends AbstractLogEnabled |
| implements LifecycleExecutor, Initializable, Contextualizable |
| { |
| // ---------------------------------------------------------------------- |
| // Components |
| // ---------------------------------------------------------------------- |
| |
| private PluginManager pluginManager; |
| |
| private ExtensionManager extensionManager; |
| |
| private List lifecycles; |
| |
| private ArtifactHandlerManager artifactHandlerManager; |
| |
| private List defaultReports; |
| |
| private Map phaseToLifecycleMap; |
| |
| private MavenProjectBuilder mavenProjectBuilder; |
| |
| private ModelInterpolator modelInterpolator; |
| |
| private ConfigurationInterpolator configInterpolator; |
| |
| // ---------------------------------------------------------------------- |
| // |
| // ---------------------------------------------------------------------- |
| |
| /** |
| * Execute a task. Each task may be a phase in the lifecycle or the |
| * execution of a mojo. |
| * |
| * @param session |
| * @param rm |
| * @param dispatcher |
| */ |
| public void execute( final MavenSession session, final ReactorManager rm, final EventDispatcher dispatcher ) |
| throws BuildFailureException, LifecycleExecutionException |
| { |
| // TODO: This is dangerous, particularly when it's just a collection of loose-leaf projects being built |
| // within the same reactor (using an inclusion pattern to gather them up)... |
| MavenProject rootProject = rm.getTopLevelProject(); |
| |
| List goals = session.getGoals(); |
| |
| if ( goals.isEmpty() && rootProject != null ) |
| { |
| String goal = rootProject.getDefaultGoal(); |
| |
| if ( goal != null ) |
| { |
| goals = Collections.singletonList( goal ); |
| } |
| } |
| |
| if ( goals.isEmpty() ) |
| { |
| StringBuffer buffer = new StringBuffer( 1024 ); |
| |
| buffer.append( "\n\n" ); |
| buffer.append( "You must specify at least one goal or lifecycle phase to perform build steps.\n" ); |
| buffer.append( "The following list illustrates some commonly used build commands:\n\n" ); |
| buffer.append( " mvn clean\n" ); |
| buffer.append( " Deletes any build output (e.g. class files or JARs).\n" ); |
| buffer.append( " mvn test\n" ); |
| buffer.append( " Runs the unit tests for the project.\n" ); |
| buffer.append( " mvn install\n" ); |
| buffer.append( " Copies the project artifacts into your local repository.\n" ); |
| buffer.append( " mvn deploy\n" ); |
| buffer.append( " Copies the project artifacts into the remote repository.\n" ); |
| buffer.append( " mvn site\n" ); |
| buffer.append( " Creates project documentation (e.g. reports or Javadoc).\n\n" ); |
| buffer.append( "Please see\n" ); |
| buffer.append( "http://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html\n" ); |
| buffer.append( "for a complete description of available lifecycle phases.\n\n" ); |
| buffer.append( "Use \"mvn --help\" to show general usage information about Maven's command line.\n\n" ); |
| |
| throw new BuildFailureException( buffer.toString() ); |
| } |
| |
| List taskSegments = segmentTaskListByAggregationNeeds( goals, session, rootProject ); |
| |
| // TODO: probably don't want to do all this up front |
| findExtensions( session ); |
| |
| executeTaskSegments( taskSegments, rm, session, rootProject, dispatcher ); |
| } |
| |
| private void findExtensions( final MavenSession session ) |
| throws LifecycleExecutionException |
| { |
| // TODO: MNG-4081. What about extensions within the current reactor?? |
| Map<String, ArtifactHandler> handlers = new HashMap<String, ArtifactHandler>(); |
| for ( MavenProject project : session.getSortedProjects() ) |
| { |
| for ( Iterator j = project.getBuildExtensions().iterator(); j.hasNext(); ) |
| { |
| Extension extension = (Extension) j.next(); |
| try |
| { |
| getLogger().debug( "Adding extension: " + extension ); |
| extensionManager.addExtension( extension, project, session.getProjectBuilderConfiguration() ); |
| } |
| catch ( PlexusContainerException e ) |
| { |
| throw new LifecycleExecutionException( "Unable to initialise extensions", e ); |
| } |
| catch ( ArtifactResolutionException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( ArtifactNotFoundException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| } |
| |
| } |
| |
| extensionManager.registerWagons(); |
| |
| handlers.putAll( extensionManager.getArtifactTypeHandlers() ); |
| |
| for ( MavenProject project : session.getSortedProjects() ) |
| { |
| try |
| { |
| handlers.putAll( findArtifactTypeHandlersInPlugins( project, session ) ); |
| |
| // shudder... |
| for ( ArtifactHandler handler : handlers.values() ) |
| { |
| if ( project.getPackaging().equals( handler.getPackaging() ) ) |
| { |
| project.getArtifact().setArtifactHandler( handler ); |
| |
| // NOTE: Adding this (maven 2.2.1) to short-circuit things. This means first match is used, NOT LAST. |
| break; |
| } |
| } |
| } |
| catch ( PluginNotFoundException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| } |
| |
| artifactHandlerManager.addHandlers( handlers ); |
| } |
| |
| private void executeTaskSegments( final List taskSegments, final ReactorManager rm, final MavenSession session, |
| final MavenProject rootProject, final EventDispatcher dispatcher ) |
| throws LifecycleExecutionException, BuildFailureException |
| { |
| for ( Iterator it = taskSegments.iterator(); it.hasNext(); ) |
| { |
| TaskSegment segment = (TaskSegment) it.next(); |
| |
| if ( segment.aggregate() ) |
| { |
| if ( !rm.isBlackListed( rootProject ) ) |
| { |
| line(); |
| |
| getLogger().info( "Building " + rootProject.getName() ); |
| |
| getLogger().info( " " + segment ); |
| |
| line(); |
| |
| // !! This is ripe for refactoring to an aspect. |
| // Event monitoring. |
| String event = MavenEvents.PROJECT_EXECUTION; |
| |
| long buildStartTime = System.currentTimeMillis(); |
| |
| String target = rootProject.getId() + " ( " + segment + " )"; |
| |
| dispatcher.dispatchStart( event, target ); |
| |
| try |
| { |
| session.setCurrentProject( rootProject ); |
| |
| // only call once, with the top-level project (assumed to be provided as a parameter)... |
| for ( Iterator goalIterator = segment.getTasks().iterator(); goalIterator.hasNext(); ) |
| { |
| String task = (String) goalIterator.next(); |
| |
| executeGoalAndHandleFailures( task, session, rootProject, dispatcher, event, rm, buildStartTime, |
| target ); |
| } |
| |
| rm.registerBuildSuccess( rootProject, System.currentTimeMillis() - buildStartTime ); |
| |
| } |
| finally |
| { |
| session.setCurrentProject( null ); |
| } |
| |
| dispatcher.dispatchEnd( event, target ); |
| } |
| else |
| { |
| line(); |
| |
| getLogger().info( "SKIPPING " + rootProject.getName() ); |
| |
| getLogger().info( " " + segment ); |
| |
| getLogger().info( |
| "This project has been banned from further executions due to previous failures." ); |
| |
| line(); |
| } |
| } |
| else |
| { |
| List sortedProjects = session.getSortedProjects(); |
| |
| // iterate over projects, and execute on each... |
| for ( Iterator projectIterator = sortedProjects.iterator(); projectIterator.hasNext(); ) |
| { |
| MavenProject currentProject = (MavenProject) projectIterator.next(); |
| |
| if ( !rm.isBlackListed( currentProject ) ) |
| { |
| line(); |
| |
| getLogger().info( "Building " + currentProject.getName() ); |
| |
| getLogger().info( " " + segment ); |
| |
| line(); |
| |
| // !! This is ripe for refactoring to an aspect. |
| // Event monitoring. |
| String event = MavenEvents.PROJECT_EXECUTION; |
| |
| long buildStartTime = System.currentTimeMillis(); |
| |
| String target = currentProject.getId() + " ( " + segment + " )"; |
| dispatcher.dispatchStart( event, target ); |
| |
| try |
| { |
| session.setCurrentProject( currentProject ); |
| |
| for ( Iterator goalIterator = segment.getTasks().iterator(); goalIterator.hasNext(); ) |
| { |
| String task = (String) goalIterator.next(); |
| |
| executeGoalAndHandleFailures( task, session, currentProject, dispatcher, event, rm, |
| buildStartTime, target ); |
| } |
| |
| } |
| finally |
| { |
| session.setCurrentProject( null ); |
| } |
| |
| rm.registerBuildSuccess( currentProject, System.currentTimeMillis() - buildStartTime ); |
| |
| dispatcher.dispatchEnd( event, target ); |
| } |
| else |
| { |
| line(); |
| |
| getLogger().info( "SKIPPING " + currentProject.getName() ); |
| |
| getLogger().info( " " + segment ); |
| |
| getLogger().info( |
| "This project has been banned from further executions due to previous failures." ); |
| |
| line(); |
| } |
| } |
| } |
| } |
| } |
| |
| private void executeGoalAndHandleFailures( final String task, final MavenSession session, final MavenProject project, |
| final EventDispatcher dispatcher, final String event, final ReactorManager rm, |
| final long buildStartTime, final String target ) |
| throws BuildFailureException, LifecycleExecutionException |
| { |
| try |
| { |
| executeGoal( task, session, project ); |
| } |
| catch ( LifecycleExecutionException e ) |
| { |
| dispatcher.dispatchError( event, target, e ); |
| |
| if ( handleExecutionFailure( rm, project, e, task, buildStartTime ) ) |
| { |
| throw e; |
| } |
| } |
| catch ( BuildFailureException e ) |
| { |
| dispatcher.dispatchError( event, target, e ); |
| |
| if ( handleExecutionFailure( rm, project, e, task, buildStartTime ) ) |
| { |
| throw e; |
| } |
| } |
| } |
| |
| private boolean handleExecutionFailure( final ReactorManager rm, final MavenProject project, final Exception e, final String task, |
| final long buildStartTime ) |
| { |
| rm.registerBuildFailure( project, e, task, System.currentTimeMillis() - buildStartTime ); |
| |
| if ( ReactorManager.FAIL_FAST.equals( rm.getFailureBehavior() ) ) |
| { |
| return true; |
| } |
| else if ( ReactorManager.FAIL_AT_END.equals( rm.getFailureBehavior() ) ) |
| { |
| rm.blackList( project ); |
| } |
| // if NEVER, don't blacklist |
| return false; |
| } |
| |
| private List segmentTaskListByAggregationNeeds( final List tasks, final MavenSession session, final MavenProject project ) |
| throws LifecycleExecutionException, BuildFailureException |
| { |
| List segments = new ArrayList(); |
| |
| if ( project != null ) |
| { |
| |
| TaskSegment currentSegment = null; |
| for ( Iterator it = tasks.iterator(); it.hasNext(); ) |
| { |
| String task = (String) it.next(); |
| |
| // if it's a phase, then we don't need to check whether it's an aggregator. |
| // simply add it to the current task partition. |
| if ( getPhaseToLifecycleMap().containsKey( task ) ) |
| { |
| if ( currentSegment != null && currentSegment.aggregate() ) |
| { |
| segments.add( currentSegment ); |
| currentSegment = null; |
| } |
| |
| if ( currentSegment == null ) |
| { |
| currentSegment = new TaskSegment(); |
| } |
| |
| currentSegment.add( task ); |
| } |
| else |
| { |
| MojoDescriptor mojo = null; |
| try |
| { |
| // definitely a CLI goal, can use prefix |
| mojo = getMojoDescriptor( task, session, project, task, true, false ); |
| } |
| catch ( PluginNotFoundException e ) |
| { |
| // TODO: shouldn't hit this, investigate using the same resolution logic as otheres for plugins in the reactor |
| getLogger().info( |
| "Cannot find mojo descriptor for: \'" + task + "\' - Treating as non-aggregator." ); |
| getLogger().debug( "", e ); |
| } |
| |
| // if the mojo descriptor was found, determine aggregator status according to: |
| // 1. whether the mojo declares itself an aggregator |
| // 2. whether the mojo DOES NOT require a project to function (implicitly avoid reactor) |
| if ( mojo != null && ( mojo.isAggregator() || !mojo.isProjectRequired() ) ) |
| { |
| if ( currentSegment != null && !currentSegment.aggregate() ) |
| { |
| segments.add( currentSegment ); |
| currentSegment = null; |
| } |
| |
| if ( currentSegment == null ) |
| { |
| currentSegment = new TaskSegment( true ); |
| } |
| |
| currentSegment.add( task ); |
| } |
| else |
| { |
| if ( currentSegment != null && currentSegment.aggregate() ) |
| { |
| segments.add( currentSegment ); |
| currentSegment = null; |
| } |
| |
| if ( currentSegment == null ) |
| { |
| currentSegment = new TaskSegment(); |
| } |
| |
| currentSegment.add( task ); |
| } |
| } |
| } |
| |
| segments.add( currentSegment ); |
| } |
| else |
| { |
| TaskSegment segment = new TaskSegment( false ); |
| for ( Iterator i = tasks.iterator(); i.hasNext(); ) |
| { |
| segment.add( (String) i.next() ); |
| } |
| segments.add( segment ); |
| } |
| |
| return segments; |
| } |
| |
| private void executeGoal( final String task, final MavenSession session, final MavenProject project ) |
| throws LifecycleExecutionException, BuildFailureException |
| { |
| try |
| { |
| Stack forkEntryPoints = new Stack(); |
| if ( getPhaseToLifecycleMap().containsKey( task ) ) |
| { |
| Lifecycle lifecycle = getLifecycleForPhase( task ); |
| |
| // we have a lifecycle phase, so lets bind all the necessary goals |
| Map lifecycleMappings = constructLifecycleMappings( session, task, project, lifecycle ); |
| executeGoalWithLifecycle( task, forkEntryPoints, session, lifecycleMappings, project, lifecycle ); |
| } |
| else |
| { |
| executeStandaloneGoal( task, forkEntryPoints, session, project ); |
| } |
| } |
| catch ( PluginNotFoundException e ) |
| { |
| throw new BuildFailureException( "A required plugin was not found: " + e.getMessage(), e ); |
| } |
| } |
| |
| private void executeGoalWithLifecycle( final String task, final Stack forkEntryPoints, final MavenSession session, |
| final Map lifecycleMappings, final MavenProject project, final Lifecycle lifecycle ) |
| throws LifecycleExecutionException, BuildFailureException, PluginNotFoundException |
| { |
| List goals = processGoalChain( task, lifecycleMappings, lifecycle ); |
| |
| if ( !goals.isEmpty() ) |
| { |
| executeGoals( goals, forkEntryPoints, session, project ); |
| } |
| else |
| { |
| getLogger().info( "No goals needed for project - skipping" ); |
| } |
| } |
| |
| private void executeStandaloneGoal( final String task, final Stack forkEntryPoints, final MavenSession session, final MavenProject project ) |
| throws LifecycleExecutionException, BuildFailureException, PluginNotFoundException |
| { |
| // guaranteed to come from the CLI and not be part of a phase |
| MojoDescriptor mojoDescriptor = getMojoDescriptor( task, session, project, task, true, false ); |
| executeGoals( Collections.singletonList( new MojoExecution( mojoDescriptor, MojoExecution.CLI_EXECUTION_ID ) ), |
| forkEntryPoints, session, project ); |
| } |
| |
| private void executeGoals( final List goals, final Stack forkEntryPoints, final MavenSession session, final MavenProject project ) |
| throws LifecycleExecutionException, BuildFailureException, PluginNotFoundException |
| { |
| for ( Iterator i = goals.iterator(); i.hasNext(); ) |
| { |
| MojoExecution mojoExecution = (MojoExecution) i.next(); |
| |
| MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor(); |
| |
| PlexusConfiguration configuration = mojoDescriptor.getMojoConfiguration(); |
| boolean usesReactorProjects = mojoDescriptor.isAggregator() || usesSessionOrReactorProjects( configuration ); |
| |
| if ( usesReactorProjects ) |
| { |
| calculateAllConcreteStates( session ); |
| } |
| else |
| { |
| calculateConcreteState( project, session, true ); |
| } |
| |
| calculateConcreteConfiguration( mojoExecution, project, session ); |
| |
| List reportExecutions = null; |
| if ( mojoDescriptor.isRequiresReports() ) |
| { |
| reportExecutions = getReportExecutions( project, forkEntryPoints, mojoExecution, session ); |
| } |
| |
| boolean hasFork = false; |
| if ( mojoDescriptor.getExecutePhase() != null || mojoDescriptor.getExecuteGoal() != null ) |
| { |
| hasFork = true; |
| } |
| else if ( reportExecutions != null ) |
| { |
| for ( Iterator it = reportExecutions.iterator(); it.hasNext(); ) |
| { |
| MojoExecution reportExecution = (MojoExecution) it.next(); |
| MojoDescriptor reportDescriptor = reportExecution.getMojoDescriptor(); |
| if ( reportDescriptor.getExecutePhase() != null || reportDescriptor.getExecuteGoal() != null ) |
| { |
| hasFork = true; |
| } |
| } |
| } |
| |
| if ( hasFork ) |
| { |
| // NOTE: This must always happen, regardless of treatment of reactorProjects below, because |
| // if we're in a forked execution right now, the current project will itself be an execution project of |
| // something in the reactorProjects list, and won't have a next-stage executionProject created |
| // for it otherwise, which leaves the project == null for the upcoming forked execution. |
| createExecutionProject( project, session, true ); |
| |
| if ( usesReactorProjects ) |
| { |
| List reactorProjects = session.getSortedProjects(); |
| for ( Iterator it = reactorProjects.iterator(); it.hasNext(); ) |
| { |
| MavenProject reactorProject = (MavenProject) it.next(); |
| createExecutionProject( reactorProject, session, false ); |
| } |
| } |
| } |
| |
| if ( mojoDescriptor.getExecutePhase() != null || mojoDescriptor.getExecuteGoal() != null ) |
| { |
| forkEntryPoints.push( mojoDescriptor ); |
| |
| forkLifecycle( mojoDescriptor, forkEntryPoints, session, project, mojoExecution.getExecutionId() ); |
| |
| forkEntryPoints.pop(); |
| } |
| |
| if ( mojoDescriptor.isRequiresReports() ) |
| { |
| List reports = getReports( reportExecutions, project, mojoExecution, session ); |
| |
| mojoExecution.setReports( reports ); |
| |
| for ( Iterator j = mojoExecution.getForkedExecutions().iterator(); j.hasNext(); ) |
| { |
| MojoExecution forkedExecution = (MojoExecution) j.next(); |
| MojoDescriptor descriptor = forkedExecution.getMojoDescriptor(); |
| |
| if ( descriptor.getExecutePhase() != null ) |
| { |
| forkEntryPoints.push( descriptor ); |
| |
| forkLifecycle( descriptor, forkEntryPoints, session, project, forkedExecution.getExecutionId() ); |
| |
| forkEntryPoints.pop(); |
| } |
| } |
| } |
| |
| if ( hasFork ) |
| { |
| // NOTE: This must always happen, regardless of treatment of reactorProjects below, because |
| // if we're in a forked execution right now, the current project will itself be an execution project of |
| // something in the reactorProjects list, and may not have had its own executionProject instance reset to |
| // a concrete state again after the previous forked executions. |
| calculateConcreteState( project.getExecutionProject(), session, true ); |
| |
| // FIXME: Would be nice to find a way to cause the execution project to stay in a concrete state... |
| // TODO: Test this! It should be fixed, but I don't want to destabilize until I have the issue I'm working on fixed. |
| if ( usesReactorProjects ) |
| { |
| calculateAllConcreteStates( session ); |
| List reactorProjects = session.getSortedProjects(); |
| for ( Iterator it = reactorProjects.iterator(); it.hasNext(); ) |
| { |
| MavenProject reactorProject = (MavenProject) it.next(); |
| calculateConcreteState( reactorProject.getExecutionProject(), session, false ); |
| } |
| } |
| } |
| |
| try |
| { |
| pluginManager.executeMojo( project, mojoExecution, session ); |
| } |
| catch ( PluginManagerException e ) |
| { |
| throw new LifecycleExecutionException( "Internal error in the plugin manager executing goal '" + |
| mojoDescriptor.getId() + "': " + e.getMessage(), e ); |
| } |
| catch ( ArtifactNotFoundException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( InvalidDependencyVersionException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( ArtifactResolutionException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( MojoFailureException e ) |
| { |
| throw new BuildFailureException( e.getMessage(), e ); |
| } |
| catch ( MojoExecutionException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( PluginConfigurationException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| } |
| } |
| |
| private void createExecutionProject( final MavenProject project, final MavenSession session, final boolean processProjectReferences ) |
| throws LifecycleExecutionException |
| { |
| MavenProject executionProject = new MavenProject( project ); |
| |
| calculateConcreteState( executionProject, session, processProjectReferences ); |
| |
| project.setExecutionProject( executionProject ); |
| } |
| |
| private boolean usesSessionOrReactorProjects( final PlexusConfiguration configuration ) |
| { |
| String value = configuration != null ? String.valueOf( configuration ) : null; |
| |
| if ( value != null ) |
| { |
| if ( value.indexOf( "${session" ) > -1 || value.indexOf( "${reactorProjects}" ) > -1 ) |
| { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| private void calculateConcreteConfiguration( final MojoExecution mojoExecution, final MavenProject project, final MavenSession session ) |
| throws LifecycleExecutionException |
| { |
| if ( mojoExecution.getConfiguration() == null ) |
| { |
| return; |
| } |
| |
| try |
| { |
| mojoExecution.setConfiguration( (Xpp3Dom) configInterpolator.interpolate( |
| mojoExecution.getConfiguration(), |
| project, |
| session.getProjectBuilderConfiguration() ) ); |
| } |
| catch ( ConfigurationInterpolationException e ) |
| { |
| throw new LifecycleExecutionException( "Error interpolating configuration for: '" + mojoExecution.getMojoDescriptor().getRoleHint() + |
| "' (execution: '" + mojoExecution.getExecutionId() + "')", e ); |
| } |
| } |
| |
| private void calculateAllConcreteStates( final MavenSession session ) |
| throws LifecycleExecutionException |
| { |
| List projects = session.getSortedProjects(); |
| if ( projects != null ) |
| { |
| for ( Iterator it = projects.iterator(); it.hasNext(); ) |
| { |
| calculateConcreteState( (MavenProject) it.next(), session, false ); |
| } |
| } |
| } |
| |
| private void calculateConcreteState( final MavenProject project, final MavenSession session, final boolean processReferences ) |
| throws LifecycleExecutionException |
| { |
| if ( mavenProjectBuilder != null && project != null ) |
| { |
| try |
| { |
| mavenProjectBuilder.calculateConcreteState( project, session.getProjectBuilderConfiguration(), processReferences ); |
| } |
| catch ( ModelInterpolationException e ) |
| { |
| throw new LifecycleExecutionException( "Failed to calculate concrete state for project: " + project, |
| e ); |
| } |
| } |
| } |
| |
| // private void restoreAllDynamicStates( MavenSession session ) |
| // throws LifecycleExecutionException |
| // { |
| // List reactorProjects = session.getSortedProjects(); |
| // if ( reactorProjects != null ) |
| // { |
| // for ( Iterator it = reactorProjects.iterator(); it.hasNext(); ) |
| // { |
| // MavenProject project = (MavenProject) it.next(); |
| // restoreDynamicState( project, session, false ); |
| // } |
| // } |
| // } |
| // |
| // private void restoreDynamicState( MavenProject project, MavenSession session, boolean processReferences ) |
| // throws LifecycleExecutionException |
| // { |
| // try |
| // { |
| // mavenProjectBuilder.restoreDynamicState( project, session.getProjectBuilderConfiguration(), processReferences ); |
| // } |
| // catch ( ModelInterpolationException e ) |
| // { |
| // throw new LifecycleExecutionException( "Failed to restore dynamic state for project: " + project, e ); |
| // } |
| // } |
| |
| private List getReportExecutions( final MavenProject project, final Stack forkEntryPoints, final MojoExecution mojoExecution, final MavenSession session ) |
| throws LifecycleExecutionException, PluginNotFoundException |
| { |
| List reportPlugins = project.getReportPlugins(); |
| |
| if ( project.getModel().getReports() != null ) |
| { |
| getLogger().error( |
| "Plugin contains a <reports/> section: this is IGNORED - please use <reporting/> instead." ); |
| } |
| |
| if ( project.getReporting() == null || !project.getReporting().isExcludeDefaults() ) |
| { |
| if ( reportPlugins == null ) |
| { |
| reportPlugins = new ArrayList(); |
| } |
| else |
| { |
| reportPlugins = new ArrayList( reportPlugins ); |
| } |
| |
| for ( Iterator i = defaultReports.iterator(); i.hasNext(); ) |
| { |
| String report = (String) i.next(); |
| |
| StringTokenizer tok = new StringTokenizer( report, ":" ); |
| int count = tok.countTokens(); |
| if ( count != 2 && count != 3 ) |
| { |
| getLogger().warn( "Invalid default report ignored: '" + report + "' (must be groupId:artifactId[:version])" ); |
| } |
| else |
| { |
| String groupId = tok.nextToken(); |
| String artifactId = tok.nextToken(); |
| String version = tok.hasMoreTokens() ? tok.nextToken() : null; |
| |
| boolean found = false; |
| for ( Iterator j = reportPlugins.iterator(); j.hasNext() && !found; ) |
| { |
| ReportPlugin reportPlugin = (ReportPlugin) j.next(); |
| if ( reportPlugin.getGroupId().equals( groupId ) && |
| reportPlugin.getArtifactId().equals( artifactId ) ) |
| { |
| found = true; |
| } |
| } |
| |
| if ( !found ) |
| { |
| ReportPlugin reportPlugin = new ReportPlugin(); |
| reportPlugin.setGroupId( groupId ); |
| reportPlugin.setArtifactId( artifactId ); |
| reportPlugin.setVersion( version ); |
| reportPlugins.add( reportPlugin ); |
| } |
| } |
| } |
| } |
| |
| List reports = new ArrayList(); |
| if ( reportPlugins != null ) |
| { |
| for ( Iterator it = reportPlugins.iterator(); it.hasNext(); ) |
| { |
| ReportPlugin reportPlugin = (ReportPlugin) it.next(); |
| |
| List reportSets = reportPlugin.getReportSets(); |
| |
| if ( reportSets == null || reportSets.isEmpty() ) |
| { |
| reports.addAll( getReportExecutions( reportPlugin, forkEntryPoints, null, project, session, mojoExecution ) ); |
| } |
| else |
| { |
| for ( Iterator j = reportSets.iterator(); j.hasNext(); ) |
| { |
| ReportSet reportSet = (ReportSet) j.next(); |
| |
| reports.addAll( getReportExecutions( reportPlugin, forkEntryPoints, reportSet, project, session, mojoExecution ) ); |
| } |
| } |
| } |
| } |
| return reports; |
| } |
| |
| private List getReportExecutions( final ReportPlugin reportPlugin, |
| final Stack forkEntryPoints, |
| final ReportSet reportSet, |
| final MavenProject project, |
| final MavenSession session, |
| final MojoExecution mojoExecution ) |
| throws LifecycleExecutionException, PluginNotFoundException |
| { |
| PluginDescriptor pluginDescriptor = verifyReportPlugin( reportPlugin, project, session ); |
| |
| List reports = new ArrayList(); |
| for ( Iterator i = pluginDescriptor.getMojos().iterator(); i.hasNext(); ) |
| { |
| MojoDescriptor mojoDescriptor = (MojoDescriptor) i.next(); |
| if ( forkEntryPoints.contains( mojoDescriptor ) ) |
| { |
| getLogger().debug( "Omitting report: " + mojoDescriptor.getFullGoalName() + " from reports list. It initiated part of the fork currently executing." ); |
| continue; |
| } |
| |
| // TODO: check ID is correct for reports |
| // if the POM configured no reports, give all from plugin |
| if ( reportSet == null || reportSet.getReports().contains( mojoDescriptor.getGoal() ) ) |
| { |
| String id = null; |
| if ( reportSet != null ) |
| { |
| id = reportSet.getId(); |
| } |
| else |
| { |
| id = mojoExecution.getExecutionId(); |
| } |
| |
| MojoExecution reportExecution; |
| if ( id.startsWith( MojoExecution.DEFAULT_EXEC_ID_PREFIX ) ) |
| { |
| reportExecution = new MojoExecution( mojoDescriptor ); |
| } |
| else |
| { |
| reportExecution = new MojoExecution( mojoDescriptor, id ); |
| } |
| |
| reports.add( reportExecution ); |
| } |
| } |
| return reports; |
| } |
| |
| private List getReports( final List reportExecutions, final MavenProject project, final MojoExecution mojoExecution, final MavenSession session ) |
| throws LifecycleExecutionException |
| { |
| List reports = new ArrayList(); |
| |
| for ( Iterator it = reportExecutions.iterator(); it.hasNext(); ) |
| { |
| MojoExecution reportExecution = (MojoExecution) it.next(); |
| PluginDescriptor pluginDescriptor = reportExecution.getMojoDescriptor().getPluginDescriptor(); |
| |
| try |
| { |
| MavenReport reportMojo = pluginManager.getReport( project, reportExecution, session ); |
| |
| // Comes back null if it was a plugin, not a report - these are mojos in the reporting plugins that are not reports |
| if ( reportMojo != null ) |
| { |
| reports.add( reportMojo ); |
| mojoExecution.addMojoExecution( reportExecution ); |
| } |
| } |
| catch ( PluginManagerException e ) |
| { |
| throw new LifecycleExecutionException( |
| "Error getting reports from the plugin '" + pluginDescriptor.getId() + "': " + e.getMessage(), e ); |
| } |
| catch ( PluginConfigurationException e ) |
| { |
| throw new LifecycleExecutionException( |
| "Error getting reports from the plugin '" + pluginDescriptor.getId() + "'", e ); |
| } |
| catch ( ArtifactNotFoundException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( ArtifactResolutionException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| } |
| |
| return reports; |
| } |
| |
| private void forkLifecycle( final MojoDescriptor mojoDescriptor, final Stack ancestorLifecycleForkers, final MavenSession session, |
| final MavenProject project, final String executionId ) |
| throws LifecycleExecutionException, BuildFailureException, PluginNotFoundException |
| { |
| PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor(); |
| getLogger().info( "Preparing " + pluginDescriptor.getGoalPrefix() + ":" + mojoDescriptor.getGoal() ); |
| |
| if ( mojoDescriptor.isAggregator() ) |
| { |
| for ( Iterator i = session.getSortedProjects().iterator(); i.hasNext(); ) |
| { |
| MavenProject reactorProject = (MavenProject) i.next(); |
| |
| line(); |
| |
| getLogger().info( "Building " + reactorProject.getName() ); |
| |
| line(); |
| |
| forkProjectLifecycle( mojoDescriptor, ancestorLifecycleForkers, session, reactorProject, executionId ); |
| } |
| } |
| else |
| { |
| forkProjectLifecycle( mojoDescriptor, ancestorLifecycleForkers, session, project, executionId ); |
| } |
| } |
| |
| private void forkProjectLifecycle( final MojoDescriptor mojoDescriptor, final Stack forkEntryPoints, final MavenSession session, |
| MavenProject project, final String executionId ) |
| throws LifecycleExecutionException, BuildFailureException, PluginNotFoundException |
| { |
| project = project.getExecutionProject(); |
| |
| forkEntryPoints.push( mojoDescriptor ); |
| |
| PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor(); |
| |
| String targetPhase = mojoDescriptor.getExecutePhase(); |
| |
| Map lifecycleMappings = null; |
| if ( targetPhase != null ) |
| { |
| Lifecycle lifecycle = getLifecycleForPhase( targetPhase ); |
| |
| // Create new lifecycle |
| lifecycleMappings = constructLifecycleMappings( session, targetPhase, project, lifecycle ); |
| |
| String executeLifecycle = mojoDescriptor.getExecuteLifecycle(); |
| if ( executeLifecycle != null ) |
| { |
| org.apache.maven.plugin.lifecycle.Lifecycle lifecycleOverlay; |
| try |
| { |
| lifecycleOverlay = pluginDescriptor.getLifecycleMapping( executeLifecycle ); |
| } |
| catch ( IOException e ) |
| { |
| throw new LifecycleExecutionException( "Unable to read lifecycle mapping file: " + e.getMessage(), |
| e ); |
| } |
| catch ( XmlPullParserException e ) |
| { |
| throw new LifecycleExecutionException( "Unable to parse lifecycle mapping file: " + e.getMessage(), |
| e ); |
| } |
| |
| if ( lifecycleOverlay == null ) |
| { |
| throw new LifecycleExecutionException( "Lifecycle '" + executeLifecycle + "' not found in plugin" ); |
| } |
| |
| for ( Iterator i = lifecycleOverlay.getPhases().iterator(); i.hasNext(); ) |
| { |
| Phase phase = (Phase) i.next(); |
| for ( Iterator j = phase.getExecutions().iterator(); j.hasNext(); ) |
| { |
| Execution exec = (Execution) j.next(); |
| |
| for ( Iterator k = exec.getGoals().iterator(); k.hasNext(); ) |
| { |
| String goal = (String) k.next(); |
| |
| PluginDescriptor lifecyclePluginDescriptor; |
| String lifecycleGoal; |
| |
| // Here we are looking to see if we have a mojo from an external plugin. |
| // If we do then we need to lookup the plugin descriptor for the externally |
| // referenced plugin so that we can overly the execution into the lifecycle. |
| // An example of this is the corbertura plugin that needs to call the surefire |
| // plugin in forking mode. |
| // |
| //<phase> |
| // <id>test</id> |
| // <executions> |
| // <execution> |
| // <goals> |
| // <goal>org.apache.maven.plugins:maven-surefire-plugin:test</goal> |
| // </goals> |
| // <configuration> |
| // <classesDirectory>${project.build.directory}/generated-classes/cobertura</classesDirectory> |
| // <ignoreFailures>true</ignoreFailures> |
| // <forkMode>once</forkMode> |
| // </configuration> |
| // </execution> |
| // </executions> |
| //</phase> |
| |
| // ---------------------------------------------------------------------- |
| // |
| // ---------------------------------------------------------------------- |
| |
| if ( goal.indexOf( ":" ) > 0 ) |
| { |
| String[] s = StringUtils.split( goal, ":" ); |
| |
| String groupId = s[0]; |
| String artifactId = s[1]; |
| lifecycleGoal = s[2]; |
| |
| Plugin plugin = new Plugin(); |
| plugin.setGroupId( groupId ); |
| plugin.setArtifactId( artifactId ); |
| lifecyclePluginDescriptor = verifyPlugin( plugin, project, session ); |
| if ( lifecyclePluginDescriptor == null ) |
| { |
| throw new LifecycleExecutionException( |
| "Unable to find plugin " + groupId + ":" + artifactId ); |
| } |
| } |
| else |
| { |
| lifecyclePluginDescriptor = pluginDescriptor; |
| lifecycleGoal = goal; |
| } |
| |
| Xpp3Dom configuration = (Xpp3Dom) exec.getConfiguration(); |
| // NOTE: This seems to be duplicated below. Why?? |
| if ( phase.getConfiguration() != null ) |
| { |
| configuration = Xpp3Dom.mergeXpp3Dom( new Xpp3Dom( (Xpp3Dom) phase.getConfiguration() ), |
| configuration ); |
| } |
| |
| MojoDescriptor desc = getMojoDescriptor( lifecyclePluginDescriptor, lifecycleGoal ); |
| MojoExecution mojoExecution; |
| if ( executionId.startsWith( MojoExecution.DEFAULT_EXEC_ID_PREFIX ) ) |
| { |
| mojoExecution = new MojoExecution( desc, configuration ); |
| } |
| else |
| { |
| mojoExecution = new MojoExecution( desc, configuration, executionId ); |
| } |
| |
| addToLifecycleMappings( lifecycleMappings, phase.getId(), mojoExecution, |
| session.getSettings() ); |
| } |
| } |
| |
| if ( phase.getConfiguration() != null ) |
| { |
| // Merge in general configuration for a phase. |
| // TODO: this is all kind of backwards from the POMM. Let's align it all under 2.1. |
| // We should create a new lifecycle executor for modelVersion >5.0.0 |
| for ( Iterator j = lifecycleMappings.values().iterator(); j.hasNext(); ) |
| { |
| List tasks = (List) j.next(); |
| |
| for ( Iterator k = tasks.iterator(); k.hasNext(); ) |
| { |
| MojoExecution exec = (MojoExecution) k.next(); |
| |
| Xpp3Dom configuration = Xpp3Dom.mergeXpp3Dom( |
| new Xpp3Dom( (Xpp3Dom) phase.getConfiguration() ), exec.getConfiguration() ); |
| |
| exec.setConfiguration( configuration ); |
| } |
| } |
| } |
| |
| } |
| } |
| |
| removeFromLifecycle( forkEntryPoints, lifecycleMappings ); |
| } |
| |
| if ( targetPhase != null ) |
| { |
| Lifecycle lifecycle = getLifecycleForPhase( targetPhase ); |
| |
| executeGoalWithLifecycle( targetPhase, forkEntryPoints, session, lifecycleMappings, project, lifecycle ); |
| } |
| else |
| { |
| String goal = mojoDescriptor.getExecuteGoal(); |
| MojoDescriptor desc = getMojoDescriptor( pluginDescriptor, goal ); |
| executeGoals( Collections.singletonList( new MojoExecution( desc, goal ) ), forkEntryPoints, session, project ); |
| } |
| } |
| |
| private Lifecycle getLifecycleForPhase( final String phase ) |
| throws BuildFailureException, LifecycleExecutionException |
| { |
| Lifecycle lifecycle = (Lifecycle) getPhaseToLifecycleMap().get( phase ); |
| |
| if ( lifecycle == null ) |
| { |
| throw new BuildFailureException( "Unable to find lifecycle for phase '" + phase + "'" ); |
| } |
| return lifecycle; |
| } |
| |
| private MojoDescriptor getMojoDescriptor( final PluginDescriptor pluginDescriptor, final String goal ) |
| throws LifecycleExecutionException |
| { |
| MojoDescriptor desc = pluginDescriptor.getMojo( goal ); |
| |
| if ( desc == null ) |
| { |
| String message = |
| "Required goal '" + goal + "' not found in plugin '" + pluginDescriptor.getGoalPrefix() + "'"; |
| int index = goal.indexOf( ':' ); |
| if ( index >= 0 ) |
| { |
| String prefix = goal.substring( index + 1 ); |
| if ( prefix.equals( pluginDescriptor.getGoalPrefix() ) ) |
| { |
| message = message + " (goals should not be prefixed - try '" + prefix + "')"; |
| } |
| } |
| throw new LifecycleExecutionException( message ); |
| } |
| return desc; |
| } |
| |
| private void removeFromLifecycle( final Stack lifecycleForkers, final Map lifecycleMappings ) |
| { |
| for ( Iterator lifecycleIterator = lifecycleMappings.values().iterator(); lifecycleIterator.hasNext(); ) |
| { |
| List tasks = (List) lifecycleIterator.next(); |
| |
| for ( Iterator taskIterator = tasks.iterator(); taskIterator.hasNext(); ) |
| { |
| MojoExecution execution = (MojoExecution) taskIterator.next(); |
| |
| if ( lifecycleForkers.contains( execution.getMojoDescriptor() ) ) |
| { |
| taskIterator.remove(); |
| getLogger().warn( "Removing: " + execution.getMojoDescriptor().getGoal() |
| + " from forked lifecycle, to prevent recursive invocation." ); |
| } |
| } |
| } |
| } |
| |
| private Map constructLifecycleMappings( final MavenSession session, final String selectedPhase, final MavenProject project, |
| final Lifecycle lifecycle ) |
| throws LifecycleExecutionException, BuildFailureException, PluginNotFoundException |
| { |
| // first, bind those associated with the packaging |
| Map lifecycleMappings = bindLifecycleForPackaging( session, selectedPhase, project, lifecycle ); |
| |
| // next, loop over plugins and for any that have a phase, bind it |
| for ( Iterator i = project.getBuildPlugins().iterator(); i.hasNext(); ) |
| { |
| Plugin plugin = (Plugin) i.next(); |
| |
| bindPluginToLifecycle( plugin, session, lifecycleMappings, project ); |
| } |
| |
| return lifecycleMappings; |
| } |
| |
| private Map bindLifecycleForPackaging( final MavenSession session, final String selectedPhase, final MavenProject project, |
| final Lifecycle lifecycle ) |
| throws LifecycleExecutionException, BuildFailureException, PluginNotFoundException |
| { |
| Map mappings = findMappingsForLifecycle( session, project, lifecycle ); |
| |
| List optionalMojos = findOptionalMojosForLifecycle( session, project, lifecycle ); |
| |
| Map lifecycleMappings = new HashMap(); |
| |
| for ( Iterator i = lifecycle.getPhases().iterator(); i.hasNext(); ) |
| { |
| String phase = (String) i.next(); |
| |
| String phaseTasks = (String) mappings.get( phase ); |
| |
| if ( phaseTasks != null ) |
| { |
| for ( StringTokenizer tok = new StringTokenizer( phaseTasks, "," ); tok.hasMoreTokens(); ) |
| { |
| String goal = tok.nextToken().trim(); |
| |
| // Not from the CLI, don't use prefix |
| MojoDescriptor mojoDescriptor = getMojoDescriptor( goal, session, project, selectedPhase, false, |
| optionalMojos.contains( goal ) ); |
| |
| if ( mojoDescriptor == null ) |
| { |
| continue; |
| } |
| |
| if ( mojoDescriptor.isDirectInvocationOnly() ) |
| { |
| throw new LifecycleExecutionException( "Mojo: \'" + goal + |
| "\' requires direct invocation. It cannot be used as part of lifecycle: \'" + |
| project.getPackaging() + "\'." ); |
| } |
| |
| addToLifecycleMappings( lifecycleMappings, phase, new MojoExecution( mojoDescriptor ), |
| session.getSettings() ); |
| } |
| } |
| |
| if ( phase.equals( selectedPhase ) ) |
| { |
| break; |
| } |
| } |
| |
| return lifecycleMappings; |
| } |
| |
| private Map findMappingsForLifecycle( final MavenSession session, final MavenProject project, final Lifecycle lifecycle ) |
| throws LifecycleExecutionException, PluginNotFoundException |
| { |
| String packaging = project.getPackaging(); |
| Map mappings = null; |
| |
| LifecycleMapping m = (LifecycleMapping) findExtension( project, LifecycleMapping.ROLE, packaging, session ); |
| if ( m != null ) |
| { |
| mappings = m.getPhases( lifecycle.getId() ); |
| } |
| |
| Map defaultMappings = lifecycle.getDefaultPhases(); |
| |
| if ( mappings == null ) |
| { |
| try |
| { |
| m = (LifecycleMapping) session.lookup( LifecycleMapping.ROLE, packaging ); |
| mappings = m.getPhases( lifecycle.getId() ); |
| } |
| catch ( ComponentLookupException e ) |
| { |
| if ( defaultMappings == null ) |
| { |
| throw new LifecycleExecutionException( |
| "Cannot find lifecycle mapping for packaging: \'" + packaging + "\'.", e ); |
| } |
| } |
| } |
| |
| if ( mappings == null ) |
| { |
| if ( defaultMappings == null ) |
| { |
| throw new LifecycleExecutionException( |
| "Cannot find lifecycle mapping for packaging: \'" + packaging + "\', and there is no default" ); |
| } |
| else |
| { |
| mappings = defaultMappings; |
| } |
| } |
| |
| return mappings; |
| } |
| |
| private List findOptionalMojosForLifecycle( final MavenSession session, final MavenProject project, final Lifecycle lifecycle ) |
| throws LifecycleExecutionException, PluginNotFoundException |
| { |
| String packaging = project.getPackaging(); |
| List optionalMojos = null; |
| |
| LifecycleMapping m = (LifecycleMapping) findExtension( project, LifecycleMapping.ROLE, packaging, session ); |
| |
| if ( m != null ) |
| { |
| optionalMojos = m.getOptionalMojos( lifecycle.getId() ); |
| } |
| |
| if ( optionalMojos == null ) |
| { |
| try |
| { |
| m = (LifecycleMapping) session.lookup( LifecycleMapping.ROLE, packaging ); |
| optionalMojos = m.getOptionalMojos( lifecycle.getId() ); |
| } |
| catch ( ComponentLookupException e ) |
| { |
| getLogger().debug( "Error looking up lifecycle mapping to retrieve optional mojos. Lifecycle ID: " + |
| lifecycle.getId() + ". Error: " + e.getMessage(), e ); |
| } |
| } |
| |
| if ( optionalMojos == null ) |
| { |
| optionalMojos = Collections.EMPTY_LIST; |
| } |
| |
| return optionalMojos; |
| } |
| |
| private Object findExtension( final MavenProject project, final String role, final String roleHint, final MavenSession session ) |
| throws LifecycleExecutionException, PluginNotFoundException |
| { |
| Object pluginComponent = null; |
| |
| for ( Iterator i = project.getBuildPlugins().iterator(); i.hasNext() && pluginComponent == null; ) |
| { |
| Plugin plugin = (Plugin) i.next(); |
| |
| if ( plugin.isExtensions() ) |
| { |
| loadPluginFully( plugin, project, session ); |
| |
| // TODO: if moved to the plugin manager we already have the descriptor from above and so do can lookup the container directly |
| try |
| { |
| pluginComponent = pluginManager.getPluginComponent( plugin, role, roleHint ); |
| } |
| catch ( ComponentLookupException e ) |
| { |
| getLogger().debug( "Unable to find the lifecycle component in the extension", e ); |
| } |
| catch ( PluginManagerException e ) |
| { |
| throw new LifecycleExecutionException( |
| "Error getting extensions from the plugin '" + plugin.getKey() + "': " + e.getMessage(), e ); |
| } |
| } |
| } |
| return pluginComponent; |
| } |
| |
| /** |
| * @todo Not particularly happy about this. Would like WagonManager and ArtifactTypeHandlerManager to be able to |
| * lookup directly, or have them passed in |
| */ |
| private Map<String, ArtifactHandler> findArtifactTypeHandlersInPlugins( final MavenProject project, final MavenSession session ) |
| throws LifecycleExecutionException, PluginNotFoundException |
| { |
| Map<String, ArtifactHandler> map = new HashMap<String, ArtifactHandler>(); |
| for ( Iterator i = project.getBuildPlugins().iterator(); i.hasNext(); ) |
| { |
| Plugin plugin = (Plugin) i.next(); |
| |
| if ( plugin.isExtensions() ) |
| { |
| loadPluginFully( plugin, project, session ); |
| |
| // TODO: if moved to the plugin manager we already have the descriptor from above and so do can lookup the container directly |
| try |
| { |
| Map components = pluginManager.getPluginComponents( plugin, ArtifactHandler.ROLE ); |
| map.putAll( components ); |
| } |
| catch ( ComponentLookupException e ) |
| { |
| getLogger().debug( "Unable to find the lifecycle component in the extension", e ); |
| } |
| catch ( PluginManagerException e ) |
| { |
| throw new LifecycleExecutionException( "Error looking up available components from plugin '" + |
| plugin.getKey() + "': " + e.getMessage(), e ); |
| } |
| } |
| } |
| return map; |
| } |
| |
| /** |
| * Take each mojo contained with a plugin, look to see whether it contributes to a |
| * phase in the lifecycle and if it does place it at the end of the list of goals |
| * to execute for that given phase. |
| * |
| * @param project |
| * @param session |
| */ |
| private void bindPluginToLifecycle( final Plugin plugin, final MavenSession session, final Map phaseMap, final MavenProject project ) |
| throws LifecycleExecutionException, PluginNotFoundException |
| { |
| Settings settings = session.getSettings(); |
| |
| PluginDescriptor pluginDescriptor = |
| verifyPlugin( plugin, project, session ); |
| |
| if ( pluginDescriptor.getMojos() != null && !pluginDescriptor.getMojos().isEmpty() ) |
| { |
| // use the plugin if inherit was true in a base class, or it is in the current POM, otherwise use the default inheritence setting |
| if ( plugin.isInheritanceApplied() || pluginDescriptor.isInheritedByDefault() ) |
| { |
| if ( plugin.getGoals() != null ) |
| { |
| getLogger().error( |
| "Plugin contains a <goals/> section: this is IGNORED - please use <executions/> instead." ); |
| } |
| |
| List executions = plugin.getExecutions(); |
| |
| if ( executions != null ) |
| { |
| for ( Iterator it = executions.iterator(); it.hasNext(); ) |
| { |
| PluginExecution execution = (PluginExecution) it.next(); |
| |
| bindExecutionToLifecycle( pluginDescriptor, phaseMap, execution, settings ); |
| } |
| } |
| } |
| } |
| } |
| |
| private PluginDescriptor verifyPlugin( final Plugin plugin, final MavenProject project, final MavenSession session ) |
| throws LifecycleExecutionException, PluginNotFoundException |
| { |
| PluginDescriptor pluginDescriptor; |
| try |
| { |
| // TODO: MNG-4081...need to flush this plugin once we look at it, to avoid using an external |
| // version of a plugin when a newer version will be created in the current reactor... |
| pluginDescriptor = pluginManager.loadPluginDescriptor( plugin, project, session ); |
| } |
| catch ( PluginManagerException e ) |
| { |
| throw new LifecycleExecutionException( |
| "Internal error in the plugin manager getting plugin '" + plugin.getKey() + "': " + e.getMessage(), e ); |
| } |
| catch ( PluginVersionResolutionException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( InvalidVersionSpecificationException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( InvalidPluginException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( ArtifactNotFoundException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( ArtifactResolutionException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( PluginVersionNotFoundException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| return pluginDescriptor; |
| } |
| |
| private PluginDescriptor loadPluginFully( final Plugin plugin, final MavenProject project, final MavenSession session ) |
| throws LifecycleExecutionException, PluginNotFoundException |
| { |
| PluginDescriptor pluginDescriptor; |
| try |
| { |
| // TODO: MNG-4081...need to flush this plugin once we look at it, to avoid using an external |
| // version of a plugin when a newer version will be created in the current reactor... |
| pluginDescriptor = pluginManager.loadPluginFully( plugin, project, session ); |
| } |
| catch ( PluginManagerException e ) |
| { |
| throw new LifecycleExecutionException( |
| "Internal error in the plugin manager getting plugin '" + plugin.getKey() + "': " + e.getMessage(), e ); |
| } |
| catch ( PluginVersionResolutionException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( InvalidVersionSpecificationException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( InvalidPluginException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( ArtifactNotFoundException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( ArtifactResolutionException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( PluginVersionNotFoundException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| return pluginDescriptor; |
| } |
| |
| private PluginDescriptor verifyReportPlugin( final ReportPlugin plugin, final MavenProject project, final MavenSession session ) |
| throws LifecycleExecutionException, PluginNotFoundException |
| { |
| PluginDescriptor pluginDescriptor; |
| try |
| { |
| pluginDescriptor = pluginManager.verifyReportPlugin( plugin, project, session ); |
| } |
| catch ( PluginManagerException e ) |
| { |
| throw new LifecycleExecutionException( |
| "Internal error in the plugin manager getting report '" + plugin.getKey() + "': " + e.getMessage(), e ); |
| } |
| catch ( PluginVersionResolutionException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( InvalidVersionSpecificationException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( InvalidPluginException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( ArtifactNotFoundException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( ArtifactResolutionException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| catch ( PluginVersionNotFoundException e ) |
| { |
| throw new LifecycleExecutionException( e.getMessage(), e ); |
| } |
| return pluginDescriptor; |
| } |
| |
| private void bindExecutionToLifecycle( final PluginDescriptor pluginDescriptor, final Map phaseMap, final PluginExecution execution, |
| final Settings settings ) |
| throws LifecycleExecutionException |
| { |
| for ( Iterator i = execution.getGoals().iterator(); i.hasNext(); ) |
| { |
| String goal = (String) i.next(); |
| |
| MojoDescriptor mojoDescriptor = pluginDescriptor.getMojo( goal ); |
| if ( mojoDescriptor == null ) |
| { |
| throw new LifecycleExecutionException( |
| "'" + goal + "' was specified in an execution, but not found in the plugin" ); |
| } |
| |
| // We have to check to see that the inheritance rules have been applied before binding this mojo. |
| if ( execution.isInheritanceApplied() || mojoDescriptor.isInheritedByDefault() ) |
| { |
| MojoExecution mojoExecution = new MojoExecution( mojoDescriptor, execution.getId() ); |
| |
| String phase = execution.getPhase(); |
| |
| if ( phase == null ) |
| { |
| // if the phase was not in the configuration, use the phase in the descriptor |
| phase = mojoDescriptor.getPhase(); |
| } |
| |
| if ( phase != null ) |
| { |
| if ( mojoDescriptor.isDirectInvocationOnly() ) |
| { |
| throw new LifecycleExecutionException( "Mojo: \'" + goal + |
| "\' requires direct invocation. It cannot be used as part of the lifecycle (it was included via the POM)." ); |
| } |
| |
| addToLifecycleMappings( phaseMap, phase, mojoExecution, settings ); |
| } |
| } |
| } |
| } |
| |
| private void addToLifecycleMappings( final Map lifecycleMappings, final String phase, final MojoExecution mojoExecution, |
| final Settings settings ) |
| { |
| List goals = (List) lifecycleMappings.get( phase ); |
| |
| if ( goals == null ) |
| { |
| goals = new ArrayList(); |
| lifecycleMappings.put( phase, goals ); |
| } |
| |
| MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor(); |
| if ( settings.isOffline() && mojoDescriptor.isOnlineRequired() ) |
| { |
| String goal = mojoDescriptor.getGoal(); |
| getLogger().warn( goal + " requires online mode, but maven is currently offline. Disabling " + goal + "." ); |
| } |
| else |
| { |
| goals.add( mojoExecution ); |
| } |
| } |
| |
| private List processGoalChain( final String task, final Map phaseMap, final Lifecycle lifecycle ) |
| { |
| List goals = new ArrayList(); |
| |
| // only execute up to the given phase |
| int index = lifecycle.getPhases().indexOf( task ); |
| |
| for ( int i = 0; i <= index; i++ ) |
| { |
| String p = (String) lifecycle.getPhases().get( i ); |
| |
| List phaseGoals = (List) phaseMap.get( p ); |
| |
| if ( phaseGoals != null ) |
| { |
| goals.addAll( phaseGoals ); |
| } |
| } |
| return goals; |
| } |
| |
| private MojoDescriptor getMojoDescriptor( final String task, final MavenSession session, final MavenProject project, |
| final String invokedVia, final boolean canUsePrefix, final boolean isOptionalMojo ) |
| throws BuildFailureException, LifecycleExecutionException, PluginNotFoundException |
| { |
| String goal; |
| Plugin plugin = null; |
| |
| PluginDescriptor pluginDescriptor = null; |
| |
| try |
| { |
| StringTokenizer tok = new StringTokenizer( task, ":" ); |
| int numTokens = tok.countTokens(); |
| |
| if ( numTokens == 2 ) |
| { |
| if ( !canUsePrefix ) |
| { |
| String msg = "Mapped-prefix lookup of mojos are only supported from direct invocation. " + |
| "Please use specification of the form groupId:artifactId[:version]:goal instead. " + |
| "(Offending mojo: \'" + task + "\', invoked via: \'" + invokedVia + "\')"; |
| throw new LifecycleExecutionException( msg ); |
| } |
| |
| String prefix = tok.nextToken(); |
| goal = tok.nextToken(); |
| |
| // Steps for retrieving the plugin model instance: |
| // 1. request directly from the plugin collector by prefix |
| pluginDescriptor = pluginManager.getPluginDescriptorForPrefix( prefix ); |
| if ( pluginDescriptor != null ) |
| { |
| plugin = new Plugin(); |
| plugin.setGroupId( pluginDescriptor.getGroupId() ); |
| plugin.setArtifactId( pluginDescriptor.getArtifactId() ); |
| plugin.setVersion( pluginDescriptor.getVersion() ); |
| } |
| |
| // 2. search plugins in the current POM |
| if ( plugin == null ) |
| { |
| for ( Iterator i = project.getBuildPlugins().iterator(); i.hasNext(); ) |
| { |
| Plugin buildPlugin = (Plugin) i.next(); |
| |
| PluginDescriptor desc = |
| verifyPlugin( buildPlugin, project, session ); |
| if ( prefix.equals( desc.getGoalPrefix() ) ) |
| { |
| plugin = buildPlugin; |
| pluginDescriptor = desc; |
| break; |
| } |
| } |
| } |
| |
| // 3. look in the repository via search groups |
| if ( plugin == null ) |
| { |
| plugin = pluginManager.getPluginDefinitionForPrefix( prefix, session, project ); |
| } |
| |
| // 4. default to o.a.m.plugins and maven-<prefix>-plugin |
| if ( plugin == null ) |
| { |
| plugin = new Plugin(); |
| plugin.setGroupId( PluginDescriptor.getDefaultPluginGroupId() ); |
| plugin.setArtifactId( PluginDescriptor.getDefaultPluginArtifactId( prefix ) ); |
| } |
| } |
| else if ( numTokens == 3 || numTokens == 4 ) |
| { |
| plugin = new Plugin(); |
| |
| plugin.setGroupId( tok.nextToken() ); |
| plugin.setArtifactId( tok.nextToken() ); |
| |
| if ( numTokens == 4 ) |
| { |
| plugin.setVersion( tok.nextToken() ); |
| } |
| |
| goal = tok.nextToken(); |
| } |
| else |
| { |
| String message = "Invalid task '" + task + "': you must specify a valid lifecycle phase, or" + |
| " a goal in the format plugin:goal or pluginGroupId:pluginArtifactId:pluginVersion:goal"; |
| throw new BuildFailureException( message ); |
| } |
| |
| if ( plugin.getVersion() == null ) |
| { |
| for ( Iterator i = project.getBuildPlugins().iterator(); i.hasNext(); ) |
| { |
| Plugin buildPlugin = (Plugin) i.next(); |
| |
| if ( buildPlugin.getKey().equals( plugin.getKey() ) ) |
| { |
| plugin = buildPlugin; |
| break; |
| } |
| } |
| |
| project.injectPluginManagementInfo( plugin ); |
| } |
| |
| if ( pluginDescriptor == null ) |
| { |
| pluginDescriptor = verifyPlugin( plugin, project, session ); |
| } |
| |
| // this has been simplified from the old code that injected the plugin management stuff, since |
| // pluginManagement injection is now handled by the project method. |
| project.addPlugin( plugin ); |
| |
| MojoDescriptor mojoDescriptor = pluginDescriptor.getMojo( goal ); |
| if ( mojoDescriptor == null ) |
| { |
| if ( isOptionalMojo ) |
| { |
| getLogger().info( "Skipping missing optional mojo: " + task ); |
| } |
| else |
| { |
| throw new BuildFailureException( "Required goal not found: " + task + " in " |
| + pluginDescriptor.getId() ); |
| } |
| } |
| |
| return mojoDescriptor; |
| } |
| catch ( PluginNotFoundException e ) |
| { |
| if ( isOptionalMojo ) |
| { |
| getLogger().info( "Skipping missing optional mojo: " + task ); |
| getLogger().debug( "Mojo: " + task + " could not be found. Reason: " + e.getMessage(), e ); |
| } |
| else |
| { |
| throw e; |
| } |
| } |
| |
| return null; |
| } |
| |
| protected void line() |
| { |
| getLogger().info( "------------------------------------------------------------------------" ); |
| } |
| |
| public Map getPhaseToLifecycleMap() |
| throws LifecycleExecutionException |
| { |
| if ( phaseToLifecycleMap == null ) |
| { |
| phaseToLifecycleMap = new HashMap(); |
| |
| for ( Iterator i = lifecycles.iterator(); i.hasNext(); ) |
| { |
| Lifecycle lifecycle = (Lifecycle) i.next(); |
| |
| for ( Iterator p = lifecycle.getPhases().iterator(); p.hasNext(); ) |
| { |
| String phase = (String) p.next(); |
| |
| if ( phaseToLifecycleMap.containsKey( phase ) ) |
| { |
| Lifecycle prevLifecycle = (Lifecycle) phaseToLifecycleMap.get( phase ); |
| throw new LifecycleExecutionException( "Phase '" + phase + |
| "' is defined in more than one lifecycle: '" + lifecycle.getId() + "' and '" + |
| prevLifecycle.getId() + "'" ); |
| } |
| else |
| { |
| phaseToLifecycleMap.put( phase, lifecycle ); |
| } |
| } |
| } |
| } |
| return phaseToLifecycleMap; |
| } |
| |
| private static class TaskSegment |
| { |
| private boolean aggregate; |
| |
| private final List tasks = new ArrayList(); |
| |
| TaskSegment() |
| { |
| |
| } |
| |
| TaskSegment( final boolean aggregate ) |
| { |
| this.aggregate = aggregate; |
| } |
| |
| public String toString() |
| { |
| StringBuffer message = new StringBuffer(); |
| |
| message.append( " task-segment: [" ); |
| |
| for ( Iterator it = tasks.iterator(); it.hasNext(); ) |
| { |
| String task = (String) it.next(); |
| |
| message.append( task ); |
| |
| if ( it.hasNext() ) |
| { |
| message.append( ", " ); |
| } |
| } |
| |
| message.append( "]" ); |
| |
| if ( aggregate ) |
| { |
| message.append( " (aggregator-style)" ); |
| } |
| |
| return message.toString(); |
| } |
| |
| boolean aggregate() |
| { |
| return aggregate; |
| } |
| |
| void add( final String task ) |
| { |
| tasks.add( task ); |
| } |
| |
| List getTasks() |
| { |
| return tasks; |
| } |
| } |
| |
| public List getLifecycles() |
| { |
| return lifecycles; |
| } |
| |
| // ------------------------------------------------------------------------- |
| // TODO: The methods and fields below are only needed for products like Hudson, |
| // that provide their own LifecycleExecutor and component configuration that extend |
| // default implementation, and which may become out-of-date as component requirements |
| // are updated within Maven itself. |
| public void initialize() |
| throws InitializationException |
| { |
| if ( mavenProjectBuilder == null ) |
| { |
| warnOfIncompleteComponentConfiguration( MavenProjectBuilder.ROLE ); |
| try |
| { |
| mavenProjectBuilder = (MavenProjectBuilder) container.lookup( MavenProjectBuilder.ROLE ); |
| } |
| catch ( ComponentLookupException e ) |
| { |
| throw new InitializationException( "Failed to lookup project builder after it was NOT injected via component requirement." ); |
| } |
| } |
| |
| if ( modelInterpolator == null ) |
| { |
| warnOfIncompleteComponentConfiguration( ModelInterpolator.ROLE ); |
| try |
| { |
| modelInterpolator = (ModelInterpolator) container.lookup( ModelInterpolator.ROLE ); |
| } |
| catch ( ComponentLookupException e ) |
| { |
| throw new InitializationException( "Failed to lookup model interpolator after it was NOT injected via component requirement." ); |
| } |
| } |
| |
| if ( configInterpolator == null ) |
| { |
| warnOfIncompleteComponentConfiguration( ConfigurationInterpolator.ROLE ); |
| try |
| { |
| configInterpolator = (ConfigurationInterpolator) container.lookup( ConfigurationInterpolator.ROLE ); |
| } |
| catch ( ComponentLookupException e ) |
| { |
| throw new InitializationException( "Failed to lookup plugin-configuration interpolator after it was NOT injected via component requirement." ); |
| } |
| } |
| } |
| |
| private void warnOfIncompleteComponentConfiguration( final String role ) |
| { |
| StringBuffer buffer = new StringBuffer(); |
| buffer.append( "\n************ WARNING ************" ); |
| buffer.append( "\n\nThis Maven runtime contains a LifecycleExecutor component with an incomplete configuration." ); |
| buffer.append( "\n\nLifecycleExecutor class: " ).append( getClass().getName() ); |
| buffer.append( "\nMissing component requirement: " ).append( role ); |
| buffer.append( "\n" ); |
| buffer.append( "\nNOTE: This seems to be a third-party Maven derivative you are using. If so, please" ); |
| buffer.append( "\nnotify the developers for this derivative project of the problem. The Apache Maven team is not" ); |
| buffer.append( "\nresponsible for maintaining the integrity of third-party component overrides." ); |
| buffer.append( "\n\n" ); |
| |
| getLogger().warn( buffer.toString() ); |
| } |
| |
| private PlexusContainer container; |
| |
| public void contextualize( final Context context ) |
| throws ContextException |
| { |
| container = (PlexusContainer) context.get( PlexusConstants.PLEXUS_KEY ); |
| } |
| } |
