orbconfiguratorimpl.java

JAVA 所有包

			LegacyServerSocketEndPointInfo.DEFAULT_ENDPOINT,
			SocketInfo.IIOP_CLEAR_TEXT);
	}
	// END Legacy

	for (int i = 0; i < acceptors.length; i++) {
	    orb.getCorbaTransportManager().registerAcceptor(acceptors[i]);
	}

	// BEGIN Legacy
	// Allocate user listeners.
	USLPort[] ports = od.getUserSpecifiedListenPorts() ;
	if (ports != null) {
	    for (int i = 0; i < ports.length; i++) {
		createAndRegisterAcceptor(
                    orb, legacySocketFactory, ports[i].getPort(),
		    LegacyServerSocketEndPointInfo.NO_NAME,
		    ports[i].getType());
	    }
	}
	// END Legacy
    }

    /*
     * Legacy: name.
     */
    // REVISIT: see ORBD. make factory in TransportDefault.
    private void createAndRegisterAcceptor(ORB orb,
					   ORBSocketFactory legacySocketFactory,
					   int port, String name, String type)
    {
	Acceptor acceptor;
	if (legacySocketFactory == null) {
	    acceptor =
		new SocketOrChannelAcceptorImpl(orb, port, name, type);
	} else {
	    acceptor =
		new SocketFactoryAcceptorImpl(orb, port, name, type);
	}
	orb.getTransportManager().registerAcceptor(acceptor);
    }

    private void setLegacySocketFactoryORB(
        final ORB orb, final ORBSocketFactory legacySocketFactory)
    {
	if (legacySocketFactory == null) {
	    return;
	}

	// Note: the createServerSocket and createSocket methods on the
	// DefaultSocketFactory need to get data from the ORB but
	// we cannot change the interface.  So set the ORB (if it's ours)
	// by reflection.

	try {
    	    AccessController.doPrivileged(
                new PrivilegedExceptionAction() {
	            public Object run()
		        throws InstantiationException, IllegalAccessException
		    {
			try {
			    Class[] params = { ORB.class };
			    Method method =
				legacySocketFactory.getClass().getMethod(
                                  "setORB", params);
			    Object[] args = { orb };
			    method.invoke(legacySocketFactory, args);
			} catch (NoSuchMethodException e) {
			    // NOTE: If there is no method then it
			    // is not ours - so ignore it.
			    ;
			} catch (IllegalAccessException e) {
			    RuntimeException rte = new RuntimeException();
			    rte.initCause(e);
			    throw rte;
			} catch (InvocationTargetException e) {
			    RuntimeException rte = new RuntimeException();
			    rte.initCause(e);
			    throw rte;
			}
			return null;
		    }
		}
	    );
	} catch (Throwable t) {
	    throw wrapper.unableToSetSocketFactoryOrb(t);
	}
    }

    private void initializeNaming( ORB orb )
    { 
	LocalResolver localResolver = ResolverDefault.makeLocalResolver() ;
	orb.setLocalResolver( localResolver ) ;

	Resolver bootResolver = ResolverDefault.makeBootstrapResolver( orb,
	    orb.getORBData().getORBInitialHost(),
	    orb.getORBData().getORBInitialPort() ) ;

	Operation urlOperation = ResolverDefault.makeINSURLOperation( orb,
	    bootResolver ) ;
	orb.setURLOperation( urlOperation ) ;

	Resolver irResolver = ResolverDefault.makeORBInitRefResolver( urlOperation,
	    orb.getORBData().getORBInitialReferences() ) ;

	Resolver dirResolver = ResolverDefault.makeORBDefaultInitRefResolver( 
	    urlOperation, orb.getORBData().getORBDefaultInitialReference() ) ;

	Resolver resolver = 
	    ResolverDefault.makeCompositeResolver( localResolver,
		ResolverDefault.makeCompositeResolver( irResolver,
		    ResolverDefault.makeCompositeResolver( dirResolver, 
			bootResolver ) ) ) ;
	orb.setResolver( resolver ) ;
    }

    private void initServiceContextRegistry( ORB orb ) 
    {
	ServiceContextRegistry scr = orb.getServiceContextRegistry() ;

	scr.register( UEInfoServiceContext.class ) ;
	scr.register( CodeSetServiceContext.class ) ;
	scr.register( SendingContextServiceContext.class ) ;
	scr.register( ORBVersionServiceContext.class ) ;
	scr.register( MaxStreamFormatVersionServiceContext.class ) ;
    }

    private void registerInitialReferences( final ORB orb ) 
    {
	// Register the Dynamic Any factory
        Closure closure = new Closure() {
            public java.lang.Object evaluate() {
                return new DynAnyFactoryImpl( orb ) ;
            }
        } ;

        Closure future = ClosureFactory.makeFuture( closure ) ;
        orb.getLocalResolver().register( ORBConstants.DYN_ANY_FACTORY_NAME, 
	    future ) ;
    }

    private static final int ORB_STREAM = 0 ;

    private void initObjectCopiers( ORB orb )
    {
	// No optimization or policy selection here.
	ObjectCopierFactory orbStream = 
	    CopyobjectDefaults.makeORBStreamObjectCopierFactory( orb ) ;

	CopierManager cm = orb.getCopierManager() ;
	cm.setDefaultId( ORB_STREAM ) ;

	cm.registerObjectCopierFactory( orbStream, ORB_STREAM ) ;
    }

    private void initIORFinders( ORB orb ) 
    {
	IdentifiableFactoryFinder profFinder = 
	    orb.getTaggedProfileFactoryFinder() ;
	profFinder.registerFactory( IIOPFactories.makeIIOPProfileFactory() ) ;

	IdentifiableFactoryFinder profTempFinder = 
	    orb.getTaggedProfileTemplateFactoryFinder() ;
	profTempFinder.registerFactory( 
	    IIOPFactories.makeIIOPProfileTemplateFactory() ) ;

	IdentifiableFactoryFinder compFinder = 
	    orb.getTaggedComponentFactoryFinder() ;
	compFinder.registerFactory( 
	    IIOPFactories.makeCodeSetsComponentFactory() ) ;
	compFinder.registerFactory( 
	    IIOPFactories.makeJavaCodebaseComponentFactory() ) ;
	compFinder.registerFactory( 
	    IIOPFactories.makeORBTypeComponentFactory() ) ;
	compFinder.registerFactory( 
	    IIOPFactories.makeMaxStreamFormatVersionComponentFactory() ) ;
	compFinder.registerFactory( 
	    IIOPFactories.makeAlternateIIOPAddressComponentFactory() ) ;
	compFinder.registerFactory( 
	    IIOPFactories.makeRequestPartitioningComponentFactory() ) ;
	compFinder.registerFactory(
	    IIOPFactories.makeJavaSerializationComponentFactory());

	// Register the ValueFactory instances for ORT
	IORFactories.registerValueFactories( orb ) ;

	// Register an ObjectKeyFactory
	orb.setObjectKeyFactory( IORFactories.makeObjectKeyFactory(orb) ) ;
    }

    private void initRequestDispatcherRegistry( ORB orb ) 
    {
	RequestDispatcherRegistry scr = orb.getRequestDispatcherRegistry() ;

	// register client subcontracts
	ClientRequestDispatcher csub = 
	    RequestDispatcherDefault.makeClientRequestDispatcher() ;
	scr.registerClientRequestDispatcher( csub, 
	    ORBConstants.TOA_SCID ) ;
	scr.registerClientRequestDispatcher( csub, 
	    ORBConstants.TRANSIENT_SCID ) ;
	scr.registerClientRequestDispatcher( csub, 
	    ORBConstants.PERSISTENT_SCID ) ;
	scr.registerClientRequestDispatcher( csub, 
	    ORBConstants.SC_TRANSIENT_SCID ) ;
	scr.registerClientRequestDispatcher( csub, 
	    ORBConstants.SC_PERSISTENT_SCID ) ;
	scr.registerClientRequestDispatcher( csub,  
	    ORBConstants.IISC_TRANSIENT_SCID ) ;
	scr.registerClientRequestDispatcher( csub, 
	    ORBConstants.IISC_PERSISTENT_SCID ) ;
	scr.registerClientRequestDispatcher( csub, 
	    ORBConstants.MINSC_TRANSIENT_SCID ) ;
	scr.registerClientRequestDispatcher( csub, 
	    ORBConstants.MINSC_PERSISTENT_SCID ) ;
	
	// register server delegates
	CorbaServerRequestDispatcher sd = 
	    RequestDispatcherDefault.makeServerRequestDispatcher( orb );
	scr.registerServerRequestDispatcher( sd, 
	    ORBConstants.TOA_SCID ) ;
	scr.registerServerRequestDispatcher( sd, 
	    ORBConstants.TRANSIENT_SCID ) ;
	scr.registerServerRequestDispatcher( sd, 
	    ORBConstants.PERSISTENT_SCID ) ;
	scr.registerServerRequestDispatcher( sd, 
	    ORBConstants.SC_TRANSIENT_SCID ) ;
	scr.registerServerRequestDispatcher( sd, 
	    ORBConstants.SC_PERSISTENT_SCID ) ;
	scr.registerServerRequestDispatcher( sd, 
	    ORBConstants.IISC_TRANSIENT_SCID ) ;
	scr.registerServerRequestDispatcher( sd, 
	    ORBConstants.IISC_PERSISTENT_SCID ) ;
	scr.registerServerRequestDispatcher( sd, 
	    ORBConstants.MINSC_TRANSIENT_SCID ) ;
	scr.registerServerRequestDispatcher( sd, 
	    ORBConstants.MINSC_PERSISTENT_SCID ) ;
	
	orb.setINSDelegate( 
	    RequestDispatcherDefault.makeINSServerRequestDispatcher( orb ) ) ;
	    
	// register local client subcontracts
	LocalClientRequestDispatcherFactory lcsf = 
	    RequestDispatcherDefault.makeJIDLLocalClientRequestDispatcherFactory( 
		orb ) ;
	scr.registerLocalClientRequestDispatcherFactory( lcsf, 
	    ORBConstants.TOA_SCID ) ;

	lcsf = 
	    RequestDispatcherDefault.makePOALocalClientRequestDispatcherFactory( 
		orb ) ;
	scr.registerLocalClientRequestDispatcherFactory( lcsf, 
	    ORBConstants.TRANSIENT_SCID ) ;
	scr.registerLocalClientRequestDispatcherFactory( lcsf, 
	    ORBConstants.PERSISTENT_SCID ) ;

	lcsf = RequestDispatcherDefault.
	    makeFullServantCacheLocalClientRequestDispatcherFactory( orb ) ;
	scr.registerLocalClientRequestDispatcherFactory( lcsf, 
	    ORBConstants.SC_TRANSIENT_SCID ) ;
	scr.registerLocalClientRequestDispatcherFactory( lcsf, 
	    ORBConstants.SC_PERSISTENT_SCID ) ;

	lcsf = RequestDispatcherDefault.
	    makeInfoOnlyServantCacheLocalClientRequestDispatcherFactory( orb ) ;
	scr.registerLocalClientRequestDispatcherFactory( lcsf, 
	    ORBConstants.IISC_TRANSIENT_SCID ) ;
	scr.registerLocalClientRequestDispatcherFactory( lcsf, 
	    ORBConstants.IISC_PERSISTENT_SCID ) ;

	lcsf = RequestDispatcherDefault.
	    makeMinimalServantCacheLocalClientRequestDispatcherFactory( orb ) ;
	scr.registerLocalClientRequestDispatcherFactory( lcsf, 
	    ORBConstants.MINSC_TRANSIENT_SCID ) ;
	scr.registerLocalClientRequestDispatcherFactory( lcsf, 
	    ORBConstants.MINSC_PERSISTENT_SCID ) ;

	/* Register the server delegate that implements the ancient bootstrap
	 * naming protocol.  This takes an object key of either "INIT" or 
	 * "TINI" to allow for big or little endian implementations.
	 */
	CorbaServerRequestDispatcher bootsd = 
	    RequestDispatcherDefault.makeBootstrapServerRequestDispatcher( 
		orb ) ;
	scr.registerServerRequestDispatcher( bootsd, "INIT" ) ;
	scr.registerServerRequestDispatcher( bootsd, "TINI" ) ;

	// Register object adapter factories
	ObjectAdapterFactory oaf = OADefault.makeTOAFactory( orb ) ;
	scr.registerObjectAdapterFactory( oaf, ORBConstants.TOA_SCID ) ;

	oaf = OADefault.makePOAFactory( orb ) ;
	scr.registerObjectAdapterFactory( oaf, ORBConstants.TRANSIENT_SCID ) ;
	scr.registerObjectAdapterFactory( oaf, ORBConstants.PERSISTENT_SCID ) ;
	scr.registerObjectAdapterFactory( oaf, ORBConstants.SC_TRANSIENT_SCID ) ;
	scr.registerObjectAdapterFactory( oaf, ORBConstants.SC_PERSISTENT_SCID ) ;
	scr.registerObjectAdapterFactory( oaf, ORBConstants.IISC_TRANSIENT_SCID ) ;
	scr.registerObjectAdapterFactory( oaf, ORBConstants.IISC_PERSISTENT_SCID ) ;
	scr.registerObjectAdapterFactory( oaf, ORBConstants.MINSC_TRANSIENT_SCID ) ;
	scr.registerObjectAdapterFactory( oaf, ORBConstants.MINSC_PERSISTENT_SCID ) ;
    } 
}

// End of file.