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

 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.repository.ArtifactRepository;

 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;

 /**

  * @author <a href="mailto:jason@maven.org">Jason van Zyl</a>

  * @author <a href="mailto:brett@apache.org">Brett Porter</a>

  * @version $Id: DefaultLifecycleExecutor.java 783173 2009-06-10 01:31:06Z jdcasey $

  * @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( MavenSession session, ReactorManager rm, 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( MavenSession session )

         throws LifecycleExecutionException

     {

         // TODO: MNG-4081. What about extensions within the current reactor??

         for ( Iterator i = session.getSortedProjects().iterator(); i.hasNext(); )

         {

             MavenProject project = (MavenProject) i.next();

             for ( Iterator j = project.getBuildExtensions().iterator(); j.hasNext(); )

             {

                 Extension extension = (Extension) j.next();

                 try

                 {

                     getLogger().debug( "Adding extension: " + extension );

                     extensionManager.addExtension( extension, project, session.getLocalRepository() );

                 }

                 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();

             try

             {

                 Map handlers = findArtifactTypeHandlers( project, session.getSettings(), session.getLocalRepository() );

                 artifactHandlerManager.addHandlers( handlers );

             }

             catch ( PluginNotFoundException e )

             {

                 throw new LifecycleExecutionException( e.getMessage(), e );

             }

         }

     }

     private void executeTaskSegments( List taskSegments, ReactorManager rm, MavenSession session,

                                       MavenProject rootProject, 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( String task, MavenSession session, MavenProject project,

                                                EventDispatcher dispatcher, String event, ReactorManager rm,

                                                long buildStartTime, 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( ReactorManager rm, MavenProject project, Exception e, String task,

                                             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( List tasks, MavenSession session, 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( String task, MavenSession session, 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( String task, Stack forkEntryPoints, MavenSession session,

                                            Map lifecycleMappings, MavenProject project, 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( String task, Stack forkEntryPoints, MavenSession session, 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( List goals, Stack forkEntryPoints, MavenSession session, 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( MavenProject project, MavenSession session, boolean processProjectReferences )

         throws LifecycleExecutionException

     {

         MavenProject executionProject = new MavenProject( project );

         calculateConcreteState( executionProject, session, processProjectReferences );

         project.setExecutionProject( executionProject );

     }

     private boolean usesSessionOrReactorProjects( 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( MojoExecution mojoExecution, MavenProject project, 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( 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( MavenProject project, MavenSession session, 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( MavenProject project, Stack forkEntryPoints, MojoExecution mojoExecution, 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( ReportPlugin reportPlugin,

                              Stack forkEntryPoints,

                              ReportSet reportSet,

                              MavenProject project,

                              MavenSession session,

                              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( List reportExecutions, MavenProject project, MojoExecution mojoExecution, 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( MojoDescriptor mojoDescriptor, Stack ancestorLifecycleForkers, MavenSession session,

                                 MavenProject project, 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( MojoDescriptor mojoDescriptor, Stack forkEntryPoints, MavenSession session,

                                        MavenProject project, 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.getSettings(),

                                                                           session.getLocalRepository() );

                                 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( 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( PluginDescriptor pluginDescriptor, 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( Stack lifecycleForkers, 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( MavenSession session, String selectedPhase, MavenProject project,

                                             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( MavenSession session, String selectedPhase, MavenProject project,

                                            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() + "\'." );

                     }