package org.apache.maven.plugin.invoker;
/*
* 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.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Map;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
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.model.Model;
import org.apache.maven.model.Parent;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.util.FileUtils;
/**
* Installs the project artifacts of the main build into the local repository as a preparation to run the sub projects.
* More precisely, all artifacts of the project itself, all its locally reachable parent POMs and all its dependencies
* from the reactor will be installed to the local repository.
*
* @goal install
* @phase pre-integration-test
* @requiresDependencyResolution runtime
* @since 1.2
* @author Paul Gier
* @author Benjamin Bentmann
* @version $Id: InstallMojo.java 814226 2009-09-12 20:01:59Z bentmann $
*/
public class InstallMojo
extends AbstractMojo
{
/**
* Maven artifact install component to copy artifacts to the local repository.
*
* @component
*/
private ArtifactInstaller installer;
/**
* The component used to create artifacts.
*
* @component
*/
private ArtifactFactory artifactFactory;
/**
* The component used to create artifacts.
*
* @component
*/
private ArtifactRepositoryFactory repositoryFactory;
/**
* @parameter expression="${localRepository}"
* @required
* @readonly
*/
private ArtifactRepository localRepository;
/**
* The path to the local repository into which the project artifacts should be installed for the integration tests.
* If not set, the regular local repository will be used. To prevent soiling of your regular local repository with
* possibly broken artifacts, it is strongly recommended to use an isolated repository for the integration tests
* (e.g. <code>${project.build.directory}/it-repo</code>).
*
* @parameter expression="${invoker.localRepositoryPath}"
*/
private File localRepositoryPath;
/**
* The current Maven project.
*
* @parameter expression="${project}"
* @required
* @readonly
*/
private MavenProject project;
/**
* The set of Maven projects in the reactor build.
*
* @parameter default-value="${reactorProjects}"
* @readonly
*/
private Collection reactorProjects;
/**
* A flag used to disable the installation procedure. This is primarily intended for usage from the command line to
* occasionally adjust the build.
*
* @parameter expression="${invoker.skip}" default-value="false"
* @since 1.4
*/
private boolean skipInstallation;
/**
* The identifiers of already installed artifacts, used to avoid multiple installation of the same artifact.
*/
private Collection installedArtifacts;
/**
* The identifiers of already copied artifacts, used to avoid multiple installation of the same artifact.
*/
private Collection copiedArtifacts;
/**
* Performs this mojo's tasks.
*
* @throws MojoExecutionException If the artifacts could not be installed.
*/
public void execute()
throws MojoExecutionException
{
if ( skipInstallation )
{
getLog().info( "Skipping artifact installation per configuration." );
return;
}
ArtifactRepository testRepository = createTestRepository();
installedArtifacts = new HashSet();
copiedArtifacts = new HashSet();
installProjectDependencies( project, reactorProjects, testRepository );
installProjectParents( project, testRepository );
installProjectArtifacts( project, testRepository );
}
/**
* Creates the local repository for the integration tests. If the user specified a custom repository location, the
* custom repository will have the same identifier, layout and policies as the real local repository. That means
* apart from the location, the custom repository will be indistinguishable from the real repository such that its
* usage is transparent to the integration tests.
*
* @return The local repository for the integration tests, never <code>null</code>.
* @throws MojoExecutionException If the repository could not be created.
*/
private ArtifactRepository createTestRepository()
throws MojoExecutionException
{
ArtifactRepository testRepository = localRepository;
if ( localRepositoryPath != null )
{
try
{
if ( !localRepositoryPath.exists() && !localRepositoryPath.mkdirs() )
{
throw new IOException( "Failed to create directory: " + localRepositoryPath );
}
testRepository =
repositoryFactory.createArtifactRepository( localRepository.getId(),
localRepositoryPath.toURL().toExternalForm(),
localRepository.getLayout(),
localRepository.getSnapshots(),
localRepository.getReleases() );
}
catch ( Exception e )
{
throw new MojoExecutionException( "Failed to create local repository: " + localRepositoryPath, e );
}
}
return testRepository;
}
/**
* Installs the specified artifact to the local repository. Note: This method should only be used for artifacts that
* originate from the current (reactor) build. Artifacts that have been grabbed from the user's local repository
* should be installed to the test repository via {@link #copyArtifact(File, Artifact, ArtifactRepository)}.
*
* @param file The file associated with the artifact, must not be <code>null</code>. This is in most cases the value
* of <code>artifact.getFile()</code> with the exception of the main artifact from a project with
* packaging "pom". Projects with packaging "pom" have no main artifact file. They have however artifact
* metadata (e.g. site descriptors) which needs to be installed.
* @param artifact The artifact to install, must not be <code>null</code>.
* @param testRepository The local repository to install the artifact to, must not be <code>null</code>.
* @throws MojoExecutionException If the artifact could not be installed (e.g. has no associated file).
*/
private void installArtifact( File file, Artifact artifact, ArtifactRepository testRepository )
throws MojoExecutionException
{
try
{
if ( file == null )
{
throw new IllegalStateException( "Artifact has no associated file: " + file );
}
if ( !file.isFile() )
{
throw new IllegalStateException( "Artifact is not fully assembled: " + file );
}
if ( installedArtifacts.add( artifact.getId() ) )
{
installer.install( file, artifact, testRepository );
}
else
{
getLog().debug( "Not re-installing " + artifact + ", " + file );
}
}
catch ( Exception e )
{
throw new MojoExecutionException( "Failed to install artifact: " + artifact, e );
}
}
/**
* Installs the specified artifact to the local repository. This method serves basically the same purpose as
* {@link #installArtifact(File, Artifact, ArtifactRepository)} but is meant for artifacts that have been resolved
* from the user's local repository (and not the current build outputs). The subtle difference here is that
* artifacts from the repository have already undergone transformations and these manipulations should not be redone
* by the artifact installer. For this reason, this method performs plain copy operations to install the artifacts.
*
* @param file The file associated with the artifact, must not be <code>null</code>.
* @param artifact The artifact to install, must not be <code>null</code>.
* @param testRepository The local repository to install the artifact to, must not be <code>null</code>.
* @throws MojoExecutionException If the artifact could not be installed (e.g. has no associated file).
*/
private void copyArtifact( File file, Artifact artifact, ArtifactRepository testRepository )
throws MojoExecutionException
{
try
{
if ( file == null )
{
throw new IllegalStateException( "Artifact has no associated file: " + file );
}
if ( !file.isFile() )
{
throw new IllegalStateException( "Artifact is not fully assembled: " + file );
}
if ( copiedArtifacts.add( artifact.getId() ) )
{
File destination = new File( testRepository.getBasedir(), testRepository.pathOf( artifact ) );
getLog().debug( "Installing " + file + " to " + destination );
copyFileIfDifferent( file, destination );
MetadataUtils.createMetadata( destination, artifact );
}
else
{
getLog().debug( "Not re-installing " + artifact + ", " + file );
}
}
catch ( Exception e )
{
throw new MojoExecutionException( "Failed to stage artifact: " + artifact, e );
}
}
private void copyFileIfDifferent( File src, File dst )
throws IOException
{
if ( src.lastModified() != dst.lastModified() || src.length() != dst.length() )
{
FileUtils.copyFile( src, dst );
dst.setLastModified( src.lastModified() );
}
}
/**
* Installs the main artifact and any attached artifacts of the specified project to the local repository.
*
* @param mvnProject The project whose artifacts should be installed, must not be <code>null</code>.
* @param testRepository The local repository to install the artifacts to, must not be <code>null</code>.
* @throws MojoExecutionException If any artifact could not be installed.
*/
private void installProjectArtifacts( MavenProject mvnProject, ArtifactRepository testRepository )
throws MojoExecutionException
{
try
{
// Install POM (usually attached as metadata but that happens only as a side effect of the Install Plugin)
installProjectPom( mvnProject, testRepository );
// Install the main project artifact (if the project has one, e.g. has no "pom" packaging)
Artifact mainArtifact = mvnProject.getArtifact();
if ( mainArtifact.getFile() != null )
{
installArtifact( mainArtifact.getFile(), mainArtifact, testRepository );
}
// Install any attached project artifacts
Collection attachedArtifacts = mvnProject.getAttachedArtifacts();
for ( Iterator artifactIter = attachedArtifacts.iterator(); artifactIter.hasNext(); )
{
Artifact attachedArtifact = (Artifact) artifactIter.next();
installArtifact( attachedArtifact.getFile(), attachedArtifact, testRepository );
}
}
catch ( Exception e )
{
throw new MojoExecutionException( "Failed to install project artifacts: " + mvnProject, e );
}
}
/**
* Installs the (locally reachable) parent POMs of the specified project to the local repository. The parent POMs
* from the reactor must be installed or the forked IT builds will fail when using a clean repository.
*
* @param mvnProject The project whose parent POMs should be installed, must not be <code>null</code>.
* @param testRepository The local repository to install the POMs to, must not be <code>null</code>.
* @throws MojoExecutionException If any POM could not be installed.
*/
private void installProjectParents( MavenProject mvnProject, ArtifactRepository testRepository )
throws MojoExecutionException
{
try
{
for ( MavenProject parent = mvnProject.getParent(); parent != null; parent = parent.getParent() )
{
if ( parent.getFile() == null )
{
copyParentPoms( parent.getGroupId(), parent.getArtifactId(), parent.getVersion(), testRepository );
break;
}
installProjectPom( parent, testRepository );
}
}
catch ( Exception e )
{
throw new MojoExecutionException( "Failed to install project parents: " + mvnProject, e );
}
}
/**
* Installs the POM of the specified project to the local repository.
*
* @param mvnProject The project whose POM should be installed, must not be <code>null</code>.
* @param testRepository The local repository to install the POM to, must not be <code>null</code>.
* @throws MojoExecutionException If the POM could not be installed.
*/
private void installProjectPom( MavenProject mvnProject, ArtifactRepository testRepository )
throws MojoExecutionException
{
try
{
Artifact pomArtifact = null;
if ( "pom".equals( mvnProject.getPackaging() ) )
{
pomArtifact = mvnProject.getArtifact();
}
if ( pomArtifact == null )
{
pomArtifact =
artifactFactory.createProjectArtifact( mvnProject.getGroupId(), mvnProject.getArtifactId(),
mvnProject.getVersion() );
}
installArtifact( mvnProject.getFile(), pomArtifact, testRepository );
}
catch ( Exception e )
{
throw new MojoExecutionException( "Failed to install POM: " + mvnProject, e );
}
}
/**
* Installs the dependent projects from the reactor to the local repository. The dependencies on other modules from
* the reactor must be installed or the forked IT builds will fail when using a clean repository.
*
* @param mvnProject The project whose dependent projects should be installed, must not be <code>null</code>.
* @param reactorProjects The set of projects in the reactor build, must not be <code>null</code>.
* @param testRepository The local repository to install the POMs to, must not be <code>null</code>.
* @throws MojoExecutionException If any dependency could not be installed.
*/
private void installProjectDependencies( MavenProject mvnProject, Collection reactorProjects,
ArtifactRepository testRepository )
throws MojoExecutionException
{
// index available reactor projects
Map projects = new HashMap();
for ( Iterator it = reactorProjects.iterator(); it.hasNext(); )
{
MavenProject reactorProject = (MavenProject) it.next();
String projectId =
reactorProject.getGroupId() + ':' + reactorProject.getArtifactId() + ':' + reactorProject.getVersion();
projects.put( projectId, reactorProject );
}
// group transitive dependencies (even those that don't contribute to the class path like POMs) ...
Collection artifacts = mvnProject.getArtifacts();
// ... into dependencies that were resolved from reactor projects ...
Collection dependencyProjects = new LinkedHashSet();
// ... and those that were resolved from the (local) repo
Collection dependencyArtifacts = new LinkedHashSet();
for ( Iterator it = artifacts.iterator(); it.hasNext(); )
{
Artifact artifact = (Artifact) it.next();
// workaround for MNG-2961 to ensure the base version does not contain a timestamp
artifact.isSnapshot();
String projectId = artifact.getGroupId() + ':' + artifact.getArtifactId() + ':' + artifact.getBaseVersion();
if ( projects.containsKey( projectId ) )
{
dependencyProjects.add( projectId );
}
else
{
dependencyArtifacts.add( artifact );
}
}
// install dependencies
try
{
// copy dependencies that where resolved from the local repo
for ( Iterator it = dependencyArtifacts.iterator(); it.hasNext(); )
{
Artifact artifact = (Artifact) it.next();
Artifact depArtifact =
artifactFactory.createArtifactWithClassifier( artifact.getGroupId(), artifact.getArtifactId(),
artifact.getBaseVersion(), artifact.getType(),
artifact.getClassifier() );
File artifactFile = artifact.getFile();
Artifact pomArtifact =
artifactFactory.createProjectArtifact( depArtifact.getGroupId(), depArtifact.getArtifactId(),
depArtifact.getBaseVersion() );
File pomFile = new File( localRepository.getBasedir(), localRepository.pathOf( pomArtifact ) );
if ( pomFile.isFile() )
{
if ( !pomArtifact.getId().equals( depArtifact.getId() ) )
{
copyArtifact( pomFile, pomArtifact, testRepository );
}
copyParentPoms( pomFile, testRepository );
}
copyArtifact( artifactFile, depArtifact, testRepository );
}
// install dependencies that were resolved from the reactor
for ( Iterator it = dependencyProjects.iterator(); it.hasNext(); )
{
String projectId = (String) it.next();
MavenProject dependencyProject = (MavenProject) projects.get( projectId );
installProjectArtifacts( dependencyProject, testRepository );
installProjectParents( dependencyProject, testRepository );
}
}
catch ( Exception e )
{
throw new MojoExecutionException( "Failed to install project dependencies: " + mvnProject, e );
}
}
/**
* Installs all parent POMs of the specified POM file that are available in the local repository.
*
* @param pomFile The path to the POM file whose parents should be installed, must not be <code>null</code>.
* @param testRepository The local repository to install the POMs to, must not be <code>null</code>.
* @throws MojoExecutionException If any (existing) parent POM could not be installed.
*/
private void copyParentPoms( File pomFile, ArtifactRepository testRepository )
throws MojoExecutionException
{
Model model = PomUtils.loadPom( pomFile );
Parent parent = model.getParent();
if ( parent != null )
{
copyParentPoms( parent.getGroupId(), parent.getArtifactId(), parent.getVersion(), testRepository );
}
}
/**
* Installs the specified POM and all its parent POMs to the local repository.
*
* @param groupId The group id of the POM which should be installed, must not be <code>null</code>.
* @param artifactId The artifact id of the POM which should be installed, must not be <code>null</code>.
* @param version The version of the POM which should be installed, must not be <code>null</code>.
* @param testRepository The local repository to install the POMs to, must not be <code>null</code>.
* @throws MojoExecutionException If any (existing) parent POM could not be installed.
*/
private void copyParentPoms( String groupId, String artifactId, String version, ArtifactRepository testRepository )
throws MojoExecutionException
{
Artifact pomArtifact = artifactFactory.createProjectArtifact( groupId, artifactId, version );
if ( installedArtifacts.contains( pomArtifact.getId() ) || copiedArtifacts.contains( pomArtifact.getId() ) )
{
getLog().debug( "Not re-installing " + pomArtifact );
return;
}
File pomFile = new File( localRepository.getBasedir(), localRepository.pathOf( pomArtifact ) );
if ( pomFile.isFile() )
{
copyArtifact( pomFile, pomArtifact, testRepository );
copyParentPoms( pomFile, testRepository );
}
}
}