servertableentry.java

来自「JAVA 所有包」· Java 代码 · 共 527 行 · 第 1/2 页

/*
 * @(#)ServerTableEntry.java	1.28 03/06/25
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package com.sun.corba.se.impl.activation;

/**
 *
 * @version     1.28
 * @author      Anita Jindal
 * @since       JDK1.2
 */

import org.omg.CORBA.CompletionStatus;

import com.sun.corba.se.spi.activation.Server;
import com.sun.corba.se.spi.activation.EndPointInfo;
import com.sun.corba.se.spi.activation.ORBAlreadyRegistered;
import com.sun.corba.se.spi.activation.ORBPortInfo;
import com.sun.corba.se.spi.activation.InvalidORBid;
import com.sun.corba.se.spi.activation.ServerHeldDown;
import com.sun.corba.se.spi.activation.RepositoryPackage.ServerDef;
import com.sun.corba.se.spi.activation.IIOP_CLEAR_TEXT;
import com.sun.corba.se.spi.orb.ORB ;

import com.sun.corba.se.impl.orbutil.ORBConstants;
import com.sun.corba.se.impl.logging.ActivationSystemException ;

import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class ServerTableEntry
{

    private final static int DE_ACTIVATED = 0;
    private final static int ACTIVATING   = 1;
    private final static int ACTIVATED    = 2;
    private final static int RUNNING      = 3;
    private final static int HELD_DOWN    = 4;


    private String printState()
    {
	String str = "UNKNOWN";

	switch (state) {
	case (DE_ACTIVATED) : str = "DE_ACTIVATED"; break;
	case (ACTIVATING  ) : str = "ACTIVATING  "; break;
	case (ACTIVATED   ) : str = "ACTIVATED   "; break;
	case (RUNNING     ) : str = "RUNNING     "; break;
	case (HELD_DOWN   ) : str = "HELD_DOWN   "; break;
	default: break;
	}

	return str;
    }

    private final static long waitTime    = 2000;
    private static final int ActivationRetryMax = 5;

    // state of each entry
    private int state;
    private int serverId;
    private HashMap orbAndPortInfo;
    private Server serverObj;
    private ServerDef serverDef;
    private Process process;
    private int activateRetryCount=0;
    private String activationCmd;
    private ActivationSystemException wrapper ;
    public String toString()
    {
	return "ServerTableEntry[" + "state=" + printState() +
	    " serverId=" + serverId +
	    " activateRetryCount=" + activateRetryCount + "]" ;
    }

    // get the string needed to make the activation command
    private static String javaHome, classPath, fileSep, pathSep;

    static {
	javaHome  = System.getProperty("java.home");
	classPath = System.getProperty("java.class.path");
	fileSep   = System.getProperty("file.separator");
	pathSep   = System.getProperty("path.separator");
    }

    ServerTableEntry( ActivationSystemException wrapper,
	int serverId, ServerDef serverDef, int initialPort,
	String dbDirName, boolean verify, boolean debug )
    {
	this.wrapper = wrapper ;
        this.serverId = serverId;
        this.serverDef = serverDef;
	this.debug = debug ;
	// create a HashMap with capacity 255
	// Since all methods are synchronized, we don't need any
	// additional synchronization mechanisms
	orbAndPortInfo = new HashMap(255);

	activateRetryCount = 0;
        state = ACTIVATING;

	// compute the activation command
	activationCmd =

	    // add path to the java vm
	    javaHome + fileSep + "bin" + fileSep + "java " +

	    // add any arguments to the server Java VM
	    serverDef.serverVmArgs + " " +

	    // add ORB properties
	    "-Dioser=" + System.getProperty( "ioser" ) + " " +
	    "-D" + ORBConstants.INITIAL_PORT_PROPERTY	+ "=" + initialPort + " " +
	    "-D" + ORBConstants.DB_DIR_PROPERTY		+ "=" + dbDirName + " " +
	    "-D" + ORBConstants.ACTIVATED_PROPERTY	+ "=true " +
	    "-D" + ORBConstants.SERVER_ID_PROPERTY	+ "=" + serverId + " " +
	    "-D" + ORBConstants.SERVER_NAME_PROPERTY	+ "=" + serverDef.serverName + " " +
	    // we need to pass in the verify flag, so that the server is not
	    // launched, when we try to validate its definition during registration
	    // into the RepositoryImpl

	    (verify ? "-D" + ORBConstants.SERVER_DEF_VERIFY_PROPERTY + "=true ": "") +

	    // add classpath to the server
	    "-classpath " + classPath +
	    (serverDef.serverClassPath.equals("") == true ? "" : pathSep) +
	    serverDef.serverClassPath +

	    // add server class name and arguments
	    " com.sun.corba.se.impl.activation.ServerMain " + serverDef.serverArgs

	    // Add the debug flag, if any
	    + (debug ? " -debug" : "") ;

	if (debug) System.out.println(
				      "ServerTableEntry constructed with activation command " +
				      activationCmd);
    }

    /**
     * Verify whether the server definition is valid.
     */
    public int verify()
    {
	try {

	    if (debug)
	        System.out.println("Server being verified w/" + activationCmd);

            process = Runtime.getRuntime().exec(activationCmd);
	    int result = process.waitFor();
	    if (debug)
		printDebug( "verify", "returns " + ServerMain.printResult( result ) ) ;
	    return result ;
	} catch (Exception e) {
	    if (debug)
		printDebug( "verify", "returns unknown error because of exception " +
			    e ) ;
	    return ServerMain.UNKNOWN_ERROR;
	}
    }

    private void printDebug(String method, String msg)
    {
	System.out.println("ServerTableEntry: method  =" + method);
	System.out.println("ServerTableEntry: server  =" + serverId);
	System.out.println("ServerTableEntry: state   =" + printState());
	System.out.println("ServerTableEntry: message =" + msg);
	System.out.println();
    }

    synchronized void activate() throws org.omg.CORBA.SystemException
    {
        state = ACTIVATED;

        try {
            if (debug)
		printDebug("activate", "activating server");
            process = Runtime.getRuntime().exec(activationCmd);
        } catch (Exception e) {
            deActivate();
            if (debug)
		printDebug("activate", "throwing premature process exit");
	    throw wrapper.unableToStartProcess() ;
        }
    }

    synchronized void register(Server server)
    {
        if (state == ACTIVATED) {

            serverObj = server;

            //state = RUNNING;
            //notifyAll();

            if (debug)
		printDebug("register", "process registered back");

        } else {

            if (debug)
		printDebug("register", "throwing premature process exit");
	    throw wrapper.serverNotExpectedToRegister() ;
        }
    }

    synchronized void registerPorts( String orbId, EndPointInfo [] endpointList)
	throws ORBAlreadyRegistered
    {

	// find if the ORB is already registered, then throw an exception
	if (orbAndPortInfo.containsKey(orbId)) {
	    throw new ORBAlreadyRegistered(orbId);
	}

	// store all listener ports and their types
	int numListenerPorts = endpointList.length;
	EndPointInfo [] serverListenerPorts = new EndPointInfo[numListenerPorts];

	for (int i = 0; i < numListenerPorts; i++) {
	    serverListenerPorts[i] = new EndPointInfo (endpointList[i].endpointType, endpointList[i].port);
	if (debug)
	    System.out.println("registering type: " + serverListenerPorts[i].endpointType  +  "  port  " + serverListenerPorts[i].port);
	}

	// put this set of listener ports in the HashMap associated
	// with the orbId
	orbAndPortInfo.put(orbId, serverListenerPorts);
        if (state == ACTIVATED) {
            state = RUNNING;
            notifyAll();
        }
        // _REVISIT_, If the state is not equal to ACTIVATED then it is a bug
        // need to log that error, once the Logging framework is in place
        // for rip-int.
        if (debug)
	    printDebug("registerPorts", "process registered Ports");
    }

    void install()
    {
        Server localServerObj = null;
        synchronized ( this ) {
            if (state == RUNNING)
                localServerObj = serverObj;
            else
                throw wrapper.serverNotRunning() ;
        }
        if (localServerObj != null) {
            localServerObj.install() ;
        }

    }

    void uninstall()
    {
        Server localServerObj = null;