maven-core/src/main/java/org/apache/maven/project/DefaultProjectBuildingHelper.java - maven - Git at Google

 package org.apache.maven.project;

 /*
  * 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.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import javax.inject.Inject;
 import javax.inject.Named;
 import javax.inject.Singleton;

 import org.apache.maven.RepositoryUtils;
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.artifact.InvalidRepositoryException;
 import org.apache.maven.artifact.repository.ArtifactRepository;
 import org.apache.maven.classrealm.ClassRealmManager;
 import org.apache.maven.model.Build;
 import org.apache.maven.model.Extension;
 import org.apache.maven.model.Model;
 import org.apache.maven.model.Plugin;
 import org.apache.maven.model.Repository;
 import org.apache.maven.plugin.ExtensionRealmCache;
 import org.apache.maven.plugin.MavenPluginManager;
 import org.apache.maven.plugin.PluginManagerException;
 import org.apache.maven.plugin.PluginResolutionException;
 import org.apache.maven.plugin.version.PluginVersionResolutionException;
 import org.apache.maven.repository.RepositorySystem;
 import org.codehaus.plexus.PlexusContainer;
 import org.codehaus.plexus.classworlds.realm.ClassRealm;
 import org.eclipse.aether.graph.DependencyFilter;
 import org.eclipse.aether.util.filter.ExclusionsDependencyFilter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 /**
  * Assists the project builder. <strong>Warning:</strong> This is an internal utility class that is only public for
  * technical reasons, it is not part of the public API. In particular, this class can be changed or deleted without
  * prior notice.
  *
  * @author Benjamin Bentmann
  */
 @Named
 @Singleton
 public class DefaultProjectBuildingHelper
     implements ProjectBuildingHelper
 {
     private final Logger logger = LoggerFactory.getLogger( getClass() );
     private final PlexusContainer container; // TODO not used? Then remove
     private final ClassRealmManager classRealmManager;
     private final ProjectRealmCache projectRealmCache;
     private final RepositorySystem repositorySystem;
     private final MavenPluginManager pluginManager;

     @Inject
     public DefaultProjectBuildingHelper(
             PlexusContainer container,
             ClassRealmManager classRealmManager,
             ProjectRealmCache projectRealmCache,
             RepositorySystem repositorySystem,
             MavenPluginManager pluginManager )
     {
         this.container = container;
         this.classRealmManager = classRealmManager;
         this.projectRealmCache = projectRealmCache;
         this.repositorySystem = repositorySystem;
         this.pluginManager = pluginManager;
     }

     public List<ArtifactRepository> createArtifactRepositories( List<Repository> pomRepositories,
                                                                 List<ArtifactRepository> externalRepositories,
                                                                 ProjectBuildingRequest request )
         throws InvalidRepositoryException
     {
         List<ArtifactRepository> internalRepositories = new ArrayList<>();

         for ( Repository repository : pomRepositories )
         {
             internalRepositories.add( repositorySystem.buildArtifactRepository( repository ) );
         }

         repositorySystem.injectMirror( request.getRepositorySession(), internalRepositories );

         repositorySystem.injectProxy( request.getRepositorySession(), internalRepositories );

         repositorySystem.injectAuthentication( request.getRepositorySession(), internalRepositories );

         List<ArtifactRepository> dominantRepositories;
         List<ArtifactRepository> recessiveRepositories;

         if ( ProjectBuildingRequest.RepositoryMerging.REQUEST_DOMINANT.equals( request.getRepositoryMerging() ) )
         {
             dominantRepositories = externalRepositories;
             recessiveRepositories = internalRepositories;
         }
         else
         {
             dominantRepositories = internalRepositories;
             recessiveRepositories = externalRepositories;
         }

         List<ArtifactRepository> artifactRepositories = new ArrayList<>();
         Collection<String> repoIds = new HashSet<>();

         if ( dominantRepositories != null )
         {
             for ( ArtifactRepository repository : dominantRepositories )
             {
                 repoIds.add( repository.getId() );
                 artifactRepositories.add( repository );
             }
         }

         if ( recessiveRepositories != null )
         {
             for ( ArtifactRepository repository : recessiveRepositories )
             {
                 if ( repoIds.add( repository.getId() ) )
                 {
                     artifactRepositories.add( repository );
                 }
             }
         }

         artifactRepositories = repositorySystem.getEffectiveRepositories( artifactRepositories );

         return artifactRepositories;
     }

     public synchronized ProjectRealmCache.CacheRecord createProjectRealm( MavenProject project, Model model,
                                                                           ProjectBuildingRequest request )
         throws PluginResolutionException, PluginVersionResolutionException, PluginManagerException
     {
         ClassRealm projectRealm;

         List<Plugin> extensionPlugins = new ArrayList<>();

         Build build = model.getBuild();

         if ( build != null )
         {
             for ( Extension extension : build.getExtensions() )
             {
                 Plugin plugin = new Plugin();
                 plugin.setGroupId( extension.getGroupId() );
                 plugin.setArtifactId( extension.getArtifactId() );
                 plugin.setVersion( extension.getVersion() );
                 extensionPlugins.add( plugin );
             }

             for ( Plugin plugin : build.getPlugins() )
             {
                 if ( plugin.isExtensions() )
                 {
                     extensionPlugins.add( plugin );
                 }
             }
         }

         if ( extensionPlugins.isEmpty() )
         {
             if ( logger.isDebugEnabled() )
             {
                 logger.debug( "Extension realms for project " + model.getId() + ": (none)" );
             }

             return new ProjectRealmCache.CacheRecord( null, null );
         }

         List<ClassRealm> extensionRealms = new ArrayList<>();

         Map<ClassRealm, List<String>> exportedPackages = new HashMap<>();

         Map<ClassRealm, List<String>> exportedArtifacts = new HashMap<>();

         List<Artifact> publicArtifacts = new ArrayList<>();

         for ( Plugin plugin : extensionPlugins )
         {
             ExtensionRealmCache.CacheRecord recordRealm =
                 pluginManager.setupExtensionsRealm( project, plugin, request.getRepositorySession() );

             final ClassRealm extensionRealm = recordRealm.getRealm();
             final ExtensionDescriptor extensionDescriptor = recordRealm.getDescriptor();
             final List<Artifact> artifacts = recordRealm.getArtifacts();

             extensionRealms.add( extensionRealm );
             if ( extensionDescriptor != null )
             {
                 exportedPackages.put( extensionRealm, extensionDescriptor.getExportedPackages() );
                 exportedArtifacts.put( extensionRealm, extensionDescriptor.getExportedArtifacts() );
             }

             if ( !plugin.isExtensions() && artifacts.size() == 1 && artifacts.get( 0 ).getFile() != null )
             {
                 /*
                  * This is purely for backward-compat with 2.x where <extensions> consisting of a single artifact where
                  * loaded into the core and hence available to plugins, in contrast to bigger extensions that were
                  * loaded into a dedicated realm which is invisible to plugins (MNG-2749).
                  */
                 publicArtifacts.addAll( artifacts );
             }
         }

         if ( logger.isDebugEnabled() )
         {
             logger.debug( "Extension realms for project " + model.getId() + ": " + extensionRealms );
         }

         ProjectRealmCache.Key projectRealmKey = projectRealmCache.createKey( extensionRealms );

         ProjectRealmCache.CacheRecord record = projectRealmCache.get( projectRealmKey );

         if ( record == null )
         {
             projectRealm = classRealmManager.createProjectRealm( model, toAetherArtifacts( publicArtifacts ) );

             Set<String> exclusions = new LinkedHashSet<>();

             for ( ClassRealm extensionRealm : extensionRealms )
             {
                 List<String> excludes = exportedArtifacts.get( extensionRealm );

                 if ( excludes != null )
                 {
                     exclusions.addAll( excludes );
                 }

                 List<String> exports = exportedPackages.get( extensionRealm );

                 if ( exports == null || exports.isEmpty() )
                 {
                     /*
                      * Most existing extensions don't define exported packages, i.e. no classes are to be exposed to
                      * plugins, yet the components provided by the extension (e.g. artifact handlers) must be
                      * accessible, i.e. we still must import the extension realm into the project realm.
                      */
                     exports = Arrays.asList( extensionRealm.getId() );
                 }

                 for ( String export : exports )
                 {
                     projectRealm.importFrom( extensionRealm, export );
                 }
             }

             DependencyFilter extensionArtifactFilter = null;
             if ( !exclusions.isEmpty() )
             {
                 extensionArtifactFilter = new ExclusionsDependencyFilter( exclusions );
             }

             record = projectRealmCache.put( projectRealmKey, projectRealm, extensionArtifactFilter );
         }

         projectRealmCache.register( project, projectRealmKey, record );

         return record;
     }

     public void selectProjectRealm( MavenProject project )
     {
         ClassLoader projectRealm = project.getClassRealm();

         if ( projectRealm == null )
         {
             projectRealm = classRealmManager.getCoreRealm();
         }

         Thread.currentThread().setContextClassLoader( projectRealm );
     }

     private List<org.eclipse.aether.artifact.Artifact> toAetherArtifacts( final List<Artifact> pluginArtifacts )
     {
         return new ArrayList<>( RepositoryUtils.toArtifacts( pluginArtifacts ) );
     }

 }
	package org.apache.maven.project;

	/*
	* 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.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.LinkedHashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import javax.inject.Inject;
	import javax.inject.Named;
	import javax.inject.Singleton;

	import org.apache.maven.RepositoryUtils;
	import org.apache.maven.artifact.Artifact;
	import org.apache.maven.artifact.InvalidRepositoryException;
	import org.apache.maven.artifact.repository.ArtifactRepository;
	import org.apache.maven.classrealm.ClassRealmManager;
	import org.apache.maven.model.Build;
	import org.apache.maven.model.Extension;
	import org.apache.maven.model.Model;
	import org.apache.maven.model.Plugin;
	import org.apache.maven.model.Repository;
	import org.apache.maven.plugin.ExtensionRealmCache;
	import org.apache.maven.plugin.MavenPluginManager;
	import org.apache.maven.plugin.PluginManagerException;
	import org.apache.maven.plugin.PluginResolutionException;
	import org.apache.maven.plugin.version.PluginVersionResolutionException;
	import org.apache.maven.repository.RepositorySystem;
	import org.codehaus.plexus.PlexusContainer;
	import org.codehaus.plexus.classworlds.realm.ClassRealm;
	import org.eclipse.aether.graph.DependencyFilter;
	import org.eclipse.aether.util.filter.ExclusionsDependencyFilter;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	/**
	* Assists the project builder. <strong>Warning:</strong> This is an internal utility class that is only public for
	* technical reasons, it is not part of the public API. In particular, this class can be changed or deleted without
	* prior notice.
	*
	* @author Benjamin Bentmann
	*/
	@Named
	@Singleton
	public class DefaultProjectBuildingHelper
	implements ProjectBuildingHelper
	{
	private final Logger logger = LoggerFactory.getLogger( getClass() );
	private final PlexusContainer container; // TODO not used? Then remove
	private final ClassRealmManager classRealmManager;
	private final ProjectRealmCache projectRealmCache;
	private final RepositorySystem repositorySystem;
	private final MavenPluginManager pluginManager;

	@Inject
	public DefaultProjectBuildingHelper(
	PlexusContainer container,
	ClassRealmManager classRealmManager,
	ProjectRealmCache projectRealmCache,
	RepositorySystem repositorySystem,
	MavenPluginManager pluginManager )
	{
	this.container = container;
	this.classRealmManager = classRealmManager;
	this.projectRealmCache = projectRealmCache;
	this.repositorySystem = repositorySystem;
	this.pluginManager = pluginManager;
	}

	public List<ArtifactRepository> createArtifactRepositories( List<Repository> pomRepositories,
	List<ArtifactRepository> externalRepositories,
	ProjectBuildingRequest request )
	throws InvalidRepositoryException
	{
	List<ArtifactRepository> internalRepositories = new ArrayList<>();

	for ( Repository repository : pomRepositories )
	{
	internalRepositories.add( repositorySystem.buildArtifactRepository( repository ) );
	}

	repositorySystem.injectMirror( request.getRepositorySession(), internalRepositories );

	repositorySystem.injectProxy( request.getRepositorySession(), internalRepositories );

	repositorySystem.injectAuthentication( request.getRepositorySession(), internalRepositories );

	List<ArtifactRepository> dominantRepositories;
	List<ArtifactRepository> recessiveRepositories;

	if ( ProjectBuildingRequest.RepositoryMerging.REQUEST_DOMINANT.equals( request.getRepositoryMerging() ) )
	{
	dominantRepositories = externalRepositories;
	recessiveRepositories = internalRepositories;
	}
	else
	{
	dominantRepositories = internalRepositories;
	recessiveRepositories = externalRepositories;
	}

	List<ArtifactRepository> artifactRepositories = new ArrayList<>();
	Collection<String> repoIds = new HashSet<>();

	if ( dominantRepositories != null )
	{
	for ( ArtifactRepository repository : dominantRepositories )
	{
	repoIds.add( repository.getId() );
	artifactRepositories.add( repository );
	}
	}

	if ( recessiveRepositories != null )
	{
	for ( ArtifactRepository repository : recessiveRepositories )
	{
	if ( repoIds.add( repository.getId() ) )
	{
	artifactRepositories.add( repository );
	}
	}
	}

	artifactRepositories = repositorySystem.getEffectiveRepositories( artifactRepositories );

	return artifactRepositories;
	}

	public synchronized ProjectRealmCache.CacheRecord createProjectRealm( MavenProject project, Model model,
	ProjectBuildingRequest request )
	throws PluginResolutionException, PluginVersionResolutionException, PluginManagerException
	{
	ClassRealm projectRealm;

	List<Plugin> extensionPlugins = new ArrayList<>();

	Build build = model.getBuild();

	if ( build != null )
	{
	for ( Extension extension : build.getExtensions() )
	{
	Plugin plugin = new Plugin();
	plugin.setGroupId( extension.getGroupId() );
	plugin.setArtifactId( extension.getArtifactId() );
	plugin.setVersion( extension.getVersion() );
	extensionPlugins.add( plugin );
	}

	for ( Plugin plugin : build.getPlugins() )
	{
	if ( plugin.isExtensions() )
	{
	extensionPlugins.add( plugin );
	}
	}
	}

	if ( extensionPlugins.isEmpty() )
	{
	if ( logger.isDebugEnabled() )
	{
	logger.debug( "Extension realms for project " + model.getId() + ": (none)" );
	}

	return new ProjectRealmCache.CacheRecord( null, null );
	}

	List<ClassRealm> extensionRealms = new ArrayList<>();

	Map<ClassRealm, List<String>> exportedPackages = new HashMap<>();

	Map<ClassRealm, List<String>> exportedArtifacts = new HashMap<>();

	List<Artifact> publicArtifacts = new ArrayList<>();

	for ( Plugin plugin : extensionPlugins )
	{
	ExtensionRealmCache.CacheRecord recordRealm =
	pluginManager.setupExtensionsRealm( project, plugin, request.getRepositorySession() );

	final ClassRealm extensionRealm = recordRealm.getRealm();
	final ExtensionDescriptor extensionDescriptor = recordRealm.getDescriptor();
	final List<Artifact> artifacts = recordRealm.getArtifacts();

	extensionRealms.add( extensionRealm );
	if ( extensionDescriptor != null )
	{
	exportedPackages.put( extensionRealm, extensionDescriptor.getExportedPackages() );
	exportedArtifacts.put( extensionRealm, extensionDescriptor.getExportedArtifacts() );
	}

	if ( !plugin.isExtensions() && artifacts.size() == 1 && artifacts.get( 0 ).getFile() != null )
	{
	/*
	* This is purely for backward-compat with 2.x where <extensions> consisting of a single artifact where
	* loaded into the core and hence available to plugins, in contrast to bigger extensions that were
	* loaded into a dedicated realm which is invisible to plugins (MNG-2749).
	*/
	publicArtifacts.addAll( artifacts );
	}
	}

	if ( logger.isDebugEnabled() )
	{
	logger.debug( "Extension realms for project " + model.getId() + ": " + extensionRealms );
	}

	ProjectRealmCache.Key projectRealmKey = projectRealmCache.createKey( extensionRealms );

	ProjectRealmCache.CacheRecord record = projectRealmCache.get( projectRealmKey );

	if ( record == null )
	{
	projectRealm = classRealmManager.createProjectRealm( model, toAetherArtifacts( publicArtifacts ) );

	Set<String> exclusions = new LinkedHashSet<>();

	for ( ClassRealm extensionRealm : extensionRealms )
	{
	List<String> excludes = exportedArtifacts.get( extensionRealm );

	if ( excludes != null )
	{
	exclusions.addAll( excludes );
	}

	List<String> exports = exportedPackages.get( extensionRealm );

	if ( exports == null \|\| exports.isEmpty() )
	{
	/*
	* Most existing extensions don't define exported packages, i.e. no classes are to be exposed to
	* plugins, yet the components provided by the extension (e.g. artifact handlers) must be
	* accessible, i.e. we still must import the extension realm into the project realm.
	*/
	exports = Arrays.asList( extensionRealm.getId() );
	}

	for ( String export : exports )
	{
	projectRealm.importFrom( extensionRealm, export );
	}
	}

	DependencyFilter extensionArtifactFilter = null;
	if ( !exclusions.isEmpty() )
	{
	extensionArtifactFilter = new ExclusionsDependencyFilter( exclusions );
	}

	record = projectRealmCache.put( projectRealmKey, projectRealm, extensionArtifactFilter );
	}

	projectRealmCache.register( project, projectRealmKey, record );

	return record;
	}

	public void selectProjectRealm( MavenProject project )
	{
	ClassLoader projectRealm = project.getClassRealm();

	if ( projectRealm == null )
	{
	projectRealm = classRealmManager.getCoreRealm();
	}

	Thread.currentThread().setContextClassLoader( projectRealm );
	}

	private List<org.eclipse.aether.artifact.Artifact> toAetherArtifacts( final List<Artifact> pluginArtifacts )
	{
	return new ArrayList<>( RepositoryUtils.toArtifacts( pluginArtifacts ) );
	}

	}