Java ExecuteWatchdog.killedProcess方法代碼示例

import org.apache.commons.exec.ExecuteWatchdog; //導入方法依賴的package包/類
@Override
public Long call() throws Exception {
    Executor executor = new DefaultExecutor();
    executor.setProcessDestroyer(new ShutdownHookProcessDestroyer());
    ExecuteWatchdog watchDog = new ExecuteWatchdog(watchdogTimeout);
    executor.setWatchdog(watchDog);
    executor.setStreamHandler(new PumpStreamHandler(new MyLogOutputStream(handler, true), new MyLogOutputStream(handler, false)));
    Long exitValue;
    try {
        exitValue = new Long(executor.execute(commandline));
    } catch (ExecuteException e) {
        exitValue = new Long(e.getExitValue());
    }
    if (watchDog.killedProcess()) {
        exitValue = WATCHDOG_EXIST_VALUE;
    }
    return exitValue;
}
 

import org.apache.commons.exec.ExecuteWatchdog; //導入方法依賴的package包/類
public void compile(String cwd, Submission submission) throws RuntimeException {
    ByteArrayOutputStream stderr = new ByteArrayOutputStream();
    ExecuteWatchdog watchdog = new ExecuteWatchdog(watchdogTimeout);

    DefaultExecutor executor = new DefaultExecutor();
    executor.setWorkingDirectory(new File(cwd));
    executor.setStreamHandler(new PumpStreamHandler(null, stderr, null));
    executor.setWatchdog(watchdog);

    CommandLine cmd = new CommandLine(javac);
    cmd.addArgument("-J-Duser.language=en");  // force using English
    cmd.addArgument("-classpath");
    cmd.addArgument(cwd);
    cmd.addArgument(fileName + ".java");
    logger.info("Compiler cmd:\t" + cmd.toString());

    try {
        executor.execute(cmd);
        logger.info("Compile OK");
    } catch (IOException e) {
        if (watchdog.killedProcess()) {
            submission.setStatus(Submission.STATUS_CE);
            submission.setError("Compile Time Exceeded");
            logger.warn("Compile Time Exceeded:\t" + e.getMessage());
        } else {
            submission.setStatus(Submission.STATUS_CE);
            submission.setError("Compile error");
            logger.warn("Compile error:\t" + e.getMessage());
        }
        logger.warn(stderr.toString());
        throw new RuntimeException("Compile Aborted.");
    }
}
 

import org.apache.commons.exec.ExecuteWatchdog; //導入方法依賴的package包/類
/**
 * Executes the given command synchronously.
 *
 * @param command The command to execute.
 * @param processInput Input provided to the process.
 * @return The result of the execution, or empty if the process does not terminate within the timeout set for this executor.
 * @throws IOException if the process execution failed.
 */
public Optional<ProcessResult> execute(String command, String processInput) throws IOException {
    ByteArrayOutputStream processErr = new ByteArrayOutputStream();
    ByteArrayOutputStream processOut = new ByteArrayOutputStream();

    DefaultExecutor executor = new DefaultExecutor();
    executor.setStreamHandler(createStreamHandler(processOut, processErr, processInput));
    ExecuteWatchdog watchDog = new ExecuteWatchdog(TimeUnit.SECONDS.toMillis(timeoutSeconds));
    executor.setWatchdog(watchDog);
    executor.setExitValues(successExitCodes);

    int exitCode;
    try {
        exitCode = executor.execute(CommandLine.parse(command));
    } catch (ExecuteException e) {
        exitCode = e.getExitValue();
    }
    return (watchDog.killedProcess()) ?
            Optional.empty() : Optional.of(new ProcessResult(exitCode, processOut.toString(), processErr.toString()));
}
 

import org.apache.commons.exec.ExecuteWatchdog; //導入方法依賴的package包/類
@Override
public void onTranscodeProcessFailed(ExecuteException e, ExecuteWatchdog watchdog, long timestamp) {
	// TODO Auto-generated method stub
	String cause = null;
	
	if(watchdog != null && watchdog.killedProcess()) cause = FAILURE_BY_TIMEOUT;
	else cause = GENERIC_FAILURE;
	
	if(timestamp - this.resultHandler.getAbortRequestTimestamp()>ABORT_TIMEOUT)
	{
		logger.warn("onTranscodeProcessFailed cause: " + cause);
		notifyObservers(SessionEvent.FAILED, new TranscoderExecutionError(e, cause, timestamp));
	}
	else
	{
		logger.warn("Probable force abort");
		doCleanUp();
	}
}
 

import org.apache.commons.exec.ExecuteWatchdog; //導入方法依賴的package包/類
public static void main(String[] args) throws Exception {
    DockerClient dc = new DockerClient();
    String v = dc.getVersion();
    LOG.info(v);

    ExecuteWatchdog dog = dc.tailServiceLogs("msc_siteservice");
    dc.delay(3000);
    dog.killedProcess();
    System.exit(0);
}
 

import org.apache.commons.exec.ExecuteWatchdog; //導入方法依賴的package包/類
public void run(String cwd, Problem problem, List<TestCase> testCases, Submission submission) throws RuntimeException {
    CommandLine cmd = new CommandLine(java);
    cmd.addArgument("-Djava.security.manager");
    cmd.addArgument("-Djava.security.policy==" + policyFile);
    cmd.addArgument("-Xmx" + problem.getMemoryLimit() + "m");
    cmd.addArgument("-classpath");
    cmd.addArgument(cwd);
    cmd.addArgument(fileName);
    logger.info("Sandbox cmd:\t" + cmd.toString());

    long cost = 0;
    for (TestCase testCase : testCases) {
        ByteArrayInputStream stdin = new ByteArrayInputStream(testCase.getInput().getBytes());
        ByteArrayOutputStream stdout = new ByteArrayOutputStream(), stderr = new ByteArrayOutputStream();
        ExecuteWatchdog watchdog = new ExecuteWatchdog(problem.getRuntimeLimit());

        DefaultExecutor executor = new DefaultExecutor();
        executor.setWorkingDirectory(new File(cwd));
        executor.setStreamHandler(new PumpStreamHandler(stdout, stderr, stdin));
        executor.setWatchdog(watchdog);

        long startTime = System.nanoTime();
        try {
            executor.execute(cmd);
        } catch (IOException e) {
            if (watchdog.killedProcess()) {
                submission.setStatus(Submission.STATUS_TLE);
                submission.setError("Time Limit Exceeded");
            } else {
                submission.setStatus(Submission.STATUS_RE);
                submission.setError(stderr.toString());
            }
            logger.warn("Runtime error:\t" + e.toString());
            throw new RuntimeException("Execution Aborted.");
        }
        cost += System.nanoTime() - startTime;

        String o = stdout.toString().trim();
        if (!o.equals(testCase.getOutput())) {
            submission.setStatus(Submission.STATUS_WA);
            submission.setInput(testCase.getInput());
            submission.setOutput(o.length() > outputMaxLength ? o.substring(0, outputMaxLength) + "..." : o);
            submission.setExpected(testCase.getOutput());
            logger.warn("Input: " + testCase.getInput());
            logger.warn("Output: " + o.substring(0, Math.min(outputMaxLength, o.length())));
            logger.warn("Expected: " + testCase.getOutput());
            throw new RuntimeException("Wrong Answer.");
        }
    }

    submission.setRuntime(cost / 1000000);
    submission.setMemory(ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed() / (1024 * 1024));
    submission.setStatus(Submission.STATUS_AC);
}
 

import org.apache.commons.exec.ExecuteWatchdog; //導入方法依賴的package包/類
public int launchNewProcess(File baseDir, String cmdString,
		int timeout) throws IOException, ProcessTimeoutException {

	DefaultExecutor executor = new DefaultExecutor();
	ExecuteWatchdog timeoutWatchdog = new ExecuteWatchdog(timeout);
	executor.setWatchdog(timeoutWatchdog);

	PumpStreamHandler streamHandler =new PumpStreamHandler(this.outAndErr, this.outAndErr, this.input);
	executor.setStreamHandler(streamHandler);
	if (baseDir!=null) {
		executor.setWorkingDirectory(baseDir);
	}

	int exitValue;
	try {
		logger.debug("About to execute command " + cmdString);
		exitValue = executor.execute(CommandLine.parse(cmdString));
		if (executor.isFailure(exitValue)
				&& timeoutWatchdog.killedProcess()) {
			// it was killed on purpose by the watchdog
			logger.debug("A timeout occured while executing a process");
			logger.debug("The command is " + cmdString);
			throw new ProcessTimeoutException(
					"A timeout occurred while executing command "
							+ cmdString);
		}

		return exitValue;
	} catch (ExecuteException e) {
		if (timeoutWatchdog.killedProcess()) {
			logger.debug("A timeout occured while executing a process");
			logger.debug("The command is " + cmdString);
			throw new ProcessTimeoutException(
					"A timeout occurred while executing command "
							+ cmdString);
		} else {
			throw e;
		}

	}

}
 

import org.apache.commons.exec.ExecuteWatchdog; //導入方法依賴的package包/類
public static int runPerformanceBenchmark(final BenchmarkConfig bc, final ExecutionConfig ec)
		throws IOException, InterruptedException {
	final Joiner joiner = Joiner.on(", ");
	System.out.println("Running benchmark.");
	System.out.println("Workload: " + bc.getConfigBase().getWorkload());
	System.out.println("Tool: " + bc.getToolName());
	System.out.println("Model: " + bc.getConfigBase().getModelPath());
	System.out.println("Description: " + bc.getDescription());
	System.out.println("Operations: [" + joiner.join(bc.getConfigBase().getOperations()) + "]");
	System.out.println("Execution configuration: " + ec);
	System.out.println("Runs: " + bc.getConfigBase().getRuns());

	final File configFile = File.createTempFile("trainbenchmark-benchmark-", ".conf");
	final String configPath = configFile.getAbsolutePath();
	bc.saveToFile(configPath);

	final String projectName = String.format("trainbenchmark-tool-%s", bc.getProjectName());
	final String jarPath = String.format("../%s/build/libs/%s-1.0.0-SNAPSHOT-fat.jar %s", projectName, projectName,
			configPath);

	final String javaCommand = String.format("java -Xms%s -Xmx%s -server -jar %s %s", ec.getXms(), ec.getXmx(),
			jarPath, configPath);
	final CommandLine cmdLine = CommandLine.parse(javaCommand);

	final long timeoutInSeconds = bc.getConfigBase().getTimeout();
	final long timeoutInMilliseconds = timeoutInSeconds * 1000;
	final ExecuteWatchdog watchdog = new ExecuteWatchdog(timeoutInMilliseconds);
	final Executor executor = new DefaultExecutor();
	executor.setWatchdog(watchdog);
	executor.setStreamHandler(new PumpStreamHandler());
	try {
		final int exitValue = executor.execute(cmdLine);
		System.out.println();
		return exitValue;
	} catch (final ExecuteException e) {
		if (watchdog.killedProcess()) {
			System.out.println("Process timed out.");
		} else {
			e.printStackTrace(System.out);
		}
		return e.getExitValue();
	}
}