package org.apache.maven;
/*
* 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.FileNotFoundException;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import java.util.TimeZone;
import org.apache.maven.artifact.manager.DefaultWagonManager;
import org.apache.maven.artifact.manager.WagonManager;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.resolver.ArtifactResolver;
import org.apache.maven.artifact.resolver.DefaultArtifactResolver;
import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
import org.apache.maven.execution.BuildFailure;
import org.apache.maven.execution.DefaultMavenExecutionRequest;
import org.apache.maven.execution.MavenExecutionRequest;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.execution.ReactorManager;
import org.apache.maven.execution.RuntimeInformation;
import org.apache.maven.lifecycle.LifecycleExecutionException;
import org.apache.maven.lifecycle.LifecycleExecutor;
import org.apache.maven.model.Profile;
import org.apache.maven.monitor.event.DefaultEventDispatcher;
import org.apache.maven.monitor.event.EventDispatcher;
import org.apache.maven.monitor.event.MavenEvents;
import org.apache.maven.profiles.ProfileManager;
import org.apache.maven.profiles.activation.ProfileActivationException;
import org.apache.maven.project.DuplicateProjectException;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.MavenProjectBuilder;
import org.apache.maven.project.MissingProjectException;
import org.apache.maven.project.ProjectBuildingException;
import org.apache.maven.reactor.MavenExecutionException;
import org.apache.maven.settings.Mirror;
import org.apache.maven.settings.Proxy;
import org.apache.maven.settings.Server;
import org.apache.maven.settings.Settings;
import org.apache.maven.usability.SystemWarnings;
import org.apache.maven.usability.diagnostics.ErrorDiagnostics;
import org.codehaus.plexus.PlexusConstants;
import org.codehaus.plexus.PlexusContainer;
import org.codehaus.plexus.component.repository.exception.ComponentLifecycleException;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
import org.codehaus.plexus.context.Context;
import org.codehaus.plexus.context.ContextException;
import org.codehaus.plexus.logging.AbstractLogEnabled;
import org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.Os;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.dag.CycleDetectedException;
import org.codehaus.plexus.util.xml.Xpp3Dom;
import org.sonatype.plexus.components.sec.dispatcher.SecDispatcher;
import org.sonatype.plexus.components.sec.dispatcher.SecDispatcherException;
/**
* @author <a href="mailto:jason@maven.org">Jason van Zyl </a>
* @version $Id: DefaultMaven.java 769611 2009-04-29 01:22:50Z jdcasey $
*/
public class DefaultMaven
extends AbstractLogEnabled
implements Maven, Contextualizable
{
// ----------------------------------------------------------------------
// Components
// ----------------------------------------------------------------------
protected MavenProjectBuilder projectBuilder;
protected LifecycleExecutor lifecycleExecutor;
protected PlexusContainer container;
protected ErrorDiagnostics errorDiagnostics;
protected RuntimeInformation runtimeInformation;
private static final long MB = 1024 * 1024;
private static final int MS_PER_SEC = 1000;
private static final int SEC_PER_MIN = 60;
// ----------------------------------------------------------------------
// Project execution
// ----------------------------------------------------------------------
public void execute( MavenExecutionRequest request )
throws MavenExecutionException
{
// if ( request.getLocalRepository() == null )
// {
// request.setLocalRepository( mavenTools.createLocalRepository( request.getLocalRepositoryPath() ) );
// }
EventDispatcher dispatcher = request.getEventDispatcher();
String event = MavenEvents.REACTOR_EXECUTION;
dispatcher.dispatchStart( event, request.getBaseDirectory() );
ReactorManager rm;
try
{
rm = doExecute( request, dispatcher );
}
catch ( LifecycleExecutionException e )
{
dispatcher.dispatchError( event, request.getBaseDirectory(), e );
logError( e, request.isShowErrors() );
stats( request.getStartTime() );
line();
throw new MavenExecutionException( e.getMessage(), e );
}
catch ( BuildFailureException e )
{
dispatcher.dispatchError( event, request.getBaseDirectory(), e );
logFailure( e, request.isShowErrors() );
stats( request.getStartTime() );
line();
throw new MavenExecutionException( e.getMessage(), e );
}
catch ( Throwable t )
{
dispatcher.dispatchError( event, request.getBaseDirectory(), t );
logFatal( t );
stats( request.getStartTime() );
line();
throw new MavenExecutionException( "Error executing project within the reactor", t );
}
// Either the build was successful, or it was a fail_at_end/fail_never reactor build
// TODO: should all the logging be left to the CLI?
logReactorSummary( rm );
if ( rm.hasBuildFailures() )
{
logErrors( rm, request.isShowErrors() );
if ( !ReactorManager.FAIL_NEVER.equals( rm.getFailureBehavior() ) )
{
dispatcher.dispatchError( event, request.getBaseDirectory(), null );
getLogger().info( "BUILD ERRORS" );
line();
stats( request.getStartTime() );
line();
throw new MavenExecutionException( "Some builds failed" );
}
else
{
getLogger().info( " + Ignoring failures" );
}
}
logSuccess( rm );
stats( request.getStartTime() );
line();
dispatcher.dispatchEnd( event, request.getBaseDirectory() );
}
private void logErrors( ReactorManager rm, boolean showErrors )
{
for ( Iterator it = rm.getSortedProjects().iterator(); it.hasNext(); )
{
MavenProject project = (MavenProject) it.next();
if ( rm.hasBuildFailure( project ) )
{
BuildFailure buildFailure = rm.getBuildFailure( project );
getLogger().info(
"Error for project: " + project.getName() + " (during " + buildFailure.getTask() + ")" );
line();
logDiagnostics( buildFailure.getCause() );
logTrace( buildFailure.getCause(), showErrors );
}
}
if ( !showErrors )
{
getLogger().info( "For more information, run Maven with the -e switch" );
line();
}
}
private ReactorManager doExecute( MavenExecutionRequest request, EventDispatcher dispatcher )
throws MavenExecutionException, BuildFailureException, LifecycleExecutionException
{
if ( request.getSettings().isOffline() )
{
getLogger().info( SystemWarnings.getOfflineWarning() );
WagonManager wagonManager = null;
try
{
wagonManager = (WagonManager) container.lookup( WagonManager.ROLE );
wagonManager.setOnline( false );
}
catch ( ComponentLookupException e )
{
throw new MavenExecutionException( "Cannot retrieve WagonManager in order to set offline mode.", e );
}
finally
{
try
{
container.release( wagonManager );
}
catch ( ComponentLifecycleException e )
{
getLogger().warn( "Cannot release WagonManager.", e );
}
}
}
try
{
resolveParameters( request.getSettings(), request.getExecutionProperties() );
}
catch ( ComponentLookupException e )
{
throw new MavenExecutionException( "Unable to configure Maven for execution", e );
}
catch ( ComponentLifecycleException e )
{
throw new MavenExecutionException( "Unable to configure Maven for execution", e );
}
catch ( SettingsConfigurationException e )
{
throw new MavenExecutionException( "Unable to configure Maven for execution", e );
}
ProfileManager globalProfileManager = request.getGlobalProfileManager();
globalProfileManager.loadSettingsProfiles( request.getSettings() );
getLogger().info( "Scanning for projects..." );
boolean foundProjects = true;
List projects = getProjects( request );
if ( projects.isEmpty() )
{
projects.add( getSuperProject( request ) );
foundProjects = false;
}
ReactorManager rm;
try
{
String resumeFrom = request.getResumeFrom();
List projectList = request.getSelectedProjects();
String makeBehavior = request.getMakeBehavior();
rm = new ReactorManager( projects, projectList, resumeFrom, makeBehavior );
rm.setFailureBehavior( request.getFailureBehavior() );
}
catch ( CycleDetectedException e )
{
throw new BuildFailureException(
"The projects in the reactor contain a cyclic reference: " + e.getMessage(), e );
}
catch ( DuplicateProjectException e )
{
throw new BuildFailureException( e.getMessage(), e );
}
catch ( MissingProjectException e )
{
throw new BuildFailureException( e.getMessage(), e );
}
// --------------------------------------------------------------------------------
// MNG-3641: print a warning if one of the profiles to be activated explicitly
// was not activated
validateActivatedProfiles( globalProfileManager, projects );
if ( rm.hasMultipleProjects() )
{
getLogger().info( "Reactor build order: " );
for ( Iterator i = rm.getSortedProjects().iterator(); i.hasNext(); )
{
MavenProject project = (MavenProject) i.next();
getLogger().info( " " + project.getName() );
}
}
MavenSession session = createSession( request, rm );
session.setUsingPOMsFromFilesystem( foundProjects );
lifecycleExecutor.execute( session, rm, dispatcher );
return rm;
}
private void validateActivatedProfiles( ProfileManager globalProfileManager, List projects )
{
if ( globalProfileManager != null )
{
// get all activated profile ids
Set activeProfileIds = new HashSet();
for ( Iterator i = projects.iterator(); i.hasNext(); )
{
MavenProject project = (MavenProject) i.next();
do
{
for ( Iterator j = project.getActiveProfiles().iterator(); j.hasNext(); )
{
activeProfileIds.add( ( (Profile) j.next() ).getId() );
}
project = project.getParent();
}
while ( project != null );
}
for ( Iterator i = globalProfileManager.getExplicitlyActivatedIds().iterator(); i.hasNext(); )
{
String explicitProfileId = (String) i.next();
if ( !activeProfileIds.contains( explicitProfileId ) )
{
getLogger().warn( "\n\tProfile with id: \'" + explicitProfileId + "\' has not been activated.\n" );
}
}
}
}
private MavenProject getSuperProject( MavenExecutionRequest request )
throws MavenExecutionException
{
MavenProject superProject;
try
{
superProject = projectBuilder.buildStandaloneSuperProject( request.getLocalRepository(), request.getGlobalProfileManager() );
}
catch ( ProjectBuildingException e )
{
throw new MavenExecutionException( e.getMessage(), e );
}
return superProject;
}
private List getProjects( MavenExecutionRequest request )
throws MavenExecutionException, BuildFailureException
{
List projects;
try
{
List files = getProjectFiles( request );
projects = collectProjects( files, request, !request.isReactorActive() );
}
catch ( IOException e )
{
throw new MavenExecutionException( "Error processing projects for the reactor: " + e.getMessage(), e );
}
catch ( ArtifactResolutionException e )
{
throw new MavenExecutionException( e.getMessage(), e );
}
catch ( ProjectBuildingException e )
{
throw new MavenExecutionException( e.getMessage(), e );
}
catch ( ProfileActivationException e )
{
throw new MavenExecutionException( e.getMessage(), e );
}
return projects;
}
private void logReactorSummaryLine( String name, String status )
{
logReactorSummaryLine( name, status, -1 );
}
private void logReactorSummaryLine( String name, String status, long time )
{
StringBuffer messageBuffer = new StringBuffer();
messageBuffer.append( name );
int dotCount = 54;
dotCount -= name.length();
messageBuffer.append( " " );
for ( int i = 0; i < dotCount; i++ )
{
messageBuffer.append( '.' );
}
messageBuffer.append( " " );
messageBuffer.append( status );
if ( time >= 0 )
{
messageBuffer.append( " [" );
messageBuffer.append( getFormattedTime( time ) );
messageBuffer.append( "]" );
}
getLogger().info( messageBuffer.toString() );
}
private static String getFormattedTime( long time )
{
String pattern = "s.SSS's'";
if ( time / 60000L > 0 )
{
pattern = "m:s" + pattern;
if ( time / 3600000L > 0 )
{
pattern = "H:m" + pattern;
}
}
DateFormat fmt = new SimpleDateFormat( pattern );
fmt.setTimeZone( TimeZone.getTimeZone( "UTC" ) );
return fmt.format( new Date( time ) );
}
private List collectProjects( List files, MavenExecutionRequest request, boolean isRoot )
throws ArtifactResolutionException, ProjectBuildingException, ProfileActivationException,
MavenExecutionException, BuildFailureException
{
// .getLocalRepository(), request.isRecursive(),
// request.getSettings(), request.getUserProperties(), requ, !request.isReactorActive()
List projects = new ArrayList( files.size() );
for ( Iterator iterator = files.iterator(); iterator.hasNext(); )
{
File file = (File) iterator.next();
boolean usingReleasePom = false;
if ( RELEASE_POMv4.equals( file.getName() ) )
{
getLogger().info( "NOTE: Using release-pom: " + file + " in reactor build." );
usingReleasePom = true;
}
MavenProject project = getProject( file, request );
if ( isRoot )
{
project.setExecutionRoot( true );
}
if ( ( project.getPrerequisites() != null ) && ( project.getPrerequisites().getMaven() != null ) )
{
DefaultArtifactVersion version = new DefaultArtifactVersion( project.getPrerequisites().getMaven() );
if ( runtimeInformation.getApplicationVersion().compareTo( version ) < 0 )
{
throw new BuildFailureException( "Unable to build project '" + project.getFile() +
"; it requires Maven version " + version.toString() );
}
}
if ( ( project.getModules() != null ) && !project.getModules().isEmpty() && request.isRecursive() )
{
// TODO: Really should fail if it was not? What if it is aggregating - eg "ear"?
project.setPackaging( "pom" );
File basedir = file.getParentFile();
// Initial ordering is as declared in the modules section
List moduleFiles = new ArrayList( project.getModules().size() );
for ( Iterator i = project.getModules().iterator(); i.hasNext(); )
{
String name = (String) i.next();
if ( StringUtils.isEmpty( StringUtils.trim( name ) ) )
{
getLogger().warn(
"Empty module detected. Please check you don't have any empty module definitions in your POM." );
continue;
}
File moduleFile = new File( basedir, name );
if ( moduleFile.exists() && moduleFile.isDirectory() )
{
if ( usingReleasePom )
{
moduleFile = new File( basedir, name + "/" + Maven.RELEASE_POMv4 );
}
else
{
moduleFile = new File( basedir, name + "/" + Maven.POMv4 );
}
}
if ( Os.isFamily( "windows" ) )
{
// we don't canonicalize on unix to avoid interfering with symlinks
try
{
moduleFile = moduleFile.getCanonicalFile();
}
catch ( IOException e )
{
throw new MavenExecutionException( "Unable to canonicalize file name " + moduleFile, e );
}
}
else
{
moduleFile = new File( moduleFile.toURI().normalize() );
}
moduleFiles.add( moduleFile );
}
List collectedProjects =
collectProjects( moduleFiles, request, false );
projects.addAll( collectedProjects );
project.setCollectedProjects( collectedProjects );
}
projects.add( project );
}
return projects;
}
/**
* @deprecated Use {@link DefaultMaven#getProject(File, MavenExecutionRequest)} instead.
*/
public MavenProject getProject( File pom, ArtifactRepository localRepository, Settings settings,
Properties userProperties, ProfileManager globalProfileManager )
throws ProjectBuildingException, ArtifactResolutionException, ProfileActivationException
{
MavenExecutionRequest request = new DefaultMavenExecutionRequest(
localRepository,
settings,
new DefaultEventDispatcher(),
Collections.EMPTY_LIST,
pom.getParentFile()
.getAbsolutePath(),
globalProfileManager,
globalProfileManager.getRequestProperties(),
new Properties(), false );
return getProject( pom, request );
}
public MavenProject getProject( File pom, MavenExecutionRequest request )
throws ProjectBuildingException, ArtifactResolutionException, ProfileActivationException
{
if ( pom.exists() )
{
if ( pom.length() == 0 )
{
throw new ProjectBuildingException( "unknown", "The file " + pom.getAbsolutePath() +
" you specified has zero length." );
}
}
return projectBuilder.build( pom, request.getProjectBuilderConfiguration() );
}
// ----------------------------------------------------------------------
// Methods used by all execution request handlers
// ----------------------------------------------------------------------
//!! We should probably have the execution request handler create the
// session as
// the session type would be specific to the request i.e. having a project
// or not.
protected MavenSession createSession( MavenExecutionRequest request,
ReactorManager rpm )
{
return new MavenSession( container, request.getSettings(), request.getLocalRepository(),
request.getEventDispatcher(), rpm, request.getGoals(), request.getBaseDirectory(),
request.getExecutionProperties(), request.getUserProperties(), request.getStartTime() );
}
/**
* @todo [BP] this might not be required if there is a better way to pass
* them in. It doesn't feel quite right.
* @todo [JC] we should at least provide a mapping of protocol-to-proxy for
* the wagons, shouldn't we?
*/
private void resolveParameters( Settings settings, Properties executionProperties )
throws ComponentLookupException, ComponentLifecycleException, SettingsConfigurationException
{
// TODO: remove when components.xml can be used to configure this instead
try
{
DefaultWagonManager wagonManager = (DefaultWagonManager) container.lookup( WagonManager.ROLE );
String oldUserAgent = wagonManager.getHttpUserAgent();
int firstSpace = oldUserAgent == null ? -1 : oldUserAgent.indexOf( " " );
StringBuffer buffer = new StringBuffer();
buffer.append( "Apache-Maven/" );
ArtifactVersion version = runtimeInformation.getApplicationVersion();
if ( version != null )
{
buffer.append( version.getMajorVersion() );
buffer.append( '.' );
buffer.append( version.getMinorVersion() );
}
else
{
buffer.append( "unknown" );
}
buffer.append( ' ' );
if ( firstSpace > -1 )
{
buffer.append( oldUserAgent.substring( firstSpace + 1 ) );
buffer.append( ' ' );
buffer.append( oldUserAgent.substring( 0, firstSpace ) );
}
else
{
buffer.append( oldUserAgent );
}
wagonManager.setHttpUserAgent( buffer.toString() );
}
catch ( ClassCastException e )
{
// ignore
}
WagonManager wagonManager = (WagonManager) container.lookup( WagonManager.ROLE );
SecDispatcher sd = null;
try
{
Proxy proxy = settings.getActiveProxy();
try
{
sd = (SecDispatcher) container.lookup( SecDispatcher.ROLE, "maven" );
}
catch (Exception e)
{
getLogger().warn( "Security features are disabled. Cannot find plexus component "+SecDispatcher.ROLE + ":maven" );
line();
}
if ( proxy != null )
{
if ( proxy.getHost() == null )
{
throw new SettingsConfigurationException( "Proxy in settings.xml has no host" );
}
String pass = proxy.getPassword();
if ( sd != null )
{
try
{
pass = sd.decrypt( pass );
}
catch ( SecDispatcherException e )
{
reportSecurityConfigurationError( "password for proxy '" + proxy.getId() + "'", e );
}
}
wagonManager.addProxy( proxy.getProtocol(), proxy.getHost(), proxy.getPort(), proxy.getUsername(),
pass, proxy.getNonProxyHosts() );
}
for ( Iterator i = settings.getServers().iterator(); i.hasNext(); )
{
Server server = (Server) i.next();
String passWord = server.getPassword();
if ( sd != null )
{
try
{
passWord = sd.decrypt( passWord );
}
catch ( SecDispatcherException e )
{
reportSecurityConfigurationError( "password for server '" + server.getId() + "'", e );
}
}
String passPhrase = server.getPassphrase();
if ( sd != null )
{
try
{
passPhrase = sd.decrypt( passPhrase );
}
catch ( SecDispatcherException e )
{
reportSecurityConfigurationError( "passphrase for server '" + server.getId() + "'", e );
}
}
wagonManager.addAuthenticationInfo( server.getId(), server.getUsername(), passWord,
server.getPrivateKey(), passPhrase );
wagonManager.addPermissionInfo( server.getId(), server.getFilePermissions(),
server.getDirectoryPermissions() );
if ( server.getConfiguration() != null )
{
wagonManager.addConfiguration( server.getId(), (Xpp3Dom) server.getConfiguration() );
}
}
for ( Iterator i = settings.getMirrors().iterator(); i.hasNext(); )
{
Mirror mirror = (Mirror) i.next();
wagonManager.addMirror( mirror.getId(), mirror.getMirrorOf(), mirror.getUrl() );
}
}
finally
{
container.release( wagonManager );
if ( sd != null )
{
container.release( sd );
}
}
// Would be better in settings.xml, but it is not extensible yet
String numThreads = System.getProperty( "maven.artifact.threads" );
if ( numThreads != null )
{
int threads = 0;
try
{
threads = Integer.valueOf( numThreads ).intValue();
if ( threads < 1 )
{
getLogger().warn( "Invalid number of threads '" + threads + "' will be ignored" );
}
}
catch ( NumberFormatException e )
{
getLogger().warn( "Invalid number of threads '" + numThreads + "' will be ignored: " + e.getMessage() );
}
if ( threads > 0 )
{
DefaultArtifactResolver artifactResolver = (DefaultArtifactResolver) container.lookup( ArtifactResolver.ROLE );
try
{
artifactResolver.configureNumberOfThreads( threads );
getLogger().debug( "Resolution thread pool size set to: " + threads );
}
finally
{
container.release( artifactResolver );
}
}
}
}
private void reportSecurityConfigurationError( String affectedConfiguration, SecDispatcherException e )
{
Throwable cause = e;
String msg = "Not decrypting " + affectedConfiguration + " due to exception in security handler.";
// Drop to the actual cause, it wraps multiple times
while ( cause.getCause() != null )
{
cause = cause.getCause();
}
// common cause is missing settings-security.xml
if ( cause instanceof FileNotFoundException )
{
msg += "\nEnsure that you have configured your master password file (and relocation if appropriate)\nSee the installation instructions for details.";
}
getLogger().warn( msg + "\nCause: " + cause.getMessage() );
getLogger().debug( "Full trace follows", e );
}
// ----------------------------------------------------------------------
// Lifecylce Management
// ----------------------------------------------------------------------
public void contextualize( Context context )
throws ContextException
{
container = (PlexusContainer) context.get( PlexusConstants.PLEXUS_KEY );
}
// ----------------------------------------------------------------------
// Reporting / Logging
// ----------------------------------------------------------------------
protected void logFatal( Throwable error )
{
line();
getLogger().error( "FATAL ERROR" );
line();
logDiagnostics( error );
logTrace( error, true );
}
protected void logError( Exception e, boolean showErrors )
{
line();
getLogger().error( "BUILD ERROR" );
line();
logDiagnostics( e );
logTrace( e, showErrors );
if ( !showErrors )
{
getLogger().info( "For more information, run Maven with the -e switch" );
line();
}
}
protected void logFailure( BuildFailureException e, boolean showErrors )
{
line();
getLogger().error( "BUILD FAILURE" );
line();
logDiagnostics( e );
logTrace( e, showErrors );
if ( !showErrors )
{
getLogger().info( "For more information, run Maven with the -e switch" );
line();
}
}
private void logTrace( Throwable t, boolean showErrors )
{
if ( getLogger().isDebugEnabled() )
{
getLogger().debug( "Trace", t );
line();
}
else if ( showErrors )
{
getLogger().info( "Trace", t );
line();
}
}
private void logDiagnostics( Throwable t )
{
String message = null;
if ( errorDiagnostics != null )
{
message = errorDiagnostics.diagnose( t );
}
if ( message == null )
{
message = t.getMessage();
}
getLogger().info( message );
line();
}
protected void logSuccess( ReactorManager rm )
{
line();
getLogger().info( "BUILD SUCCESSFUL" );
line();
}
private void logReactorSummary( ReactorManager rm )
{
if ( rm.hasMultipleProjects() && rm.executedMultipleProjects() )
{
getLogger().info( "" );
getLogger().info( "" );
// -------------------------
// Reactor Summary:
// -------------------------
// o project-name...........FAILED
// o project2-name..........SKIPPED (dependency build failed or was skipped)
// o project-3-name.........SUCCESS
line();
getLogger().info( "Reactor Summary:" );
line();
for ( Iterator it = rm.getSortedProjects().iterator(); it.hasNext(); )
{
MavenProject project = (MavenProject) it.next();
if ( rm.hasBuildFailure( project ) )
{
logReactorSummaryLine( project.getName(), "FAILED", rm.getBuildFailure( project ).getTime() );
}
else if ( rm.isBlackListed( project ) )
{
logReactorSummaryLine( project.getName(), "SKIPPED (dependency build failed or was skipped)" );
}
else if ( rm.hasBuildSuccess( project ) )
{
logReactorSummaryLine( project.getName(), "SUCCESS", rm.getBuildSuccess( project ).getTime() );
}
else
{
logReactorSummaryLine( project.getName(), "NOT BUILT" );
}
}
line();
}
}
protected void stats( Date start )
{
Date finish = new Date();
long time = finish.getTime() - start.getTime();
getLogger().info( "Total time: " + formatTime( time ) );
getLogger().info( "Finished at: " + finish );
//noinspection CallToSystemGC
System.gc();
Runtime r = Runtime.getRuntime();
getLogger().info(
"Final Memory: " + ( r.totalMemory() - r.freeMemory() ) / MB + "M/" + r.totalMemory() / MB + "M" );
}
protected void line()
{
getLogger().info( "------------------------------------------------------------------------" );
}
protected static String formatTime( long ms )
{
long secs = ms / MS_PER_SEC;
long min = secs / SEC_PER_MIN;
secs = secs % SEC_PER_MIN;
String msg = "";
if ( min > 1 )
{
msg = min + " minutes ";
}
else if ( min == 1 )
{
msg = "1 minute ";
}
if ( secs > 1 )
{
msg += secs + " seconds";
}
else if ( secs == 1 )
{
msg += "1 second";
}
else if ( min == 0 )
{
msg += "< 1 second";
}
return msg;
}
private List getProjectFiles( MavenExecutionRequest request )
throws IOException
{
List files = Collections.EMPTY_LIST;
File userDir = new File( System.getProperty( "user.dir" ) );
if ( request.isReactorActive() )
{
// TODO: should we now include the pom.xml in the current directory?
// String includes = System.getProperty( "maven.reactor.includes", "**/" + POMv4 );
// String excludes = System.getProperty( "maven.reactor.excludes", POMv4 );
String includes = System.getProperty( "maven.reactor.includes", "**/" + POMv4 + ",**/" + RELEASE_POMv4 );
String excludes = System.getProperty( "maven.reactor.excludes", POMv4 + "," + RELEASE_POMv4 );
files = FileUtils.getFiles( userDir, includes, excludes );
filterOneProjectFilePerDirectory( files );
// make sure there is consistent ordering on all platforms, rather than using the filesystem ordering
Collections.sort( files );
}
else if ( request.getPomFile() != null )
{
File projectFile = new File( request.getPomFile() ).getAbsoluteFile();
if ( projectFile.exists() )
{
files = Collections.singletonList( projectFile );
}
}
else
{
File projectFile = new File( userDir, RELEASE_POMv4 );
if ( !projectFile.exists() )
{
projectFile = new File( userDir, POMv4 );
}
if ( projectFile.exists() )
{
files = Collections.singletonList( projectFile );
}
}
return files;
}
private void filterOneProjectFilePerDirectory( List files )
{
List releaseDirs = new ArrayList();
for ( Iterator it = files.iterator(); it.hasNext(); )
{
File projectFile = (File) it.next();
if ( RELEASE_POMv4.equals( projectFile.getName() ) )
{
releaseDirs.add( projectFile.getParentFile() );
}
}
for ( Iterator it = files.iterator(); it.hasNext(); )
{
File projectFile = (File) it.next();
// remove pom.xml files where there is a sibling release-pom.xml file...
if ( !RELEASE_POMv4.equals( projectFile.getName() ) && releaseDirs.contains( projectFile.getParentFile() ) )
{
it.remove();
}
}
}
}