/** * Updates link in given Panel according the src/dst names. */ void updateLinks( Panel& p ) { bool change; TemplateDict templates = p.templates(); for( unsigned int i = 0; i < templates.count(); ++i ) { change=false; LTMap<PropertyDict> pg = templates[i]->propertyGroups(); for( unsigned int j = 0; j < pg.count(); ++j ) { PropertyDict pd = pg[j]; for( unsigned int k = 0; k < pd.count(); ++k ) { if( pd[k]->type() == Property::LinkType ) { if( pd[k]->encodeValue() == srcPanelName ) { change=true; pd[k]->decodeValue( dstPanelName ); } } } } if( change ) { templates[i]->propertiesChanged(); } } }
AddDelServerLoggingCommand::AddDelServerLoggingCommand( const QString& name, const QString& type, QMap<QString,QString> props, ProjectWindow* pw, MainWindow* mw ) : Command(pw, mw, qApp->translate("AddDelServerLoggingCommand", "Add ServerLogging")), d(new AddDelServerLoggingCommandPrivate) { Q_CHECK_PTR(d); d->mode = AddDelServerLoggingCommandPrivate::Add; d->cn = name; d->ct = type; d->props = props; PropertyDict pd; for(QMap<QString,QString>::const_iterator it = d->props.begin(); it != d->props.end(); ++it) { Property* p = new Property(it.key(), "string", it.data()); Q_CHECK_PTR(p); pd.insert(it.key(), p); } d->sl = new ServerLogging(d->ct, pd); Q_CHECK_PTR(d->sl); d->canDelete = true; }
bool Ice::ObjectAdapterI::filterProperties(StringSeq& unknownProps) { static const string suffixes[] = { "AdapterId", "Endpoints", "Locator", "PublishedEndpoints", "RegisterProcess", "ReplicaGroupId", "Router", "ThreadPerConnection", "ThreadPerConnection.StackSize", "ThreadPool.Size", "ThreadPool.SizeMax", "ThreadPool.SizeWarn", "ThreadPool.StackSize" }; // // Do not create unknown properties list if Ice prefix, ie Ice, Glacier2, etc // bool addUnknown = true; string prefix = _name + "."; for(const char** i = IceInternal::PropertyNames::clPropNames; *i != 0; ++i) { string icePrefix = string(*i) + "."; if(prefix.find(icePrefix) == 0) { addUnknown = false; break; } } bool noProps = true; PropertyDict props = _instance->initializationData().properties->getPropertiesForPrefix(prefix); PropertyDict::const_iterator p; for(p = props.begin(); p != props.end(); ++p) { bool valid = false; for(unsigned int i = 0; i < sizeof(suffixes)/sizeof(*suffixes); ++i) { string prop = prefix + suffixes[i]; if(p->first == prop) { noProps = false; valid = true; break; } } if(!valid && addUnknown) { unknownProps.push_back(p->first); } } return noProps; }
void IceInternal::ReferenceFactory::checkForUnknownProperties(const string& prefix) { static const string suffixes[] = { "EndpointSelection", "ConnectionCached", "PreferSecure", "LocatorCacheTimeout", "InvocationTimeout", "Locator", "Router", "CollocationOptimized", "Context.*" }; // // Do not warn about unknown properties list if Ice prefix, ie Ice, Glacier2, etc // for(const char** i = IceInternal::PropertyNames::clPropNames; *i != 0; ++i) { if(prefix.find(*i) == 0) { return; } } StringSeq unknownProps; PropertyDict props = _instance->initializationData().properties->getPropertiesForPrefix(prefix + "."); for(PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p) { bool valid = false; for(unsigned int i = 0; i < sizeof(suffixes)/sizeof(*suffixes); ++i) { string prop = prefix + "." + suffixes[i]; if(IceUtilInternal::match(p->first, prop)) { valid = true; break; } } if(!valid) { unknownProps.push_back(p->first); } } if(unknownProps.size()) { Warning out(_instance->initializationData().logger); out << "found unknown properties for proxy '" << prefix << "':"; for(unsigned int i = 0; i < unknownProps.size(); ++i) { out << "\n " << unknownProps[i]; } } }
void Template::setPropertyGroupEnabled( const QString & group, bool enabled ) { if( d->propertyGroups.contains( group ) ) { PropertyDict props = d->propertyGroups[ group ]; for( unsigned i = 0; i < props.count(); i ++ ) { props[ i ]->setEnabled( enabled ); } } }
ObjectAdapterPtr Ice::CommunicatorI::createObjectAdapterWithRouter(const string& name, const RouterPrxPtr& router) { string oaName = name; if(oaName.empty()) { oaName = IceUtil::generateUUID(); } PropertyDict properties = proxyToProperty(router, oaName + ".Router"); for(PropertyDict::const_iterator p = properties.begin(); p != properties.end(); ++p) { getProperties()->setProperty(p->first, p->second); } return _instance->objectAdapterFactory()->createObjectAdapter(oaName, router); }
void MetricsAdminI::updated(const PropertyDict& props) { for(PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p) { if(p->first.find("IceMX.") == 0) { // Udpate the metrics views using the new configuration. try { updateViews(); } catch(const std::exception& ex) { ::Ice::Warning warn(_logger); warn << "unexpected exception while updating metrics view configuration:\n" << ex.what(); } return; } } }
void Analyzer::reload(const PropertiesPtr& properties) { MCE_INFO("Analyzer::reload type: " << type_); int defaultmin = properties->getPropertyAsIntWithDefault("Analyzer."+type_+".Default.Min", INT_MIN); int defaultmax = properties->getPropertyAsIntWithDefault("Analyzer."+type_+".Default.Max", INT_MAX); int defaultmoremin = properties->getPropertyAsIntWithDefault("Analyzer."+type_+".Default.MoreMin", INT_MIN); int defaultmoremax = properties->getPropertyAsIntWithDefault("Analyzer."+type_+".Default.MoreMax", INT_MAX); LimiterPtr defaulter = new Limiter(defaultmoremin, defaultmin, defaultmax, defaultmoremax); map<string, LimiterPtr> limits; PropertyDict patterns = properties->getPropertiesForPrefix("Analyzer."+type_+".Patterns"); for (PropertyDict::iterator pattern = patterns.begin(); pattern != patterns.end(); ++pattern) { vector<string> strings; boost::algorithm::split(strings, pattern->second, boost::algorithm::is_any_of(" ")); limits[strings.at(0)]=new Limiter(lexical_cast<int>(strings.at(1)),lexical_cast<int>(strings.at(2)),lexical_cast<int>(strings.at(3)),lexical_cast<int>(strings.at(4))); } { RWRecMutex::WLock lock(mutex_); limits_ = limits; default_ = defaulter; } MCE_DEBUG("Analyzer::reload done"); }
void Ice::PluginManagerI::loadPlugins(int& argc, const char* argv[]) { assert(_communicator); StringSeq cmdArgs = argsToStringSeq(argc, argv); const string prefix = "Ice.Plugin."; PropertiesPtr properties = _communicator->getProperties(); PropertyDict plugins = properties->getPropertiesForPrefix(prefix); // // First, load static plugin factories which were setup to load on // communicator initialization. If a matching plugin property is // set, we load the plugin with the plugin specification. The // entryPoint will be ignored but the rest of the plugin // specification might be used. // if(loadOnInitialization) { for(vector<string>::const_iterator p = loadOnInitialization->begin(); p != loadOnInitialization->end(); ++p) { string property = prefix + *p; PropertyDict::iterator r = plugins.find(property + ".cpp"); if(r == plugins.end()) { r = plugins.find(property); } else { plugins.erase(property); } if(r != plugins.end()) { loadPlugin(*p, r->second, cmdArgs); plugins.erase(r); } else { loadPlugin(*p, "", cmdArgs); } } } // // Next, load and initialize the plug-ins defined in the property // set with the prefix "Ice.Plugin.". These properties should have // the following format: // // Ice.Plugin.name[.<language>]=entry_point [args] // // If the Ice.PluginLoadOrder property is defined, load the // specified plug-ins in the specified order, then load any // remaining plug-ins. // StringSeq loadOrder = properties->getPropertyAsList("Ice.PluginLoadOrder"); for(StringSeq::const_iterator p = loadOrder.begin(); p != loadOrder.end(); ++p) { string name = *p; if(findPlugin(name)) { PluginInitializationException ex(__FILE__, __LINE__); ex.reason = "plug-in `" + name + "' already loaded"; throw ex; } string property = prefix + name; PropertyDict::iterator r = plugins.find(property + ".cpp"); if(r == plugins.end()) { r = plugins.find(property); } else { plugins.erase(property); } if(r != plugins.end()) { loadPlugin(name, r->second, cmdArgs); plugins.erase(r); } else { PluginInitializationException ex(__FILE__, __LINE__); ex.reason = "plug-in `" + name + "' not defined"; throw ex; } } // // Load any remaining plug-ins that weren't specified in PluginLoadOrder. // while(!plugins.empty()) { PropertyDict::iterator p = plugins.begin(); string name = p->first.substr(prefix.size()); size_t dotPos = name.find_last_of('.'); if(dotPos != string::npos) { string suffix = name.substr(dotPos + 1); if(suffix == "java" || suffix == "clr") { // // Ignored // plugins.erase(p); } else if(suffix == "cpp") { name = name.substr(0, dotPos); loadPlugin(name, p->second, cmdArgs); plugins.erase(p); plugins.erase(prefix + name); } else { // // Name is just a regular name that happens to contain a dot // dotPos = string::npos; } } if(dotPos == string::npos) { // // Is there a .cpp entry? // PropertyDict::iterator q = plugins.find(prefix + name + ".cpp"); if(q != plugins.end()) { plugins.erase(p); p = q; } loadPlugin(name, p->second, cmdArgs); plugins.erase(p); } } stringSeqToArgs(cmdArgs, argc, argv); }
void MetricsAdminI::updateViews() { set<MetricsMapFactoryPtr> updatedMaps; { Lock sync(*this); const string viewsPrefix = "IceMX.Metrics."; PropertyDict viewsProps = _properties->getPropertiesForPrefix(viewsPrefix); map<string, MetricsViewIPtr> views; _disabledViews.clear(); for(PropertyDict::const_iterator p = viewsProps.begin(); p != viewsProps.end(); ++p) { string viewName = p->first.substr(viewsPrefix.size()); string::size_type dotPos = viewName.find('.'); if(dotPos != string::npos) { viewName = viewName.substr(0, dotPos); } if(views.find(viewName) != views.end() || _disabledViews.find(viewName) != _disabledViews.end()) { continue; // View already configured. } validateProperties(viewsPrefix + viewName + ".", _properties); if(_properties->getPropertyAsIntWithDefault(viewsPrefix + viewName + ".Disabled", 0) > 0) { _disabledViews.insert(viewName); continue; // The view is disabled } // // Create the view or update it. // map<string, MetricsViewIPtr>::const_iterator q = _views.find(viewName); if(q == _views.end()) { q = views.insert(map<string, MetricsViewIPtr>::value_type(viewName, new MetricsViewI(viewName))).first; } else { q = views.insert(make_pair(viewName, q->second)).first; } for(map<string, MetricsMapFactoryPtr>::const_iterator p = _factories.begin(); p != _factories.end(); ++p) { if(q->second->addOrUpdateMap(_properties, p->first, p->second, _logger)) { updatedMaps.insert(p->second); } } } _views.swap(views); // // Go through removed views to collect maps to update. // for(map<string, MetricsViewIPtr>::const_iterator p = views.begin(); p != views.end(); ++p) { if(_views.find(p->first) == _views.end()) { vector<string> maps = p->second->getMaps(); for(vector<string>::const_iterator q = maps.begin(); q != maps.end(); ++q) { updatedMaps.insert(_factories[*q]); } p->second->destroy(); } } } // // Call the updaters to update the maps. // for(set<MetricsMapFactoryPtr>::const_iterator p = updatedMaps.begin(); p != updatedMaps.end(); ++p) { (*p)->update(); } }
bool IceBox::IceBoxService::start(int argc, char* argv[], int& status) { // Run through the command line arguments removing all the service // properties. vector<string> args = Ice::argsToStringSeq(argc, argv); PropertiesPtr properties = communicator()->getProperties(); const string prefix = "IceBox.Service."; PropertyDict services = properties->getPropertiesForPrefix(prefix); for(PropertyDict::const_iterator p = services.begin(); p != services.end(); ++p) { string name = p->first.substr(prefix.size()); StringSeq::iterator q = args.begin(); while(q != args.end()) { if(q->find("--" + name + ".") == 0) { q = args.erase(q); continue; } ++q; } } IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("v", "version"); try { args = opts.parse(args); } catch(const IceUtilInternal::BadOptException& e) { error(e.reason); usage(argv[0]); return false; } if(opts.isSet("help")) { usage(argv[0]); status = EXIT_SUCCESS; return false; } if(opts.isSet("version")) { print(ICE_STRING_VERSION); status = EXIT_SUCCESS; return false; } if(!args.empty()) { usage(argv[0]); return false; } _serviceManager = new ServiceManagerI(communicator(), argc, argv); return _serviceManager->start(); }
void ServiceI::validateProperties(const string& name, const PropertiesPtr& properties, const LoggerPtr& logger) { static const string suffixes[] = { "ReplicatedTopicManagerEndpoints", "ReplicatedPublishEndpoints", "Nodes.*", "Transient", "NodeId", "Flush.Timeout", "InstanceName", "Election.MasterTimeout", "Election.ElectionTimeout", "Election.ResponseTimeout", "Publish.AdapterId", "Publish.Endpoints", "Publish.Locator", "Publish.PublishedEndpoints", "Publish.RegisterProcess", "Publish.ReplicaGroupId", "Publish.Router", "Publish.ThreadPool.Size", "Publish.ThreadPool.SizeMax", "Publish.ThreadPool.SizeWarn", "Publish.ThreadPool.StackSize", "Node.AdapterId", "Node.Endpoints", "Node.Locator", "Node.PublishedEndpoints", "Node.RegisterProcess", "Node.ReplicaGroupId", "Node.Router", "Node.ThreadPool.Size", "Node.ThreadPool.SizeMax", "Node.ThreadPool.SizeWarn", "Node.ThreadPool.StackSize", "TopicManager.AdapterId", "TopicManager.Endpoints", "TopicManager.Locator", "TopicManager.Proxy", "TopicManager.Proxy.EndpointSelection", "TopicManager.Proxy.ConnectionCached", "TopicManager.Proxy.PreferSecure", "TopicManager.Proxy.LocatorCacheTimeout", "TopicManager.Proxy.Locator", "TopicManager.Proxy.Router", "TopicManager.Proxy.CollocationOptimization", "TopicManager.PublishedEndpoints", "TopicManager.RegisterProcess", "TopicManager.ReplicaGroupId", "TopicManager.Router", "TopicManager.ThreadPool.Size", "TopicManager.ThreadPool.SizeMax", "TopicManager.ThreadPool.SizeWarn", "TopicManager.ThreadPool.StackSize", "Trace.Election", "Trace.Replication", "Trace.Subscriber", "Trace.Topic", "Trace.TopicManager", "Send.Timeout", "Discard.Interval", "SQL.DatabaseType", "SQL.EncodingVersion", "SQL.HostName", "SQL.Port", "SQL.DatabaseName", "SQL.UserName", "SQL.Password" }; vector<string> unknownProps; string prefix = name + "."; PropertyDict props = properties->getPropertiesForPrefix(prefix); for(PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p) { bool valid = false; for(unsigned int i = 0; i < sizeof(suffixes)/sizeof(*suffixes); ++i) { string prop = prefix + suffixes[i]; if(IceUtilInternal::match(p->first, prop)) { valid = true; break; } } if(!valid) { unknownProps.push_back(p->first); } } if(!unknownProps.empty()) { Warning out(logger); out << "found unknown properties for IceStorm service '" << name << "':"; for(vector<string>::const_iterator p = unknownProps.begin(); p != unknownProps.end(); ++p) { out << "\n " << *p; } } }
RoutableReferencePtr IceInternal::ReferenceFactory::create(const Identity& ident, const string& facet, Reference::Mode mode, bool secure, const Ice::ProtocolVersion& protocol, const Ice::EncodingVersion& encoding, const vector<EndpointIPtr>& endpoints, const string& adapterId, const string& propertyPrefix) { DefaultsAndOverridesPtr defaultsAndOverrides = _instance->defaultsAndOverrides(); // // Default local proxy options. // LocatorInfoPtr locatorInfo; if(_defaultLocator) { if(_defaultLocator->ice_getEncodingVersion() != encoding) { locatorInfo = _instance->locatorManager()->get(_defaultLocator->ice_encodingVersion(encoding)); } else { locatorInfo = _instance->locatorManager()->get(_defaultLocator); } } RouterInfoPtr routerInfo = _instance->routerManager()->get(_defaultRouter); bool collocationOptimized = defaultsAndOverrides->defaultCollocationOptimization; bool cacheConnection = true; bool preferSecure = defaultsAndOverrides->defaultPreferSecure; Ice::EndpointSelectionType endpointSelection = defaultsAndOverrides->defaultEndpointSelection; int locatorCacheTimeout = defaultsAndOverrides->defaultLocatorCacheTimeout; int invocationTimeout = defaultsAndOverrides->defaultInvocationTimeout; Ice::Context ctx; // // Override the defaults with the proxy properties if a property prefix is defined. // if(!propertyPrefix.empty()) { PropertiesPtr properties = _instance->initializationData().properties; if(properties->getPropertyAsIntWithDefault("Ice.Warn.UnknownProperties", 1) > 0) { checkForUnknownProperties(propertyPrefix); } string property; property = propertyPrefix + ".Locator"; LocatorPrx locator = LocatorPrx::uncheckedCast(_communicator->propertyToProxy(property)); if(locator) { if(locator->ice_getEncodingVersion() != encoding) { locatorInfo = _instance->locatorManager()->get(locator->ice_encodingVersion(encoding)); } else { locatorInfo = _instance->locatorManager()->get(locator); } } property = propertyPrefix + ".Router"; RouterPrx router = RouterPrx::uncheckedCast(_communicator->propertyToProxy(property)); if(router) { if(propertyPrefix.size() > 7 && propertyPrefix.substr(propertyPrefix.size() - 7, 7) == ".Router") { Warning out(_instance->initializationData().logger); out << "`" << property << "=" << properties->getProperty(property) << "': cannot set a router on a router; setting ignored"; } else { routerInfo = _instance->routerManager()->get(router); } } property = propertyPrefix + ".CollocationOptimized"; collocationOptimized = properties->getPropertyAsIntWithDefault(property, collocationOptimized) > 0; property = propertyPrefix + ".ConnectionCached"; cacheConnection = properties->getPropertyAsIntWithDefault(property, cacheConnection) > 0; property = propertyPrefix + ".PreferSecure"; preferSecure = properties->getPropertyAsIntWithDefault(property, preferSecure) > 0; property = propertyPrefix + ".EndpointSelection"; if(!properties->getProperty(property).empty()) { string type = properties->getProperty(property); if(type == "Random") { endpointSelection = Random; } else if(type == "Ordered") { endpointSelection = Ordered; } else { EndpointSelectionTypeParseException ex(__FILE__, __LINE__); ex.str = "illegal value `" + type + "'; expected `Random' or `Ordered'"; throw ex; } } property = propertyPrefix + ".LocatorCacheTimeout"; string value = properties->getProperty(property); if(!value.empty()) { locatorCacheTimeout = properties->getPropertyAsIntWithDefault(property, locatorCacheTimeout); if(locatorCacheTimeout < -1) { locatorCacheTimeout = -1; Warning out(_instance->initializationData().logger); out << "invalid value for " << property << "`" << properties->getProperty(property) << "'" << ": defaulting to -1"; } } property = propertyPrefix + ".InvocationTimeout"; value = properties->getProperty(property); if(!value.empty()) { invocationTimeout = properties->getPropertyAsIntWithDefault(property, invocationTimeout); if(invocationTimeout < 1 && invocationTimeout != -1) { invocationTimeout = -1; Warning out(_instance->initializationData().logger); out << "invalid value for " << property << "`" << properties->getProperty(property) << "'" << ": defaulting to -1"; } } property = propertyPrefix + ".Context."; PropertyDict contexts = properties->getPropertiesForPrefix(property); for(PropertyDict::const_iterator p = contexts.begin(); p != contexts.end(); ++p) { ctx.insert(make_pair(p->first.substr(property.length()), p->second)); } } // // Create new reference // return new RoutableReference(_instance, _communicator, ident, facet, mode, secure, protocol, encoding, endpoints, adapterId, locatorInfo, routerInfo, collocationOptimized, cacheConnection, preferSecure, endpointSelection, locatorCacheTimeout, invocationTimeout, ctx); }
bool MetricsViewI::addOrUpdateMap(const PropertiesPtr& properties, const string& mapName, const MetricsMapFactoryPtr& factory, const ::Ice::LoggerPtr& logger) { const string viewPrefix = "IceMX.Metrics." + _name + "."; const string mapsPrefix = viewPrefix + "Map."; PropertyDict mapsProps = properties->getPropertiesForPrefix(mapsPrefix); string mapPrefix; PropertyDict mapProps; if(!mapsProps.empty()) { mapPrefix = mapsPrefix + mapName + "."; mapProps = properties->getPropertiesForPrefix(mapPrefix); if(mapProps.empty()) { // This map isn't configured for this view. map<string, MetricsMapIPtr>::iterator q = _maps.find(mapName); if(q != _maps.end()) { q->second->destroy(); _maps.erase(q); return true; } return false; } } else { mapPrefix = viewPrefix; mapProps = properties->getPropertiesForPrefix(mapPrefix); } if(properties->getPropertyAsInt(mapPrefix + "Disabled") > 0) { // This map is disabled for this view. map<string, MetricsMapIPtr>::iterator q = _maps.find(mapName); if(q != _maps.end()) { q->second->destroy(); _maps.erase(q); return true; } return false; } map<string, MetricsMapIPtr>::iterator q = _maps.find(mapName); if(q != _maps.end() && q->second->getProperties() == mapProps) { return false; // The map configuration didn't change, no need to re-create. } if(q != _maps.end()) { // Destroy the previous map q->second->destroy(); _maps.erase(q); } try { _maps.insert(make_pair(mapName, factory->create(mapPrefix, properties))); } catch(const std::exception& ex) { ::Ice::Warning warn(logger); warn << "unexpected exception while creating metrics map:\n" << ex; } catch(const string& msg) { ::Ice::Warning warn(logger); warn << msg; } return true; }
bool Ice::ObjectAdapterI::filterProperties(StringSeq& unknownProps) { static const string suffixes[] = { "ACM", "ACM.Close", "ACM.Heartbeat", "ACM.Timeout", "AdapterId", "Endpoints", "Locator", "Locator.EncodingVersion", "Locator.EndpointSelection", "Locator.ConnectionCached", "Locator.PreferSecure", "Locator.CollocationOptimized", "Locator.Router", "MessageSizeMax", "PublishedEndpoints", "ReplicaGroupId", "Router", "Router.EncodingVersion", "Router.EndpointSelection", "Router.ConnectionCached", "Router.PreferSecure", "Router.CollocationOptimized", "Router.Locator", "Router.Locator.EndpointSelection", "Router.Locator.ConnectionCached", "Router.Locator.PreferSecure", "Router.Locator.CollocationOptimized", "Router.Locator.LocatorCacheTimeout", "Router.Locator.InvocationTimeout", "Router.LocatorCacheTimeout", "Router.InvocationTimeout", "ProxyOptions", "ThreadPool.Size", "ThreadPool.SizeMax", "ThreadPool.SizeWarn", "ThreadPool.StackSize", "ThreadPool.Serialize", "ThreadPool.ThreadPriority" }; // // Do not create unknown properties list if Ice prefix, ie Ice, Glacier2, etc // bool addUnknown = true; string prefix = _name + "."; for(const char** i = IceInternal::PropertyNames::clPropNames; *i != 0; ++i) { string icePrefix = string(*i) + "."; if(prefix.find(icePrefix) == 0) { addUnknown = false; break; } } bool noProps = true; PropertyDict props = _instance->initializationData().properties->getPropertiesForPrefix(prefix); for(PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p) { bool valid = false; for(unsigned int i = 0; i < sizeof(suffixes)/sizeof(*suffixes); ++i) { string prop = prefix + suffixes[i]; if(p->first == prop) { noProps = false; valid = true; break; } } if(!valid && addUnknown) { unknownProps.push_back(p->first); } } return noProps; }
void PropertiesAdminI::setProperties_async(const AMD_PropertiesAdmin_setPropertiesPtr& cb, const PropertyDict& props, const Current&) { Lock sync(*this); PropertyDict old = _properties->getPropertiesForPrefix(""); PropertyDict::const_iterator p; const int traceLevel = _properties->getPropertyAsInt("Ice.Trace.Admin.Properties"); // // Compute the difference between the new property set and the existing property set: // // 1) Any properties in the new set that were not defined in the existing set. // // 2) Any properties that appear in both sets but with different values. // // 3) Any properties not present in the new set but present in the existing set. // In other words, the property has been removed. // PropertyDict added, changed, removed; for(p = props.begin(); p != props.end(); ++p) { PropertyDict::iterator q = old.find(p->first); if(q == old.end()) { if(!p->second.empty()) { // // This property is new. // added.insert(*p); } } else { if(p->second != q->second) { if(p->second.empty()) { // // This property was removed. // removed.insert(*p); } else { // // This property has changed. // changed.insert(*p); } } } } if(traceLevel > 0 && (!added.empty() || !changed.empty() || !removed.empty())) { Trace out(_logger, traceCategory); out << "Summary of property changes"; if(!added.empty()) { out << "\nNew properties:"; for(p = added.begin(); p != added.end(); ++p) { out << "\n " << p->first; if(traceLevel > 1) { out << " = " << p->second; } } } if(!changed.empty()) { out << "\nChanged properties:"; for(p = changed.begin(); p != changed.end(); ++p) { out << "\n " << p->first; if(traceLevel > 1) { out << " = " << p->second << " (old value = " << _properties->getProperty(p->first) << ")"; } } } if(!removed.empty()) { out << "\nRemoved properties:"; for(p = removed.begin(); p != removed.end(); ++p) { out << "\n " << p->first; } } } // // Update the property set. // for(p = added.begin(); p != added.end(); ++p) { _properties->setProperty(p->first, p->second); } for(p = changed.begin(); p != changed.end(); ++p) { _properties->setProperty(p->first, p->second); } for(p = removed.begin(); p != removed.end(); ++p) { _properties->setProperty(p->first, ""); } // // Send the response now so that we do not block the client during // the call to the update callback. // cb->ice_response(); // // Copy the callbacks to allow callbacks to update the callbacks. // vector<PropertiesAdminUpdateCallbackPtr> callbacks = _updateCallbacks; if(!callbacks.empty()) { PropertyDict changes = added; changes.insert(changed.begin(), changed.end()); changes.insert(removed.begin(), removed.end()); for(vector<PropertiesAdminUpdateCallbackPtr>::const_iterator p = callbacks.begin(); p != callbacks.end(); ++p) { try { (*p)->updated(changes); } catch(...) { // Ignore. } } } }
int AttackClient::run(int, char**) { ObjectPrx routerBase = communicator()->stringToProxy("Glacier2/router:" + getTestEndpoint(communicator(), 10)); Glacier2::RouterPrx router = Glacier2::RouterPrx::checkedCast(routerBase); test(router); communicator()->setDefaultRouter(router); PropertyDict::const_iterator p; PropertyDict badProxies = communicator()->getProperties()->getPropertiesForPrefix("Reject.Proxy."); for(p = badProxies.begin(); p != badProxies.end(); ++p) { try { Glacier2::SessionPrx session = router->createSession("userid", "abc123"); } catch(const Glacier2::CannotCreateSessionException&) { test("Unable to create new session" == 0); } BackendPrx backend = BackendPrx::uncheckedCast(communicator()->stringToProxy(p->second)); try { backend->ice_ping(); cerr << "Test failed on : " << p->second << endl; test("Expected exception" == 0); } catch(const ConnectionLostException&) { // // This is ok. // } catch(const CloseConnectionException&) { // // This is also ok. // } catch(const ObjectNotExistException&) { // // This is ok for non-address filters. // try { router->destroySession(); } catch(...) { } } catch(const LocalException& e) { cerr << e << endl; test("Unexpected local exception" == 0); } } PropertyDict goodProxies = communicator()->getProperties()->getPropertiesForPrefix("Accept.Proxy."); for(p = goodProxies.begin(); p != goodProxies.end(); ++p) { try { Glacier2::SessionPrx session = router->createSession("userid", "abc123"); } catch(const Glacier2::CannotCreateSessionException&) { test("Unable to create new session" == 0); } BackendPrx backend = BackendPrx::uncheckedCast(communicator()->stringToProxy(p->second)); try { backend->ice_ping(); } catch(const LocalException& ex) { cerr << p->second << endl; cerr << ex << endl; test("Unexpected local exception" == 0); } try { router->destroySession(); } catch(const LocalException&) { // // Expected. // } } // // Stop using router and communicate with backend and router directly // to shut things down. // communicator()->setDefaultRouter(0); try { BackendPrx backend = BackendPrx::checkedCast(communicator()->stringToProxy("dummy:tcp -p 12010")); backend->shutdown(); } catch(const Ice::LocalException&) { test(false); } ObjectPrx processBase = communicator()->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(communicator(), 11)); Ice::ProcessPrx process = Ice::ProcessPrx::checkedCast(processBase); test(process); process->shutdown(); try { process->ice_ping(); test(false); } catch(const Ice::LocalException&) { cout << "ok" << endl; } return EXIT_SUCCESS; }
bool IceBox::ServiceManagerI::start() { try { ServiceManagerPtr obj = this; PropertiesPtr 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. // ObjectAdapterPtr adapter; if(properties->getProperty("IceBox.ServiceManager.Endpoints") != "") { adapter = _communicator->createObjectAdapter("IceBox.ServiceManager"); Identity identity; identity.category = properties->getPropertyWithDefault("IceBox.InstanceName", "IceBox"); identity.name = "ServiceManager"; adapter->add(obj, identity); } // // Parse the property set with the prefix "IceBox.Service.". These // properties should have the following format: // // IceBox.Service.Foo=entry_point [args] // // We parse the service properties specified in IceBox.LoadOrder // first, then the ones from remaining services. // const string prefix = "IceBox.Service."; PropertyDict services = properties->getPropertiesForPrefix(prefix); PropertyDict::iterator p; StringSeq loadOrder = properties->getPropertyAsList("IceBox.LoadOrder"); vector<StartServiceInfo> servicesInfo; for(StringSeq::const_iterator q = loadOrder.begin(); q != loadOrder.end(); ++q) { p = services.find(prefix + *q); if(p == services.end()) { FailureException ex(__FILE__, __LINE__); ex.reason = "ServiceManager: no service definition for `" + *q + "'"; throw ex; } servicesInfo.push_back(StartServiceInfo(*q, p->second, _argv)); services.erase(p); } for(p = services.begin(); p != services.end(); ++p) { servicesInfo.push_back(StartServiceInfo(p->first.substr(prefix.size()), p->second, _argv)); } // // Check if some services are using the shared communicator in which // case we create the shared communicator now with a property set which // is the union of all the service properties (services which are using // the shared communicator). // PropertyDict sharedCommunicatorServices = properties->getPropertiesForPrefix("IceBox.UseSharedCommunicator."); if(!sharedCommunicatorServices.empty()) { InitializationData initData; initData.properties = createServiceProperties("SharedCommunicator"); for(vector<StartServiceInfo>::iterator q = servicesInfo.begin(); q != servicesInfo.end(); ++q) { if(properties->getPropertyAsInt("IceBox.UseSharedCommunicator." + q->name) <= 0) { continue; } // // Load the service properties using the shared communicator properties as // the default properties. // PropertiesPtr svcProperties = createProperties(q->args, initData.properties); // // Erase properties from the shared communicator which don't exist in the // service properties (which include the shared communicator properties // overriden by the service properties). // PropertyDict allProps = initData.properties->getPropertiesForPrefix(""); for(PropertyDict::iterator p = allProps.begin(); p != allProps.end(); ++p) { if(svcProperties->getProperty(p->first) == "") { initData.properties->setProperty(p->first, ""); } } // // Add the service properties to the shared communicator properties. // PropertyDict props = svcProperties->getPropertiesForPrefix(""); for(PropertyDict::const_iterator r = props.begin(); r != props.end(); ++r) { initData.properties->setProperty(r->first, r->second); } // // Parse <service>.* command line options (the Ice command line options // were parsed by the createProperties above) // q->args = initData.properties->parseCommandLineOptions(q->name, q->args); } _sharedCommunicator = initialize(initData); } // // Start the services. // for(vector<StartServiceInfo>::const_iterator r = servicesInfo.begin(); r != servicesInfo.end(); ++r) { start(r->name, r->entryPoint, r->args); } // // We may want to notify external scripts that the services // have started. This is done by defining the property: // // IceBox.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.empty()) { cout << bundleName << " ready" << endl; } // // Register "this" as a facet to the Admin object, and then create // Admin object // try { _communicator->addAdminFacet(this, "IceBox.ServiceManager"); // // Add a Properties facet for each service // for(vector<ServiceInfo>::iterator r = _services.begin(); r != _services.end(); ++r) { const ServiceInfo& info = *r; CommunicatorPtr communicator = info.communicator != 0 ? info.communicator : _sharedCommunicator; _communicator->addAdminFacet(new PropertiesAdminI(communicator->getProperties()), "IceBox.Service." + info.name + ".Properties"); } _communicator->getAdmin(); } catch(const ObjectAdapterDeactivatedException&) { // // Expected if the communicator has been shutdown. // } if(adapter) { try { adapter->activate(); } catch(const ObjectAdapterDeactivatedException&) { // // Expected if the communicator has been shutdown. // } } } catch(const FailureException& ex) { Error out(_logger); out << ex.reason; stopAll(); return false; } catch(const Exception& ex) { Error out(_logger); out << "ServiceManager: " << ex; stopAll(); return false; } return true; }
void BpDocument::composeFireCharacteristicsDiagram( void ) { // Surface Module must be active and using fuel model inputs PropertyDict *prop = m_eqTree->m_propDict; if ( ! prop->boolean( "surfaceModuleActive" ) || ! prop->boolean( "surfaceCalcFireCharacteristicsDiagram" ) ) { return; } // Graph fonts. QFont textFont( property()->string( "graphTextFontFamily" ), property()->integer( "graphTextFontSize" ) ); QColor textColor( property()->color( "graphTextFontColor" ) ); QPen textPen( textColor ); QFont subTitleFont( property()->string( "graphSubtitleFontFamily" ), property()->integer( "graphSubtitleFontSize" ) ); QColor subTitleColor( property()->color( "graphSubtitleFontColor" ) ); // Open the result file QString resultFile = m_eqTree->m_resultFile; FILE *fptr = 0; if ( ! ( fptr = fopen( resultFile.latin1(), "r" ) ) ) // This code block should never be executed! { QString text(""); translate( text, "BpDocument:FireCharacteristicsDiagram:NoLogOpen", resultFile ); error( text ); return; } // Allocate ros and hpua data arrays int rows = tableRows(); int cols = tableCols(); int cells = rows * cols; double *hpua = new double[ cells ]; checkmem( __FILE__, __LINE__, hpua, "double hpua", cells ); double *ros = new double[ cells ]; checkmem( __FILE__, __LINE__, ros, "double ros", cells ); // Set the variable names we're looking for const char* hpuaName = "vSurfaceFireHeatPerUnitArea"; const char* rosName = "vSurfaceFireSpreadAtHead"; if ( prop->boolean( "surfaceConfSpreadDirInput" ) ) { rosName = "vSurfaceFireSpreadAtVector"; } // Read and store the ros and hpua values char buffer[1024], varName[128], varUnits[128]; int row, col, cell; double value; double rosMax = 0.0; double hpuaMax = 0.0; while ( fgets( buffer, sizeof(buffer), fptr ) ) { if ( strncmp( buffer, "CELL", 4 ) == 0 ) { if ( strstr( buffer, hpuaName ) ) { sscanf( buffer, "CELL %d %d %s cont %lf %s", &row, &col, varName, &value, varUnits ); cell = ( col - 1 ) + ( cols * ( row - 1) ); if ( ( hpua[ cell ] = value ) > hpuaMax ) { hpuaMax = value; } } else if ( strstr( buffer, rosName ) ) { sscanf( buffer, "CELL %d %d %s cont %lf %s", &row, &col, varName, &value, varUnits ); cell = ( col - 1 ) + ( cols * ( row - 1) ); if ( ( ros[ cell ] = value ) > rosMax ) { rosMax = value; } } } } fclose( fptr ); // Get variable pointers EqVar *hpuaVar = m_eqTree->m_varDict->find( "vSurfaceFireHeatPerUnitArea" ); EqVar *rosVar = m_eqTree->m_varDict->find( "vSurfaceFireSpreadAtHead" ); EqVar *fliVar = m_eqTree->m_varDict->find( "vSurfaceFireLineIntAtHead" ); EqVar *flVar = m_eqTree->m_varDict->find( "vSurfaceFireFlameLengAtHead" ); // Conversion factor double flFactor, fliFactor, rosFactor, hpuaFactor, offset; appSiUnits()->conversionFactorOffset( flVar->m_nativeUnits, flVar->m_displayUnits, &flFactor, &offset ); appSiUnits()->conversionFactorOffset( fliVar->m_nativeUnits, fliVar->m_displayUnits, &fliFactor, &offset ); appSiUnits()->conversionFactorOffset( hpuaVar->m_nativeUnits, hpuaVar->m_displayUnits, &hpuaFactor, &offset ); appSiUnits()->conversionFactorOffset( rosVar->m_nativeUnits, rosVar->m_displayUnits, &rosFactor, &offset ); // Determine which of four different chart scales to use static const int Scales = 4; static double RosScale[Scales] = { 100., 200., 400., 800. }; // ft/min static double HpuaScale[Scales] = { 2000., 4000., 8000., 16000. }; // Btu/ft2 double rosScale = 0.; // Max y-axis ros double hpuaScale = 0.; // Max x-axis hpua int scale; for ( scale=0; scale<Scales; scale++ ) { if ( rosMax < ( rosScale = RosScale[ scale ] ) ) { break; } } for ( scale=0; scale<Scales; scale++ ) { if ( hpuaMax < ( hpuaScale = HpuaScale[scale] ) ) { break; } } // Set axis maximums to appropriate predefined scale in display units rosMax = rosFactor * rosScale; hpuaMax = hpuaFactor * hpuaScale; double ratio = rosMax / hpuaMax; // Create the graph Graph graph; GraphLine *graphLine; GraphMarker *graphMarker; static const int Points = 100; double l_x[Points]; double l_y[Points]; // Draw the four standard hauling chart fli-fl levels static const int Lines = 4; static const double Fli[Lines] = { 100., 500., 1000., 2000. }; // Btu/ft/s static const double Fl[Lines] = { 4., 8., 11., 15. }; // ft // Create the hauling chart lines // Put Fireline Int label 65% of the way along the HPUA axis (display units) double xPosFli = 0.65 * hpuaMax; // Put Flame Length label 85% of the way along the HPUA axis (display units) double xPosFl = 0.85 * hpuaMax; // Fireline Int and Flame Length label Y positions (display units) double yPosFl[Lines], yPosFli[Lines]; // Icon locations (in display units) double xIcon[Lines+1], yIcon[Lines+1]; double diff, minDiff; QString label; QPen redPen( "red", 1 ); QColor blackColor( "black" ); int alignCenter = Qt::AlignHCenter | Qt::AlignVCenter; // Fireline intensity - flame length curves int line, point; for ( line = 0; line < Lines; line++ ) { minDiff = 999999999.; for ( point = 0; point < Points; point++ ) { // Hpua value in native units (Btu/ft2) l_x[point] = ( (point+1) * hpuaScale ) / (double) Points; // Ros value in native units (ft/min) l_y[point] = 60. * Fli[line] / l_x[point]; // Convert to display units l_x[point] *= hpuaFactor; l_y[point] *= rosFactor; // Check for curve inflection point (for icon placement) if ( ( diff = fabs( l_y[point]/l_x[point] - ratio ) ) < minDiff ) { minDiff = diff; xIcon[line+1] = l_x[point]; yIcon[line+1] = l_y[point]; } } // Create a graph line (with its own copy of the data). graphLine = graph.addGraphLine( Points, l_x, l_y, redPen ); // Fireline intensity label label = QString( "%1" ).arg( ( Fli[line] * fliFactor ), 0, 'f', 0 ); yPosFli[line] = rosFactor * ( 60. * Fli[line] / ( xPosFli / hpuaFactor ) ); graph.addGraphMarker( xPosFli, yPosFli[line], label, textFont, blackColor, alignCenter ); // Flame length label label = QString( "%1" ).arg( ( Fl[line] * flFactor ), 0, 'f', 0 ); yPosFl[line] = rosFactor * ( 60. * Fli[line] / ( xPosFl / hpuaFactor ) ); graph.addGraphMarker( xPosFl, yPosFl[line], label, textFont, blackColor, alignCenter ); } // Next line // Fireline intensity label and units translate( label, "BpDocument:FireCharacteristicsDiagram:FLI" ); graph.addGraphMarker( xPosFli, ( yPosFli[Lines-1] + 0.10 * rosMax ), label, textFont, blackColor, alignCenter ); graph.addGraphMarker( xPosFli, ( yPosFli[Lines-1] + 0.05 * rosMax ), fliVar->m_displayUnits, textFont, blackColor, alignCenter ); // Flame length label and units translate( label, "BpDocument:FireCharacteristicsDiagram:FL" ); graph.addGraphMarker( xPosFl, ( yPosFl[Lines-1] + 0.10 * rosMax ), label, textFont, blackColor, alignCenter ); graph.addGraphMarker( xPosFl, ( yPosFl[Lines-1] + 0.05 * rosMax ), flVar->m_displayUnits, textFont, blackColor, alignCenter ); // Add icons QPixmap pixmap[Lines]; pixmap[0] = QPixmap( fireman_xpm ); pixmap[1] = QPixmap( dozer_xpm ); pixmap[2] = QPixmap( torchtree_xpm ); pixmap[3] = QPixmap( mtnfire_xpm ); xIcon[0] = yIcon[0] = 0.0; for ( line=0; line<Lines; line++ ) { graphMarker = graph.addGraphMarker( xIcon[line] + ( 0.5 * ( xIcon[line+1] - xIcon[line] ) ), yIcon[line] + ( 0.5 * ( yIcon[line+1] - yIcon[line] ) ), "", textFont, blackColor, alignCenter ); graphMarker->setGraphMarkerPixmap( pixmap[line] ); } // Finally, add a marker for each output result QColor bluePen( "blue" ); for ( cell=0; cell<cells; cell++ ) { //fprintf( stderr, "%02d: %3.2f %3.2f\n", i, hpua[i], ros[i] ); graph.addGraphMarker( hpua[cell], ros[cell], QString( "%1" ).arg( cell + 1 ), textFont, bluePen, alignCenter ); } // Compose the graph EqVar *zVar = 0; GraphAxleParms xParms( 0.0, hpuaMax, 11 ); GraphAxleParms yParms( 0.0, rosMax, 11 ); composeGraphBasics( &graph, true, hpuaVar, rosVar, zVar, Lines, &xParms, &yParms ); // Create a separate page for this graph. translate( label, "BpDocument:FireCharacteristicsDiagram:Caption" ); graph.setSubTitle( label, subTitleFont, subTitleColor ); startNewPage( label, TocHaulChart ); // This is how we save the graph and its composer. m_composer->graph( graph, m_pageSize->m_marginLeft + m_pageSize->m_bodyWd * property()->real( "graphXOffset" ), m_pageSize->m_marginTop + m_pageSize->m_bodyHt * property()->real( "graphYOffset" ), m_pageSize->m_bodyWd * property()->real( "graphScaleWidth" ), m_pageSize->m_bodyHt * property()->real( "graphScaleHeight" ) ); // Be polite and stop the composer. m_composer->end(); delete[] ros; ros = 0; delete[] hpua; hpua = 0; return; }