public ProtocolInstance(Instance instance, short type, string protocol, bool secure) { instance_ = instance; traceLevel_ = instance_.traceLevels().network; traceCategory_ = instance_.traceLevels().networkCat; logger_ = instance_.initializationData().logger; properties_ = instance_.initializationData().properties; type_ = type; protocol_ = protocol; secure_ = secure; }
public ProtocolInstance(Ice.Communicator communicator, short type, string protocol, bool secure) { instance_ = Util.getInstance(communicator); traceLevel_ = instance_.traceLevels().network; traceCategory_ = instance_.traceLevels().networkCat; logger_ = instance_.initializationData().logger; properties_ = instance_.initializationData().properties; type_ = type; protocol_ = protocol; secure_ = secure; }
public int run() { try { Ice.Properties properties = _communicator.getProperties(); // // Create an object adapter. Services probably should NOT share // this object adapter, as the endpoint(s) for this object adapter // will most likely need to be firewalled for security reasons. // Ice.ObjectAdapter adapter = null; if (properties.getProperty("IceBox.ServiceManager.Endpoints").Length != 0) { adapter = _communicator.createObjectAdapter("IceBox.ServiceManager"); Ice.Identity identity = new Ice.Identity(); identity.category = properties.getPropertyWithDefault("IceBox.InstanceName", "IceBox"); identity.name = "ServiceManager"; adapter.add(this, identity); } // // Parse the property set with the prefix "IceBox.Service.". These // properties should have the following format: // // IceBox.Service.Foo=<assembly>:Package.Foo [args] // // We parse the service properties specified in IceBox.LoadOrder // first, then the ones from remaining services. // string prefix = "IceBox.Service."; Dictionary <string, string> services = properties.getPropertiesForPrefix(prefix); string[] loadOrder = properties.getPropertyAsList("IceBox.LoadOrder"); List <StartServiceInfo> servicesInfo = new List <StartServiceInfo>(); for (int i = 0; i < loadOrder.Length; ++i) { if (loadOrder[i].Length > 0) { string key = prefix + loadOrder[i]; string value = services[key]; if (value == null) { FailureException ex = new FailureException(); ex.reason = "ServiceManager: no service definition for `" + loadOrder[i] + "'"; throw ex; } servicesInfo.Add(new StartServiceInfo(loadOrder[i], value, _argv)); services.Remove(key); } } foreach (KeyValuePair <string, string> entry in services) { string name = entry.Key.Substring(prefix.Length); string value = entry.Value; servicesInfo.Add(new StartServiceInfo(name, value, _argv)); } // // Check if some services are using the shared communicator in which // case we create the shared communicator now with a property set that // is the union of all the service properties (from services that use // the shared communicator). // if (properties.getPropertiesForPrefix("IceBox.UseSharedCommunicator.").Count > 0) { Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = createServiceProperties("SharedCommunicator"); foreach (StartServiceInfo service in servicesInfo) { if (properties.getPropertyAsInt("IceBox.UseSharedCommunicator." + service.name) <= 0) { continue; } // // Load the service properties using the shared communicator properties as // the default properties. // Ice.Properties svcProperties = Ice.Util.createProperties(ref service.args, initData.properties); // // Remove properties from the shared property set that a service explicitly clears. // Dictionary <string, string> allProps = initData.properties.getPropertiesForPrefix(""); foreach (string key in allProps.Keys) { if (svcProperties.getProperty(key).Length == 0) { initData.properties.setProperty(key, ""); } } // // Add the service properties to the shared communicator properties. // foreach (KeyValuePair <string, string> entry in svcProperties.getPropertiesForPrefix("")) { initData.properties.setProperty(entry.Key, entry.Value); } // // Parse <service>.* command line options (the Ice command line options // were parsed by the call to createProperties above). // service.args = initData.properties.parseCommandLineOptions(service.name, service.args); } string facetNamePrefix = "IceBox.SharedCommunicator."; bool addFacets = configureAdmin(initData.properties, facetNamePrefix); _sharedCommunicator = Ice.Util.initialize(initData); if (addFacets) { // Add all facets created on shared communicator to the IceBox communicator // but renamed <prefix>.<facet-name>, except for the Process facet which is // never added. foreach (KeyValuePair <string, Ice.Object> p in _sharedCommunicator.findAllAdminFacets()) { if (!p.Key.Equals("Process")) { _communicator.addAdminFacet(p.Value, facetNamePrefix + p.Key); } } } } foreach (StartServiceInfo s in servicesInfo) { startService(s.name, s.entryPoint, s.args); } // // We may want to notify external scripts that the services // have started. This is done by defining the property: // // PrintServicesReady=bundleName // // Where bundleName is whatever you choose to call this set of // services. It will be echoed back as "bundleName ready". // // This must be done after start() has been invoked on the // services. // string bundleName = properties.getProperty("IceBox.PrintServicesReady"); if (bundleName.Length > 0) { Console.Out.WriteLine(bundleName + " ready"); } // // Don't move after the adapter activation. This allows // applications to wait for the service manager to be // reachable before sending a signal to shutdown the // // Ice.Application.shutdownOnInterrupt(); // // Register "this" as a facet to the Admin object and create Admin object // try { _communicator.addAdminFacet(this, "IceBox.ServiceManager"); _communicator.getAdmin(); } catch (Ice.ObjectAdapterDeactivatedException) { // // Expected if the communicator has been shutdown. // } // // Start request dispatching after we've started the services. // if (adapter != null) { try { adapter.activate(); } catch (Ice.ObjectAdapterDeactivatedException) { // // Expected if the communicator has been shutdown. // } } _communicator.waitForShutdown(); } catch (FailureException ex) { _logger.error(ex.ToString()); return(1); } catch (Exception ex) { _logger.error("ServiceManager: caught exception:\n" + ex.ToString()); return(1); } finally { // // Invoke stop() on the services. // stopAll(); } return(0); }
static public string getTestProtocol(Ice.Properties properties) { return(properties.getPropertyWithDefault("Ice.Default.Protocol", "tcp")); }
static public int getTestPort(Ice.Properties properties, int num) { return(properties.getPropertyAsIntWithDefault("Test.BasePort", 12010) + num); }
public PropertiesAdminI(string name, Ice.Properties properties, Ice.Logger logger) { _name = name; _properties = properties; _logger = logger; }
static public string getTestHost(Ice.Properties properties) { return(properties.getPropertyWithDefault("Ice.Default.Host", "127.0.0.1")); }
public ThreadPool(Instance instance, string prefix, int timeout) { Ice.Properties properties = instance.initializationData().properties; _instance = instance; _dispatcher = instance.initializationData().dispatcher; _destroyed = false; _prefix = prefix; _threadIndex = 0; _inUse = 0; _serialize = properties.getPropertyAsInt(_prefix + ".Serialize") > 0; _serverIdleTime = timeout; string programName = properties.getProperty("Ice.ProgramName"); if (programName.Length > 0) { _threadPrefix = programName + "-" + _prefix; } else { _threadPrefix = _prefix; } // // We use just one thread as the default. This is the fastest // possible setting, still allows one level of nesting, and // doesn't require to make the servants thread safe. // int size = properties.getPropertyAsIntWithDefault(_prefix + ".Size", 1); if (size < 1) { string s = _prefix + ".Size < 1; Size adjusted to 1"; _instance.initializationData().logger.warning(s); size = 1; } int sizeMax = properties.getPropertyAsIntWithDefault(_prefix + ".SizeMax", size); if (sizeMax < size) { string s = _prefix + ".SizeMax < " + _prefix + ".Size; SizeMax adjusted to Size (" + size + ")"; _instance.initializationData().logger.warning(s); sizeMax = size; } int sizeWarn = properties.getPropertyAsInt(_prefix + ".SizeWarn"); if (sizeWarn != 0 && sizeWarn < size) { string s = _prefix + ".SizeWarn < " + _prefix + ".Size; adjusted SizeWarn to Size (" + size + ")"; _instance.initializationData().logger.warning(s); sizeWarn = size; } else if (sizeWarn > sizeMax) { string s = _prefix + ".SizeWarn > " + _prefix + ".SizeMax; adjusted SizeWarn to SizeMax (" + sizeMax + ")"; _instance.initializationData().logger.warning(s); sizeWarn = sizeMax; } int threadIdleTime = properties.getPropertyAsIntWithDefault(_prefix + ".ThreadIdleTime", 60); if (threadIdleTime < 0) { string s = _prefix + ".ThreadIdleTime < 0; ThreadIdleTime adjusted to 0"; _instance.initializationData().logger.warning(s); threadIdleTime = 0; } _size = size; _sizeMax = sizeMax; _sizeWarn = sizeWarn; _threadIdleTime = threadIdleTime; int stackSize = properties.getPropertyAsInt(_prefix + ".StackSize"); if (stackSize < 0) { string s = _prefix + ".StackSize < 0; Size adjusted to OS default"; _instance.initializationData().logger.warning(s); stackSize = 0; } _stackSize = stackSize; _priority = properties.getProperty(_prefix + ".ThreadPriority").Length > 0 ? Util.stringToThreadPriority(properties.getProperty(_prefix + ".ThreadPriority")) : Util.stringToThreadPriority(properties.getProperty("Ice.ThreadPriority")); if (_instance.traceLevels().threadPool >= 1) { string s = "creating " + _prefix + ": Size = " + _size + ", SizeMax = " + _sizeMax + ", SizeWarn = " + _sizeWarn; _instance.initializationData().logger.trace(_instance.traceLevels().threadPoolCat, s); } _workItems = new Queue <ThreadPoolWorkItem>(); try { _threads = new List <WorkerThread>(); for (int i = 0; i < _size; ++i) { WorkerThread thread = new WorkerThread(this, _threadPrefix + "-" + _threadIndex++); thread.start(_priority); _threads.Add(thread); } } catch (System.Exception ex) { string s = "cannot create thread for `" + _prefix + "':\n" + ex; _instance.initializationData().logger.error(s); destroy(); joinWithAllThreads(); throw; } }
internal LocatorManager(Ice.Properties properties) { _table = new Dictionary <Ice.LocatorPrx, LocatorInfo>(); _locatorTables = new Dictionary <LocatorKey, LocatorTable>(); _background = properties.getPropertyAsInt("Ice.BackgroundLocatorCacheUpdates") > 0; }
public IMetricsMap create(string mapPrefix, Ice.Properties properties) { return(new MetricsMap <T>(mapPrefix, properties, _subMaps)); }
public MetricsAdminI(Ice.Properties properties, Ice.Logger logger) { _logger = logger; _properties = properties; updateViews(); }
internal MetricsMap(string mapPrefix, Ice.Properties props, Dictionary <string, ISubMapFactory> subMaps) { MetricsAdminI.validateProperties(mapPrefix, props); _properties = props.getPropertiesForPrefix(mapPrefix); _retain = props.getPropertyAsIntWithDefault(mapPrefix + "RetainDetached", 10); _accept = parseRule(props, mapPrefix + "Accept"); _reject = parseRule(props, mapPrefix + "Reject"); _groupByAttributes = new List <string>(); _groupBySeparators = new List <string>(); string groupBy = props.getPropertyWithDefault(mapPrefix + "GroupBy", "id"); if (groupBy.Length > 0) { string v = ""; bool attribute = char.IsLetter(groupBy[0]) || char.IsDigit(groupBy[0]); if (!attribute) { _groupByAttributes.Add(""); } foreach (char p in groupBy) { bool isAlphaNum = char.IsLetter(p) || char.IsDigit(p) || p == '.'; if (attribute && !isAlphaNum) { _groupByAttributes.Add(v); v = "" + p; attribute = false; } else if (!attribute && isAlphaNum) { _groupBySeparators.Add(v); v = "" + p; attribute = true; } else { v += p; } } if (attribute) { _groupByAttributes.Add(v); } else { _groupBySeparators.Add(v); } } if (subMaps != null && subMaps.Count > 0) { _subMaps = new Dictionary <string, ISubMapCloneFactory>(); List <string> subMapNames = new List <string>(); foreach (KeyValuePair <string, ISubMapFactory> e in subMaps) { subMapNames.Add(e.Key); string subMapsPrefix = mapPrefix + "Map."; string subMapPrefix = subMapsPrefix + e.Key + '.'; if (props.getPropertiesForPrefix(subMapPrefix).Count == 0) { if (props.getPropertiesForPrefix(subMapsPrefix).Count == 0) { subMapPrefix = mapPrefix; } else { continue; // This sub-map isn't configured. } } _subMaps.Add(e.Key, e.Value.createCloneFactory(subMapPrefix, props)); } } else { _subMaps = null; } }
public ISubMapCloneFactory createCloneFactory(string subMapPrefix, Ice.Properties properties) { return(new SubMapCloneFactory <S>(new MetricsMap <S>(subMapPrefix, properties, null), _field)); }
private Reference create(Ice.Identity ident, string facet, Reference.Mode mode, bool secure, Ice.ProtocolVersion protocol, Ice.EncodingVersion encoding, EndpointI[] endpoints, string adapterId, string propertyPrefix) { DefaultsAndOverrides defaultsAndOverrides = _instance.defaultsAndOverrides(); // // Default local proxy options. // LocatorInfo locatorInfo = null; if (_defaultLocator != null) { if (!((Ice.ObjectPrxHelperBase)_defaultLocator).iceReference().getEncoding().Equals(encoding)) { locatorInfo = _instance.locatorManager().get( (Ice.LocatorPrx)_defaultLocator.ice_encodingVersion(encoding)); } else { locatorInfo = _instance.locatorManager().get(_defaultLocator); } } RouterInfo routerInfo = _instance.routerManager().get(_defaultRouter); bool collocOptimized = defaultsAndOverrides.defaultCollocationOptimization; bool cacheConnection = true; bool preferSecure = defaultsAndOverrides.defaultPreferSecure; Ice.EndpointSelectionType endpointSelection = defaultsAndOverrides.defaultEndpointSelection; int locatorCacheTimeout = defaultsAndOverrides.defaultLocatorCacheTimeout; int invocationTimeout = defaultsAndOverrides.defaultInvocationTimeout; Dictionary <string, string> context = null; // // Override the defaults with the proxy properties if a property prefix is defined. // if (propertyPrefix != null && propertyPrefix.Length > 0) { Ice.Properties properties = _instance.initializationData().properties; // // Warn about unknown properties. // if (properties.getPropertyAsIntWithDefault("Ice.Warn.UnknownProperties", 1) > 0) { checkForUnknownProperties(propertyPrefix); } string property; property = propertyPrefix + ".Locator"; Ice.LocatorPrx locator = Ice.LocatorPrxHelper.uncheckedCast(_communicator.propertyToProxy(property)); if (locator != null) { if (!((Ice.ObjectPrxHelperBase)locator).iceReference().getEncoding().Equals(encoding)) { locatorInfo = _instance.locatorManager().get( (Ice.LocatorPrx)locator.ice_encodingVersion(encoding)); } else { locatorInfo = _instance.locatorManager().get(locator); } } property = propertyPrefix + ".Router"; Ice.RouterPrx router = Ice.RouterPrxHelper.uncheckedCast(_communicator.propertyToProxy(property)); if (router != null) { if (propertyPrefix.EndsWith(".Router", StringComparison.Ordinal)) { string s = "`" + property + "=" + properties.getProperty(property) + "': cannot set a router on a router; setting ignored"; _instance.initializationData().logger.warning(s); } else { routerInfo = _instance.routerManager().get(router); } } property = propertyPrefix + ".CollocationOptimized"; collocOptimized = properties.getPropertyAsIntWithDefault(property, collocOptimized ? 1 : 0) > 0; property = propertyPrefix + ".ConnectionCached"; cacheConnection = properties.getPropertyAsIntWithDefault(property, cacheConnection ? 1 : 0) > 0; property = propertyPrefix + ".PreferSecure"; preferSecure = properties.getPropertyAsIntWithDefault(property, preferSecure ? 1 : 0) > 0; property = propertyPrefix + ".EndpointSelection"; if (properties.getProperty(property).Length > 0) { string type = properties.getProperty(property); if (type.Equals("Random")) { endpointSelection = Ice.EndpointSelectionType.Random; } else if (type.Equals("Ordered")) { endpointSelection = Ice.EndpointSelectionType.Ordered; } else { throw new Ice.EndpointSelectionTypeParseException("illegal value `" + type + "'; expected `Random' or `Ordered'"); } } property = propertyPrefix + ".LocatorCacheTimeout"; string val = properties.getProperty(property); if (val.Length > 0) { locatorCacheTimeout = properties.getPropertyAsIntWithDefault(property, locatorCacheTimeout); if (locatorCacheTimeout < -1) { locatorCacheTimeout = -1; StringBuilder msg = new StringBuilder("invalid value for "); msg.Append(property); msg.Append(" `"); msg.Append(properties.getProperty(property)); msg.Append("': defaulting to -1"); _instance.initializationData().logger.warning(msg.ToString()); } } property = propertyPrefix + ".InvocationTimeout"; val = properties.getProperty(property); if (val.Length > 0) { invocationTimeout = properties.getPropertyAsIntWithDefault(property, invocationTimeout); if (invocationTimeout < 1 && invocationTimeout != -1) { invocationTimeout = -1; StringBuilder msg = new StringBuilder("invalid value for "); msg.Append(property); msg.Append(" `"); msg.Append(properties.getProperty(property)); msg.Append("': defaulting to -1"); _instance.initializationData().logger.warning(msg.ToString()); } } property = propertyPrefix + ".Context."; Dictionary <string, string> contexts = properties.getPropertiesForPrefix(property); if (contexts.Count != 0) { context = new Dictionary <string, string>(); foreach (KeyValuePair <string, string> e in contexts) { context.Add(e.Key.Substring(property.Length), e.Value); } } } // // Create new reference // return(new RoutableReference(_instance, _communicator, ident, facet, mode, secure, protocol, encoding, endpoints, adapterId, locatorInfo, routerInfo, collocOptimized, cacheConnection, preferSecure, endpointSelection, locatorCacheTimeout, invocationTimeout, context)); }
internal PropertiesAdminI(IceInternal.Instance instance) { _properties = instance.initializationData().properties; _logger = instance.initializationData().logger; }
static public string getTestEndpoint(Ice.Properties properties, int num) { return(getTestEndpoint(properties, num, "")); }
public PropertiesAdminI(Ice.Properties properties) { _properties = properties; }
internal DefaultsAndOverrides(Ice.Properties properties, Ice.Logger logger) { string val; defaultProtocol = properties.getPropertyWithDefault("Ice.Default.Protocol", "tcp"); val = properties.getProperty("Ice.Default.Host"); if (val.Length != 0) { defaultHost = val; } else { defaultHost = null; } val = properties.getProperty("Ice.Default.SourceAddress"); if (val.Length > 0) { defaultSourceAddress = Network.getNumericAddress(val); if (defaultSourceAddress == null) { throw new Ice.InitializationException("invalid IP address set for Ice.Default.SourceAddress: `" + val + "'"); } } else { defaultSourceAddress = null; } val = properties.getProperty("Ice.Override.Timeout"); if (val.Length > 0) { overrideTimeout = true; overrideTimeoutValue = properties.getPropertyAsInt("Ice.Override.Timeout"); if (overrideTimeoutValue < 1 && overrideTimeoutValue != -1) { overrideTimeoutValue = -1; StringBuilder msg = new StringBuilder("invalid value for Ice.Override.Timeout `"); msg.Append(properties.getProperty("Ice.Override.Timeout")); msg.Append("': defaulting to -1"); logger.warning(msg.ToString()); } } else { overrideTimeout = false; overrideTimeoutValue = -1; } val = properties.getProperty("Ice.Override.ConnectTimeout"); if (val.Length > 0) { overrideConnectTimeout = true; overrideConnectTimeoutValue = properties.getPropertyAsInt("Ice.Override.ConnectTimeout"); if (overrideConnectTimeoutValue < 1 && overrideConnectTimeoutValue != -1) { overrideConnectTimeoutValue = -1; StringBuilder msg = new StringBuilder("invalid value for Ice.Override.ConnectTimeout `"); msg.Append(properties.getProperty("Ice.Override.ConnectTimeout")); msg.Append("': defaulting to -1"); logger.warning(msg.ToString()); } } else { overrideConnectTimeout = false; overrideConnectTimeoutValue = -1; } val = properties.getProperty("Ice.Override.CloseTimeout"); if (val.Length > 0) { overrideCloseTimeout = true; overrideCloseTimeoutValue = properties.getPropertyAsInt("Ice.Override.CloseTimeout"); if (overrideCloseTimeoutValue < 1 && overrideCloseTimeoutValue != -1) { overrideCloseTimeoutValue = -1; StringBuilder msg = new StringBuilder("invalid value for Ice.Override.CloseTimeout `"); msg.Append(properties.getProperty("Ice.Override.CloseTimeout")); msg.Append("': defaulting to -1"); logger.warning(msg.ToString()); } } else { overrideCloseTimeout = false; overrideCloseTimeoutValue = -1; } #if COMPACT overrideCompress = false; overrideCompressValue = false; #else val = properties.getProperty("Ice.Override.Compress"); if (val.Length > 0) { overrideCompress = true; overrideCompressValue = properties.getPropertyAsInt("Ice.Override.Compress") > 0; if (!BasicStream.compressible() && overrideCompressValue) { string lib = AssemblyUtil.runtime_ == AssemblyUtil.Runtime.Mono ? "bzip2 library" : "bzip2.dll"; Console.Error.WriteLine("warning: " + lib + " not found, Ice.Override.Compress ignored."); overrideCompressValue = false; } } else { overrideCompress = !BasicStream.compressible(); overrideCompressValue = false; } #endif val = properties.getProperty("Ice.Override.Secure"); if (val.Length > 0) { overrideSecure = true; overrideSecureValue = properties.getPropertyAsInt("Ice.Override.Secure") > 0; } else { overrideSecure = false; overrideSecureValue = false; } defaultCollocationOptimization = properties.getPropertyAsIntWithDefault("Ice.Default.CollocationOptimized", 1) > 0; val = properties.getPropertyWithDefault("Ice.Default.EndpointSelection", "Random"); if (val.Equals("Random")) { defaultEndpointSelection = Ice.EndpointSelectionType.Random; } else if (val.Equals("Ordered")) { defaultEndpointSelection = Ice.EndpointSelectionType.Ordered; } else { Ice.EndpointSelectionTypeParseException ex = new Ice.EndpointSelectionTypeParseException(); ex.str = "illegal value `" + val + "'; expected `Random' or `Ordered'"; throw ex; } defaultTimeout = properties.getPropertyAsIntWithDefault("Ice.Default.Timeout", 60000); if (defaultTimeout < 1 && defaultTimeout != -1) { defaultTimeout = 60000; StringBuilder msg = new StringBuilder("invalid value for Ice.Default.Timeout `"); msg.Append(properties.getProperty("Ice.Default.Timeout")); msg.Append("': defaulting to 60000"); logger.warning(msg.ToString()); } defaultLocatorCacheTimeout = properties.getPropertyAsIntWithDefault("Ice.Default.LocatorCacheTimeout", -1); if (defaultLocatorCacheTimeout < -1) { defaultLocatorCacheTimeout = -1; StringBuilder msg = new StringBuilder("invalid value for Ice.Default.LocatorCacheTimeout `"); msg.Append(properties.getProperty("Ice.Default.LocatorCacheTimeout")); msg.Append("': defaulting to -1"); logger.warning(msg.ToString()); } defaultInvocationTimeout = properties.getPropertyAsIntWithDefault("Ice.Default.InvocationTimeout", -1); if (defaultInvocationTimeout < 1 && defaultInvocationTimeout != -1 && defaultInvocationTimeout != -2) { defaultInvocationTimeout = -1; StringBuilder msg = new StringBuilder("invalid value for Ice.Default.InvocationTimeout `"); msg.Append(properties.getProperty("Ice.Default.InvocationTimeout")); msg.Append("': defaulting to -1"); logger.warning(msg.ToString()); } defaultPreferSecure = properties.getPropertyAsIntWithDefault("Ice.Default.PreferSecure", 0) > 0; val = properties.getPropertyWithDefault("Ice.Default.EncodingVersion", Ice.Util.encodingVersionToString(Ice.Util.currentEncoding)); defaultEncoding = Ice.Util.stringToEncodingVersion(val); Protocol.checkSupportedEncoding(defaultEncoding); bool slicedFormat = properties.getPropertyAsIntWithDefault("Ice.Default.SlicedFormat", 0) > 0; defaultFormat = slicedFormat ? Ice.FormatType.SlicedFormat : Ice.FormatType.CompactFormat; }