Mercurial > hg > truffle
annotate agent/test/jdi/VMConnection.java @ 4862:f457154eee8b
7140882: Don't return booleans from methods returning pointers
Summary: Changed "return false" to "return NULL"
Reviewed-by: dholmes, rottenha
Contributed-by: dbhole@redhat.com
author | brutisso |
---|---|
date | Mon, 30 Jan 2012 12:36:49 +0100 |
parents | c18cbe5936b8 |
children |
rev | line source |
---|---|
0 | 1 /* |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
2 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved. |
0 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * questions. |
0 | 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 } |