| /* |
| * 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 |
| } |
| } |