File	Doc	Category	Size	Date	Package
ExecuteWatchdog.java	API Doc	Apache Ant 1.70	5833	Wed Dec 13 06:16:20 GMT 2006	org.apache.tools.ant.taskdefs

ExecuteWatchdog

• java.lang.Object

ExecuteWatchdog watchdog = new ExecuteWatchdog(30000);
Execute exec = new Execute(myloghandler, watchdog);
exec.setCommandLine(mycmdline);
int exitvalue = exec.execute();
if (Execute.isFailure(exitvalue) && watchdog.killedProcess()) {
// it was killed on purpose by the watchdog
}

Fields Summary
private Process	process the process to execute and watch for duration
private volatile boolean	watch say whether or not the watchdog is currently monitoring a process
private Exception	caught exception that might be thrown during the process execution
private volatile boolean	killedProcess say whether or not the process was killed due to running overtime
private org.apache.tools.ant.util.Watchdog	watchdog will tell us whether timeout has occurred

Constructors Summary
public ExecuteWatchdog(long timeout) Creates a new watchdog with a given timeout. param timeout the timeout for the process in milliseconds. It must be greater than 0. watchdog = new Watchdog(timeout); watchdog.addTimeoutObserver(this);
public ExecuteWatchdog(int timeout) param timeout the timeout value to use in milliseconds. see #ExecuteWatchdog(long) deprecated since 1.5.x. Use constructor with a long type instead. (1.4.x compatibility) this((long) timeout);

Methods Summary
public synchronized void	checkException() 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 BuildException a wrapped exception over the one that was silently swallowed and stored during the process run. if (caught != null) { throw new BuildException("Exception in ExecuteWatchdog.run: " + caught.getMessage(), caught); }
protected synchronized void	cleanUp() reset the monitor flag and the process. watch = false; process = null;
public boolean	isWatching() Indicates whether or not the watchdog is still monitoring the process. return true if the process is still running, otherwise false. return watch;
public boolean	killedProcess() Indicates whether the last process run was killed on timeout or not. return true if the process was killed otherwise false. return killedProcess;
public synchronized void	start(java.lang.Process process) Watches the given process and terminates it, if it runs for too long. All information from the previous run are reset. param process the process to monitor. It cannot be null throws IllegalStateException if a process is still being monitored. if (process == 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 = process; watchdog.start();
public synchronized void	stop() Stops the watcher. It will notify all threads possibly waiting on this object. watchdog.stop(); cleanUp();
public synchronized void	timeoutOccured(org.apache.tools.ant.util.Watchdog w) Called after watchdog has finished. This can be called in the watchdog thread param w the watchdog try { try { // We must check if the process was not stopped // before being here process.exitValue(); } catch (IllegalThreadStateException itse) { // the process is not terminated, if this is really // a timeout and not a manual stop then kill it. if (watch) { killedProcess = true; process.destroy(); } } } catch (Exception e) { caught = e; } finally { cleanUp(); }