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