package org.apache.maven.lifecycle.internal;
   
   /*
    * 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.execution.ExecutionEvent;
  import org.apache.maven.execution.MavenExecutionRequest;
  import org.apache.maven.execution.MavenExecutionResult;
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.lifecycle.DefaultLifecycles;
  import org.apache.maven.lifecycle.MissingProjectException;
  import org.apache.maven.lifecycle.NoGoalSpecifiedException;
  import org.codehaus.plexus.component.annotations.Component;
  import org.codehaus.plexus.component.annotations.Requirement;
  import org.codehaus.plexus.logging.Logger;
  
  import java.util.List;
  import java.util.concurrent.CompletionService;
  import java.util.concurrent.ExecutorCompletionService;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.TimeUnit;
  
  /**
   * Starts the build life cycle
   * @author Jason van Zyl
   * @author Benjamin Bentmann
   * @author Kristian Rosenvold
   */
  @Component( role = LifecycleStarter.class )
  public class LifecycleStarter
  {
  
      @Requirement
      private ExecutionEventCatapult eventCatapult;
  
      @Requirement
      private DefaultLifecycles defaultLifeCycles;
  
      @Requirement
      private Logger logger;
  
      @Requirement
      private LifecycleModuleBuilder lifecycleModuleBuilder;
  
      @Requirement
      private LifecycleWeaveBuilder lifeCycleWeaveBuilder;
  
      @Requirement
      private LifecycleThreadedBuilder lifecycleThreadedBuilder;
  
      @Requirement
      private BuildListCalculator buildListCalculator;
  
      @Requirement
      private LifecycleDebugLogger lifecycleDebugLogger;
  
      @Requirement
      private LifecycleTaskSegmentCalculator lifecycleTaskSegmentCalculator;
  
      @Requirement
      private ThreadConfigurationService threadConfigService;
  
      public void execute( MavenSession session )
      {
          eventCatapult.fire( ExecutionEvent.Type.SessionStarted, session, null );
  
          MavenExecutionResult result = session.getResult();
  
          try
          {
              if ( !session.isUsingPOMsFromFilesystem() && lifecycleTaskSegmentCalculator.requiresProject( session ) )
              {
                  throw new MissingProjectException( "The goal you specified requires a project to execute"
                      + " but there is no POM in this directory (" + session.getExecutionRootDirectory() + ")."
                      + " Please verify you invoked Maven from the correct directory." );
              }
  
              final MavenExecutionRequest executionRequest = session.getRequest();
              boolean isThreaded = executionRequest.isThreadConfigurationPresent();
              session.setParallel( isThreaded );
  
              List<TaskSegment> taskSegments = lifecycleTaskSegmentCalculator.calculateTaskSegments( session );
  
             ProjectBuildList projectBuilds = buildListCalculator.calculateProjectBuilds( session, taskSegments );
 
             if ( projectBuilds.isEmpty() )
             {
                 throw new NoGoalSpecifiedException( "No goals have been specified for this build."
                     + " You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or"
                     + " <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>."
                     + " Available lifecycle phases are: " + defaultLifeCycles.getLifecyclePhaseList() + "." );
             }
 
             ProjectIndex projectIndex = new ProjectIndex( session.getProjects() );
 
             if ( logger.isDebugEnabled() )
             {
                 lifecycleDebugLogger.debugReactorPlan( projectBuilds );
             }
 
             ClassLoader oldContextClassLoader = Thread.currentThread().getContextClassLoader();
 
             ReactorBuildStatus reactorBuildStatus = new ReactorBuildStatus( session.getProjectDependencyGraph() );
             ReactorContext callableContext =
                 new ReactorContext( result, projectIndex, oldContextClassLoader, reactorBuildStatus );
 
             if ( isThreaded )
             {
                 ExecutorService executor =
                     threadConfigService.getExecutorService( executionRequest.getThreadCount(),
                                                             executionRequest.isPerCoreThreadCount(),
                                                             session.getProjects().size() );
                 try
                 {
 
                     final boolean isWeaveMode = LifecycleWeaveBuilder.isWeaveMode( executionRequest );
                     if ( isWeaveMode )
                     {
                         lifecycleDebugLogger.logWeavePlan( session );
                         lifeCycleWeaveBuilder.build( projectBuilds, callableContext, taskSegments, session, executor,
                                                      reactorBuildStatus );
                     }
                     else
                     {
                         ConcurrencyDependencyGraph analyzer =
                             new ConcurrencyDependencyGraph( projectBuilds, session.getProjectDependencyGraph() );
 
                         CompletionService<ProjectSegment> service =
                             new ExecutorCompletionService<ProjectSegment>( executor );
 
                         lifecycleThreadedBuilder.build( session, callableContext, projectBuilds, taskSegments, analyzer,
                                                         service );
                     }
                 }
                 finally
                 {
                     executor.shutdown();
                     // If the builder has terminated with an exception we want to catch any stray threads before going
                     // to System.exit in the mavencli.
                     executor.awaitTermination( 5, TimeUnit.SECONDS ) ;
                 }
             }
             else
             {
                 singleThreadedBuild( session, callableContext, projectBuilds, taskSegments, reactorBuildStatus );
             }
 
         }
         catch ( Exception e )
         {
             result.addException( e );
         }
 
         eventCatapult.fire( ExecutionEvent.Type.SessionEnded, session, null );
     }
 
     private void singleThreadedBuild( MavenSession session, ReactorContext callableContext,
                                       ProjectBuildList projectBuilds, List<TaskSegment> taskSegments,
                                       ReactorBuildStatus reactorBuildStatus )
     {
         for ( TaskSegment taskSegment : taskSegments )
         {
             for ( ProjectSegment projectBuild : projectBuilds.getByTaskSegment( taskSegment ) )
             {
                 try
                 {
                     lifecycleModuleBuilder.buildProject( session, callableContext, projectBuild.getProject(),
                                                          taskSegment );
                     if ( reactorBuildStatus.isHalted() )
                     {
                         break;
                     }
                 }
                 catch ( Exception e )
                 {
                     break;  // Why are we just ignoring this exception? Are exceptions are being used for flow control
                 }
 
             }
         }
     }
 }