0
|
1 /*
|
|
2 * Copyright 2002 Sun Microsystems, Inc. All Rights Reserved.
|
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
4 *
|
|
5 * This code is free software; you can redistribute it and/or modify it
|
|
6 * under the terms of the GNU General Public License version 2 only, as
|
|
7 * published by the Free Software Foundation.
|
|
8 *
|
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT
|
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
12 * version 2 for more details (a copy is included in the LICENSE file that
|
|
13 * accompanied this code).
|
|
14 *
|
|
15 * You should have received a copy of the GNU General Public License version
|
|
16 * 2 along with this work; if not, write to the Free Software Foundation,
|
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
18 *
|
|
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or
|
|
21 * have any questions.
|
|
22 *
|
|
23 */
|
|
24
|
|
25 import com.sun.jdi.*;
|
|
26 import com.sun.jdi.connect.*;
|
|
27 import com.sun.jdi.request.EventRequestManager;
|
|
28
|
|
29 import java.util.*;
|
|
30 import java.io.*;
|
|
31
|
|
32
|
|
33 /**
|
|
34 * Manages a VM conection for the JDI test framework.
|
|
35 */
|
|
36 class VMConnection {
|
|
37 private VirtualMachine vm;
|
|
38 private Process process = null;
|
|
39 private int outputCompleteCount = 0;
|
|
40
|
|
41 private final Connector connector;
|
|
42 private final Map connectorArgs;
|
|
43 private final int traceFlags;
|
|
44
|
|
45 /**
|
|
46 * Return a String containing VM Options to pass to the debugee
|
|
47 * or an empty string if there are none.
|
|
48 * These are read from the first non-comment line
|
|
49 * in file test/com/sun/jdi/@debuggeeVMOptions.
|
|
50 */
|
|
51 static public String getDebuggeeVMOptions() {
|
|
52
|
|
53 // When we run under jtreg, test.src contains the pathname of
|
|
54 // the test/com/sun/jdi dir.
|
|
55 BufferedReader reader;
|
|
56 final String filename = "@debuggeeVMOptions";
|
|
57 String srcDir = System.getProperty("test.src");
|
|
58
|
|
59 if (srcDir == null) {
|
|
60 srcDir = System.getProperty("user.dir");
|
|
61 }
|
|
62 srcDir = srcDir + File.separator;
|
|
63
|
|
64 File myDir = new File(srcDir);
|
|
65
|
|
66 File myFile = new File(myDir, filename);
|
|
67 if (!myFile.canRead()) {
|
|
68 try {
|
|
69 // We have some subdirs of test/com/sun/jdi so in case we
|
|
70 // are in one of them, look in our parent dir for the file.
|
|
71 myFile = new File(myDir.getCanonicalFile().getParent(),
|
|
72 filename);
|
|
73 if (!myFile.canRead()) {
|
|
74 return "";
|
|
75 }
|
|
76 } catch (IOException ee) {
|
|
77 System.out.println("-- Error 1 trying to access file " +
|
|
78 myFile.getPath() + ": " + ee);
|
|
79 return "";
|
|
80 }
|
|
81 }
|
|
82 String wholePath = myFile.getPath();
|
|
83 try {
|
|
84 reader = new BufferedReader(new FileReader(myFile));
|
|
85 } catch (FileNotFoundException ee) {
|
|
86 System.out.println("-- Error 2 trying to access file " +
|
|
87 wholePath + ": " + ee);
|
|
88 return "";
|
|
89 }
|
|
90
|
|
91 String line;
|
|
92 String retVal = "";
|
|
93 while (true) {
|
|
94 try {
|
|
95 line = reader.readLine();
|
|
96 } catch (IOException ee) {
|
|
97 System.out.println("-- Error reading options from file " +
|
|
98 wholePath + ": " + ee);
|
|
99 break;
|
|
100 }
|
|
101 if (line == null) {
|
|
102 System.out.println("-- No debuggee VM options found in file " +
|
|
103 wholePath);
|
|
104 break;
|
|
105 }
|
|
106 line = line.trim();
|
|
107 if (line.length() != 0 && !line.startsWith("#")) {
|
|
108 System.out.println("-- Added debuggeeVM options from file " +
|
|
109 wholePath + ": " + line);
|
|
110 retVal = line;
|
|
111 break;
|
|
112 }
|
|
113 // Else, read he next line.
|
|
114 }
|
|
115 try {
|
|
116 reader.close();
|
|
117 } catch (IOException ee) {
|
|
118 }
|
|
119 return retVal;
|
|
120 }
|
|
121
|
|
122 private Connector findConnector(String name) {
|
|
123 List connectors = Bootstrap.virtualMachineManager().allConnectors();
|
|
124 Iterator iter = connectors.iterator();
|
|
125 while (iter.hasNext()) {
|
|
126 Connector connector = (Connector)iter.next();
|
|
127 if (connector.name().equals(name)) {
|
|
128 return connector;
|
|
129 }
|
|
130 }
|
|
131 return null;
|
|
132 }
|
|
133
|
|
134 private Map parseConnectorArgs(Connector connector, String argString) {
|
|
135 StringTokenizer tokenizer = new StringTokenizer(argString, ",");
|
|
136 Map arguments = connector.defaultArguments();
|
|
137
|
|
138 while (tokenizer.hasMoreTokens()) {
|
|
139 String token = tokenizer.nextToken();
|
|
140 int index = token.indexOf('=');
|
|
141 if (index == -1) {
|
|
142 throw new IllegalArgumentException("Illegal connector argument: " +
|
|
143 token);
|
|
144 }
|
|
145 String name = token.substring(0, index);
|
|
146 String value = token.substring(index + 1);
|
|
147 Connector.Argument argument = (Connector.Argument)arguments.get(name);
|
|
148 if (argument == null) {
|
|
149 throw new IllegalArgumentException("Argument " + name +
|
|
150 "is not defined for connector: " +
|
|
151 connector.name());
|
|
152 }
|
|
153 argument.setValue(value);
|
|
154 }
|
|
155 return arguments;
|
|
156 }
|
|
157
|
|
158 VMConnection(String connectSpec, int traceFlags) {
|
|
159 String nameString;
|
|
160 String argString;
|
|
161 int index = connectSpec.indexOf(':');
|
|
162 if (index == -1) {
|
|
163 nameString = connectSpec;
|
|
164 argString = "";
|
|
165 } else {
|
|
166 nameString = connectSpec.substring(0, index);
|
|
167 argString = connectSpec.substring(index + 1);
|
|
168 }
|
|
169
|
|
170 connector = findConnector(nameString);
|
|
171 if (connector == null) {
|
|
172 throw new IllegalArgumentException("No connector named: " +
|
|
173 nameString);
|
|
174 }
|
|
175
|
|
176 connectorArgs = parseConnectorArgs(connector, argString);
|
|
177 this.traceFlags = traceFlags;
|
|
178 }
|
|
179
|
|
180 synchronized VirtualMachine open() {
|
|
181 if (connector instanceof LaunchingConnector) {
|
|
182 vm = launchTarget();
|
|
183 } else if (connector instanceof AttachingConnector) {
|
|
184 vm = attachTarget();
|
|
185 } else if (connector instanceof ListeningConnector) {
|
|
186 vm = listenTarget();
|
|
187 } else {
|
|
188 throw new InternalError("Invalid connect type");
|
|
189 }
|
|
190 vm.setDebugTraceMode(traceFlags);
|
|
191 System.out.println("JVM version:" + vm.version());
|
|
192 System.out.println("JDI version: " + Bootstrap.virtualMachineManager().majorInterfaceVersion() +
|
|
193 "." + Bootstrap.virtualMachineManager().minorInterfaceVersion());
|
|
194 System.out.println("JVM description: " + vm.description());
|
|
195
|
|
196 return vm;
|
|
197 }
|
|
198
|
|
199 boolean setConnectorArg(String name, String value) {
|
|
200 /*
|
|
201 * Too late if the connection already made
|
|
202 */
|
|
203 if (vm != null) {
|
|
204 return false;
|
|
205 }
|
|
206
|
|
207 Connector.Argument argument = (Connector.Argument)connectorArgs.get(name);
|
|
208 if (argument == null) {
|
|
209 return false;
|
|
210 }
|
|
211 argument.setValue(value);
|
|
212 return true;
|
|
213 }
|
|
214
|
|
215 String connectorArg(String name) {
|
|
216 Connector.Argument argument = (Connector.Argument)connectorArgs.get(name);
|
|
217 if (argument == null) {
|
|
218 return "";
|
|
219 }
|
|
220 return argument.value();
|
|
221 }
|
|
222
|
|
223 public synchronized VirtualMachine vm() {
|
|
224 if (vm == null) {
|
|
225 throw new InternalError("VM not connected");
|
|
226 } else {
|
|
227 return vm;
|
|
228 }
|
|
229 }
|
|
230
|
|
231 boolean isOpen() {
|
|
232 return (vm != null);
|
|
233 }
|
|
234
|
|
235 boolean isLaunch() {
|
|
236 return (connector instanceof LaunchingConnector);
|
|
237 }
|
|
238
|
|
239 Connector connector() {
|
|
240 return connector;
|
|
241 }
|
|
242
|
|
243 boolean isListen() {
|
|
244 return (connector instanceof ListeningConnector);
|
|
245 }
|
|
246
|
|
247 boolean isAttach() {
|
|
248 return (connector instanceof AttachingConnector);
|
|
249 }
|
|
250
|
|
251 private synchronized void notifyOutputComplete() {
|
|
252 outputCompleteCount++;
|
|
253 notifyAll();
|
|
254 }
|
|
255
|
|
256 private synchronized void waitOutputComplete() {
|
|
257 // Wait for stderr and stdout
|
|
258 if (process != null) {
|
|
259 while (outputCompleteCount < 2) {
|
|
260 try {wait();} catch (InterruptedException e) {}
|
|
261 }
|
|
262 }
|
|
263 }
|
|
264
|
|
265 public void disposeVM() {
|
|
266 try {
|
|
267 if (vm != null) {
|
|
268 vm.dispose();
|
|
269 vm = null;
|
|
270 }
|
|
271 } finally {
|
|
272 if (process != null) {
|
|
273 process.destroy();
|
|
274 process = null;
|
|
275 }
|
|
276 waitOutputComplete();
|
|
277 }
|
|
278 }
|
|
279
|
|
280 private void dumpStream(InputStream stream) throws IOException {
|
|
281 PrintStream outStream = System.out;
|
|
282 BufferedReader in =
|
|
283 new BufferedReader(new InputStreamReader(stream));
|
|
284 String line;
|
|
285 while ((line = in.readLine()) != null) {
|
|
286 outStream.println(line);
|
|
287 }
|
|
288 }
|
|
289
|
|
290 /**
|
|
291 * Create a Thread that will retrieve and display any output.
|
|
292 * Needs to be high priority, else debugger may exit before
|
|
293 * it can be displayed.
|
|
294 */
|
|
295 private void displayRemoteOutput(final InputStream stream) {
|
|
296 Thread thr = new Thread("output reader") {
|
|
297 public void run() {
|
|
298 try {
|
|
299 dumpStream(stream);
|
|
300 } catch (IOException ex) {
|
|
301 System.err.println("IOException reading output of child java interpreter:"
|
|
302 + ex.getMessage());
|
|
303 } finally {
|
|
304 notifyOutputComplete();
|
|
305 }
|
|
306 }
|
|
307 };
|
|
308 thr.setPriority(Thread.MAX_PRIORITY-1);
|
|
309 thr.start();
|
|
310 }
|
|
311
|
|
312 private void dumpFailedLaunchInfo(Process process) {
|
|
313 try {
|
|
314 dumpStream(process.getErrorStream());
|
|
315 dumpStream(process.getInputStream());
|
|
316 } catch (IOException e) {
|
|
317 System.err.println("Unable to display process output: " +
|
|
318 e.getMessage());
|
|
319 }
|
|
320 }
|
|
321
|
|
322 /* launch child target vm */
|
|
323 private VirtualMachine launchTarget() {
|
|
324 LaunchingConnector launcher = (LaunchingConnector)connector;
|
|
325 try {
|
|
326 VirtualMachine vm = launcher.launch(connectorArgs);
|
|
327 process = vm.process();
|
|
328 displayRemoteOutput(process.getErrorStream());
|
|
329 displayRemoteOutput(process.getInputStream());
|
|
330 return vm;
|
|
331 } catch (IOException ioe) {
|
|
332 ioe.printStackTrace();
|
|
333 System.err.println("\n Unable to launch target VM.");
|
|
334 } catch (IllegalConnectorArgumentsException icae) {
|
|
335 icae.printStackTrace();
|
|
336 System.err.println("\n Internal debugger error.");
|
|
337 } catch (VMStartException vmse) {
|
|
338 System.err.println(vmse.getMessage() + "\n");
|
|
339 dumpFailedLaunchInfo(vmse.process());
|
|
340 System.err.println("\n Target VM failed to initialize.");
|
|
341 }
|
|
342 return null; // Shuts up the compiler
|
|
343 }
|
|
344
|
|
345 /* attach to running target vm */
|
|
346 private VirtualMachine attachTarget() {
|
|
347 AttachingConnector attacher = (AttachingConnector)connector;
|
|
348 try {
|
|
349 return attacher.attach(connectorArgs);
|
|
350 } catch (IOException ioe) {
|
|
351 ioe.printStackTrace();
|
|
352 System.err.println("\n Unable to attach to target VM.");
|
|
353 } catch (IllegalConnectorArgumentsException icae) {
|
|
354 icae.printStackTrace();
|
|
355 System.err.println("\n Internal debugger error.");
|
|
356 }
|
|
357 return null; // Shuts up the compiler
|
|
358 }
|
|
359
|
|
360 /* listen for connection from target vm */
|
|
361 private VirtualMachine listenTarget() {
|
|
362 ListeningConnector listener = (ListeningConnector)connector;
|
|
363 try {
|
|
364 String retAddress = listener.startListening(connectorArgs);
|
|
365 System.out.println("Listening at address: " + retAddress);
|
|
366 vm = listener.accept(connectorArgs);
|
|
367 listener.stopListening(connectorArgs);
|
|
368 return vm;
|
|
369 } catch (IOException ioe) {
|
|
370 ioe.printStackTrace();
|
|
371 System.err.println("\n Unable to attach to target VM.");
|
|
372 } catch (IllegalConnectorArgumentsException icae) {
|
|
373 icae.printStackTrace();
|
|
374 System.err.println("\n Internal debugger error.");
|
|
375 }
|
|
376 return null; // Shuts up the compiler
|
|
377 }
|
|
378 }
|