Back to index...

	/*
	* Copyright (c) 2001, 2011, 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. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* 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.
	*/

	/*
	* This source code is provided to illustrate the usage of a given feature
	* or technique and has been deliberately simplified. Additional steps
	* required for a production-quality application, such as security checks,
	* input validation and proper error handling, might not be present in
	* this sample code.
	*/


	package com.sun.tools.example.trace;

	import com.sun.jdi.VirtualMachine;
	import com.sun.jdi.Bootstrap;
	import com.sun.jdi.connect.*;

	import java.util.Map;
	import java.util.List;

	import java.io.PrintWriter;
	import java.io.FileWriter;
	import java.io.IOException;

	/**
	* This program traces the execution of another program.
	* See "java Trace -help".
	* It is a simple example of the use of the Java Debug Interface.
	*
	* @author Robert Field
	*/
	public class Trace {

	// Running remote VM
	private final VirtualMachine vm;

	// Thread transferring remote error stream to our error stream
	private Thread errThread = null;

	// Thread transferring remote output stream to our output stream
	private Thread outThread = null;

	// Mode for tracing the Trace program (default= 0 off)
	private int debugTraceMode = 0;

	// Do we want to watch assignments to fields
	private boolean watchFields = false;

	// Class patterns for which we don't want events
	private String[] excludes = {"java.", "javax.", "sun.*",
	"com.sun.*"};

	/**
	* main
	*/
	public static void main(String[] args) {
	new Trace(args);
	}

	/**
	* Parse the command line arguments.
	* Launch target VM.
	* Generate the trace.
	*/
	Trace(String[] args) {
	PrintWriter writer = new PrintWriter(System.out);
	int inx;
	for (inx = 0; inx < args.length; ++inx) {
	String arg = args[inx];
	if (arg.charAt(0) != '-') {
	break;
	}
	if (arg.equals("-output")) {
	try {
	writer = new PrintWriter(new FileWriter(args[++inx]));
	} catch (IOException exc) {
	System.err.println("Cannot open output file: " + args[inx]
	+ " - " + exc);
	System.exit(1);
	}
	} else if (arg.equals("-all")) {
	excludes = new String[0];
	} else if (arg.equals("-fields")) {
	watchFields = true;
	} else if (arg.equals("-dbgtrace")) {
	debugTraceMode = Integer.parseInt(args[++inx]);
	} else if (arg.equals("-help")) {
	usage();
	System.exit(0);
	} else {
	System.err.println("No option: " + arg);
	usage();
	System.exit(1);
	}
	}
	if (inx >= args.length) {
	System.err.println("<class> missing");
	usage();
	System.exit(1);
	}
	StringBuffer sb = new StringBuffer();
	sb.append(args[inx]);
	for (++inx; inx < args.length; ++inx) {
	sb.append(' ');
	sb.append(args[inx]);
	}
	vm = launchTarget(sb.toString());
	generateTrace(writer);
	}


	/**
	* Generate the trace.
	* Enable events, start thread to display events,
	* start threads to forward remote error and output streams,
	* resume the remote VM, wait for the final event, and shutdown.
	*/
	void generateTrace(PrintWriter writer) {
	vm.setDebugTraceMode(debugTraceMode);
	EventThread eventThread = new EventThread(vm, excludes, writer);
	eventThread.setEventRequests(watchFields);
	eventThread.start();
	redirectOutput();
	vm.resume();

	// Shutdown begins when event thread terminates
	try {
	eventThread.join();
	errThread.join(); // Make sure output is forwarded
	outThread.join(); // before we exit
	} catch (InterruptedException exc) {
	// we don't interrupt
	}
	writer.close();
	}

	/**
	* Launch target VM.
	* Forward target's output and error.
	*/
	VirtualMachine launchTarget(String mainArgs) {
	LaunchingConnector connector = findLaunchingConnector();
	Map<String, Connector.Argument> arguments =
	connectorArguments(connector, mainArgs);
	try {
	return connector.launch(arguments);
	} catch (IOException exc) {
	throw new Error("Unable to launch target VM: " + exc);
	} catch (IllegalConnectorArgumentsException exc) {
	throw new Error("Internal error: " + exc);
	} catch (VMStartException exc) {
	throw new Error("Target VM failed to initialize: " +
	exc.getMessage());
	}
	}

	void redirectOutput() {
	Process process = vm.process();

	// Copy target's output and error to our output and error.
	errThread = new StreamRedirectThread("error reader",
	process.getErrorStream(),
	System.err);
	outThread = new StreamRedirectThread("output reader",
	process.getInputStream(),
	System.out);
	errThread.start();
	outThread.start();
	}

	/**
	* Find a com.sun.jdi.CommandLineLaunch connector
	*/
	LaunchingConnector findLaunchingConnector() {
	List<Connector> connectors = Bootstrap.virtualMachineManager().allConnectors();
	for (Connector connector : connectors) {
	if (connector.name().equals("com.sun.jdi.CommandLineLaunch")) {
	return (LaunchingConnector)connector;
	}
	}
	throw new Error("No launching connector");
	}

	/**
	* Return the launching connector's arguments.
	*/
	Map<String, Connector.Argument> connectorArguments(LaunchingConnector connector, String mainArgs) {
	Map<String, Connector.Argument> arguments = connector.defaultArguments();
	Connector.Argument mainArg =
	(Connector.Argument)arguments.get("main");
	if (mainArg == null) {
	throw new Error("Bad launching connector");
	}
	mainArg.setValue(mainArgs);

	if (watchFields) {
	// We need a VM that supports watchpoints
	Connector.Argument optionArg =
	(Connector.Argument)arguments.get("options");
	if (optionArg == null) {
	throw new Error("Bad launching connector");
	}
	optionArg.setValue("-classic");
	}
	return arguments;
	}

	/**
	* Print command line usage help
	*/
	void usage() {
	System.err.println("Usage: java Trace <options> <class> <args>");
	System.err.println("<options> are:");
	System.err.println(
	" -output <filename> Output trace to <filename>");
	System.err.println(
	" -all Include system classes in output");
	System.err.println(
	" -help Print this help message");
	System.err.println("<class> is the program to trace");
	System.err.println("<args> are the arguments to <class>");
	}
	}

Back to index...