keys.scala, etc.: Make merging public keys have a progress bar.

[tripe-android] / sys.scala

diff --git a/sys.scala b/sys.scala
index 402bf1d..43487b5 100644 (file)
--- a/sys.scala
+++ b/sys.scala
@@ -32,12 +32,15 @@ import scala.collection.mutable.{HashMap, HashSet};
 
 import java.io.{BufferedReader, BufferedWriter, Closeable, File,
                FileDescriptor, FileInputStream, FileOutputStream,
+               FileReader, FileWriter,
                InputStream, InputStreamReader,
                OutputStream, OutputStreamWriter};
 import java.nio.{ByteBuffer, CharBuffer};
 import java.nio.charset.Charset;
 import java.util.Date;
 
+import Implicits.truish;
+
 /*----- Some magic for C strings ------------------------------------------*/
 
 type CString = Array[Byte];
@@ -407,6 +410,8 @@ def unlink(path: String) { unlink(path.toCString); }
 def rmdir(path: String) { rmdir(path.toCString); }
 @native protected def mkdir(path: CString, mode: Int);
 def mkdir(path: String, mode: Int) { mkdir(path.toCString, mode); }
+@native protected def chmod(path: CString, mode: Int);
+def chmod(path: String, mode: Int) { chmod(path.toCString, mode); }
 @native protected def mkfile(path: CString, mode: Int);
 def mkfile(path: String, mode: Int) { mkfile(path.toCString, mode); }
 @native protected def rename(from: CString, to: CString);
@@ -606,6 +611,7 @@ object FileImplicits {
     def rmdir_!() { rmdir(file.getPath); }
     def mkdir_!(mode: Int) { mkdir(file.getPath, mode); }
     def mkdir_!() { mkdir_!(0x1ff); }
+    def chmod_!(mode: Int) { chmod(file.getPath, mode); }
     def mkfile_!(mode: Int) { mkfile(file.getPath, mode); }
     def mkfile_!() { mkfile_!(0x1b6); }
     def rename_!(to: File) { rename(file.getPath, to.getPath); }
@@ -679,10 +685,8 @@ object FileImplicits {
     /* Opening files.  Again, I'm surprised this isn't here already. */
     def open(): FileInputStream = new FileInputStream(file);
     def openForOutput(): FileOutputStream = new FileOutputStream(file);
-    def reader(): BufferedReader =
-      new BufferedReader(new InputStreamReader(open()));
-    def writer(): BufferedWriter =
-      new BufferedWriter(new OutputStreamWriter(openForOutput()));
+    def reader(): BufferedReader = new BufferedReader(new FileReader(file));
+    def writer(): BufferedWriter = new BufferedWriter(new FileWriter(file));
     def withInput[T](body: FileInputStream => T): T = {
       val in = open();
       try { body(in) }
@@ -692,13 +696,15 @@ object FileImplicits {
       val out = openForOutput();
       try { body(out) } finally { out.close(); }
     }
-    def withReader[T](body: BufferedReader => T): T = withInput { in =>
-      body(new BufferedReader(new InputStreamReader(in)))
-    };
-    def withWriter[T](body: BufferedWriter => T): T = withOutput { out =>
-      val w = new BufferedWriter(new OutputStreamWriter(out));
-      /* Do this the hard way, so that we flush the `BufferedWriter'. */
-      try { body(w) } finally { w.close(); }
+    def withReader[T](body: BufferedReader => T): T = {
+      val r = reader();
+      try { body(r) }
+      finally { r.close(); }
+    }
+    def withWriter[T](body: BufferedWriter => T): T = {
+      val w = writer();
+      try { body(w) }
+      finally { w.close(); }
     }
   }
 }
@@ -773,8 +779,9 @@ def runCommand(cmd: String*): (String, String) = {
   withCleaner { clean =>
 
     /* Create the child process and pick up the ends of its streams. */
-    val pb = new ProcessBuilder(cmd.asJava).redirectInput(devnull);
+    val pb = new ProcessBuilder(cmd.asJava);
     val kid = pb.start(); clean { kid.destroy(); }
+    kid.getOutputStream.close();
     val out = kid.getInputStream(); clean { out.close(); }
     val err = kid.getErrorStream(); clean { err.close(); }
 
@@ -796,7 +803,7 @@ def runCommand(cmd: String*): (String, String) = {
 
     /* Check the exit status. */
     val rc = kid.exitValue;
-    if (rc != 0) throw new SubprocessFailed(cmd, rc, berr.result);
+    if (rc) throw new SubprocessFailed(cmd, rc, berr.result);
 
     /* We're all done. */
     return (bout.result, berr.result);
@@ -817,7 +824,7 @@ private var triggers: List[Wrapper] = Nil;
 
 private def getTrigger(): Wrapper = {
   triggerLock synchronized {
-    if (nTriggers == 0)
+    if (!nTriggers)
       make_trigger()
     else {
       val trig = triggers.head;