[MNG-7429] The classloader containing build extension should be used throughout the build

maven-core/src/main/java/org/apache/maven/DefaultMaven.java

@@ -23,9 +23,7 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.Date;
-import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
@@ -51,6 +49,8 @@
 import org.apache.maven.repository.LocalRepositoryNotAccessibleException;
 import org.apache.maven.session.scope.internal.SessionScope;
 import org.codehaus.plexus.PlexusContainer;
+import org.codehaus.plexus.classworlds.realm.ClassRealm;
+import org.codehaus.plexus.classworlds.realm.DuplicateRealmException;
 import org.codehaus.plexus.component.annotations.Component;
 import org.codehaus.plexus.component.annotations.Requirement;
 import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
@@ -202,12 +202,7 @@ private MavenExecutionResult doExecute( MavenExecutionRequest request, MavenSess
     {
         try
         {
-            // CHECKSTYLE_OFF: LineLength
-            for ( AbstractMavenLifecycleParticipant listener : getLifecycleParticipants( Collections.<MavenProject>emptyList() ) )
-            {
-                listener.afterSessionStart( session );
-            }
-            // CHECKSTYLE_ON: LineLength
+            callListeners( session, AbstractMavenLifecycleParticipant::afterSessionStart );
         }
         catch ( MavenExecutionException e )
         {
@@ -232,6 +227,32 @@ private MavenExecutionResult doExecute( MavenExecutionRequest request, MavenSess
             return addExceptionToResult( result, e );
         }
 
+
+        ClassLoader tccl = Thread.currentThread().getContextClassLoader();
+        try
+        {
+            ClassRealm lookupRealm = setupBuildExtensions( session );
+            Thread.currentThread().setContextClassLoader( lookupRealm );
+            container.setLookupRealm( lookupRealm );
+
+            return doExecute2( request, result, session, repoSession );
+        }
+        catch ( DuplicateRealmException e )
+        {
+            return addExceptionToResult( result, e );
+        }
+        finally
+        {
+            Thread.currentThread().setContextClassLoader( tccl );
+        }
+    }
+
+    private MavenExecutionResult doExecute2( MavenExecutionRequest request,
+                                             MavenExecutionResult result,
+                                             MavenSession session,
+                                             DefaultRepositorySystemSession repoSession )
+    {
+        Result<? extends ProjectDependencyGraph> graphResult;
         try
         {
             setupWorkspaceReader( session, repoSession );
@@ -243,24 +264,14 @@ private MavenExecutionResult doExecute( MavenExecutionRequest request, MavenSess
 
         repoSession.setReadOnly();
 
-        ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
         try
         {
-            for ( AbstractMavenLifecycleParticipant listener : getLifecycleParticipants( session.getProjects() ) )
-            {
-                Thread.currentThread().setContextClassLoader( listener.getClass().getClassLoader() );
-
-                listener.afterProjectsRead( session );
-            }
+            callListeners( session, AbstractMavenLifecycleParticipant::afterProjectsRead );
         }
         catch ( MavenExecutionException e )
         {
             return addExceptionToResult( result, e );
         }
-        finally
-        {
-            Thread.currentThread().setContextClassLoader( originalClassLoader );
-        }
 
         //
         // The projects need to be topologically after the participants have run their afterProjectsRead(session)
@@ -313,10 +324,59 @@ private MavenExecutionResult doExecute( MavenExecutionRequest request, MavenSess
                 return addExceptionToResult( result, e );
             }
         }
-
         return result;
     }
 
+    @FunctionalInterface
+    interface ListenerMethod
+    {
+        void run( AbstractMavenLifecycleParticipant listener, MavenSession session ) throws MavenExecutionException;
+    }
+
+    private void callListeners( MavenSession session, ListenerMethod method ) throws MavenExecutionException
+    {
+        ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
+        try
+        {
+            for ( AbstractMavenLifecycleParticipant listener : getLifecycleParticipants( session.getProjects() ) )
+            {
+                Thread.currentThread().setContextClassLoader( listener.getClass().getClassLoader() );
+
+                method.run( listener, session );
+            }
+        }
+        finally
+        {
+            Thread.currentThread().setContextClassLoader( originalClassLoader );
+        }
+    }
+
+    private ClassRealm setupBuildExtensions( MavenSession session ) throws DuplicateRealmException
+    {
+        List<ClassRealm> buildExtensionsRealms = new ArrayList<>();
+        for ( MavenProject project : session.getProjects() )
+        {
+            ClassRealm realm = project.getClassRealm();
+            if ( realm != null )
+            {
+                buildExtensionsRealms.add( realm );
+            }
+        }
+        if ( !buildExtensionsRealms.isEmpty() )
+        {
+            ClassRealm extRealm = container.createChildRealm( "session.ext" );
+            for ( ClassRealm realm : buildExtensionsRealms )
+            {
+                extRealm.importFrom( realm, realm.getId() );
+            }
+            return extRealm;
+        }
+        else
+        {
+            return container.getContainerRealm();
+        }
+    }
+
     private void setupWorkspaceReader( MavenSession session, DefaultRepositorySystemSession repoSession )
         throws ComponentLookupException
     {
@@ -331,8 +391,7 @@ private void setupWorkspaceReader( MavenSession session, DefaultRepositorySystem
             workspaceReaders.add( repoWorkspaceReader );
         }
         // 3) .. n) Project-scoped workspace readers
-        for ( WorkspaceReader workspaceReader : getProjectScopedExtensionComponents( session.getProjects(),
-                                                                                     WorkspaceReader.class ) )
+        for ( WorkspaceReader workspaceReader : container.lookupList( WorkspaceReader.class ) )
         {
             if ( workspaceReaders.contains( workspaceReader ) )
             {
@@ -342,26 +401,12 @@ private void setupWorkspaceReader( MavenSession session, DefaultRepositorySystem
         }
         WorkspaceReader[] readers = workspaceReaders.toArray( new WorkspaceReader[0] );
         repoSession.setWorkspaceReader( new ChainedWorkspaceReader( readers ) );
-
     }
 
     private void afterSessionEnd( Collection<MavenProject> projects, MavenSession session )
         throws MavenExecutionException
     {
-        ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
-        try
-        {
-            for ( AbstractMavenLifecycleParticipant listener : getLifecycleParticipants( projects ) )
-            {
-                Thread.currentThread().setContextClassLoader( listener.getClass().getClassLoader() );
-
-                listener.afterSessionEnd( session );
-            }
-        }
-        finally
-        {
-            Thread.currentThread().setContextClassLoader( originalClassLoader );
-        }
+        callListeners( session, AbstractMavenLifecycleParticipant::afterSessionEnd );
     }
 
     public RepositorySystemSession newRepositorySession( MavenExecutionRequest request )
@@ -398,49 +443,9 @@ private Collection<AbstractMavenLifecycleParticipant> getLifecycleParticipants(
             logger.warn( "Failed to lookup lifecycle participants: " + e.getMessage() );
         }
 
-        lifecycleListeners.addAll( getProjectScopedExtensionComponents( projects,
-                                                                        AbstractMavenLifecycleParticipant.class ) );
-
         return lifecycleListeners;
     }
 
-    protected <T> Collection<T> getProjectScopedExtensionComponents( Collection<MavenProject> projects, Class<T> role )
-    {
-
-        Collection<T> foundComponents = new LinkedHashSet<>();
-        Collection<ClassLoader> scannedRealms = new HashSet<>();
-
-        Thread currentThread = Thread.currentThread();
-        ClassLoader originalContextClassLoader = currentThread.getContextClassLoader();
-        try
-        {
-            for ( MavenProject project : projects )
-            {
-                ClassLoader projectRealm = project.getClassRealm();
-
-                if ( projectRealm != null && scannedRealms.add( projectRealm ) )
-                {
-                    currentThread.setContextClassLoader( projectRealm );
-
-                    try
-                    {
-                        foundComponents.addAll( container.lookupList( role ) );
-                    }
-                    catch ( ComponentLookupException e )
-                    {
-                        // this is just silly, lookupList should return an empty list!
-                        logger.warn( "Failed to lookup " + role + ": " + e.getMessage() );
-                    }
-                }
-            }
-            return foundComponents;
-        }
-        finally
-        {
-            currentThread.setContextClassLoader( originalContextClassLoader );
-        }
-    }
-
     private MavenExecutionResult addExceptionToResult( MavenExecutionResult result, Throwable e )
     {
         if ( !result.getExceptions().contains( e ) )

maven-core/src/main/java/org/apache/maven/lifecycle/internal/BuildListCalculator.java

@@ -20,7 +20,6 @@
  */
 
 import org.apache.maven.execution.MavenSession;
-import org.apache.maven.lifecycle.internal.builder.BuilderCommon;
 import org.apache.maven.project.MavenProject;
 import org.codehaus.plexus.component.annotations.Component;
 
@@ -57,18 +56,9 @@ public ProjectBuildList calculateProjectBuilds( MavenSession session, List<TaskS
             }
             for ( MavenProject project : projects )
             {
-                ClassLoader tccl = Thread.currentThread().getContextClassLoader();
-                try
-                {
-                    BuilderCommon.attachToThread( project ); // Not totally sure if this is needed for anything
-                    MavenSession copiedSession = session.clone();
-                    copiedSession.setCurrentProject( project );
-                    projectBuilds.add( new ProjectSegment( project, taskSegment, copiedSession ) );
-                }
-                finally
-                {
-                    Thread.currentThread().setContextClassLoader( tccl );
-                }
+                MavenSession copiedSession = session.clone();
+                copiedSession.setCurrentProject( project );
+                projectBuilds.add( new ProjectSegment( project, taskSegment, copiedSession ) );
             }
         }
         return new ProjectBuildList( projectBuilds );

maven-core/src/main/java/org/apache/maven/lifecycle/internal/ExecutionPlanItem.java

@@ -19,7 +19,6 @@
  * under the License.
  */
 
-import org.apache.maven.lifecycle.internal.builder.BuilderCommon;
 import org.apache.maven.model.Plugin;
 import org.apache.maven.plugin.MojoExecution;
 import org.apache.maven.plugin.descriptor.MojoDescriptor;
@@ -49,8 +48,6 @@ public ExecutionPlanItem( MojoExecution mojoExecution )
     public static List<ExecutionPlanItem> createExecutionPlanItems( MavenProject mavenProject,
                                                                     List<MojoExecution> executions )
     {
-        BuilderCommon.attachToThread( mavenProject );
-
         List<ExecutionPlanItem> result = new ArrayList<>();
         for ( MojoExecution mojoExecution : executions )
         {

maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleModuleBuilder.java

@@ -105,8 +105,6 @@ public void buildProject( MavenSession session, MavenSession rootSession, Reacto
                 return;
             }
 
-            BuilderCommon.attachToThread( currentProject );
-
             projectExecutionListener.beforeProjectExecution( new ProjectExecutionEvent( session, currentProject ) );
 
             eventCatapult.fire( ExecutionEvent.Type.ProjectStarted, session, null );
@@ -155,8 +153,6 @@ public void buildProject( MavenSession session, MavenSession rootSession, Reacto
             }
 
             session.setCurrentProject( null );
-
-            Thread.currentThread().setContextClassLoader( reactorContext.getOriginalContextClassLoader() );
         }
     }
 }

maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleStarter.java

@@ -104,10 +104,8 @@ public void execute( MavenSession session )
                 lifecycleDebugLogger.debugReactorPlan( projectBuilds );
             }
 
-            ClassLoader oldContextClassLoader = Thread.currentThread().getContextClassLoader();
             ReactorBuildStatus reactorBuildStatus = new ReactorBuildStatus( session.getProjectDependencyGraph() );
-            reactorContext =
-                new ReactorContext( result, projectIndex, oldContextClassLoader, reactorBuildStatus );
+            reactorContext = new ReactorContext( result, projectIndex, reactorBuildStatus );
 
             String builderId = session.getRequest().getBuilderId();
             Builder builder = builders.get( builderId );

maven-core/src/main/java/org/apache/maven/lifecycle/internal/MojoExecutor.java

@@ -19,6 +19,11 @@
  * under the License.
  */
 
+import javax.inject.Inject;
+import javax.inject.Named;
+import javax.inject.Provider;
+import javax.inject.Singleton;
+
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
 import org.apache.maven.artifact.resolver.filter.CumulativeScopeArtifactFilter;
@@ -38,8 +43,6 @@
 import org.apache.maven.plugin.PluginManagerException;
 import org.apache.maven.plugin.descriptor.MojoDescriptor;
 import org.apache.maven.project.MavenProject;
-import org.codehaus.plexus.component.annotations.Component;
-import org.codehaus.plexus.component.annotations.Requirement;
 import org.codehaus.plexus.util.StringUtils;
 import org.eclipse.aether.SessionData;
 
@@ -69,26 +72,27 @@
  * @author Kristian Rosenvold
  * @since 3.0
  */
-@Component( role = MojoExecutor.class )
+@Named
+@Singleton
 public class MojoExecutor
 {
 
-    @Requirement
+    @Inject
     private BuildPluginManager pluginManager;
 
-    @Requirement
+    @Inject
     private MavenPluginManager mavenPluginManager;
 
-    @Requirement
+    @Inject
     private LifecycleDependencyResolver lifeCycleDependencyResolver;
 
-    @Requirement
+    @Inject
     private ExecutionEventCatapult eventCatapult;
 
     private final ReadWriteLock aggregatorLock = new ReentrantReadWriteLock();
 
-    @Requirement
-    private MojosExecutionStrategy mojosExecutionStrategy;
+    @Inject
+    private Provider<MojosExecutionStrategy> mojosExecutionStrategy;
 
     public MojoExecutor()
     {
@@ -159,7 +163,9 @@ public void execute( final MavenSession session,
 
         final PhaseRecorder phaseRecorder = new PhaseRecorder( session.getCurrentProject() );
 
-        mojosExecutionStrategy.execute( mojoExecutions, session, new MojoExecutionRunner()
+        final MojosExecutionStrategy strategy = mojosExecutionStrategy.get();
+
+        strategy.execute( mojoExecutions, session, new MojoExecutionRunner()
         {
             @Override
             public void run( MojoExecution mojoExecution ) throws LifecycleExecutionException