<argument> or <classpath>
* Can be overriden using "exec.args" env. variable
*
* @parameter
* @since 1.0
*/
private List arguments;
/**
* @parameter expression="${basedir}"
* @required
* @readonly
* @since 1.0
*/
private File basedir;
/**
* Environment variables to pass to the executed program.
* @parameter
* @since 1.1-beta-2
*/
private Map environmentVariables = new HashMap();
/**
* The current build session instance. This is used for
* toolchain manager API calls.
*
* @parameter expression="${session}"
* @required
* @readonly
*/
private MavenSession session;
/**
* Exit codes to be resolved as successful execution for non-compliant
* applications (applications not returning 0 for success).
*
* @parameter
* @since 1.1.1
*/
private List successCodes;
/**
* if exec.args expression is used when invokign the exec:exec goal,
* any occurence of %classpath argument is replaced by the actual project dependency classpath.
*/
public static final String CLASSPATH_TOKEN = "%classpath";
/**
* priority in the execute method will be to use System properties arguments over the pom specification.
* @throws MojoExecutionException if a failure happens
*/
public void execute()
throws MojoExecutionException
{
if ( skip )
{
getLog().info( "skipping execute as per configuraion" );
return;
}
if ( basedir == null )
{
throw new IllegalStateException( "basedir is null. Should not be possible." );
}
String argsProp = getSystemProperty( "exec.args" );
List commandArguments = new ArrayList();
if ( hasCommandlineArgs() )
{
String[] args = parseCommandlineArgs();
for ( int i = 0; i < args.length; i++ )
{
if ( CLASSPATH_TOKEN.equals( args[i] ) )
{
commandArguments.add( computeClasspath( null ) );
}
else
{
commandArguments.add( args[i] );
}
}
}
else if ( !isEmpty( argsProp ) )
{
getLog().debug( "got arguments from system properties: " + argsProp );
StringTokenizer strtok = new StringTokenizer( argsProp, " " );
while ( strtok.hasMoreTokens() )
{
commandArguments.add( strtok.nextToken() );
}
}
else
{
if ( arguments != null )
{
for ( int i = 0; i < arguments.size(); i++ )
{
Object argument = arguments.get( i );
String arg;
if ( argument == null )
{
throw new MojoExecutionException(
"Misconfigured argument, value is null. Set the argument to an empty value"
+ " if this is the required behaviour." );
}
else if ( argument instanceof Classpath )
{
Classpath specifiedClasspath = (Classpath) argument;
arg = computeClasspath( specifiedClasspath );
}
else
{
arg = argument.toString();
}
commandArguments.add( arg );
}
}
}
Commandline commandLine = new Commandline();
commandLine.setExecutable( getExecutablePath() );
String [] args = new String[ commandArguments.size() ];
for ( int i = 0; i < commandArguments.size(); i++ )
{
args[i] = (String) commandArguments.get( i );
}
commandLine.addArguments( args );
if ( workingDirectory == null )
{
workingDirectory = basedir;
}
if ( !workingDirectory.exists() )
{
getLog().debug( "Making working directory '" + workingDirectory.getAbsolutePath() + "'." );
if ( !workingDirectory.mkdirs() )
{
throw new MojoExecutionException(
"Could not make working directory: '" + workingDirectory.getAbsolutePath() + "'" );
}
}
commandLine.setWorkingDirectory( workingDirectory.getAbsolutePath() );
if ( environmentVariables != null )
{
Iterator iter = environmentVariables.keySet().iterator();
while ( iter.hasNext() )
{
String key = (String) iter.next();
String value = (String) environmentVariables.get( key );
commandLine.addEnvironment( key, value );
}
}
final Log outputLog = getExecOutputLog();
StreamConsumer stdout = new StreamConsumer()
{
public void consumeLine( String line )
{
outputLog.info( line );
}
};
StreamConsumer stderr = new StreamConsumer()
{
public void consumeLine( String line )
{
outputLog.info( line );
}
};
try
{
int resultCode = executeCommandLine( commandLine, stdout, stderr );
if ( isResultCodeAFailure( resultCode ) )
{
throw new MojoExecutionException( "Result of " + commandLine + " execution is: '" + resultCode + "'." );
}
}
catch ( CommandLineException e )
{
throw new MojoExecutionException( "Command execution failed.", e );
}
registerSourceRoots();
}
boolean isResultCodeAFailure(int result)
{
if (successCodes == null || successCodes.size() == 0)
return result != 0;
for (Iterator it = successCodes.iterator(); it.hasNext(); )
{
int code = Integer.parseInt((String) it.next());
if (code == result)
return false;
}
return true;
}
private Log getExecOutputLog()
{
Log log = getLog();
if ( outputFile != null )
{
try
{
if ( !outputFile.getParentFile().exists() && !outputFile.getParentFile().mkdirs() )
{
getLog().warn( "Could not create non existing parent directories for log file: " + outputFile );
}
PrintStream stream = new PrintStream( new FileOutputStream( outputFile ) );
log = new StreamLog( stream );
}
catch ( Exception e )
{
getLog().warn( "Could not open " + outputFile + ". Using default log", e );
}
}
return log;
}
/**
* Compute the classpath from the specified Classpath. The computed classpath is based on the classpathScope.
* The plugin cannot know from maven the phase it is executed in. So we have to depend on the user to tell us
* he wants the scope in which the plugin is expected to be executed.
* @param specifiedClasspath Non null when the user restricted the dependenceis, null otherwise
(the default classpath will be used)
* @return a platform specific String representation of the classpath
*/
private String computeClasspath( Classpath specifiedClasspath )
{
// TODO we should consider rewriting this bit into something like
// Listtrue, all of the project dependencies
* will be included on the executable's classpath. Whether a particular project
* dependency is a dependency of the identified ExecutableDependency will be
* irrelevant to its inclusion in the classpath.
*
* @parameter
* @optional
* @since 1.1-beta-1
*/
private ExecutableDependency executableDependency;
/**
* Wether to interrupt/join and possibly stop the daemon threads upon quitting. false,
* maven does nothing about the daemon threads. When maven has no more work to do, the VM will normally terminate
* any remaining daemon threads.
* * In certain cases (in particular if maven is embedded), * you might need to keep this enabled to make sure threads are properly cleaned up to ensure they don't interfere * with subsequent activity. * In that case, see {@link #daemonThreadJoinTimeout} and * {@link #stopUnresponsiveDaemonThreads} for further tuning. *
* @parameter expression="${exec.cleanupDaemonThreads} default-value="true" * @since 1.1-beta-1 */ private boolean cleanupDaemonThreads; /** * This defines the number of milliseconds to wait for daemon threads to quit following their interruption.true.
* A value <=0 means to not timeout (i.e. wait indefinitely for threads to finish). Following a timeout, a
* warning will be logged.
* Note: properly coded threads should terminate upon interruption but some threads may prove * problematic: as the VM does interrupt daemon threads, some code may not have been written to handle * interruption properly. For example java.util.Timer is known to not handle interruptions in JDK <= 1.6. * So it is not possible for us to infinitely wait by default otherwise maven could hang. A sensible default * value has been chosen, but this default value may change in the future based on user feedback.
* @parameter expression="${exec.daemonThreadJoinTimeout}" default-value="15000" * @since 1.1-beta-1 */ private long daemonThreadJoinTimeout; /** * Wether to call {@link Thread#stop()} following a timing out of waiting for an interrupted thread to finish. * This is only taken into account if {@link #cleanupDaemonThreads} istrue
* and the {@link #daemonThreadJoinTimeout} threshold has been reached for an uncooperative thread.
* If this is false, or if {@link Thread#stop()} fails to get the thread to stop, then
* a warning is logged and Maven will continue on while the affected threads (and related objects in memory)
* linger on. Consider setting this to true if you are invoking problematic code that you can't fix.
* An example is {@link java.util.Timer} which doesn't respond to interruption. To have Timer
* fixed, vote for this bug.
* @parameter expression="${exec.stopUnresponsiveDaemonThreads} default-value="false"
* @since 1.1-beta-1
*/
private boolean stopUnresponsiveDaemonThreads;
/**
* Deprecated this is not needed anymore.
*
* @parameter expression="${exec.killAfter}" default-value="-1"
* @deprecated since 1.1-alpha-1
* @since 1.0
*/
private long killAfter;
private Properties originalSystemProperties;
/**
* Execute goal.
* @throws MojoExecutionException execution of the main class or one of the threads it generated failed.
* @throws MojoFailureException something bad happened...
*/
public void execute()
throws MojoExecutionException, MojoFailureException
{
if ( killAfter != -1 )
{
getLog().warn( "Warning: killAfter is now deprecated. Do you need it ? Please comment on MEXEC-6." );
}
if ( null == arguments )
{
arguments = new String[0];
}
if ( getLog().isDebugEnabled() )
{
StringBuffer msg = new StringBuffer( "Invoking : " );
msg.append( mainClass );
msg.append( ".main(" );
for ( int i = 0; i < arguments.length; i++ )
{
if ( i > 0 )
{
msg.append( ", " );
}
msg.append( arguments[i] );
}
msg.append( ")" );
getLog().debug( msg );
}
IsolatedThreadGroup threadGroup = new IsolatedThreadGroup( mainClass /*name*/ );
Thread bootstrapThread = new Thread( threadGroup, new Runnable()
{
public void run()
{
try
{
Method main = Thread.currentThread().getContextClassLoader().loadClass( mainClass )
.getMethod( "main", new Class[]{ String[].class } );
if ( ! main.isAccessible() )
{
getLog().debug( "Setting accessibility to true in order to invoke main()." );
main.setAccessible( true );
}
main.invoke( main, new Object[]{arguments} );
}
catch ( NoSuchMethodException e )
{ // just pass it on
Thread.currentThread().getThreadGroup().uncaughtException( Thread.currentThread(),
new Exception(
"The specified mainClass doesn't contain a main method with appropriate signature.", e
)
);
}
catch ( Exception e )
{ // just pass it on
Thread.currentThread().getThreadGroup().uncaughtException( Thread.currentThread(), e );
}
}
}, mainClass + ".main()" );
bootstrapThread.setContextClassLoader( getClassLoader() );
setSystemProperties();
bootstrapThread.start();
joinNonDaemonThreads( threadGroup );
// It's plausible that spontaneously a non-daemon thread might be created as we try and shut down,
// but it's too late since the termination condition (only daemon threads) has been triggered.
if ( keepAlive )
{
getLog().warn(
"Warning: keepAlive is now deprecated and obsolete. Do you need it? Please comment on MEXEC-6." );
waitFor( 0 );
}
if ( cleanupDaemonThreads )
{
terminateThreads( threadGroup );
try
{
threadGroup.destroy();
}
catch ( IllegalThreadStateException e )
{
getLog().warn( "Couldn't destroy threadgroup " + threadGroup, e );
}
}
if ( originalSystemProperties != null )
{
System.setProperties( originalSystemProperties );
}
synchronized ( threadGroup )
{
if ( threadGroup.uncaughtException != null )
{
throw new MojoExecutionException( "An exception occured while executing the Java class. "
+ threadGroup.uncaughtException.getMessage(),
threadGroup.uncaughtException );
}
}
registerSourceRoots();
}
/**
* a ThreadGroup to isolate execution and collect exceptions.
*/
class IsolatedThreadGroup extends ThreadGroup
{
Throwable uncaughtException; // synchronize access to this
public IsolatedThreadGroup( String name )
{
super( name );
}
public void uncaughtException( Thread thread, Throwable throwable )
{
if ( throwable instanceof ThreadDeath )
{
return; //harmless
}
boolean doLog = false;
synchronized ( this )
{
if ( uncaughtException == null ) // only remember the first one
{
uncaughtException = throwable; // will be reported eventually
}
else
{
doLog = true;
}
}
if ( doLog )
{
getLog().warn( "an additional exception was thrown", throwable );
}
}
}
private void joinNonDaemonThreads( ThreadGroup threadGroup )
{
boolean foundNonDaemon;
do
{
foundNonDaemon = false;
Collection threads = getActiveThreads( threadGroup );
for ( Iterator iter = threads.iterator(); iter.hasNext(); )
{
Thread thread = (Thread) iter.next();
if ( thread.isDaemon() )
{
continue;
}
foundNonDaemon = true; //try again; maybe more threads were created while we were busy
joinThread( thread, 0 );
}
} while ( foundNonDaemon );
}
private void joinThread( Thread thread, long timeoutMsecs )
{
try
{
getLog().debug( "joining on thread " + thread );
thread.join( timeoutMsecs );
}
catch ( InterruptedException e )
{
Thread.currentThread().interrupt(); // good practice if don't throw
getLog().warn( "interrupted while joining against thread " + thread, e ); // not expected!
}
if ( thread.isAlive() ) //generally abnormal
{
getLog().warn( "thread " + thread + " was interrupted but is still alive after waiting at least "
+ timeoutMsecs + "msecs" );
}
}
private void terminateThreads( ThreadGroup threadGroup )
{
long startTime = System.currentTimeMillis();
Set uncooperativeThreads = new HashSet(); // these were not responsive to interruption
for ( Collection threads = getActiveThreads( threadGroup ); !threads.isEmpty();
threads = getActiveThreads( threadGroup ), threads.removeAll( uncooperativeThreads ) )
{
// Interrupt all threads we know about as of this instant (harmless if spuriously went dead (! isAlive())
// or if something else interrupted it ( isInterrupted() ).
for ( Iterator iter = threads.iterator(); iter.hasNext(); )
{
Thread thread = (Thread) iter.next();
getLog().debug( "interrupting thread " + thread );
thread.interrupt();
}
// Now join with a timeout and call stop() (assuming flags are set right)
for ( Iterator iter = threads.iterator(); iter.hasNext(); )
{
Thread thread = (Thread) iter.next();
if ( ! thread.isAlive() )
{
continue; //and, presumably it won't show up in getActiveThreads() next iteration
}
if ( daemonThreadJoinTimeout <= 0 )
{
joinThread( thread, 0 ); //waits until not alive; no timeout
continue;
}
long timeout = daemonThreadJoinTimeout
- ( System.currentTimeMillis() - startTime );
if ( timeout > 0 )
{
joinThread( thread, timeout );
}
if ( ! thread.isAlive() )
{
continue;
}
uncooperativeThreads.add( thread ); // ensure we don't process again
if ( stopUnresponsiveDaemonThreads )
{
getLog().warn( "thread " + thread + " will be Thread.stop()'ed" );
thread.stop();
}
else
{
getLog().warn( "thread " + thread + " will linger despite being asked to die via interruption" );
}
}
}
if ( ! uncooperativeThreads.isEmpty() )
{
getLog().warn( "NOTE: " + uncooperativeThreads.size() + " thread(s) did not finish despite being asked to "
+ " via interruption. This is not a problem with exec:java, it is a problem with the running code."
+ " Although not serious, it should be remedied." );
}
else
{
int activeCount = threadGroup.activeCount();
if ( activeCount != 0 )
{
// TODO this may be nothing; continue on anyway; perhaps don't even log in future
Thread[] threadsArray = new Thread[1];
threadGroup.enumerate( threadsArray );
getLog().debug( "strange; " + activeCount
+ " thread(s) still active in the group " + threadGroup + " such as " + threadsArray[0] );
}
}
}
private Collection getActiveThreads( ThreadGroup threadGroup )
{
Thread[] threads = new Thread[ threadGroup.activeCount() ];
int numThreads = threadGroup.enumerate( threads );
Collection result = new ArrayList( numThreads );
for ( int i = 0; i < threads.length && threads[i] != null; i++ )
{
result.add( threads[i] );
}
return result; //note: result should be modifiable
}
/**
* Pass any given system properties to the java system properties.
*/
private void setSystemProperties()
{
if ( systemProperties != null )
{
originalSystemProperties = System.getProperties();
for ( int i = 0; i < systemProperties.length; i++ )
{
Property systemProperty = systemProperties[i];
String value = systemProperty.getValue();
System.setProperty( systemProperty.getKey(), value == null ? "" : value );
}
}
}
/**
* Set up a classloader for the execution of the main class.
*
* @return the classloader
* @throws MojoExecutionException if a problem happens
*/
private ClassLoader getClassLoader()
throws MojoExecutionException
{
List classpathURLs = new ArrayList();
this.addRelevantPluginDependenciesToClasspath( classpathURLs );
this.addRelevantProjectDependenciesToClasspath( classpathURLs );
return new URLClassLoader( ( URL[] ) classpathURLs.toArray( new URL[ classpathURLs.size() ] ) );
}
/**
* Add any relevant project dependencies to the classpath.
* Indirectly takes includePluginDependencies and ExecutableDependency into consideration.
*
* @param path classpath of {@link java.net.URL} objects
* @throws MojoExecutionException if a problem happens
*/
private void addRelevantPluginDependenciesToClasspath( List path )
throws MojoExecutionException
{
if ( hasCommandlineArgs() )
{
arguments = parseCommandlineArgs();
}
try
{
Iterator iter = this.determineRelevantPluginDependencies().iterator();
while ( iter.hasNext() )
{
Artifact classPathElement = (Artifact) iter.next();
getLog().debug(
"Adding plugin dependency artifact: " + classPathElement.getArtifactId() + " to classpath" );
path.add( classPathElement.getFile().toURL() );
}
}
catch ( MalformedURLException e )
{
throw new MojoExecutionException( "Error during setting up classpath", e );
}
}
/**
* Add any relevant project dependencies to the classpath.
* Takes includeProjectDependencies into consideration.
*
* @param path classpath of {@link java.net.URL} objects
* @throws MojoExecutionException if a problem happens
*/
private void addRelevantProjectDependenciesToClasspath( List path )
throws MojoExecutionException
{
if ( this.includeProjectDependencies )
{
try
{
getLog().debug( "Project Dependencies will be included." );
List artifacts = new ArrayList();
List theClasspathFiles = new ArrayList();
collectProjectArtifactsAndClasspath( artifacts, theClasspathFiles );
for ( Iterator it = theClasspathFiles.iterator(); it.hasNext(); )
{
URL url = ( (File) it.next() ).toURL();
getLog().debug( "Adding to classpath : " + url );
path.add( url );
}
Iterator iter = artifacts.iterator();
while ( iter.hasNext() )
{
Artifact classPathElement = (Artifact) iter.next();
getLog().debug(
"Adding project dependency artifact: " + classPathElement.getArtifactId() + " to classpath" );
path.add( classPathElement.getFile().toURL() );
}
}
catch ( MalformedURLException e )
{
throw new MojoExecutionException( "Error during setting up classpath", e );
}
}
else
{
getLog().debug( "Project Dependencies will be excluded." );
}
}
/**
* Determine all plugin dependencies relevant to the executable.
* Takes includePlugins, and the executableDependency into consideration.
*
* @return a set of Artifact objects.
* (Empty set is returned if there are no relevant plugin dependencies.)
* @throws MojoExecutionException if a problem happens resolving the plufin dependencies
*/
private Set determineRelevantPluginDependencies()
throws MojoExecutionException
{
Set relevantDependencies;
if ( this.includePluginDependencies )
{
if ( this.executableDependency == null )
{
getLog().debug( "All Plugin Dependencies will be included." );
relevantDependencies = new HashSet( this.pluginDependencies );
}
else
{
getLog().debug( "Selected plugin Dependencies will be included." );
Artifact executableArtifact = this.findExecutableArtifact();
Artifact executablePomArtifact = this.getExecutablePomArtifact( executableArtifact );
relevantDependencies = this.resolveExecutableDependencies( executablePomArtifact );
}
}
else
{
relevantDependencies = Collections.EMPTY_SET;
getLog().debug( "Plugin Dependencies will be excluded." );
}
return relevantDependencies;
}
/**
* Get the artifact which refers to the POM of the executable artifact.
*
* @param executableArtifact this artifact refers to the actual assembly.
* @return an artifact which refers to the POM of the executable artifact.
*/
private Artifact getExecutablePomArtifact( Artifact executableArtifact )
{
return this.artifactFactory.createBuildArtifact( executableArtifact.getGroupId(),
executableArtifact.getArtifactId(),
executableArtifact.getVersion(), "pom" );
}
/**
* Examine the plugin dependencies to find the executable artifact.
*
* @return an artifact which refers to the actual executable tool (not a POM)
* @throws MojoExecutionException if no executable artifact was found
*/
private Artifact findExecutableArtifact()
throws MojoExecutionException
{
//ILimitedArtifactIdentifier execToolAssembly = this.getExecutableToolAssembly();
Artifact executableTool = null;
for ( Iterator iter = this.pluginDependencies.iterator(); iter.hasNext(); )
{
Artifact pluginDep = (Artifact) iter.next();
if ( this.executableDependency.matches( pluginDep ) )
{
executableTool = pluginDep;
break;
}
}
if ( executableTool == null )
{
throw new MojoExecutionException(
"No dependency of the plugin matches the specified executableDependency."
+ " Specified executableToolAssembly is: " + executableDependency.toString() );
}
return executableTool;
}
/**
* Resolve the executable dependencies for the specified project
* @param executablePomArtifact the project's POM
* @return a set of Artifacts
* @throws MojoExecutionException if a failure happens
*/
private Set resolveExecutableDependencies( Artifact executablePomArtifact )
throws MojoExecutionException
{
Set executableDependencies;
try
{
MavenProject executableProject = this.projectBuilder.buildFromRepository( executablePomArtifact,
this.remoteRepositories,
this.localRepository );
//get all of the dependencies for the executable project
List dependencies = executableProject.getDependencies();
//make Artifacts of all the dependencies
Set dependencyArtifacts =
MavenMetadataSource.createArtifacts( this.artifactFactory, dependencies, null, null, null );
//not forgetting the Artifact of the project itself
dependencyArtifacts.add( executableProject.getArtifact() );
//resolve all dependencies transitively to obtain a comprehensive list of assemblies
ArtifactResolutionResult result = artifactResolver.resolveTransitively( dependencyArtifacts,
executablePomArtifact,
Collections.EMPTY_MAP,
this.localRepository,
this.remoteRepositories,
metadataSource, null,
Collections.EMPTY_LIST );
executableDependencies = result.getArtifacts();
}
catch ( Exception ex )
{
throw new MojoExecutionException(
"Encountered problems resolving dependencies of the executable " + "in preparation for its execution.",
ex );
}
return executableDependencies;
}
/**
* Stop program execution for nn millis.
*
* @param millis the number of millis-seconds to wait for,
* 0 stops program forever.
*/
private void waitFor( long millis )
{
Object lock = new Object();
synchronized ( lock )
{
try
{
lock.wait( millis );
}
catch ( InterruptedException e )
{
Thread.currentThread().interrupt(); // good practice if don't throw
getLog().warn( "Spuriously interrupted while waiting for " + millis + "ms", e );
}
}
}
}
./src/site/ 0000755 0001750 0001750 00000000000 11303510553 011766 5 ustar user03 user03 ./src/site/apt/ 0000755 0001750 0001750 00000000000 11303510553 012552 5 ustar user03 user03 ./src/site/apt/examples/ 0000755 0001750 0001750 00000000000 11303510553 014370 5 ustar user03 user03 ./src/site/apt/examples/example-exec-using-plugin-dependencies.apt 0000644 0001750 0001750 00000010750 11303510553 024521 0 ustar user03 user03 ------
Using plugin dependencies with the exec:java goal
------
Jerome Lacoste
------
2008-10-10
------
~~ Copyright 2008 The Codehaus
~~
~~ Licensed 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.
~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/doxia/references/apt-format.html
Using Plugin Dependencies Instead of Project Dependencies
Ocassionally it is desirable to execute a Java class without affecting your project's dependencies.
For example, if you are using the Maven csharp plugins, adding Java dependencies to your project
will upset the csharp compiler. Therefore the Exec Maven Plugin allows you specify dependencies of
your executable class as plugin dependencies. Since Maven takes plugin dependencies into consideration
when determining build order for a multi-module project your build order should automatically be
appropriately adjusted (I think).
If you specify your executable class dependencies as plugin dependencies, you may end up with extraneous
undesirable dependences required by the Exec Maven Plugin but not by your executable class. If this
causes a problem, or if you simply prefer to avoid the extraneous dependencies you can use the
<<<\Use several execution nodes each with a different id. Don't forget to bind each execution to a phase.
Read the full answer.