public void finishSetup(ref string[] args)
{
//
// Load plug-ins.
//
Debug.Assert(_serverThreadPool == null);
Ice.PluginManagerI pluginManagerImpl = (Ice.PluginManagerI)_pluginManager;
pluginManagerImpl.loadPlugins(ref args);
//
// Create threads.
//
try
{
if(initializationData().properties.getProperty("Ice.ThreadPriority").Length > 0)
{
ThreadPriority priority = IceInternal.Util.stringToThreadPriority(
initializationData().properties.getProperty("Ice.ThreadPriority"));
_timer = new Timer(this, priority);
}
else
{
_timer = new Timer(this);
}
}
catch(System.Exception ex)
{
string s = "cannot create thread for timer:\n" + ex;
_initData.logger.error(s);
throw;
}
try
{
_endpointHostResolver = new EndpointHostResolver(this);
}
catch(System.Exception ex)
{
string s = "cannot create thread for endpoint host resolver:\n" + ex;
_initData.logger.error(s);
throw;
}
_clientThreadPool = new ThreadPool(this, "Ice.ThreadPool.Client", 0);
//
// Get default router and locator proxies. Don't move this
// initialization before the plug-in initialization!!! The proxies
// might depend on endpoint factories to be installed by plug-ins.
//
Ice.RouterPrx r = Ice.RouterPrxHelper.uncheckedCast(_proxyFactory.propertyToProxy("Ice.Default.Router"));
if(r != null)
{
_referenceFactory = _referenceFactory.setDefaultRouter(r);
}
Ice.LocatorPrx l = Ice.LocatorPrxHelper.uncheckedCast(_proxyFactory.propertyToProxy("Ice.Default.Locator"));
if(l != null)
{
_referenceFactory = _referenceFactory.setDefaultLocator(l);
}
//
// Show process id if requested (but only once).
//
lock(this)
{
if(!_printProcessIdDone && _initData.properties.getPropertyAsInt("Ice.PrintProcessId") > 0)
{
using(Process p = Process.GetCurrentProcess())
{
System.Console.WriteLine(p.Id);
}
_printProcessIdDone = true;
}
}
//
// Create the connection monitor and ensure the interval for
// monitoring connections is appropriate for client & server
// ACM.
//
int interval = _initData.properties.getPropertyAsInt("Ice.MonitorConnections");
_connectionMonitor = new ConnectionMonitor(this, interval);
_connectionMonitor.checkIntervalForACM(_clientACM);
_connectionMonitor.checkIntervalForACM(_serverACM);
//
// 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
//
public bool destroy()
{
lock(this)
{
//
// If the _state is not StateActive then the instance is
// either being destroyed, or has already been destroyed.
//
if(_state != StateActive)
{
return false;
}
//
// We cannot set state to StateDestroyed otherwise instance
// methods called during the destroy process (such as
// outgoingConnectionFactory() from
// ObjectAdapterI::deactivate() will cause an exception.
//
_state = StateDestroyInProgress;
}
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();
}
ThreadPool serverThreadPool = null;
ThreadPool clientThreadPool = null;
AsyncIOThread asyncIOThread = null;
EndpointHostResolver endpointHostResolver = null;
lock(this)
{
_objectAdapterFactory = null;
_outgoingConnectionFactory = null;
_retryQueue = null;
if(_connectionMonitor != null)
{
_connectionMonitor.destroy();
_connectionMonitor = null;
}
if(_serverThreadPool != null)
{
_serverThreadPool.destroy();
serverThreadPool = _serverThreadPool;
_serverThreadPool = null;
}
if(_clientThreadPool != null)
{
_clientThreadPool.destroy();
clientThreadPool = _clientThreadPool;
_clientThreadPool = null;
}
if(_asyncIOThread != null)
{
_asyncIOThread.destroy();
asyncIOThread = _asyncIOThread;
_asyncIOThread = null;
}
if(_endpointHostResolver != null)
{
_endpointHostResolver.destroy();
endpointHostResolver = _endpointHostResolver;
_endpointHostResolver = null;
}
if(_timer != null)
{
_timer.destroy();
_timer = null;
}
if(_servantFactoryManager != null)
{
_servantFactoryManager.destroy();
_servantFactoryManager = null;
}
if(_referenceFactory != null)
{
_referenceFactory.destroy();
_referenceFactory = null;
}
// No destroy function defined.
// _proxyFactory.destroy();
_proxyFactory = null;
if(_routerManager != null)
{
_routerManager.destroy();
_routerManager = null;
}
if(_locatorManager != null)
{
_locatorManager.destroy();
_locatorManager = null;
}
if(_endpointFactoryManager != null)
{
_endpointFactoryManager.destroy();
_endpointFactoryManager = null;
}
if(_pluginManager != null)
{
_pluginManager.destroy();
_pluginManager = null;
}
_adminAdapter = null;
_adminFacets.Clear();
_state = StateDestroyed;
}
//
// Join with threads outside the synchronization.
//
if(clientThreadPool != null)
{
clientThreadPool.joinWithAllThreads();
}
if(serverThreadPool != null)
{
serverThreadPool.joinWithAllThreads();
}
if(asyncIOThread != null)
{
asyncIOThread.joinWithThread();
}
if(endpointHostResolver != null)
{
endpointHostResolver.joinWithThread();
}
if(_initData.properties.getPropertyAsInt("Ice.Warn.UnusedProperties") > 0)
{
ArrayList unusedProperties = ((Ice.PropertiesI)_initData.properties).getUnusedProperties();
if(unusedProperties.Count != 0)
{
StringBuilder message = new StringBuilder("The following properties were set but never read:");
foreach(string s in unusedProperties)
{
message.Append("\n ");
message.Append(s);
}
_initData.logger.warning(message.ToString());
}
}
return true;
}
