Rolled back a subset of partest to use StreamAp...

Rolled back a subset of partest to use StreamAppender and avoid
io.Process. No review.

2 files changed, 136 insertions, 16 deletions

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 <code>command</code> redirecting standard out and
+     *  error out to <code>output</code> 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() }
+}