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];
}
}
}
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");
}
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;
}
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;
}
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);
}
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
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;
}
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();
}
}