From acc5c7e65032c369fb08dd82540cea6351358c72 Mon Sep 17 00:00:00 2001 From: Paul Phillips Date: Wed, 5 May 2010 16:56:55 +0000 Subject: Rolled back a subset of partest to use StreamAp... Rolled back a subset of partest to use StreamAppender and avoid io.Process. No review. --- src/partest/scala/tools/partest/Actions.scala | 58 +++++++++---- .../scala/tools/partest/nest/StreamAppender.scala | 94 ++++++++++++++++++++++ 2 files changed, 136 insertions(+), 16 deletions(-) create mode 100644 src/partest/scala/tools/partest/nest/StreamAppender.scala (limited to 'src') diff --git a/src/partest/scala/tools/partest/Actions.scala b/src/partest/scala/tools/partest/Actions.scala index 5cbe64ce23..cb60152b71 100644 --- a/src/partest/scala/tools/partest/Actions.scala +++ b/src/partest/scala/tools/partest/Actions.scala @@ -43,26 +43,52 @@ trait Actions { isDryRun || execAndLog(cmd) } + /** Runs command redirecting standard out and + * error out to output file. + */ + private def runCommandOld(command: String, output: java.io.File): Int = { + import java.io._ + import nest.StreamAppender + + // NestUI.verbose("running command:\n"+command) + val proc = Runtime.getRuntime.exec(command) + val in = proc.getInputStream + val err = proc.getErrorStream + val writer = new PrintWriter(new FileWriter(output), true) + val inApp = StreamAppender(in, writer) + val errApp = StreamAppender(err, writer) + val async = new Thread(errApp) + async.start() + inApp.run() + async.join() + writer.close() + + try proc.exitValue() + catch { case _: IllegalThreadStateException => 0 } + } + /** Exec a process to run a command. Assumes 0 exit value is success. * Of necessity, also treats no available exit value as success. */ protected def execAndLog(cmd: String): Boolean = { - var proc: Process = null - - val result = interruptMeIn(cmd, testTimeout) { - loggingResult { - proc = Process.exec(toArgs(cmd), execEnv, execCwd.orNull, true) - proc.slurp() - } - proc != null && (proc.waitFor() == 0) - } - result getOrElse { - warning("Process never terminated: '%s'" format cmd) - if (proc != null) - proc.destroy() - - false - } + runCommandOld(cmd, logFile.jfile) == 0 + + // var proc: Process = null + // + // val result = interruptMeIn(cmd, testTimeout) { + // loggingResult { + // proc = Process.exec(toArgs(cmd), execEnv, execCwd.orNull, true) + // proc.slurp() + // } + // proc != null && (proc.waitFor() == 0) + // } + // result getOrElse { + // warning("Process never terminated: '%s'" format cmd) + // if (proc != null) + // proc.destroy() + // + // false + // } } } diff --git a/src/partest/scala/tools/partest/nest/StreamAppender.scala b/src/partest/scala/tools/partest/nest/StreamAppender.scala new file mode 100644 index 0000000000..8cebcf1685 --- /dev/null +++ b/src/partest/scala/tools/partest/nest/StreamAppender.scala @@ -0,0 +1,94 @@ +/* NEST (New Scala Test) + * Copyright 2007-2010 LAMP/EPFL + * @author Philipp Haller + */ + +// $Id$ + +package scala.tools.partest +package nest + +import java.io._ + +object StreamAppender { + def wrapIn(in: InputStream): BufferedReader = new BufferedReader(new InputStreamReader(in)) + def wrapIn(reader: Reader): BufferedReader = new BufferedReader(reader) + def wrapIn(str: String): BufferedReader = new BufferedReader(new StringReader(str)) + + def wrapOut(out: OutputStream): PrintWriter = new PrintWriter(new OutputStreamWriter(out), true) + def wrapOut(writer: Writer): PrintWriter = new PrintWriter(writer, true) + def wrapOut(): PrintWriter = wrapOut(new StringWriter) + + def apply(reader: BufferedReader, writer: Writer): StreamAppender = + new StreamAppender(reader, wrapOut(writer)) + + def apply(reader: Reader, writer: Writer): StreamAppender = + apply(wrapIn(reader), writer) + + def apply(in: InputStream, writer: Writer): StreamAppender = + apply(wrapIn(in), writer) + + def apply(str: String, writer: Writer): StreamAppender = + apply(wrapIn(str), writer) + + def apply(in: File, out: File): StreamAppender = + apply(new FileReader(in), new FileWriter(out)) + + def appendToString(in1: InputStream, in2: InputStream): String = { + val swriter1 = new StringWriter + val swriter2 = new StringWriter + val app1 = StreamAppender(wrapIn(in1), swriter1) + val app2 = StreamAppender(wrapIn(in2), swriter2) + + val async = new Thread(app2) + async.start() + app1.run() + async.join() + swriter1.toString + swriter2.toString + } +/* + private def inParallel(t1: Runnable, t2: Runnable, t3: Runnable) { + val thr1 = new Thread(t1) + val thr2 = new Thread(t2) + thr1.start() + thr2.start() + t3.run() + thr1.join() + thr2.join() + } +*/ + private def inParallel(t1: Runnable, t2: Runnable) { + val thr = new Thread(t2) + thr.start() + t1.run() + thr.join() + } + + def concat(in: InputStream, err: InputStream, out: OutputStream) = new Runnable { + override def run() { + val outWriter = wrapOut(out) + val inApp = StreamAppender(in, outWriter) + + val errStringWriter = new StringWriter + val errApp = StreamAppender(wrapIn(err), errStringWriter) + + inParallel(inApp, errApp) + + // append error string to out + StreamAppender(errStringWriter.toString, outWriter).run() + } + } +} + +class StreamAppender(reader: BufferedReader, writer: PrintWriter) extends Runnable { + override def run() = runAndMap(identity) + private def lines() = Iterator continually reader.readLine() takeWhile (_ != null) + def closeAll() = { + reader.close() + writer.close() + } + + def runAndMap(f: String => String) = + try lines() map f foreach (writer println _) + catch { case e: IOException => e.printStackTrace() } +} -- cgit v1.2.3