/*
 * 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       1.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;
    }
}