* Binder also makes it possible to establish TCP/IP
* connection between debugger and debuggee throw IOPipe
* object. This connection allows debugger to communicate with debuggee
* by exchanging with synchronization messages and data.
*
* To launch debuggee VM and bind to it use bindToDebugee()
* method. This method construct mirror of debugee VM, represented by
* object of DebugeeProcess class or derived. This mirror object
* allows to control debuggee VM.
*
* See also nsk.share.jdi.Binder and nsk.share.jdwp.Binder
* classes which provide launching and binding to debuggee VM using specific
* JDI and JDWP features.
*
* @see DebugeeArgumentHandler
* @see DebugeeProcess
* @see IOPipe
*
* @see nsk.share.jdb.Launcher
* @see nsk.share.jdi.Binder
* @see nsk.share.jdwp.Binder
*/
public class DebugeeBinder extends Log.Logger {
private static final boolean IS_WINDOWS = System.getProperty("os.name")
.toLowerCase()
.startsWith("win");
public static int TRY_DELAY = 1000; // milliseconds
public static int CONNECT_TIMEOUT = 1 * 60 * 1000; // milliseconds
public static int CONNECT_TRY_DELAY = 2 * 1000; // milliseconds
public static int CONNECT_TRIES = CONNECT_TIMEOUT / CONNECT_TRY_DELAY;
public static int THREAD_TIMEOUT = 2 * CONNECT_TRY_DELAY; // milliseconds
public static int PING_TIMEOUT = 30 * 1000; // milliseconds
public static int SOCKET_TIMEOUT = 2 * 1000; // milliseconds
public static int SOCKET_LINGER = 1; // milliseconds
private static int TRACE_LEVEL_PACKETS = 10;
private static int TRACE_LEVEL_THREADS = 20;
private static int TRACE_LEVEL_ACTIONS = 30;
private static int TRACE_LEVEL_SOCKETS = 40;
private static int TRACE_LEVEL_IO = 50;
/**
* Default message prefix for Binder object.
*/
public static final String LOG_PREFIX = "binder> ";
private DebugeeArgumentHandler argumentHandler = null;
/**
* Get version string.
*/
public static String getVersion () {
return "@(#)Binder.java %I% %E%";
}
// -------------------------------------------------- //
private ServerSocket pipeServerSocket = null;
// -------------------------------------------------- //
/**
* Incarnate new Binder obeying the given
* argumentHandler; and assign the given
* log.
*/
public DebugeeBinder (DebugeeArgumentHandler argumentHandler, Log log) {
super(log, LOG_PREFIX);
this.argumentHandler = argumentHandler;
}
/**
* Get argument handler of this binder object.
*/
DebugeeArgumentHandler getArgumentHandler() {
return argumentHandler;
}
// -------------------------------------------------- //
/**
* Wait for given thread finished for THREAD_TIMEOUT timeout and
* interrupt this thread if not finished.
*
* @param thr thread to wait for
* @param logger to write log messages to
*/
public static void waitForThread(Thread thr, Log.Logger logger) {
waitForThread(thr, THREAD_TIMEOUT, logger);
}
/**
* Wait for given thread finished for specified timeout and
* interrupt this thread if not finished.
*
* @param thr thread to wait for
* @param millisecs timeout in milliseconds
* @param logger to write log messages to
*/
public static void waitForThread(Thread thr, long millisecs, Log.Logger logger) {
if (thr != null) {
if (thr.isAlive()) {
try {
logger.trace(TRACE_LEVEL_THREADS, "Waiting for thread: " + thr.getName());
thr.join(millisecs);
} catch (InterruptedException e) {
e.printStackTrace(logger.getOutStream());
throw new Failure ("Thread interrupted while waiting for another thread:\n\t"
+ e);
} finally {
if (thr.isAlive()) {
logger.trace(TRACE_LEVEL_THREADS, "Interrupting not finished thread: " + thr);
thr.interrupt();
}
}
}
}
}
/**
* Make preperation for IOPipe connection before starting debugee VM process.
* May change options in the passed argumentHandler.
*/
public void prepareForPipeConnection(DebugeeArgumentHandler argumentHandler) {
if (argumentHandler.isTransportAddressDynamic()) {
try {
pipeServerSocket = new ServerSocket();
pipeServerSocket.setReuseAddress(false);
pipeServerSocket.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0));
} catch (IOException e) {
e.printStackTrace(getOutStream());
throw new Failure("Caught IOException while binding for IOPipe connection: \n\t"
+ e);
}
int port = pipeServerSocket.getLocalPort();
argumentHandler.setPipePortNumber(port);
}
}
/**
* Return already bound ServerSocket for IOPipe connection or null.
*/
protected ServerSocket getPipeServerSocket() {
return pipeServerSocket;
}
/**
* Close ServerSocket used for IOPipeConnection if any.
*/
private void closePipeServerSocket() {
if (pipeServerSocket != null) {
try {
pipeServerSocket.close();
} catch (IOException e) {
println("# WARNING: Caught IOException while closing ServerSocket used for IOPipe connection: \n\t"
+ e);
}
}
}
// -------------------------------------------------- //
/**
* Make environment for launching JVM process.
*/
public String[] makeProcessEnvironment() {
/*
String env = new String[0];
return env;
*/
return null;
}
/**
* Launch process by the specified command line.
*
* @throws IOException if I/O error occured while launching process
*/
public Process launchProcess(String cmdLine) throws IOException {
String env[] = makeProcessEnvironment();
return Runtime.getRuntime().exec(cmdLine, env);
}
/**
* Launch process by the arguments array.
*
* @throws IOException if I/O error occured while launching process
*/
public Process launchProcess(String[] args) throws IOException {
String env[] = makeProcessEnvironment();
return Runtime.getRuntime().exec(args, env);
}
/**
* Make string representation of debuggee VM transport address according
* to current command line options.
*/
public String makeTransportAddress() {
String address = null;
if (argumentHandler.isSocketTransport()) {
if (argumentHandler.isListeningConnector()) {
address = argumentHandler.getTestHost()
+ ":" + argumentHandler.getTransportPort();
} else {
address = argumentHandler.getTransportPort();
}
} else if (argumentHandler.isShmemTransport() ) {
address = argumentHandler.getTransportSharedName();
} else {
throw new TestBug("Undefined transport type: "
+ argumentHandler.getTransportType());
}
return address;
}
/**
* Make command line to launch debugee VM as a string using given quote symbol,
* using specified transportAddress for JDWP connection.
*/
public String makeCommandLineString(String classToExecute, String transportAddress, String quote) {
String[] args = makeCommandLineArgs(classToExecute, transportAddress);
return ArgumentParser.joinArguments(args, quote);
}
/**
* Make command line to launch debugee VM as a string using given quote symbol.
*/
public String makeCommandLineString(String classToExecute, String quote) {
return makeCommandLineString(classToExecute, makeTransportAddress(), quote);
}
/**
* Make command line to launch debugee VM as a string using default quote symbol,
* using specified transportAddress for JDWP connection.
*/
/*
public String makeCommandLineString(String classToExecute, String transportAddress) {
return makeCommandLineString(classToExecute, transportAddress, "\"");
}
*/
/**
* Make command line to launch debugee VM as a string using default quote symbol.
*/
/*
public String makeCommandLineString(String classToExecute) {
return makeCommandLineString(classToExecute, makeTransportAddress());
}
*/
/**
* Make command line to launch debugee VM as an array of arguments,
* using specified transportAddress for JDWP connection.
*/
public String[] makeCommandLineArgs(String classToExecute, String transportAddress) {
Vector