-
*
- set a current working directory for the subprocess *
- provide a set of environment variables passed to the subprocess *
- capture the subprocess output of stdout and stderr using an ExecuteStreamHandler *
- kill long-running processes using an ExecuteWatchdog *
- define a set of expected exit values *
- terminate any started processes when the main process is terminating using a ProcessDestroyer *
* Executor exec = new DefaultExecutor();
* CommandLine cl = new CommandLine("ls -l");
* int exitvalue = exec.execute(cl);
*
*
* @version $Id: DefaultExecutor.java 1636056 2014-11-01 21:12:52Z ggregory $
*/
public class DefaultExecutor implements Executor {
/** taking care of output and error stream */
private ExecuteStreamHandler streamHandler;
/** the working directory of the process */
private File workingDirectory;
/** monitoring of long running processes */
private ExecuteWatchdog watchdog;
/** the exit values considered to be successful */
private int[] exitValues;
/** launches the command in a new process */
private final CommandLauncher launcher;
/** optional cleanup of started processes */
private ProcessDestroyer processDestroyer;
/** worker thread for asynchronous execution */
private Thread executorThread;
/** the first exception being caught to be thrown to the caller */
private IOException exceptionCaught;
/**
* Default constructor creating a default {@code PumpStreamHandler}
* and sets the working directory of the subprocess to the current
* working directory.
*
* The {@code PumpStreamHandler} pumps the output of the subprocess
* into our {@code System.out} and {@code System.err} to avoid
* into our {@code System.out} and {@code System.err} to avoid
* a blocked or deadlocked subprocess (see{@link java.lang.Process Process}).
*/
public DefaultExecutor() {
this.streamHandler = new PumpStreamHandler();
this.launcher = CommandLauncherFactory.createVMLauncher();
this.exitValues = new int[0];
this.workingDirectory = new File(".");
this.exceptionCaught = null;
}
/**
* @see org.apache.commons.exec.Executor#getStreamHandler()
*/
public ExecuteStreamHandler getStreamHandler() {
return streamHandler;
}
/**
* @see org.apache.commons.exec.Executor#setStreamHandler(org.apache.commons.exec.ExecuteStreamHandler)
*/
public void setStreamHandler(final ExecuteStreamHandler streamHandler) {
this.streamHandler = streamHandler;
}
/**
* @see org.apache.commons.exec.Executor#getWatchdog()
*/
public ExecuteWatchdog getWatchdog() {
return watchdog;
}
/**
* @see org.apache.commons.exec.Executor#setWatchdog(org.apache.commons.exec.ExecuteWatchdog)
*/
public void setWatchdog(final ExecuteWatchdog watchDog) {
this.watchdog = watchDog;
}
/**
* @see org.apache.commons.exec.Executor#getProcessDestroyer()
*/
public ProcessDestroyer getProcessDestroyer() {
return this.processDestroyer;
}
/**
* @see org.apache.commons.exec.Executor#setProcessDestroyer(ProcessDestroyer)
*/
public void setProcessDestroyer(final ProcessDestroyer processDestroyer) {
this.processDestroyer = processDestroyer;
}
/**
* @see org.apache.commons.exec.Executor#getWorkingDirectory()
*/
public File getWorkingDirectory() {
return workingDirectory;
}
/**
* @see org.apache.commons.exec.Executor#setWorkingDirectory(java.io.File)
*/
public void setWorkingDirectory(final File dir) {
this.workingDirectory = dir;
}
/**
* @see org.apache.commons.exec.Executor#execute(CommandLine)
*/
public int execute(final CommandLine command) throws ExecuteException,
IOException {
return execute(command, (MapProcess.
*/
private void closeProcessStreams(final Process process) {
try {
process.getInputStream().close();
}
catch (final IOException e) {
setExceptionCaught(e);
}
try {
process.getOutputStream().close();
}
catch (final IOException e) {
setExceptionCaught(e);
}
try {
process.getErrorStream().close();
}
catch (final IOException e) {
setExceptionCaught(e);
}
}
/**
* Execute an internal process. If the executing thread is interrupted while waiting for the
* child process to return the child process will be killed.
*
* @param command the command to execute
* @param environment the execution environment
* @param dir the working directory
* @param streams process the streams (in, out, err) of the process
* @return the exit code of the process
* @throws IOException executing the process failed
*/
private int executeInternal(final CommandLine command, final Map
* ExecuteWatchdog watchdog = new ExecuteWatchdog(30000);
* Executer exec = new Executer(myloghandler, watchdog);
* exec.setCommandLine(mycmdline);
* int exitvalue = exec.execute();
* if (Execute.isFailure(exitvalue) && watchdog.killedProcess()) {
* // it was killed on purpose by the watchdog
* }
*
*
* When starting an asynchronous process than 'ExecuteWatchdog' is the
* keeper of the process handle. In some cases it is useful not to define
* a timeout (and pass 'INFINITE_TIMEOUT') and to kill the process explicitly
* using 'destroyProcess()'.
* * Please note that ExecuteWatchdog is processed asynchronously, e.g. it might * be still attached to a process even after the DefaultExecutor.execute * has returned. * * @see org.apache.commons.exec.Executor * @see org.apache.commons.exec.Watchdog * * @version $Id: ExecuteWatchdog.java 1612032 2014-07-20 06:30:44Z ggregory $ */ public class ExecuteWatchdog implements TimeoutObserver { /** The marker for an infinite timeout */ public static final long INFINITE_TIMEOUT = -1; /** The process to execute and watch for duration. */ private Process process; /** Is a user-supplied timeout in use */ private final boolean hasWatchdog; /** Say whether or not the watchdog is currently monitoring a process. */ private boolean watch; /** Exception that might be thrown during the process execution. */ private Exception caught; /** Say whether or not the process was killed due to running overtime. */ private boolean killedProcess; /** Will tell us whether timeout has occurred. */ private final Watchdog watchdog; /** Indicates that the process is verified as started */ private volatile boolean processStarted; /** * Creates a new watchdog with a given timeout. * * @param timeout * the timeout for the process in milliseconds. It must be * greater than 0 or 'INFINITE_TIMEOUT' */ public ExecuteWatchdog(final long timeout) { this.killedProcess = false; this.watch = false; this.hasWatchdog = timeout != INFINITE_TIMEOUT; this.processStarted = false; if (this.hasWatchdog) { this.watchdog = new Watchdog(timeout); this.watchdog.addTimeoutObserver(this); } else { this.watchdog = null; } } /** * Watches the given process and terminates it, if it runs for too long. All * information from the previous run are reset. * * @param processToMonitor * the process to monitor. It cannot be {@code null} * @throws IllegalStateException * if a process is still being monitored. */ public synchronized void start(final Process processToMonitor) { if (processToMonitor == null) { throw new NullPointerException("process is null."); } if (this.process != null) { throw new IllegalStateException("Already running."); } this.caught = null; this.killedProcess = false; this.watch = true; this.process = processToMonitor; this.processStarted = true; this.notifyAll(); if (this.hasWatchdog) { watchdog.start(); } } /** * Stops the watcher. It will notify all threads possibly waiting on this * object. */ public synchronized void stop() { if (hasWatchdog) { watchdog.stop(); } watch = false; process = null; } /** * Destroys the running process manually. */ public synchronized void destroyProcess() { ensureStarted(); this.timeoutOccured(null); this.stop(); } /** * Called after watchdog has finished. */ public synchronized void timeoutOccured(final Watchdog w) { try { try { // We must check if the process was not stopped // before being here if (process != null) { process.exitValue(); } } catch (final IllegalThreadStateException itse) { // the process is not terminated, if this is really // a timeout and not a manual stop then destroy it. if (watch) { killedProcess = true; process.destroy(); } } } catch (final Exception e) { caught = e; DebugUtils.handleException("Getting the exit value of the process failed", e); } finally { cleanUp(); } } /** * This method will rethrow the exception that was possibly caught during * the run of the process. It will only remains valid once the process has * been terminated either by 'error', timeout or manual intervention. * Information will be discarded once a new process is ran. * * @throws Exception * a wrapped exception over the one that was silently swallowed * and stored during the process run. */ public synchronized void checkException() throws Exception { if (caught != null) { throw caught; } } /** * Indicates whether or not the watchdog is still monitoring the process. * * @return {@code true} if the process is still running, otherwise * {@code false}. */ public synchronized boolean isWatching() { ensureStarted(); return watch; } /** * Indicates whether the last process run was killed. * * @return {@code true} if the process was killed * {@code false}. */ public synchronized boolean killedProcess() { return killedProcess; } /** * reset the monitor flag and the process. */ protected synchronized void cleanUp() { watch = false; process = null; } void setProcessNotStarted() { processStarted = false; } /** * Ensures that the process is started, so we do not race with asynch execution. * The caller of this method must be holding the lock on this */ private void ensureStarted() { while (!processStarted) { try { this.wait(); } catch (final InterruptedException e) { throw new RuntimeException(e.getMessage()); } } } } commons-exec-1.3-src/src/main/java/org/apache/commons/exec/Executor.java 100644 0 0 17163 12425540624 23426 0 ustar 0 0 /* * 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. * */ package org.apache.commons.exec; import java.io.File; import java.io.IOException; import java.util.Map; /** * The main abstraction to start an external process. * * The interface allows to *
-
*
- set a current working directory for the subprocess *
- provide a set of environment variables passed to the subprocess *
- capture the subprocess output of stdout and stderr using an ExecuteStreamHandler *
- kill long-running processes using an ExecuteWatchdog *
- define a set of expected exit values *
- terminate any started processes when the main process is terminating using a ProcessDestroyer *
* Executor exec = new DefaultExecutor();
* CommandLine cl = new CommandLine("ls -l");
* int exitvalue = exec.execute(cl);
*
*
* @version $Id: Executor.java 1636056 2014-11-01 21:12:52Z ggregory $
*/
public interface Executor {
/** Invalid exit code. */
int INVALID_EXITVALUE = 0xdeadbeef;
/**
* Define the {@code exitValue} of the process to be considered
* successful. If a different exit value is returned by
* the process then {@link org.apache.commons.exec.Executor#execute(CommandLine)}
* will throw an {@link org.apache.commons.exec.ExecuteException}
*
* @param value the exit code representing successful execution
*/
void setExitValue(final int value);
/**
* Define a list of {@code exitValue} of the process to be considered
* successful. The caller can pass one of the following values
* -
*
- an array of exit values to be considered successful *
- an empty array for auto-detect of successful exit codes relying on {@link org.apache.commons.exec.Executor#isFailure(int)} *
- null to indicate to skip checking of exit codes *
* Note that this method relies on the conventions of the OS, it * will return false results if the application you are running doesn't * follow these conventions. One notable exception is the Java VM provided * by HP for OpenVMS - it will return 0 if successful (like on any other * platform), but this signals a failure on OpenVMS. So if you execute a new * Java VM on OpenVMS, you cannot trust this method. *
* * @param exitValue the exit value (return code) to be checked * @return {@code true} if {@code exitValue} signals a failure */ boolean isFailure(final int exitValue); } commons-exec-1.3-src/src/main/java/org/apache/commons/exec/launcher/CommandLauncherFactory.java 100644 0 0 3157 12425540624 27777 0 ustar 0 0 /* * 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. * */ package org.apache.commons.exec.launcher; import org.apache.commons.exec.OS; /** * Builds a command launcher for the OS and JVM we are running under. * * @version $Id: CommandLauncherFactory.java 1556869 2014-01-09 16:51:11Z britter $ */ public final class CommandLauncherFactory { private CommandLauncherFactory() { } /** * Factory method to create an appropriate launcher. * * @return the command launcher */ public static CommandLauncher createVMLauncher() { // Try using a JDK 1.3 launcher CommandLauncher launcher; if (OS.isFamilyOpenVms()) { launcher = new VmsCommandLauncher(); } else { launcher = new Java13CommandLauncher(); } return launcher; } } commons-exec-1.3-src/src/main/java/org/apache/commons/exec/launcher/CommandLauncherImpl.java 100644 0 0 3777 12425540624 27301 0 ustar 0 0 /* * 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. * */ package org.apache.commons.exec.launcher; import java.io.File; import java.io.IOException; import java.util.Map; import org.apache.commons.exec.CommandLine; import org.apache.commons.exec.environment.EnvironmentUtils; /** * A command launcher for a particular JVM/OS platform. This class is a general * purpose command launcher which can only launch commands in the current * working directory. * * @version $Id: CommandLauncherImpl.java 1557338 2014-01-11 10:34:22Z sebb $ */ public abstract class CommandLauncherImpl implements CommandLauncher { public Process exec(final CommandLine cmd, final Map* Unlike Windows NT and friends, OS/2's cd doesn't support the /d switch to * change drives and directories in one go. *
* Please not that this class is currently unused because the Java13CommandLauncher * is used for 0S/2 * * @version $Id: OS2CommandLauncher.java 1557338 2014-01-11 10:34:22Z sebb $ */ public class OS2CommandLauncher extends CommandLauncherProxy { public OS2CommandLauncher(final CommandLauncher launcher) { super(launcher); } /** * Launches the given command in a new process, in the given working * directory. * * @param cmd * the command line to execute as an array of strings * @param env * the environment to set as an array of strings * @param workingDir * working directory where the command should run * @throws IOException * forwarded from the exec method of the command launcher */ @Override public Process exec(final CommandLine cmd, final Map*
-
*
- dos *
- mac *
- netware *
- os/2 *
- tandem *
- unix *
- windows *
- win9x *
- z/os *
- os/400 *
PumpStreamHandler.
*/
public PumpStreamHandler() {
this(System.out, System.err);
}
/**
* Construct a new PumpStreamHandler.
*
* @param outAndErr the output/error OutputStream.
*/
public PumpStreamHandler(final OutputStream outAndErr) {
this(outAndErr, outAndErr);
}
/**
* Construct a new PumpStreamHandler.
*
* @param out the output OutputStream.
* @param err the error OutputStream.
*/
public PumpStreamHandler(final OutputStream out, final OutputStream err) {
this(out, err, null);
}
/**
* Construct a new PumpStreamHandler.
*
* @param out the output OutputStream.
* @param err the error OutputStream.
* @param input the input InputStream.
*/
public PumpStreamHandler(final OutputStream out, final OutputStream err, final InputStream input) {
this.out = out;
this.err = err;
this.input = input;
}
/**
* Set maximum time to wait until output streams are exchausted
* when {@link #stop()} was called.
*
* @param timeout timeout in milliseconds or zero to wait forever (default)
*/
public void setStopTimeout(final long timeout) {
this.stopTimeout = timeout;
}
/**
* Set the InputStream from which to read the standard output
* of the process.
*
* @param is the InputStream.
*/
public void setProcessOutputStream(final InputStream is) {
if (out != null) {
createProcessOutputPump(is, out);
}
}
/**
* Set the InputStream from which to read the standard error
* of the process.
*
* @param is the InputStream.
*/
public void setProcessErrorStream(final InputStream is) {
if (err != null) {
createProcessErrorPump(is, err);
}
}
/**
* Set the OutputStream by means of which input can be sent
* to the process.
*
* @param os the OutputStream.
*/
public void setProcessInputStream(final OutputStream os) {
if (input != null) {
if (input == System.in) {
inputThread = createSystemInPump(input, os);
} else {
inputThread = createPump(input, os, true);
}
} else {
try {
os.close();
} catch (final IOException e) {
final String msg = "Got exception while closing output stream";
DebugUtils.handleException(msg, e);
}
}
}
/**
* Start the Threads.
*/
public void start() {
if (outputThread != null) {
outputThread.start();
}
if (errorThread != null) {
errorThread.start();
}
if (inputThread != null) {
inputThread.start();
}
}
/**
* Stop pumping the streams. When a timeout is specified it it is not guaranteed that the
* pumper threads are cleanly terminated.
*/
public void stop() throws IOException {
if (inputStreamPumper != null) {
inputStreamPumper.stopProcessing();
}
stopThread(outputThread, stopTimeout);
stopThread(errorThread, stopTimeout);
stopThread(inputThread, stopTimeout);
if (err != null && err != out) {
try {
err.flush();
} catch (final IOException e) {
final String msg = "Got exception while flushing the error stream : " + e.getMessage();
DebugUtils.handleException(msg, e);
}
}
if (out != null) {
try {
out.flush();
} catch (final IOException e) {
final String msg = "Got exception while flushing the output stream";
DebugUtils.handleException(msg, e);
}
}
if (caught != null) {
throw caught;
}
}
/**
* Get the error stream.
*
* @return OutputStream.
*/
protected OutputStream getErr() {
return err;
}
/**
* Get the output stream.
*
* @return OutputStream.
*/
protected OutputStream getOut() {
return out;
}
/**
* Create the pump to handle process output.
*
* @param is the InputStream.
* @param os the OutputStream.
*/
protected void createProcessOutputPump(final InputStream is, final OutputStream os) {
outputThread = createPump(is, os);
}
/**
* Create the pump to handle error output.
*
* @param is the InputStream.
* @param os the OutputStream.
*/
protected void createProcessErrorPump(final InputStream is, final OutputStream os) {
errorThread = createPump(is, os);
}
/**
* Creates a stream pumper to copy the given input stream to the given
* output stream. When the 'os' is an PipedOutputStream we are closing
* 'os' afterwards to avoid an IOException ("Write end dead").
*
* @param is the input stream to copy from
* @param os the output stream to copy into
* @return the stream pumper thread
*/
protected Thread createPump(final InputStream is, final OutputStream os) {
final boolean closeWhenExhausted = os instanceof PipedOutputStream ? true : false;
return createPump(is, os, closeWhenExhausted);
}
/**
* Creates a stream pumper to copy the given input stream to the given
* output stream.
*
* @param is the input stream to copy from
* @param os the output stream to copy into
* @param closeWhenExhausted close the output stream when the input stream is exhausted
* @return the stream pumper thread
*/
protected Thread createPump(final InputStream is, final OutputStream os, final boolean closeWhenExhausted) {
final Thread result = new Thread(new StreamPumper(is, os, closeWhenExhausted), "Exec Stream Pumper");
result.setDaemon(true);
return result;
}
/**
* Stopping a pumper thread. The implementation actually waits
* longer than specified in 'timeout' to detect if the timeout
* was indeed exceeded. If the timeout was exceeded an IOException
* is created to be thrown to the caller.
*
* @param thread the thread to be stopped
* @param timeout the time in ms to wait to join
*/
protected void stopThread(final Thread thread, final long timeout) {
if (thread != null) {
try {
if (timeout == 0) {
thread.join();
} else {
final long timeToWait = timeout + STOP_TIMEOUT_ADDITION;
final long startTime = System.currentTimeMillis();
thread.join(timeToWait);
if (!(System.currentTimeMillis() < startTime + timeToWait)) {
final String msg = "The stop timeout of " + timeout + " ms was exceeded";
caught = new ExecuteException(msg, Executor.INVALID_EXITVALUE);
}
}
} catch (final InterruptedException e) {
thread.interrupt();
}
}
}
/**
* Creates a stream pumper to copy the given input stream to the given
* output stream.
*
* @param is the System.in input stream to copy from
* @param os the output stream to copy into
* @return the stream pumper thread
*/
private Thread createSystemInPump(final InputStream is, final OutputStream os) {
inputStreamPumper = new InputStreamPumper(is, os);
final Thread result = new Thread(inputStreamPumper, "Exec Input Stream Pumper");
result.setDaemon(true);
return result;
}
}
commons-exec-1.3-src/src/main/java/org/apache/commons/exec/ShutdownHookProcessDestroyer.java 100644 0 0 15242 12425540624 27520 0 ustar 0 0 /*
* 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.
*
*/
package org.apache.commons.exec;
import java.util.Enumeration;
import java.util.Vector;
/**
* Destroys all registered {@code Process}es when the VM exits.
*
* @version $Id: ShutdownHookProcessDestroyer.java 1636056 2014-11-01 21:12:52Z ggregory $
*/
public class ShutdownHookProcessDestroyer implements ProcessDestroyer, Runnable {
/** the list of currently running processes */
private final Vector* The substitutions are performed by replacing ${variable} in the target string with the value of provided by the * key "variable" in the provided hash table. *
** A key consists of the following characters: *
*-
*
- letter *
- digit *
- dot character *
- hyphen character *
- plus character *
- underscore character *
-
*
- '/' → File.separatorChar *
- '\\' → File.separatorChar *
* If the argument doesn't include spaces or quotes, return it as is. If it * contains double quotes, use single quotes - else surround the argument by * double quotes. *
* * @param argument the argument to be quoted * @return the quoted argument * @throws IllegalArgumentException If argument contains both types of quotes */ public static String quoteArgument(final String argument) { String cleanedArgument = argument.trim(); // strip the quotes from both ends while (cleanedArgument.startsWith(SINGLE_QUOTE) || cleanedArgument.startsWith(DOUBLE_QUOTE)) { cleanedArgument = cleanedArgument.substring(1); } while (cleanedArgument.endsWith(SINGLE_QUOTE) || cleanedArgument.endsWith(DOUBLE_QUOTE)) { cleanedArgument = cleanedArgument.substring(0, cleanedArgument.length() - 1); } final StringBuilder buf = new StringBuilder(); if (cleanedArgument.indexOf(DOUBLE_QUOTE) > -1) { if (cleanedArgument.indexOf(SINGLE_QUOTE) > -1) { throw new IllegalArgumentException( "Can't handle single and double quotes in same argument"); } return buf.append(SINGLE_QUOTE).append(cleanedArgument).append( SINGLE_QUOTE).toString(); } else if (cleanedArgument.indexOf(SINGLE_QUOTE) > -1 || cleanedArgument.indexOf(" ") > -1) { return buf.append(DOUBLE_QUOTE).append(cleanedArgument).append( DOUBLE_QUOTE).toString(); } else { return cleanedArgument; } } /** * Determines if this is a quoted argument - either single or * double quoted. * * @param argument the argument to check * @return true when the argument is quoted */ public static boolean isQuoted(final String argument) { return argument.startsWith(SINGLE_QUOTE) && argument.endsWith(SINGLE_QUOTE) || argument.startsWith(DOUBLE_QUOTE) && argument.endsWith(DOUBLE_QUOTE); } } commons-exec-1.3-src/src/main/java/org/apache/commons/exec/Watchdog.java 100644 0 0 5725 12425540624 23351 0 ustar 0 0 /* * 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. * */ package org.apache.commons.exec; import java.util.Enumeration; import java.util.Vector; /** * Generalization of {@code ExecuteWatchdog} * * @see org.apache.commons.exec.ExecuteWatchdog * * @version $Id: Watchdog.java 1636056 2014-11-01 21:12:52Z ggregory $ */ public class Watchdog implements Runnable { private final VectorThe code was ported from Apache Ant and extensively tested on various platforms. So there is no reason not to use it and it is very likely better than any home-grown library.
It is recommended to use CommandLine.addArgument() instead of CommandLine.parse(). Using CommandLine.parse() the implementation tries to figure out the correct quoting using your arguments and file names containing spaces. With CommandLine.addArgument() you can enable/disable quoting depending on your requirements. Having said that this is the recommended approach using Ant anyway.
This functionality is largely depend on the operating system - on Unix it works mostly and under Windows not at all (see Bug 4770092). In terms of stability and cross-platform support try to start your applications directly and avoid various wrapper scripts.
Well - one out of 55 regression tests fails. The EnvironmentUtilTest.testGetProcEnvironment() test fails because it detects no environment variables for the current process but there must be one since we require JAVA_HOME to be set. Not sure if this is a plain bug in java-gcj-4.2.1 or requires a work around in commons-exec
Assuming that you have an environment not listed on the test matrix and want to make sure that everything works fine you can run easily run the regression tests. Make a SVN checkout and run 'ant test-distribution' to create the test distribution in './target'. On a production box downloading the ready-to-run test distribution might be even more handy ( http://people.apache.org/~sgoeschl/download/commons-exec/). Unpack the 'zip' or 'tar.gz' file and start the tests. Independent from the result we very much appreciate your feedback ... :-)
Please check if the shell scripts under "./src/test/script" are executable - assuming that they are not executable the "testExecute*" and "testExecuteAsync*" test will fail. We try very hard to keep the executable bit but they have somehow the tendency to to be lost ...
We recommend you use a mirror to download our release builds, but you must verify the integrity of the downloaded files using signatures downloaded from our main distribution directories. Recent releases (48 hours) may not yet be available from the mirrors.
You are currently using [preferred]. If you
encounter a problem with this mirror, please select another
mirror. If all mirrors are failing, there are backup
mirrors (at the end of the mirrors list) that should be
available.
[if-any logo][end]
The KEYS
link links to the code signing keys used to sign the product.
The PGP link downloads the OpenPGP compatible signature from our main site.
The MD5 link downloads the checksum from the main site.
| commons-exec-1.3-bin.tar.gz | md5 | pgp |
| commons-exec-1.3-bin.zip | md5 | pgp |
| commons-exec-1.3-src.tar.gz | md5 | pgp |
| commons-exec-1.3-src.zip | md5 | pgp |
Older releases can be obtained from the archives.
Commons Exec uses ASF JIRA for tracking issues. See the Commons Exec JIRA project page.
To use JIRA you may need to create an account (if you have previously created/updated Commons issues using Bugzilla an account will have been automatically created and you can use the Forgot Password page to get a new password).
If you would like to report a bug, or raise an enhancement request with Commons Exec please do the following:
- Search existing open bugs. If you find your issue listed then please add a comment with your details.
- Search the mailing list archive(s). You may find your issue or idea has already been discussed.
- Decide if your issue is a bug or an enhancement.
- Submit either a bug report or enhancement request.
Please also remember these points:
- the more information you provide, the better we can help you
- test cases are vital, particularly for any proposed enhancements
- the developers of Commons Exec are all unpaid volunteers
For more information on subversion and creating patches see the Apache Contributors Guide.
You may also find these links useful:
Commons Exec shares mailing lists with all the other Commons Components. To make it easier for people to only read messages related to components they are interested in, the convention in Commons is to prefix the subject line of messages with the component's name, for example:
- [exec] Problem with the ...
Questions related to the usage of Commons Exec should be posted to the
User List.
The Developer List
is for questions and discussion related to the development of Commons Exec.
Please do not cross-post; developers are also subscribed to the user list.
Note: please don't send patches or attachments to any of the mailing lists. Patches are best handled via the Issue Tracking system. Otherwise, please upload the file to a public server and include the URL in the mail.
Please prefix the subject line of any messages for Commons Exec
with [exec] - thanks!
| Name | Subscribe | Unsubscribe | Post | Archive | Other Archives |
|---|---|---|---|---|---|
|
Commons User List
Questions on using Commons Exec. |
Subscribe | Unsubscribe | Post | mail-archives.apache.org | markmail.org www.mail-archive.com news.gmane.org |
|
Commons Developer List
Discussion of development of Commons Exec. |
Subscribe | Unsubscribe | Post | mail-archives.apache.org | markmail.org www.mail-archive.com news.gmane.org |
|
Commons Issues List
Only for e-mails automatically generated by the issue tracking system. |
Subscribe | Unsubscribe | read only | mail-archives.apache.org | markmail.org www.mail-archive.com |
|
Commons Commits List
Only for e-mails automatically generated by the source control sytem. |
Subscribe | Unsubscribe | read only | mail-archives.apache.org | markmail.org www.mail-archive.com |
Other mailing lists which you may find useful include:
| Name | Subscribe | Unsubscribe | Post | Archive | Other Archives |
|---|---|---|---|---|---|
|
Apache Announce List
General announcements of Apache project releases. |
Subscribe | Unsubscribe | read only | mail-archives.apache.org | markmail.org old.nabble.com www.mail-archive.com news.gmane.org |
The following tables contains the test results of running the comons-exec regression tests on different OS/JVMs
| Operating System | JVM | Status | Reporter |
|---|---|---|---|
| Linux (2.6.34.7-56.fc1, x86, 64 bit) | java version "1.6.0_20" Java(TM) SE Runtime Environment (build 1.6.0_20-b02) Java HotSpot(TM) 64-Bit Server VM (build 16.3-b01, mixed mode) |
Passed | James Carman |
| Linux (2.6.35-gentoo-r9, x86, 64 bit) | java version "1.6.0_21" Java(TM) SE Runtime Environment (build 1.6.0_21-b06) Java HotSpot(TM) 64-Bit Server VM (build 17.0-b16, mixed mode) |
Passed | Jörg Schaible |
| Linux (2.6.35-gentoo-r9, x86, 64 bit) | java version "1.5.0_22" Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_22-b03) Java HotSpot(TM) 64-Bit Server VM (build 1.5.0_22-b03, mixed mode) |
Passed | Jörg Schaible |
| Linux (2.6.35-gentoo-r9, x86, 64 bit) | java version "1.4.2-03" Java(TM) 2 Runtime Environment, Standard Edition (build Blackdown-1.4.2-03) Java HotSpot(TM) 64-Bit Server VM (build Blackdown-1.4.2-03, mixed mode) |
Failed DefaultExecutorTest#testEnvironmentVariables DefaultExecutorTest#testAddEnvironmentVariables |
Jörg Schaible |
| Linux (2.6.35-gentoo-r9, x86, 64 bit) | java version "1.5.0" Java(TM) 2 Runtime Environment, Standard Edition (build pxa64dev-20100813 (SR12 FP1 )) IBM J9 VM (build 2.3, J2RE 1.5.0 IBM J9 2.3 Linux amd64-64 j9vmxa6423-20100808 (JIT enabled) |
Passed | Jörg Schaible |
| Linux (2.6.35-gentoo-r9, x86, 64 bit) | java version "1.6.0" Java(TM) SE Runtime Environment (build pxa6460sr8fp1-20100624_01(SR8 FP1)) IBM J9 VM (build 2.4, JRE 1.6.0 IBM J9 2.4 Linux amd64-64 jvmxa6460sr8ifx-20100609_59383 (JIT enabled, AOT enabled) |
Passed | Jörg Schaible |
| Linux (2.6.35-gentoo-r9, x86, 64 bit) | java version "1.6.0_18" OpenJDK Runtime Environment (IcedTea6 1.8.1) (Gentoo build 1.6.0_18-b18) OpenJDK 64-Bit Server VM (build 16.0-b13, mixed mode) |
Passed | Jörg Schaible |
| Linux (2.6.35-gentoo-r9, x86, 64 bit) | java version "1.5.0" JamVM version 1.5.4 Copyright (C) 2003-2010 Robert Lougher GPL2 Execution Engine: inline-threaded interpreter Compiled with: gcc 4.4.3 |
Failed DefaultExecutorTest#testExecuteAsyncWithTimelyUserTermination |
Jörg Schaible |
| Operating System | JVM | Status | Reporter |
|---|---|---|---|
| Mac OS X (Darwin Kernel Version 13.0.0) | java version "1.7.0_45" Java(TM) SE Runtime Environment (build 1.7.0_45-b18) Java HotSpot(TM) 64-Bit Server VM (build 24.45-b08, mixed mode) |
Passed | Emmanuel Keller |
| Mac OS X (Darwin Kernel Version 10.4.0) | java version "1.6.0_20" Java(TM) SE Runtime Environment (build 1.6.0_20-b02) Java HotSpot(TM) 64-Bit Server VM (build 16.3-b01, mixed mode) |
Passed | James Carman |
| Mac OS X (Darwin Kernel Version 10.4.0) | java version "1.5.0_24" Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_24-b02-357-10M3065) Java HotSpot(TM) Client VM (build 1.5.0_24-149, mixed mode, sharing) |
Passed | Simon Tripodi |
| Operating System | JVM | Status | Reporter |
|---|---|---|---|
| Windows 7 Professional 64 bit | java version "1.6.0_20" Java(TM) SE Runtime Environment (build 1.6.0_20-b02) Java HotSpot(TM) 64-Bit Server VM (build 16.3-b01, mixed mode) |
Passed | James Carman |
| Windows 7 Enterprise | java version "1.6.0_21" | Passed | Niall Pemberton |
| Windows 7 Enterprise | java version "1.5.0_22-b03" | Passed | Niall Pemberton |
| Windows 7 Enterprise | java version "1.4.2_19-b04" | Passed | Niall Pemberton |
| Windows 7 Enterprise | java version "1.3.1_18-b01" | Passed | Niall Pemberton |
| Windows Vista Business | java version "1.6.0_21" Java(TM) SE Runtime Environment (build 1.6.0_21-b07) Java HotSpot(TM) 64-Bit Server VM (build 17.0-b17, mixed mode) |
Passed | Gary Gregory |
| Operating System | JVM | Status | Reporter |
|---|---|---|---|
| OpenVMS V8.3 (AlphaServer ES40 - 4 CPUs) | Fast VM (build 1.5.0-4, build J2SDK.v.1.5.0:03/31/2008-15:26, native threads, jit_150) | Fails tests which try to terminate a subprocess
|
Sebastian Bazley |
| OpenVMS V8.3-1H1 (Integrity HP rx2600 (1.30GHz/3.0MB) - 2 CPUs) | Java HotSpot(TM) Server VM (build 1.5.0-2 12/02/2006-21:30 IA64, mixed mode) | Fails tests which try to terminate a subprocess
|
Sebastian Bazley |
-
*
- blocking or non-blocking print jobs *
- with print job timeouts to trigger the {@code ExecuteWatchdog} *
- with the {@code exitValue} returned from the print script *