Class ExecMojo

java.lang.Object
org.apache.maven.plugin.AbstractMojo
org.codehaus.mojo.exec.AbstractExecMojo
org.codehaus.mojo.exec.ExecMojo
All Implemented Interfaces:
org.apache.maven.plugin.ContextEnabled, org.apache.maven.plugin.Mojo
@Mojo(name="exec", threadSafe=true, requiresDependencyResolution=TEST) public class ExecMojo extends AbstractExecMojo
A Plugin for executing external programs.
Since:
1.0
Version:
$Id$

  • Field Details

    • ENDS_WITH_JAVA

      private static final Pattern ENDS_WITH_JAVA
      Trying to recognize whether the given executable might be a java binary.

    • executable

      @Parameter(property="exec.executable") private String executable

      The executable. Can be a full path or the name of the executable. In the latter case, the executable must be in the PATH for the execution to work. Omit when using executableDependency.

      The plugin will search for the executable in the following order:

      1. relative to the root of the project
      2. as toolchain executable
      3. relative to the working directory (Windows only)
      4. relative to the directories specified in the system property PATH (Windows Only)
      Otherwise use the executable as is.

      Since:
      1.0

    • timeout

      @Parameter(property="exec.timeout", defaultValue="0") private int timeout

      Timeout in full milliseconds, default is 0.

      When set to a value larger than zero, the executable is forcefully terminated if it did not finish within this time, and the build will fail.

      Since:
      3.0.0

    • toolchain

      @Parameter(property="exec.toolchain", defaultValue="jdk") private String toolchain

      The toolchain. If omitted, "jdk" is assumed.

    • workingDirectory

      @Parameter(property="exec.workingdir") private File workingDirectory
      The current working directory. Optional. If not specified, basedir will be used.
      Since:
      1.0

    • outputFile

      @Parameter(property="exec.outputFile") private File outputFile
      Program standard and error output will be redirected to the file specified by this optional field. If not specified the standard Maven logging is used.
      Note: Be aware that System.out and System.err use buffering, so don't rely on the order!
      Since:
      1.1-beta-2
      See Also:

    • inheritIo

      @Parameter(property="exec.inheritIo") private boolean inheritIo
      Program standard input, output and error streams will be inherited from the maven process. This allow tighter control of the streams and the console.
      Since:
      3.0.1
      See Also:

    • useMavenLogger

      @Parameter(property="exec.useMavenLogger", defaultValue="false") private boolean useMavenLogger
      When enabled, program standard and error output will be redirected to the Maven logger as Info and Error level logs, respectively. If not enabled the traditional behavior of program output being directed to standard System.out and System.err is used.

      NOTE: When enabled, to log the program standard out as Maven Debug level instead of Info level use exec.quietLogs=true.

      This option can be extremely helpful when combined with multithreaded builds for two reasons:
      • Program output is suffixed with the owning thread name, making it easier to trace execution of a specific projects build thread.
      • Program output will not get jumbled with other maven log messages.
      For Example, if using exec:exec to run a script to echo a count from 1 to 100 as: 
      for i in {1..100}
do
  echo "${project.artifactId} - $i"
done
      When this script is run multi-threaded on two modules, module1 and module2, you might get output such as: 
      [BuilderThread 1] [INFO] --- exec-maven-plugin:1.6.0:exec (test) @ module1 ---
[BuilderThread 2] [INFO] --- exec-maven-plugin:1.6.0:exec (test) @ module2 ---
...
module2 - 98
modu
module1 - 97
module1 -
le2 - 9899
...
      With this flag enabled, the output will instead come something similar to: 
      ...
[Exec Stream Pumper] [INFO] [BuilderThread 2] module2 - 98
[Exec Stream Pumper] [INFO] [BuilderThread 1] module1 - 97
[Exec Stream Pumper] [INFO] [BuilderThread 1] module1 - 98
[Exec Stream Pumper] [INFO] [BuilderThread 2] module2 - 99
...
      NOTE 1: To show the thread in the Maven log, configure the Maven installations conf/logging/simplelogger.properties option: org.slf4j.simpleLogger.showThreadName=true
      NOTE 2: This option is ignored when exec.outputFile is specified.
      Since:
      3.0.0
      See Also:

    • quietLogs

      @Parameter(property="exec.quietLogs", defaultValue="false") private boolean quietLogs
      When combined with exec.useMavenLogger=true, prints all executed program output at debug level instead of the default info level to the Maven logger.
      Since:
      3.0.0

    • arguments

      @Parameter private List<?> arguments

      A list of arguments passed to the executable, which should be of type <argument> or <classpath>. Can be overridden by using the exec.args environment variable.

      Since:
      1.0

    • basedir

      @Parameter(readonly=true, required=true, defaultValue="${basedir}") private File basedir
      Since:
      1.0

    • buildDirectory

      @Parameter(readonly=true, required=true, defaultValue="${project.build.directory}") private File buildDirectory
      Since:
      3.0.0

    • environmentVariables

      @Parameter private Map<String,String> environmentVariables

      Environment variables to pass to the executed program. For example if you want to set the LANG var: <environmentVariables> <LANG>en_US</LANG> </environmentVariables>

      Since:
      1.1-beta-2

    • environmentScript

      @Parameter private File environmentScript
      Environment script to be merged with environmentVariables This script is platform specifics, on Unix its must be Bourne shell format. Use this feature if you have a need to create environment variable dynamically such as invoking Visual Studio environment script file
      Since:
      1.4.0

    • successCodes

      @Parameter private int[] successCodes
      Exit codes to be resolved as successful execution for non-compliant applications (applications not returning 0 for success).
      Since:
      1.1.1

    • longClasspath

      @Parameter(property="exec.longClasspath", defaultValue="false") private boolean longClasspath
      If set to true the classpath and the main class will be written to a MANIFEST.MF file and wrapped into a jar. Instead of '-classpath/-cp CLASSPATH mainClass' the exec plugin executes '-jar maven-exec.jar'.
      Since:
      1.1.2

    • longModulepath

      @Parameter(property="exec.longModulepath", defaultValue="true") private boolean longModulepath
      If set to true the modulepath and the main class will be written as an @arg file Instead of '--module-path/-p MODULEPATH ' the exec plugin executes '@modulepath'.
      Since:
      1.1.2

    • forceJava

      @Parameter(property="exec.forceJava", defaultValue="false") private boolean forceJava
      Forces the plugin to recognize the given executable as java executable. This helps with longClasspath and longModulepath parameters.

      You shouldn't normally be needing this unless you renamed your java binary or are executing tools other than java which need modulepath or classpath parameters in a separate file.

      Since:
      3.1.1

    • async

      @Parameter(property="exec.async", defaultValue="false") private boolean async
      If set to true the child process executes asynchronously and build execution continues in parallel.

    • asyncDestroyOnShutdown

      @Parameter(property="exec.asyncDestroyOnShutdown", defaultValue="true") private boolean asyncDestroyOnShutdown
      If set to true, the asynchronous child process is destroyed upon JVM shutdown. If set to false, asynchronous child process continues execution after JVM shutdown. Applies only to asynchronous processes; ignored for synchronous processes.

    • toolchainJavaHomeEnvName

      @Parameter(property="exec.toolchainJavaHomeEnvName", defaultValue="TOOLCHAIN_JAVA_HOME") private String toolchainJavaHomeEnvName
      Name of environment variable that will contain path to java executable provided by the toolchain (works only if JDK toolchain feature is used)
      Since:
      3.5.0

    • toolchainManager

      @Component private org.apache.maven.toolchain.ToolchainManager toolchainManager

    • CLASSPATH_TOKEN

      public static final String CLASSPATH_TOKEN
      See Also:

    • MODULEPATH_TOKEN

      public static final String MODULEPATH_TOKEN
      See Also:

    • processDestroyer

      private org.apache.commons.exec.ProcessDestroyer processDestroyer

  • Constructor Details

    • ExecMojo

      public ExecMojo()

  • Method Details

    • execute

      public void execute() throws org.apache.maven.plugin.MojoExecutionException
      priority in the execute method will be to use System properties arguments over the pom specification.
      Throws:
      org.apache.maven.plugin.MojoExecutionException - if a failure happens

    • handleSystemEnvVariables

      private Map<String,String> handleSystemEnvVariables() throws org.apache.maven.plugin.MojoExecutionException
      Throws:
      org.apache.maven.plugin.MojoExecutionException

    • handleWorkingDirectory

      private void handleWorkingDirectory() throws org.apache.maven.plugin.MojoExecutionException
      This is a convenient method to make the execute method a little bit more readable. It will define the workingDirectory to be the baseDir in case of workingDirectory is null. If the workingDirectory does not exist it will created.
      Throws:
      org.apache.maven.plugin.MojoExecutionException

    • handleSystemPropertyArguments

      private void handleSystemPropertyArguments(String argsProp, List<String> commandArguments) throws org.apache.maven.plugin.MojoExecutionException
      Throws:
      org.apache.maven.plugin.MojoExecutionException

    • handleCommandLineArgs

      private void handleCommandLineArgs(List<String> commandArguments) throws org.apache.maven.plugin.MojoExecutionException, IOException
      Throws:
      org.apache.maven.plugin.MojoExecutionException
      IOException

    • handleArguments

      private void handleArguments(List<String> commandArguments) throws org.apache.maven.plugin.MojoExecutionException, IOException
      Throws:
      org.apache.maven.plugin.MojoExecutionException
      IOException

    • fillSuccessCodes

      private void fillSuccessCodes(org.apache.commons.exec.Executor exec)

    • isResultCodeAFailure

      boolean isResultCodeAFailure(int result)

    • isLongClassPathArgument

      private boolean isLongClassPathArgument(String arg)

    • isLongModulePathArgument

      private boolean isLongModulePathArgument(String arg)

    • isJavaExec

      private boolean isJavaExec()
      Returns true when a java binary is being executed.
      Returns:
      true when a java binary is being executed.

    • computeClasspathString

      private String computeClasspathString(AbstractPath specifiedClasspath) throws org.apache.maven.plugin.MojoExecutionException
      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.
      Parameters:
      specifiedClasspath - Non null when the user restricted the dependencies, null otherwise (the default classpath will be used)
      Returns:
      a platform specific String representation of the classpath
      Throws:
      org.apache.maven.plugin.MojoExecutionException

    • computePath

      private List<String> computePath(AbstractPath specifiedClasspath) throws org.apache.maven.plugin.MojoExecutionException
      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.
      Parameters:
      specifiedClasspath - Non null when the user restricted the dependencies, null otherwise (the default classpath will be used)
      Returns:
      a list of class path elements
      Throws:
      org.apache.maven.plugin.MojoExecutionException

    • addToClasspath

      private static void addToClasspath(StringBuffer theClasspath, String toAdd)

    • filterArtifacts

      private List<org.apache.maven.artifact.Artifact> filterArtifacts(List<org.apache.maven.artifact.Artifact> artifacts, Collection<String> dependencies)

    • getExecutablePath

      org.apache.commons.exec.CommandLine getExecutablePath(Map<String,String> enviro, File dir)

    • findExecutable

      static String findExecutable(String executable, List<String> paths)

    • hasNativeExtension

      private static boolean hasNativeExtension(String exec)

    • hasExecutableExtension

      private static boolean hasExecutableExtension(String exec)

    • getExecutableExtensions

      private static List<String> getExecutableExtensions()

    • getExecutablePaths

      private List<String> getExecutablePaths(Map<String,String> enviro)

    • executeCommandLine

      protected int executeCommandLine(org.apache.commons.exec.Executor exec, org.apache.commons.exec.CommandLine commandLine, Map<String,String> enviro, OutputStream out, OutputStream err) throws IOException
      Throws:
      IOException

    • executeCommandLine

      protected int executeCommandLine(org.apache.commons.exec.Executor exec, org.apache.commons.exec.CommandLine commandLine, Map<String,String> enviro, FileOutputStream outputFile) throws IOException
      Throws:
      IOException

    • executeCommandLine

      protected int executeCommandLine(org.apache.commons.exec.Executor exec, org.apache.commons.exec.CommandLine commandLine, Map<String,String> enviro, org.apache.commons.exec.PumpStreamHandler psh) throws IOException
      Throws:
      IOException

    • setExecutable

      void setExecutable(String executable)

    • getExecutable

      String getExecutable()

    • setWorkingDirectory

      void setWorkingDirectory(String workingDir)

    • setWorkingDirectory

      void setWorkingDirectory(File workingDir)

    • setArguments

      void setArguments(List<?> arguments)

    • setBasedir

      void setBasedir(File basedir)

    • setProject

      void setProject(org.apache.maven.project.MavenProject project)

    • getSystemProperty

      protected String getSystemProperty(String key)

    • setSuccessCodes

      public void setSuccessCodes(Integer... list)

    • getSuccessCodes

      public int[] getSuccessCodes()

    • getToolchain

      private org.apache.maven.toolchain.Toolchain getToolchain()

    • createJar

      private File createJar(List<String> classPath, String mainClass) throws IOException
      Create a jar with just a manifest containing a Main-Class entry for SurefireBooter and a Class-Path entry for all classpath elements. Copied from surefire (ForkConfiguration#createJar())
      Parameters:
      classPath - List<String> of all classpath elements.
      Returns:
      Throws:
      IOException

    • createArgFile

      private void createArgFile(String filePath, List<String> lines) throws IOException
      Throws:
      IOException

    • createEnvs

      protected Map<String,String> createEnvs(File envScriptFile) throws org.apache.maven.plugin.MojoExecutionException
      Throws:
      org.apache.maven.plugin.MojoExecutionException

    • createEnvWrapperFile

      protected File createEnvWrapperFile(File envScript) throws IOException
      Throws:
      IOException

    • getProcessDestroyer

      protected org.apache.commons.exec.ProcessDestroyer getProcessDestroyer()