hotspot/agent/test/jdi/VMConnection.java - edge/openjdk - Git at Google

 /*
  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */

 import com.sun.jdi.*;
 import com.sun.jdi.connect.*;
 import com.sun.jdi.request.EventRequestManager;

 import java.util.*;
 import java.io.*;


 /**
  * Manages a VM conection for the JDI test framework.
  */
 class VMConnection {
     private VirtualMachine vm;
     private Process process = null;
     private int outputCompleteCount = 0;

     private final Connector connector;
     private final Map connectorArgs;
     private final int traceFlags;

     /**
      * Return a String containing VM Options to pass to the debugee
      * or an empty string if there are none.
      * These are read from the first non-comment line
      * in file test/com/sun/jdi/@debuggeeVMOptions.
      */
     static public String getDebuggeeVMOptions() {

         // When we run under jtreg, test.src contains the pathname of
         // the test/com/sun/jdi dir.
         BufferedReader reader;
         final String filename = "@debuggeeVMOptions";
         String srcDir = System.getProperty("test.src");

         if (srcDir == null) {
           srcDir = System.getProperty("user.dir");
         }
         srcDir = srcDir + File.separator;

         File myDir = new File(srcDir);

         File myFile = new File(myDir, filename);
         if (!myFile.canRead()) {
             try {
                 // We have some subdirs of test/com/sun/jdi so in case we
                 // are in one of them, look in our parent dir for the file.
                 myFile = new File(myDir.getCanonicalFile().getParent(),
                                   filename);
                 if (!myFile.canRead()) {
                     return "";
                 }
             } catch (IOException ee) {
                 System.out.println("-- Error 1 trying to access file " +
                                    myFile.getPath() + ": " + ee);
                 return "";
             }
         }
         String wholePath = myFile.getPath();
         try {
             reader = new BufferedReader(new FileReader(myFile));
         } catch (FileNotFoundException ee) {
             System.out.println("-- Error 2 trying to access file " +
                                wholePath + ": " + ee);
             return "";
         }

         String line;
         String retVal = "";
         while (true) {
             try {
                 line = reader.readLine();
             } catch (IOException ee) {
                 System.out.println("-- Error reading options from file " +
                                    wholePath + ": " + ee);
                 break;
             }
             if (line == null) {
                 System.out.println("-- No debuggee VM options found in file " +
                                    wholePath);
                 break;
             }
             line = line.trim();
             if (line.length() != 0 && !line.startsWith("#")) {
                 System.out.println("-- Added debuggeeVM options from file " +
                                    wholePath + ": " + line);
                 retVal = line;
                 break;
             }
             // Else, read he next line.
         }
         try {
             reader.close();
         } catch (IOException ee) {
         }
         return retVal;
     }

     private Connector findConnector(String name) {
         List connectors = Bootstrap.virtualMachineManager().allConnectors();
         Iterator iter = connectors.iterator();
         while (iter.hasNext()) {
             Connector connector = (Connector)iter.next();
             if (connector.name().equals(name)) {
                 return connector;
             }
         }
         return null;
     }

     private Map parseConnectorArgs(Connector connector, String argString) {
         StringTokenizer tokenizer = new StringTokenizer(argString, ",");
         Map arguments = connector.defaultArguments();

         while (tokenizer.hasMoreTokens()) {
             String token = tokenizer.nextToken();
             int index = token.indexOf('=');
             if (index == -1) {
                 throw new IllegalArgumentException("Illegal connector argument: " +
                                                    token);
             }
             String name = token.substring(0, index);
             String value = token.substring(index + 1);
             Connector.Argument argument = (Connector.Argument)arguments.get(name);
             if (argument == null) {
                 throw new IllegalArgumentException("Argument " + name +
                                                "is not defined for connector: " +
                                                connector.name());
             }
             argument.setValue(value);
         }
         return arguments;
     }

     VMConnection(String connectSpec, int traceFlags) {
         String nameString;
         String argString;
         int index = connectSpec.indexOf(':');
         if (index == -1) {
             nameString = connectSpec;
             argString = "";
         } else {
             nameString = connectSpec.substring(0, index);
             argString = connectSpec.substring(index + 1);
         }

         connector = findConnector(nameString);
         if (connector == null) {
             throw new IllegalArgumentException("No connector named: " +
                                                nameString);
         }

         connectorArgs = parseConnectorArgs(connector, argString);
         this.traceFlags = traceFlags;
     }

     synchronized VirtualMachine open() {
         if (connector instanceof LaunchingConnector) {
             vm = launchTarget();
         } else if (connector instanceof AttachingConnector) {
             vm = attachTarget();
         } else if (connector instanceof ListeningConnector) {
             vm = listenTarget();
         } else {
             throw new InternalError("Invalid connect type");
         }
         vm.setDebugTraceMode(traceFlags);
         System.out.println("JVM version:" + vm.version());
         System.out.println("JDI version: " + Bootstrap.virtualMachineManager().majorInterfaceVersion() +
                            "." + Bootstrap.virtualMachineManager().minorInterfaceVersion());
         System.out.println("JVM description: " + vm.description());

         return vm;
     }

     boolean setConnectorArg(String name, String value) {
         /*
          * Too late if the connection already made
          */
         if (vm != null) {
             return false;
         }

         Connector.Argument argument = (Connector.Argument)connectorArgs.get(name);
         if (argument == null) {
             return false;
         }
         argument.setValue(value);
         return true;
     }

     String connectorArg(String name) {
         Connector.Argument argument = (Connector.Argument)connectorArgs.get(name);
         if (argument == null) {
             return "";
         }
         return argument.value();
     }

     public synchronized VirtualMachine vm() {
         if (vm == null) {
             throw new InternalError("VM not connected");
         } else {
             return vm;
         }
     }

     boolean isOpen() {
         return (vm != null);
     }

     boolean isLaunch() {
         return (connector instanceof LaunchingConnector);
     }

     Connector connector() {
         return connector;
     }

     boolean isListen() {
         return (connector instanceof ListeningConnector);
     }

     boolean isAttach() {
         return (connector instanceof AttachingConnector);
     }

     private synchronized void notifyOutputComplete() {
         outputCompleteCount++;
         notifyAll();
     }

     private synchronized void waitOutputComplete() {
         // Wait for stderr and stdout
         if (process != null) {
             while (outputCompleteCount < 2) {
                 try {wait();} catch (InterruptedException e) {}
             }
         }
     }

     public void disposeVM() {
         try {
             if (vm != null) {
                 vm.dispose();
                 vm = null;
             }
         } finally {
             if (process != null) {
                 process.destroy();
                 process = null;
             }
             waitOutputComplete();
         }
     }

     private void dumpStream(InputStream stream) throws IOException {
         PrintStream outStream = System.out;
         BufferedReader in =
             new BufferedReader(new InputStreamReader(stream));
         String line;
         while ((line = in.readLine()) != null) {
             outStream.println(line);
         }
     }

     /**
      *  Create a Thread that will retrieve and display any output.
      *  Needs to be high priority, else debugger may exit before
      *  it can be displayed.
      */
     private void displayRemoteOutput(final InputStream stream) {
         Thread thr = new Thread("output reader") {
             public void run() {
                 try {
                     dumpStream(stream);
                 } catch (IOException ex) {
                     System.err.println("IOException reading output of child java interpreter:"
                                        + ex.getMessage());
                 } finally {
                     notifyOutputComplete();
                 }
             }
         };
         thr.setPriority(Thread.MAX_PRIORITY-1);
         thr.start();
     }

     private void dumpFailedLaunchInfo(Process process) {
         try {
             dumpStream(process.getErrorStream());
             dumpStream(process.getInputStream());
         } catch (IOException e) {
             System.err.println("Unable to display process output: " +
                                e.getMessage());
         }
     }

     /* launch child target vm */
     private VirtualMachine launchTarget() {
         LaunchingConnector launcher = (LaunchingConnector)connector;
         try {
             VirtualMachine vm = launcher.launch(connectorArgs);
             process = vm.process();
             displayRemoteOutput(process.getErrorStream());
             displayRemoteOutput(process.getInputStream());
             return vm;
         } catch (IOException ioe) {
             ioe.printStackTrace();
             System.err.println("\n Unable to launch target VM.");
         } catch (IllegalConnectorArgumentsException icae) {
             icae.printStackTrace();
             System.err.println("\n Internal debugger error.");
         } catch (VMStartException vmse) {
             System.err.println(vmse.getMessage() + "\n");
             dumpFailedLaunchInfo(vmse.process());
             System.err.println("\n Target VM failed to initialize.");
         }
         return null; // Shuts up the compiler
     }

     /* attach to running target vm */
     private VirtualMachine attachTarget() {
         AttachingConnector attacher = (AttachingConnector)connector;
         try {
             return attacher.attach(connectorArgs);
         } catch (IOException ioe) {
             ioe.printStackTrace();
             System.err.println("\n Unable to attach to target VM.");
         } catch (IllegalConnectorArgumentsException icae) {
             icae.printStackTrace();
             System.err.println("\n Internal debugger error.");
         }
         return null; // Shuts up the compiler
     }

     /* listen for connection from target vm */
     private VirtualMachine listenTarget() {
         ListeningConnector listener = (ListeningConnector)connector;
         try {
             String retAddress = listener.startListening(connectorArgs);
             System.out.println("Listening at address: " + retAddress);
             vm = listener.accept(connectorArgs);
             listener.stopListening(connectorArgs);
             return vm;
         } catch (IOException ioe) {
             ioe.printStackTrace();
             System.err.println("\n Unable to attach to target VM.");
         } catch (IllegalConnectorArgumentsException icae) {
             icae.printStackTrace();
             System.err.println("\n Internal debugger error.");
         }
         return null; // Shuts up the compiler
     }
 }
	/*
	* Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*
	*/

	import com.sun.jdi.*;
	import com.sun.jdi.connect.*;
	import com.sun.jdi.request.EventRequestManager;

	import java.util.*;
	import java.io.*;


	/**
	* Manages a VM conection for the JDI test framework.
	*/
	class VMConnection {
	private VirtualMachine vm;
	private Process process = null;
	private int outputCompleteCount = 0;

	private final Connector connector;
	private final Map connectorArgs;
	private final int traceFlags;

	/**
	* Return a String containing VM Options to pass to the debugee
	* or an empty string if there are none.
	* These are read from the first non-comment line
	* in file test/com/sun/jdi/@debuggeeVMOptions.
	*/
	static public String getDebuggeeVMOptions() {

	// When we run under jtreg, test.src contains the pathname of
	// the test/com/sun/jdi dir.
	BufferedReader reader;
	final String filename = "@debuggeeVMOptions";
	String srcDir = System.getProperty("test.src");

	if (srcDir == null) {
	srcDir = System.getProperty("user.dir");
	}
	srcDir = srcDir + File.separator;

	File myDir = new File(srcDir);

	File myFile = new File(myDir, filename);
	if (!myFile.canRead()) {
	try {
	// We have some subdirs of test/com/sun/jdi so in case we
	// are in one of them, look in our parent dir for the file.
	myFile = new File(myDir.getCanonicalFile().getParent(),
	filename);
	if (!myFile.canRead()) {
	return "";
	}
	} catch (IOException ee) {
	System.out.println("-- Error 1 trying to access file " +
	myFile.getPath() + ": " + ee);
	return "";
	}
	}
	String wholePath = myFile.getPath();
	try {
	reader = new BufferedReader(new FileReader(myFile));
	} catch (FileNotFoundException ee) {
	System.out.println("-- Error 2 trying to access file " +
	wholePath + ": " + ee);
	return "";
	}

	String line;
	String retVal = "";
	while (true) {
	try {
	line = reader.readLine();
	} catch (IOException ee) {
	System.out.println("-- Error reading options from file " +
	wholePath + ": " + ee);
	break;
	}
	if (line == null) {
	System.out.println("-- No debuggee VM options found in file " +
	wholePath);
	break;
	}
	line = line.trim();
	if (line.length() != 0 && !line.startsWith("#")) {
	System.out.println("-- Added debuggeeVM options from file " +
	wholePath + ": " + line);
	retVal = line;
	break;
	}
	// Else, read he next line.
	}
	try {
	reader.close();
	} catch (IOException ee) {
	}
	return retVal;
	}

	private Connector findConnector(String name) {
	List connectors = Bootstrap.virtualMachineManager().allConnectors();
	Iterator iter = connectors.iterator();
	while (iter.hasNext()) {
	Connector connector = (Connector)iter.next();
	if (connector.name().equals(name)) {
	return connector;
	}
	}
	return null;
	}

	private Map parseConnectorArgs(Connector connector, String argString) {
	StringTokenizer tokenizer = new StringTokenizer(argString, ",");
	Map arguments = connector.defaultArguments();

	while (tokenizer.hasMoreTokens()) {
	String token = tokenizer.nextToken();
	int index = token.indexOf('=');
	if (index == -1) {
	throw new IllegalArgumentException("Illegal connector argument: " +
	token);
	}
	String name = token.substring(0, index);
	String value = token.substring(index + 1);
	Connector.Argument argument = (Connector.Argument)arguments.get(name);
	if (argument == null) {
	throw new IllegalArgumentException("Argument " + name +
	"is not defined for connector: " +
	connector.name());
	}
	argument.setValue(value);
	}
	return arguments;
	}

	VMConnection(String connectSpec, int traceFlags) {
	String nameString;
	String argString;
	int index = connectSpec.indexOf(':');
	if (index == -1) {
	nameString = connectSpec;
	argString = "";
	} else {
	nameString = connectSpec.substring(0, index);
	argString = connectSpec.substring(index + 1);
	}

	connector = findConnector(nameString);
	if (connector == null) {
	throw new IllegalArgumentException("No connector named: " +
	nameString);
	}

	connectorArgs = parseConnectorArgs(connector, argString);
	this.traceFlags = traceFlags;
	}

	synchronized VirtualMachine open() {
	if (connector instanceof LaunchingConnector) {
	vm = launchTarget();
	} else if (connector instanceof AttachingConnector) {
	vm = attachTarget();
	} else if (connector instanceof ListeningConnector) {
	vm = listenTarget();
	} else {
	throw new InternalError("Invalid connect type");
	}
	vm.setDebugTraceMode(traceFlags);
	System.out.println("JVM version:" + vm.version());
	System.out.println("JDI version: " + Bootstrap.virtualMachineManager().majorInterfaceVersion() +
	"." + Bootstrap.virtualMachineManager().minorInterfaceVersion());
	System.out.println("JVM description: " + vm.description());

	return vm;
	}

	boolean setConnectorArg(String name, String value) {
	/*
	* Too late if the connection already made
	*/
	if (vm != null) {
	return false;
	}

	Connector.Argument argument = (Connector.Argument)connectorArgs.get(name);
	if (argument == null) {
	return false;
	}
	argument.setValue(value);
	return true;
	}

	String connectorArg(String name) {
	Connector.Argument argument = (Connector.Argument)connectorArgs.get(name);
	if (argument == null) {
	return "";
	}
	return argument.value();
	}

	public synchronized VirtualMachine vm() {
	if (vm == null) {
	throw new InternalError("VM not connected");
	} else {
	return vm;
	}
	}

	boolean isOpen() {
	return (vm != null);
	}

	boolean isLaunch() {
	return (connector instanceof LaunchingConnector);
	}

	Connector connector() {
	return connector;
	}

	boolean isListen() {
	return (connector instanceof ListeningConnector);
	}

	boolean isAttach() {
	return (connector instanceof AttachingConnector);
	}

	private synchronized void notifyOutputComplete() {
	outputCompleteCount++;
	notifyAll();
	}

	private synchronized void waitOutputComplete() {
	// Wait for stderr and stdout
	if (process != null) {
	while (outputCompleteCount < 2) {
	try {wait();} catch (InterruptedException e) {}
	}
	}
	}

	public void disposeVM() {
	try {
	if (vm != null) {
	vm.dispose();
	vm = null;
	}
	} finally {
	if (process != null) {
	process.destroy();
	process = null;
	}
	waitOutputComplete();
	}
	}

	private void dumpStream(InputStream stream) throws IOException {
	PrintStream outStream = System.out;
	BufferedReader in =
	new BufferedReader(new InputStreamReader(stream));
	String line;
	while ((line = in.readLine()) != null) {
	outStream.println(line);
	}
	}

	/**
	* Create a Thread that will retrieve and display any output.
	* Needs to be high priority, else debugger may exit before
	* it can be displayed.
	*/
	private void displayRemoteOutput(final InputStream stream) {
	Thread thr = new Thread("output reader") {
	public void run() {
	try {
	dumpStream(stream);
	} catch (IOException ex) {
	System.err.println("IOException reading output of child java interpreter:"
	+ ex.getMessage());
	} finally {
	notifyOutputComplete();
	}
	}
	};
	thr.setPriority(Thread.MAX_PRIORITY-1);
	thr.start();
	}

	private void dumpFailedLaunchInfo(Process process) {
	try {
	dumpStream(process.getErrorStream());
	dumpStream(process.getInputStream());
	} catch (IOException e) {
	System.err.println("Unable to display process output: " +
	e.getMessage());
	}
	}

	/* launch child target vm */
	private VirtualMachine launchTarget() {
	LaunchingConnector launcher = (LaunchingConnector)connector;
	try {
	VirtualMachine vm = launcher.launch(connectorArgs);
	process = vm.process();
	displayRemoteOutput(process.getErrorStream());
	displayRemoteOutput(process.getInputStream());
	return vm;
	} catch (IOException ioe) {
	ioe.printStackTrace();
	System.err.println("\n Unable to launch target VM.");
	} catch (IllegalConnectorArgumentsException icae) {
	icae.printStackTrace();
	System.err.println("\n Internal debugger error.");
	} catch (VMStartException vmse) {
	System.err.println(vmse.getMessage() + "\n");
	dumpFailedLaunchInfo(vmse.process());
	System.err.println("\n Target VM failed to initialize.");
	}
	return null; // Shuts up the compiler
	}

	/* attach to running target vm */
	private VirtualMachine attachTarget() {
	AttachingConnector attacher = (AttachingConnector)connector;
	try {
	return attacher.attach(connectorArgs);
	} catch (IOException ioe) {
	ioe.printStackTrace();
	System.err.println("\n Unable to attach to target VM.");
	} catch (IllegalConnectorArgumentsException icae) {
	icae.printStackTrace();
	System.err.println("\n Internal debugger error.");
	}
	return null; // Shuts up the compiler
	}

	/* listen for connection from target vm */
	private VirtualMachine listenTarget() {
	ListeningConnector listener = (ListeningConnector)connector;
	try {
	String retAddress = listener.startListening(connectorArgs);
	System.out.println("Listening at address: " + retAddress);
	vm = listener.accept(connectorArgs);
	listener.stopListening(connectorArgs);
	return vm;
	} catch (IOException ioe) {
	ioe.printStackTrace();
	System.err.println("\n Unable to attach to target VM.");
	} catch (IllegalConnectorArgumentsException icae) {
	icae.printStackTrace();
	System.err.println("\n Internal debugger error.");
	}
	return null; // Shuts up the compiler
	}
	}