protected void runScript(String[] cmd, JTextArea txaMsg) {
String strg = "";
if (cmd == null) return;
Process prcs = null;
try {
Messages.postDebug("Running script: " + cmd[2]);
Runtime rt = Runtime.getRuntime();
prcs = rt.exec(cmd);
if (prcs == null) return;
InputStream istrm = prcs.getInputStream();
if (istrm == null) return;
BufferedReader bfr = new BufferedReader(new InputStreamReader(istrm));
while ((strg = bfr.readLine()) != null) {
// System.out.println(strg);
strg = strg.trim();
// Messages.postDebug(strg);
strg = strg.toLowerCase();
if (txaMsg != null) {
txaMsg.append(strg);
txaMsg.append("\n");
}
}
} catch (Exception e) {
// e.printStackTrace();
Messages.writeStackTrace(e);
Messages.postDebug(e.toString());
} finally {
// It is my understanding that these streams are left
// open sometimes depending on the garbage collector.
// So, close them.
try {
if (prcs != null) {
OutputStream os = prcs.getOutputStream();
if (os != null) os.close();
InputStream is = prcs.getInputStream();
if (is != null) is.close();
is = prcs.getErrorStream();
if (is != null) is.close();
}
} catch (Exception ex) {
Messages.writeStackTrace(ex);
}
}
}
public static boolean testCommand(
final Context context,
final String command,
final String contains,
final List<String> arguments) {
try {
final List<String> commandAndArgs = new ArrayList<String>();
commandAndArgs.add(command);
commandAndArgs.addAll(arguments);
final ProcessBuilder pb = new ProcessBuilder(commandAndArgs);
logCommand(context, pb);
final Process compilation = pb.start();
final ConsumeStream result = ConsumeStream.start(compilation.getInputStream(), null);
final ConsumeStream error = ConsumeStream.start(compilation.getErrorStream(), null);
compilation.waitFor();
result.join();
error.join();
return error.output.toString().contains(contains)
|| result.output.toString().contains(contains);
} catch (IOException ex) {
context.log(ex.getMessage());
return false;
} catch (InterruptedException ex) {
context.log(ex.getMessage());
return false;
}
}
/**
* Gives the same basic functionality of File.exists but can be used to look for removable media
* without showing a system dialog if the media is not present. Workaround pulled from the <A
* HREF="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4089199"> bug report</A> on
* bugs.sun.com. This bug was fixed in Java 6, and we can remove the workaround when we start
* requiring Java 6.
*/
protected static boolean fileExists(File file) {
try {
Process process =
Runtime.getRuntime().exec(new String[] {"cmd.exe", "/c", "dir", file.getAbsolutePath()});
// We need to consume all available output or the process will block.
boolean haveExitCode = false;
int exitCode = -1;
InputStream out = process.getInputStream();
InputStream err = process.getErrorStream();
while (!haveExitCode) {
while (out.read() >= 0) {}
while (err.read() >= 0) {}
try {
exitCode = process.exitValue();
haveExitCode = true;
} catch (IllegalThreadStateException e) {
// Not yet complete.
Thread.sleep(100);
}
}
// int exitCode = process.waitFor();
return exitCode == 0;
} catch (IOException e) {
System.out.println("Unable to check for file: " + file + " : " + e);
return false;
} catch (InterruptedException e) {
System.out.println("Unable to check for file. Interrupted: " + file + " : " + e);
return false;
}
}
public static void command(String command) {
boolean err = false;
try {
Process process = new ProcessBuilder(command.split(" ")).start();
BufferedReader results = new BufferedReader(new InputStreamReader(process.getInputStream()));
String s;
while ((s = results.readLine()) != null) {
System.out.println(s);
}
BufferedReader errors = new BufferedReader(new InputStreamReader(process.getErrorStream()));
while ((s = errors.readLine()) != null) {
System.err.println(s);
err = true;
}
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
if (err) {
throw new OSExecuteException("Errors executing " + command);
}
}
/**
* Executes the command through a system 'exec'. This method will be used only if the supporting
* Java Native Interface library could not be loaded.
*/
private synchronized void pure_exec(String[] cmd) throws IOException {
if (null != this.environ.getExecutable()) {
cmd[0] = this.environ.getExecutable();
}
p = rt.exec(cmd, this.environ.getEnvp());
InputStream is = p.getInputStream();
Debug.verbose("P4Process.exec().is: " + is);
InputStreamReader isr = new InputStreamReader(is);
Debug.verbose("P4Process.exec().isr: " + isr);
in = new BufferedReader(isr);
InputStream es = p.getErrorStream();
Debug.verbose("P4Process.exec().es: " + es);
InputStreamReader esr = new InputStreamReader(es);
Debug.verbose("P4Process.exec().esr: " + esr);
err = new BufferedReader(esr);
OutputStream os = p.getOutputStream();
Debug.verbose("P4Process.exec().os: " + os);
OutputStreamWriter osw = new OutputStreamWriter(os);
Debug.verbose("P4Process.exec().osw: " + osw);
out =
new FilterWriter(new BufferedWriter(osw)) {
public void write(String str) throws IOException {
super.write(str);
System.out.print("P4DebugOutput: " + str);
}
};
}
/**
* Creates a transcoded input stream by executing the given command. If <code>in</code> is not
* null, data from it is copied to the command.
*
* @param command The command to execute.
* @param in Data to feed to the command. May be <code>null</code>.
* @throws IOException If an I/O error occurs.
*/
public TranscodeInputStream(String[] command, final InputStream in) throws IOException {
StringBuffer buf = new StringBuffer("Starting transcoder: ");
for (String s : command) {
buf.append('[').append(s).append("] ");
}
LOG.debug(buf);
process = Runtime.getRuntime().exec(command);
processOutputStream = process.getOutputStream();
processInputStream = process.getInputStream();
// Must read stderr from the process, otherwise it may block.
final String name = command[0];
new InputStreamReaderThread(process.getErrorStream(), name, true).start();
// Copy data in a separate thread
if (in != null) {
new Thread(name + " TranscodedInputStream copy thread") {
public void run() {
try {
IOUtils.copy(in, processOutputStream);
} catch (IOException x) {
// Intentionally ignored. Will happen if the remote player closes the stream.
} finally {
IOUtils.closeQuietly(in);
IOUtils.closeQuietly(processOutputStream);
}
}
}.start();
}
}
public static String execute(String command) {
StringBuilder sb = new StringBuilder();
String[] commands =
new String[] {"/bin/bash", "-c", "export PATH=\"$PATH:/opt/local/bin\"; " + command};
try {
Process proc = new ProcessBuilder(commands).start();
BufferedReader stdInput = new BufferedReader(new InputStreamReader(proc.getInputStream()));
BufferedReader stdError = new BufferedReader(new InputStreamReader(proc.getErrorStream()));
String s = null;
while ((s = stdInput.readLine()) != null) {
sb.append(s);
sb.append("\n");
}
while ((s = stdError.readLine()) != null) {
sb.append(s);
sb.append("\n");
}
} catch (IOException e) {
e.printStackTrace();
}
return sb.toString();
}
public static void processPSOutput(Process psProcess, Processor<String> processor)
throws IOException {
@SuppressWarnings({"IOResourceOpenedButNotSafelyClosed"})
BufferedReader stdOutput =
new BufferedReader(new InputStreamReader(psProcess.getInputStream()));
BufferedReader stdError = new BufferedReader(new InputStreamReader(psProcess.getErrorStream()));
try {
String s;
stdOutput.readLine(); // ps output header
while ((s = stdOutput.readLine()) != null) {
processor.process(s);
}
StringBuilder errorStr = new StringBuilder();
while ((s = stdError.readLine()) != null) {
errorStr.append(s).append("\n");
}
if (errorStr.length() > 0) {
throw new IllegalStateException("error:" + errorStr.toString());
}
} finally {
stdOutput.close();
stdError.close();
}
}
/** Redirect a VMs output and error streams to System.out and System.err */
protected void redirectStreams(VirtualMachine vm) {
MessageSiphon ms = new MessageSiphon(process.getErrorStream(), this);
errThread = ms.getThread();
outThread = new StreamRedirectThread("VM output reader", process.getInputStream(), System.out);
errThread.start();
outThread.start();
}
/**
* Takes as input a GnuPlot script file path and executes this script. inside the script the user
* can plot to screen, pause and then print to a post script file.
*
* @param args args[0] should be the path to the GnuPlot script file relative to the Simulator
* directory e.g. ./inputFiles/100C_20P_centralised/Gnuplot.gnu
* <p>Example Script file GnuPlot.gnu:
* <p>set xlabel "Lateral Displacement"; set ylabel "Contra-Lateral Displacement"; set zlabel
* "Amplitude" set parametric set isosamples 75,75 set contour base set cntrparam level
* incremental -1, 0.2, 10 set clabel '%4.2f' set contour surface set contour base; set
* nosurface set surface; set view 20,60 set view 60,30 set hidden3d splot u,v,sin(u)*cos(v)
* title "Standing Waves" set size 1.0, 0.6 set terminal postscript portrait enhanced color
* dashed lw 1 "Helvetica" 14 set output 'tempoutput/my-plot.ps' replot set terminal x11 set
* size 1,1 #pause 5
*/
public static void gnuplot(String[] args) {
logger.info("gnuplot called on scriptfile: " + args[0]);
// get a Runtime object
Runtime r = Runtime.getRuntime();
try {
// start the process: gnuplot
String exe = "wgnuplot " + args[0];
// String exe = "C:/Program Files/gnuplot/bin/wgnuplot " + args[0];
logger.info(exe);
Process p = r.exec(exe);
// any error message?
StreamGobbler errorGobbler = new StreamGobbler(p.getErrorStream(), "ERR");
// any output?
StreamGobbler outputGobbler = new StreamGobbler(p.getInputStream(), "OUT");
// kick them off
errorGobbler.start();
outputGobbler.start();
// any error???
int exitVal = p.waitFor();
logger.error("ExitValue: " + exitVal);
} catch (Exception e) {
logger.fatal("Error Executing gnuplot: " + args[0] + " - ", e);
}
}
String[] getMedkit(
String[] availableResources,
String[] requiredResources,
String[] missions,
double P,
double C) {
try {
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec(exec);
OutputStream os = proc.getOutputStream();
InputStream is = proc.getInputStream();
new ErrorReader(proc.getErrorStream()).start();
StringBuffer sb = new StringBuffer();
append(sb, availableResources);
append(sb, requiredResources);
append(sb, missions);
sb.append(P).append('\n');
sb.append(C).append('\n');
os.write(sb.toString().getBytes());
BufferedReader br = new BufferedReader(new InputStreamReader(is));
int N = Integer.parseInt(br.readLine().trim());
String[] ret = new String[N];
for (int i = 0; i < N; i++) ret[i] = br.readLine().trim();
return ret;
} catch (Exception e) {
System.err.println("An error occurred while executing your program");
e.printStackTrace();
return null;
}
}
protected synchronized void execute(GeneralCommandLine commandLine)
throws AuthenticationException {
try {
commandLine.getEnvironment().clear();
commandLine.getEnvironment().putAll(EnvironmentUtil.getEnvironmentProperties());
myProcess = commandLine.createProcess();
myErrThread =
new ReadProcessThread(
new BufferedReader(
new InputStreamReader(
myProcess.getErrorStream(),
EncodingManager.getInstance().getDefaultCharset()))) {
protected void textAvailable(String s) {
myErrorText.append(s);
myErrorRegistry.registerError(s);
myContainsError = true;
}
};
final Application application = ApplicationManager.getApplication();
myStdErrFuture = application.executeOnPooledThread(myErrThread);
myInputStream = myProcess.getInputStream();
myOutputStream = myProcess.getOutputStream();
waitForProcess(application);
} catch (Exception e) {
closeInternal();
throw new AuthenticationException(e.getLocalizedMessage(), e);
}
}
private static void exec(String command) {
try {
System.out.println("Invoking: " + command);
Process p = Runtime.getRuntime().exec(command);
// get standard output
BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream()));
String line;
while ((line = input.readLine()) != null) {
System.out.println(line);
}
input.close();
// get error output
input = new BufferedReader(new InputStreamReader(p.getErrorStream()));
while ((line = input.readLine()) != null) {
System.out.println(line);
}
input.close();
p.waitFor();
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public String[] runJob(String command) {
outputCatcher = null;
try {
String[] cmd = null;
Process proc = null;
Runtime rt = Runtime.getRuntime();
String os = getOsName();
System.out.println("OS = " + os);
if (os.startsWith("Windows")) {
cmd = new String[3];
cmd[0] = "cmd.exe";
cmd[1] = "/C";
cmd[2] = command;
proc = rt.exec(cmd);
} else if (os.startsWith("Linux")) {
cmd = new String[1];
cmd[0] = command;
proc = rt.exec(command.split(" "));
}
System.out.println("command is:");
for (int i = 0; i < cmd.length; i++) {
System.out.print(cmd[i] + " ");
}
System.out.println();
// any error message?
errorCatcher = new StreamCatcher(proc.getErrorStream(), "ERROR");
// any output?
outputCatcher = new StreamCatcher(proc.getInputStream(), "OUTPUT");
// kick them off
errorCatcher.start();
outputCatcher.start();
// any error???
exitVal = proc.waitFor();
System.out.println("ExitValue: " + exitVal);
if (exitVal != 0) System.out.println(errorCatcher.builder.toString());
} catch (Throwable t) {
t.printStackTrace();
}
// now return both the stdout and stderr streams
// just use a String array for this -- not pretty but it works
// stdout is at position [0], stderr is at [1]
String[] outputs = new String[2];
outputs[0] = outputCatcher.builder.toString();
outputs[1] = errorCatcher.builder.toString();
return outputs;
}
public static void logFile(String file, boolean isWrite) {
ArrayList<String> cmds = new ArrayList<String>();
cmds.add(Dependencies.getPythonLocation());
cmds.add(Dependencies.getCLILocation());
cmds.add("--file");
cmds.add(file);
String project = WakaTime.getProjectName();
if (project != null) {
cmds.add("--project");
cmds.add(project);
}
cmds.add("--plugin");
cmds.add(IDE_NAME + "/" + IDE_VERSION + " " + IDE_NAME + "-wakatime/" + VERSION);
if (isWrite) cmds.add("--write");
try {
log.debug("Executing CLI: " + Arrays.toString(cmds.toArray()));
Process proc = Runtime.getRuntime().exec(cmds.toArray(new String[cmds.size()]));
if (WakaTime.DEBUG) {
BufferedReader stdInput = new BufferedReader(new InputStreamReader(proc.getInputStream()));
BufferedReader stdError = new BufferedReader(new InputStreamReader(proc.getErrorStream()));
proc.waitFor();
String s;
while ((s = stdInput.readLine()) != null) {
log.debug(s);
}
while ((s = stdError.readLine()) != null) {
log.debug(s);
}
log.debug("Command finished with return value: " + proc.exitValue());
}
} catch (Exception e) {
log.error(e);
}
}
public String execRecognizer() {
try {
String inputFile = new File(tmpdir, "input").getAbsolutePath();
String[] args =
new String[] {"java", "-classpath", tmpdir + pathSep + CLASSPATH, "Test", inputFile};
// String cmdLine = "java -classpath "+CLASSPATH+pathSep+tmpdir+" Test " + new File(tmpdir,
// "input").getAbsolutePath();
// System.out.println("execParser: "+cmdLine);
Process process = Runtime.getRuntime().exec(args, null, new File(tmpdir));
StreamVacuum stdoutVacuum = new StreamVacuum(process.getInputStream());
StreamVacuum stderrVacuum = new StreamVacuum(process.getErrorStream());
stdoutVacuum.start();
stderrVacuum.start();
process.waitFor();
stdoutVacuum.join();
stderrVacuum.join();
String output = null;
output = stdoutVacuum.toString();
if (stderrVacuum.toString().length() > 0) {
this.stderrDuringParse = stderrVacuum.toString();
System.err.println("exec stderrVacuum: " + stderrVacuum);
}
return output;
} catch (Exception e) {
System.err.println("can't exec recognizer");
e.printStackTrace(System.err);
}
return null;
}
public static Either<CommandResult> runCommand(
final Context context, final String command, final File path, final List<String> arguments) {
try {
final List<String> commandAndArgs = new ArrayList<String>();
commandAndArgs.add(command);
commandAndArgs.addAll(arguments);
final ProcessBuilder pb = new ProcessBuilder(commandAndArgs);
if (path != null) {
pb.directory(path);
}
logCommand(context, pb);
final Process compilation = pb.start();
final ConsumeStream result = ConsumeStream.start(compilation.getInputStream(), context);
final ConsumeStream error = ConsumeStream.start(compilation.getErrorStream(), context);
final int exitCode = compilation.waitFor();
result.join();
error.join();
if (result.exception != null) {
return Either.fail(result.exception);
}
if (error.exception != null) {
return Either.fail(error.exception);
}
return Either.success(
new CommandResult(result.output.toString(), error.output.toString(), exitCode));
} catch (IOException ex) {
return Either.fail(ex);
} catch (InterruptedException ex) {
return Either.fail(ex);
}
}
// Method: runTest
// Runs the script specified in the test case object
public void runTest() {
try {
Process p = Runtime.getRuntime().exec(this.execCommandLine);
InputStreamReader esr = new InputStreamReader(p.getErrorStream());
BufferedReader ereader = new BufferedReader(esr);
InputStreamReader isr = new InputStreamReader(p.getInputStream());
BufferedReader ireader = new BufferedReader(isr);
String line = null;
String line1 = null;
while ((line = ireader.readLine()) != null) {
// System.out.println("Output: " + line);
System.out.println(line);
}
while ((line1 = ereader.readLine()) != null) {
System.err.println("Error: " + line1);
}
int exitValue = p.waitFor();
tcInstanceTools.LogMessage('d', "Test Case exit value: " + exitValue);
if (exitValue == 0) {
setTestCaseResult(Result.Pass);
} else {
setTestCaseResult(Result.Fail);
}
} catch (IOException ioe) {
System.out.println("Error: " + ioe.getMessage());
} catch (InterruptedException e) {
System.out.println("Error: " + e.getMessage());
}
}
// Creates a new thread, runs the program in that thread, and reports any errors as needed.
private void run(String clazz) {
try {
// Makes sure the JVM resets if it's already running.
if (JVMrunning) kill();
// Some String constants for java path and OS-specific separators.
String separator = System.getProperty("file.separator");
String path = System.getProperty("java.home") + separator + "bin" + separator + "java";
// Tries to run compiled code.
ProcessBuilder builder = new ProcessBuilder(path, clazz);
// Should be good now! Everything past this is on you. Don't mess it up.
println(
"Build succeeded on " + java.util.Calendar.getInstance().getTime().toString(), progErr);
println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", progErr);
JVM = builder.start();
// Note that as of right now, there is no support for input. Only output.
Reader errorReader = new InputStreamReader(JVM.getErrorStream());
Reader outReader = new InputStreamReader(JVM.getInputStream());
// Writer inReader = new OutputStreamWriter(JVM.getOutputStream());
redirectErr = redirectIOStream(errorReader, err);
redirectOut = redirectIOStream(outReader, out);
// redirectIn = redirectIOStream(null, inReader);
} catch (Exception e) {
// This catches any other errors we might get.
println("Some error thrown", progErr);
logError(e.toString());
displayLog();
return;
}
}
public static TByteArrayList transformByExternalCommand(
final String command, final InputStream input) throws IOException {
final Process process = Runtime.getRuntime().exec(command);
final InputStream in = process.getInputStream();
final OutputStream out = process.getOutputStream();
final TByteArrayList bytes = new TByteArrayList(100500);
final byte[] buffer = new byte[1024 * 1024];
try {
int read;
while ((read = input.read(buffer)) > 0) {
out.write(buffer, 0, read);
if (in.available() > 0) {
read = in.read(buffer);
bytes.add(buffer, 0, read);
}
}
out.close();
while ((read = in.read(buffer)) > 0) {
bytes.add(buffer, 0, read);
}
in.close();
} catch (IOException ioe) {
System.err.println(readByteStream(process.getErrorStream()));
LOG.error(ioe);
throw ioe;
}
return bytes;
}
@Test
public void testUnpack() {
String type = "unpack";
String path = "P:\\Ruby22-x64\\bin";
String dir = "P:\\temp-workspace\\RPGTestProject1";
try {
Process process =
Runtime.getRuntime()
.exec(path + "\\rvpacker.bat --verbose -f -d " + dir + " -t ace -a " + type);
new Thread(
() -> {
String line = null;
int i = 0;
try {
BufferedReader bR =
new BufferedReader(new InputStreamReader(process.getInputStream()));
while ((line = bR.readLine()) != null) {
if (line.isEmpty()) {
System.out.print("{E}");
}
System.out.println(++i + ": " + line);
}
System.out.println("NULL got | Closing");
} catch (Exception e) {
e.printStackTrace();
fail("Exception");
}
})
.start();
new Thread(
() -> {
String line = null;
try {
BufferedReader bR =
new BufferedReader(new InputStreamReader(process.getErrorStream()));
while ((line = bR.readLine()) != null) {
System.out.println("Err " + line);
}
System.out.println("NULL got");
} catch (Exception e) {
e.printStackTrace();
fail("Exception");
}
})
.start();
;
process.waitFor();
assertEquals(0, process.exitValue());
} catch (IOException e) {
e.printStackTrace();
fail("Exception");
} catch (InterruptedException e) {
e.printStackTrace();
fail("Exception");
}
}
private void dumpFailedLaunchInfo(Process process) {
try {
dumpStream(process.getErrorStream());
dumpStream(process.getInputStream());
} catch (IOException e) {
MessageOutput.println("Unable to display process output:", e.getMessage());
}
}
protected boolean compile(String fileName) {
String compiler = "javac";
String classpathOption = "-classpath";
if (jikes != null) {
compiler = jikes;
classpathOption = "-bootclasspath";
}
String[] args =
new String[] {
compiler,
"-d",
tmpdir,
classpathOption,
tmpdir + pathSep + CLASSPATH,
tmpdir + "/" + fileName
};
String cmdLine =
compiler
+ " -d "
+ tmpdir
+ " "
+ classpathOption
+ " "
+ tmpdir
+ pathSep
+ CLASSPATH
+ " "
+ fileName;
// System.out.println("compile: "+cmdLine);
File outputDir = new File(tmpdir);
try {
Process process = Runtime.getRuntime().exec(args, null, outputDir);
StreamVacuum stdout = new StreamVacuum(process.getInputStream());
StreamVacuum stderr = new StreamVacuum(process.getErrorStream());
stdout.start();
stderr.start();
process.waitFor();
stdout.join();
stderr.join();
if (stdout.toString().length() > 0) {
System.err.println("compile stdout from: " + cmdLine);
System.err.println(stdout);
}
if (stderr.toString().length() > 0) {
System.err.println("compile stderr from: " + cmdLine);
System.err.println(stderr);
}
int ret = process.exitValue();
return ret == 0;
} catch (Exception e) {
System.err.println("can't exec compilation");
e.printStackTrace(System.err);
return false;
}
}
/**
* processes the input String and produces an output String.
*
* @param input the String to input to the underlying process
* @throws java.lang.Exception exceptions from Runtime and Process that this class uses
* @return the output from the underlying process
*/
public String process(String input) throws Exception {
String returnValue = new String();
StringBuffer buffer = new StringBuffer();
if (socketServer == true) {
returnValue = client.process(input);
ServerThread current = getServer();
if (current != null) {
if (!current.isDaemon()) {
current.getProcess().destroy();
}
current.interrupt();
}
} else { // not a socket server
Runtime rt = Runtime.getRuntime();
String output = "";
String errors = "";
try {
p = rt.exec(getCodeCall() + " " + getParams());
PrintStream processInputStream = new PrintStream(p.getOutputStream(), true, "utf-8");
processInputStream.println(input + "\n\u0003"); // put in garbage to kill Bikel's loop
StreamConsumer errorConsumer = new StreamConsumer(p.getErrorStream(), "error", 1);
StreamConsumer outputConsumer = new StreamConsumer(p.getInputStream(), "output", 10);
outputConsumer.start();
errorConsumer.start();
int countloops = 0;
int time = 0;
String message = "";
while (!outputConsumer.isComplete()) {
// wait
Thread.sleep(100);
countloops++;
time += 100; // one tenth of a second
if (time > waittime) { // just wait 5 minutes
message = "exceeded waittime of " + waittime + " milliseconds";
break;
}
}
errors = errorConsumer.getOutput();
output = outputConsumer.getOutput();
if (!message.equals("")) {
errors = message;
}
} catch (IOException ioe) {
System.err.println("Module error: " + getModuleName());
ioe.printStackTrace();
System.exit(0);
}
p.destroy();
if (errors.equals("")) {
returnValue = output;
} else {
returnValue = errors;
}
}
return returnValue;
}
public void run() {
InputStream is = process.getErrorStream();
int i = -1;
try {
while ((i = is.read()) != -1) {
// if (showDisplay)System.out.print((char)i);
}
} catch (IOException ioe) {
}
}
private static String copyStderr(Process p) throws IOException {
InputStream err = p.getErrorStream();
StringBuilder result = new StringBuilder();
byte[] buff = new byte[4096];
int len = err.read(buff);
while (len > 0) {
result.append(new String(buff, 0, len));
len = err.read(buff);
}
return result.toString();
}
private static boolean isAaptPresent() throws Exception {
boolean result = true;
try {
Process proc = Runtime.getRuntime().exec("aapt");
BufferedReader br = new BufferedReader(new InputStreamReader(proc.getErrorStream()));
String line = null;
while ((line = br.readLine()) != null) {}
} catch (Exception ex) {
result = false;
}
return result;
}
public void run() {
Throwable tr = null;
try {
List<Object> cmdArray = ((List<Object>) (new ArrayList<Object>(20)));
cmdArray.add(((Object) (SettingsAdapter.getInstance().getMPlayerCommand())));
if (MPlayer.isChangingProcessPrioritySupported()) {
cmdArray.add("-priority");
cmdArray.add(((Object) (SettingsAdapter.getInstance().getMPlayerProcessPriority().name())));
}
cmdArray.add("-ss");
cmdArray.add(((Object) (Long.toString(mOffset))));
cmdArray.add(((Object) (player.mFile.getPath())));
if (logger.isDebugEnabled()) {
StringBuilder sb = new StringBuilder();
String s;
for (Iterator<Object> iterator = cmdArray.iterator();
iterator.hasNext();
sb.append(s).append(' ')) s = (String) iterator.next();
logger.debug(
((Object)
((new StringBuilder("Executing ["))
.append(((Object) (sb)))
.append("]")
.toString())));
}
mProc =
Runtime.getRuntime()
.exec((String[]) cmdArray.toArray(((Object[]) (new String[cmdArray.size()]))));
logger.debug(
((Object) ((new StringBuilder(" as process ")).append(((Object) (mProc))).toString())));
threadStartupDone = true;
StreamGobbler errorGobbler = new StreamGobbler("stderr", mProc.getErrorStream());
errorGobbler.start();
StreamGobbler outputGobbler = new StreamGobbler("stdout", mProc.getInputStream());
outputGobbler.start();
int exitCode = mProc.waitFor();
logger.debug(
((Object)
((new StringBuilder())
.append(((Object) (mProc)))
.append(" finished with exit code ")
.append(exitCode)
.toString())));
} catch (Exception e) {
logger.error("", ((Throwable) (e)));
tr = ((Throwable) (e));
} finally {
threadStartupDone = true;
terminated = true;
}
if (tr != null) player.fireExceptionEvent(tr);
}
public static void textToMp3(String text, OutputStream os) {
File txt = null;
File wav = null;
File mp3 = null;
try {
txt = File.createTempFile("txt", ".txt");
FileWriter fw = new FileWriter(txt);
fw.write(text);
fw.close();
wav = File.createTempFile("wav", ".wav");
if (!wav.delete()) {
throw new RuntimeException("couldn't delete wav");
}
mp3 = File.createTempFile("mp3", ".mp3");
if (!mp3.delete()) {
throw new RuntimeException("couldn't delete mp3");
}
String cmd =
String.format(
"/usr/bin/text2wave < %s -o %s", txt.getAbsolutePath(), wav.getAbsolutePath());
Process p = Runtime.getRuntime().exec(new String[] {"/bin/bash", "-c", cmd});
show(p.getErrorStream());
System.out.println(p.waitFor()); // TODO check return code
p =
Runtime.getRuntime()
.exec(new String[] {"/usr/bin/lame", wav.getAbsolutePath(), mp3.getAbsolutePath()});
System.out.println(p.waitFor()); // TODO check return code
FileInputStream fis = new FileInputStream(mp3);
int read = fis.read();
while (read != -1) {
os.write(read);
read = fis.read();
}
} catch (Throwable t) {
throw new RuntimeException(t);
} finally {
// TODO check return codes
if (mp3 != null) {
mp3.delete();
}
if (txt != null) {
txt.delete();
}
if (wav != null) {
wav.delete();
}
}
}
public void runMPIJob(Integer nodes) {
try {
String s;
runningDir.mkdir();
inputFile.createNewFile();
FileWriter writer = new FileWriter(inputFile);
writer.write(deck.toString());
writer.close();
logFile.createNewFile();
writer = new FileWriter(logFile);
String command = "mpirun ";
command += "-np " + nodes.toString() + " ";
command += "mcnpxMpi ";
command += "i= " + inputFile.getPath() + " ";
command += "o= " + outputFile.getPath() + " ";
command += "run= " + runFile.getPath() + " ";
Process p = Runtime.getRuntime().exec(command);
writer.write(command + "\n");
BufferedReader stdInput = new BufferedReader(new InputStreamReader(p.getInputStream()));
BufferedReader stdError = new BufferedReader(new InputStreamReader(p.getErrorStream()));
while ((s = stdInput.readLine()) != null) {
writer.write(s + '\n');
}
while ((s = stdError.readLine()) != null) {
writer.write(s + '\n');
}
writer.close();
String finalFilename = name + "/" + name + "_" + System.currentTimeMillis();
new File(name).mkdir();
inputFile.renameTo(new File(finalFilename + ".input"));
outputFile.renameTo(new File(finalFilename + ".output"));
runFile.renameTo(new File(finalFilename + ".run"));
logFile.renameTo(new File(finalFilename + ".log"));
} catch (IOException e) {
e.printStackTrace();
return;
}
}