package org.argeo.slc.core.execution;
import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
import java.text.SimpleDateFormat;
+import org.apache.commons.io.IOUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.SlcException;
import org.argeo.slc.execution.ExecutionContext;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
return resource;
}
+ public String getAsOsPath(Resource resource, Boolean overwrite) {
+ File file = null;
+ try {
+ file = resource.getFile();
+ return file.getCanonicalPath();
+ } catch (IOException e) {
+ if (log.isTraceEnabled())
+ log
+ .trace("Resource "
+ + resource
+ + " is not available on the file system. Retrieving it...");
+ }
+
+ InputStream in = null;
+ OutputStream out = null;
+ try {
+ String path = resource.getURL().getPath();
+ file = getFile(path);
+ if (file.exists() && !overwrite)
+ return file.getCanonicalPath();
+
+ file.getParentFile().mkdirs();
+ in = resource.getInputStream();
+ out = new FileOutputStream(file);
+ IOUtils.copy(in, out);
+ if (log.isDebugEnabled())
+ log.debug("Retrieved " + resource + " to OS file " + file);
+ return file.getCanonicalPath();
+ } catch (IOException e) {
+ throw new SlcException("Could not make resource " + resource
+ + " an OS file.", e);
+ } finally {
+ IOUtils.closeQuietly(in);
+ IOUtils.closeQuietly(out);
+ }
+ }
+
public File getFile(String relativePath) {
Assert.notNull(executionContext, "execution context is null");
--- /dev/null
+package org.argeo.slc.core.execution;
+
+import java.io.File;
+
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.core.io.Resource;
+import org.springframework.util.Assert;
+
+/** Workaround when execution placedholders needs to be passed. */
+public class OsFileFactoryBean implements FactoryBean {
+ private ExecutionResources executionResources;
+ private Resource resource;
+ private Boolean overwrite = false;
+
+ /** Return an existing file on the fiel system. */
+ public Object getObject() throws Exception {
+ Assert.notNull(executionResources, "executionResources is null");
+ Assert.notNull(resource, "relativePath is null");
+ return executionResources.getAsOsPath(resource, overwrite);
+ }
+
+ public Class<? extends Object> getObjectType() {
+ return File.class;
+ }
+
+ public boolean isSingleton() {
+ return true;
+ }
+
+ /** The execution resources object. */
+ public void setExecutionResources(ExecutionResources executionResources) {
+ this.executionResources = executionResources;
+ }
+
+ /** The resource to access. */
+ public void setResource(Resource resource) {
+ this.resource = resource;
+ }
+
+ /**
+ * Whether to overwrite the resource if it already exists. Default is
+ * <code>false</code>.
+ */
+ public void setOverwrite(Boolean overwrite) {
+ this.overwrite = overwrite;
+ }
+
+}
package org.argeo.slc.core.execution.tasks;
-import java.io.BufferedReader;
import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.io.OutputStreamWriter;
-import java.io.Writer;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.exec.LogOutputStream;
import org.apache.commons.exec.PumpStreamHandler;
import org.apache.commons.exec.ShutdownHookProcessDestroyer;
-import org.apache.commons.exec.launcher.CommandLauncher;
-import org.apache.commons.exec.launcher.CommandLauncherFactory;
-import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.NotImplementedException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.argeo.slc.SlcException;
+/** Execute and OS system call. */
public class SystemCall implements Runnable {
- // TODO: specify environment variables
-
private final Log log = LogFactory.getLog(getClass());
private String execDir;
private List<String> command = null;
private Boolean synchronous = true;
- // private Boolean captureStdIn = false;
private String stdErrLogLevel = "ERROR";
private String stdOutLogLevel = "INFO";
dir = new File(execDir).getCanonicalFile();
}
- // Process process = null;
-
// Check if an OS specific command overrides
String osName = System.getProperty("os.name");
List<String> commandToUse = null;
+ getUsedDir(dir));
commandLine = CommandLine.parse(cmdToUse);
- // process = Runtime.getRuntime().exec(cmdToUse, null, dir);
} else if (commandToUse != null) {
if (log.isTraceEnabled())
log.trace("Execute '" + commandToUse + "' in "
commandLine = new CommandLine(commandToUse.get(0));
for (int i = 1; i < commandToUse.size(); i++)
commandLine.addArgument(commandToUse.get(i));
- // ProcessBuilder processBuilder = new
- // ProcessBuilder(commandToUse);
- // processBuilder.directory(dir);
- // process = processBuilder.start();
} else {
// all cases covered previously
throw new NotImplementedException();
ExecuteResultHandler executeResultHandler = new ExecuteResultHandler() {
public void onProcessComplete(int exitValue) {
- log.info("Process " + commandLine + " properly completed.");
+ if (log.isDebugEnabled())
+ log.debug("Process " + commandLine
+ + " properly completed.");
}
public void onProcessFailed(ExecuteException e) {
else
executor.execute(commandLine, environmentVariablesToUse,
executeResultHandler);
-
- // Manage standard streams
- // StreamReaderThread stdOutThread = new StreamReaderThread(process
- // .getInputStream()) {
- // protected void callback(String line) {
- // stdOutCallback(line);
- // }
- // };
- // stdOutThread.start();
- // StreamReaderThread stdErrThread = new StreamReaderThread(process
- // .getErrorStream()) {
- // protected void callback(String line) {
- // stdErrCallback(line);
- // }
- // };
- // stdErrThread.start();
- // if (captureStdIn)
- // new StdInThread(process.getOutputStream()).start();
- //
- // // Wait for the end of the process
- // if (synchronous) {
- // Integer exitCode = process.waitFor();
- // if (exitCode != 0) {
- // Thread.sleep(5000);// leave the process a chance to log
- // log.warn("Process return exit code " + exitCode);
- // }
- // } else {
- // // asynchronous: return
- // }
} catch (Exception e) {
throw new SlcException("Could not execute command " + cmd, e);
}
return dir.getPath();
}
- // protected void stdOutCallback(String line) {
- // log(stdOutLogLevel, line);
- // }
- //
- // protected void stdErrCallback(String line) {
- // log(stdErrLogLevel, line);
- // }
- //
protected void log(String logLevel, String line) {
if ("ERROR".equals(logLevel))
log.error(line);
this.synchronous = synchronous;
}
- // public void setCaptureStdIn(Boolean captureStdIn) {
- // this.captureStdIn = captureStdIn;
- // }
-
public void setCommand(List<String> command) {
this.command = command;
}
this.osCmds = osCmds;
}
- // protected abstract class StreamReaderThread extends Thread {
- // private final InputStream stream;
- //
- // public StreamReaderThread(InputStream stream) {
- // this.stream = stream;
- // }
- //
- // @Override
- // public void run() {
- // BufferedReader in = null;
- // try {
- // in = new BufferedReader(new InputStreamReader(stream));
- // String line = null;
- // while ((line = in.readLine()) != null) {
- // stdOutCallback(line);
- // }
- // } catch (IOException e) {
- // if (log.isTraceEnabled()) {
- // log.trace("Could not read stream", e);
- // // catch silently
- // // because the other methods
- // // to check whether the stream
- // // is closed would probably
- // // be to costly
- // }
- // } finally {
- // if (synchronous)
- // IOUtils.closeQuietly(in);
- // }
- // }
- //
- // protected abstract void callback(String line);
- // }
- //
- // protected class StdInThread extends Thread {
- // private final OutputStream stream;
- //
- // public StdInThread(OutputStream stream) {
- // this.stream = stream;
- // }
- //
- // @Override
- // public void run() {
- // BufferedReader in = null;
- // Writer out = null;
- // try {
- // out = new OutputStreamWriter(stream);
- // in = new BufferedReader(new InputStreamReader(System.in));
- // String line = null;
- // while ((line = in.readLine()) != null) {
- // out.write(line);
- // out.write("\n");
- // out.flush();
- // }
- // } catch (IOException e) {
- // throw new SlcException("Could not write to stdin stream", e);
- // } finally {
- // if (synchronous) {
- // IOUtils.closeQuietly(in);
- // IOUtils.closeQuietly(out);
- // }
- // }
- // }
- //
- // }
+ public void setEnvironmentVariables(Map<String, String> environmentVariables) {
+ this.environmentVariables = environmentVariables;
+ }
+
+ public void setWatchdogTimeout(Long watchdogTimeout) {
+ this.watchdogTimeout = watchdogTimeout;
+ }
+
}
projects / gpl / argeo-slc.git / commitdiff