infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-03-06 14:10:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

8005290: remove -showversion from RMI test library subprocess mechanism

Browse Source 
Reviewed-by: jgish, chegar, dmocek
This commit is contained in:
Stuart Marks 2012-12-20 20:11:45 -08:00
parent 50185a4371
commit 1fd4da4d29
3 changed files with 33 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
jdk/test/java/rmi/testlibrary/JavaVM.java
View File

@ -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() {

90
jdk/test/java/rmi/testlibrary/StreamPipe.java
View File

@ -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 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();
}
}
}

2
jdk/test/sun/rmi/runtime/Log/6409194/NoConsoleOutput.java
View File

@ -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();