It is essential that you provide some form of integration testing for your projects and the Invoker Plugin tries to make is easy for you to create integration tests for your Maven Plugins, new Lifecycles, or any other type of Maven component that you've created. Currently the Invoker Plugin forks Maven to execute the specified projects, but it is hoped that soon we will integrate the Maven Embedder into the mix to allow you run your projects in process for great speed.
Sometimes you might want to test that error conditions are properly dealt with, i.e. fail a build. To assert
a failure for a particular IT project, put the following setting into the properties file denoted by the
plugin's invokerPropertiesFile parameter:
invoker.buildResult=failure.
Now, the failure of the IT build will be interpreted as a test success. Likewise, a successful IT build will
be considered a test failure.
If you want to avoid copy&paste of lengthy code snippets within the hook scripts, you can move this code
into a regular Java class. More precisely, you would place this utility code somewhere in your test source
tree and set the plugin parameter addTestClassPath
to true. For more details, please see the example
Accessing Test Classes.
This is not supported in the plugin configuration but rather on a per project basis by means of the invoker
properties. This way, you use properties like invoker.goals.2 to configure the goals for a second
invocation of Maven. Have a look at the example about using
Invoker Properties.
null.
*/
private MavenProject mavenProject;
/**
* The set of additional properties from which to extract interpolated values, never null.
*/
private Map properties;
/**
* Creates a new interpolation source backed by the specified Maven project and some user-specified properties.
*
* @param mavenProject The Maven project from which to extract interpolated values, must not be null.
* @param properties The set of additional properties from which to extract interpolated values, may be
* null.
*/
protected CompositeMap( MavenProject mavenProject, Map properties )
{
if ( mavenProject == null )
{
throw new IllegalArgumentException( "no project specified" );
}
this.mavenProject = mavenProject;
this.properties = properties == null ? new Properties() : properties;
}
/**
* {@inheritDoc}
*
* @see java.util.Map#clear()
*/
public void clear()
{
// nothing here
}
/**
* {@inheritDoc}
*
* @see java.util.Map#containsKey(java.lang.Object)
*/
public boolean containsKey( Object key )
{
if ( !( key instanceof String ) )
{
return false;
}
String expression = (String) key;
if ( expression.startsWith( "project." ) || expression.startsWith( "pom." ) )
{
try
{
Object evaluated = ReflectionValueExtractor.evaluate( expression, this.mavenProject );
if ( evaluated != null )
{
return true;
}
}
catch ( Exception e )
{
// uhm do we have to throw a RuntimeException here ?
}
}
return properties.containsKey( key ) || mavenProject.getProperties().containsKey( key );
}
/**
* {@inheritDoc}
*
* @see java.util.Map#containsValue(java.lang.Object)
*/
public boolean containsValue( Object value )
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#entrySet()
*/
public Set entrySet()
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#get(java.lang.Object)
*/
public Object get( Object key )
{
if ( !( key instanceof String ) )
{
return null;
}
String expression = (String) key;
if ( expression.startsWith( "project." ) || expression.startsWith( "pom." ) )
{
try
{
Object evaluated = ReflectionValueExtractor.evaluate( expression, this.mavenProject );
if ( evaluated != null )
{
return evaluated;
}
}
catch ( Exception e )
{
// uhm do we have to throw a RuntimeException here ?
}
}
Object value = properties.get( key );
return ( value != null ? value : this.mavenProject.getProperties().get( key ) );
}
/**
* {@inheritDoc}
*
* @see java.util.Map#isEmpty()
*/
public boolean isEmpty()
{
return this.mavenProject == null && this.mavenProject.getProperties().isEmpty() && this.properties.isEmpty();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#keySet()
*/
public Set keySet()
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#put(java.lang.Object, java.lang.Object)
*/
public Object put( Object key, Object value )
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#putAll(java.util.Map)
*/
public void putAll( Map t )
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#remove(java.lang.Object)
*/
public Object remove( Object key )
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#size()
*/
public int size()
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#values()
*/
public Collection values()
{
throw new UnsupportedOperationException();
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/AbstractInvokerMojo.java 0000644 0001750 0001750 00000217470 11270330034 031522 0 ustar tony tony 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 org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugin.invoker.model.BuildJob;
import org.apache.maven.plugin.invoker.model.io.xpp3.BuildJobXpp3Writer;
import org.apache.maven.model.Model;
import org.apache.maven.model.Profile;
import org.apache.maven.shared.invoker.InvocationRequest;
import org.apache.maven.shared.invoker.DefaultInvocationRequest;
import org.apache.maven.shared.invoker.MavenCommandLineBuilder;
import org.apache.maven.shared.invoker.CommandLineConfigurationException;
import org.apache.maven.shared.invoker.InvocationResult;
import org.apache.maven.shared.invoker.MavenInvocationException;
import org.apache.maven.shared.invoker.Invoker;
import org.apache.maven.project.MavenProject;
import org.apache.maven.settings.Settings;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.ReaderFactory;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.DirectoryScanner;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.InterpolationFilterReader;
import org.codehaus.plexus.util.WriterFactory;
import org.codehaus.plexus.interpolation.Interpolator;
import org.codehaus.plexus.interpolation.RegexBasedInterpolator;
import org.codehaus.plexus.interpolation.MapBasedValueSource;
import org.codehaus.plexus.interpolation.InterpolationException;
import java.io.IOException;
import java.io.File;
import java.io.Reader;
import java.io.FileOutputStream;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.BufferedReader;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;
import java.util.Properties;
import java.util.TreeSet;
import java.util.Map;
import java.util.LinkedHashMap;
import java.util.Arrays;
import java.util.HashMap;
import java.util.StringTokenizer;
import java.util.Collections;
import java.util.Locale;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
/**
* Provides common code for mojos invoking sub builds.
*
* @author Stephen Connolly
* @since 15-Aug-2009 09:09:29
*/
public abstract class AbstractInvokerMojo
extends AbstractMojo
{
/**
* Flag used to suppress certain invocations. This is useful in tailoring the build using profiles.
*
* @parameter expression="${invoker.skip}" default-value="false"
* @since 1.1
*/
private boolean skipInvocation;
/**
* Flag used to suppress the summary output notifying of successes and failures. If set to true, the
* only indication of the build's success or failure will be the effect it has on the main build (if it fails, the
* main build should fail as well). If {@link #streamLogs} is enabled, the sub-build summary will also provide an
* indication.
*
* @parameter default-value="false"
*/
protected boolean suppressSummaries;
/**
* Flag used to determine whether the build logs should be output to the normal mojo log.
*
* @parameter expression="${invoker.streamLogs}" default-value="false"
*/
private boolean streamLogs;
/**
* The local repository for caching artifacts. It is strongly recommended to specify a path to an isolated
* repository like ${project.build.directory}/it-repo. Otherwise, your ordinary local repository will
* be used, potentially soiling it with broken artifacts.
*
* @parameter expression="${invoker.localRepositoryPath}" default-value="${settings.localRepository}"
*/
private File localRepositoryPath;
/**
* Directory to search for integration tests.
*
* @parameter expression="${invoker.projectsDirectory}" default-value="${basedir}/src/it/"
*/
private File projectsDirectory;
/**
* Base directory where all build reports are written to.
*
* @parameter expression="${invoker.reportsDirectory}" default-value="${project.build.directory}/invoker-reports"
* @since 1.4
*/
private File reportsDirectory;
/**
* A flag to disable the generation of build reports.
*
* @parameter expression="${invoker.disableReports}" default-value="false"
* @since 1.4
*/
private boolean disableReports;
/**
* Directory to which projects should be cloned prior to execution. If not specified, each integration test will be
* run in the directory in which the corresponding IT POM was found. In this case, you most likely want to configure
* your SCM to ignore target and build.log in the test's base directory.
*
* @parameter
* @since 1.1
*/
private File cloneProjectsTo;
/**
* Some files are normally excluded when copying the IT projects from the directory specified by the parameter
* projectsDirectory to the directory given by cloneProjectsTo (e.g. .svn, CVS,
* *~, etc). Setting this parameter to true will cause all files to be copied to the
* cloneProjectsTo directory.
*
* @parameter default-value="false"
* @since 1.2
*/
private boolean cloneAllFiles;
/**
* A single POM to build, skipping any scanning parameters and behavior.
*
* @parameter expression="${invoker.pom}"
*/
private File pom;
/**
* Include patterns for searching the integration test directory for projects. This parameter is meant to be set
* from the POM. If this parameter is not set, the plugin will search for all pom.xml files one
* directory below {@link #projectsDirectory} (i.e. */pom.xml).* will run Maven builds on all immediate sub directories of {@link #projectsDirectory},
* regardless if they contain a pom.xml. This allows to perform builds that need/should not depend on
* the existence of a POM.
*
* @parameter
*/
private List pomIncludes = Collections.singletonList( "*/pom.xml" );
/**
* Exclude patterns for searching the integration test directory. This parameter is meant to be set from the POM. By
* default, no POM files are excluded. For the convenience of using an include pattern like *, the
* custom settings file specified by the parameter {@link #settingsFile} will always be excluded automatically.
*
* @parameter
*/
private List pomExcludes = Collections.EMPTY_LIST;
/**
* Include patterns for searching the projects directory for projects that need to be run before the other projects.
* This parameter allows to declare projects that perform setup tasks like installing utility artifacts into the
* local repository. Projects matched by these patterns are implicitly excluded from the scan for ordinary projects.
* Also, the exclusions defined by the parameter {@link #pomExcludes} apply to the setup projects, too. Default
* value is: setup*/pom.xml.
*
* @parameter
* @since 1.3
*/
private List setupIncludes = Collections.singletonList( "setup*/pom.xml" );
/**
* The list of goals to execute on each project. Default value is: package.
*
* @parameter
*/
private List goals = Collections.singletonList( "package" );
/**
* The name of the project-specific file that contains the enumeration of goals to execute for that test.
*
* @parameter expression="${invoker.goalsFile}" default-value="goals.txt"
* @deprecated As of version 1.2, the key invoker.goals from the properties file specified by the
* parameter {@link #invokerPropertiesFile} should be used instead.
*/
private String goalsFile;
/**
* @component
*/
private Invoker invoker;
/**
* Relative path of a selector script to run prior in order to decide if the build should be executed. This script
* may be written with either BeanShell or Groovy. If the file extension is omitted (e.g. selector),
* the plugin searches for the file by trying out the well-known extensions .bsh and .groovy.
* If this script exists for a particular project but returns any non-null value different from true,
* the corresponding build is flagged as skipped. In this case, none of the pre-build hook script,
* Maven nor the post-build hook script will be invoked. If this script throws an exception, the corresponding
* build is flagged as in error, and none of the pre-build hook script, Maven not the post-build hook script will
* be invoked.
*
* @parameter expression="${invoker.selectorScript}" default-value="selector"
* @since 1.5
*/
private String selectorScript;
/**
* Relative path of a pre-build hook script to run prior to executing the build. This script may be written with
* either BeanShell or Groovy (since 1.3). If the file extension is omitted (e.g. prebuild), the plugin
* searches for the file by trying out the well-known extensions .bsh and .groovy. If this
* script exists for a particular project but returns any non-null value different from true or throws
* an exception, the corresponding build is flagged as a failure. In this case, neither Maven nor the post-build
* hook script will be invoked.
*
* @parameter expression="${invoker.preBuildHookScript}" default-value="prebuild"
*/
private String preBuildHookScript;
/**
* Relative path of a cleanup/verification hook script to run after executing the build. This script may be written
* with either BeanShell or Groovy (since 1.3). If the file extension is omitted (e.g. verify), the
* plugin searches for the file by trying out the well-known extensions .bsh and .groovy.
* If this script exists for a particular project but returns any non-null value different from true or
* throws an exception, the corresponding build is flagged as a failure.
*
* @parameter expression="${invoker.postBuildHookScript}" default-value="postbuild"
*/
private String postBuildHookScript;
/**
* Location of a properties file that defines CLI properties for the test.
*
* @parameter expression="${invoker.testPropertiesFile}" default-value="test.properties"
*/
private String testPropertiesFile;
/**
* Common set of test properties to pass in on each IT's command line, via -D parameters.
*
* @parameter
* @deprecated As of version 1.1, use the {@link #properties} parameter instead.
*/
private Properties testProperties;
/**
* Common set of properties to pass in on each project's command line, via -D parameters.
*
* @parameter
* @since 1.1
*/
private Map properties;
/**
* Whether to show errors in the build output.
*
* @parameter expression="${invoker.showErrors}" default-value="false"
*/
private boolean showErrors;
/**
* Whether to show debug statements in the build output.
*
* @parameter expression="${invoker.debug}" default-value="false"
*/
private boolean debug;
/**
* Suppress logging to the build.log file.
*
* @parameter expression="${invoker.noLog}" default-value="false"
*/
private boolean noLog;
/**
* List of profile identifiers to explicitly trigger in the build.
*
* @parameter
* @since 1.1
*/
private List profiles;
/**
* List of properties which will be used to interpolate goal files.
*
* @parameter
* @since 1.1
* @deprecated As of version 1.3, the parameter {@link #filterProperties} should be used instead.
*/
private Properties interpolationsProperties;
/**
* A list of additional properties which will be used to filter tokens in POMs and goal files.
*
* @parameter
* @since 1.3
*/
private Map filterProperties;
/**
* The Maven Project Object
*
* @parameter expression="${project}"
* @required
* @readonly
* @since 1.1
*/
private MavenProject project;
/**
* A comma separated list of project names to run. Specify this parameter to run individual tests by file name,
* overriding the {@link #setupIncludes}, {@link #pomIncludes} and {@link #pomExcludes} parameters. Each pattern you
* specify here will be used to create an include pattern formatted like
* ${projectsDirectory}/pattern, so you can just type
* -Dinvoker.test=FirstTest,SecondTest to run builds in ${projectsDirectory}/FirstTest and
* ${projectsDirectory}/SecondTest.
*
* @parameter expression="${invoker.test}"
* @since 1.1
*/
private String invokerTest;
/**
* The name of the project-specific file that contains the enumeration of profiles to use for that test. If the
* file exists and is empty no profiles will be used even if the parameter {@link #profiles} is set.
*
* @parameter expression="${invoker.profilesFile}" default-value="profiles.txt"
* @since 1.1
* @deprecated As of version 1.2, the key invoker.profiles from the properties file specified by the
* parameter {@link #invokerPropertiesFile} should be used instead.
*/
private String profilesFile;
/**
* Path to an alternate settings.xml to use for Maven invocation with all ITs. Note that the
* <localRepository> element of this settings file is always ignored, i.e. the path given by the
* parameter {@link #localRepositoryPath} is dominant.
*
* @parameter expression="${invoker.settingsFile}"
* @since 1.2
*/
private File settingsFile;
/**
* The MAVEN_OPTS environment variable to use when invoking Maven. This value can be overridden for
* individual integration tests by using {@link #invokerPropertiesFile}.
*
* @parameter expression="${invoker.mavenOpts}"
* @since 1.2
*/
private String mavenOpts;
/**
* The home directory of the Maven installation to use for the forked builds. Defaults to the current Maven
* installation.
*
* @parameter expression="${invoker.mavenHome}"
* @since 1.3
*/
private File mavenHome;
/**
* The JAVA_HOME environment variable to use for forked Maven invocations. Defaults to the current Java
* home directory.
*
* @parameter expression="${invoker.javaHome}"
* @since 1.3
*/
private File javaHome;
/**
* The file encoding for the pre-/post-build scripts and the list files for goals and profiles.
*
* @parameter expression="${encoding}" default-value="${project.build.sourceEncoding}"
* @since 1.2
*/
private String encoding;
/**
* The current user system settings for use in Maven.
*
* @parameter expression="${settings}"
* @required
* @readonly
* @since 1.2
*/
private Settings settings;
/**
* A flag whether the test class path of the project under test should be included in the class path of the
* pre-/post-build scripts. If set to false, the class path of script interpreter consists only of
* the runtime dependencies of the Maven Invoker Plugin. If set the
* true, the project's test class path will be prepended to the interpreter class path. Among
* others, this feature allows the scripts to access utility classes from the test sources of your project.
*
* @parameter expression="${invoker.addTestClassPath}" default-value="false"
* @since 1.2
*/
private boolean addTestClassPath;
/**
* The test class path of the project under test.
*
* @parameter default-value="${project.testClasspathElements}"
* @readonly
*/
private List testClassPath;
/**
* The name of an optional project-specific file that contains properties used to specify settings for an individual
* Maven invocation. Any property present in the file will override the corresponding setting from the plugin
* configuration. The values of the properties are filtered and may use expressions like
* ${project.version} to reference project properties or values from the parameter
* {@link #filterProperties}. The snippet below describes the supported properties:
*
*
* # A comma or space separated list of goals/phases to execute, may
* # specify an empty list to execute the default goal of the IT project
* invoker.goals = clean install
*
* # Optionally, a list of goals to run during further invocations of Maven
* invoker.goals.2 = ${project.groupId}:${project.artifactId}:${project.version}:run
*
* # A comma or space separated list of profiles to activate
* invoker.profiles = its,jdk15
*
* # The path to an alternative POM or base directory to invoke Maven on, defaults to the
* # project that was originally specified in the plugin configuration
* # Since plugin version 1.4
* invoker.project = sub-module
*
* # The value for the environment variable MAVEN_OPTS
* invoker.mavenOpts = -Dfile.encoding=UTF-16 -Xms32m -Xmx256m
*
* # Possible values are "fail-fast" (default), "fail-at-end" and "fail-never"
* invoker.failureBehavior = fail-never
*
* # The expected result of the build, possible values are "success" (default) and "failure"
* invoker.buildResult = failure
*
* # A boolean value controlling the aggregator mode of Maven, defaults to "false"
* invoker.nonRecursive = true
*
* # A boolean value controlling the network behavior of Maven, defaults to "false"
* # Since plugin version 1.4
* invoker.offline = true
*
* # The path to the properties file from which to load system properties, defaults to the
* # filename given by the plugin parameter testPropertiesFile
* # Since plugin version 1.4
* invoker.systemPropertiesFile = test.properties
*
* # An optional human friendly name for this build job to be included in the build reports.
* # Since plugin version 1.4
* invoker.name = Test Build 01
*
* # An optional description for this build job to be included in the build reports.
* # Since plugin version 1.4
* invoker.description = Checks the support for build reports.
*
* # A comma separated list of JRE versions on which this build job should be run.
* # Since plugin version 1.4
* invoker.java.version = 1.4+, !1.4.1, 1.7-
*
* # A comma separated list of OS families on which this build job should be run.
* # Since plugin version 1.4
* invoker.os.family = !windows, unix, mac
*
* # A comma separated list of Maven versions on which this build should be run.
* # Since plugin version 1.5
* invoker.maven.version = 2.0.10+, !2.1.0, !2.2.0
*
*
* @parameter expression="${invoker.invokerPropertiesFile}" default-value="invoker.properties"
* @since 1.2
*/
private String invokerPropertiesFile;
/**
* flag to enable show mvn version used for running its (cli option : -V,--show-version )
* @parameter expression="${invoker.showVersion}" default-value="false"
* @since 1.4
*/
private boolean showVersion;
/**
* The scripter runner that is responsible to execute hook scripts.
*/
private ScriptRunner scriptRunner;
/**
* A string used to prefix the file name of the filtered POMs in case the POMs couldn't be filtered in-place (i.e.
* the projects were not cloned to a temporary directory), can be null. This will be set to
* null if the POMs have already been filtered during cloning.
*/
private String filteredPomPrefix = "interpolated-";
/**
* The format for elapsed build time.
*/
private final DecimalFormat secFormat = new DecimalFormat( "(0.0 s)", new DecimalFormatSymbols( Locale.ENGLISH ) );
/**
* Invokes Maven on the configured test projects.
*
* @throws org.apache.maven.plugin.MojoExecutionException If the goal encountered severe errors.
* @throws org.apache.maven.plugin.MojoFailureException If any of the Maven builds failed.
*/
public void execute()
throws MojoExecutionException, MojoFailureException
{
if ( skipInvocation )
{
getLog().info( "Skipping invocation per configuration."
+ " If this is incorrect, ensure the skipInvocation parameter is not set to true." );
return;
}
BuildJob[] buildJobs;
if ( pom != null )
{
try
{
projectsDirectory = pom.getCanonicalFile().getParentFile();
}
catch ( IOException e )
{
throw new MojoExecutionException( "Failed to discover projectsDirectory from pom File parameter."
+ " Reason: " + e.getMessage(), e );
}
buildJobs = new BuildJob[]{ new BuildJob( pom.getName(), BuildJob.Type.NORMAL )};
}
else
{
try
{
buildJobs = getBuildJobs();
}
catch ( final IOException e )
{
throw new MojoExecutionException( "Error retrieving POM list from includes, excludes, "
+ "and projects directory. Reason: " + e.getMessage(), e );
}
}
if ( ( buildJobs == null ) || ( buildJobs.length < 1 ) )
{
getLog().info( "No projects were selected for execution." );
return;
}
if ( StringUtils.isEmpty( encoding ) )
{
getLog().warn(
"File encoding has not been set, using platform encoding " + ReaderFactory.FILE_ENCODING
+ ", i.e. build is platform dependent!" );
}
scriptRunner = new ScriptRunner( getLog() );
scriptRunner.setScriptEncoding( encoding );
scriptRunner.setGlobalVariable( "localRepositoryPath", localRepositoryPath );
scriptRunner.setClassPath( addTestClassPath ? testClassPath : null );
Collection collectedProjects = new LinkedHashSet();
for ( int i = 0; i < buildJobs.length; i++ )
{
collectProjects( projectsDirectory, buildJobs[i].getProject(), collectedProjects, true );
}
File projectsDir = projectsDirectory;
if ( cloneProjectsTo != null )
{
cloneProjects( collectedProjects );
projectsDir = cloneProjectsTo;
}
else
{
getLog().warn( "Filtering of parent/child POMs is not supported without cloning the projects" );
}
runBuilds( projectsDir, buildJobs );
processResults( new InvokerSession( buildJobs ) );
}
/**
* Processes the results of invoking the build jobs.
*
* @param invokerSession The session with the build jobs, must not be null.
* @throws MojoFailureException If the mojo had failed as a result of invoking the build jobs.
* @since 1.4
*/
abstract void processResults( InvokerSession invokerSession )
throws MojoFailureException;
/**
* Creates a new reader for the specified file, using the plugin's {@link #encoding} parameter.
*
* @param file The file to create a reader for, must not be null.
* @return The reader for the file, never null.
* @throws java.io.IOException If the specified file was not found or the configured encoding is not supported.
*/
private Reader newReader( File file )
throws IOException
{
if ( StringUtils.isNotEmpty( encoding ) )
{
return ReaderFactory.newReader( file, encoding );
}
else
{
return ReaderFactory.newPlatformReader( file );
}
}
/**
* Collects all projects locally reachable from the specified project. The method will as such try to read the POM
* and recursively follow its parent/module elements.
*
* @param projectsDir The base directory of all projects, must not be null.
* @param projectPath The relative path of the current project, can denote either the POM or its base directory,
* must not be null.
* @param projectPaths The set of already collected projects to add new projects to, must not be null.
* This set will hold the relative paths to either a POM file or a project base directory.
* @param included A flag indicating whether the specified project has been explicitly included via the parameter
* {@link #pomIncludes}. Such projects will always be added to the result set even if there is no
* corresponding POM.
* @throws org.apache.maven.plugin.MojoExecutionException If the project tree could not be traversed.
*/
private void collectProjects( File projectsDir, String projectPath, Collection projectPaths, boolean included )
throws MojoExecutionException
{
projectPath = projectPath.replace( '\\', '/' );
File pomFile = new File( projectsDir, projectPath );
if ( pomFile.isDirectory() )
{
pomFile = new File( pomFile, "pom.xml" );
if ( !pomFile.exists() )
{
if ( included )
{
projectPaths.add( projectPath );
}
return;
}
if ( !projectPath.endsWith( "/" ) )
{
projectPath += '/';
}
projectPath += "pom.xml";
}
else if ( !pomFile.isFile() )
{
return;
}
if ( !projectPaths.add( projectPath ) )
{
return;
}
getLog().debug( "Collecting parent/child projects of " + projectPath );
Model model = PomUtils.loadPom( pomFile );
try
{
String projectsRoot = projectsDir.getCanonicalPath();
String projectDir = pomFile.getParent();
String parentPath = "../pom.xml";
if ( model.getParent() != null && StringUtils.isNotEmpty( model.getParent().getRelativePath() ) )
{
parentPath = model.getParent().getRelativePath();
}
String parent = relativizePath( new File( projectDir, parentPath ), projectsRoot );
if ( parent != null )
{
collectProjects( projectsDir, parent, projectPaths, false );
}
Collection modulePaths = new LinkedHashSet();
modulePaths.addAll( model.getModules() );
for ( Iterator it = model.getProfiles().iterator(); it.hasNext(); )
{
Profile profile = (Profile) it.next();
modulePaths.addAll( profile.getModules() );
}
for ( Iterator it = modulePaths.iterator(); it.hasNext(); )
{
String modulePath = (String) it.next();
String module = relativizePath( new File( projectDir, modulePath ), projectsRoot );
if ( module != null )
{
collectProjects( projectsDir, module, projectPaths, false );
}
}
}
catch ( IOException e )
{
throw new MojoExecutionException( "Failed to analyze POM: " + pomFile, e );
}
}
/**
* Copies the specified projects to the directory given by {@link #cloneProjectsTo}. A project may either be denoted
* by a path to a POM file or merely by a path to a base directory. During cloning, the POM files will be filtered.
*
* @param projectPaths The paths to the projects to clone, relative to the projects directory, must not be
* null nor contain null elements.
* @throws org.apache.maven.plugin.MojoExecutionException If the the projects could not be copied/filtered.
*/
private void cloneProjects( Collection projectPaths )
throws MojoExecutionException
{
cloneProjectsTo.mkdirs();
// determine project directories to clone
Collection dirs = new LinkedHashSet();
for ( Iterator it = projectPaths.iterator(); it.hasNext(); )
{
String projectPath = (String) it.next();
if ( !new File( projectsDirectory, projectPath ).isDirectory() )
{
projectPath = getParentPath( projectPath );
}
dirs.add( projectPath );
}
boolean filter = false;
// clone project directories
try
{
filter = !cloneProjectsTo.getCanonicalFile().equals( projectsDirectory.getCanonicalFile() );
List clonedSubpaths = new ArrayList();
for ( Iterator it = dirs.iterator(); it.hasNext(); )
{
String subpath = (String) it.next();
// skip this project if its parent directory is also scheduled for cloning
if ( !".".equals( subpath ) && dirs.contains( getParentPath( subpath ) ) )
{
continue;
}
// avoid copying subdirs that are already cloned.
if ( !alreadyCloned( subpath, clonedSubpaths ) )
{
// avoid creating new files that point to dir/.
if ( ".".equals( subpath ) )
{
String cloneSubdir = relativizePath( cloneProjectsTo, projectsDirectory.getCanonicalPath() );
// avoid infinite recursion if the cloneTo path is a subdirectory.
if ( cloneSubdir != null )
{
File temp = File.createTempFile( "pre-invocation-clone.", "" );
temp.delete();
temp.mkdirs();
copyDirectoryStructure( projectsDirectory, temp );
FileUtils.deleteDirectory( new File( temp, cloneSubdir ) );
copyDirectoryStructure( temp, cloneProjectsTo );
}
else
{
copyDirectoryStructure( projectsDirectory, cloneProjectsTo );
}
}
else
{
File srcDir = new File( projectsDirectory, subpath );
File dstDir = new File( cloneProjectsTo, subpath );
copyDirectoryStructure( srcDir, dstDir );
}
clonedSubpaths.add( subpath );
}
}
}
catch ( IOException e )
{
throw new MojoExecutionException( "Failed to clone projects from: " + projectsDirectory + " to: "
+ cloneProjectsTo + ". Reason: " + e.getMessage(), e );
}
// filter cloned POMs
if ( filter )
{
for ( Iterator it = projectPaths.iterator(); it.hasNext(); )
{
String projectPath = (String) it.next();
File pomFile = new File( cloneProjectsTo, projectPath );
if ( pomFile.isFile() )
{
buildInterpolatedFile( pomFile, pomFile );
}
}
filteredPomPrefix = null;
}
}
/**
* Gets the parent path of the specified relative path.
*
* @param path The relative path whose parent should be retrieved, must not be null.
* @return The parent path or "." if the specified path has no parent, never null.
*/
private String getParentPath( String path )
{
int lastSep = Math.max( path.lastIndexOf( '/' ), path.lastIndexOf( '\\' ) );
return ( lastSep < 0 ) ? "." : path.substring( 0, lastSep );
}
/**
* Copied a directory structure with deafault exclusions (.svn, CVS, etc)
*
* @param sourceDir The source directory to copy, must not be null.
* @param destDir The target directory to copy to, must not be null.
* @throws java.io.IOException If the directory structure could not be copied.
*/
private void copyDirectoryStructure( File sourceDir, File destDir )
throws IOException
{
DirectoryScanner scanner = new DirectoryScanner();
scanner.setBasedir( sourceDir );
if ( !cloneAllFiles )
{
scanner.addDefaultExcludes();
}
scanner.scan();
/*
* NOTE: Make sure the destination directory is always there (even if empty) to support POM-less ITs.
*/
destDir.mkdirs();
String[] includedDirs = scanner.getIncludedDirectories();
for ( int i = 0; i < includedDirs.length; ++i )
{
File clonedDir = new File( destDir, includedDirs[i] );
clonedDir.mkdirs();
}
String[] includedFiles = scanner.getIncludedFiles();
for ( int i = 0; i < includedFiles.length; ++i )
{
File sourceFile = new File( sourceDir, includedFiles[i] );
File destFile = new File( destDir, includedFiles[i] );
FileUtils.copyFile( sourceFile, destFile );
}
}
/**
* Determines whether the specified sub path has already been cloned, i.e. whether one of its ancestor directories
* was already cloned.
*
* @param subpath The sub path to check, must not be null.
* @param clonedSubpaths The list of already cloned paths, must not be null nor contain
* null elements.
* @return true if the specified path has already been cloned, false otherwise.
*/
static boolean alreadyCloned( String subpath, List clonedSubpaths )
{
for ( Iterator iter = clonedSubpaths.iterator(); iter.hasNext(); )
{
String path = (String) iter.next();
if ( ".".equals( path ) || subpath.equals( path ) || subpath.startsWith( path + File.separator ) )
{
return true;
}
}
return false;
}
/**
* Runs the specified build jobs.
*
* @param projectsDir The base directory of all projects, must not be null.
* @param buildJobs The build jobs to run must not be null nor contain null elements.
* @throws org.apache.maven.plugin.MojoExecutionException If any build could not be launched.
*/
private void runBuilds( File projectsDir, BuildJob[] buildJobs )
throws MojoExecutionException
{
if ( !localRepositoryPath.exists() )
{
localRepositoryPath.mkdirs();
}
File interpolatedSettingsFile = null;
if ( settingsFile != null )
{
if ( cloneProjectsTo != null )
{
interpolatedSettingsFile = new File( cloneProjectsTo, "interpolated-" + settingsFile.getName() );
}
else
{
interpolatedSettingsFile =
new File( settingsFile.getParentFile(), "interpolated-" + settingsFile.getName() );
}
buildInterpolatedFile( settingsFile, interpolatedSettingsFile );
}
try
{
for ( int i = 0; i < buildJobs.length; i++ )
{
BuildJob project = buildJobs[i];
runBuild( projectsDir, project, interpolatedSettingsFile );
}
}
finally
{
if ( interpolatedSettingsFile != null && cloneProjectsTo == null )
{
interpolatedSettingsFile.delete();
}
}
}
/**
* Runs the specified project.
*
* @param projectsDir The base directory of all projects, must not be null.
* @param buildJob The build job to run, must not be null.
* @param settingsFile The (already interpolated) user settings file for the build, may be null to use
* the current user settings.
* @throws org.apache.maven.plugin.MojoExecutionException If the project could not be launched.
*/
private void runBuild( File projectsDir, BuildJob buildJob, File settingsFile )
throws MojoExecutionException
{
File pomFile = new File( projectsDir, buildJob.getProject() );
File basedir;
if ( pomFile.isDirectory() )
{
basedir = pomFile;
pomFile = new File( basedir, "pom.xml" );
if ( !pomFile.exists() )
{
pomFile = null;
}
else
{
buildJob.setProject( buildJob.getProject() + File.separator + "pom.xml" );
}
}
else
{
basedir = pomFile.getParentFile();
}
getLog().info( "Building: " + buildJob.getProject() );
File interpolatedPomFile = null;
if ( pomFile != null )
{
if ( filteredPomPrefix != null )
{
interpolatedPomFile = new File( basedir, filteredPomPrefix + pomFile.getName() );
buildInterpolatedFile( pomFile, interpolatedPomFile );
}
else
{
interpolatedPomFile = pomFile;
}
}
InvokerProperties invokerProperties = getInvokerProperties( basedir );
// let's set what details we can
buildJob.setName( invokerProperties.getJobName() );
buildJob.setDescription( invokerProperties.getJobDescription() );
try
{
if ( isSelected( invokerProperties ) )
{
long milliseconds = System.currentTimeMillis();
boolean executed;
try
{
executed = runBuild( basedir, interpolatedPomFile, settingsFile, invokerProperties );
}
finally
{
milliseconds = System.currentTimeMillis() - milliseconds;
buildJob.setTime( milliseconds / 1000.0 );
}
if ( executed )
{
buildJob.setResult( BuildJob.Result.SUCCESS );
if ( !suppressSummaries )
{
getLog().info( "..SUCCESS " + formatTime( buildJob.getTime() ) );
}
}
else
{
buildJob.setResult( BuildJob.Result.SKIPPED );
if ( !suppressSummaries )
{
getLog().info( "..SKIPPED " + formatTime( buildJob.getTime() ) );
}
}
}
else
{
buildJob.setResult( BuildJob.Result.SKIPPED );
if ( !suppressSummaries )
{
getLog().info( "..SKIPPED " );
}
}
}
catch ( BuildErrorException e )
{
buildJob.setResult( BuildJob.Result.ERROR );
buildJob.setFailureMessage( e.getMessage() );
if ( !suppressSummaries )
{
getLog().info( "..ERROR " + formatTime( buildJob.getTime() ) );
getLog().info( " " + e.getMessage() );
}
}
catch ( BuildFailureException e )
{
buildJob.setResult( e.getType() );
buildJob.setFailureMessage( e.getMessage() );
if ( !suppressSummaries )
{
getLog().info( "..FAILED " + formatTime( buildJob.getTime() ) );
getLog().info( " " + e.getMessage() );
}
}
finally
{
if ( interpolatedPomFile != null && StringUtils.isNotEmpty( filteredPomPrefix ) )
{
interpolatedPomFile.delete();
}
writeBuildReport( buildJob );
}
}
/**
* Determines whether selector conditions of the specified invoker properties match the current environment.
*
* @param invokerProperties The invoker properties to check, must not be null.
* @return true if the job corresponding to the properties should be run, false otherwise.
*/
private boolean isSelected( InvokerProperties invokerProperties )
{
if ( !SelectorUtils.isMavenVersion( invokerProperties.getMavenVersion() ) )
{
return false;
}
if ( !SelectorUtils.isJreVersion( invokerProperties.getJreVersion() ) )
{
return false;
}
if ( !SelectorUtils.isOsFamily( invokerProperties.getOsFamily() ) )
{
return false;
}
return true;
}
/**
* Writes the XML report for the specified build job unless report generation has been disabled.
*
* @param buildJob The build job whose report should be written, must not be null.
* @throws org.apache.maven.plugin.MojoExecutionException If the report could not be written.
*/
private void writeBuildReport( BuildJob buildJob )
throws MojoExecutionException
{
if ( disableReports )
{
return;
}
if ( !reportsDirectory.exists() )
{
reportsDirectory.mkdirs();
}
String safeFileName = buildJob.getProject().replace( '/', '_' ).replace( '\\', '_' ).replace( ' ', '_' );
if ( safeFileName.endsWith( "_pom.xml" ) )
{
safeFileName = safeFileName.substring( 0, safeFileName.length() - "_pom.xml".length() );
}
File reportFile = new File( reportsDirectory, "BUILD-" + safeFileName + ".xml" );
try
{
FileOutputStream fos = new FileOutputStream( reportFile );
try
{
Writer osw = new OutputStreamWriter( fos, buildJob.getModelEncoding() );
BuildJobXpp3Writer writer = new BuildJobXpp3Writer();
writer.write( osw, buildJob );
osw.close();
}
finally
{
fos.close();
}
}
catch ( IOException e )
{
throw new MojoExecutionException( "Failed to write build report " + reportFile, e );
}
}
/**
* Formats the specified build duration time.
*
* @param seconds The duration of the build.
* @return The formatted time, never null.
*/
private String formatTime( double seconds )
{
return secFormat.format( seconds );
}
/**
* Runs the specified project.
*
* @param basedir The base directory of the project, must not be null.
* @param pomFile The (already interpolated) POM file, may be null for a POM-less Maven invocation.
* @param settingsFile The (already interpolated) user settings file for the build, may be null to use
* the current user settings.
* @param invokerProperties The properties to use.
* @return true if the project was launched or false if the selector script indicated that
* the project should be skipped.
* @throws org.apache.maven.plugin.MojoExecutionException If the project could not be launched.
* @throws org.apache.maven.plugin.invoker.BuildFailureException If either a hook script or the build itself failed.
*/
private boolean runBuild( File basedir, File pomFile, File settingsFile, InvokerProperties invokerProperties )
throws MojoExecutionException, BuildFailureException
{
if ( getLog().isDebugEnabled() && !invokerProperties.getProperties().isEmpty() )
{
Properties props = invokerProperties.getProperties();
getLog().debug( "Using invoker properties:" );
for ( Iterator it = new TreeSet( props.keySet() ).iterator(); it.hasNext(); )
{
String key = (String) it.next();
String value = props.getProperty( key );
getLog().debug( " " + key + " = " + value );
}
}
List goals = getGoals( basedir );
List profiles = getProfiles( basedir );
Map context = new LinkedHashMap();
FileLogger logger = setupLogger( basedir );
try
{
try
{
scriptRunner.run( "selector script", basedir, selectorScript, context, logger,
BuildJob.Result.SKIPPED, false );
}
catch ( BuildErrorException e )
{
throw e;
}
catch ( BuildFailureException e )
{
return false;
}
scriptRunner.run( "pre-build script", basedir, preBuildHookScript, context, logger,
BuildJob.Result.FAILURE_PRE_HOOK, false );
final InvocationRequest request = new DefaultInvocationRequest();
request.setLocalRepositoryDirectory( localRepositoryPath );
request.setUserSettingsFile( settingsFile );
request.setInteractive( false );
request.setShowErrors( showErrors );
request.setDebug( debug );
request.setShowVersion( showVersion );
if ( logger != null )
{
request.setErrorHandler( logger );
request.setOutputHandler( logger );
}
if ( mavenHome != null )
{
invoker.setMavenHome( mavenHome );
request.addShellEnvironment( "M2_HOME", mavenHome.getAbsolutePath() );
}
if ( javaHome != null )
{
request.setJavaHome( javaHome );
}
for ( int invocationIndex = 1;; invocationIndex++ )
{
if ( invocationIndex > 1 && !invokerProperties.isInvocationDefined( invocationIndex ) )
{
break;
}
request.setBaseDirectory( basedir );
request.setPomFile( pomFile );
request.setGoals( goals );
request.setProfiles( profiles );
request.setMavenOpts( mavenOpts );
request.setOffline( false );
Properties systemProperties =
getSystemProperties( basedir, invokerProperties.getSystemPropertiesFile( invocationIndex ) );
request.setProperties( systemProperties );
invokerProperties.configureInvocation( request, invocationIndex );
if ( getLog().isDebugEnabled() )
{
try
{
getLog().debug( "Using MAVEN_OPTS: " + request.getMavenOpts() );
getLog().debug( "Executing: " + new MavenCommandLineBuilder().build( request ) );
}
catch ( CommandLineConfigurationException e )
{
getLog().debug( "Failed to display command line: " + e.getMessage() );
}
}
InvocationResult result;
try
{
result = invoker.execute( request );
}
catch ( final MavenInvocationException e )
{
getLog().debug( "Error invoking Maven: " + e.getMessage(), e );
throw new BuildFailureException( "Maven invocation failed. " + e.getMessage(),
BuildJob.Result.FAILURE_BUILD );
}
verify( result, invocationIndex, invokerProperties, logger );
}
scriptRunner.run( "post-build script", basedir, postBuildHookScript, context, logger,
BuildJob.Result.FAILURE_POST_HOOK, true );
}
finally
{
if ( logger != null )
{
logger.close();
}
}
return true;
}
/**
* Initializes the build logger for the specified project.
*
* @param basedir The base directory of the project, must not be null.
* @return The build logger or null if logging has been disabled.
* @throws org.apache.maven.plugin.MojoExecutionException If the log file could not be created.
*/
private FileLogger setupLogger( File basedir )
throws MojoExecutionException
{
FileLogger logger = null;
if ( !noLog )
{
File outputLog = new File( basedir, "build.log" );
try
{
if ( streamLogs )
{
logger = new FileLogger( outputLog, getLog() );
}
else
{
logger = new FileLogger( outputLog );
}
getLog().debug( "build log initialized in: " + outputLog );
}
catch ( IOException e )
{
throw new MojoExecutionException( "Error initializing build logfile in: " + outputLog, e );
}
}
return logger;
}
/**
* Gets the system properties to use for the specified project.
*
* @param basedir The base directory of the project, must not be null.
* @param filename The filename to the properties file to load, may be null to use the default path
* given by {@link #testPropertiesFile}.
* @return The system properties to use, may be empty but never null.
* @throws org.apache.maven.plugin.MojoExecutionException If the properties file exists but could not be read.
*/
private Properties getSystemProperties( final File basedir, final String filename )
throws MojoExecutionException
{
Properties collectedTestProperties = new Properties();
if ( testProperties != null )
{
collectedTestProperties.putAll( testProperties );
}
if ( properties != null )
{
collectedTestProperties.putAll( properties );
}
File propertiesFile = null;
if ( filename != null )
{
propertiesFile = new File( basedir, filename );
}
else if ( testPropertiesFile != null )
{
propertiesFile = new File( basedir, testPropertiesFile );
}
if ( propertiesFile != null && propertiesFile.isFile() )
{
InputStream fin = null;
try
{
fin = new FileInputStream( propertiesFile );
Properties loadedProperties = new Properties();
loadedProperties.load( fin );
collectedTestProperties.putAll( loadedProperties );
}
catch ( IOException e )
{
throw new MojoExecutionException( "Error reading system properties from " + propertiesFile );
}
finally
{
IOUtil.close( fin );
}
}
return collectedTestProperties;
}
/**
* Verifies the invocation result.
*
* @param result The invocation result to check, must not be null.
* @param invocationIndex The index of the invocation for which to check the exit code, must not be negative.
* @param invokerProperties The invoker properties used to check the exit code, must not be null.
* @param logger The build logger, may be null if logging is disabled.
* @throws org.apache.maven.plugin.invoker.BuildFailureException If the invocation result indicates a build failure.
*/
private void verify( InvocationResult result, int invocationIndex, InvokerProperties invokerProperties,
FileLogger logger )
throws BuildFailureException
{
if ( result.getExecutionException() != null )
{
throw new BuildFailureException( "The Maven invocation failed. "
+ result.getExecutionException().getMessage(), BuildJob.Result.ERROR );
}
else if ( !invokerProperties.isExpectedResult( result.getExitCode(), invocationIndex ) )
{
StringBuffer buffer = new StringBuffer( 256 );
buffer.append( "The build exited with code " ).append( result.getExitCode() ).append( ". " );
if ( logger != null )
{
buffer.append( "See " );
buffer.append( logger.getOutputFile().getAbsolutePath() );
buffer.append( " for details." );
}
else
{
buffer.append( "See console output for details." );
}
throw new BuildFailureException( buffer.toString(), BuildJob.Result.FAILURE_BUILD );
}
}
/**
* Gets the goal list for the specified project.
*
* @param basedir The base directory of the project, must not be null.
* @return The list of goals to run when building the project, may be empty but never null.
* @throws org.apache.maven.plugin.MojoExecutionException If the profile file could not be read.
*/
List getGoals( final File basedir )
throws MojoExecutionException
{
try
{
return getTokens( basedir, goalsFile, goals );
}
catch ( IOException e )
{
throw new MojoExecutionException( "error reading goals", e );
}
}
/**
* Gets the profile list for the specified project.
*
* @param basedir The base directory of the project, must not be null.
* @return The list of profiles to activate when building the project, may be empty but never null.
* @throws org.apache.maven.plugin.MojoExecutionException If the profile file could not be read.
*/
List getProfiles( File basedir )
throws MojoExecutionException
{
try
{
return getTokens( basedir, profilesFile, profiles );
}
catch ( IOException e )
{
throw new MojoExecutionException( "error reading profiles", e );
}
}
/**
* Gets the build jobs that should be processed. Note that the order of the returned build jobs is significant.
*
* @return The build jobs to process, may be empty but never null.
* @throws java.io.IOException If the projects directory could not be scanned.
*/
BuildJob[] getBuildJobs()
throws IOException
{
BuildJob[] buildJobs;
if ( ( pom != null ) && pom.exists() )
{
buildJobs = new BuildJob[] { new BuildJob( pom.getAbsolutePath(), BuildJob.Type.NORMAL ) };
}
else if ( invokerTest != null )
{
String[] testRegexes = StringUtils.split( invokerTest, "," );
List /* String */includes = new ArrayList( testRegexes.length );
for ( int i = 0, size = testRegexes.length; i < size; i++ )
{
// user just use -Dinvoker.test=MWAR191,MNG111 to use a directory thats the end is not pom.xml
includes.add( testRegexes[i] );
}
// it would be nice if we could figure out what types these are... but perhaps
// not necessary for the -Dinvoker.test=xxx t
buildJobs = scanProjectsDirectory( includes, null, BuildJob.Type.DIRECT );
}
else
{
List excludes = ( pomExcludes != null ) ? new ArrayList( pomExcludes ) : new ArrayList();
if ( this.settingsFile != null )
{
String exclude = relativizePath( this.settingsFile, projectsDirectory.getCanonicalPath() );
if ( exclude != null )
{
excludes.add( exclude.replace( '\\', '/' ) );
getLog().debug( "Automatically excluded " + exclude + " from project scanning" );
}
}
BuildJob[] setupPoms = scanProjectsDirectory( setupIncludes, excludes, BuildJob.Type.SETUP );
getLog().debug( "Setup projects: " + Arrays.asList( setupPoms ) );
BuildJob[] normalPoms = scanProjectsDirectory( pomIncludes, excludes, BuildJob.Type.NORMAL );
Map uniquePoms = new LinkedHashMap();
for ( int i = 0; i < setupPoms.length; i++ )
{
uniquePoms.put( setupPoms[i].getProject(), setupPoms[i] );
}
for ( int i = 0; i < normalPoms.length; i++ )
{
if ( !uniquePoms.containsKey( normalPoms[i].getProject() ) )
{
uniquePoms.put( normalPoms[i].getProject(), normalPoms[i] );
}
}
buildJobs = (BuildJob[]) uniquePoms.values().toArray( new BuildJob[uniquePoms.size()] );
}
relativizeProjectPaths( buildJobs );
return buildJobs;
}
/**
* Scans the projects directory for projects to build. Both (POM) files and mere directories will be matched by the
* scanner patterns. If the patterns match a directory which contains a file named "pom.xml", the results will
* include the path to this file rather than the directory path in order to avoid duplicate invocations of the same
* project.
*
* @param includes The include patterns for the scanner, may be null.
* @param excludes The exclude patterns for the scanner, may be null to exclude nothing.
* @param type The type to assign to the resulting build jobs, must not be null.
* @return The build jobs matching the patterns, never null.
* @throws java.io.IOException If the project directory could not be scanned.
*/
private BuildJob[] scanProjectsDirectory( List includes, List excludes, String type )
throws IOException
{
if ( !projectsDirectory.isDirectory() )
{
return new BuildJob[0];
}
DirectoryScanner scanner = new DirectoryScanner();
scanner.setBasedir( projectsDirectory.getCanonicalFile() );
scanner.setFollowSymlinks( false );
if ( includes != null )
{
scanner.setIncludes( (String[]) includes.toArray( new String[includes.size()] ) );
}
if ( excludes != null )
{
scanner.setExcludes( (String[]) excludes.toArray( new String[excludes.size()] ) );
}
scanner.addDefaultExcludes();
scanner.scan();
Map matches = new LinkedHashMap();
String[] includedFiles = scanner.getIncludedFiles();
for ( int i = 0; i < includedFiles.length; i++ )
{
matches.put( includedFiles[i], new BuildJob( includedFiles[i], type ) );
}
String[] includedDirs = scanner.getIncludedDirectories();
for ( int i = 0; i < includedDirs.length; i++ )
{
String includedFile = includedDirs[i] + File.separatorChar + "pom.xml";
if ( new File( scanner.getBasedir(), includedFile ).isFile() )
{
matches.put( includedFile, new BuildJob( includedFile, type ) );
}
else
{
matches.put( includedDirs[i], new BuildJob( includedDirs[i], type ) );
}
}
return (BuildJob[]) matches.values().toArray( new BuildJob[matches.size()] );
}
/**
* Relativizes the project paths of the specified build jobs against the directory specified by
* {@link #projectsDirectory} (if possible). If a project path does not denote a sub path of the projects directory,
* it is returned as is.
*
* @param buildJobs The build jobs whose project paths should be relativized, must not be null nor
* contain null elements.
* @throws java.io.IOException If any path could not be relativized.
*/
private void relativizeProjectPaths( BuildJob[] buildJobs )
throws IOException
{
String projectsDirPath = projectsDirectory.getCanonicalPath();
for ( int i = 0; i < buildJobs.length; i++ )
{
String projectPath = buildJobs[i].getProject();
File file = new File( projectPath );
if ( !file.isAbsolute() )
{
file = new File( projectsDirectory, projectPath );
}
String relativizedPath = relativizePath( file, projectsDirPath );
if ( relativizedPath == null )
{
relativizedPath = projectPath;
}
buildJobs[i].setProject( relativizedPath );
}
}
/**
* Relativizes the specified path against the given base directory. Besides relativization, the returned path will
* also be normalized, e.g. directory references like ".." will be removed.
*
* @param path The path to relativize, must not be null.
* @param basedir The (canonical path of the) base directory to relativize against, must not be null.
* @return The relative path in normal form or null if the input path does not denote a sub path of the
* base directory.
* @throws java.io.IOException If the path could not be relativized.
*/
private String relativizePath( File path, String basedir )
throws IOException
{
String relativizedPath = path.getCanonicalPath();
if ( relativizedPath.startsWith( basedir ) )
{
relativizedPath = relativizedPath.substring( basedir.length() );
if ( relativizedPath.startsWith( File.separator ) )
{
relativizedPath = relativizedPath.substring( File.separator.length() );
}
return relativizedPath;
}
else
{
return null;
}
}
/**
* Returns the map-based value source used to interpolate POMs and other stuff.
*
* @return The map-based value source for interpolation, never null.
*/
private Map getInterpolationValueSource()
{
Map props = new HashMap();
if ( interpolationsProperties != null )
{
props.putAll( interpolationsProperties );
}
if ( filterProperties != null )
{
props.putAll( filterProperties );
}
props.put( "basedir", this.project.getBasedir().getAbsolutePath() );
props.put( "baseurl", toUrl( this.project.getBasedir().getAbsolutePath() ) );
if ( settings.getLocalRepository() != null )
{
props.put( "localRepository", settings.getLocalRepository() );
props.put( "localRepositoryUrl", toUrl( settings.getLocalRepository() ) );
}
return new CompositeMap( this.project, props );
}
/**
* Converts the specified filesystem path to a URL. The resulting URL has no trailing slash regardless whether the
* path denotes a file or a directory.
*
* @param filename The filesystem path to convert, must not be null.
* @return The file: URL for the specified path, never null.
*/
private static String toUrl( String filename )
{
/*
* NOTE: Maven fails to properly handle percent-encoded "file:" URLs (WAGON-111) so don't use File.toURI() here
* as-is but use the decoded path component in the URL.
*/
String url = "file://" + new File( filename ).toURI().getPath();
if ( url.endsWith( "/" ) )
{
url = url.substring( 0, url.length() - 1 );
}
return url;
}
/**
* Gets goal/profile names for the specified project, either directly from the plugin configuration or from an
* external token file.
*
* @param basedir The base directory of the test project, must not be null.
* @param filename The (simple) name of an optional file in the project base directory from which to read
* goals/profiles, may be null.
* @param defaultTokens The list of tokens to return in case the specified token file does not exist, may be
* null.
* @return The list of goal/profile names, may be empty but never null.
* @throws java.io.IOException If the token file exists but could not be parsed.
*/
private List getTokens( File basedir, String filename, List defaultTokens )
throws IOException
{
List tokens = ( defaultTokens != null ) ? defaultTokens : new ArrayList();
if ( StringUtils.isNotEmpty( filename ) )
{
File tokenFile = new File( basedir, filename );
if ( tokenFile.exists() )
{
tokens = readTokens( tokenFile );
}
}
return tokens;
}
/**
* Reads the tokens from the specified file. Tokens are separated either by line terminators or commas. During
* parsing, the file contents will be interpolated.
*
* @param tokenFile The file to read the tokens from, must not be null.
* @return The list of tokens, may be empty but never null.
* @throws java.io.IOException If the token file could not be read.
*/
private List readTokens( final File tokenFile )
throws IOException
{
List result = new ArrayList();
BufferedReader reader = null;
try
{
Map composite = getInterpolationValueSource();
reader = new BufferedReader( new InterpolationFilterReader( newReader( tokenFile ), composite ) );
String line = null;
while ( ( line = reader.readLine() ) != null )
{
result.addAll( collectListFromCSV( line ) );
}
}
finally
{
IOUtil.close( reader );
}
return result;
}
/**
* Gets a list of comma separated tokens from the specified line.
*
* @param csv The line with comma separated tokens, may be null.
* @return The list of tokens from the line, may be empty but never null.
*/
private List collectListFromCSV( final String csv )
{
final List result = new ArrayList();
if ( ( csv != null ) && ( csv.trim().length() > 0 ) )
{
final StringTokenizer st = new StringTokenizer( csv, "," );
while ( st.hasMoreTokens() )
{
result.add( st.nextToken().trim() );
}
}
return result;
}
/**
* Interpolates the specified POM/settings file to a temporary file. The destination file may be same as the input
* file, i.e. interpolation can be performed in-place.
*
* @param originalFile The XML file to interpolate, must not be null.
* @param interpolatedFile The target file to write the interpolated contents of the original file to, must not be
* null.
* @throws org.apache.maven.plugin.MojoExecutionException If the target file could not be created.
*/
void buildInterpolatedFile( File originalFile, File interpolatedFile )
throws MojoExecutionException
{
getLog().debug( "Interpolate " + originalFile.getPath() + " to " + interpolatedFile.getPath() );
try
{
String xml;
Reader reader = null;
try
{
// interpolation with token @...@
Map composite = getInterpolationValueSource();
reader = ReaderFactory.newXmlReader( originalFile );
reader = new InterpolationFilterReader( reader, composite, "@", "@" );
xml = IOUtil.toString( reader );
}
finally
{
IOUtil.close( reader );
}
Writer writer = null;
try
{
interpolatedFile.getParentFile().mkdirs();
writer = WriterFactory.newXmlWriter( interpolatedFile );
writer.write( xml );
writer.flush();
}
finally
{
IOUtil.close( writer );
}
}
catch ( IOException e )
{
throw new MojoExecutionException( "Failed to interpolate file " + originalFile.getPath(), e );
}
}
/**
* Gets the (interpolated) invoker properties for an integration test.
*
* @param projectDirectory The base directory of the IT project, must not be null.
* @return The invoker properties, may be empty but never null.
* @throws org.apache.maven.plugin.MojoExecutionException If an I/O error occurred during reading the properties.
*/
private InvokerProperties getInvokerProperties( final File projectDirectory )
throws MojoExecutionException
{
Properties props = new Properties();
if ( invokerPropertiesFile != null )
{
File propertiesFile = new File( projectDirectory, invokerPropertiesFile );
if ( propertiesFile.isFile() )
{
InputStream in = null;
try
{
in = new FileInputStream( propertiesFile );
props.load( in );
}
catch ( IOException e )
{
throw new MojoExecutionException( "Failed to read invoker properties: " + propertiesFile, e );
}
finally
{
IOUtil.close( in );
}
}
Interpolator interpolator = new RegexBasedInterpolator();
interpolator.addValueSource( new MapBasedValueSource( getInterpolationValueSource() ) );
for ( Iterator it = props.keySet().iterator(); it.hasNext(); )
{
String key = (String) it.next();
String value = props.getProperty( key );
try
{
value = interpolator.interpolate( value, "" );
}
catch ( InterpolationException e )
{
throw new MojoExecutionException( "Failed to interpolate invoker properties: " + propertiesFile,
e );
}
props.setProperty( key, value );
}
}
return new InvokerProperties( props );
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/GroovyScriptInterpreter.java 0000644 0001750 0001750 00000006115 11137101662 032467 0 ustar tony tony 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 groovy.lang.Binding;
import groovy.lang.GroovyShell;
import java.io.File;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.tools.ant.AntClassLoader;
import org.codehaus.groovy.control.CompilerConfiguration;
/**
* Provides a facade to evaluate Groovy scripts.
*
* @author Benjamin Bentmann
* @version $Id: GroovyScriptInterpreter.java 737521 2009-01-25 15:22:26Z bentmann $
*/
class GroovyScriptInterpreter
implements ScriptInterpreter
{
/**
* {@inheritDoc}
*/
public Object evaluateScript( String script, List classPath, Map globalVariables, PrintStream scriptOutput )
throws ScriptEvaluationException
{
PrintStream origOut = System.out;
PrintStream origErr = System.err;
try
{
CompilerConfiguration config = new CompilerConfiguration( CompilerConfiguration.DEFAULT );
if ( scriptOutput != null )
{
System.setErr( scriptOutput );
System.setOut( scriptOutput );
config.setOutput( new PrintWriter( scriptOutput ) );
}
ClassLoader loader = null;
if ( classPath != null && !classPath.isEmpty() )
{
AntClassLoader childFirstLoader = new AntClassLoader( getClass().getClassLoader(), false );
for ( Iterator it = classPath.iterator(); it.hasNext(); )
{
String path = (String) it.next();
childFirstLoader.addPathComponent( new File( path ) );
}
loader = childFirstLoader;
}
Binding binding = new Binding( globalVariables );
GroovyShell interpreter = new GroovyShell( loader, binding, config );
try
{
return interpreter.evaluate( script );
}
catch ( ThreadDeath e )
{
throw e;
}
catch ( Throwable e )
{
throw new ScriptEvaluationException( e );
}
}
finally
{
System.setErr( origErr );
System.setOut( origOut );
}
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/VerifyMojo.java 0000644 0001750 0001750 00000010702 11242031713 027653 0 ustar tony tony 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 org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugin.invoker.model.io.xpp3.BuildJobXpp3Reader;
import org.codehaus.plexus.util.ReaderFactory;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
import java.io.File;
import java.io.IOException;
/**
* Checks the results of maven-invoker-plugin based integration tests and fails the build if any tests failed.
*
* @goal verify
* @phase verify
* @author olamy
* @since 1.4
*/
public class VerifyMojo extends AbstractMojo
{
/**
* Flag used to suppress certain invocations. This is useful in tailoring the build using profiles.
*
* @parameter expression="${invoker.skip}" default-value="false"
* @since 1.1
*/
private boolean skipInvocation;
/**
* Base directory where all build reports are read from.
*
* @parameter expression="${invoker.reportsDirectory}" default-value="${project.build.directory}/invoker-reports"
* @since 1.4
*/
private File reportsDirectory;
/**
* A flag controlling whether failures of the sub builds should fail the main build, too. If set to
* true, the main build will proceed even if one or more sub builds failed.
*
* @parameter expression="${maven.test.failure.ignore}" default-value="false"
* @since 1.3
*/
private boolean ignoreFailures;
/**
* Flag used to suppress the summary output notifying of successes and failures. If set to true, the
* only indication of the build's success or failure will be the effect it has on the main build (if it fails, the
* main build should fail as well).
*
* @parameter default-value="false"
*/
private boolean suppressSummaries;
/**
* Invokes Maven on the configured test projects.
*
* @throws org.apache.maven.plugin.MojoExecutionException If the goal encountered severe errors.
* @throws org.apache.maven.plugin.MojoFailureException If any of the Maven builds failed.
*/
public void execute()
throws MojoExecutionException, MojoFailureException
{
if ( skipInvocation )
{
getLog().info( "Skipping invocation per configuration."
+ " If this is incorrect, ensure the skipInvocation parameter is not set to true." );
return;
}
File[] reportFiles = ReportUtils.getReportFiles( reportsDirectory );
if ( reportFiles.length <= 0 )
{
getLog().info( "No invoker report files found, nothing to check." );
return;
}
InvokerSession invokerSession = new InvokerSession();
for ( int i = 0, size = reportFiles.length; i < size; i++ )
{
File reportFile = reportFiles[i];
try
{
BuildJobXpp3Reader reader = new BuildJobXpp3Reader();
invokerSession.addJob( reader.read( ReaderFactory.newXmlReader( reportFile ) ) );
}
catch ( XmlPullParserException e )
{
throw new MojoExecutionException( "Failed to parse report file: " + reportFile, e );
}
catch ( IOException e )
{
throw new MojoExecutionException( "Failed to read report file: " + reportFile, e );
}
}
if ( !suppressSummaries )
{
invokerSession.logSummary( getLog(), ignoreFailures );
}
invokerSession.handleFailures( getLog(), ignoreFailures );
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/MetadataUtils.java 0000644 0001750 0001750 00000014626 11252777067 030360 0 ustar tony tony 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.io.Reader;
import java.io.Writer;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TimeZone;
import org.apache.maven.artifact.Artifact;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.ReaderFactory;
import org.codehaus.plexus.util.WriterFactory;
import org.codehaus.plexus.util.xml.Xpp3Dom;
import org.codehaus.plexus.util.xml.Xpp3DomBuilder;
import org.codehaus.plexus.util.xml.Xpp3DomUtils;
import org.codehaus.plexus.util.xml.Xpp3DomWriter;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
/**
* Provides utility methods for artifact metadata processing.
*
* @author Benjamin Bentmann
*/
class MetadataUtils
{
/**
* Creates local metadata files for the specified artifact. The goal is to simulate the installation of the artifact
* by a local build, thereby decoupling the forked builds from the inderministic collection of remote repositories
* that are available to the main build and from which the artifact was originally resolved.
*
* @param file The artifact's file in the local test repository, must not be null.
* @param artifact The artifact to create metadata for, must not be null.
* @throws IOException If the metadata could not be created.
*/
public static void createMetadata( File file, Artifact artifact )
throws IOException
{
TimeZone tz = java.util.TimeZone.getTimeZone( "UTC" );
SimpleDateFormat fmt = new SimpleDateFormat( "yyyyMMddHHmmss" );
fmt.setTimeZone( tz );
String timestamp = fmt.format( new Date() );
if ( artifact.isSnapshot() )
{
File metadataFile = new File( file.getParentFile(), "maven-metadata-local.xml" );
Xpp3Dom metadata = new Xpp3Dom( "metadata" );
addChild( metadata, "groupId", artifact.getGroupId() );
addChild( metadata, "artifactId", artifact.getArtifactId() );
addChild( metadata, "version", artifact.getBaseVersion() );
Xpp3Dom versioning = new Xpp3Dom( "versioning" );
versioning.addChild( addChild( new Xpp3Dom( "snapshot" ), "localCopy", "true" ) );
addChild( versioning, "lastUpdated", timestamp );
metadata.addChild( versioning );
writeMetadata( metadataFile, metadata );
}
{
File metadataFile = new File( file.getParentFile().getParentFile(), "maven-metadata-local.xml" );
Set allVersions = new LinkedHashSet();
Xpp3Dom metadata = readMetadata( metadataFile );
if ( metadata != null )
{
Xpp3Dom versioning = metadata.getChild( "versioning" );
if ( versioning != null )
{
Xpp3Dom versions = versioning.getChild( "versions" );
if ( versions != null )
{
Xpp3Dom[] children = versions.getChildren( "version" );
for ( int i = 0; i < children.length; i++ )
{
allVersions.add( children[i].getValue() );
}
}
}
}
allVersions.add( artifact.getBaseVersion() );
metadata = new Xpp3Dom( "metadata" );
addChild( metadata, "groupId", artifact.getGroupId() );
addChild( metadata, "artifactId", artifact.getArtifactId() );
Xpp3Dom versioning = new Xpp3Dom( "versioning" );
versioning.addChild( addChildren( new Xpp3Dom( "versions" ), "version", allVersions ) );
addChild( versioning, "lastUpdated", timestamp );
metadata.addChild( versioning );
metadata = Xpp3DomUtils.mergeXpp3Dom( metadata, readMetadata( metadataFile ) );
writeMetadata( metadataFile, metadata );
}
}
private static Xpp3Dom addChild( Xpp3Dom parent, String childName, String childValue )
{
Xpp3Dom child = new Xpp3Dom( childName );
child.setValue( childValue );
parent.addChild( child );
return parent;
}
private static Xpp3Dom addChildren( Xpp3Dom parent, String childName, Collection childValues )
{
for ( Iterator it = childValues.iterator(); it.hasNext(); )
{
String childValue = (String) it.next();
addChild( parent, childName, childValue );
}
return parent;
}
private static Xpp3Dom readMetadata( File metadataFile )
throws IOException
{
if ( !metadataFile.isFile() )
{
return null;
}
Reader reader = ReaderFactory.newXmlReader( metadataFile );
try
{
try
{
return Xpp3DomBuilder.build( reader );
}
catch ( XmlPullParserException e )
{
throw (IOException) new IOException( e.getMessage() ).initCause( e );
}
}
finally
{
IOUtil.close( reader );
}
}
private static void writeMetadata( File metadataFile, Xpp3Dom metadata )
throws IOException
{
metadataFile.getParentFile().mkdirs();
Writer writer = WriterFactory.newXmlWriter( metadataFile );
try
{
Xpp3DomWriter.write( writer, metadata );
}
finally
{
IOUtil.close( writer );
}
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/SelectorUtils.java 0000644 0001750 0001750 00000014512 11267653240 030402 0 ustar tony tony 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 org.apache.maven.project.MavenProject;
import org.codehaus.plexus.util.Os;
import org.codehaus.plexus.util.StringUtils;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
/**
* Provides utility methods for selecting build jobs based on environmental conditions.
*
* @author Benjamin Bentmann
*/
class SelectorUtils
{
static void parseList( String list, Collection includes, Collection excludes )
{
String[] tokens = ( list != null ) ? StringUtils.split( list, "," ) : new String[0];
for ( int i = 0; i < tokens.length; i++ )
{
String token = tokens[i].trim();
if ( token.startsWith( "!" ) )
{
excludes.add( token.substring( 1 ) );
}
else
{
includes.add( token );
}
}
}
static boolean isOsFamily( String osSpec )
{
List includes = new ArrayList();
List excludes = new ArrayList();
parseList( osSpec, includes, excludes );
return isOsFamily( includes, true ) && !isOsFamily( excludes, false );
}
static boolean isOsFamily( List families, boolean defaultMatch )
{
if ( families != null && !families.isEmpty() )
{
for ( Iterator it = families.iterator(); it.hasNext(); )
{
String family = (String) it.next();
if ( Os.isFamily( family ) )
{
return true;
}
}
return false;
}
else
{
return defaultMatch;
}
}
/**
* Retrieves the current Maven version.
* @return The current Maven version.
*/
static String getMavenVersion()
{
try
{
// This relies on the fact that MavenProject is the in core classloader
// and that the core classloader is for the maven-core artifact
// and that should have a pom.properties file
// if this ever changes, we will have to revisit this code.
Properties properties = new Properties();
properties.load( MavenProject.class.getClassLoader().getResourceAsStream(
"META-INF/maven/org.apache.maven/maven-core/pom.properties" ) );
return StringUtils.trim( properties.getProperty( "version" ) );
}
catch ( Exception e )
{
return null;
}
}
static boolean isMavenVersion( String mavenSpec )
{
List includes = new ArrayList();
List excludes = new ArrayList();
parseList( mavenSpec, includes, excludes );
List mavenVersionList = parseVersion( getMavenVersion() );
return isJreVersion( mavenVersionList, includes, true ) && !isJreVersion( mavenVersionList, excludes, false );
}
static boolean isJreVersion( String jreSpec )
{
List includes = new ArrayList();
List excludes = new ArrayList();
parseList( jreSpec, includes, excludes );
List jreVersion = parseVersion( System.getProperty( "java.version", "" ) );
return isJreVersion( jreVersion, includes, true ) && !isJreVersion( jreVersion, excludes, false );
}
static boolean isJreVersion( List jreVersion, List versionPatterns, boolean defaultMatch )
{
if ( versionPatterns != null && !versionPatterns.isEmpty() )
{
for ( Iterator it = versionPatterns.iterator(); it.hasNext(); )
{
String versionPattern = (String) it.next();
if ( isJreVersion( jreVersion, versionPattern ) )
{
return true;
}
}
return false;
}
else
{
return defaultMatch;
}
}
static boolean isJreVersion( List jreVersion, String versionPattern )
{
List checkVersion = parseVersion( versionPattern );
if ( versionPattern.endsWith( "+" ) )
{
// 1.5+ <=> [1.5,)
return compareVersions( jreVersion, checkVersion ) >= 0;
}
else if ( versionPattern.endsWith( "-" ) )
{
// 1.5- <=> (,1.5)
return compareVersions( jreVersion, checkVersion ) < 0;
}
else
{
// 1.5 <=> [1.5,1.6)
return checkVersion.size() <= jreVersion.size() && checkVersion.equals(
jreVersion.subList( 0, checkVersion.size() ) );
}
}
static List parseVersion( String version )
{
version = version.replaceAll( "[^0-9]", "." );
String[] tokens = StringUtils.split( version, "." );
List numbers = new ArrayList();
for ( int i = 0; i < tokens.length; i++ )
{
numbers.add( Integer.valueOf( tokens[i] ) );
}
return numbers;
}
static int compareVersions( List version1, List version2 )
{
for ( Iterator it1 = version1.iterator(), it2 = version2.iterator(); ; )
{
if ( !it1.hasNext() )
{
return it2.hasNext() ? -1 : 0;
}
if ( !it2.hasNext() )
{
return it1.hasNext() ? 1 : 0;
}
Integer num1 = (Integer) it1.next();
Integer num2 = (Integer) it2.next();
int rel = num1.compareTo( num2 );
if ( rel != 0 )
{
return rel;
}
}
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/InvokerSession.java 0000644 0001750 0001750 00000017156 11270273205 030562 0 ustar tony tony 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.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugin.invoker.model.BuildJob;
import org.apache.maven.plugin.logging.Log;
/**
* Tracks a set of build jobs and their results.
*
* @author Benjamin Bentmann
*/
class InvokerSession
{
private List buildJobs;
private List failedJobs;
private List errorJobs;
private List successfulJobs;
private List skippedJobs;
/**
* Creates a new empty session.
*/
public InvokerSession()
{
buildJobs = new ArrayList();
}
/**
* Creates a session that initially contains the specified build jobs.
*
* @param buildJobs The build jobs to set, must not be null.
*/
public InvokerSession( BuildJob[] buildJobs )
{
this.buildJobs = new ArrayList( Arrays.asList( buildJobs ) );
}
/**
* Adds the specified build job to this session.
*
* @param buildJob The build job to add, must not be null.
*/
public void addJob( BuildJob buildJob )
{
buildJobs.add( buildJob );
resetStats();
}
/**
* Sets the build jobs of this session.
*
* @param buildJobs The build jobs to set, must not be null.
*/
public void setJobs( List buildJobs )
{
this.buildJobs = new ArrayList( buildJobs );
resetStats();
}
/**
* Gets the build jobs in this session.
*
* @return The build jobs in this session, can be empty but never null.
*/
public List getJobs()
{
return buildJobs;
}
/**
* Gets the successful build jobs in this session.
*
* @return The successful build jobs in this session, can be empty but never null.
*/
public List getSuccessfulJobs()
{
updateStats();
return successfulJobs;
}
/**
* Gets the failed build jobs in this session.
*
* @return The failed build jobs in this session, can be empty but never null.
*/
public List getFailedJobs()
{
updateStats();
return failedJobs;
}
/**
* Gets the build jobs which had errors for this session.
*
* @return The build jobs in error for this session, can be empty but never null.
*/
public List getErrorJobs()
{
updateStats();
return errorJobs;
}
/**
* Gets the skipped build jobs in this session.
*
* @return The skipped build jobs in this session, can be empty but never null.
*/
public List getSkippedJobs()
{
updateStats();
return skippedJobs;
}
private void resetStats()
{
successfulJobs = null;
failedJobs = null;
skippedJobs = null;
errorJobs = null;
}
private void updateStats()
{
if ( successfulJobs != null && skippedJobs != null && failedJobs != null && errorJobs != null )
{
return;
}
successfulJobs = new ArrayList();
failedJobs = new ArrayList();
skippedJobs = new ArrayList();
errorJobs = new ArrayList();
for ( Iterator iterator = buildJobs.iterator(); iterator.hasNext(); )
{
BuildJob buildJob = (BuildJob) iterator.next();
if ( BuildJob.Result.SUCCESS.equals( buildJob.getResult() ) )
{
successfulJobs.add( buildJob );
}
else if ( BuildJob.Result.SKIPPED.equals( buildJob.getResult() ) )
{
skippedJobs.add( buildJob );
}
else if ( BuildJob.Result.ERROR.equals( buildJob.getResult() ) )
{
errorJobs.add( buildJob );
}
else if ( buildJob.getResult() != null )
{
failedJobs.add( buildJob );
}
}
}
/**
* Prints a summary of this session to the specified logger.
*
* @param logger The mojo logger to output messages to, must not be null.
* @param ignoreFailures A flag whether failures should be ignored or whether a build failure should be signaled.
*/
public void logSummary( Log logger, boolean ignoreFailures )
{
updateStats();
String separator = "-------------------------------------------------";
logger.info( separator );
logger.info( "Build Summary:" );
logger.info( " Passed: " + successfulJobs.size() + ", Failed: " + failedJobs.size() + ", Errors: "
+ errorJobs.size() + ", Skipped: " + skippedJobs.size() );
logger.info( separator );
if ( !failedJobs.isEmpty() )
{
String heading = "The following builds failed:";
if ( ignoreFailures )
{
logger.warn( heading );
}
else
{
logger.error( heading );
}
for ( Iterator it = failedJobs.iterator(); it.hasNext(); )
{
BuildJob buildJob = (BuildJob) it.next();
String item = "* " + buildJob.getProject();
if ( ignoreFailures )
{
logger.warn( item );
}
else
{
logger.error( item );
}
}
logger.info( separator );
}
}
/**
* Handles the build failures in this session.
*
* @param logger The mojo logger to output messages to, must not be null.
* @param ignoreFailures A flag whether failures should be ignored or whether a build failure should be signaled.
* @throws MojoFailureException If failures are present and not ignored.
*/
public void handleFailures( Log logger, boolean ignoreFailures )
throws MojoFailureException
{
updateStats();
if ( !failedJobs.isEmpty() )
{
String message = failedJobs.size() + " build" + ( failedJobs.size() == 1 ? "" : "s" ) + " failed.";
if ( ignoreFailures )
{
logger.warn( "Ignoring that " + message );
}
else
{
throw new MojoFailureException( this, message, message );
}
}
if ( !errorJobs.isEmpty() )
{
String message = errorJobs.size() + " build" + ( errorJobs.size() == 1 ? "" : "s" ) + " in error.";
if ( ignoreFailures )
{
logger.warn( "Ignoring that " + message );
}
else
{
throw new MojoFailureException( this, message, message );
}
}
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/InstallMojo.java 0000644 0001750 0001750 00000053641 11252777067 030052 0 ustar tony tony 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. ${project.build.directory}/it-repo).
*
* @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 null.
* @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 null. This is in most cases the value
* of artifact.getFile() 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 null.
* @param testRepository The local repository to install the artifact to, must not be null.
* @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 null.
* @param artifact The artifact to install, must not be null.
* @param testRepository The local repository to install the artifact to, must not be null.
* @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 null.
* @param testRepository The local repository to install the artifacts to, must not be null.
* @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 null.
* @param testRepository The local repository to install the POMs to, must not be null.
* @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 null.
* @param testRepository The local repository to install the POM to, must not be null.
* @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 null.
* @param reactorProjects The set of projects in the reactor build, must not be null.
* @param testRepository The local repository to install the POMs to, must not be null.
* @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 null.
* @param testRepository The local repository to install the POMs to, must not be null.
* @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 null.
* @param artifactId The artifact id of the POM which should be installed, must not be null.
* @param version The version of the POM which should be installed, must not be null.
* @param testRepository The local repository to install the POMs to, must not be null.
* @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 );
}
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/BuildFailureException.java 0000644 0001750 0001750 00000004074 11140143601 032012 0 ustar tony tony 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.
*/
/**
* Signals a failure of a sub build run by the Invoker Plugin. This can be caused by an unsuccessful pre-/post-build
* script or a failure of the forked Maven build itself.
*
* @author Benjamin Bentmann
* @version $Id: BuildFailureException.java 738621 2009-01-28 21:00:49Z bentmann $
*/
class BuildFailureException
extends Exception
{
/**
* The serial version identifier for this class.
*/
private static final long serialVersionUID = 236131530635863815L;
/**
* The type of the build failure.
*/
private final String type;
/**
* Creates a new exception with the specified detail message.
*
* @param message The detail message, may be null.
* @param type The type of build failure, may not be null.
*/
public BuildFailureException( String message, String type )
{
super( message );
if ( type == null )
{
throw new IllegalArgumentException( "missing failure type" );
}
this.type = type;
}
/**
* Returns the type of build failure.
*
* @return The type of build failure, never null.
*/
public String getType()
{
return type;
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/IntegrationTestMojo.java 0000644 0001750 0001750 00000003051 11242031713 031531 0 ustar tony tony 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 org.apache.maven.plugin.MojoFailureException;
/**
* Searches for integration test Maven projects, and executes each, collecting a log in the project directory, will
* never fail the build, designed to be used in conjunction with the verify mojo.
*
* @goal integration-test
* @phase integration-test
* @requiresDependencyResolution test
* @since 1.4
*
* @author Stephen Connolly
* @version $Id: IntegrationTestMojo.java 804712 2009-08-16 16:28:59Z bentmann $
*/
public class IntegrationTestMojo
extends AbstractInvokerMojo
{
void processResults( InvokerSession invokerSession )
throws MojoFailureException
{
// do nothing
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/InvokerReport.java 0000644 0001750 0001750 00000026050 11255413576 030415 0 ustar tony tony 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.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import org.apache.maven.doxia.sink.Sink;
import org.apache.maven.doxia.siterenderer.Renderer;
import org.apache.maven.plugin.invoker.model.BuildJob;
import org.apache.maven.plugin.invoker.model.io.xpp3.BuildJobXpp3Reader;
import org.apache.maven.project.MavenProject;
import org.apache.maven.reporting.AbstractMavenReport;
import org.apache.maven.reporting.MavenReportException;
import org.codehaus.plexus.i18n.I18N;
import org.codehaus.plexus.util.ReaderFactory;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
/**
* Generate a report based on the results of the Maven invocations. Note: This mojo doesn't fork any
* lifecycle, if you have a clean working copy, you have to use a command like
* mvn clean integration-test site to ensure the build results are present when this goal is invoked.
*
* @goal report
* @author olamy
* @since 1.4
*/
public class InvokerReport
extends AbstractMavenReport
{
/**
* The Maven Project.
*
* @parameter default-value="${project}"
* @required
* @readonly
*/
protected MavenProject project;
/**
* Doxia Site Renderer component.
*
* @component
*/
protected Renderer siteRenderer;
/**
* Internationalization component.
*
* @component
*/
protected I18N i18n;
/**
* The output directory for the report. Note that this parameter is only evaluated if the goal is run directly from
* the command line. If the goal is run indirectly as part of a site generation, the output directory configured in
* the Maven Site Plugin is used instead.
*
* @parameter default-value="${project.reporting.outputDirectory}"
* @required
*/
protected File outputDirectory;
/**
* Base directory where all build reports have been written to.
*
* @parameter expression="${invoker.reportsDirectory}" default-value="${project.build.directory}/invoker-reports"
*/
private File reportsDirectory;
/**
* The number format used to print percent values in the report locale.
*/
private NumberFormat percentFormat;
/**
* The number format used to print time values in the report locale.
*/
private NumberFormat secondsFormat;
protected void executeReport( Locale locale )
throws MavenReportException
{
DecimalFormatSymbols symbols = new DecimalFormatSymbols( locale );
percentFormat = new DecimalFormat( getText( locale, "report.invoker.format.percent" ), symbols );
secondsFormat = new DecimalFormat( getText( locale, "report.invoker.format.seconds" ), symbols );
Sink sink = getSink();
sink.head();
sink.title();
sink.text( getText( locale, "report.invoker.result.title" ) );
sink.title_();
sink.head_();
sink.body();
sink.section1();
sink.sectionTitle1();
sink.text( getText( locale, "report.invoker.result.title" ) );
sink.sectionTitle1_();
sink.paragraph();
sink.text( getText( locale, "report.invoker.result.description" ) );
sink.paragraph_();
sink.section1_();
// ----------------------------------
// build buildJob beans
// ----------------------------------
File[] reportFiles = ReportUtils.getReportFiles( reportsDirectory );
if ( reportFiles.length <= 0 )
{
getLog().info( "no invoker report files found, skip report generation" );
return;
}
List buildJobs = new ArrayList( reportFiles.length );
for ( int i = 0, size = reportFiles.length; i < size; i++ )
{
File reportFile = reportFiles[i];
try
{
BuildJobXpp3Reader reader = new BuildJobXpp3Reader();
buildJobs.add( reader.read( ReaderFactory.newXmlReader( reportFile ) ) );
}
catch ( XmlPullParserException e )
{
throw new MavenReportException( "Failed to parse report file: " + reportFile, e );
}
catch ( IOException e )
{
throw new MavenReportException( "Failed to read report file: " + reportFile, e );
}
}
// ----------------------------------
// summary
// ----------------------------------
constructSummarySection( buildJobs, locale );
// ----------------------------------
// per file/it detail
// ----------------------------------
sink.section2();
sink.sectionTitle2();
sink.text( getText( locale, "report.invoker.detail.title" ) );
sink.sectionTitle2_();
sink.section2_();
// detail tests table header
sink.table();
sink.tableRow();
// -------------------------------------------
// name | Result | time | message
// -------------------------------------------
sinkTableHeader( sink, getText( locale, "report.invoker.detail.name" ) );
sinkTableHeader( sink, getText( locale, "report.invoker.detail.result" ) );
sinkTableHeader( sink, getText( locale, "report.invoker.detail.time" ) );
sinkTableHeader( sink, getText( locale, "report.invoker.detail.message" ) );
sink.tableRow_();
for ( Iterator iterator = buildJobs.iterator(); iterator.hasNext(); )
{
BuildJob buildJob = (BuildJob) iterator.next();
renderBuildJob( buildJob, locale );
}
sink.table_();
sink.body_();
sink.flush();
sink.close();
}
private void constructSummarySection( List /* BuildJob */buildJobs, Locale locale )
{
Sink sink = getSink();
sink.section2();
sink.sectionTitle2();
sink.text( getText( locale, "report.invoker.summary.title" ) );
sink.sectionTitle2_();
sink.section2_();
// ------------------------------------------------------------------------
// Building a table with
// it number | succes nb | failed nb | Success rate | total time | avg time
// ------------------------------------------------------------------------
sink.table();
sink.tableRow();
sinkTableHeader( sink, getText( locale, "report.invoker.summary.number" ) );
sinkTableHeader( sink, getText( locale, "report.invoker.summary.success" ) );
sinkTableHeader( sink, getText( locale, "report.invoker.summary.failed" ) );
sinkTableHeader( sink, getText( locale, "report.invoker.summary.success.rate" ) );
sinkTableHeader( sink, getText( locale, "report.invoker.summary.time.total" ) );
sinkTableHeader( sink, getText( locale, "report.invoker.summary.time.avg" ) );
int number = buildJobs.size();
int success = 0;
int failed = 0;
double totalTime = 0;
for ( Iterator iterator = buildJobs.iterator(); iterator.hasNext(); )
{
BuildJob buildJob = (BuildJob) iterator.next();
if ( BuildJob.Result.SUCCESS.equals( buildJob.getResult() ) )
{
success++;
}
else if ( !BuildJob.Result.SKIPPED.equals( buildJob.getResult() ) )
{
failed++;
}
totalTime += buildJob.getTime();
}
sink.tableRow_();
sink.tableRow();
sinkCell( sink, Integer.toString( number ) );
sinkCell( sink, Integer.toString( success ) );
sinkCell( sink, Integer.toString( failed ) );
if ( success + failed > 0 )
{
sinkCell( sink, percentFormat.format( (double) success / ( success + failed ) ) );
}
else
{
sinkCell( sink, "" );
}
sinkCell( sink, secondsFormat.format( totalTime ) );
sinkCell( sink, secondsFormat.format( totalTime / number ) );
sink.tableRow_();
sink.table_();
}
private void renderBuildJob( BuildJob buildJob, Locale locale )
{
Sink sink = getSink();
sink.tableRow();
StringBuffer buffer = new StringBuffer();
if ( !StringUtils.isEmpty( buildJob.getName() ) && !StringUtils.isEmpty( buildJob.getDescription() ) )
{
buffer.append( buildJob.getName() );
buffer.append( " : " );
buffer.append( buildJob.getDescription() );
}
else
{
buffer.append( buildJob.getProject() );
}
sinkCell( sink, buffer.toString() );
// FIXME image
sinkCell( sink, buildJob.getResult() );
sinkCell( sink, secondsFormat.format( buildJob.getTime() ) );
sinkCell( sink, buildJob.getFailureMessage() );
sink.tableRow_();
}
protected String getOutputDirectory()
{
return outputDirectory.getAbsolutePath();
}
protected MavenProject getProject()
{
return project;
}
protected Renderer getSiteRenderer()
{
return siteRenderer;
}
public String getDescription( Locale locale )
{
return getText( locale, "report.invoker.result.description" );
}
public String getName( Locale locale )
{
return getText( locale, "report.invoker.result.name" );
}
public String getOutputName()
{
return "invoker-report";
}
public boolean canGenerateReport()
{
return ReportUtils.getReportFiles( reportsDirectory ).length > 0;
}
private String getText( Locale locale, String key )
{
return i18n.getString( "invoker-report", locale, key );
}
private void sinkTableHeader( Sink sink, String header )
{
sink.tableHeaderCell();
sink.text( header );
sink.tableHeaderCell_();
}
private void sinkCell( Sink sink, String text )
{
sink.tableCell();
sink.text( text );
sink.tableCell_();
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/ReportUtils.java 0000644 0001750 0001750 00000003111 11242031713 030052 0 ustar tony tony 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;
/**
* Provides utility methods for invoker report processing.
*
* @author Benjamin Bentmann
*/
class ReportUtils
{
/**
* Gets the paths to the invoker reports available in the specified directory.
*
*@param reportsDirectory The base directory where the invoker reports are located in, may be null.
* @return The paths to the invoker reports, can be empty but never null.
*/
public static File[] getReportFiles( File reportsDirectory )
{
File[] reportFiles = ( reportsDirectory != null ) ? reportsDirectory.listFiles() : null;
if ( reportFiles == null )
{
reportFiles = new File[0];
}
return reportFiles;
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/ScriptRunner.java 0000644 0001750 0001750 00000024655 11267526125 030251 0 ustar tony tony 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.io.PrintStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.logging.Log;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.StringUtils;
/**
* Runs pre-/post-build hook scripts.
*
* @author Benjamin Bentmann
* @version $Id: ScriptRunner.java 827900 2009-10-21 06:38:13Z stephenc $
*/
class ScriptRunner
{
/**
* The mojo logger to print diagnostic to, never null.
*/
private Log log;
/**
* The supported script interpreters, indexed by the lower-case file extension of their associated script files,
* never null.
*/
private Map scriptInterpreters;
/**
* The common set of global variables to pass into the script interpreter, never null.
*/
private Map globalVariables;
/**
* The additional class path for the script interpreter, never null.
*/
private List classPath;
/**
* The file encoding of the hook scripts or null to use platform encoding.
*/
private String encoding;
/**
* Creates a new script runner.
*
* @param log The mojo logger to print diagnostic to, must not be null.
*/
public ScriptRunner( Log log )
{
if ( log == null )
{
throw new IllegalArgumentException( "missing logger" );
}
this.log = log;
scriptInterpreters = new LinkedHashMap();
scriptInterpreters.put( "bsh", new BeanShellScriptInterpreter() );
scriptInterpreters.put( "groovy", new GroovyScriptInterpreter() );
globalVariables = new HashMap();
classPath = new ArrayList();
}
/**
* Gets the mojo logger.
*
* @return The mojo logger, never null.
*/
private Log getLog()
{
return log;
}
/**
* Sets a global variable for the script interpeter.
*
* @param name The name of the variable, must not be null.
* @param value The value of the variable, may be null.
*/
public void setGlobalVariable( String name, Object value )
{
this.globalVariables.put( name, value );
}
/**
* Sets the additional class path for the hook scripts. Note that the provided list is copied, so any later changes
* will not affect the scripts.
*
* @param classPath The additional class path for the script interpreter, may be null or empty if only
* the plugin realm should be used for the script evaluation. If specified, this class path will precede
* the artifacts from the plugin class path.
*/
public void setClassPath( List classPath )
{
this.classPath = ( classPath != null ) ? new ArrayList( classPath ) : new ArrayList();
}
/**
* Sets the file encoding of the hook scripts.
*
* @param encoding The file encoding of the hook scripts, may be null or empty to use the platform's
* default encoding.
*/
public void setScriptEncoding( String encoding )
{
this.encoding = StringUtils.isNotEmpty( encoding ) ? encoding : null;
}
/**
* Runs the specified hook script of the specified project (if any).
*
* @param scriptDescription The description of the script to use for logging, must not be null.
* @param basedir The base directory of the project, must not be null.
* @param relativeScriptPath The path to the script relative to the project base directory, may be null
* to skip the script execution.
* @param context The key-value storage used to share information between hook scripts, may be null.
* @param logger The logger to redirect the script output to, may be null to use stdout/stderr.
* @param stage The stage of the build job the script is invoked in, must not be null.
* @param failOnException If true and the script throws an exception, then a {@link BuildFailureException}
* will be thrown, otherwise a {@link BuildErrorException} will be thrown on script exception.
* @throws MojoExecutionException If an I/O error occurred while reading the script file.
* @throws BuildFailureException If the script did not return true of threw an exception.
*/
public void run( final String scriptDescription, final File basedir, final String relativeScriptPath,
final Map context, final FileLogger logger, String stage, boolean failOnException )
throws MojoExecutionException, BuildFailureException
{
if ( relativeScriptPath == null )
{
return;
}
final File scriptFile = resolveScript( new File( basedir, relativeScriptPath ) );
if ( !scriptFile.exists() )
{
return;
}
Map globalVariables = new HashMap( this.globalVariables );
globalVariables.put( "basedir", basedir );
globalVariables.put( "context", context );
PrintStream out = ( logger != null ) ? logger.getPrintStream() : null;
ScriptInterpreter interpreter = getInterpreter( scriptFile );
if ( getLog().isDebugEnabled() )
{
String name = interpreter.getClass().getName();
name = name.substring( name.lastIndexOf( '.' ) + 1 );
getLog().debug( "Running script with " + name + ": " + scriptFile );
}
String script;
try
{
script = FileUtils.fileRead( scriptFile, encoding );
}
catch ( IOException e )
{
String errorMessage =
"error reading " + scriptDescription + " " + scriptFile.getPath() + ", " + e.getMessage();
throw new MojoExecutionException( errorMessage, e );
}
Object result;
try
{
if ( logger != null )
{
logger.consumeLine( "Running " + scriptDescription + ": " + scriptFile );
}
result = interpreter.evaluateScript( script, classPath, globalVariables, out );
if ( logger != null )
{
logger.consumeLine( "Finished " + scriptDescription + ": " + scriptFile );
}
}
catch ( ScriptEvaluationException e )
{
Throwable t = ( e.getCause() != null ) ? e.getCause() : e;
String msg = ( t.getMessage() != null ) ? t.getMessage() : t.toString();
if ( getLog().isDebugEnabled() )
{
String errorMessage = "Error evaluating " + scriptDescription + " " + scriptFile.getPath() + ", " + t;
getLog().debug( errorMessage, t );
}
if ( logger != null )
{
t.printStackTrace( logger.getPrintStream() );
}
if ( failOnException )
{
throw new BuildFailureException( "The " + scriptDescription + " did not succeed. " + msg, stage );
}
else
{
throw new BuildErrorException( "The " + scriptDescription + " did not succeed. " + msg, stage, t );
}
}
if ( !( result == null || Boolean.TRUE.equals( result ) || "true".equals( result ) ) )
{
throw new BuildFailureException( "The " + scriptDescription + " returned " + result + ".", stage );
}
}
/**
* Gets the effective path to the specified script. For convenience, we allow to specify a script path as "verify"
* and have the plugin auto-append the file extension to search for "verify.bsh" and "verify.groovy".
*
* @param scriptFile The script file to resolve, may be null.
* @return The effective path to the script file or null if the input was null.
*/
private File resolveScript( File scriptFile )
{
if ( scriptFile != null && !scriptFile.exists() )
{
for ( Iterator it = this.scriptInterpreters.keySet().iterator(); it.hasNext(); )
{
String ext = (String) it.next();
File candidateFile = new File( scriptFile.getPath() + '.' + ext );
if ( candidateFile.exists() )
{
scriptFile = candidateFile;
break;
}
}
}
return scriptFile;
}
/**
* Determines the script interpreter for the specified script file by looking at its file extension. In this
* context, file extensions are considered case-insensitive. For backward compatibility with plugin versions 1.2-,
* the BeanShell interpreter will be used for any unrecognized extension.
*
* @param scriptFile The script file for which to determine an interpreter, must not be null.
* @return The script interpreter for the file, never null.
*/
private ScriptInterpreter getInterpreter( File scriptFile )
{
String ext = FileUtils.extension( scriptFile.getName() ).toLowerCase( Locale.ENGLISH );
ScriptInterpreter interpreter = (ScriptInterpreter) scriptInterpreters.get( ext );
if ( interpreter == null )
{
interpreter = (ScriptInterpreter) scriptInterpreters.get( "bsh" );
}
return interpreter;
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/InvokerMojo.java 0000644 0001750 0001750 00000004051 11242031713 030024 0 ustar tony tony 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 org.apache.maven.plugin.MojoFailureException;
/**
* Searches for integration test Maven projects, and executes each, collecting a log in the project directory, and
* outputting the results to the command line.
*
* @goal run
* @phase integration-test
* @requiresDependencyResolution test
* @since 1.0
*
* @author Kenney Westerhof
* @author John Casey
* @version $Id: InvokerMojo.java 804712 2009-08-16 16:28:59Z bentmann $
*/
public class InvokerMojo
extends AbstractInvokerMojo
{
/**
* A flag controlling whether failures of the sub builds should fail the main build, too. If set to
* true, the main build will proceed even if one or more sub builds failed.
*
* @parameter expression="${maven.test.failure.ignore}" default-value="false"
* @since 1.3
*/
private boolean ignoreFailures;
void processResults( InvokerSession invokerSession )
throws MojoFailureException
{
if ( !suppressSummaries )
{
invokerSession.logSummary( getLog(), ignoreFailures );
}
invokerSession.handleFailures( getLog(), ignoreFailures );
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/BuildErrorException.java 0000644 0001750 0001750 00000003403 11267406352 031526 0 ustar tony tony 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.
*/
/**
* Signals an error in a sub build run by the Invoker Plugin. This can be caused by a selector/pre-build
* script throwing an exception or an error in forking the Maven build itself.
*
* @author Stephen Connolly
* @version $Id: BuildErrorException.java 827765 2009-10-20 19:18:02Z stephenc $
*/
class BuildErrorException
extends BuildFailureException
{
/**
* The serial version identifier for this class.
*/
private static final long serialVersionUID = 236131530635863815L;
/**
* Creates a new exception with the specified detail message.
*
* @param message The detail message, may be null.
* @param type The type of build failure, may not be null.
* @param cause The cause of the build error.
*/
public BuildErrorException( String message, String type, Throwable cause )
{
super( message, type );
initCause( cause );
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/ScriptEvaluationException.java maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/ScriptEvaluationException.jav0000644 0001750 0001750 00000003052 11047613663 032611 0 ustar tony tony 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.
*/
/**
* Signals an error during parsing/evaluation of a script. This can either be a syntax error in the script itself or an
* exception triggered by the methods it invoked.
*
* @author Benjamin Bentmann
* @version $Id: ScriptEvaluationException.java 684549 2008-08-10 16:30:43Z bentmann $
*/
class ScriptEvaluationException
extends Exception
{
/**
* The serial version identifier for this class.
*/
private static final long serialVersionUID = 199336743291078393L;
/**
* Creates a new exception with the specified cause.
*
* @param cause The cause, may be null.
*/
public ScriptEvaluationException( Throwable cause )
{
super( cause );
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/BeanShellScriptInterpreter.java maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/BeanShellScriptInterpreter.ja0000644 0001750 0001750 00000010040 11137101662 032500 0 ustar tony tony 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.io.PrintStream;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import bsh.Capabilities;
import bsh.EvalError;
import bsh.Interpreter;
import bsh.TargetError;
/**
* Provides a facade to evaluate BeanShell scripts.
*
* @author Benjamin Bentmann
* @version $Id: BeanShellScriptInterpreter.java 737521 2009-01-25 15:22:26Z bentmann $
*/
class BeanShellScriptInterpreter
implements ScriptInterpreter
{
/**
* {@inheritDoc}
*/
public Object evaluateScript( String script, List classPath, Map globalVariables, PrintStream scriptOutput )
throws ScriptEvaluationException
{
PrintStream origOut = System.out;
PrintStream origErr = System.err;
try
{
Interpreter engine = new Interpreter();
if ( scriptOutput != null )
{
System.setErr( scriptOutput );
System.setOut( scriptOutput );
engine.setErr( scriptOutput );
engine.setOut( scriptOutput );
}
if ( !Capabilities.haveAccessibility() )
{
try
{
Capabilities.setAccessibility( true );
}
catch ( Exception e )
{
if ( scriptOutput != null )
{
e.printStackTrace( scriptOutput );
}
}
}
if ( classPath != null && !classPath.isEmpty() )
{
for ( Iterator it = classPath.iterator(); it.hasNext(); )
{
String path = (String) it.next();
try
{
engine.getClassManager().addClassPath( new File( path ).toURI().toURL() );
}
catch ( IOException e )
{
throw new RuntimeException( "bad class path: " + path, e );
}
}
}
if ( globalVariables != null )
{
for ( Iterator it = globalVariables.keySet().iterator(); it.hasNext(); )
{
String variable = (String) it.next();
Object value = globalVariables.get( variable );
try
{
engine.set( variable, value );
}
catch ( EvalError e )
{
throw new RuntimeException( e );
}
}
}
try
{
return engine.eval( script );
}
catch ( TargetError e )
{
throw new ScriptEvaluationException( e.getTarget() );
}
catch ( ThreadDeath e )
{
throw e;
}
catch ( Throwable e )
{
throw new ScriptEvaluationException( e );
}
}
finally
{
System.setErr( origErr );
System.setOut( origOut );
}
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/ScriptInterpreter.java 0000644 0001750 0001750 00000004445 11047613663 031276 0 ustar tony tony 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.PrintStream;
import java.util.List;
import java.util.Map;
/**
* Defines a simple abstraction used to plug-in several script interpreters for the pre-/post-build-hooks. Each
* interpretator implementation should be stateless and support reuse.
*
* @author Benjamin Bentmann
* @version $Id: ScriptInterpreter.java 684549 2008-08-10 16:30:43Z bentmann $
*/
interface ScriptInterpreter
{
/**
* Evaluates the specified script.
*
* @param script The script contents to evalute, must not be null.
* @param classPath The additional class path for the script interpreter, may be null or empty if only
* the plugin realm should be used for the script evaluation. If specified, this class path will precede
* the artifacts from the plugin class path.
* @param globalVariables The global variables (as a mapping from variable name to value) to define for the script,
* may be null if not used.
* @param scriptOutput A print stream to redirect any output from the script to, may be null to use
* stdout/stderr.
* @return The return value from the script, can be null
* @throws ScriptEvaluationException If the script evaluation produced an error.
*/
Object evaluateScript( String script, List classPath, Map globalVariables, PrintStream scriptOutput )
throws ScriptEvaluationException;
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/InvokerProperties.java 0000644 0001750 0001750 00000023021 11267653240 031266 0 ustar tony tony 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.util.ArrayList;
import java.util.Arrays;
import java.util.Properties;
import org.apache.maven.shared.invoker.InvocationRequest;
import org.codehaus.plexus.util.StringUtils;
/**
* Provides a convenient facade around the invoker.properties.
*
* @author Benjamin Bentmann
* @version $Id: InvokerProperties.java 828136 2009-10-21 18:44:48Z stephenc $
*/
class InvokerProperties
{
/**
* The invoker properties being wrapped, never null.
*/
private final Properties properties;
/**
* The constant for the invoker property.
*/
private static final String PROJECT = "invoker.project";
/**
* The constant for the invoker property.
*/
private static final String GOALS = "invoker.goals";
/**
* The constant for the invoker property.
*/
private static final String PROFILES = "invoker.profiles";
/**
* The constant for the invoker property.
*/
private static final String MAVEN_OPTS = "invoker.mavenOpts";
/**
* The constant for the invoker property.
*/
private static final String FAILURE_BEHAVIOR = "invoker.failureBehavior";
/**
* The constant for the invoker property.
*/
private static final String NON_RECURSIVE = "invoker.nonRecursive";
/**
* The constant for the invoker property.
*/
private static final String OFFLINE = "invoker.offline";
/**
* The constant for the invoker property.
*/
private static final String SYSTEM_PROPERTIES_FILE = "invoker.systemPropertiesFile";
/**
* Creates a new facade for the specified invoker properties. The properties will not be copied, so any changes to
* them will be reflected by the facade.
*
* @param properties The invoker properties to wrap, may be null if none.
*/
public InvokerProperties( Properties properties )
{
this.properties = ( properties != null ) ? properties : new Properties();
}
/**
* Gets the invoker properties being wrapped.
*
* @return The invoker properties being wrapped, never null.
*/
public Properties getProperties()
{
return this.properties;
}
/**
* Gets the name of the corresponding build job.
*
* @return The name of the build job or an empty string if not set.
*/
public String getJobName()
{
return this.properties.getProperty( "invoker.name", "" );
}
/**
* Gets the description of the corresponding build job.
*
* @return The description of the build job or an empty string if not set.
*/
public String getJobDescription()
{
return this.properties.getProperty( "invoker.description", "" );
}
/**
* Gets the specification of JRE versions on which this build job should be run.
*
* @return The specification of JRE versions or an empty string if not set.
*/
public String getJreVersion()
{
return this.properties.getProperty( "invoker.java.version", "" );
}
/**
* Gets the specification of Maven versions on which this build job should be run.
*
* @return The specification of Maven versions on which this build job should be run.
* @since 1.5
*/
public String getMavenVersion()
{
return this.properties.getProperty( "invoker.maven.version", "" );
}
/**
* Gets the specification of OS families on which this build job should be run.
*
* @return The specification of OS families or an empty string if not set.
*/
public String getOsFamily()
{
return this.properties.getProperty( "invoker.os.family", "" );
}
/**
* Determines whether these invoker properties contain a build definition for the specified invocation index.
*
* @param index The one-based index of the invocation to check for, must not be negative.
* @return true if the invocation with the specified index is defined, false otherwise.
*/
public boolean isInvocationDefined( int index )
{
String[] keys =
{ PROJECT, GOALS, PROFILES, MAVEN_OPTS, FAILURE_BEHAVIOR, NON_RECURSIVE, OFFLINE, SYSTEM_PROPERTIES_FILE };
for ( int i = 0; i < keys.length; i++ )
{
if ( properties.getProperty( keys[i] + '.' + index ) != null )
{
return true;
}
}
return false;
}
/**
* Configures the specified invocation request from these invoker properties. Settings not present in the invoker
* properties will be left unchanged in the invocation request.
*
* @param request The invocation request to configure, must not be null.
* @param index The one-based index of the invocation to configure, must not be negative.
*/
public void configureInvocation( InvocationRequest request, int index )
{
String project = get( PROJECT, index );
if ( project != null )
{
File file = new File( request.getBaseDirectory(), project );
if ( file.isFile() )
{
request.setBaseDirectory( file.getParentFile() );
request.setPomFile( file );
}
else
{
request.setBaseDirectory( file );
request.setPomFile( null );
}
}
String goals = get( GOALS, index );
if ( goals != null )
{
request.setGoals( new ArrayList( Arrays.asList( StringUtils.split( goals, ", \t\n\r\f" ) ) ) );
}
String profiles = get( PROFILES, index );
if ( profiles != null )
{
request.setProfiles( new ArrayList( Arrays.asList( StringUtils.split( profiles, ", \t\n\r\f" ) ) ) );
}
String mvnOpts = get( MAVEN_OPTS, index );
if ( mvnOpts != null )
{
request.setMavenOpts( mvnOpts );
}
String failureBehavior = get( FAILURE_BEHAVIOR, index );
if ( failureBehavior != null )
{
request.setFailureBehavior( failureBehavior );
}
String nonRecursive = get( NON_RECURSIVE, index );
if ( nonRecursive != null )
{
request.setRecursive( !Boolean.valueOf( nonRecursive ).booleanValue() );
}
String offline = get( OFFLINE, index );
if ( offline != null )
{
request.setOffline( Boolean.valueOf( offline ).booleanValue() );
}
}
/**
* Checks whether the specified exit code matches the one expected for the given invocation.
*
* @param exitCode The exit code of the Maven invocation to check.
* @param index The index of the invocation for which to check the exit code, must not be negative.
* @return true if the exit code is zero and a success was expected or if the exit code is non-zero and
* a failue was expected, false otherwise.
*/
public boolean isExpectedResult( int exitCode, int index )
{
boolean nonZeroExit = "failure".equalsIgnoreCase( get( "invoker.buildResult", index ) );
return ( exitCode != 0 ) == nonZeroExit;
}
/**
* Gets the path to the properties file used to set the system properties for the specified execution.
*
* @param index The index of the invocation for which to check the exit code, must not be negative.
* @return The path to the properties file or null if not set.
*/
public String getSystemPropertiesFile( int index )
{
return get( SYSTEM_PROPERTIES_FILE, index );
}
/**
* Gets a value from the invoker properties. The invoker properties are intended to describe the invocation settings
* for multiple builds of the same project. For this reason, the properties are indexed. First, a property named
* key.index will be queried. If this property does not exist, the value of the property named
* key will finally be returned.
*
* @param key The (base) key for the invoker property to lookup, must not be null.
* @param index The index of the invocation for which to retrieve the value, must not be negative.
* @return The value for the requested invoker property or null if not defined.
*/
String get( String key, int index )
{
if ( index < 0 )
{
throw new IllegalArgumentException( "invalid invocation index: " + index );
}
String value = properties.getProperty( key + '.' + index );
if ( value == null )
{
value = properties.getProperty( key );
}
return value;
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/FileLogger.java 0000644 0001750 0001750 00000010343 11047107157 027613 0 ustar tony tony 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 org.apache.maven.plugin.logging.Log;
import org.apache.maven.shared.invoker.InvocationOutputHandler;
import org.codehaus.plexus.util.IOUtil;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
/**
* @version $Id: FileLogger.java 684034 2008-08-08 18:20:31Z bentmann $
*/
class FileLogger
implements InvocationOutputHandler
{
/**
* The path to the log file.
*/
private File file;
/**
* The underlying file stream this logger writes to.
*/
private PrintStream stream;
/**
* A flag whether the output stream should be closed during finalization of this logger.
*/
private boolean shouldFinalize = true;
/**
* The optional mojo logger to additionally write messages to, can be nulll.
*/
private final Log log;
/**
* Creates a new logger that writes to the specified file.
*
* @param outputFile The path to the output file, must not be null.
* @throws IOException If the output file could not be created.
*/
public FileLogger( File outputFile )
throws IOException
{
this( outputFile, null );
}
/**
* Creates a new logger that writes to the specified file and optionally mirrors messages to the given mojo logger.
*
* @param outputFile The path to the output file, must not be null.
* @param log The mojo logger to additionally output messages to, may be null if not used.
* @throws IOException If the output file could not be created.
*/
public FileLogger( File outputFile, Log log )
throws IOException
{
this.file = outputFile;
this.log = log;
outputFile.getParentFile().mkdirs();
stream = new PrintStream( new FileOutputStream( outputFile ) );
Runnable finalizer = new Runnable()
{
public void run()
{
try
{
finalize();
}
catch ( Throwable e )
{
// ignore
}
}
};
Runtime.getRuntime().addShutdownHook( new Thread( finalizer ) );
}
/**
* Gets the path to the output file.
*
* @return The path to the output file, never null.
*/
public File getOutputFile()
{
return file;
}
/**
* Gets the underlying stream used to write message to the log file.
*
* @return The underlying stream used to write message to the log file, never null.
*/
public PrintStream getPrintStream()
{
return stream;
}
/**
* Writes the specified line to the log file and optionally to the mojo logger.
*
* @param line The message to log.
*/
public void consumeLine( String line )
{
stream.println( line );
stream.flush();
if ( log != null )
{
log.info( line );
}
}
/**
* Closes the underlying file stream.
*/
public void close()
{
if ( stream != null )
{
stream.flush();
}
IOUtil.close( stream );
}
/**
* Closes the underlying file stream.
*/
protected void finalize()
{
if ( shouldFinalize )
{
close();
}
}
}
maven-invoker-plugin-1.5/src/main/java/org/apache/maven/plugin/invoker/PomUtils.java 0000644 0001750 0001750 00000004343 11150621463 027347 0 ustar tony tony 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.io.Reader;
import org.apache.maven.model.Model;
import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
import org.apache.maven.plugin.MojoExecutionException;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.ReaderFactory;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
/**
* Provides utility methods for POM processing.
*
* @author Benjamin Bentmann
*/
class PomUtils
{
/**
* Loads the (raw) model from the specified POM file.
*
* @param pomFile The path to the POM file to load, must not be null.
* @return The raw model, never null.
* @throws MojoExecutionException If the POM file could not be loaded.
*/
public static Model loadPom( File pomFile )
throws MojoExecutionException
{
Reader reader = null;
try
{
reader = ReaderFactory.newXmlReader( pomFile );
return new MavenXpp3Reader().read( reader, false );
}
catch ( XmlPullParserException e )
{
throw new MojoExecutionException( "Failed to parse POM: " + pomFile, e );
}
catch ( IOException e )
{
throw new MojoExecutionException( "Failed to read POM: " + pomFile, e );
}
finally
{
IOUtil.close( reader );
}
}
}
maven-invoker-plugin-1.5/src/main/mdo/ 0000755 0001750 0001750 00000000000 11623526250 016474 5 ustar tony tony maven-invoker-plugin-1.5/src/main/mdo/invocation.mdo 0000644 0001750 0001750 00000015140 11140143601 021334 0 ustar tony tony
-Dinvoker.test=xxx,yyy parameter.
*/
public static final String DIRECT = "direct";
}
]]>