8005290: remove -showversion from RMI test library subprocess mechanism

Reviewed-by: jgish, chegar, dmocek

test/java/rmi/testlibrary/JavaVM.java

@@ -21,13 +21,10 @@
  * questions.
  */
 
-/**
- *
- */
-
-import java.io.*;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
 import java.util.Arrays;
-import java.util.Properties;
 import java.util.StringTokenizer;
 
 /**
@@ -45,10 +42,6 @@ public class JavaVM {
     private OutputStream errorStream = System.err;
     private String policyFileName = null;
 
-    // This is used to shorten waiting time at startup.
-    private volatile boolean started = false;
-    private boolean forcesOutput = true; // default behavior
-
     private static void mesg(Object mesg) {
         System.err.println("JAVAVM: " + mesg.toString());
     }
@@ -82,24 +75,6 @@ public class JavaVM {
         this.errorStream = err;
     }
 
-    /* This constructor will instantiate a JavaVM object for which caller
-     * can ask for forcing initial version output on child vm process
-     * (if forcesVersionOutput is true), or letting the started vm behave freely
-     * (when forcesVersionOutput is false).
-     */
-    public JavaVM(String classname,
-                  String options, String args,
-                  OutputStream out, OutputStream err,
-                  boolean forcesVersionOutput) {
-        this(classname, options, args, out, err);
-        this.forcesOutput = forcesVersionOutput;
-    }
-
-
-    public void setStarted() {
-        started = true;
-    }
-
     // Prepends passed opts array to current options
     public void addOptions(String[] opts) {
         String newOpts = "";
@@ -139,7 +114,8 @@ public class JavaVM {
      */
     public void start() throws IOException {
 
-        if (vm != null) return;
+        if (vm != null)
+            throw new IllegalStateException("JavaVM already started");
 
         /*
          * If specified, add option for policy file
@@ -151,18 +127,6 @@ public class JavaVM {
 
         addOptions(new String[] { getCodeCoverageOptions() });
 
-        /*
-         * If forcesOutput is true :
-         *  We force the new starting vm to output something so that we can know
-         *  when it is effectively started by redirecting standard output through
-         *  the next StreamPipe call (the vm is considered started when a first
-         *  output has been streamed out).
-         *  We do this by prepnding a "-showversion" option in the command line.
-         */
-        if (forcesOutput) {
-            addOptions(new String[] {"-showversion"});
-        }
-
         StringTokenizer optionsTokenizer = new StringTokenizer(options);
         StringTokenizer argsTokenizer = new StringTokenizer(args);
         int optionsCount = optionsTokenizer.countTokens();
@@ -186,43 +150,8 @@ public class JavaVM {
         vm = Runtime.getRuntime().exec(javaCommand);
 
         /* output from the execed process may optionally be captured. */
-        StreamPipe.plugTogether(this, vm.getInputStream(), this.outputStream);
-        StreamPipe.plugTogether(this, vm.getErrorStream(), this.errorStream);
-
-        try {
-            if (forcesOutput) {
-                // Wait distant vm to start, by using waiting time slices of 100 ms.
-                // Wait at most for 2secs, after it considers the vm to be started.
-                final long vmStartSleepTime = 100;
-                final int maxTrials = 20;
-                int numTrials = 0;
-                while (!started && numTrials < maxTrials) {
-                    numTrials++;
-                    Thread.sleep(vmStartSleepTime);
-                }
-
-                // Outputs running status of distant vm
-                String message =
-                    "after " + (numTrials * vmStartSleepTime) + " milliseconds";
-                if (started) {
-                    mesg("distant vm process running, " + message);
-                }
-                else {
-                    mesg("unknown running status of distant vm process, " + message);
-                }
-            }
-            else {
-                // Since we have no way to know if the distant vm is started,
-                // we just consider the vm to be started after a 2secs waiting time.
-                Thread.sleep(2000);
-                mesg("distant vm considered to be started after a waiting time of 2 secs");
-            }
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-            mesg("Thread interrupted while checking if distant vm is started. Giving up check.");
-            mesg("Distant vm state unknown");
-            return;
-        }
+        StreamPipe.plugTogether(vm.getInputStream(), this.outputStream);
+        StreamPipe.plugTogether(vm.getErrorStream(), this.errorStream);
     }
 
     public void destroy() {

test/java/rmi/testlibrary/StreamPipe.java

@@ -21,11 +21,10 @@
  * questions.
  */
 
-/**
- *
- */
-
-import java.io.*;
+import java.io.InputStream;
+import java.io.InterruptedIOException;
+import java.io.IOException;
+import java.io.OutputStream;
 
 /**
  * Pipe output of one stream into input of another.
@@ -34,84 +33,46 @@ public class StreamPipe extends Thread {
 
     private InputStream in;
     private OutputStream out;
-    private String preamble;
-    private JavaVM javaVM;
-    private static Object lock = new Object();
-    private static int count = 0;
 
+    private static Object countLock = new Object();
+    private static int count = 0;
 
-    /* StreamPipe constructor : should only be called by plugTogether() method !!
-     * If passed vm is not null :
-     * -  This is StreamPipe usage when streams to pipe come from a given
-     *    vm (JavaVM) process (the vm process must be started with a prefixed
-     *    "-showversion" option to be able to determine as soon as possible when
-     *    the vm process is started through the redirection of the streams).
-     *    There must be a close connection between the StreamPipe instance and
-     *    the JavaVM object on which a start() call has been done.
-     *    run() method will flag distant JavaVM as started.
-     * If passed vm is null :
-     * -  We don't have control on the process which we want to redirect the passed
-     *    streams.
-     *    run() method will ignore distant process.
+    /**
+     * StreamPipe constructor : should only be called by plugTogether() method.
      */
-    private StreamPipe(JavaVM vm, InputStream in, OutputStream out, String name) {
+    private StreamPipe(InputStream in, OutputStream out, String name) {
         super(name);
         this.in  = in;
         this.out = out;
-        this.preamble = "# ";
-        this.javaVM = vm;
     }
 
-    // Install redirection of passed InputStream and OutputStream from passed JavaVM
-    // to this vm standard output and input streams.
-    public static void plugTogether(JavaVM vm, InputStream in, OutputStream out) {
-        String name = null;
+    /**
+     * Creates a StreamPipe thread that copies in to out and returns
+     * the created instance.
+     */
+    public static StreamPipe plugTogether(InputStream in, OutputStream out) {
+        String name;
 
-        synchronized (lock) {
-            name = "TestLibrary: StreamPipe-" + (count ++ );
+        synchronized (countLock) {
+            name = "java.rmi.testlibrary.StreamPipe-" + (count++);
         }
 
-        Thread pipe = new StreamPipe(vm, in, out, name);
+        StreamPipe pipe = new StreamPipe(in, out, name);
         pipe.setDaemon(true);
         pipe.start();
-    }
-
-    /* Redirects the InputStream and OutputStream passed by caller to this
-     * vm standard output and input streams.
-     * (we just have to use fully parametered plugTogether() call with a null
-     *  JavaVM input to do this).
-     */
-    public static void plugTogether(InputStream in, OutputStream out) {
-        plugTogether(null, in, out);
+        return pipe;
     }
 
     // Starts redirection of streams.
     public void run() {
-        BufferedReader r = new BufferedReader(new InputStreamReader(in), 1);
-        BufferedWriter w = new BufferedWriter(new OutputStreamWriter(out));
-        byte[] buf = new byte[256];
-
         try {
-            String line;
+            byte[] buf = new byte[1024];
 
-            /* This is to check that the distant vm has started,
-             * if such a vm has been provided at construction :
-             * - As soon as we can read something from r BufferedReader,
-             *   that means the distant vm is already started.
-             * Thus we signal associated JavaVM object that it is now started.
-             */
-            if (((line = r.readLine()) != null) &&
-                (javaVM != null)) {
-                javaVM.setStarted();
-            }
-
-            // Redirects r on w.
-            while (line != null) {
-                w.write(preamble);
-                w.write(line);
-                w.newLine();
-                w.flush();
-                line = r.readLine();
+            while (true) {
+                int nr = in.read(buf);
+                if (nr == -1)
+                    break;
+                out.write(buf, 0, nr);
             }
         } catch (InterruptedIOException iioe) {
             // Thread interrupted during IO operation. Terminate StreamPipe.
@@ -121,5 +82,4 @@ public class StreamPipe extends Thread {
             e.printStackTrace();
         }
     }
-
 }

test/sun/rmi/runtime/Log/6409194/NoConsoleOutput.java

@@ -64,7 +64,7 @@ public class NoConsoleOutput {
         // (neither on standard output, nor on standard err streams).
         JavaVM vm = new JavaVM(DoRMIStuff.class.getName(),
             "-Djava.util.logging.config.file=" + loggingPropertiesFile,
-                               "", out, err, false);
+                               "", out, err);
         vm.start();
         vm.getVM().waitFor();