orbconfiguratorimpl.java

Mobile 应用程序使用 Java Micro Edition (Java ME) 平台

/*
 * @(#)ORBConfiguratorImpl.java	1.61 05/11/17
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

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

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.InetAddress ;
import java.security.PrivilegedAction ;
import java.security.PrivilegedExceptionAction ;
import java.security.AccessController ;
import java.util.Collection ;
import java.util.Iterator ;

import org.omg.CORBA.CompletionStatus ;
import org.omg.CORBA.portable.ValueFactory ;

import com.sun.corba.se.pept.protocol.ClientRequestDispatcher ;
import com.sun.corba.se.pept.transport.Acceptor;

import com.sun.corba.se.spi.activation.Locator ;
import com.sun.corba.se.spi.activation.Activator ;
import com.sun.corba.se.spi.activation.LocatorHelper ;
import com.sun.corba.se.spi.activation.ActivatorHelper ;
import com.sun.corba.se.spi.activation.EndPointInfo ;

import com.sun.corba.se.spi.copyobject.ObjectCopierFactory ;
import com.sun.corba.se.spi.copyobject.CopyobjectDefaults ;
import com.sun.corba.se.spi.copyobject.CopierManager ;

import com.sun.corba.se.spi.ior.IdentifiableFactoryFinder ;
import com.sun.corba.se.spi.ior.IOR;
import com.sun.corba.se.spi.ior.IORFactories ;

import com.sun.corba.se.spi.ior.iiop.IIOPFactories ;

import com.sun.corba.se.spi.legacy.connection.ORBSocketFactory;

import com.sun.corba.se.spi.logging.CORBALogDomains ;

import com.sun.corba.se.spi.oa.OADefault ;
import com.sun.corba.se.spi.oa.ObjectAdapter ;
import com.sun.corba.se.spi.oa.ObjectAdapterFactory ;

import com.sun.corba.se.spi.orb.Operation ;
import com.sun.corba.se.spi.orb.OperationFactory ;
import com.sun.corba.se.spi.orb.ORBData ;
import com.sun.corba.se.spi.orb.DataCollector ;
import com.sun.corba.se.spi.orb.ORBConfigurator ;
import com.sun.corba.se.spi.orb.ParserImplBase ;
import com.sun.corba.se.spi.orb.PropertyParser ;
import com.sun.corba.se.spi.orb.ORB ;

import com.sun.corba.se.spi.orbutil.closure.Closure ;
import com.sun.corba.se.spi.orbutil.closure.ClosureFactory ;

import com.sun.corba.se.spi.protocol.RequestDispatcherRegistry ;
import com.sun.corba.se.spi.protocol.CorbaServerRequestDispatcher ;
import com.sun.corba.se.spi.protocol.RequestDispatcherDefault ;
import com.sun.corba.se.spi.protocol.LocalClientRequestDispatcherFactory ;

import com.sun.corba.se.spi.resolver.LocalResolver ;
import com.sun.corba.se.spi.resolver.Resolver ;
import com.sun.corba.se.spi.resolver.ResolverDefault ;

import com.sun.corba.se.spi.transport.CorbaContactInfoList;
import com.sun.corba.se.spi.transport.CorbaContactInfoListFactory;
import com.sun.corba.se.spi.transport.SocketInfo;
import com.sun.corba.se.spi.transport.TransportDefault ;

import com.sun.corba.se.spi.presentation.rmi.PresentationManager ;
import com.sun.corba.se.spi.presentation.rmi.PresentationDefaults ;

import com.sun.corba.se.spi.servicecontext.ServiceContext ;
import com.sun.corba.se.spi.servicecontext.ServiceContextRegistry ;
import com.sun.corba.se.spi.servicecontext.UEInfoServiceContext ;
import com.sun.corba.se.spi.servicecontext.CodeSetServiceContext ;
import com.sun.corba.se.spi.servicecontext.SendingContextServiceContext ;
import com.sun.corba.se.spi.servicecontext.ORBVersionServiceContext ;
import com.sun.corba.se.spi.servicecontext.MaxStreamFormatVersionServiceContext ;
import com.sun.corba.se.impl.logging.ORBUtilSystemException ;
import com.sun.corba.se.impl.transport.SocketOrChannelAcceptorImpl;

// XXX This should go away once we get rid of the port exchange for ORBD
import com.sun.corba.se.spi.legacy.connection.LegacyServerSocketEndPointInfo;
import com.sun.corba.se.impl.legacy.connection.SocketFactoryAcceptorImpl;
import com.sun.corba.se.impl.legacy.connection.SocketFactoryContactInfoListImpl;
import com.sun.corba.se.impl.legacy.connection.USLPort;

// XXX These should move to SPI
import com.sun.corba.se.impl.orbutil.ORBConstants ;

// XXX This needs an SPI
import com.sun.corba.se.impl.dynamicany.DynAnyFactoryImpl ;

public class ORBConfiguratorImpl implements ORBConfigurator {
    private ORBUtilSystemException wrapper ;

    public static class ConfigParser extends ParserImplBase {
	public Class[] userConfigurators = null ;

	public PropertyParser makeParser()
	{
	    PropertyParser parser = new PropertyParser() ;
	    Operation action = OperationFactory.compose( 
		OperationFactory.suffixAction(),
		OperationFactory.classAction() 
	    ) ;
	    parser.addPrefix( ORBConstants.SUN_PREFIX + "ORBUserConfigurators",
		action, "userConfigurators", Class.class ) ;
	    return parser ;
	}
    }

    public void configure( DataCollector collector, ORB orb ) 
    {
	ORB theOrb = orb ;
	wrapper = ORBUtilSystemException.get( orb, CORBALogDomains.ORB_LIFECYCLE ) ;

	initObjectCopiers( theOrb ) ;
	initIORFinders( theOrb ) ;

	theOrb.setClientDelegateFactory( 
            // REVISIT: this should be ProtocolDefault.
	    TransportDefault.makeClientDelegateFactory( theOrb )) ;

	initializeTransport(theOrb) ;

	initializeNaming( theOrb ) ;
	initServiceContextRegistry( theOrb ) ;
	initRequestDispatcherRegistry( theOrb ) ;
	registerInitialReferences( theOrb ) ;

	persistentServerInitialization( theOrb ) ;

	runUserConfigurators( collector, theOrb ) ;
    }

    private void runUserConfigurators( DataCollector collector, ORB orb ) 
    {
	// Run any pluggable configurators.  This is a lot like 
	// ORBInitializers, only it uses the internal ORB and has
	// access to all data for parsing.  
	ConfigParser parser = new ConfigParser()  ;
	parser.init( collector ) ;
	if (parser.userConfigurators != null) {
	    for (int ctr=0; ctr<parser.userConfigurators.length; ctr++) {
		Class cls = parser.userConfigurators[ctr] ;
		try {
		    ORBConfigurator config = (ORBConfigurator)(cls.newInstance()) ;
		    config.configure( collector, orb ) ;
		} catch (Exception exc) {
		    // XXX Log this exception
		    // ignore this for now: a bad user configurator does nothing
		}
	    }
	}
    }

    private void persistentServerInitialization( ORB orb )
    {
	ORBData data = orb.getORBData() ;

	// determine the ORBD port so that persistent objrefs can be
	// created.
	if (data.getServerIsORBActivated()) {
	    try {
                Locator locator = LocatorHelper.narrow(
		    orb.resolve_initial_references( 
			ORBConstants.SERVER_LOCATOR_NAME )) ;
                Activator activator = ActivatorHelper.narrow(
		    orb.resolve_initial_references( 
			ORBConstants.SERVER_ACTIVATOR_NAME )) ;
		Collection serverEndpoints = 
		    orb.getCorbaTransportManager().getAcceptors(null, null);
		EndPointInfo[] endpointList = 
		    new EndPointInfo[serverEndpoints.size()];
		Iterator iterator = serverEndpoints.iterator();
		int i = 0 ;
		while (iterator.hasNext()) {
		    Object n = iterator.next();
		    if (! (n instanceof LegacyServerSocketEndPointInfo)) {
			continue;
		    }
		    LegacyServerSocketEndPointInfo ep = 
			(LegacyServerSocketEndPointInfo) n;
		    // REVISIT - use exception instead of -1.
		    int port = locator.getEndpoint(ep.getType());
		    if (port == -1) {
			port = locator.getEndpoint(SocketInfo.IIOP_CLEAR_TEXT);
			if (port == -1) {
			    throw new Exception(
				"ORBD must support IIOP_CLEAR_TEXT");
			}
		    }

		    ep.setLocatorPort(port);
		    
		    endpointList[i++] = 
			new EndPointInfo(ep.getType(), ep.getPort());
		}

	        activator.registerEndpoints(
		    data.getPersistentServerId(), data.getORBId(), 
			endpointList);
	    } catch (Exception ex) {
		throw wrapper.persistentServerInitError( 
		    CompletionStatus.COMPLETED_MAYBE, ex ) ;
	    }
	}
    }

    /**
     * This is made somewhat complex because we are currently supporting
     * the ContactInfoList/Acceptor *AND* the legacy SocketFactory 
     * transport architecture.
     */
    private void initializeTransport(final ORB orb)
    {
	ORBData od = orb.getORBData();

	CorbaContactInfoListFactory contactInfoListFactory =
	    od.getCorbaContactInfoListFactory();
	Acceptor[] acceptors = od.getAcceptors();

	// BEGIN Legacy
	ORBSocketFactory legacySocketFactory = od.getLegacySocketFactory();
	USLPort[] uslPorts = od.getUserSpecifiedListenPorts() ;
	setLegacySocketFactoryORB(orb, legacySocketFactory);
	// END Legacy

	//
	// Check for incorrect configuration.
	//

	if (legacySocketFactory != null && contactInfoListFactory != null) {
	    throw wrapper.socketFactoryAndContactInfoListAtSameTime();
	}

	if (acceptors.length != 0 && legacySocketFactory != null) {
	    throw wrapper.acceptorsAndLegacySocketFactoryAtSameTime();
	}


	//
	// Client and Server side setup.
	//

	od.getSocketFactory().setORB(orb);

	//
	// Set up client side.
	//

	if (legacySocketFactory != null) {
	    // BEGIN Legacy
	    // Since the user specified a legacy socket factory we need to
	    // use a ContactInfoList that will use the legacy socket factory.
	    contactInfoListFactory =
		new CorbaContactInfoListFactory() {
			public void setORB(ORB orb) { }
			public CorbaContactInfoList create( IOR ior ) {
			    return new SocketFactoryContactInfoListImpl( 
                                orb, ior);
			}
		    };
	    // END Legacy
	} else if (contactInfoListFactory != null) {
	    // The user specified an explicit ContactInfoListFactory.
	    contactInfoListFactory.setORB(orb);
	} else {
	    // Use the default.
	    contactInfoListFactory =
	        TransportDefault.makeCorbaContactInfoListFactory(orb);
	}
	orb.setCorbaContactInfoListFactory(contactInfoListFactory);

	//
	// Set up server side.
	//

	//
	// Maybe allocate the Legacy default listener.
	//
	// If old legacy properties set, or there are no explicit
	// acceptors then register a default listener.  Type of
	// default listener depends on presence of legacy socket factory.
	//
	// Note: this must happen *BEFORE* registering explicit acceptors.
	//

	// BEGIN Legacy
	int port = -1;
	if (od.getORBServerPort() != 0) {
	    port = od.getORBServerPort();
	} else if (od.getPersistentPortInitialized()) {
	    port = od.getPersistentServerPort();
	} else if (acceptors.length == 0) {
	    port = 0;
	}
	if (port != -1) {
	    createAndRegisterAcceptor(orb, legacySocketFactory, port,