IceInternal.Instance Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of ice-compat Show documentation
Show all versions of ice-compat Show documentation
Ice is a comprehensive RPC framework that helps you build distributed applications with minimal effort using familiar object-oriented idioms
The newest version!
//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
package IceInternal;
import java.util.concurrent.TimeUnit;
public final class Instance implements Ice.ClassResolver
{
static private class ThreadObserverHelper
{
ThreadObserverHelper(String threadName)
{
_threadName = threadName;
}
synchronized public void updateObserver(Ice.Instrumentation.CommunicatorObserver obsv)
{
assert(obsv != null);
_observer = obsv.getThreadObserver("Communicator",
_threadName,
Ice.Instrumentation.ThreadState.ThreadStateIdle,
_observer);
if(_observer != null)
{
_observer.attach();
}
}
protected void beforeExecute()
{
_threadObserver = _observer;
if(_threadObserver != null)
{
_threadObserver.stateChanged(Ice.Instrumentation.ThreadState.ThreadStateIdle,
Ice.Instrumentation.ThreadState.ThreadStateInUseForOther);
}
}
protected void afterExecute()
{
if(_threadObserver != null)
{
_threadObserver.stateChanged(Ice.Instrumentation.ThreadState.ThreadStateInUseForOther,
Ice.Instrumentation.ThreadState.ThreadStateIdle);
_threadObserver = null;
}
}
final private String _threadName;
//
// We use a volatile to avoid synchronization when reading
// _observer. Reference assignement is atomic in Java so it
// also doesn't need to be synchronized.
//
private volatile Ice.Instrumentation.ThreadObserver _observer;
private Ice.Instrumentation.ThreadObserver _threadObserver;
}
static private class Timer extends java.util.concurrent.ScheduledThreadPoolExecutor
{
Timer(Ice.Properties props, String threadName)
{
super(1, Util.createThreadFactory(props, threadName)); // Single thread executor
setRemoveOnCancelPolicy(true);
setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
_observerHelper = new ThreadObserverHelper(threadName);
}
public void updateObserver(Ice.Instrumentation.CommunicatorObserver obsv)
{
_observerHelper.updateObserver(obsv);
}
@Override
protected void beforeExecute(Thread t, Runnable r)
{
_observerHelper.beforeExecute();
}
@Override
protected void afterExecute(Runnable t, Throwable e)
{
_observerHelper.afterExecute();
}
private final ThreadObserverHelper _observerHelper;
}
static private class QueueExecutor extends java.util.concurrent.ThreadPoolExecutor
{
QueueExecutor(Ice.Properties props, String threadName)
{
super(1, 1, 0, TimeUnit.MILLISECONDS, new java.util.concurrent.LinkedBlockingQueue(),
Util.createThreadFactory(props, threadName));
_observerHelper = new ThreadObserverHelper(threadName);
}
public void updateObserver(Ice.Instrumentation.CommunicatorObserver obsv)
{
_observerHelper.updateObserver(obsv);
}
@Override
protected void beforeExecute(Thread t, Runnable r)
{
_observerHelper.beforeExecute();
}
@Override
protected void afterExecute(Runnable t, Throwable e)
{
_observerHelper.afterExecute();
}
public void destroy()
throws InterruptedException
{
shutdown();
while(!isTerminated())
{
// A very long time.
awaitTermination(100000, java.util.concurrent.TimeUnit.SECONDS);
}
}
private final ThreadObserverHelper _observerHelper;
}
private class ObserverUpdaterI implements Ice.Instrumentation.ObserverUpdater
{
@Override
public void
updateConnectionObservers()
{
Instance.this.updateConnectionObservers();
}
@Override
public void
updateThreadObservers()
{
Instance.this.updateThreadObservers();
}
}
public Ice.InitializationData
initializationData()
{
//
// No check for destruction. It must be possible to access the
// initialization data after destruction.
//
// No mutex lock, immutable.
//
return _initData;
}
public TraceLevels
traceLevels()
{
// No mutex lock, immutable.
assert(_traceLevels != null);
return _traceLevels;
}
public DefaultsAndOverrides
defaultsAndOverrides()
{
// No mutex lock, immutable.
assert(_defaultsAndOverrides != null);
return _defaultsAndOverrides;
}
public synchronized RouterManager
routerManager()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
assert(_routerManager != null);
return _routerManager;
}
public synchronized LocatorManager
locatorManager()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
assert(_locatorManager != null);
return _locatorManager;
}
public synchronized ReferenceFactory
referenceFactory()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
assert(_referenceFactory != null);
return _referenceFactory;
}
public synchronized RequestHandlerFactory
requestHandlerFactory()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
assert(_requestHandlerFactory != null);
return _requestHandlerFactory;
}
public synchronized ProxyFactory
proxyFactory()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
assert(_proxyFactory != null);
return _proxyFactory;
}
public synchronized OutgoingConnectionFactory
outgoingConnectionFactory()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
assert(_outgoingConnectionFactory != null);
return _outgoingConnectionFactory;
}
public synchronized ObjectAdapterFactory
objectAdapterFactory()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
assert(_objectAdapterFactory != null);
return _objectAdapterFactory;
}
public int
protocolSupport()
{
return _protocolSupport;
}
public boolean
preferIPv6()
{
return _preferIPv6;
}
public NetworkProxy
networkProxy()
{
return _networkProxy;
}
public synchronized ThreadPool
clientThreadPool()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
assert(_clientThreadPool != null);
return _clientThreadPool;
}
public synchronized ThreadPool
serverThreadPool()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
if(_serverThreadPool == null) // Lazy initialization.
{
if(_state == StateDestroyInProgress)
{
throw new Ice.CommunicatorDestroyedException();
}
int timeout = _initData.properties.getPropertyAsInt("Ice.ServerIdleTime");
_serverThreadPool = new ThreadPool(this, "Ice.ThreadPool.Server", timeout);
}
return _serverThreadPool;
}
public synchronized EndpointHostResolver
endpointHostResolver()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
assert(_endpointHostResolver != null);
return _endpointHostResolver;
}
synchronized public RetryQueue
retryQueue()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
assert(_retryQueue != null);
return _retryQueue;
}
synchronized public java.util.concurrent.ScheduledExecutorService
timer()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
assert(_timer != null);
return _timer;
}
public synchronized EndpointFactoryManager
endpointFactoryManager()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
assert(_endpointFactoryManager != null);
return _endpointFactoryManager;
}
public synchronized Ice.PluginManager
pluginManager()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
assert(_pluginManager != null);
return _pluginManager;
}
public int
messageSizeMax()
{
// No mutex lock, immutable.
return _messageSizeMax;
}
public int
batchAutoFlushSize()
{
// No mutex lock, immutable.
return _batchAutoFlushSize;
}
public Ice.ToStringMode
toStringMode()
{
// No mutex lock, immutable
return _toStringMode;
}
public int
cacheMessageBuffers()
{
// No mutex lock, immutable.
return _cacheMessageBuffers;
}
public ACMConfig
clientACM()
{
// No mutex lock, immutable.
return _clientACM;
}
public ACMConfig
serverACM()
{
// No mutex lock, immutable.
return _serverACM;
}
public Ice.ImplicitContextI
getImplicitContext()
{
return _implicitContext;
}
public synchronized Ice.ObjectPrx
createAdmin(Ice.ObjectAdapter adminAdapter, Ice.Identity adminIdentity)
{
if(Thread.interrupted())
{
throw new Ice.OperationInterruptedException();
}
boolean createAdapter = (adminAdapter == null);
synchronized(this)
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
if(adminIdentity == null || adminIdentity.name == null || adminIdentity.name.isEmpty())
{
throw new Ice.IllegalIdentityException(adminIdentity);
}
if(_adminAdapter != null)
{
throw new Ice.InitializationException("Admin already created");
}
if(!_adminEnabled)
{
throw new Ice.InitializationException("Admin is disabled");
}
if(createAdapter)
{
if(!_initData.properties.getProperty("Ice.Admin.Endpoints").isEmpty())
{
adminAdapter = _objectAdapterFactory.createObjectAdapter("Ice.Admin", null);
}
else
{
throw new Ice.InitializationException("Ice.Admin.Endpoints is not set");
}
}
_adminIdentity = adminIdentity;
_adminAdapter = adminAdapter;
addAllAdminFacets();
}
if(createAdapter)
{
try
{
adminAdapter.activate();
}
catch(Ice.LocalException ex)
{
//
// We cleanup _adminAdapter, however this error is not recoverable
// (can't call again getAdmin() after fixing the problem)
// since all the facets (servants) in the adapter are lost
//
adminAdapter.destroy();
synchronized(this)
{
_adminAdapter = null;
}
throw ex;
}
}
setServerProcessProxy(adminAdapter, adminIdentity);
return adminAdapter.createProxy(adminIdentity);
}
public Ice.ObjectPrx
getAdmin()
{
if(Thread.interrupted())
{
throw new Ice.OperationInterruptedException();
}
Ice.ObjectAdapter adminAdapter;
Ice.Identity adminIdentity;
synchronized(this)
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
if(_adminAdapter != null)
{
return _adminAdapter.createProxy(_adminIdentity);
}
else if(_adminEnabled)
{
if(!_initData.properties.getProperty("Ice.Admin.Endpoints").isEmpty())
{
adminAdapter = _objectAdapterFactory.createObjectAdapter("Ice.Admin", null);
}
else
{
return null;
}
adminIdentity = new Ice.Identity("admin", _initData.properties.getProperty("Ice.Admin.InstanceName"));
if(adminIdentity.category.isEmpty())
{
adminIdentity.category = java.util.UUID.randomUUID().toString();
}
_adminIdentity = adminIdentity;
_adminAdapter = adminAdapter;
addAllAdminFacets();
// continue below outside synchronization
}
else
{
return null;
}
}
try
{
adminAdapter.activate();
}
catch(Ice.LocalException ex)
{
//
// We cleanup _adminAdapter, however this error is not recoverable
// (can't call again getAdmin() after fixing the problem)
// since all the facets (servants) in the adapter are lost
//
adminAdapter.destroy();
synchronized(this)
{
_adminAdapter = null;
}
throw ex;
}
setServerProcessProxy(adminAdapter, adminIdentity);
return adminAdapter.createProxy(adminIdentity);
}
public synchronized void
addAdminFacet(Ice.Object servant, String facet)
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
if(_adminAdapter == null || (!_adminFacetFilter.isEmpty() && !_adminFacetFilter.contains(facet)))
{
if(_adminFacets.get(facet) != null)
{
throw new Ice.AlreadyRegisteredException("facet", facet);
}
_adminFacets.put(facet, servant);
}
else
{
_adminAdapter.addFacet(servant, _adminIdentity, facet);
}
}
public synchronized Ice.Object
removeAdminFacet(String facet)
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
Ice.Object result;
if(_adminAdapter == null || (!_adminFacetFilter.isEmpty() && !_adminFacetFilter.contains(facet)))
{
result = _adminFacets.remove(facet);
if(result == null)
{
throw new Ice.NotRegisteredException("facet", facet);
}
}
else
{
result = _adminAdapter.removeFacet(_adminIdentity, facet);
}
return result;
}
public synchronized Ice.Object
findAdminFacet(String facet)
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
Ice.Object result = null;
if(_adminAdapter == null || (!_adminFacetFilter.isEmpty() && !_adminFacetFilter.contains(facet)))
{
result = _adminFacets.get(facet);
}
else
{
result = _adminAdapter.findFacet(_adminIdentity, facet);
}
return result;
}
public synchronized java.util.Map
findAllAdminFacets()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
if(_adminAdapter == null)
{
return new java.util.HashMap(_adminFacets);
}
else
{
java.util.Map result = _adminAdapter.findAllFacets(_adminIdentity);
if(!_adminFacets.isEmpty())
{
// Also returns filtered facets
result.putAll(_adminFacets);
}
return result;
}
}
public synchronized void
setDefaultLocator(Ice.LocatorPrx locator)
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
_referenceFactory = _referenceFactory.setDefaultLocator(locator);
}
public synchronized void
setDefaultRouter(Ice.RouterPrx router)
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
_referenceFactory = _referenceFactory.setDefaultRouter(router);
}
public void
setLogger(Ice.Logger logger)
{
//
// No locking, as it can only be called during plug-in loading
//
_initData.logger = logger;
}
public void
setThreadHook(Ice.ThreadNotification threadHook)
{
//
// No locking, as it can only be called during plug-in loading
//
_initData.threadHook = threadHook;
}
public Class
findClass(String className)
{
return Util.findClass(className, _initData.classLoader);
}
public ClassLoader
getClassLoader()
{
return _initData.classLoader;
}
//
// From Ice.ClassResolver.
//
public Class resolveClass(String typeId)
throws LinkageError
{
Class c = null;
//
// To convert a Slice type id into a Java class, we do the following:
//
// 1. Convert the Slice type id into a classname (e.g., ::M::X -> M.X).
// 2. If that fails, extract the top-level module (if any) from the type id
// and check for an Package property. If found, prepend the property
// value to the classname.
// 3. If that fails, check for an Default.Package property. If found,
// prepend the property value to the classname.
//
String className;
boolean addClass = false;
synchronized(this)
{
className = _typeToClassMap.get(typeId);
}
if(className == null)
{
className = Ice.Util.typeIdToClass(typeId);
addClass = true;
}
c = getConcreteClass(className);
if(c == null)
{
int pos = typeId.indexOf(':', 2);
if(pos != -1)
{
String topLevelModule = typeId.substring(2, pos);
String pkg = _initData.properties.getProperty("Ice.Package." + topLevelModule);
if(pkg.length() > 0)
{
c = getConcreteClass(pkg + "." + className);
}
}
}
if(c == null)
{
String pkg = _initData.properties.getProperty("Ice.Default.Package");
if(pkg.length() > 0)
{
c = getConcreteClass(pkg + "." + className);
}
}
if(c != null && addClass)
{
synchronized(this)
{
className = c.getName();
if(_typeToClassMap.containsKey(typeId))
{
assert(_typeToClassMap.get(typeId).equals(className));
}
else
{
_typeToClassMap.put(typeId, className);
}
}
}
return c;
}
public String resolveCompactId(int compactId)
{
String className = "IceCompactId.TypeId_" + Integer.toString(compactId);
Class c = getConcreteClass(className);
if(c == null)
{
for(String pkg : _packages)
{
c = getConcreteClass(pkg + "." + className);
if(c != null)
{
break;
}
}
}
if(c != null)
{
try
{
return (String)c.getField("typeId").get(null);
}
catch(Exception ex)
{
assert(false);
}
}
return "";
}
public Class getConcreteClass(String className)
throws LinkageError
{
Class c = findClass(className);
if(c != null)
{
//
// Ensure the class is instantiable. The constants are
// defined in the JVM specification (0x200 = interface,
// 0x400 = abstract).
//
final int modifiers = c.getModifiers();
if((modifiers & 0x200) == 0 && (modifiers & 0x400) == 0)
{
return c;
}
}
return null;
}
public boolean
useApplicationClassLoader()
{
return _useApplicationClassLoader;
}
public boolean
queueRequests()
{
return _queueExecutorService != null;
}
synchronized public QueueExecutorService
getQueueExecutor()
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
return _queueExecutorService;
}
//
// Only for use by Ice.CommunicatorI
//
public
Instance(Ice.Communicator communicator, Ice.InitializationData initData)
{
_state = StateActive;
_initData = initData;
try
{
if(_initData.properties == null)
{
_initData.properties = Ice.Util.createProperties();
}
synchronized(Instance.class)
{
if(!_oneOffDone)
{
String stdOut = _initData.properties.getProperty("Ice.StdOut");
String stdErr = _initData.properties.getProperty("Ice.StdErr");
java.io.PrintStream outStream = null;
if(stdOut.length() > 0)
{
//
// We need to close the existing stdout for JVM thread dump to go
// to the new file
//
System.out.close();
try
{
outStream = new java.io.PrintStream(new java.io.FileOutputStream(stdOut, true));
}
catch(java.io.FileNotFoundException ex)
{
throw new Ice.FileException(0, stdOut, ex);
}
System.setOut(outStream);
}
if(stdErr.length() > 0)
{
//
// close for consistency with stdout
//
System.err.close();
if(stdErr.equals(stdOut))
{
System.setErr(outStream);
}
else
{
try
{
System.setErr(new java.io.PrintStream(new java.io.FileOutputStream(stdErr, true)));
}
catch(java.io.FileNotFoundException ex)
{
throw new Ice.FileException(0, stdErr, ex);
}
}
}
_oneOffDone = true;
}
}
if(_initData.logger == null)
{
String logfile = _initData.properties.getProperty("Ice.LogFile");
if(_initData.properties.getPropertyAsInt("Ice.UseSyslog") > 0 &&
!System.getProperty("os.name").startsWith("Windows"))
{
if(logfile.length() != 0)
{
throw new Ice.InitializationException("Both syslog and file logger cannot be enabled.");
}
_initData.logger = new Ice.SysLoggerI(_initData.properties.getProperty("Ice.ProgramName"),
_initData.properties.getPropertyWithDefault("Ice.SyslogFacility", "LOG_USER"));
}
else if(logfile.length() != 0)
{
_initData.logger = new Ice.LoggerI(_initData.properties.getProperty("Ice.ProgramName"), logfile);
}
else
{
_initData.logger = Ice.Util.getProcessLogger();
if(_initData.logger instanceof Ice.LoggerI)
{
_initData.logger =
new Ice.LoggerI(_initData.properties.getProperty("Ice.ProgramName"), "");
}
}
}
_packages = validatePackages();
_useApplicationClassLoader = _initData.properties.getPropertyAsInt("Ice.UseApplicationClassLoader") > 0;
_traceLevels = new TraceLevels(_initData.properties);
_defaultsAndOverrides = new DefaultsAndOverrides(_initData.properties, _initData.logger);
_clientACM = new ACMConfig(_initData.properties,
_initData.logger,
"Ice.ACM.Client",
new ACMConfig(_initData.properties, _initData.logger, "Ice.ACM",
new ACMConfig(false)));
_serverACM = new ACMConfig(_initData.properties,
_initData.logger,
"Ice.ACM.Server",
new ACMConfig(_initData.properties, _initData.logger, "Ice.ACM",
new ACMConfig(true)));
{
final int defaultMessageSizeMax = 1024;
int num = _initData.properties.getPropertyAsIntWithDefault("Ice.MessageSizeMax", defaultMessageSizeMax);
if(num < 1 || num > 0x7fffffff / 1024)
{
_messageSizeMax = 0x7fffffff;
}
else
{
_messageSizeMax = num * 1024; // Property is in kilobytes, _messageSizeMax in bytes
}
}
if(_initData.properties.getProperty("Ice.BatchAutoFlushSize").isEmpty() &&
!_initData.properties.getProperty("Ice.BatchAutoFlush").isEmpty())
{
if(_initData.properties.getPropertyAsInt("Ice.BatchAutoFlush") > 0)
{
_batchAutoFlushSize = _messageSizeMax;
}
else
{
_batchAutoFlushSize = 0;
}
}
else
{
int num = _initData.properties.getPropertyAsIntWithDefault("Ice.BatchAutoFlushSize", 1024); // 1MB
if(num < 1)
{
_batchAutoFlushSize = num;
}
else if(num > 0x7fffffff / 1024)
{
_batchAutoFlushSize = 0x7fffffff;
}
else
{
_batchAutoFlushSize = num * 1024; // Property is in kilobytes, _batchAutoFlushSize in bytes
}
}
String toStringModeStr = _initData.properties.getPropertyWithDefault("Ice.ToStringMode", "Unicode");
if(toStringModeStr.equals("Unicode"))
{
_toStringMode = Ice.ToStringMode.Unicode;
}
else if(toStringModeStr.equals("ASCII"))
{
_toStringMode = Ice.ToStringMode.ASCII;
}
else if(toStringModeStr.equals("Compat"))
{
_toStringMode = Ice.ToStringMode.Compat;
}
else
{
throw new Ice.InitializationException("The value for Ice.ToStringMode must be Unicode, ASCII or Compat");
}
_implicitContext = Ice.ImplicitContextI.create(_initData.properties.getProperty("Ice.ImplicitContext"));
_routerManager = new RouterManager();
_locatorManager = new LocatorManager(_initData.properties);
_referenceFactory = new ReferenceFactory(this, communicator);
_requestHandlerFactory = new RequestHandlerFactory(this);
_proxyFactory = new ProxyFactory(this);
boolean isIPv6Supported = Network.isIPv6Supported();
boolean ipv4 = _initData.properties.getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
boolean ipv6 = _initData.properties.getPropertyAsIntWithDefault("Ice.IPv6", isIPv6Supported ? 1 : 0) > 0;
if(!ipv4 && !ipv6)
{
throw new Ice.InitializationException("Both IPV4 and IPv6 support cannot be disabled.");
}
else if(ipv4 && ipv6)
{
_protocolSupport = Network.EnableBoth;
}
else if(ipv4)
{
_protocolSupport = Network.EnableIPv4;
}
else
{
_protocolSupport = Network.EnableIPv6;
}
_preferIPv6 = _initData.properties.getPropertyAsInt("Ice.PreferIPv6Address") > 0;
_networkProxy = createNetworkProxy(_initData.properties, _protocolSupport);
_endpointFactoryManager = new EndpointFactoryManager(this);
ProtocolInstance tcpProtocolInstance = new ProtocolInstance(this, Ice.TCPEndpointType.value, "tcp", false);
_endpointFactoryManager.add(new TcpEndpointFactory(tcpProtocolInstance));
ProtocolInstance udpProtocolInstance = new ProtocolInstance(this, Ice.UDPEndpointType.value, "udp", false);
_endpointFactoryManager.add(new UdpEndpointFactory(udpProtocolInstance));
ProtocolInstance wsProtocolInstance = new ProtocolInstance(this, Ice.WSEndpointType.value, "ws", false);
_endpointFactoryManager.add(new WSEndpointFactory(wsProtocolInstance, Ice.TCPEndpointType.value));
ProtocolInstance wssProtocolInstance = new ProtocolInstance(this, Ice.WSSEndpointType.value, "wss", true);
_endpointFactoryManager.add(new WSEndpointFactory(wssProtocolInstance, Ice.SSLEndpointType.value));
_pluginManager = new Ice.PluginManagerI(communicator, this);
if(_initData.valueFactoryManager == null)
{
_initData.valueFactoryManager = new ValueFactoryManagerI();
}
_outgoingConnectionFactory = new OutgoingConnectionFactory(communicator, this);
_objectAdapterFactory = new ObjectAdapterFactory(this, communicator);
_retryQueue = new RetryQueue(this);
//
// If Ice.ThreadInterruptSafe is set or we're running on Android all
// IO is done on the background thread. For Android we use the queue
// executor as Android doesn't allow any network invocations on the main
// thread even if the call is non-blocking.
//
if(_initData.properties.getPropertyAsInt("Ice.ThreadInterruptSafe") > 0 || Util.isAndroid())
{
_queueExecutor = new QueueExecutor(_initData.properties,
Util.createThreadName(_initData.properties, "Ice.BackgroundIO"));
_queueExecutorService = new QueueExecutorService(_queueExecutor);
// Caching message buffers is not supported with background IO.
_cacheMessageBuffers = 0;
}
else
{
_cacheMessageBuffers = _initData.properties.getPropertyAsIntWithDefault("Ice.CacheMessageBuffers", 2);
}
}
catch(Ice.LocalException ex)
{
destroy(false);
throw ex;
}
}
@SuppressWarnings("deprecation")
@Override
protected synchronized void
finalize()
throws Throwable
{
try
{
IceUtilInternal.Assert.FinalizerAssert(_state == StateDestroyed);
IceUtilInternal.Assert.FinalizerAssert(_referenceFactory == null);
IceUtilInternal.Assert.FinalizerAssert(_requestHandlerFactory == null);
IceUtilInternal.Assert.FinalizerAssert(_proxyFactory == null);
IceUtilInternal.Assert.FinalizerAssert(_outgoingConnectionFactory == null);
IceUtilInternal.Assert.FinalizerAssert(_objectAdapterFactory == null);
IceUtilInternal.Assert.FinalizerAssert(_clientThreadPool == null);
IceUtilInternal.Assert.FinalizerAssert(_serverThreadPool == null);
IceUtilInternal.Assert.FinalizerAssert(_endpointHostResolver == null);
IceUtilInternal.Assert.FinalizerAssert(_timer == null);
IceUtilInternal.Assert.FinalizerAssert(_routerManager == null);
IceUtilInternal.Assert.FinalizerAssert(_locatorManager == null);
IceUtilInternal.Assert.FinalizerAssert(_endpointFactoryManager == null);
IceUtilInternal.Assert.FinalizerAssert(_pluginManager == null);
IceUtilInternal.Assert.FinalizerAssert(_retryQueue == null);
}
catch(java.lang.Exception ex)
{
}
finally
{
super.finalize();
}
}
public void
finishSetup(Ice.StringSeqHolder args, Ice.Communicator communicator)
{
//
// Load plug-ins.
//
assert(_serverThreadPool == null);
Ice.PluginManagerI pluginManagerImpl = (Ice.PluginManagerI)_pluginManager;
pluginManagerImpl.loadPlugins(args);
//
// Initialize the endpoint factories once all the plugins are loaded. This gives
// the opportunity for the endpoint factories to find underyling factories.
//
_endpointFactoryManager.initialize();
//
// Create Admin facets, if enabled.
//
// Note that any logger-dependent admin facet must be created after we load all plugins,
// since one of these plugins can be a Logger plugin that sets a new logger during loading
//
if(_initData.properties.getProperty("Ice.Admin.Enabled").isEmpty())
{
_adminEnabled = !_initData.properties.getProperty("Ice.Admin.Endpoints").isEmpty();
}
else
{
_adminEnabled = _initData.properties.getPropertyAsInt("Ice.Admin.Enabled") > 0;
}
String[] facetFilter = _initData.properties.getPropertyAsList("Ice.Admin.Facets");
if(facetFilter.length > 0)
{
_adminFacetFilter.addAll(java.util.Arrays.asList(facetFilter));
}
if(_adminEnabled)
{
//
// Process facet
//
String processFacetName = "Process";
if(_adminFacetFilter.isEmpty() || _adminFacetFilter.contains(processFacetName))
{
_adminFacets.put(processFacetName, new ProcessI(communicator));
}
//
// Logger facet
//
String loggerFacetName = "Logger";
if(_adminFacetFilter.isEmpty() || _adminFacetFilter.contains(loggerFacetName))
{
LoggerAdminLogger logger = new LoggerAdminLoggerI(_initData.properties, _initData.logger);
setLogger(logger);
_adminFacets.put(loggerFacetName, logger.getFacet());
}
//
// Properties facet
//
String propertiesFacetName = "Properties";
PropertiesAdminI propsAdmin = null;
if(_adminFacetFilter.isEmpty() || _adminFacetFilter.contains(propertiesFacetName))
{
propsAdmin = new PropertiesAdminI(this);
_adminFacets.put(propertiesFacetName, propsAdmin);
}
//
// Metrics facet
//
String metricsFacetName = "Metrics";
if(_adminFacetFilter.isEmpty() || _adminFacetFilter.contains(metricsFacetName))
{
CommunicatorObserverI observer = new CommunicatorObserverI(_initData);
_initData.observer = observer;
_adminFacets.put(metricsFacetName, observer.getFacet());
//
// Make sure the admin plugin receives property updates.
//
if(propsAdmin != null)
{
propsAdmin.addUpdateCallback(observer.getFacet());
}
}
}
//
// Set observer updater
//
if(_initData.observer != null)
{
_initData.observer.setObserverUpdater(new ObserverUpdaterI());
}
//
// Create threads.
//
try
{
_timer = new Timer(_initData.properties, Util.createThreadName(_initData.properties, "Ice.Timer"));
}
catch(RuntimeException ex)
{
String s = "cannot create thread for timer:\n" + Ex.toString(ex);
_initData.logger.error(s);
throw ex;
}
try
{
_endpointHostResolver = new EndpointHostResolver(this);
}
catch(RuntimeException ex)
{
String s = "cannot create thread for endpoint host resolver:\n" + Ex.toString(ex);
_initData.logger.error(s);
throw ex;
}
_clientThreadPool = new ThreadPool(this, "Ice.ThreadPool.Client", 0);
//
// The default router/locator may have been set during the loading of plugins.
// Therefore we make sure it is not already set before checking the property.
//
if(_referenceFactory.getDefaultRouter() == null)
{
Ice.RouterPrx router =
Ice.RouterPrxHelper.uncheckedCast(_proxyFactory.propertyToProxy("Ice.Default.Router"));
if(router != null)
{
_referenceFactory = _referenceFactory.setDefaultRouter(router);
}
}
if(_referenceFactory.getDefaultLocator() == null)
{
Ice.LocatorPrx loc =
Ice.LocatorPrxHelper.uncheckedCast(_proxyFactory.propertyToProxy("Ice.Default.Locator"));
if(loc != null)
{
_referenceFactory = _referenceFactory.setDefaultLocator(loc);
}
}
//
// Server thread pool initialization is lazy in serverThreadPool().
//
//
// An application can set Ice.InitPlugins=0 if it wants to postpone
// initialization until after it has interacted directly with the
// plug-ins.
//
if(_initData.properties.getPropertyAsIntWithDefault("Ice.InitPlugins", 1) > 0)
{
pluginManagerImpl.initializePlugins();
}
//
// This must be done last as this call creates the Ice.Admin object adapter
// and eventually registers a process proxy with the Ice locator (allowing
// remote clients to invoke on Ice.Admin facets as soon as it's registered).
//
if(_initData.properties.getPropertyAsIntWithDefault("Ice.Admin.DelayCreation", 0) <= 0)
{
getAdmin();
}
}
//
// Only for use by Ice.CommunicatorI
//
@SuppressWarnings("deprecation")
public void
destroy(boolean interruptible)
{
if(interruptible && Thread.interrupted())
{
throw new Ice.OperationInterruptedException();
}
synchronized(this)
{
//
// If destroy is in progress, wait for it to be done. This
// is necessary in case destroy() is called concurrently
// by multiple threads.
//
while(_state == StateDestroyInProgress)
{
try
{
wait();
}
catch(InterruptedException ex)
{
if(interruptible)
{
throw new Ice.OperationInterruptedException();
}
}
}
if(_state == StateDestroyed)
{
return;
}
_state = StateDestroyInProgress;
}
try
{
//
// Shutdown and destroy all the incoming and outgoing Ice
// connections and wait for the connections to be finished.
//
if(_objectAdapterFactory != null)
{
_objectAdapterFactory.shutdown();
}
if(_outgoingConnectionFactory != null)
{
_outgoingConnectionFactory.destroy();
}
if(_objectAdapterFactory != null)
{
_objectAdapterFactory.destroy();
}
if(_outgoingConnectionFactory != null)
{
_outgoingConnectionFactory.waitUntilFinished();
}
if(_retryQueue != null)
{
_retryQueue.destroy(); // Must be called before destroying thread pools.
}
if(_initData.observer != null)
{
_initData.observer.setObserverUpdater(null);
}
if(_initData.logger instanceof LoggerAdminLogger)
{
//
// This only disables the remote logging; we don't set or reset _initData.logger
//
((LoggerAdminLogger)_initData.logger).destroy();
}
//
// Now, destroy the thread pools. This must be done *only* after
// all the connections are finished (the connections destruction
// can require invoking callbacks with the thread pools).
//
if(_serverThreadPool != null)
{
_serverThreadPool.destroy();
}
if(_clientThreadPool != null)
{
_clientThreadPool.destroy();
}
if(_endpointHostResolver != null)
{
_endpointHostResolver.destroy();
}
if(_timer != null)
{
_timer.shutdown(); // Don't use shutdownNow(), timers don't support interrupts
}
//
// Wait for all the threads to be finished.
//
try
{
if(_clientThreadPool != null)
{
_clientThreadPool.joinWithAllThreads();
}
if(_serverThreadPool != null)
{
_serverThreadPool.joinWithAllThreads();
}
if(_endpointHostResolver != null)
{
_endpointHostResolver.joinWithThread();
}
if(_queueExecutor != null)
{
_queueExecutor.destroy();
}
if(_timer != null)
{
while(!_timer.isTerminated())
{
// A very long time.
_timer.awaitTermination(100000, java.util.concurrent.TimeUnit.SECONDS);
}
}
}
catch(InterruptedException ex)
{
if(interruptible)
{
throw new Ice.OperationInterruptedException();
}
}
//
// NOTE: at this point destroy() can't be interrupted
// anymore. The calls below are therefore guaranteed to be
// called once.
//
for(Ice.ObjectFactory f : _objectFactoryMap.values())
{
f.destroy();
}
_objectFactoryMap.clear();
if(_routerManager != null)
{
_routerManager.destroy();
}
if(_locatorManager != null)
{
_locatorManager.destroy();
}
if(_endpointFactoryManager != null)
{
_endpointFactoryManager.destroy();
}
if(_initData.properties.getPropertyAsInt("Ice.Warn.UnusedProperties") > 0)
{
java.util.List unusedProperties = ((Ice.PropertiesI)_initData.properties).getUnusedProperties();
if(unusedProperties.size() != 0)
{
StringBuilder message = new StringBuilder("The following properties were set but never read:");
for(String p : unusedProperties)
{
message.append("\n ");
message.append(p);
}
_initData.logger.warning(message.toString());
}
}
//
// Destroy last so that a Logger plugin can receive all log/traces before its destruction.
//
if(_pluginManager != null)
{
_pluginManager.destroy();
}
if(_initData.logger instanceof Ice.LoggerI)
{
Ice.LoggerI logger = (Ice.LoggerI)_initData.logger;
logger.destroy();
}
synchronized(this)
{
_objectAdapterFactory = null;
_outgoingConnectionFactory = null;
_retryQueue = null;
_serverThreadPool = null;
_clientThreadPool = null;
_endpointHostResolver = null;
_timer = null;
_referenceFactory = null;
_requestHandlerFactory = null;
_proxyFactory = null;
_routerManager = null;
_locatorManager = null;
_endpointFactoryManager = null;
_pluginManager = null;
_adminAdapter = null;
_adminFacets.clear();
_queueExecutor = null;
_queueExecutorService = null;
_typeToClassMap.clear();
_state = StateDestroyed;
notifyAll();
}
}
finally
{
synchronized(this)
{
if(_state == StateDestroyInProgress)
{
assert(interruptible);
_state = StateActive;
notifyAll();
}
}
}
}
public BufSizeWarnInfo getBufSizeWarn(short type)
{
synchronized(_setBufSizeWarn)
{
BufSizeWarnInfo info;
if(!_setBufSizeWarn.containsKey(type))
{
info = new BufSizeWarnInfo();
info.sndWarn = false;
info.sndSize = -1;
info.rcvWarn = false;
info.rcvSize = -1;
_setBufSizeWarn.put(type, info);
}
else
{
info = _setBufSizeWarn.get(type);
}
return info;
}
}
public void setSndBufSizeWarn(short type, int size)
{
synchronized(_setBufSizeWarn)
{
BufSizeWarnInfo info = getBufSizeWarn(type);
info.sndWarn = true;
info.sndSize = size;
_setBufSizeWarn.put(type, info);
}
}
public void setRcvBufSizeWarn(short type, int size)
{
synchronized(_setBufSizeWarn)
{
BufSizeWarnInfo info = getBufSizeWarn(type);
info.rcvWarn = true;
info.rcvSize = size;
_setBufSizeWarn.put(type, info);
}
}
@SuppressWarnings("deprecation")
public synchronized void addObjectFactory(final Ice.ObjectFactory factory, String id)
{
//
// Create a ValueFactory wrapper around the given ObjectFactory and register the wrapper
// with the value factory manager. This may raise AlreadyRegisteredException.
//
_initData.valueFactoryManager.add(
new Ice.ValueFactory()
{
public Ice.Object create(String id)
{
return factory.create(id);
}
}, id);
_objectFactoryMap.put(id, factory);
}
@SuppressWarnings("deprecation")
public synchronized Ice.ObjectFactory findObjectFactory(String id)
{
return _objectFactoryMap.get(id);
}
private void
updateConnectionObservers()
{
try
{
assert(_outgoingConnectionFactory != null);
_outgoingConnectionFactory.updateConnectionObservers();
assert(_objectAdapterFactory != null);
_objectAdapterFactory.updateConnectionObservers();
}
catch(Ice.CommunicatorDestroyedException ex)
{
}
}
private void
updateThreadObservers()
{
try
{
if(_clientThreadPool != null)
{
_clientThreadPool.updateObservers();
}
if(_serverThreadPool != null)
{
_serverThreadPool.updateObservers();
}
assert(_objectAdapterFactory != null);
_objectAdapterFactory.updateThreadObservers();
if(_endpointHostResolver != null)
{
_endpointHostResolver.updateObserver();
}
if(_timer != null)
{
_timer.updateObserver(_initData.observer);
}
if(_queueExecutor != null)
{
_queueExecutor.updateObserver(_initData.observer);
}
}
catch(Ice.CommunicatorDestroyedException ex)
{
}
}
private String[]
validatePackages()
{
final String prefix = "Ice.Package.";
java.util.Map map = _initData.properties.getPropertiesForPrefix(prefix);
java.util.List packages = new java.util.ArrayList();
for(java.util.Map.Entry p : map.entrySet())
{
String key = p.getKey();
String pkg = p.getValue();
if(key.length() == prefix.length())
{
_initData.logger.warning("ignoring invalid property: " + key + "=" + pkg);
}
String module = key.substring(prefix.length());
String className = pkg + "." + module + "._Marker";
Class cls = null;
try
{
cls = findClass(className);
}
catch(java.lang.Exception ex)
{
}
if(cls == null)
{
_initData.logger.warning("unable to validate package: " + key + "=" + pkg);
}
else
{
packages.add(pkg);
}
}
String pkg = _initData.properties.getProperty("Ice.Default.Package");
if(pkg.length() > 0)
{
packages.add(pkg);
}
return packages.toArray(new String[packages.size()]);
}
private synchronized void
addAllAdminFacets()
{
java.util.Map filteredFacets = new java.util.HashMap();
for(java.util.Map.Entry p : _adminFacets.entrySet())
{
if(_adminFacetFilter.isEmpty() || _adminFacetFilter.contains(p.getKey()))
{
_adminAdapter.addFacet(p.getValue(), _adminIdentity, p.getKey());
}
else
{
filteredFacets.put(p.getKey(), p.getValue());
}
}
_adminFacets = filteredFacets;
}
private void
setServerProcessProxy(Ice.ObjectAdapter adminAdapter, Ice.Identity adminIdentity)
{
Ice.ObjectPrx admin = adminAdapter.createProxy(adminIdentity);
Ice.LocatorPrx locator = adminAdapter.getLocator();
String serverId = _initData.properties.getProperty("Ice.Admin.ServerId");
if(locator != null && !serverId.isEmpty())
{
Ice.ProcessPrx process = Ice.ProcessPrxHelper.uncheckedCast(admin.ice_facet("Process"));
try
{
//
// Note that as soon as the process proxy is registered, the communicator might be
// shutdown by a remote client and admin facets might start receiving calls.
//
locator.getRegistry().setServerProcessProxy(serverId, process);
}
catch(Ice.ServerNotFoundException ex)
{
if(_traceLevels.location >= 1)
{
StringBuilder s = new StringBuilder(128);
s.append("couldn't register server `");
s.append(serverId);
s.append("' with the locator registry:\n");
s.append("the server is not known to the locator registry");
_initData.logger.trace(_traceLevels.locationCat, s.toString());
}
throw new Ice.InitializationException("Locator knows nothing about server `" + serverId + "'");
}
catch(Ice.LocalException ex)
{
if(_traceLevels.location >= 1)
{
StringBuilder s = new StringBuilder(128);
s.append("couldn't register server `");
s.append(serverId);
s.append("' with the locator registry:\n");
s.append(ex.toString());
_initData.logger.trace(_traceLevels.locationCat, s.toString());
}
throw ex;
}
if(_traceLevels.location >= 1)
{
StringBuilder s = new StringBuilder(128);
s.append("registered server `");
s.append(serverId);
s.append("' with the locator registry");
_initData.logger.trace(_traceLevels.locationCat, s.toString());
}
}
}
private NetworkProxy createNetworkProxy(Ice.Properties properties, int protocolSupport)
{
String proxyHost;
proxyHost = properties.getProperty("Ice.SOCKSProxyHost");
if(!proxyHost.isEmpty())
{
if(protocolSupport == Network.EnableIPv6)
{
throw new Ice.InitializationException("IPv6 only is not supported with SOCKS4 proxies");
}
int proxyPort = properties.getPropertyAsIntWithDefault("Ice.SOCKSProxyPort", 1080);
return new SOCKSNetworkProxy(proxyHost, proxyPort);
}
proxyHost = properties.getProperty("Ice.HTTPProxyHost");
if(!proxyHost.isEmpty())
{
return new HTTPNetworkProxy(proxyHost, properties.getPropertyAsIntWithDefault("Ice.HTTPProxyPort", 1080));
}
return null;
}
private static final int StateActive = 0;
private static final int StateDestroyInProgress = 1;
private static final int StateDestroyed = 2;
private int _state;
private final Ice.InitializationData _initData; // Immutable, not reset by destroy().
private final TraceLevels _traceLevels; // Immutable, not reset by destroy().
private final DefaultsAndOverrides _defaultsAndOverrides; // Immutable, not reset by destroy().
private final int _messageSizeMax; // Immutable, not reset by destroy().
private final int _batchAutoFlushSize; // Immutable, not reset by destroy().
private final Ice.ToStringMode _toStringMode; // Immutable, not reset by destroy().
private final int _cacheMessageBuffers; // Immutable, not reset by destroy().
private final ACMConfig _clientACM; // Immutable, not reset by destroy().
private final ACMConfig _serverACM; // Immutable, not reset by destroy().
private final Ice.ImplicitContextI _implicitContext;
private RouterManager _routerManager;
private LocatorManager _locatorManager;
private ReferenceFactory _referenceFactory;
private RequestHandlerFactory _requestHandlerFactory;
private ProxyFactory _proxyFactory;
private OutgoingConnectionFactory _outgoingConnectionFactory;
private ObjectAdapterFactory _objectAdapterFactory;
private int _protocolSupport;
private boolean _preferIPv6;
private NetworkProxy _networkProxy;
private ThreadPool _clientThreadPool;
private ThreadPool _serverThreadPool;
private EndpointHostResolver _endpointHostResolver;
private RetryQueue _retryQueue;
private Timer _timer;
private EndpointFactoryManager _endpointFactoryManager;
private Ice.PluginManager _pluginManager;
private boolean _adminEnabled = false;
private Ice.ObjectAdapter _adminAdapter;
private java.util.Map _adminFacets = new java.util.HashMap();
private java.util.Set _adminFacetFilter = new java.util.HashSet();
private Ice.Identity _adminIdentity;
private java.util.Map _setBufSizeWarn = new java.util.HashMap();
private java.util.Map _typeToClassMap = new java.util.HashMap();
final private String[] _packages;
final private boolean _useApplicationClassLoader;
private static boolean _oneOffDone = false;
private QueueExecutorService _queueExecutorService;
private QueueExecutor _queueExecutor;
@SuppressWarnings("deprecation")
private java.util.HashMap _objectFactoryMap =
new java.util.HashMap();
}