* The following items are discussed below: *
* * ** the simplest invocation of the tool would be: ** java -Djava.security.policy=my_policy \ * -jar install_dir/lib/start.jar mystart.config *
* Note that the entire command line, including the* java -jar install_dir/lib/envcheck.jar \ * java -Djava.security.policy=my_policy \ * -jar install_dir/lib/start.jar mystart.config *
java command,
* is supplied as arguments to the tool. The java command used to
* run the tool may be different than the java command invoked by
* the command line under test. The first token in the command line being
* analyzed must not begin with a '-' and must end with the string "java".
*
*
* *
-traces
* *
-explain
* -explain
* option is a hint that may result in the generation of additional output
* describing the purpose and context of the check. An explanation is output
* the first time its associated message is output, and is not repeated. It
* is the responsibility of the individual plugin implementation to honor
* this option.
* *
-level info|warning|error
* *
localhost in a codebase annotation.
* java.util.logging.config.file system property.
* * This option is used to set the level at which message records are * generated. The default value is warning. *
*
-plugin file
* META-INF/services/com.sun.jini.tool.envcheck.Plugin, which
* contains the class names of the plugins to run listed one per line.
* Every class listed must implement the
* com.sun.jini.tool.envcheck.Plugin interface. This option
* may be supplied zero or more times.
* *
-security
* isPlugOption method of the
* Plugin interface.
* main method:
* *
* In this case, the tool is limited to performing validity checks on the * classpath, policy, and codebase values identified by the system properties * and options provided on the service command line. The* java -jar install_dir/lib/envcheck.jar -level info -explain -traces \ * java -cp mylib_dir/myservice.jar:/jini/lib/jsk-platform.jar \ * -Djava.security.policy=my_policy \ * -Djava.server.rmi.codebase=http://myhost/myservice-dl.jar \ * myservice.MyServiceImpl *
-level,
* -explain, and -traces options supplied will result
* in the most verbose output possible from the tool.
* * The following example will analyze a command line used to start reggie using * the service starter. The command being analyzed uses a policy and service * starter configuration located in the working directory: *
*
* The tool can perform many more checks in this case because the * bundled plugins include built-in knowledge about the service starter * and its public configuration entries. The tool options used will minimize * the output produced by the tool. ** java -jar install_dir/lib/envcheck.jar -level error \ * java -Djava.security.policy=my_starterpolicy \ * -jar install_dir/lib/start.jar reggie.config *
* If the command line being analyzed invokes the service starter, the tool will
* create a Configuration from the arguments of the command line
* being analyzed. Failure to create the Configuration will result
* in termination of the tool, otherwise the
* com.sun.jini.start.ServiceDescriptors provided by the
* Configuration are examined. The following checks are done for
* each ServiceDescriptor:
*
getPolicy method returns a reference to a
* policy file that is valid and accessible
* AllPermissions to all
* protection domains
* NonActivatableServiceDescriptor and each
* SharedActivatableServiceDescriptor
* getServerConfigArgs does not return
* null or an empty array
* Configuration can be constructed from those
* args
* Configuration named
* initialLookupGroups does not have a value of
* ALL_GROUPS
* -security option was specified:
* javax.net.ssl.trustStore is defined and
* that the trust store it references is accessible
* com.sun.jini.discovery.x500.trustStore
* is defined, and if so that the trust store it references is
* accessible
* javax.net.ssl.keyStore is defined, and
* if so that the key store it references is accessible
* SharedActivatableServiceDescriptor:
* Configuration named
* persistenceDirectory refers to either an empty directory
* or a non-existant directory
* SharedActivationGroupDescriptor:
* jsk-policy.jar is loaded from the extensions
* directory
*
* jsk-platform.jar is in the classpath
*
*
* java.util.logging.config.file is defined in the
* properties returned by calling getServerProperties then
* verify that the file it references is accessible
* java.rmi.server.codebase
* java.security.policy
* jsk-policy being loaded by the extension
* class loader
* jsk-platform in the classpath
* -security was specified
* ServiceDescriptors obtained from the starter config */
private ServiceDescriptor[] descriptors = new ServiceDescriptor[0];
/** the localization resource bundle */
private static ResourceBundle bundle;
/** the java command on the command line being checked */
private String javaCmd;
/** the options on the command line being checked (never null) */
String[] options = new String[0];
/** the properties on the command line being checked (never null) */
Properties properties = new Properties();
/** the classpath on the command line being checked */
String classpath = null;
/** the main class on the command line being checked */
String mainClass = null;
/** the executable JAR file on the command line being checked */
String jarToRun = null;
/** the list of plugins supplied via the -plugin option */
static ArrayList pluginJarList = new ArrayList();
/** the class loader for loading plugins */
ClassLoader pluginLoader = EnvCheck.class.getClassLoader();
/** the classpath of the tool, including the plugins (updated in run) */
static String combinedClasspath = System.getProperty("java.class.path");
/**
* The entry point for the tool. The localization resource bundle is
* located, the plugins are loaded, and the checks are performed. The system
* property java.protocol.handler.pkgs for the tool VM is set
* to net.jini.url to ensure that the tool can manipulate
* HTTPMD URLs.
*
* @param args the command line arguments
*/
public static void main(String[] args) {
System.setProperty("java.protocol.handler.pkgs", "net.jini.url");
bundle = Util.getResourceBundle(EnvCheck.class);
if (args.length == 0) {
usage();
System.exit(1);
}
findPlugins(args);
new EnvCheck().run(args);
}
/**
* Output the usage message.
*/
private static void usage(){
System.err.println(Util.getString("envcheck.usage", bundle));
}
/**
* Helper to print a localized string
*
* @param key the resource key
*/
private String getString(String key) {
return Util.getString(key, bundle);
}
/**
* Helper to print a localized string
*
* @param key the resource key
* @param val the value parameter expected by the message
*/
private String getString(String key, String val) {
return Util.getString(key, bundle, val);
}
/**
* Search the command line for user supplied plugin definitions
* and place them in the internal plugin list.
*
* @param cmdLine the original command line args
*/
private static void findPlugins(String[] cmdLine) {
int index = 0;
String arg;
while ((arg = cmdLine[index++]).startsWith("-")) {
if (arg.equals("-plugin")) {
String pluginName = cmdLine[index++];
if (!(new File(pluginName).exists())) {
System.err.println(Util.getString("envcheck.noplugin",
bundle,
pluginName));
System.exit(1);
}
combinedClasspath += File.pathSeparator + pluginName;
try {
pluginJarList.add(new URL("file:" + pluginName));
} catch (MalformedURLException e) { // should never happen
e.printStackTrace();
System.exit(1);
}
} else if (arg.equals("-level")) {
index++;
}
}
}
/**
* Parse the command line, identifying options for the tool and parsing
* the VM, system properties, options, JAR/main class and arguments
* for the command line being tested. The -plugin option
* is ignored by this parser since they must have been processed
* earlier.
*
* @param cmdLine the original command line arguments
*/
private void parseArgs(String[] cmdLine) {
int index = 0;
try {
while (true) {
String arg = cmdLine[index++];
if (arg.equals("-traces")) {
printStackTraces = true;
Reporter.setPrintTraces(true);
} else if (arg.equals("-explain")) {
Reporter.setExplanation(true);
} else if (arg.equals("-level")) {
String val = cmdLine[index++];
if (val.equals("info")) {
Reporter.setLevel(Reporter.INFO);
} else if (val.equals("warning")) {
Reporter.setLevel(Reporter.WARNING);
} else if (val.equals("error")) {
Reporter.setLevel(Reporter.ERROR);
} else {
System.err.println(getString("envcheck.badlevel"));
usage();
System.exit(1);
}
} else if (arg.equals("-plugin")) {
index++; // already processed the plugin
} else if (isPluginOption(arg)) { //no additional work to do
} else if (arg.startsWith("-")) {
System.err.println(getString("envcheck.illegalopt", arg));
usage();
System.exit(1);
} else if (arg.endsWith("java")) {
javaCmd = arg;
break;
} else {
System.err.println(getString("envcheck.nojavacmd"));
usage();
System.exit(1);
}
}
} catch (ArrayIndexOutOfBoundsException e) {
System.err.println(getString("envcheck.nocmdargs"));
usage();
System.exit(1);
}
try {
ArrayList optList = new ArrayList();
while (true) {
String opt = cmdLine[index++];
if (!opt.startsWith("-")) {
mainClass = opt;
break;
} else if (opt.startsWith("-D")) {
int valueIndex = opt.indexOf("=");
String key = opt.substring(2, valueIndex);
String value = opt.substring(valueIndex + 1);
properties.put(key, value);
} else if (opt.equals("-cp") || opt.equals("-classpath")) {
classpath = cmdLine[index++];
} else if (opt.equals("-jar")) {
jarToRun = cmdLine[index++];
break;
} else {
optList.add(opt);
}
}
options =
(String[]) optList.toArray(new String[optList.size()]);
} catch (ArrayIndexOutOfBoundsException e) {
System.err.println(getString("noexecutable"));
usage();
System.exit(1);
}
ArrayList argList = new ArrayList();
while (index < cmdLine.length) {
argList.add(cmdLine[index++]);
}
args = (String[]) argList.toArray(new String[argList.size()]);
}
/**
* Return the ServiceDescriptors contained in the service
* starter configuration. If the command being analyzed does not invoke the
* service starter, a zero-length array will be returned.
*
* @return the descriptors in the starter configuration or an empty array
*/
public ServiceDescriptor[] getDescriptors() {
return descriptors;
}
/**
* Return the SharedActivationGroupDescriptor contained in the
* service starter configuration. Returns null if there is no
* such descriptor, or if the command being analyzed does not invoke the
* service starter.
*
* @return the SharedActivationGroupDescriptor or
* null
*/
public SharedActivationGroupDescriptor getGroupDescriptor() {
for (int i = 0; i < descriptors.length; i++) {
if (descriptors[i] instanceof SharedActivationGroupDescriptor) {
return (SharedActivationGroupDescriptor) descriptors[i];
}
}
return null;
}
/**
* Perform the runtime checks. If any user plugins were supplied, construct
* a class loader capable of loading them and modify
* combinedClasspath to make the classes available to subtasks.
* Load the plugins and parse the command line. The plugins must be
* available to the parser so that plugin specific options can be checked
* for. Load the service starter configuration if the service starter is
* being invoked. Execute all of the plugin classes in the order loaded.
*
* @param cmdLine the original command line arguments
*/
private void run(String[] cmdLine) {
if (pluginJarList.size() > 0) {
URL[] urls =
(URL[]) pluginJarList.toArray(new URL[pluginJarList.size()]);
pluginLoader = new URLClassLoader(urls, pluginLoader);
}
loadPlugins();
parseArgs(cmdLine);
if (jarToRun == null && classpath == null) {
System.err.println(getString("envcheck.missingclasspath"));
System.exit(1);
}
loadConfiguration();
Iterator plugins = pluginList.iterator();
while (plugins.hasNext()) {
Plugin plugin = (Plugin) plugins.next();
try {
plugin.run(this);
} catch (SecurityException e) { // limp on if permission check fails
e.printStackTrace();
}
}
int warningCount = Reporter.getWarningCount();
int errorCount = Reporter.getErrorCount();
if ((warningCount + errorCount) > 0) {
System.out.println();
System.out.println();
System.out.println(getString("envcheck.summaryseparator"));
}
if (warningCount > 0) {
System.out.println(getString("envcheck.warningheader")
+ warningCount);
}
if (errorCount > 0) {
System.out.println(getString("envcheck.errorheader") + errorCount);
}
}
/**
* Check whether arg is a plugin specific option. The
* isPluginOption method of every plugin is called in
* case an option is shared among multiple plugins.
*
* @param arg the argument to check
* @return true if any plugin's isPluginOption
* method returns true
*/
private boolean isPluginOption(String arg) {
boolean gotOne = false;
Iterator plugins = pluginList.iterator();
while (plugins.hasNext()) {
Plugin plugin = (Plugin) plugins.next();
if (plugin.isPluginOption(arg)) {
gotOne = true;
}
}
return gotOne;
}
/**
* Instantiate the service starter configuration if the command line being
* analyzed runs the service starter. This is assumed to be true if the
* command line specified an executable JAR file named start.jar and
* if that file resides in the same directory as a file named
* jsk-platform.jar. Extract and save all of the service
* descriptors and service destructors from the configuration. If a
* ConfigurationException is thrown the tool will exit. If
* there are no ServiceDescriptor or
* ServiceDestructor entries supplied by the configuration a
* error is generated and a normal return is done. The instantiation of
* the configuration is done in a child process using the VM, properties,
* options and arguments supplied in the command line under test.
*/
private void loadConfiguration() {
if (jarToRun != null) {
if (!jarToRun.endsWith("start.jar")) {
return;
}
//XXX do existence check in parser
File starterFile = new File(jarToRun);
File jskLibDir = starterFile.getParentFile();
File jskplatform = new File(jskLibDir, "jsk-platform.jar");
if (!jskplatform.exists()) {
return; // presumably a user file coincidentally named start.jar
}
} else {
if (!mainClass.equals("com.sun.jini.start.ServiceStarter")) {
return;
}
}
//XXX need to check validity of javaCmd and arg list length
Object lobj =
launch("com.sun.jini.tool.envcheck.EnvCheck$GetDescriptors", args);
if (lobj instanceof ServiceDescriptor[]) {
descriptors = (ServiceDescriptor[]) lobj;
if (descriptors.length == 0) {
Reporter.print(new Message(Reporter.ERROR,
getString("envcheck.emptyconfig"),
null));
}
} else if (lobj instanceof ConfigurationException) {
System.err.println(getString("envcheck.ssdescfailed"));
((Throwable) lobj).printStackTrace();
System.exit(1);
} else {
System.err.println(getString("envcheck.subtaskex", lobj.toString()));
((Throwable) lobj).printStackTrace();
System.exit(1);
}
}
/**
* Load the plugin classes. All of the resources named
* META-INF/services/com.sun.jini.tool.envcheck.Plugin are
* read; each such resource is expected to contain a list of plugin class
* names, one per line (white space is trimmed). The corresponding classes
* are loaded and saved. Any other exceptions thrown while processing
* the plugin JAR files will cause the tool to exit.
*/
private void loadPlugins() {
Package pkg = getClass().getPackage();
String pkgName = "";
if (pkg != null) {
pkgName = pkg.getName();
}
pkgName = pkgName.replace('.', '/');
if (pkgName.length() > 0) {
pkgName += "/";
}
Iterator plugins =
Service.providers(com.sun.jini.tool.envcheck.Plugin.class,
pluginLoader);
while (plugins.hasNext()) {
pluginList.add(plugins.next());
}
}
/**
* Get the command line arguments of the command being analyzed.
*
* @return the args
*/
// unused, but supplied to support user developed plugins
public String[] getArgs() {
return args;
}
/**
* Return the flag indicating whether to output stack traces that
* result from a check.
*/
public boolean printStacks() {
return printStackTraces;
}
/**
* Launch a child VM using the java command, properties, and
* options supplied on the command line being analyzed. If an executable JAR
* file was specified, the classpath of the child VM consists of the JAR
* file name augmented with the classpath of the tool and plugins. If a main
* class was specified, the classpath of the child VM consists of the
* -cp/-classpath option value of the command line being
* analyzed augmented with the classpath of the tool and plugins.
*
* @param task the class name of the task to launch, which must implement
* the SubVMTask interface
* @param args the arguments to pass to the main method of the task
* @return the result or exception returned by the subtask supplied as a
* serialized object written on the subtask's
* System.out stream.
*/
public Object launch(String task, String[] args) {
String cp;
if (jarToRun != null) {
cp = jarToRun + File.pathSeparator;
} else {
cp = classpath + File.pathSeparator;
}
cp += combinedClasspath;
String[] opts = new String[options.length + 2];
opts[0] = "-cp";
opts[1] = cp;
System.arraycopy(options, 0, opts, 2, options.length);
if (args == null) {
args = new String[0];
}
String[] subvmArgs = new String[args.length + 1];
subvmArgs[0] = task;
System.arraycopy(args, 0, subvmArgs, 1, args.length);
return launch(javaCmd, properties, opts, subvmArgs);
}
/**
* Launch a child VM using the java command, properties, and
* options supplied on the command line. If an executable JAR file was
* specified, the classpath of the child VM consists of the JAR file name
* augmented with the classpath of the tool and plugins. If a main class was
* specified, the classpath of the child VM consists of the
* -cp/-classpath option value of the command line being
* analyzed augmented with the classpath of the tool and plugins.
*
* @param task the class name of the task to launch, which must implement
* the SubVMTask interface
* @return the result or exception returned by the subtask supplied as a
* serialized object written on the subtask's
* System.out stream.
*/
public Object launch(String task) {
return launch(task, null);
}
/**
* Return a property value that was specified on the command line being
* analyzed. Only properties explicitly defined on the command line will
* resolve to a value.
*
* @param key the name of the property
* @return the property value, or null if undefined
*/
public String getProperty(String key) {
return properties.getProperty(key);
}
/**
* Return a copy of the properties that were specified on the
* command line being analyzed. The caller may modify the returned
* properties object.
*
* @return the properties, which may be empty
*/
public Properties getProperties() {
return (Properties) properties.clone();
}
/**
* Launch a subtask VM using the java command given by
* javaCmd. If javaCmd is null, the
* command to run is derived from the value of the java.home
* property of the tool VM. The first value in args must name
* a class that implements the SubVMTask interface. The
* props and opts arrays must contain fully
* formatted command line values for properties and options
* (i.e. "-Dfoo=bar" or "-opt"). opts must include a
* -cp or -classpath option and its value must
* completely specify the classpath required to run the subtask.
*
* @param javaCmd the java command to execute, or
* null to create another instance of the
* tool VM
* @param props properties to define, which may be null or
* empty
* @param opts options to define, which must include a classpath
* definition
* @param args arguments to pass to the child VM
* @return the result or exception returned by the subtask supplied
* as a serialized object written on the subtask's
* System.out stream.
*
* @throws IllegalArgumentException if opts does not
* include a classpath definition, or if args[0]
* does not contain the name of a class that implements
* SubVMTask
*/
public Object launch(String javaCmd,
Properties props,
String[] opts,
String[] args)
{
if (args == null || args.length == 0) {
throw new IllegalArgumentException("No class name in args[0]");
}
// make sure subtask is valid to avoid obscure failures at exec time
String taskName = args[0];
try {
Class taskClass = Class.forName(taskName, true, pluginLoader);
if (!SubVMTask.class.isAssignableFrom(taskClass)) {
throw new IllegalArgumentException(taskName
+ " does not implement "
+ "SubVMTask");
}
// make sure inner classes are static
if (taskClass.getDeclaringClass() != null) {
if ((taskClass.getModifiers() & Modifier.STATIC) == 0) {
throw new IllegalArgumentException(taskName
+ " must be a static class");
}
}
} catch (ClassNotFoundException e) {
throw new IllegalArgumentException("Class not found: " + taskName);
}
if (javaCmd == null) {
javaCmd = System.getProperty("java.home");
javaCmd += File.separator + "bin" + File.separator + "java";
}
ArrayList cmdList = new ArrayList();
cmdList.add(javaCmd);
boolean gotClasspath = false;
if (opts != null) {
for (int i = 0; i < opts.length; i++) {
if (opts[i].equals("-cp") || opts[i].equals("-classpath"))
if (i + 1 == opts.length) {
throw new IllegalArgumentException("classpath option "
+ "does not have "
+ "a value");
}
gotClasspath = true;
cmdList.add(opts[i]);
}
}
if (!gotClasspath) {
throw new IllegalArgumentException("no classpath defined");
}
if (props != null) {
Enumeration en = props.propertyNames();
while (en.hasMoreElements()) {
String key = (String) en.nextElement();
String value = props.getProperty(key);
cmdList.add("-D" + key + "=" + value);
}
}
cmdList.add("com.sun.jini.tool.envcheck.SubVM");
for (int i = 0; i < args.length; i++) {
cmdList.add(args[i]);
}
try {
String[] argList =
(String[]) cmdList.toArray(new String[cmdList.size()]);
// for (int i = 0; i < argList.length; i++) {
// System.out.print(argList[i] + " ");
// }
// System.out.println();
Process p = Runtime.getRuntime().exec(argList);
Pipe pipe = new Pipe("errorPipe",
p.getErrorStream(),
System.err,
"Child VM: ");
ObjectInputStream s = new ObjectInputStream(p.getInputStream());
Object o = s.readObject();
pipe.waitTillEmpty(5000);
return o;
} catch (Exception e) {
return e;
}
}
/**
* Launch a subtask using the environment defined by the given service
* descriptors. Calling this method is equivalent to calling
* launch(d, g, taskName, null).
*
* @param d the services descriptor, which may be null
* @param gd the group descriptor, which may be nullSystem.out stream.
*/
public Object launch(NonActivatableServiceDescriptor d,
SharedActivationGroupDescriptor gd,
String taskName)
{
return launch(d, gd, taskName, null);
}
/**
* Launch a subtask using the environment defined by the given service
* descriptors.
*
* If d and gd are both null, then
* calling this method is equivalent to calling
* launch(taskName, args).
*
* If d is null and gd is
* non-null then the properties are taken from
* gd.getServerProperties() and the
* java.security.policy property is added or replaced with the
* value of gd.getPolicy(). The options are taken from
* gd.getServerOptions(), but any -cp/-classpath
* option is discarded; a -cp option is added that is the value
* of gd.getClasspath() augmented with the classpath of the
* tool and plugins. If gd.getServerCommand() is
* non-null, its value is used to invoke the child VM;
* otherwise the java command of the command line being
* analyzed is used. The arguments passed to the child VM consist of an
* array whose first element is taskName and whose remaining
* elements are taken from args.
*
* If d is not null, but gd is
* null, then if d is an instance of
* SharedActivatableServiceDescriptor an
* IllegalArgumentException is thrown. Otherwise the properties
* and options are taken from the command line being analyzed. The
* java.security.policy property is added or replaced using the
* value of d.getPolicy(). The -cp/-classpath
* option is replaced with the value of d.getImportCodebase()
* augmented with the classpath of the tool and plugins. The arguments
* passed to the child VM consist of taskName followed by
* args if args is non-null, or
* followed by d.getServerConfigArgs() otherwise. The VM is
* invoked using the java command of the command line being
* analyzed.
*
* if d and gd are both non-null then
* if d is an instance of
* SharedActivatableServiceDescriptor then the properties,
* options, and java command are taken from
* gd.getServerProperties(),
* gd.getServerOptions(), and
* gd.getServerCommand(); however, if the value of
* gd.getServerCommand() is null, the
* java command is taken from the command line being
* analysed. If d is not an instance of
* SharedActivatableServiceDescriptor then the properties,
* options, and java command are taken from the command line
* being analyzed. In all cases the java.security.policy
* property is added or replaced using the value of
* d.getPolicy(). The -cp/-classpath option is
* added or replaced with the value of d.getImportCodebase()
* augmented with the value of the classpath of the tool and plugins. The
* arguments passed to the child VM consist of taskName
* followed by args if args is
* non-null, or followed by
* d.getServerConfigArgs() otherwise.
*
*
* @param d the service descriptor, which may be null
* @param gd the group descriptor, which may be nullnull
* @return the result or exception returned by the subtask supplied as a
* serialized object written on the subtask's
* System.out stream.
*/
public Object launch(NonActivatableServiceDescriptor d,
SharedActivationGroupDescriptor gd,
String taskName,
String[] args)
{
if (d == null && gd == null) {
return launch(taskName, args);
}
//build taskArgs array
if (args == null) {
if (d != null) {
args = d.getServerConfigArgs();
if (args == null || args.length == 0) {
return new IllegalArgumentException("No configuration args "
+ "in descriptor");
}
} else {
args = new String[0];
}
}
String[] taskArgs = new String[args.length + 1];
taskArgs[0] = taskName;
System.arraycopy(args, 0, taskArgs, 1, args.length);
if (d == null && gd != null) {
Properties props = gd.getServerProperties();
props.put("java.security.policy", gd.getPolicy());
ArrayList l = new ArrayList();
String[] opts = gd.getServerOptions();
if (opts != null) {
for (int i = 0; i < opts.length; i++ ) {
if (opts[i].equals("-cp")) {
i++; // bump past value
} else {
l.add(opts[i]);
}
}
}
l.add("-cp");
l.add(gd.getClasspath() + File.pathSeparator + combinedClasspath);
opts = (String[]) l.toArray(new String[l.size()]);
String cmd = gd.getServerCommand();
if (cmd == null) {
cmd = javaCmd;
}
return launch(cmd, props, opts, taskArgs);
} else if (d != null && gd == null) {
if (d instanceof SharedActivatableServiceDescriptor) {
throw new IllegalArgumentException("no group for service");
}
Properties props = getProperties();
props.put("java.security.policy", d.getPolicy());
ArrayList l = new ArrayList();
for (int i = 0; i < options.length; i++ ) {
if (options[i].equals("-cp")
|| options[i].equals("-classpath")) {
i++; // bump past value
} else {
l.add(options[i]);
}
}
l.add("-cp");
l.add(d.getImportCodebase()
+ File.pathSeparator
+ combinedClasspath);
String[] opts = (String[]) l.toArray(new String[l.size()]);
return launch(javaCmd, props, opts, taskArgs);
} else if (d != null && gd != null) {
Properties props = getProperties();
String[] opts = options;
String vm = null;
if (d instanceof SharedActivatableServiceDescriptor) {
props = gd.getServerProperties();
if (props == null) {
props = new Properties();
}
opts = gd.getServerOptions();
vm = gd.getServerCommand();
}
if (vm == null) {
vm = javaCmd;
}
props.put("java.security.policy", d.getPolicy());
ArrayList l = new ArrayList();
if (opts != null) {
for (int i = 0; i < opts.length; i++ ) {
if (opts[i].equals("-cp")
|| opts[i].equals("-classpath")) {
i++; // bump past value
} else {
l.add(opts[i]);
}
}
}
l.add("-cp");
l.add(d.getImportCodebase()
+ File.pathSeparator
+ combinedClasspath);
opts = (String[]) l.toArray(new String[l.size()]);
return launch(vm, props, opts, taskArgs);
} else {
throw new IllegalStateException("Should never get here");
}
}
/**
* Return the java command for the command line being analyzed.
*
* @return the java command
*/
public String getJavaCmd() {
return javaCmd;
}
/**
* Check for the existence of a file identified by a property
* supplied on the command line being analyzed.
*
* @param prop the name of the property
* @param desc a brief description of the file
* @return the property value, or null if undefined
*/
public String checkFile(String prop, String desc) {
String name = getProperty(prop);
if (name == null) {
return getString("util.undef", desc);
}
return Util.checkFileName(name, desc);
}
/**
* Return the name of the executable JAR file supplied on the
* command line being analyzed.
*
* @return the JAR file name, or null if the command line
* did not specify one.
*/
public String getJarToRun() {
return jarToRun;
}
/**
* Get the classpath provided by the command line being analyzed. If
* getJarToRun() returns a non-null value then
* its value is returned. Otherwise the value supplied by the command
* line -cp/-classpath option is returned.
*
* @return the classpath supplied on the command line being analyzed.
*/
public String getClasspath() {
if (jarToRun != null) {
return jarToRun;
}
return classpath;
}
/**
* A subtask which returns the service descriptors and service
* destructors supplied by the service starter configuration constructed
* from args.
*/
static class GetDescriptors implements SubVMTask {
public Object run(String[] args) {
Configuration starterConfig = null;
try {
starterConfig = ConfigurationProvider.getInstance(args);
} catch (ConfigurationException e) {
return e;
}
try {
ServiceDescriptor[] d1 = (ServiceDescriptor[])
starterConfig.getEntry("com.sun.jini.start",
"serviceDescriptors",
ServiceDescriptor[].class,
new ServiceDescriptor[0]);
ServiceDescriptor[] d2 = (ServiceDescriptor[])
starterConfig.getEntry("com.sun.jini.start",
"serviceDestructors",
ServiceDescriptor[].class,
new ServiceDescriptor[0]);
ServiceDescriptor[] descriptors =
new ServiceDescriptor[d1.length + d2.length];
System.arraycopy(d1, 0, descriptors, 0, d1.length);
System.arraycopy(d2, 0, descriptors, d1.length, d2.length);
return descriptors;
} catch (ConfigurationException e) {
return e;
}
}
}
/**
* An I/O redirection pipe. A daemon thread copies data from an input
* stream to an output stream. An optional annotation may be provided
* which will prefix each line of the copied data with a label which
* can be used to identify the source.
*/
private class Pipe implements Runnable {
/** the line separator character */
private final static byte SEPARATOR = (byte) '\n';
/** output line buffer */
private ByteArrayOutputStream bufOut = new ByteArrayOutputStream();
/** the input stream */
private InputStream in;
/** the output PrintStream */
private PrintStream stream;
/** the output stream annotation */
private String annotation;
/** the thread to process the data */
private Thread outThread;
/**
* Create a new Pipe object and start the thread to handle the data.
*
* @param name the name to assign to the thread
* @param in input stream from which pipe input flows
* @param stream the stream to which output will be sent
* @param a the annotation for prepending text to logged lines
*/
Pipe(String name,
InputStream in,
PrintStream stream,
String a)
{
this.in = in;
this.stream = stream;
this.annotation = a;
outThread = new Thread(this, name);
outThread.setDaemon(true);
outThread.start();
}
/**
* Wait until the run method terminates due to reading EOF on input
*
* @param timeout max time to wait for the thread to terminate
*/
void waitTillEmpty(int timeout) {
try {
outThread.join(timeout);
} catch (InterruptedException ignore) {
}
}
/**
* Read and write data until EOF is detected. Flush any remaining data to
* the output steam and return, terminating the thread.
*/
public void run() {
byte[] buf = new byte[256];
int count;
try {
/* read bytes till there are no more. */
while ((count = in.read(buf)) != -1) {
write(buf, count);
}
/* If annotating, flush internal buffer... may not have ended on a
* line separator, we also need a last annotation if
* something was left.
*/
String lastInBuffer = bufOut.toString();
bufOut.reset();
if (lastInBuffer.length() > 0) {
if (annotation != null) {
stream.print(annotation);
}
stream.println(lastInBuffer);
}
} catch (IOException e) {
}
}
/**
* Write each byte in the give byte array.
*
* @param b the array of input bytes
* @param len the number data bytes in the array
*/
private void write(byte b[], int len) throws IOException {
if (len < 0) {
throw new ArrayIndexOutOfBoundsException(len);
}
for (int i = 0; i < len; i++) {
write(b[i]);
}
}
/**
* If not annotated, write the byte to the stream immediately. Otherwise,
* write a byte of data to the internal buffer. If we have matched a line
* separator, then the currently buffered line is sent to the output writer
* with a prepended annotation string.
*/
private void write(byte b) throws IOException {
bufOut.write(b);
// write buffered line if line separator detected
if (b == SEPARATOR) {
String s = bufOut.toString();
bufOut.reset();
if (annotation != null) {
stream.print(annotation);
}
stream.print(s);
}
}
}
}