package org.apache.maven.extension;
/*
* 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.MavenArtifactFilterManager;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.ArtifactUtils;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.manager.WagonManager;
import org.apache.maven.artifact.metadata.ArtifactMetadataRetrievalException;
import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
import org.apache.maven.artifact.metadata.ResolutionGroup;
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.resolver.ArtifactResolutionResult;
import org.apache.maven.artifact.resolver.ArtifactResolver;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.model.Extension;
import org.apache.maven.plugin.DefaultPluginManager;
import org.apache.maven.project.MavenProject;
import org.apache.maven.wagon.Wagon;
import org.codehaus.classworlds.ClassRealm;
import org.codehaus.classworlds.ClassWorld;
import org.codehaus.classworlds.DuplicateRealmException;
import org.codehaus.classworlds.NoSuchRealmException;
import org.codehaus.plexus.DefaultPlexusContainer;
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.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.util.xml.Xpp3Dom;
import org.codehaus.plexus.util.xml.Xpp3DomBuilder;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import java.util.jar.JarFile;
/**
* Used to locate extensions.
*
* @author <a href="mailto:brett@apache.org">Brett Porter</a>
* @author Jason van Zyl
* @version $Id: DefaultExtensionManager.java 770474 2009-04-30 22:30:10Z jdcasey $
*/
public class DefaultExtensionManager
extends AbstractLogEnabled
implements ExtensionManager, Contextualizable
{
private ArtifactResolver artifactResolver;
private ArtifactFactory artifactFactory;
private ArtifactMetadataSource artifactMetadataSource;
private DefaultPlexusContainer container;
private ArtifactFilter artifactFilter = MavenArtifactFilterManager.createExtensionFilter();
private WagonManager wagonManager;
private PlexusContainer extensionContainer;
private static final String CONTAINER_NAME = "extensions";
public void addExtension( Extension extension,
MavenProject project,
ArtifactRepository localRepository )
throws ArtifactResolutionException, PlexusContainerException, ArtifactNotFoundException
{
String extensionId = ArtifactUtils.versionlessKey( extension.getGroupId(), extension.getArtifactId() );
getLogger().debug( "Initialising extension: " + extensionId );
Artifact artifact = (Artifact) project.getExtensionArtifactMap().get( extensionId );
if ( artifact != null )
{
ArtifactFilter filter = new ProjectArtifactExceptionFilter( artifactFilter, project.getArtifact() );
ResolutionGroup resolutionGroup;
try
{
resolutionGroup = artifactMetadataSource.retrieve( artifact, localRepository,
project.getRemoteArtifactRepositories() );
}
catch ( ArtifactMetadataRetrievalException e )
{
throw new ArtifactResolutionException( "Unable to download metadata from repository for plugin '" +
artifact.getId() + "': " + e.getMessage(), artifact, e );
}
// We use the same hack here to make sure that plexus 1.1 is available for extensions that do
// not declare plexus-utils but need it. MNG-2900
Set rgArtifacts = resolutionGroup.getArtifacts();
rgArtifacts = DefaultPluginManager.checkPlexusUtils( rgArtifacts, artifactFactory );
Set dependencies = new LinkedHashSet();
dependencies.add( artifact );
dependencies.addAll( rgArtifacts );
// Make sure that we do not influence the dependenecy resolution of extensions with the project's
// dependencyManagement
ArtifactResolutionResult result = artifactResolver.resolveTransitively( dependencies, project.getArtifact(),
Collections.EMPTY_MAP,
//project.getManagedVersionMap(),
localRepository,
project.getRemoteArtifactRepositories(),
artifactMetadataSource, filter );
// gross hack for some backwards compat (MNG-2749)
// if it is a lone artifact, then we assume it to be a resource package, and put it in the main container
// as before. If it has dependencies, that's when we risk conflict and exile to the child container
// jvz: we have to make this 2 because plexus is always added now.
Set artifacts = result.getArtifacts();
// Lifecycles are loaded by the Lifecycle executor by looking up lifecycle definitions from the
// core container. So we need to look if an extension has a lifecycle mapping and use the container
// and not an extension container. (MNG-2831)
if ( extensionContainsLifeycle( artifact.getFile() ) )
{
for ( Iterator i = artifacts.iterator(); i.hasNext(); )
{
Artifact a = (Artifact) i.next();
if ( artifactFilter.include( a ) )
{
getLogger().debug( "Adding extension to core container: " + a.getFile() );
container.addJarResource( a.getFile() );
}
}
}
else if ( artifacts.size() == 2 )
{
for ( Iterator i = artifacts.iterator(); i.hasNext(); )
{
Artifact a = (Artifact) i.next();
if ( !a.getArtifactId().equals( "plexus-utils" ) )
{
a = project.replaceWithActiveArtifact( a );
getLogger().debug( "Adding extension to core container: " + a.getFile() );
container.addJarResource( a.getFile() );
}
}
}
else
{
// create a child container for the extension
// TODO: this could surely be simpler/different on trunk with the new classworlds
if ( extensionContainer == null )
{
extensionContainer = createContainer();
}
for ( Iterator i = result.getArtifacts().iterator(); i.hasNext(); )
{
Artifact a = (Artifact) i.next();
a = project.replaceWithActiveArtifact( a );
getLogger().debug( "Adding to extension classpath: " + a.getFile() );
extensionContainer.addJarResource( a.getFile() );
}
if ( getLogger().isDebugEnabled() )
{
getLogger().debug( "Extension container contents:" );
extensionContainer.getContainerRealm().display();
}
}
}
}
private PlexusContainer createContainer()
throws PlexusContainerException
{
DefaultPlexusContainer child = new DefaultPlexusContainer();
ClassWorld classWorld = container.getClassWorld();
child.setClassWorld( classWorld );
ClassRealm childRealm = null;
// note: ideally extensions would live in their own realm, but this would mean that things like wagon-scm would
// have no way to obtain SCM extensions
String childRealmId = "plexus.core.child-container[" + CONTAINER_NAME + "]";
try
{
childRealm = classWorld.getRealm( childRealmId );
}
catch ( NoSuchRealmException e )
{
try
{
childRealm = classWorld.newRealm( childRealmId );
}
catch ( DuplicateRealmException impossibleError )
{
getLogger().error( "An impossible error has occurred. After getRealm() failed, newRealm() " +
"produced duplication error on same id!", impossibleError );
}
}
childRealm.setParent( container.getContainerRealm() );
child.setCoreRealm( childRealm );
child.setName( CONTAINER_NAME );
// This is what we are skipping - we use the parent realm, but not the parent container since otherwise
// we won't reload component descriptors that already exist in there
// child.setParentPlexusContainer( this );
// ----------------------------------------------------------------------
// Set all the child elements from the parent that were set
// programmatically.
// ----------------------------------------------------------------------
child.setLoggerManager( container.getLoggerManager() );
child.initialize();
child.start();
return child;
}
public void registerWagons()
{
if ( extensionContainer != null )
{
try
{
Map wagons = extensionContainer.lookupMap( Wagon.ROLE );
getLogger().debug( "Wagons to register: " + wagons.keySet() );
wagonManager.registerWagons( wagons.keySet(), extensionContainer );
}
catch ( ComponentLookupException e )
{
// no wagons found in the extension
getLogger().debug( "No wagons found in the extensions or other internal error: " + e.getMessage(), e );
}
}
else
{
getLogger().debug( "Wagons could not be registered as the extension container was never created" );
}
}
public void contextualize( Context context )
throws ContextException
{
container = (DefaultPlexusContainer) context.get( PlexusConstants.PLEXUS_KEY );
}
private static final class ProjectArtifactExceptionFilter
implements ArtifactFilter
{
private ArtifactFilter passThroughFilter;
private String projectDependencyConflictId;
ProjectArtifactExceptionFilter( ArtifactFilter passThroughFilter,
Artifact projectArtifact )
{
this.passThroughFilter = passThroughFilter;
projectDependencyConflictId = projectArtifact.getDependencyConflictId();
}
public boolean include( Artifact artifact )
{
String depConflictId = artifact.getDependencyConflictId();
return projectDependencyConflictId.equals( depConflictId ) || passThroughFilter.include( artifact );
}
}
private boolean extensionContainsLifeycle( File extension )
{
JarFile f;
try
{
f = new JarFile( extension );
InputStream is = f.getInputStream( f.getEntry( "META-INF/plexus/components.xml" ) );
if ( is == null )
{
return false;
}
Xpp3Dom dom = Xpp3DomBuilder.build( new InputStreamReader( is ) );
Xpp3Dom[] components = dom.getChild( "components" ).getChildren( "component" );
for ( int i = 0; i < components.length; i++ )
{
if ( components[i].getChild( "role" ).getValue().equals( "org.apache.maven.lifecycle.mapping.LifecycleMapping" ) )
{
return true;
}
}
}
catch( Exception e )
{
// do nothing
}
return false;
}
}