FileDocCategorySizeDatePackage
Tool.javaAPI DocGlassfish v2 API10067Fri May 04 22:32:30 BST 2007org.apache.catalina.startup

Tool

public final class Tool extends Object

General purpose wrapper for command line tools that should execute in an environment with the common class loader environment set up by Catalina. This should be executed from a command line script that conforms to the following requirements:

  • Passes the catalina.home system property configured with the pathname of the Tomcat installation directory.
  • Sets the system classpath to include bootstrap.jar and $JAVA_HOME/lib/tools.jar.

The command line to execute the tool looks like:

java -classpath $CLASSPATH org.apache.catalina.startup.Tool \
${options} ${classname} ${arguments}

with the following replacement contents:

  • ${options} - Command line options for this Tool wrapper. The following options are supported:
    • -ant : Set the ant.home system property to corresponding to the value of catalina.home (useful when your command line tool runs Ant).
    • -common : Add common/classes and common/lib
    • -debug : Enable debugging messages from this wrapper.
    • -server : Add server/classes and server/lib to the class loader repositories.
    • -shared : Add shared/classes and shared/lib to the class loader repositories.
  • ${classname} - Fully qualified Java class name of the application's main class.
  • ${arguments} - Command line arguments to be passed to the application's main() method.
author
Craig R. McClanahan
version
$Revision: 1.4 $ $Date: 2007/05/05 05:32:29 $

Fields Summary
private static boolean
ant
Set ant.home system property?
private static String
catalinaHome
The pathname of our installation base directory.
private static boolean
common
Include common classes in the repositories?
private static boolean
debug
Enable debugging detail messages?
private static com.sun.org.apache.commons.logging.Log
log
private static boolean
server
Include server classes in the repositories?
private static boolean
shared
Include shared classes in the repositories?
Constructors Summary
Methods Summary
public static voidmain(java.lang.String[] args)
The main program for the bootstrap.

param
args Command line arguments to be processed



    // ----------------------------------------------------------- Main Program


                       
         

        // Verify that "catalina.home" was passed.
        if (catalinaHome == null) {
            log.error("Must set 'catalina.home' system property");
            System.exit(1);
        }

        // Process command line options
        int index = 0;
        while (true) {
            if (index == args.length) {
                usage();
                System.exit(1);
            }
            if ("-ant".equals(args[index]))
                ant = true;
            else if ("-common".equals(args[index]))
                common = true;
            else if ("-debug".equals(args[index]))
                debug = true;
            else if ("-server".equals(args[index]))
                server = true;
            else if ("-shared".equals(args[index]))
                shared = true;
            else
                break;
            index++;
        }
        if (index > args.length) {
            usage();
            System.exit(1);
        }

        // Set "ant.home" if requested
        if (ant)
            System.setProperty("ant.home", catalinaHome);

        // Construct the class loader we will be using
        ClassLoader classLoader = null;
        try {
            if (log.isDebugEnabled()) {
                log.debug("Constructing class loader");
                ClassLoaderFactory.setDebug(1);
            }
            ArrayList packed = new ArrayList();
            ArrayList unpacked = new ArrayList();
            unpacked.add(new File(catalinaHome, "classes"));
            packed.add(new File(catalinaHome, "lib"));
            if (common) {
                unpacked.add(new File(catalinaHome,
                                      "common" + File.separator + "classes"));
                packed.add(new File(catalinaHome,
                                    "common" + File.separator + "lib"));
            }
            if (server) {
                unpacked.add(new File(catalinaHome,
                                      "server" + File.separator + "classes"));
                packed.add(new File(catalinaHome,
                                    "server" + File.separator + "lib"));
            }
            if (shared) {
                unpacked.add(new File(catalinaHome,
                                      "shared" + File.separator + "classes"));
                packed.add(new File(catalinaHome,
                                    "shared" + File.separator + "lib"));
            }
            classLoader =
                ClassLoaderFactory.createClassLoader
                ((File[]) unpacked.toArray(new File[0]),
                 (File[]) packed.toArray(new File[0]),
                 null);
        } catch (Throwable t) {
            log.error("Class loader creation threw exception", t);
            System.exit(1);
        }
        Thread.currentThread().setContextClassLoader(classLoader);

        // Load our application class
        Class clazz = null;
        String className = args[index++];
        try {
            if (log.isDebugEnabled())
                log.debug("Loading application class " + className);
            clazz = classLoader.loadClass(className);
        } catch (Throwable t) {
            log.error("Exception creating instance of " + className, t);
            System.exit(1);
        }

        // Locate the static main() method of the application class
        Method method = null;
        String params[] = new String[args.length - index];
        System.arraycopy(args, index, params, 0, params.length);
        try {
            if (log.isDebugEnabled())
                log.debug("Identifying main() method");
            String methodName = "main";
            Class paramTypes[] = new Class[1];
            paramTypes[0] = params.getClass();
            method = clazz.getMethod(methodName, paramTypes);
        } catch (Throwable t) {
            log.error("Exception locating main() method", t);
            System.exit(1);
        }

        // Invoke the main method of the application class
        try {
            if (log.isDebugEnabled())
                log.debug("Calling main() method");
            Object paramValues[] = new Object[1];
            paramValues[0] = params;
            method.invoke(null, paramValues);
        } catch (Throwable t) {
            log.error("Exception calling main() method", t);
            System.exit(1);
        }

    
private static voidusage()
Display usage information about this tool.


        log.info("Usage:  java org.apache.catalina.startup.Tool [<options>] <class> [<arguments>]");