+/*
+ * Copyright (C) 2010 Mathieu Baudier <mbaudier@argeo.org>
+ *
+ * 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.
+ */
+
package org.argeo.slc.core.execution.tasks;
import java.io.File;
import java.io.OutputStream;
import java.io.Writer;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.argeo.slc.SlcException;
import org.argeo.slc.UnsupportedException;
import org.argeo.slc.core.execution.ExecutionResources;
-import org.argeo.slc.core.structure.tree.TreeSRelatedHelper;
import org.argeo.slc.core.test.SimpleResultPart;
import org.argeo.slc.test.TestResult;
import org.argeo.slc.test.TestStatus;
import org.springframework.core.io.Resource;
/** Execute an OS specific system call. */
-public class SystemCall extends TreeSRelatedHelper implements Runnable {
+public class SystemCall implements Runnable {
+ public final static String LOG_STDOUT = "System.out";
+
private final Log log = LogFactory.getLog(getClass());
private String execDir;
private Resource stdInFile = null;
private Boolean redirectStdOut = false;
+ private List<SystemCallOutputListener> outputListeners = Collections
+ .synchronizedList(new ArrayList<SystemCallOutputListener>());
+
private Map<String, List<Object>> osCommands = new HashMap<String, List<Object>>();
private Map<String, String> osCmds = new HashMap<String, String>();
private Map<String, String> environmentVariables = new HashMap<String, String>();
// Execute
ExecuteResultHandler executeResultHandler = createExecuteResultHandler(commandLine);
+ //
+ // THE EXECUTION PROPER
+ //
try {
if (synchronous)
try {
environmentVariablesToUse);
executeResultHandler.onProcessComplete(exitValue);
} catch (ExecuteException e1) {
+ if (e1.getExitValue() == Executor.INVALID_EXITVALUE) {
+ Thread.currentThread().interrupt();
+ return;
+ }
executeResultHandler.onProcessFailed(e1);
}
else
}
+ public synchronized String function() {
+ final StringBuffer buf = new StringBuffer("");
+ SystemCallOutputListener tempOutputListener = new SystemCallOutputListener() {
+ public void newLine(SystemCall systemCall, String line,
+ Boolean isError) {
+ if (!isError)
+ buf.append(line);
+ }
+ };
+ addOutputListener(tempOutputListener);
+ run();
+ removeOutputListener(tempOutputListener);
+ return buf.toString();
+ }
+
public String asCommand() {
return createCommandLine().toString();
}
: new LogOutputStream() {
protected void processLine(String line, int level) {
if (line != null && !line.trim().equals(""))
- log(stdOutLogLevel, line);
+ logStdOut(line);
if (stdOutWriter != null)
appendLineToFile(stdOutWriter, line);
}
}, new LogOutputStream() {
protected void processLine(String line, int level) {
if (line != null && !line.trim().equals(""))
- log(stdErrLogLevel, line);
+ logStdErr(line);
if (stdErrWriter != null)
appendLineToFile(stdErrWriter, line);
}
public void onProcessComplete(int exitValue) {
String msg = "System call '" + commandLine
+ "' properly completed.";
- if (log.isDebugEnabled())
- log.debug(msg);
+ if (log.isTraceEnabled())
+ log.trace(msg);
if (testResult != null) {
- forwardPath(testResult, null);
+ forwardPath(testResult);
testResult.addResultPart(new SimpleResultPart(
TestStatus.PASSED, msg));
}
public void onProcessFailed(ExecuteException e) {
String msg = "System call '" + commandLine + "' failed.";
if (testResult != null) {
- forwardPath(testResult, null);
+ forwardPath(testResult);
testResult.addResultPart(new SimpleResultPart(
TestStatus.ERROR, msg, e));
} else {
};
}
+ protected void forwardPath(TestResult testResult) {
+ // TODO: allocate a TreeSPath
+ }
+
/**
* Shortcut method getting the execDir to use
*/
}
}
+ protected void logStdOut(String line) {
+ for (SystemCallOutputListener outputListener : outputListeners)
+ outputListener.newLine(this, line, false);
+ log(stdOutLogLevel, line);
+ }
+
+ protected void logStdErr(String line) {
+ for (SystemCallOutputListener outputListener : outputListeners)
+ outputListener.newLine(this, line, true);
+ log(stdErrLogLevel, line);
+ }
+
/** Log from the underlying streams. */
protected void log(String logLevel, String line) {
if ("ERROR".equals(logLevel))
log.debug(line);
else if ("TRACE".equals(logLevel))
log.trace(line);
- else if ("System.out".equals(logLevel))
+ else if (LOG_STDOUT.equals(logLevel))
System.out.println(line);
else if ("System.err".equals(logLevel))
System.err.println(line);
/** Append the argument (for chaining) */
public SystemCall arg(String arg) {
+ if (command == null)
+ command = new ArrayList<Object>();
command.add(arg);
return this;
}
/** Append the argument (for chaining) */
public SystemCall arg(String arg, String value) {
+ if (command == null)
+ command = new ArrayList<Object>();
command.add(arg);
command.add(value);
return this;
this.redirectStdOut = redirectStdOut;
}
+ public void addOutputListener(SystemCallOutputListener outputListener) {
+ outputListeners.add(outputListener);
+ }
+
+ public void removeOutputListener(SystemCallOutputListener outputListener) {
+ outputListeners.remove(outputListener);
+ }
+
+ public void setOutputListeners(
+ List<SystemCallOutputListener> outputListeners) {
+ this.outputListeners = outputListeners;
+ }
+
private class DummyexecuteStreamHandler implements ExecuteStreamHandler {
public void setProcessErrorStream(InputStream is) throws IOException {
projects / gpl / argeo-slc.git / blobdiff