public OutputStreamI(Communicator communicator)
{
_communicator = communicator;
IceInternal.Instance instance = IceInternal.Util.getInstance(communicator);
_os = new IceInternal.BasicStream(instance, instance.defaultsAndOverrides().defaultEncoding);
_os.closure(this);
}
internal Timer(IceInternal.Instance instance)
{
#if !SILVERLIGHT
init(instance, ThreadPriority.Normal, false);
#else
init(instance);
#endif
}
public OutputStreamI(Communicator communicator, EncodingVersion v)
{
_communicator = communicator;
IceInternal.Instance instance = IceInternal.Util.getInstance(communicator);
_os = new IceInternal.BasicStream(instance, v);
_os.closure(this);
}
ThreadHookPlugin(Communicator communicator, System.Action threadStart, System.Action threadStop)
{
if (communicator == null)
{
PluginInitializationException ex = new PluginInitializationException();
ex.reason = "Communicator cannot be null";
throw ex;
}
IceInternal.Instance instance = IceInternal.Util.getInstance(communicator);
instance.setThreadHook(threadStart, threadStop);
}
private void initialize(IceInternal.Instance instance, byte[] data, EncodingVersion v, bool copyData)
{
if (copyData)
{
_is = new IceInternal.BasicStream(instance, v);
_is.resize(data.Length, true);
IceInternal.Buffer buf = _is.getBuffer();
buf.b.position(0);
buf.b.put(data);
buf.b.position(0);
}
else
{
_is = new IceInternal.BasicStream(instance, v, data);
}
_is.closure(this);
}
LoggerPlugin(Communicator communicator, Logger logger)
{
if (communicator == null)
{
PluginInitializationException ex = new PluginInitializationException();
ex.reason = "Communicator cannot be null";
throw ex;
}
if (logger == null)
{
PluginInitializationException ex = new PluginInitializationException();
ex.reason = "Logger cannot be null";
throw ex;
}
IceInternal.Instance instance = IceInternal.Util.getInstance(communicator);
instance.setLogger(logger);
}
internal void init(IceInternal.Instance instance, ThreadPriority priority, bool hasPriority)
{
_instance = instance;
string threadName = _instance.initializationData().properties.getProperty("Ice.ProgramName");
if (threadName.Length > 0)
{
threadName += "-";
}
_thread = new Thread(new ThreadStart(Run));
_thread.IsBackground = true;
_thread.Name = threadName + "Ice.Timer";
if (hasPriority)
{
_thread.Priority = priority;
}
_thread.Start();
}
public InputStreamI(Communicator communicator, byte[] data, bool copyData)
{
_communicator = communicator;
IceInternal.Instance instance = IceInternal.Util.getInstance(communicator);
initialize(instance, data, instance.defaultsAndOverrides().defaultEncoding, copyData);
}
internal PropertiesAdminI(IceInternal.Instance instance)
{
_properties = instance.initializationData().properties;
_logger = instance.initializationData().logger;
}
internal CommunicatorI(InitializationData initData)
{
instance_ = new IceInternal.Instance(this, initData);
}
internal void init(IceInternal.Instance instance, ThreadPriority priority, bool hasPriority)
//
// Only for use by IceInternal.ObjectAdapterFactory
//
public ObjectAdapterI(IceInternal.Instance instance, Communicator communicator,
IceInternal.ObjectAdapterFactory objectAdapterFactory, string name,
RouterPrx router, bool noConfig)
{
_deactivated = false;
instance_ = instance;
_communicator = communicator;
_objectAdapterFactory = objectAdapterFactory;
_hasAcmTimeout = false;
_acmTimeout = 0;
_servantManager = new IceInternal.ServantManager(instance, name);
_activateOneOffDone = false;
_name = name;
_incomingConnectionFactories = new List<IceInternal.IncomingConnectionFactory>();
_publishedEndpoints = new List<IceInternal.EndpointI>();
_routerEndpoints = new List<IceInternal.EndpointI>();
_routerInfo = null;
_directCount = 0;
_waitForActivate = false;
_waitForHold = 0;
_waitForHoldRetry = false;
_noConfig = noConfig;
_processId = null;
if(_noConfig)
{
_id = "";
_replicaGroupId = "";
_reference = instance_.referenceFactory().create("dummy -t", "");
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.
//
_deactivated = true;
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;
}
try
{
int threadPoolSize = properties.getPropertyAsInt(_name + ".ThreadPool.Size");
int threadPoolSizeMax = properties.getPropertyAsInt(_name + ".ThreadPool.SizeMax");
if(threadPoolSize > 0 || threadPoolSizeMax > 0)
{
_threadPool = new IceInternal.ThreadPool(instance_, _name + ".ThreadPool", 0);
}
_hasAcmTimeout = properties.getProperty(_name + ".ACM").Length > 0;
if(_hasAcmTimeout)
{
_acmTimeout = properties.getPropertyAsInt(_name + ".ACM");
instance_.connectionMonitor().checkIntervalForACM(_acmTimeout);
}
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.
//
IceInternal.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;)
{
IceInternal.EndpointI e1 = _routerEndpoints[i];
IceInternal.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<IceInternal.EndpointI> endpoints =
parseEndpoints(properties.getProperty(_name + ".Endpoints"), true);
foreach(IceInternal.EndpointI endp in endpoints)
{
IceInternal.IncomingConnectionFactory factory =
new IceInternal.IncomingConnectionFactory(instance, endp, this, _name);
_incomingConnectionFactories.Add(factory);
}
if(endpoints.Count == 0)
{
IceInternal.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;
}
}
public void destroy()
{
_m.Lock();
try
{
//
// Another thread is in the process of destroying the object
// adapter. Wait for it to finish.
//
while(_destroying)
{
_m.Wait();
}
//
// Object adpater is already destroyed.
//
if(_destroyed)
{
return;
}
_destroying = true;
}
finally
{
_m.Unlock();
}
//
// Deactivate and wait for completion.
//
deactivate();
waitForDeactivate();
//
// 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();
}
IceInternal.ObjectAdapterFactory objectAdapterFactory;
_m.Lock();
try
{
//
// Signal that destroying is complete.
//
_destroying = false;
_destroyed = true;
_m.NotifyAll();
//
// 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 = _objectAdapterFactory;
_objectAdapterFactory = null;
}
finally
{
_m.Unlock();
}
if(objectAdapterFactory != null)
{
objectAdapterFactory.removeObjectAdapter(this);
}
}
private void initialize(EncodingVersion encoding)
{
instance_ = null;
_encoding = encoding;
_encapsStack = null;
_encapsCache = null;
_traceSlicing = false;
_closure = null;
_sliceValues = true;
_startSeq = -1;
_minSeqSize = 0;
}
private void initialize(IceInternal.Instance instance, EncodingVersion encoding)
{
initialize(encoding);
instance_ = instance;
_traceSlicing = instance_.traceLevels().slicing > 0;
_valueFactoryManager = instance_.initializationData().valueFactoryManager;
_logger = instance_.initializationData().logger;
_classResolver = instance_.resolveClass;
}
internal ConnectionI(Communicator communicator, IceInternal.Instance instance,
IceInternal.ACMMonitor monitor, IceInternal.Transceiver transceiver,
IceInternal.Connector connector, IceInternal.EndpointI endpoint, ObjectAdapterI adapter)
{
_communicator = communicator;
_instance = instance;
_monitor = monitor;
_transceiver = transceiver;
_desc = transceiver.ToString();
_type = transceiver.protocol();
_connector = connector;
_endpoint = endpoint;
_adapter = adapter;
InitializationData initData = instance.initializationData();
_logger = initData.logger; // Cached for better performance.
_traceLevels = instance.traceLevels(); // Cached for better performance.
_timer = instance.timer();
_writeTimeout = new TimeoutCallback(this);
_writeTimeoutScheduled = false;
_readTimeout = new TimeoutCallback(this);
_readTimeoutScheduled = false;
_warn = initData.properties.getPropertyAsInt("Ice.Warn.Connections") > 0;
_warnUdp = initData.properties.getPropertyAsInt("Ice.Warn.Datagrams") > 0;
_cacheBuffers = instance.cacheMessageBuffers() > 0;
if(_monitor != null && _monitor.getACM().timeout > 0)
{
_acmLastActivity = IceInternal.Time.currentMonotonicTimeMillis();
}
else
{
_acmLastActivity = -1;
}
_nextRequestId = 1;
_messageSizeMax = adapter != null ? adapter.messageSizeMax() : instance.messageSizeMax();
_batchRequestQueue = new IceInternal.BatchRequestQueue(instance, _endpoint.datagram());
_readStream = new InputStream(instance, Util.currentProtocolEncoding);
_readHeader = false;
_readStreamPos = -1;
_writeStream = new OutputStream(instance, Util.currentProtocolEncoding);
_writeStreamPos = -1;
_dispatchCount = 0;
_state = StateNotInitialized;
_compressionLevel = initData.properties.getPropertyAsIntWithDefault("Ice.Compression.Level", 1);
if(_compressionLevel < 1)
{
_compressionLevel = 1;
}
else if(_compressionLevel > 9)
{
_compressionLevel = 9;
}
if(adapter != null)
{
_servantManager = adapter.getServantManager();
}
try
{
if(adapter != null)
{
_threadPool = adapter.getThreadPool();
}
else
{
_threadPool = instance.clientThreadPool();
}
_threadPool.initialize(this);
}
catch(LocalException)
{
throw;
}
catch(System.Exception ex)
{
throw new SyscallException(ex);
}
}
internal CommunicatorI(InitializationData initData)
{
instance_ = new IceInternal.Instance(this, initData);
}
//
// Only for use by Instance.
//
internal Timer(IceInternal.Instance instance, ThreadPriority priority)
{
init(instance, priority, true);
}
internal Timer(IceInternal.Instance instance)
{
init(instance, ThreadPriority.Normal, false);
}
internal ConnectionI(IceInternal.Instance instance, IceInternal.ConnectionReaper reaper,
IceInternal.Transceiver transceiver, IceInternal.Connector connector,
IceInternal.EndpointI endpoint, ObjectAdapter adapter)
{
_instance = instance;
_reaper = reaper;
InitializationData initData = instance.initializationData();
_transceiver = transceiver;
_desc = transceiver.ToString();
_type = transceiver.type();
_connector = connector;
_endpoint = endpoint;
_adapter = adapter;
_dispatcher = initData.dispatcher; // Cached for better performance.
_logger = initData.logger; // Cached for better performance.
_traceLevels = instance.traceLevels(); // Cached for better performance.
_timer = instance.timer();
_writeTimeout = new TimeoutCallback(this);
_writeTimeoutScheduled = false;
_readTimeout = new TimeoutCallback(this);
_readTimeoutScheduled = false;
_warn = initData.properties.getPropertyAsInt("Ice.Warn.Connections") > 0;
_warnUdp = initData.properties.getPropertyAsInt("Ice.Warn.Datagrams") > 0;
_cacheBuffers = initData.properties.getPropertyAsIntWithDefault("Ice.CacheMessageBuffers", 1) == 1;
_acmAbsoluteTimeoutMillis = 0;
_nextRequestId = 1;
_batchAutoFlush = initData.properties.getPropertyAsIntWithDefault("Ice.BatchAutoFlush", 1) > 0;
_batchStream = new IceInternal.BasicStream(instance, _batchAutoFlush);
_batchStreamInUse = false;
_batchRequestNum = 0;
_batchRequestCompress = false;
_batchMarker = 0;
_readStream = new IceInternal.BasicStream(instance);
_readHeader = false;
_writeStream = new IceInternal.BasicStream(instance);
_dispatchCount = 0;
_state = StateNotInitialized;
_compressionLevel = initData.properties.getPropertyAsIntWithDefault("Ice.Compression.Level", 1);
if(_compressionLevel < 1)
{
_compressionLevel = 1;
}
else if(_compressionLevel > 9)
{
_compressionLevel = 9;
}
ObjectAdapterI adapterImpl = _adapter as ObjectAdapterI;
if(adapterImpl != null)
{
_servantManager = adapterImpl.getServantManager();
}
try
{
if(_endpoint.datagram())
{
_acmTimeout = 0;
}
else
{
if(adapterImpl != null)
{
_acmTimeout = adapterImpl.getACM();
}
else
{
_acmTimeout = _instance.clientACM();
}
}
if(adapterImpl != null)
{
_threadPool = adapterImpl.getThreadPool();
}
else
{
_threadPool = instance.clientThreadPool();
}
_threadPool.initialize(this);
}
catch(LocalException)
{
throw;
}
catch(System.Exception ex)
{
throw new SyscallException(ex);
}
}