package org.apache.maven.shared.test.plugin;
/*
* 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.File;
import java.io.IOException;
import java.io.Reader;
import java.net.MalformedURLException;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.installer.ArtifactInstallationException;
import org.apache.maven.artifact.installer.ArtifactInstaller;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.repository.ArtifactRepositoryFactory;
import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout;
import org.apache.maven.execution.DefaultMavenExecutionRequest;
import org.apache.maven.execution.DefaultMavenExecutionResult;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.model.Model;
import org.apache.maven.model.Parent;
import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
import org.apache.maven.plugin.LegacySupport;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.artifact.ProjectArtifactMetadata;
import org.apache.maven.repository.internal.MavenRepositorySystemSession;
import org.apache.maven.settings.MavenSettingsBuilder;
import org.apache.maven.settings.Settings;
import org.codehaus.plexus.PlexusConstants;
import org.codehaus.plexus.PlexusContainer;
import org.codehaus.plexus.component.annotations.Component;
import org.codehaus.plexus.component.annotations.Requirement;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
import org.codehaus.plexus.context.Context;
import org.codehaus.plexus.context.ContextException;
import org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.ReaderFactory;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
/**
* Tools to access and manage Maven repositories for test builds, including construction of a local
* repository directory structure.
*
* <p>
* <b>WARNING:</b> Currently, the <code>createLocalRepositoryFromPlugin</code> method will not
* resolve parent POMs that exist <b>only</b> in your normal local repository, and are not reachable
* using the relativePath element. This may result in failed test builds, as one or more of the
* plugin's ancestor POMs cannot be resolved.
* </p>
*
* @author jdcasey
* @version $Id: RepositoryTool.java 1185951 2011-10-19 02:43:50Z ifedorenko $
*/
@Component( role = RepositoryTool.class )
public class RepositoryTool
implements Contextualizable
{
/** Plexus role */
public static final String ROLE = RepositoryTool.class.getName();
@Requirement
private ArtifactRepositoryFactory repositoryFactory;
@Requirement
private MavenSettingsBuilder settingsBuilder;
@Requirement
private ArtifactFactory artifactFactory;
@Requirement
private ArtifactInstaller artifactInstaller;
@Requirement
private LegacySupport legacySupport;
// contextualized.
private PlexusContainer container;
/**
* Lookup and return the location of the normal Maven local repository.
*
* @return the location of the normal Maven local repository.
* @throws TestToolsException if any
*/
public File findLocalRepositoryDirectory()
throws TestToolsException
{
String localRepo = System.getProperty( "maven.local.repo" );
if ( StringUtils.isNotEmpty( localRepo ) )
{
return new File( localRepo );
}
Settings settings;
try
{
DefaultMavenExecutionRequest request = new DefaultMavenExecutionRequest();
request.setUserSettingsFile( new File( System.getProperty( "user.home" ), ".m2/settings.xml" ) );
request.setGlobalSettingsFile( new File( System.getProperty( "maven.home" ), "conf/settings.xml" ) );
settings = settingsBuilder.buildSettings( request );
}
catch ( IOException e )
{
throw new TestToolsException( "Error building Maven settings.", e );
}
catch ( XmlPullParserException e )
{
throw new TestToolsException( "Error building Maven settings.", e );
}
if ( settings == null || settings.getLocalRepository() == null
|| settings.getLocalRepository().trim().length() < 1 )
{
return new File( System.getProperty( "user.home" ), ".m2/repository" );
}
return new File( settings.getLocalRepository() );
}
/**
* Construct an ArtifactRepository instance that refers to the normal Maven local repository.
*
* @return an ArtifactRepository instance
* @throws TestToolsException if any
*/
public ArtifactRepository createLocalArtifactRepositoryInstance()
throws TestToolsException
{
File localRepoDir = findLocalRepositoryDirectory();
return createLocalArtifactRepositoryInstance( localRepoDir );
}
/**
* Construct an ArtifactRepository instance that refers to the test-time Maven local repository.
*
* @param localRepositoryDirectory The location of the local repository to be used for test builds.
* @return an ArtifactRepository instance
* @throws TestToolsException if any
*/
public ArtifactRepository createLocalArtifactRepositoryInstance( File localRepositoryDirectory )
throws TestToolsException
{
ArtifactRepositoryLayout defaultLayout;
try
{
defaultLayout = (ArtifactRepositoryLayout) container.lookup( ArtifactRepositoryLayout.ROLE, "default" );
}
catch ( ComponentLookupException e )
{
throw new TestToolsException( "Error retrieving default repository layout.", e );
}
try
{
return repositoryFactory.createArtifactRepository( "local", localRepositoryDirectory.toURL()
.toExternalForm(), defaultLayout, null, null );
}
catch ( MalformedURLException e )
{
throw new TestToolsException( "Error converting local repo directory to a URL.", e );
}
}
/**
* Install a test version of a plugin - along with its POM, and as many ancestor POMs as can be
* reached using the <relativePath/> element - to a clean local repository directory for
* use in test builds.
*
* <p>
* <b>WARNING:</b> Currently, this method will not resolve parent POMs that exist <b>only</b> in
* your normal local repository, and are not reachable using the relativePath element. This may
* result in failed test builds, as one or more of the plugin's ancestor POMs cannot be resolved.
* </p>
*
* @param project
* @param realPomFile
* @param targetLocalRepoBasedir
* @throws TestToolsException if any
*/
public void createLocalRepositoryFromComponentProject( MavenProject project, File realPomFile,
File targetLocalRepoBasedir )
throws TestToolsException
{
Artifact artifact = project.getArtifact();
if ( "pom".equals( project.getPackaging() ) )
{
artifact.setFile( project.getFile() );
}
ArtifactRepository localRepository = createLocalArtifactRepositoryInstance( targetLocalRepoBasedir );
String localPath = localRepository.pathOf( artifact );
File destination = new File( localRepository.getBasedir(), localPath );
if ( !destination.getParentFile().exists() )
{
destination.getParentFile().mkdirs();
}
legacySupport.setSession( new MavenSession( container, new MavenRepositorySystemSession(),
new DefaultMavenExecutionRequest(),
new DefaultMavenExecutionResult() ) );
try
{
artifactInstaller.install( artifact.getFile(), artifact, localRepository );
}
catch ( ArtifactInstallationException e )
{
throw new TestToolsException( "Error installing plugin artifact to target local repository: "
+ targetLocalRepoBasedir, e );
}
finally
{
legacySupport.setSession( null );
}
installLocallyReachableAncestorPoms( realPomFile, localRepository );
}
/**
* Traverse <relativePath/> links for successive POMs in the plugin's ancestry, installing
* each one into the test-time local repository.
*
* @param realPomFile The real plugin POM; a starting point, but the POM is already installed,
* so we won't actually install this file, only use it to locate parents.
* @param localRepo The test-time local repository instance
* @throws TestToolsException if any
*/
private void installLocallyReachableAncestorPoms( File realPomFile, ArtifactRepository localRepo )
throws TestToolsException
{
MavenXpp3Reader pomReader = new MavenXpp3Reader();
File pom = realPomFile;
boolean firstPass = true;
while ( pom != null )
{
if ( !pom.exists() )
{
pom = null;
break;
}
String pomGroupId = null;
String pomArtifactId = null;
String pomVersion = null;
Reader reader = null;
File currentPom = pom;
try
{
reader = ReaderFactory.newXmlReader( pom );
Model model = pomReader.read( reader );
pomGroupId = model.getGroupId();
pomArtifactId = model.getArtifactId();
pomVersion = model.getVersion();
Parent parent = model.getParent();
if ( parent != null )
{
pom = new File( pom.getParentFile(), parent.getRelativePath() );
if ( pomGroupId == null )
{
pomGroupId = parent.getGroupId();
}
if ( pomVersion == null )
{
pomVersion = parent.getVersion();
}
}
else
{
pom = null;
}
}
catch ( IOException e )
{
throw new TestToolsException( "Error reading ancestor POM: " + currentPom, e );
}
catch ( XmlPullParserException e )
{
throw new TestToolsException( "Error reading ancestor POM: " + currentPom, e );
}
finally
{
IOUtil.close( reader );
}
if ( !firstPass )
{
Artifact pomArtifact = artifactFactory.createProjectArtifact( pomGroupId, pomArtifactId, pomVersion );
pomArtifact.addMetadata( new ProjectArtifactMetadata( pomArtifact, currentPom ) );
try
{
artifactInstaller.install( currentPom, pomArtifact, localRepo );
}
catch ( ArtifactInstallationException e )
{
throw new TestToolsException( "Error installing ancestor POM: " + currentPom
+ " to target local repository: " + localRepo.getBasedir(), e );
}
}
else
{
firstPass = false;
}
}
}
/**
* Retrieve the PlexusContainer instance used to instantiate this component. The container is
* used to retrieve the default ArtifactRepositoryLayout component, for use in constructing
* instances of ArtifactRepository that can be used to access local repositories.
*
* @see org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable#contextualize(org.codehaus.plexus.context.Context)
*/
public void contextualize( Context context )
throws ContextException
{
this.container = (PlexusContainer) context.get( PlexusConstants.PLEXUS_KEY );
}
}