/*
* @(#)ORB.java 1.59 09/02/23
*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
package com.sun.corba.se.spi.orb;
import java.util.Map ;
import java.util.HashMap ;
import java.util.Properties ;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Logger ;
import java.security.AccessController ;
import java.security.PrivilegedAction ;
import org.omg.CORBA.TCKind ;
import com.sun.corba.se.pept.broker.Broker ;
import com.sun.corba.se.pept.transport.ByteBufferPool;
import com.sun.corba.se.spi.protocol.RequestDispatcherRegistry ;
import com.sun.corba.se.spi.protocol.ClientDelegateFactory ;
import com.sun.corba.se.spi.protocol.CorbaServerRequestDispatcher ;
import com.sun.corba.se.spi.protocol.CorbaMessageMediator ;
import com.sun.corba.se.spi.protocol.PIHandler ;
import com.sun.corba.se.spi.resolver.LocalResolver ;
import com.sun.corba.se.spi.resolver.Resolver ;
import com.sun.corba.se.spi.transport.CorbaContactInfoListFactory ;
import com.sun.corba.se.spi.legacy.connection.LegacyServerSocketEndPointInfo;
import com.sun.corba.se.spi.legacy.connection.LegacyServerSocketManager;
import com.sun.corba.se.spi.monitoring.MonitoringConstants;
import com.sun.corba.se.spi.monitoring.MonitoringManager;
import com.sun.corba.se.spi.monitoring.MonitoringManagerFactory;
import com.sun.corba.se.spi.monitoring.MonitoringFactories;
import com.sun.corba.se.spi.ior.IdentifiableFactoryFinder ;
import com.sun.corba.se.spi.ior.TaggedComponentFactoryFinder ;
import com.sun.corba.se.spi.ior.ObjectKey ;
import com.sun.corba.se.spi.ior.ObjectKeyFactory ;
import com.sun.corba.se.spi.ior.IOR ;
import com.sun.corba.se.spi.orbutil.closure.Closure ;
import com.sun.corba.se.spi.orb.Operation ;
import com.sun.corba.se.spi.orb.ORBData ;
import com.sun.corba.se.spi.orb.ORBVersion ;
import com.sun.corba.se.spi.orbutil.threadpool.ThreadPoolManager;
import com.sun.corba.se.spi.oa.OAInvocationInfo ;
import com.sun.corba.se.spi.transport.CorbaTransportManager;
import com.sun.corba.se.spi.logging.LogWrapperFactory ;
import com.sun.corba.se.spi.logging.LogWrapperBase ;
import com.sun.corba.se.spi.logging.CORBALogDomains ;
import com.sun.corba.se.spi.copyobject.CopierManager ;
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.ServiceContextRegistry ;
// XXX needs an SPI or else it does not belong here
import com.sun.corba.se.impl.corba.TypeCodeImpl ;
import com.sun.corba.se.impl.corba.TypeCodeFactory ;
// XXX Should there be a SPI level constants ?
import com.sun.corba.se.impl.orbutil.ORBConstants ;
import com.sun.corba.se.impl.oa.poa.BadServerIdHandler ;
import com.sun.corba.se.impl.transport.ByteBufferPoolImpl;
import com.sun.corba.se.impl.logging.ORBUtilSystemException ;
import com.sun.corba.se.impl.logging.OMGSystemException ;
import com.sun.corba.se.impl.presentation.rmi.PresentationManagerImpl ;
import com.sun.corba.se.impl.orbutil.ORBClassLoader ;
public abstract class ORB extends com.sun.corba.se.org.omg.CORBA.ORB
implements Broker, TypeCodeFactory
{
// As much as possible, this class should be stateless. However,
// there are a few reasons why it is not:
//
// 1. The ORB debug flags are defined here because they are accessed
// frequently, and we do not want a cast to the impl just for that.
// 2. typeCodeMap and primitiveTypeCodeConstants are here because they
// are needed in both ORBImpl and ORBSingleton.
// 3. Logging support is here so that we can avoid problems with
// incompletely initialized ORBs that need to perform logging.
// Flag set at compile time to debug flag processing: this can't
// be one of the xxxDebugFlags because it is used to debug the mechanism
// that sets the xxxDebugFlags!
public static boolean ORBInitDebug = false;
// Currently defined debug flags. Any additions must be called xxxDebugFlag.
// All debug flags must be public boolean types.
// These are set by passing the flag -ORBDebug x,y,z in the ORB init args.
// Note that x,y,z must not contain spaces.
public boolean transportDebugFlag = false ;
public boolean subcontractDebugFlag = false ;
public boolean poaDebugFlag = false ;
public boolean poaConcurrencyDebugFlag = false ;
public boolean poaFSMDebugFlag = false ;
public boolean orbdDebugFlag = false ;
public boolean namingDebugFlag = false ;
public boolean serviceContextDebugFlag = false ;
public boolean transientObjectManagerDebugFlag = false ;
public boolean giopVersionDebugFlag = false;
public boolean shutdownDebugFlag = false;
public boolean giopDebugFlag = false;
public boolean invocationTimingDebugFlag = false ;
// SystemException log wrappers. Protected so that they can be used in
// subclasses.
protected static ORBUtilSystemException staticWrapper ;
protected ORBUtilSystemException wrapper ;
protected OMGSystemException omgWrapper ;
// This map is needed for resolving recursive type code placeholders
// based on the unique repository id.
// XXX Should this be a WeakHashMap for GC?
private Map typeCodeMap ;
private TypeCodeImpl[] primitiveTypeCodeConstants ;
// ByteBufferPool - needed by both ORBImpl and ORBSingleton
ByteBufferPool byteBufferPool;
// Local testing
// XXX clean this up, probably remove these
public abstract boolean isLocalHost( String hostName ) ;
public abstract boolean isLocalServerId( int subcontractId, int serverId ) ;
// Invocation stack manipulation
public abstract OAInvocationInfo peekInvocationInfo() ;
public abstract void pushInvocationInfo( OAInvocationInfo info ) ;
public abstract OAInvocationInfo popInvocationInfo() ;
public abstract CorbaTransportManager getCorbaTransportManager();
public abstract LegacyServerSocketManager getLegacyServerSocketManager();
// wrapperMap maintains a table of LogWrapper instances used by
// different classes to log exceptions. The key is a StringPair
// representing LogDomain and ExceptionGroup.
private Map wrapperMap ;
private static Map staticWrapperMap = new ConcurrentHashMap();
protected MonitoringManager monitoringManager;
// There is only one instance of the PresentationManager
// that is shared between all ORBs. This is necessary
// because RMI-IIOP requires the PresentationManager in
// places where no ORB is available, so the PresentationManager
// must be global. It is initialized here as well.
protected static PresentationManager globalPM = null ;
static {
staticWrapper = ORBUtilSystemException.get(
CORBALogDomains.RPC_PRESENTATION ) ;
boolean useDynamicStub =
((Boolean)AccessController.doPrivileged(
new PrivilegedAction() {
public java.lang.Object run() {
return Boolean.valueOf( Boolean.getBoolean (
ORBConstants.USE_DYNAMIC_STUB_PROPERTY ) ) ;
}
}
)).booleanValue() ;
PresentationManager.StubFactoryFactory dynamicStubFactoryFactory =
(PresentationManager.StubFactoryFactory)AccessController.doPrivileged(
new PrivilegedAction() {
public java.lang.Object run() {
PresentationManager.StubFactoryFactory sff =
PresentationDefaults.getProxyStubFactoryFactory() ;
String className = System.getProperty(
ORBConstants.DYNAMIC_STUB_FACTORY_FACTORY_CLASS,
"com.sun.corba.se.impl.presentation.rmi.bcel.StubFactoryFactoryBCELImpl" ) ;
try {
// First try the configured class name, if any
Class cls = ORBClassLoader.loadClass( className ) ;
sff = (PresentationManager.StubFactoryFactory)cls.newInstance() ;
} catch (Exception exc) {
// Use the default. Log the error as a warning.
staticWrapper.errorInSettingDynamicStubFactoryFactory(
exc, className ) ;
}
return sff ;
}
}
) ;
globalPM = new PresentationManagerImpl( useDynamicStub ) ;
globalPM.setStubFactoryFactory( false,
PresentationDefaults.getStaticStubFactoryFactory() ) ;
globalPM.setStubFactoryFactory( true, dynamicStubFactoryFactory ) ;
}
public void destroy() {
wrapper = null ;
omgWrapper = null ;
typeCodeMap = null ;
primitiveTypeCodeConstants = null ;
byteBufferPool = null ;
}
/** Get the single instance of the PresentationManager
*/
public static PresentationManager getPresentationManager()
{
return globalPM ;
}
/** Get the appropriate StubFactoryFactory. This
* will be dynamic or static depending on whether
* com.sun.CORBA.ORBUseDynamicStub is true or false.
*/
public static PresentationManager.StubFactoryFactory
getStubFactoryFactory()
{
boolean useDynamicStubs = globalPM.useDynamicStubs() ;
return globalPM.getStubFactoryFactory( useDynamicStubs ) ;
}
protected ORB()
{
// Initialize logging first, since it is needed nearly
// everywhere (for example, in TypeCodeImpl).
wrapperMap = new ConcurrentHashMap();
wrapper = ORBUtilSystemException.get( this,
CORBALogDomains.RPC_PRESENTATION ) ;
omgWrapper = OMGSystemException.get( this,
CORBALogDomains.RPC_PRESENTATION ) ;
typeCodeMap = new HashMap();
primitiveTypeCodeConstants = new TypeCodeImpl[] {
new TypeCodeImpl(this, TCKind._tk_null),
new TypeCodeImpl(this, TCKind._tk_void),
new TypeCodeImpl(this, TCKind._tk_short),
new TypeCodeImpl(this, TCKind._tk_long),
new TypeCodeImpl(this, TCKind._tk_ushort),
new TypeCodeImpl(this, TCKind._tk_ulong),
new TypeCodeImpl(this, TCKind._tk_float),
new TypeCodeImpl(this, TCKind._tk_double),
new TypeCodeImpl(this, TCKind._tk_boolean),
new TypeCodeImpl(this, TCKind._tk_char),
new TypeCodeImpl(this, TCKind._tk_octet),
new TypeCodeImpl(this, TCKind._tk_any),
new TypeCodeImpl(this, TCKind._tk_TypeCode),
new TypeCodeImpl(this, TCKind._tk_Principal),
new TypeCodeImpl(this, TCKind._tk_objref),
null, // tk_struct
null, // tk_union
null, // tk_enum
new TypeCodeImpl(this, TCKind._tk_string),
null, // tk_sequence
null, // tk_array
null, // tk_alias
null, // tk_except
new TypeCodeImpl(this, TCKind._tk_longlong),
new TypeCodeImpl(this, TCKind._tk_ulonglong),
new TypeCodeImpl(this, TCKind._tk_longdouble),
new TypeCodeImpl(this, TCKind._tk_wchar),
new TypeCodeImpl(this, TCKind._tk_wstring),
new TypeCodeImpl(this, TCKind._tk_fixed),
new TypeCodeImpl(this, TCKind._tk_value),
new TypeCodeImpl(this, TCKind._tk_value_box),
new TypeCodeImpl(this, TCKind._tk_native),
new TypeCodeImpl(this, TCKind._tk_abstract_interface)
} ;
monitoringManager =
MonitoringFactories.getMonitoringManagerFactory( ).
createMonitoringManager(
MonitoringConstants.DEFAULT_MONITORING_ROOT,
MonitoringConstants.DEFAULT_MONITORING_ROOT_DESCRIPTION);
}
// Typecode support: needed in both ORBImpl and ORBSingleton
public TypeCodeImpl get_primitive_tc(int kind)
{
synchronized (this) {
checkShutdownState();
}
try {
return primitiveTypeCodeConstants[kind] ;
} catch (Throwable t) {
throw wrapper.invalidTypecodeKind( t, new Integer(kind) ) ;
}
}
public synchronized void setTypeCode(String id, TypeCodeImpl code)
{
checkShutdownState();
typeCodeMap.put(id, code);
}
public synchronized TypeCodeImpl getTypeCode(String id)
{
checkShutdownState();
return (TypeCodeImpl)typeCodeMap.get(id);
}
public MonitoringManager getMonitoringManager( ) {
synchronized (this) {
checkShutdownState();
}
return monitoringManager;
}
// Special non-standard set_parameters method for
// creating a precisely controlled ORB instance.
// An ORB created by this call is affected only by
// those properties passes explicitly in props, not by
// the system properties and orb.properties files as
// with the standard ORB.init methods.
public abstract void set_parameters( Properties props ) ;
// ORB versioning
public abstract ORBVersion getORBVersion() ;
public abstract void setORBVersion( ORBVersion version ) ;
// XXX This needs a better name
public abstract IOR getFVDCodeBaseIOR() ;
/**
* Handle a bad server id for the given object key. This should
* always through an exception: either a ForwardException to
* allow another server to handle the request, or else an error
* indication. XXX Remove after ORT for ORBD work is integrated.
*/
public abstract void handleBadServerId( ObjectKey okey ) ;
public abstract void setBadServerIdHandler( BadServerIdHandler handler ) ;
public abstract void initBadServerIdHandler() ;
public abstract void notifyORB() ;
public abstract PIHandler getPIHandler() ;
public abstract void checkShutdownState();
// Dispatch support: in the ORB because it is needed for shutdown.
// This is used by the first level server side subcontract.
public abstract boolean isDuringDispatch() ;
public abstract void startingDispatch();
public abstract void finishedDispatch();
/** Return this ORB's transient server ID. This is needed for
* initializing object adapters.
*/
public abstract int getTransientServerId();
public abstract ServiceContextRegistry getServiceContextRegistry() ;
public abstract RequestDispatcherRegistry getRequestDispatcherRegistry();
public abstract ORBData getORBData() ;
public abstract void setClientDelegateFactory( ClientDelegateFactory factory ) ;
public abstract ClientDelegateFactory getClientDelegateFactory() ;
public abstract void setCorbaContactInfoListFactory( CorbaContactInfoListFactory factory ) ;
public abstract CorbaContactInfoListFactory getCorbaContactInfoListFactory() ;
// XXX These next 7 methods should be moved to a ResolverManager.
/** Set the resolver used in this ORB. This resolver will be used for list_initial_services
* and resolve_initial_references.
*/
public abstract void setResolver( Resolver resolver ) ;
/** Get the resolver used in this ORB. This resolver will be used for list_initial_services
* and resolve_initial_references.
*/
public abstract Resolver getResolver() ;
/** Set the LocalResolver used in this ORB. This LocalResolver is used for
* register_initial_reference only.
*/
public abstract void setLocalResolver( LocalResolver resolver ) ;
/** Get the LocalResolver used in this ORB. This LocalResolver is used for
* register_initial_reference only.
*/
public abstract LocalResolver getLocalResolver() ;
/** Set the operation used in string_to_object calls. The Operation must expect a
* String and return an org.omg.CORBA.Object.
*/
public abstract void setURLOperation( Operation stringToObject ) ;
/** Get the operation used in string_to_object calls. The Operation must expect a
* String and return an org.omg.CORBA.Object.
*/
public abstract Operation getURLOperation() ;
/** Set the ServerRequestDispatcher that should be used for handling INS requests.
*/
public abstract void setINSDelegate( CorbaServerRequestDispatcher insDelegate ) ;
// XXX The next 5 operations should be moved to an IORManager.
/** Factory finders for the various parts of the IOR: tagged components, tagged
* profiles, and tagged profile templates.
*/
public abstract TaggedComponentFactoryFinder getTaggedComponentFactoryFinder() ;
public abstract IdentifiableFactoryFinder getTaggedProfileFactoryFinder() ;
public abstract IdentifiableFactoryFinder getTaggedProfileTemplateFactoryFinder() ;
public abstract ObjectKeyFactory getObjectKeyFactory() ;
public abstract void setObjectKeyFactory( ObjectKeyFactory factory ) ;
// Logging SPI
/**
* Returns the logger based on the category.
*/
public Logger getLogger( String domain )
{
synchronized (this) {
checkShutdownState();
}
ORBData odata = getORBData() ;
// Determine the correct ORBId. There are 3 cases:
// 1. odata is null, which happens if we are getting a logger before
// ORB initialization is complete. In this case we cannot determine
// the ORB ID (it's not known yet), so we set the ORBId to
// _INITIALIZING_.
// 2. odata is not null, so initialization is complete, but ORBId is set to
// the default "". To avoid a ".." in
// the log domain, we simply use _DEFAULT_ in this case.
// 3. odata is not null, ORBId is not "": just use the ORBId.
String ORBId ;
if (odata == null)
ORBId = "_INITIALIZING_" ;
else {
ORBId = odata.getORBId() ;
if (ORBId.equals(""))
ORBId = "_DEFAULT_" ;
}
return getCORBALogger( ORBId, domain ) ;
}
public static Logger staticGetLogger( String domain )
{
return getCORBALogger( "_CORBA_", domain ) ;
}
private static Logger getCORBALogger( String ORBId, String domain )
{
String fqLogDomain = CORBALogDomains.TOP_LEVEL_DOMAIN + "." +
ORBId + "." + domain;
return Logger.getLogger( fqLogDomain, ORBConstants.LOG_RESOURCE_FILE );
}
/** get the log wrapper class (its type is dependent on the exceptionGroup) for the
* given log domain and exception group in this ORB instance.
*/
public LogWrapperBase getLogWrapper( String logDomain,
String exceptionGroup, LogWrapperFactory factory )
{
StringPair key = new StringPair( logDomain, exceptionGroup ) ;
LogWrapperBase logWrapper = (LogWrapperBase)wrapperMap.get( key );
if (logWrapper == null) {
logWrapper = factory.create( getLogger( logDomain ) );
wrapperMap.put( key, logWrapper );
}
return logWrapper;
}
/** get the log wrapper class (its type is dependent on the exceptionGroup) for the
* given log domain and exception group in this ORB instance.
*/
public static LogWrapperBase staticGetLogWrapper( String logDomain,
String exceptionGroup, LogWrapperFactory factory )
{
StringPair key = new StringPair( logDomain, exceptionGroup ) ;
LogWrapperBase logWrapper = (LogWrapperBase)staticWrapperMap.get( key );
if (logWrapper == null) {
logWrapper = factory.create( staticGetLogger( logDomain ) );
staticWrapperMap.put( key, logWrapper );
}
return logWrapper;
}
// get a reference to a ByteBufferPool, a pool of NIO ByteBuffers
// NOTE: ByteBuffer pool must be unique per ORB, not per process.
// There can be more than one ORB per process.
// This method must also be inherited by both ORB and ORBSingleton.
public ByteBufferPool getByteBufferPool()
{
synchronized (this) {
checkShutdownState();
}
if (byteBufferPool == null)
byteBufferPool = new ByteBufferPoolImpl(this);
return byteBufferPool;
}
public abstract void setThreadPoolManager(ThreadPoolManager mgr);
public abstract ThreadPoolManager getThreadPoolManager();
public abstract CopierManager getCopierManager() ;
}
// End of file.