//
// 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();
}
#if !SILVERLIGHT && !UNITY
lock(_staticLock)
{
if(!_oneOfDone)
{
string stdOut = _initData.properties.getProperty("Ice.StdOut");
string stdErr = _initData.properties.getProperty("Ice.StdErr");
System.IO.StreamWriter outStream = null;
if(stdOut.Length > 0)
{
try
{
outStream = System.IO.File.AppendText(stdOut);
}
catch(System.IO.IOException ex)
{
Ice.FileException fe = new Ice.FileException(ex);
fe.path = stdOut;
throw fe;
}
outStream.AutoFlush = true;
System.Console.Out.Close();
System.Console.SetOut(outStream);
}
if(stdErr.Length > 0)
{
if(stdErr.Equals(stdOut))
{
System.Console.SetError(outStream);
}
else
{
System.IO.StreamWriter errStream = null;
try
{
errStream = System.IO.File.AppendText(stdErr);
}
catch(System.IO.IOException ex)
{
Ice.FileException fe = new Ice.FileException(ex);
fe.path = stdErr;
throw fe;
}
errStream.AutoFlush = true;
System.Console.Error.Close();
System.Console.SetError(errStream);
}
}
_oneOfDone = true;
}
}
#endif
if(_initData.logger == null)
{
#if !SILVERLIGHT && !UNITY
string logfile = _initData.properties.getProperty("Ice.LogFile");
if(_initData.properties.getPropertyAsInt("Ice.UseSyslog") > 0 &&
AssemblyUtil.platform_ != AssemblyUtil.Platform.Windows)
{
if(logfile.Length != 0)
{
throw new Ice.InitializationException("Ice.LogFile and Ice.UseSyslog cannot both be set.");
}
_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.FileLoggerI(_initData.properties.getProperty("Ice.ProgramName"), logfile);
}
else if(Ice.Util.getProcessLogger() is Ice.LoggerI)
{
//
// Ice.ConsoleListener is enabled by default.
//
# if COMPACT
_initData.logger =
new Ice.ConsoleLoggerI(_initData.properties.getProperty("Ice.ProgramName"));
# else
bool console =
_initData.properties.getPropertyAsIntWithDefault("Ice.ConsoleListener", 1) > 0;
_initData.logger =
new Ice.TraceLoggerI(_initData.properties.getProperty("Ice.ProgramName"), console);
# endif
}
#else
if(Ice.Util.getProcessLogger() is Ice.LoggerI)
{
_initData.logger =
new Ice.ConsoleLoggerI(_initData.properties.getProperty("Ice.ProgramName"));
}
#endif
else
{
_initData.logger = Ice.Util.getProcessLogger();
}
}
_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)));
#if COMPACT || SILVERLIGHT
char[] separators = { ' ', '\t', '\n', '\r' };
_factoryAssemblies = _initData.properties.getProperty("Ice.FactoryAssemblies").Split(separators);
#endif
{
const 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").Length == 0 &&
_initData.properties.getProperty("Ice.BatchAutoFlush").Length > 0)
{
if(_initData.properties.getPropertyAsInt("Ice.BatchAutoFlush") > 0)
{
_batchAutoFlushSize = _messageSizeMax;
}
}
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
}
}
_cacheMessageBuffers = _initData.properties.getPropertyAsIntWithDefault("Ice.CacheMessageBuffers", 2);
_implicitContext = Ice.ImplicitContextI.create(_initData.properties.getProperty("Ice.ImplicitContext"));
_routerManager = new RouterManager();
_locatorManager = new LocatorManager(_initData.properties);
_referenceFactory = new ReferenceFactory(this, communicator);
_proxyFactory = new ProxyFactory(this);
_requestHandlerFactory = new RequestHandlerFactory(this);
bool isIPv6Supported = Network.isIPv6Supported();
bool ipv4 = _initData.properties.getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
bool 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");
EndpointFactory tcpEndpointFactory = new TcpEndpointFactory(tcpProtocolInstance);
_endpointFactoryManager.add(tcpEndpointFactory);
ProtocolInstance udpProtocolInstance =
new ProtocolInstance(this, Ice.UDPEndpointType.value, "udp");
EndpointFactory udpEndpointFactory = new UdpEndpointFactory(udpProtocolInstance);
_endpointFactoryManager.add(udpEndpointFactory);
ProtocolInstance wsProtocolInstance = new ProtocolInstance(this, Ice.WSEndpointType.value, "ws");
_endpointFactoryManager.add(new WSEndpointFactory(wsProtocolInstance,
tcpEndpointFactory.clone(wsProtocolInstance)));
#if !SILVERLIGHT
_pluginManager = new Ice.PluginManagerI(communicator);
#endif
_outgoingConnectionFactory = new OutgoingConnectionFactory(communicator, this);
_servantFactoryManager = new ObjectFactoryManager();
_objectAdapterFactory = new ObjectAdapterFactory(this, communicator);
_retryQueue = new RetryQueue(this);
}
//
// 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();
}
#if !SILVERLIGHT && !UNITY
lock(_staticLock)
{
if(!_oneOffDone)
{
string stdOut = _initData.properties.getProperty("Ice.StdOut");
string stdErr = _initData.properties.getProperty("Ice.StdErr");
System.IO.StreamWriter outStream = null;
if(stdOut.Length > 0)
{
try
{
outStream = System.IO.File.AppendText(stdOut);
}
catch(System.IO.IOException ex)
{
Ice.FileException fe = new Ice.FileException(ex);
fe.path = stdOut;
throw fe;
}
outStream.AutoFlush = true;
System.Console.Out.Close();
System.Console.SetOut(outStream);
}
if(stdErr.Length > 0)
{
if(stdErr.Equals(stdOut))
{
System.Console.SetError(outStream);
}
else
{
System.IO.StreamWriter errStream = null;
try
{
errStream = System.IO.File.AppendText(stdErr);
}
catch(System.IO.IOException ex)
{
Ice.FileException fe = new Ice.FileException(ex);
fe.path = stdErr;
throw fe;
}
errStream.AutoFlush = true;
System.Console.Error.Close();
System.Console.SetError(errStream);
}
}
_oneOffDone = true;
}
}
#endif
if(_initData.logger == null)
{
#if !SILVERLIGHT && !UNITY
string logfile = _initData.properties.getProperty("Ice.LogFile");
if(_initData.properties.getPropertyAsInt("Ice.UseSyslog") > 0 &&
AssemblyUtil.platform_ != AssemblyUtil.Platform.Windows)
{
if(logfile.Length != 0)
{
throw new Ice.InitializationException("Ice.LogFile and Ice.UseSyslog cannot both be set.");
}
_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.FileLoggerI(_initData.properties.getProperty("Ice.ProgramName"), logfile);
}
else if(Ice.Util.getProcessLogger() is Ice.LoggerI)
{
//
// Ice.ConsoleListener is enabled by default.
//
# if COMPACT
_initData.logger =
new Ice.ConsoleLoggerI(_initData.properties.getProperty("Ice.ProgramName"));
# else
bool console =
_initData.properties.getPropertyAsIntWithDefault("Ice.ConsoleListener", 1) == 1;
_initData.logger =
new Ice.TraceLoggerI(_initData.properties.getProperty("Ice.ProgramName"), console);
# endif
}
#else
if(Ice.Util.getProcessLogger() is Ice.LoggerI)
{
_initData.logger =
new Ice.ConsoleLoggerI(_initData.properties.getProperty("Ice.ProgramName"));
}
#endif
else
{
_initData.logger = Ice.Util.getProcessLogger();
}
}
_traceLevels = new TraceLevels(_initData.properties);
_defaultsAndOverrides = new DefaultsAndOverrides(_initData.properties);
#if COMPACT || SILVERLIGHT
char[] separators = { ' ', '\t', '\n', '\r' };
_factoryAssemblies = _initData.properties.getProperty("Ice.FactoryAssemblies").Split(separators);
#endif
{
const int defaultMessageSizeMax = 1024;
int num =
_initData.properties.getPropertyAsIntWithDefault("Ice.MessageSizeMax", defaultMessageSizeMax);
if(num < 1)
{
_messageSizeMax = defaultMessageSizeMax * 1024; // Ignore non-sensical values.
}
else if(num > 0x7fffffff / 1024)
{
_messageSizeMax = 0x7fffffff;
}
else
{
_messageSizeMax = num * 1024; // Property is in kilobytes, _messageSizeMax in bytes
}
}
//
// Client ACM enabled by default. Server ACM disabled by default.
//
_clientACM = _initData.properties.getPropertyAsIntWithDefault("Ice.ACM.Client", 60);
_serverACM = _initData.properties.getPropertyAsInt("Ice.ACM.Server");
_implicitContext = Ice.ImplicitContextI.create(_initData.properties.getProperty("Ice.ImplicitContext"));
_routerManager = new RouterManager();
_locatorManager = new LocatorManager(_initData.properties);
_referenceFactory = new ReferenceFactory(this, communicator);
_proxyFactory = new ProxyFactory(this);
bool ipv4 = _initData.properties.getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
bool ipv6 = _initData.properties.getPropertyAsIntWithDefault("Ice.IPv6", 1) > 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;
_endpointFactoryManager = new EndpointFactoryManager(this);
EndpointFactory tcpEndpointFactory = new TcpEndpointFactory(this);
_endpointFactoryManager.add(tcpEndpointFactory);
EndpointFactory udpEndpointFactory = new UdpEndpointFactory(this);
_endpointFactoryManager.add(udpEndpointFactory);
#if !SILVERLIGHT
_pluginManager = new Ice.PluginManagerI(communicator);
#endif
_outgoingConnectionFactory = new OutgoingConnectionFactory(communicator, this);
_servantFactoryManager = new ObjectFactoryManager();
_objectAdapterFactory = new ObjectAdapterFactory(this, communicator);
_retryQueue = new RetryQueue(this);
string[] facetFilter = _initData.properties.getPropertyAsList("Ice.Admin.Facets");
if(facetFilter.Length > 0)
{
foreach(string s in facetFilter)
{
_adminFacetFilter.Add(s);
}
}
_adminFacets.Add("Process", new ProcessI(communicator));
MetricsAdminI admin = new MetricsAdminI(_initData.properties, _initData.logger);
_adminFacets.Add("Metrics", admin);
PropertiesAdminI props = new PropertiesAdminI("Properties", _initData.properties, _initData.logger);
_adminFacets.Add("Properties", props);
//
// Setup the communicator observer only if the user didn't already set an
// Ice observer resolver and if the admininistrative endpoints are set.
//
if(_initData.observer == null &&
(_adminFacetFilter.Count == 0 || _adminFacetFilter.Contains("Metrics")) &&
_initData.properties.getProperty("Ice.Admin.Endpoints").Length > 0)
{
CommunicatorObserverI observer = new CommunicatorObserverI(admin);
_initData.observer = observer;
//
// Make sure the admin plugin receives property updates.
//
props.addUpdateCallback(admin);
}
}
public void destroy()
{
//
// Deactivate and wait for completion.
//
deactivate();
waitForDeactivate();
lock(this)
{
//
// Only a single thread is allowed to destroy the object
// adapter. Other threads wait for the destruction to be
// completed.
//
while(state_ == StateDestroying)
{
System.Threading.Monitor.Wait(this);
}
if(state_ == StateDestroyed)
{
return;
}
state_ = StateDestroying;
}
//
// Now it's also time to clean up our servants and servant
// locators.
//
_servantManager.destroy();
//
// Destroy the thread pool.
//
if(_threadPool != null)
{
_threadPool.destroy();
_threadPool.joinWithAllThreads();
}
if(_objectAdapterFactory != null)
{
_objectAdapterFactory.removeObjectAdapter(this);
}
lock(this)
{
//
// We're done, now we can throw away all incoming connection
// factories.
//
_incomingConnectionFactories.Clear();
//
// Remove object references (some of them cyclic).
//
instance_ = null;
_threadPool = null;
_routerEndpoints = null;
_routerInfo = null;
_publishedEndpoints = null;
_locatorInfo = null;
_reference = null;
_objectAdapterFactory = null;
state_ = StateDestroyed;
System.Threading.Monitor.PulseAll(this);
}
}
//
// Only for use by ObjectAdapterFactory
//
public ObjectAdapterI(Instance instance, Communicator communicator,
ObjectAdapterFactory objectAdapterFactory, string name,
RouterPrx router, bool noConfig)
{
instance_ = instance;
_communicator = communicator;
_objectAdapterFactory = objectAdapterFactory;
_servantManager = new ServantManager(instance, name);
_name = name;
_incomingConnectionFactories = new List<IncomingConnectionFactory>();
_publishedEndpoints = new List<EndpointI>();
_routerEndpoints = new List<EndpointI>();
_routerInfo = null;
_directCount = 0;
_noConfig = noConfig;
if(_noConfig)
{
_id = "";
_replicaGroupId = "";
_reference = instance_.referenceFactory().create("dummy -t", "");
_acm = instance_.serverACM();
return;
}
Properties properties = instance_.initializationData().properties;
List<string> unknownProps = new List<string>();
bool noProps = filterProperties(unknownProps);
//
// Warn about unknown object adapter properties.
//
if(unknownProps.Count != 0 && properties.getPropertyAsIntWithDefault("Ice.Warn.UnknownProperties", 1) > 0)
{
StringBuilder message = new StringBuilder("found unknown properties for object adapter `");
message.Append(_name);
message.Append("':");
foreach(string s in unknownProps)
{
message.Append("\n ");
message.Append(s);
}
instance_.initializationData().logger.warning(message.ToString());
}
//
// Make sure named adapter has configuration.
//
if(router == null && noProps)
{
//
// These need to be set to prevent warnings/asserts in the destructor.
//
state_ = StateDestroyed;
instance_ = null;
_incomingConnectionFactories = null;
InitializationException ex = new InitializationException();
ex.reason = "object adapter `" + _name + "' requires configuration";
throw ex;
}
_id = properties.getProperty(_name + ".AdapterId");
_replicaGroupId = properties.getProperty(_name + ".ReplicaGroupId");
//
// Setup a reference to be used to get the default proxy options
// when creating new proxies. By default, create twoway proxies.
//
string proxyOptions = properties.getPropertyWithDefault(_name + ".ProxyOptions", "-t");
try
{
_reference = instance_.referenceFactory().create("dummy " + proxyOptions, "");
}
catch(ProxyParseException)
{
InitializationException ex = new InitializationException();
ex.reason = "invalid proxy options `" + proxyOptions + "' for object adapter `" + _name + "'";
throw ex;
}
_acm = new ACMConfig(properties, communicator.getLogger(), _name + ".ACM", instance_.serverACM());
{
int defaultMessageSizeMax = instance.messageSizeMax() / 1024;
int num = properties.getPropertyAsIntWithDefault(_name + ".MessageSizeMax", defaultMessageSizeMax);
if(num < 1 || num > 0x7fffffff / 1024)
{
_messageSizeMax = 0x7fffffff;
}
else
{
_messageSizeMax = num * 1024; // Property is in kilobytes, _messageSizeMax in bytes
}
}
try
{
int threadPoolSize = properties.getPropertyAsInt(_name + ".ThreadPool.Size");
int threadPoolSizeMax = properties.getPropertyAsInt(_name + ".ThreadPool.SizeMax");
if(threadPoolSize > 0 || threadPoolSizeMax > 0)
{
_threadPool = new ThreadPool(instance_, _name + ".ThreadPool", 0);
}
if(router == null)
{
router = RouterPrxHelper.uncheckedCast(
instance_.proxyFactory().propertyToProxy(_name + ".Router"));
}
if(router != null)
{
_routerInfo = instance_.routerManager().get(router);
if(_routerInfo != null)
{
//
// Make sure this router is not already registered with another adapter.
//
if(_routerInfo.getAdapter() != null)
{
Ice.AlreadyRegisteredException ex = new Ice.AlreadyRegisteredException();
ex.kindOfObject = "object adapter with router";
ex.id = instance_.identityToString(router.ice_getIdentity());
throw ex;
}
//
// Add the router's server proxy endpoints to this object
// adapter.
//
EndpointI[] endpoints = _routerInfo.getServerEndpoints();
for(int i = 0; i < endpoints.Length; ++i)
{
_routerEndpoints.Add(endpoints[i]);
}
_routerEndpoints.Sort(); // Must be sorted.
//
// Remove duplicate endpoints, so we have a list of unique endpoints.
//
for(int i = 0; i < _routerEndpoints.Count-1;)
{
EndpointI e1 = _routerEndpoints[i];
EndpointI e2 = _routerEndpoints[i + 1];
if(e1.Equals(e2))
{
_routerEndpoints.RemoveAt(i);
}
else
{
++i;
}
}
//
// Associate this object adapter with the router. This way,
// new outgoing connections to the router's client proxy will
// use this object adapter for callbacks.
//
_routerInfo.setAdapter(this);
//
// Also modify all existing outgoing connections to the
// router's client proxy to use this object adapter for
// callbacks.
//
instance_.outgoingConnectionFactory().setRouterInfo(_routerInfo);
}
}
else
{
//
// Parse the endpoints, but don't store them in the adapter. The connection
// factory might change it, for example, to fill in the real port number.
//
List<EndpointI> endpoints = parseEndpoints(properties.getProperty(_name + ".Endpoints"), true);
foreach(EndpointI endp in endpoints)
{
IncomingConnectionFactory factory = new IncomingConnectionFactory(instance, endp, this);
_incomingConnectionFactories.Add(factory);
}
if(endpoints.Count == 0)
{
TraceLevels tl = instance_.traceLevels();
if(tl.network >= 2)
{
instance_.initializationData().logger.trace(tl.networkCat, "created adapter `" + _name +
"' without endpoints");
}
}
//
// Parse published endpoints.
//
_publishedEndpoints = parsePublishedEndpoints();
}
if(properties.getProperty(_name + ".Locator").Length > 0)
{
setLocator(LocatorPrxHelper.uncheckedCast(
instance_.proxyFactory().propertyToProxy(_name + ".Locator")));
}
else
{
setLocator(instance_.referenceFactory().getDefaultLocator());
}
}
catch(LocalException)
{
destroy();
throw;
}
}
//
// Only for use by Ice.CommunicatorI
//
public void destroy()
{
lock(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)
{
Monitor.Wait(this);
}
if(_state == StateDestroyed)
{
return;
}
_state = StateDestroyInProgress;
}
//
// 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);
}
LoggerAdminLogger logger = _initData.logger as LoggerAdminLogger;
if(logger != null)
{
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(_asyncIOThread != null)
{
_asyncIOThread.destroy();
}
if(_endpointHostResolver != null)
{
_endpointHostResolver.destroy();
}
//
// Wait for all the threads to be finished.
//
if(_timer != null)
{
_timer.destroy();
}
if(_clientThreadPool != null)
{
_clientThreadPool.joinWithAllThreads();
}
if(_serverThreadPool != null)
{
_serverThreadPool.joinWithAllThreads();
}
if(_asyncIOThread != null)
{
_asyncIOThread.joinWithThread();
}
if(_endpointHostResolver != null)
{
_endpointHostResolver.joinWithThread();
}
foreach(Ice.ObjectFactory factory in _objectFactoryMap.Values)
{
// Disable Obsolete warning/error
#pragma warning disable 612, 618
factory.destroy();
#pragma warning restore 612, 618
}
_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)
{
List<string> 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());
}
}
//
// Destroy last so that a Logger plugin can receive all log/traces before its destruction.
//
if(_pluginManager != null)
{
_pluginManager.destroy();
}
lock(this)
{
_objectAdapterFactory = null;
_outgoingConnectionFactory = null;
_retryQueue = null;
_serverThreadPool = null;
_clientThreadPool = null;
_asyncIOThread = null;
_endpointHostResolver = null;
_timer = null;
_referenceFactory = null;
_requestHandlerFactory = null;
_proxyFactory = null;
_routerManager = null;
_locatorManager = null;
_endpointFactoryManager = null;
_pluginManager = null;
_adminAdapter = null;
_adminFacets.Clear();
_state = StateDestroyed;
Monitor.PulseAll(this);
}
}
private TraceLevels _traceLevels; // Immutable, not reset by destroy().
#endregion Fields
#region Constructors
//
// 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();
}
lock(_staticLock)
{
if(!_oneOffDone)
{
string stdOut = _initData.properties.getProperty("Ice.StdOut");
string stdErr = _initData.properties.getProperty("Ice.StdErr");
System.IO.StreamWriter outStream = null;
if(stdOut.Length > 0)
{
try
{
outStream = System.IO.File.AppendText(stdOut);
}
catch(System.IO.IOException ex)
{
Ice.FileException fe = new Ice.FileException(ex);
fe.path = stdOut;
throw fe;
}
outStream.AutoFlush = true;
System.Console.Out.Close();
System.Console.SetOut(outStream);
}
if(stdErr.Length > 0)
{
if(stdErr.Equals(stdOut))
{
System.Console.SetError(outStream);
}
else
{
System.IO.StreamWriter errStream = null;
try
{
errStream = System.IO.File.AppendText(stdErr);
}
catch(System.IO.IOException ex)
{
Ice.FileException fe = new Ice.FileException(ex);
fe.path = stdErr;
throw fe;
}
errStream.AutoFlush = true;
System.Console.Error.Close();
System.Console.SetError(errStream);
}
}
_oneOffDone = true;
}
}
if(_initData.logger == null)
{
string logfile = _initData.properties.getProperty("Ice.LogFile");
if(_initData.properties.getPropertyAsInt("Ice.UseSyslog") > 0)
{
if(logfile.Length != 0)
{
throw new Ice.InitializationException("Ice.LogFile and Ice.UseSyslog cannot both be set.");
}
_initData.logger = new Ice.SysLoggerI(_initData.properties.getProperty("Ice.ProgramName"),
_initData.properties.getPropertyWithDefault("Ice.SyslogFacility", "LOG_USER"));
}
else if(logfile.Length != 0 || Ice.Util.getProcessLogger() is Ice.LoggerI)
{
//
// Ice.ConsoleListener is enabled by default unless Ice.LogFile is set.
//
bool console =
_initData.properties.getPropertyAsIntWithDefault("Ice.ConsoleListener",
logfile.Length == 0 ? 1 : 0) > 0;
_initData.logger =
new Ice.TraceLoggerI(_initData.properties.getProperty("Ice.ProgramName"), logfile, console);
}
else
{
_initData.logger = Ice.Util.getProcessLogger();
}
}
_traceLevels = new TraceLevels(_initData.properties);
_defaultsAndOverrides = new DefaultsAndOverrides(_initData.properties);
#if COMPACT
_factoryAssemblies = _initData.properties.getPropertyAsList("Ice.FactoryAssemblies");
#endif
{
const int defaultMessageSizeMax = 1024;
int num =
_initData.properties.getPropertyAsIntWithDefault("Ice.MessageSizeMax", defaultMessageSizeMax);
if(num < 1)
{
_messageSizeMax = defaultMessageSizeMax * 1024; // Ignore non-sensical values.
}
else if(num > 0x7fffffff / 1024)
{
_messageSizeMax = 0x7fffffff;
}
else
{
_messageSizeMax = num * 1024; // Property is in kilobytes, _messageSizeMax in bytes
}
}
//
// Client ACM enabled by default. Server ACM disabled by default.
//
_clientACM = _initData.properties.getPropertyAsIntWithDefault("Ice.ACM.Client", 60);
_serverACM = _initData.properties.getPropertyAsInt("Ice.ACM.Server");
_implicitContext = Ice.ImplicitContextI.create(_initData.properties.getProperty("Ice.ImplicitContext"));
_routerManager = new RouterManager();
_locatorManager = new LocatorManager(_initData.properties);
_referenceFactory = new ReferenceFactory(this, communicator);
_proxyFactory = new ProxyFactory(this);
bool ipv4 = _initData.properties.getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
bool ipv6 = _initData.properties.getPropertyAsIntWithDefault("Ice.IPv6", 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;
}
_endpointFactoryManager = new EndpointFactoryManager(this);
EndpointFactory tcpEndpointFactory = new TcpEndpointFactory(this);
_endpointFactoryManager.add(tcpEndpointFactory);
EndpointFactory udpEndpointFactory = new UdpEndpointFactory(this);
_endpointFactoryManager.add(udpEndpointFactory);
_pluginManager = new Ice.PluginManagerI(communicator);
_outgoingConnectionFactory = new OutgoingConnectionFactory(this);
_servantFactoryManager = new ObjectFactoryManager();
_objectAdapterFactory = new ObjectAdapterFactory(this, communicator);
_retryQueue = new RetryQueue(this);
string[] facetFilter = _initData.properties.getPropertyAsList("Ice.Admin.Facets");
if(facetFilter.Length > 0)
{
foreach(string s in facetFilter)
{
_adminFacetFilter.Add(s);
}
}
_adminFacets.Add("Properties", new PropertiesAdminI(_initData.properties));
_adminFacets.Add("Process", new ProcessI(communicator));
}
catch(Ice.LocalException)
{
destroy();
throw;
}
}
//
// 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;
}