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 &&
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.
//
bool console =
_initData.properties.getPropertyAsIntWithDefault("Ice.ConsoleListener", 1) > 0;
_initData.logger =
new Ice.TraceLoggerI(_initData.properties.getProperty("Ice.ProgramName"), console);
}
if(Ice.Util.getProcessLogger() is Ice.LoggerI)
{
_initData.logger =
new Ice.ConsoleLoggerI(_initData.properties.getProperty("Ice.ProgramName"));
}
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)));
{
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 tcpInstance = new ProtocolInstance(this, Ice.TCPEndpointType.value, "tcp", false);
_endpointFactoryManager.add(new TcpEndpointFactory(tcpInstance));
ProtocolInstance udpInstance = new ProtocolInstance(this, Ice.UDPEndpointType.value, "udp", false);
_endpointFactoryManager.add(new UdpEndpointFactory(udpInstance));
_pluginManager = new Ice.PluginManagerI(communicator);
if(_initData.valueFactoryManager == null)
{
_initData.valueFactoryManager = new ValueFactoryManagerI();
}
_outgoingConnectionFactory = new OutgoingConnectionFactory(communicator, this);
_objectAdapterFactory = new ObjectAdapterFactory(this, communicator);
_retryQueue = new RetryQueue(this);
}
catch(Ice.LocalException)
{
destroy();
throw;
}
}
public void prepare(string operation, Ice.OperationMode mode, Dictionary <string, string>?context)
{
Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(proxy_.IceReference.getProtocol()));
mode_ = mode;
observer_ = ObserverHelper.get(proxy_, operation, context);
switch (proxy_.IceReference.getMode())
{
case Ice.InvocationMode.Twoway:
case Ice.InvocationMode.Oneway:
case Ice.InvocationMode.Datagram:
{
os_.WriteBlob(Protocol.requestHdr);
break;
}
case Ice.InvocationMode.BatchOneway:
case Ice.InvocationMode.BatchDatagram:
{
Debug.Assert(false); // not implemented
break;
}
}
Reference rf = proxy_.IceReference;
rf.getIdentity().ice_writeMembers(os_);
//
// For compatibility with the old FacetPath.
//
string facet = rf.getFacet();
if (facet == null || facet.Length == 0)
{
os_.WriteStringSeq(null);
}
else
{
string[] facetPath = { facet };
os_.WriteStringSeq(facetPath);
}
os_.WriteString(operation);
os_.WriteByte((byte)mode);
if (context != null)
{
//
// Explicit context
//
Ice.ContextHelper.Write(os_, context);
}
else
{
//
// Implicit context
//
Ice.ImplicitContextI implicitContext = (Ice.ImplicitContextI)rf.getCommunicator().getImplicitContext();
Dictionary <string, string> prxContext = rf.getContext();
if (implicitContext == null)
{
Ice.ContextHelper.Write(os_, prxContext);
}
else
{
implicitContext.write(prxContext, os_);
}
}
}
public void prepare(string operation, Ice.OperationMode mode, Dictionary <string, string> ctx,
bool explicitCtx, bool synchronous)
{
Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(proxy_.reference__().getProtocol()));
mode_ = mode;
_synchronous = synchronous;
if (explicitCtx && ctx == null)
{
ctx = _emptyContext;
}
observer_ = ObserverHelper.get(proxy_, operation, ctx);
switch (proxy_.reference__().getMode())
{
case Reference.Mode.ModeTwoway:
case Reference.Mode.ModeOneway:
case Reference.Mode.ModeDatagram:
{
os_.writeBlob(Protocol.requestHdr);
break;
}
case Reference.Mode.ModeBatchOneway:
case Reference.Mode.ModeBatchDatagram:
{
proxy_.getBatchRequestQueue__().prepareBatchRequest(os_);
break;
}
}
Reference rf = proxy_.reference__();
rf.getIdentity().write__(os_);
//
// For compatibility with the old FacetPath.
//
string facet = rf.getFacet();
if (facet == null || facet.Length == 0)
{
os_.writeStringSeq(null);
}
else
{
string[] facetPath = { facet };
os_.writeStringSeq(facetPath);
}
os_.writeString(operation);
os_.writeByte((byte)mode);
if (ctx != null)
{
//
// Explicit context
//
Ice.ContextHelper.write(os_, ctx);
}
else
{
//
// Implicit context
//
Ice.ImplicitContextI implicitContext = rf.getInstance().getImplicitContext();
Dictionary <string, string> prxContext = rf.getContext();
if (implicitContext == null)
{
Ice.ContextHelper.write(os_, prxContext);
}
else
{
implicitContext.write(prxContext, os_);
}
}
}
private void writeHeader(string operation, Ice.OperationMode mode, Dictionary <string, string> context)
{
switch (_handler.getReference().getMode())
{
case Reference.Mode.ModeTwoway:
case Reference.Mode.ModeOneway:
case Reference.Mode.ModeDatagram:
{
_os.writeBlob(IceInternal.Protocol.requestHdr);
break;
}
case Reference.Mode.ModeBatchOneway:
case Reference.Mode.ModeBatchDatagram:
{
_handler.prepareBatchRequest(_os);
break;
}
}
try
{
_handler.getReference().getIdentity().write__(_os);
//
// For compatibility with the old FacetPath.
//
string facet = _handler.getReference().getFacet();
if (facet == null || facet.Length == 0)
{
_os.writeStringSeq(null);
}
else
{
string[] facetPath = { facet };
_os.writeStringSeq(facetPath);
}
_os.writeString(operation);
_os.writeByte((byte)mode);
if (context != null)
{
//
// Explicit context
//
Ice.ContextHelper.write(_os, context);
}
else
{
//
// Implicit context
//
Ice.ImplicitContextI implicitContext = _handler.getReference().getInstance().getImplicitContext();
Dictionary <string, string> prxContext = _handler.getReference().getContext();
if (implicitContext == null)
{
Ice.ContextHelper.write(_os, prxContext);
}
else
{
implicitContext.write(prxContext, _os);
}
}
}
catch (Ice.LocalException ex)
{
abort(ex);
}
}
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;
}
}