Java example source code file (ServerTool.java)

This example Java source code file (ServerTool.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

activator, commandhandler, corba, exception, getserverid, locateserverfororb, orb, printstream, repository, serverdef, serverhelddown, servernotregistered, servertool, string, unregisterserver, util

The ServerTool.java Java example source code

/*
 * Copyright (c) 1997, 2002, 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.
 */

package com.sun.corba.se.impl.activation;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Vector;
import java.util.Properties;
import java.util.StringTokenizer;

import org.omg.CORBA.ORB;
import org.omg.CORBA.INITIALIZE;
import org.omg.CORBA.CompletionStatus;
import com.sun.corba.se.impl.orbutil.ORBConstants;
import com.sun.corba.se.impl.orbutil.CorbaResourceUtil;
import com.sun.corba.se.spi.activation.*;
import com.sun.corba.se.spi.activation.ServerHeldDown;
import com.sun.corba.se.spi.activation.RepositoryPackage.ServerDef;
import com.sun.corba.se.spi.activation.LocatorPackage.ServerLocation;
import com.sun.corba.se.spi.activation.LocatorPackage.ServerLocationPerORB;

/**
 *
 * @author      Anita Jindal
 * @since       JDK1.3
 */
public class ServerTool
{
    final static String helpCommand = "help";
    final static String toolName    = "servertool";
    final static String commandArg  = "-cmd";

    static int getServerIdForAlias( ORB orb, String applicationName ) throws ServerNotRegistered
    {
        try {
            Repository rep = RepositoryHelper.narrow(
                orb.resolve_initial_references( ORBConstants.SERVER_REPOSITORY_NAME ) ) ;
            int serverid = rep.getServerID(applicationName);

            return rep.getServerID( applicationName ) ;
        } catch (Exception ex) {
            throw (new ServerNotRegistered());
        }
    }

    void run(String[] args)
    {
        String[] cmd = null;

        // if command specified in the args, get it
        for (int i=0; i < args.length; i++) {

            if (args[i].equals(commandArg)) {
                // get the command
                int cmdLen = args.length - i - 1;
                cmd = new String[cmdLen];
                for (int j=0; j < cmdLen; j++) cmd[j] = args[++i];

                break;
            }
        }

        try {
            // create the POA ORB
            Properties props = System.getProperties() ;
            props.put("org.omg.CORBA.ORBClass",
                "com.sun.corba.se.impl.orb.ORBImpl" );
            orb = (ORB) ORB.init(args, props);

            // if command specified in the args, process it
            if (cmd != null)  executeCommand(cmd);
            else { // process commands interactively

                // create a buffered reader to read commands from standard in
                BufferedReader in = new
                    BufferedReader(new InputStreamReader(System.in));

                // print tool banner
                System.out.println(CorbaResourceUtil.getText("servertool.banner"));

                // process commands until user quits
                while (true) {
                    cmd = readCommand(in);
                    if (cmd != null) executeCommand(cmd);
                    else printAvailableCommands();
                }
            }
        } catch (Exception ex) {
            System.out.println(CorbaResourceUtil.getText("servertool.usage", "servertool"));
            System.out.println();
            ex.printStackTrace();
        }
    }

    public static void main(String[] args)
    {
        ServerTool tool = new ServerTool();
        tool.run(args);
    }

    String[] readCommand(BufferedReader in)
    {
        System.out.print(toolName + " > ");

        try {
            int i = 0;
            String cmd[] = null;

            String cmdLine = in.readLine();

            if (cmdLine != null) {
                StringTokenizer st = new StringTokenizer(cmdLine);
                if (st.countTokens() != 0) {
                    cmd = new String[st.countTokens()];
                    while (st.hasMoreTokens()) cmd[i++] = st.nextToken();
                }
            }

            return cmd;
        } catch (Exception ex) {
            System.out.println(CorbaResourceUtil.getText("servertool.usage", "servertool"));
            System.out.println();
            ex.printStackTrace();
        }

        return null;
    }

    void printAvailableCommands()
    {
        CommandHandler handler;

        // print short help
        System.out.println(CorbaResourceUtil.getText("servertool.shorthelp"));

        for (int i=0; i < handlers.size(); i++) {
            handler = (CommandHandler) handlers.elementAt(i);
            System.out.print("\t" + handler.getCommandName());
            for (int j=handler.getCommandName().length();
                 j < maxNameLen; j++) System.out.print(" ");
            System.out.print(" - ");
            handler.printCommandHelp(System.out,
                                     CommandHandler.shortHelp);
        }

        System.out.println();
    }

    void executeCommand(String[] cmd)
    {
        boolean result;
        CommandHandler handler;

        // handle the help command
        if (cmd[0].equals(helpCommand)) {
            if (cmd.length == 1) printAvailableCommands();
            else {
                // print long help for a specific command
                for (int i=0; i < handlers.size(); i++) {
                    handler = (CommandHandler) handlers.elementAt(i);
                    if (handler.getCommandName().equals(cmd[1])) {
                        handler.printCommandHelp(System.out,
                                                 CommandHandler.longHelp);
                    }
                }
            }

            return;
        }

        // determine the subcommand and execute it
        for (int i=0; i < handlers.size(); i++) {
            handler = (CommandHandler) handlers.elementAt(i);
            if (handler.getCommandName().equals(cmd[0])) {
                String[] cmdArgs = new String[cmd.length - 1];

                // construct args to the command
                for (int j=0; j < cmdArgs.length; j++)
                    cmdArgs[j] = cmd[j+1];

                // execute the command
                try {
                    System.out.println();

                    result = handler.processCommand(cmdArgs, orb, System.out);

                    if (result == CommandHandler.parseError) {
                        handler.printCommandHelp(System.out,
                                                 CommandHandler.longHelp);
                    }

                    System.out.println();

                } catch (Exception ex) {}

                return;
            }
        }

        // unknown command - print available commands
        printAvailableCommands();
    }

    final private static boolean debug = false;

    ORB orb = null;

    static Vector handlers;
    static int maxNameLen;

    static {
        handlers = new Vector();
        handlers.addElement(new RegisterServer());
        handlers.addElement(new UnRegisterServer());
        handlers.addElement(new GetServerID());
        handlers.addElement(new ListServers());
        handlers.addElement(new ListAliases());
        handlers.addElement(new ListActiveServers());
        handlers.addElement(new LocateServer());
        handlers.addElement(new LocateServerForORB());
        handlers.addElement(new ListORBs());
        handlers.addElement(new ShutdownServer());
        handlers.addElement(new StartServer());
        handlers.addElement(new Help());
        handlers.addElement(new Quit());

        // determine longest command name
        maxNameLen = 0;
        int cmdNameLen;
        for (int i=0; i < handlers.size(); i++) {
            CommandHandler handler = (CommandHandler) handlers.elementAt(i);
            cmdNameLen = handler.getCommandName().length();
            if (cmdNameLen > maxNameLen) maxNameLen =  cmdNameLen;
        }
    }
}

class RegisterServer implements CommandHandler
{
    public String getCommandName() {return "register";}

    public void printCommandHelp(PrintStream out, boolean helpType)
    {
        if (helpType == longHelp) {
            out.println(CorbaResourceUtil.getText("servertool.register"));
        } else {
            out.println(CorbaResourceUtil.getText("servertool.register1"));
        }
    }

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
        int i=0;
        String applicationName = "";
        String name = "";
        String classpath = "";
        String args = "";
        String vmargs = "";
        int serverId = 0;

        // parse register server command
        String arg;
        while (i < cmdArgs.length) {

            arg = cmdArgs[i++];

            if (arg.equals("-server")) {
                if (i < cmdArgs.length) name = cmdArgs[i++];
                else return parseError;
            } else if (arg.equals("-applicationName")) {
                if (i < cmdArgs.length) applicationName = cmdArgs[i++];
                else return parseError;
            } else if (arg.equals("-classpath")) {
                if (i < cmdArgs.length) classpath = cmdArgs[i++];
                else return parseError;
            } else if (arg.equals("-args")) {
                while ((i < cmdArgs.length) && !cmdArgs[i].equals("-vmargs")){
                    args = args.equals("") ? cmdArgs[i] :
                        args + " " + cmdArgs[i];
                    i++;
                }
                if (args.equals("")) return parseError;
            } else if (arg.equals("-vmargs")) {
                while ((i < cmdArgs.length) && !cmdArgs[i].equals("-args")){
                    vmargs = vmargs.equals("") ? cmdArgs[i] :
                        vmargs + " " + cmdArgs[i];
                    i++;
                }
                if (vmargs.equals("")) return parseError;
            } else return parseError;
        }

        // minimally the server class name has to be specified
        if (name.equals("")) return parseError;

        // register server and activate it
        try {
            // register the server with the repository
            Repository repository = RepositoryHelper.narrow(
                orb.resolve_initial_references( ORBConstants.SERVER_REPOSITORY_NAME ));

            ServerDef server = new ServerDef(applicationName, name, classpath, args, vmargs);
            serverId = repository.registerServer(server);

            // activate the server
            Activator activator = ActivatorHelper.narrow(
                orb.resolve_initial_references( ORBConstants.SERVER_ACTIVATOR_NAME ));
            activator.activate(serverId);
            activator.install(serverId);

            // print success message
            out.println(CorbaResourceUtil.getText("servertool.register2", serverId));
        } catch (ServerNotRegistered ex) {
        } catch (ServerAlreadyActive ex) {
        } catch (ServerHeldDown ex) {
            out.println(CorbaResourceUtil.getText("servertool.register3", serverId));
        } catch (ServerAlreadyRegistered ex) {
            out.println(CorbaResourceUtil.getText("servertool.register4", serverId));
        } catch (BadServerDefinition ex) {
            out.println(CorbaResourceUtil.getText("servertool.baddef", ex.reason));
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return commandDone;
    }
}

class UnRegisterServer implements CommandHandler
{
    public String getCommandName() {return "unregister";}

    public void printCommandHelp(PrintStream out, boolean helpType)
    {
        if (helpType == longHelp) {
            out.println(CorbaResourceUtil.getText("servertool.unregister"));
        } else {
            out.println(CorbaResourceUtil.getText("servertool.unregister1"));
        }
}

    final static int illegalServerId = -1;

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
        int serverId = illegalServerId;

        try {
            if (cmdArgs.length == 2) {
                if (cmdArgs[0].equals("-serverid"))
                    serverId = (Integer.valueOf(cmdArgs[1])).intValue();
                else if (cmdArgs[0].equals("-applicationName"))
                    serverId = ServerTool.getServerIdForAlias( orb, cmdArgs[1] ) ;
            }

            // the server id has to be specified
            if (serverId == illegalServerId)
                return parseError;

            // deactivate server, hold it down and and unregister it
            // deactivate the server
            try {
                Activator activator = ActivatorHelper.narrow(
                     orb.resolve_initial_references( ORBConstants.SERVER_ACTIVATOR_NAME ));
                activator.uninstall(serverId);
            } catch (ServerHeldDown ex) {}

            // unregister the server from the repository
            Repository repository = RepositoryHelper.narrow(
                orb.resolve_initial_references( ORBConstants.SERVER_REPOSITORY_NAME ));
            repository.unregisterServer(serverId);

            // print success message
            out.println(CorbaResourceUtil.getText("servertool.unregister2"));
        } catch (ServerNotRegistered ex) {
            out.println(CorbaResourceUtil.getText("servertool.nosuchserver"));
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return commandDone;
    }
}

class LocateServer implements CommandHandler
{
    public String getCommandName() {return "locate";}

    public void printCommandHelp(PrintStream out, boolean helpType)
    {
        if (helpType == longHelp) {
            out.println(CorbaResourceUtil.getText("servertool.locate"));
        } else {
            out.println(CorbaResourceUtil.getText("servertool.locate1"));
        }
    }

    final static int illegalServerId = -1;

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
        int serverId = illegalServerId;

        String endPointType = IIOP_CLEAR_TEXT.value;
        try {

            // parse command
            String arg;
            int i = 0;
            while (i < cmdArgs.length) {

                arg = cmdArgs[i++];

                if (arg.equals("-serverid")) {
                    if (i < cmdArgs.length)
                        serverId = (Integer.valueOf(cmdArgs[i++])).intValue();
                    else
                        return parseError;
                } else if (arg.equals("-applicationName")) {
                    if (i < cmdArgs.length)
                        serverId = ServerTool.getServerIdForAlias( orb, cmdArgs[i++] ) ;
                    else
                        return parseError;
                } else if (arg.equals("-endpointType")) {
                    if (i < cmdArgs.length)
                        endPointType = cmdArgs[i++];
                }
            }

            // the server id has to be specified
            if (serverId == illegalServerId)
                return parseError;

            // locate the server
            // deactivate the server
            Locator locator = LocatorHelper.narrow(
                orb.resolve_initial_references( ORBConstants.SERVER_LOCATOR_NAME ));

            ServerLocation location = locator.locateServer(serverId, endPointType);

            // print success message
            out.println(CorbaResourceUtil.getText("servertool.locate2", location.hostname));
            int numEntries = location.ports.length;
            for (i = 0; i < numEntries; i++) {
                ORBPortInfo orbPort = location.ports[i];
                out.println("\t\t"+ orbPort.port + "\t\t" + endPointType + "\t\t" + orbPort.orbId );
            }
        } catch (NoSuchEndPoint ex) {
        } catch (ServerHeldDown ex) {
            out.println(CorbaResourceUtil.getText("servertool.helddown"));
        } catch (ServerNotRegistered ex) {
            out.println(CorbaResourceUtil.getText("servertool.nosuchserver"));
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return commandDone;
    }
}

class LocateServerForORB implements CommandHandler
{
    public String getCommandName() {return "locateperorb";}

    public void printCommandHelp(PrintStream out, boolean helpType)
    {
        if (helpType == longHelp) {
            out.println(CorbaResourceUtil.getText("servertool.locateorb"));
        } else {
            out.println(CorbaResourceUtil.getText("servertool.locateorb1"));
        }
    }

    final static int illegalServerId = -1;

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
        int serverId = illegalServerId;

        String orbId = "";
        try {

            // parse command
            String arg;
            int i = 0;
            while (i < cmdArgs.length) {

                arg = cmdArgs[i++];

                if (arg.equals("-serverid")) {
                    if (i < cmdArgs.length)
                        serverId = (Integer.valueOf(cmdArgs[i++])).intValue();
                    else
                        return parseError;
                } else if (arg.equals("-applicationName")) {
                    if (i < cmdArgs.length)
                        serverId = ServerTool.getServerIdForAlias( orb, cmdArgs[i++] ) ;
                    else
                        return parseError;
                } else if (arg.equals("-orbid")) {
                    if (i < cmdArgs.length)
                        orbId = cmdArgs[i++];
                }
            }

            // the server id has to be specified
            if (serverId == illegalServerId)
                return parseError;

            // locate the server
            // deactivate the server
            Locator locator = LocatorHelper.narrow(
                orb.resolve_initial_references( ORBConstants.SERVER_LOCATOR_NAME ));

            ServerLocationPerORB location = locator.locateServerForORB(serverId,
                                            orbId);

            // print success message
            out.println(CorbaResourceUtil.getText("servertool.locateorb2", location.hostname));
            int numEntries = location.ports.length;
            for (i = 0; i < numEntries; i++) {
                EndPointInfo Port = location.ports[i];
                out.println("\t\t"+ Port.port + "\t\t" + Port.endpointType + "\t\t" + orbId );
            }
        } catch (InvalidORBid ex) {
            out.println(CorbaResourceUtil.getText("servertool.nosuchorb"));
        } catch (ServerHeldDown ex) {
            out.println(CorbaResourceUtil.getText("servertool.helddown"));
        } catch (ServerNotRegistered ex) {
            out.println(CorbaResourceUtil.getText("servertool.nosuchserver"));
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return commandDone;
    }
}

class GetServerID implements CommandHandler
{
    public String getCommandName() {return "getserverid" ; }

    public void printCommandHelp( PrintStream out, boolean helpType )
    {
        if (helpType == longHelp) {
            out.println(CorbaResourceUtil.getText("servertool.getserverid"));
        } else {
            out.println(CorbaResourceUtil.getText("servertool.getserverid1"));
        }
    }

    public boolean processCommand( String[] cmdArgs, ORB orb, PrintStream out )
    {
        if ((cmdArgs.length == 2) && cmdArgs[0].equals( "-applicationName" )) {
            String str = (String)cmdArgs[1] ;

            try {
                Repository repository = RepositoryHelper.narrow(
                    orb.resolve_initial_references( ORBConstants.SERVER_REPOSITORY_NAME ));

                try {
                    int result = repository.getServerID( str ) ;
                    out.println() ;
                    out.println(CorbaResourceUtil.getText("servertool.getserverid2", str, Integer.toString(result)));
                    out.println() ;
                } catch (ServerNotRegistered e) {
                    out.println(CorbaResourceUtil.getText("servertool.nosuchserver"));
                }
            } catch (Exception ex) {
                ex.printStackTrace() ;
            }

            return commandDone ;
        } else
            return parseError ;
    }
}

class ListServers implements CommandHandler
{
    public String getCommandName() {return "list";}

    public void printCommandHelp(PrintStream out, boolean helpType)
    {
        if (helpType == longHelp) {
            out.println(CorbaResourceUtil.getText("servertool.list"));
        } else {
            out.println(CorbaResourceUtil.getText("servertool.list1"));
        }
    }

    final static int illegalServerId = -1;

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
        int serverId = illegalServerId;
        boolean listOneServer = false;
        ServerDef serverDef;

        // determine if list single server or all servers
        listOneServer = (cmdArgs.length!=0) ;
        if ((cmdArgs.length == 2) && cmdArgs[0].equals("-serverid"))
            serverId = (Integer.valueOf(cmdArgs[1])).intValue();

        if ((serverId == illegalServerId) && listOneServer)
            return parseError;

        // process the list server command
        try {
            Repository repository = RepositoryHelper.narrow(
                orb.resolve_initial_references( ORBConstants.SERVER_REPOSITORY_NAME ));

            if (listOneServer) {

                try {
                    serverDef = repository.getServer(serverId);
                    out.println();
                    printServerDef(serverDef, serverId, out);
                    out.println();
                } catch (ServerNotRegistered e) {
                    out.println(CorbaResourceUtil.getText("servertool.nosuchserver"));
                }

            } else {
                int[] servers = repository.listRegisteredServers();
                out.println(CorbaResourceUtil.getText("servertool.list2"));

                sortServers(servers);
                for (int i=0; i < servers.length; i++) {
                    try {
                        serverDef = repository.getServer(servers[i]);
                        out.println("\t   " + servers[i] + "\t\t" +
                                    serverDef.serverName + "\t\t"
                                    + serverDef.applicationName);
                    } catch (ServerNotRegistered e) {}
                }

            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return commandDone;
    }

static void printServerDef(ServerDef serverDef, int serverId,
                           PrintStream out)
{
    out.println(CorbaResourceUtil.getText("servertool.appname", serverDef.applicationName));
    out.println(CorbaResourceUtil.getText("servertool.name", serverDef.serverName));
    out.println(CorbaResourceUtil.getText("servertool.classpath", serverDef.serverClassPath));
    out.println(CorbaResourceUtil.getText("servertool.args", serverDef.serverArgs));
    out.println(CorbaResourceUtil.getText("servertool.vmargs", serverDef.serverVmArgs));
    out.println(CorbaResourceUtil.getText("servertool.serverid", serverId));
}

/**
 * Do a simple bubble sort to sort the server ids in ascending
 * order.
 */
static void sortServers(int[] serverIds)
{
    int size = serverIds.length;
    int lowest;

    for (int i=0; i < size; i++) {

        lowest = i;

        for (int j=i+1; j < size; j++) {
            if (serverIds[j] < serverIds[lowest]) lowest = j;
        }

        if (lowest != i) {
            int temp = serverIds[i];
            serverIds[i] = serverIds[lowest];
            serverIds[lowest] = temp;
        }
    }
}
}

class ListActiveServers implements CommandHandler
{
    public String getCommandName() {return "listactive";}

    public void printCommandHelp(PrintStream out, boolean helpType)
    {
        if (helpType == longHelp) {
            out.println(CorbaResourceUtil.getText("servertool.listactive"));
        } else {
            out.println(CorbaResourceUtil.getText("servertool.listactive1"));
        }
    }

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
        ServerDef serverDef;

        // process the list active servers command
        try {
            Repository repository = RepositoryHelper.narrow(
                orb.resolve_initial_references( ORBConstants.SERVER_REPOSITORY_NAME ));

            Activator activator = ActivatorHelper.narrow(
                orb.resolve_initial_references( ORBConstants.SERVER_ACTIVATOR_NAME ));

            int[] servers = activator.getActiveServers();

            out.println(CorbaResourceUtil.getText("servertool.list2"));

            ListServers.sortServers(servers);
            for (int i=0; i < servers.length; i++) {
                try {
                    serverDef = repository.getServer(servers[i]);
                    out.println("\t   " + servers[i] + "\t\t" +
                                serverDef.serverName + "\t\t" +
                                serverDef.applicationName);
                } catch (ServerNotRegistered e) {}
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return commandDone;
    }
}

class ListAliases implements CommandHandler
{
    public String getCommandName() {return "listappnames";}

    public void printCommandHelp(PrintStream out, boolean helpType)
    {
        if (helpType == longHelp) {
            out.println(CorbaResourceUtil.getText("servertool.listappnames"));
        } else {
            out.println(CorbaResourceUtil.getText("servertool.listappnames1"));
        }
    }

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
        try {
            Repository repository = RepositoryHelper.narrow(
                orb.resolve_initial_references( ORBConstants.SERVER_REPOSITORY_NAME ));

            String[] applicationNames = repository.getApplicationNames();

            out.println(CorbaResourceUtil.getText("servertool.listappnames2"));
            out.println();
            for (int i=0; i < applicationNames.length; i++)
                out.println( "\t" + applicationNames[i] ) ;
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return commandDone;
    }
}

class ShutdownServer implements CommandHandler
{
    public String getCommandName() {return "shutdown";}

    public void printCommandHelp(PrintStream out, boolean helpType)
    {
        if (helpType == longHelp) {
            out.println(CorbaResourceUtil.getText("servertool.shutdown"));
        } else {
            out.println(CorbaResourceUtil.getText("servertool.shutdown1"));
        }
    }

    final static int illegalServerId = -1;

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
        int serverId = illegalServerId;

        try {
            // determine the server id
            if (cmdArgs.length == 2)
                if (cmdArgs[0].equals("-serverid"))
                    serverId = (Integer.valueOf(cmdArgs[1])).intValue();
                else if (cmdArgs[0].equals("-applicationName"))
                    serverId = ServerTool.getServerIdForAlias( orb, cmdArgs[1] ) ;

            if (serverId == illegalServerId)
                return parseError;

            // shutdown the server
            Activator activator = ActivatorHelper.narrow(
                orb.resolve_initial_references( ORBConstants.SERVER_ACTIVATOR_NAME ));
            activator.shutdown(serverId);

            out.println(CorbaResourceUtil.getText("servertool.shutdown2"));
        } catch (ServerNotActive ex) {
            out.println(CorbaResourceUtil.getText("servertool.servernotrunning"));
        } catch (ServerNotRegistered ex) {
            out.println(CorbaResourceUtil.getText("servertool.nosuchserver"));
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return commandDone;
    }
}

class StartServer implements CommandHandler
{
    public String getCommandName() {return "startup";}

    public void printCommandHelp(PrintStream out, boolean helpType)
    {
        if (helpType == longHelp) {
            out.println(CorbaResourceUtil.getText("servertool.startserver"));
        } else {
            out.println(CorbaResourceUtil.getText("servertool.startserver1"));
        }
    }

    final static int illegalServerId = -1;

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
        int serverId = illegalServerId;

        try {
            // determine the server id
            if (cmdArgs.length == 2)
                if (cmdArgs[0].equals("-serverid"))
                    serverId = (Integer.valueOf(cmdArgs[1])).intValue();
                else if (cmdArgs[0].equals("-applicationName"))
                    serverId = ServerTool.getServerIdForAlias( orb, cmdArgs[1] ) ;

            if (serverId == illegalServerId)
                return parseError;

            // startup the server
            Activator activator = ActivatorHelper.narrow(
                orb.resolve_initial_references( ORBConstants.SERVER_ACTIVATOR_NAME ));
            activator.activate(serverId);

            out.println(CorbaResourceUtil.getText("servertool.startserver2"));
        } catch (ServerNotRegistered ex) {
            out.println(CorbaResourceUtil.getText("servertool.nosuchserver"));
        } catch (ServerAlreadyActive ex) {
            out.println(CorbaResourceUtil.getText("servertool.serverup"));
        } catch (ServerHeldDown ex) {
            out.println(CorbaResourceUtil.getText("servertool.helddown"));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return commandDone;
    }
}

class Quit implements CommandHandler
{
    public String getCommandName() {return "quit";}

    public void printCommandHelp(PrintStream out, boolean helpType)
    {
        if (helpType == longHelp) {
            out.println(CorbaResourceUtil.getText("servertool.quit"));
        } else {
            out.println(CorbaResourceUtil.getText("servertool.quit1"));
        }
    }

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
        System.exit(0);

        return commandDone;
    }
}

class Help implements CommandHandler
{
    public String getCommandName() {return "help";}

    public void printCommandHelp(PrintStream out, boolean helpType)
    {
        if (helpType == longHelp) {
            out.println(CorbaResourceUtil.getText("servertool.help"));
        } else {
            out.println(CorbaResourceUtil.getText("servertool.help1"));
        }
    }

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {
        return commandDone;
    }
}

class ListORBs implements CommandHandler
{
    public String getCommandName() {return "orblist";}

    public void printCommandHelp(PrintStream out, boolean helpType)
    {
        if (helpType == longHelp) {
            out.println(CorbaResourceUtil.getText("servertool.orbidmap"));
        } else {
            out.println(CorbaResourceUtil.getText("servertool.orbidmap1"));
        }
    }

    final static int illegalServerId = -1;

    public boolean processCommand(String[] cmdArgs, ORB orb, PrintStream out)
    {

        int serverId = illegalServerId;

        try {
            if (cmdArgs.length == 2) {
                if (cmdArgs[0].equals("-serverid"))
                    serverId = (Integer.valueOf(cmdArgs[1])).intValue();
                else if (cmdArgs[0].equals("-applicationName"))
                    serverId = ServerTool.getServerIdForAlias( orb, cmdArgs[1] ) ;
            }

            // the server id has to be specified
            if (serverId == illegalServerId)
                return parseError;
            // activate the server
            Activator activator = ActivatorHelper.narrow(
                orb.resolve_initial_references( ORBConstants.SERVER_ACTIVATOR_NAME ));

            String[] orbList = activator.getORBNames(serverId);

            out.println(CorbaResourceUtil.getText("servertool.orbidmap2"));

            for (int i = 0;  i < orbList.length ; i++) {
                out.println("\t "+ orbList[i]);
            }
        } catch (ServerNotRegistered ex) {
            out.println("\tno such server found.");
        } catch (Exception ex) {
            ex.printStackTrace();
        }

      return commandDone;
    }
}