Ice::ObjectPrx
WellKnownObjectsManager::getWellKnownObjectReplicatedProxy(const Ice::Identity& id, const string& endpt)
{
try
{
Ice::ObjectPrx proxy = _database->getObjectProxy(id);
Ice::EndpointSeq registryEndpoints = getEndpoints(endpt)->ice_getEndpoints();
//
// Re-order the endpoints to return first the endpoint for this
// registry replica.
//
Ice::EndpointSeq endpoints = proxy->ice_getEndpoints();
Ice::EndpointSeq newEndpoints = registryEndpoints;
for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
{
if(find(registryEndpoints.begin(), registryEndpoints.end(), *p) == registryEndpoints.end())
{
newEndpoints.push_back(*p);
}
}
return proxy->ice_endpoints(newEndpoints);
}
catch(const ObjectNotRegisteredException&)
{
//
// If for some reasons the object isn't registered, we compute
// the endpoints with the replica cache. For slaves, this will
// however only return the slave endpoints.
//
return _database->getReplicaCache().getEndpoints(endpt, getEndpoints(endpt))->ice_identity(id);
}
}
void
AdapterRequest::finished(const Ice::ObjectPrx& proxy)
{
if(proxy || _proxies.empty())
{
RequestT<std::string, Ice::AMD_Locator_findAdapterByIdPtr>::finished(proxy);
return;
}
else if(_proxies.size() == 1)
{
RequestT<std::string, Ice::AMD_Locator_findAdapterByIdPtr>::finished(_proxies[0]);
return;
}
Ice::EndpointSeq endpoints;
Ice::ObjectPrx prx;
for(vector<Ice::ObjectPrx>::const_iterator p = _proxies.begin(); p != _proxies.end(); ++p)
{
if(!prx)
{
prx = *p;
}
Ice::EndpointSeq endpts = (*p)->ice_getEndpoints();
copy(endpts.begin(), endpts.end(), back_inserter(endpoints));
}
RequestT<std::string, Ice::AMD_Locator_findAdapterByIdPtr>::finished(prx->ice_endpoints(endpoints));
}
Ice::ObjectPrx
LocatorRegistryI::findAdapter(const string& adapterId, bool& isReplicaGroup) const
{
Lock sync(*this);
map<string, Ice::ObjectPrx>::const_iterator p = _adapters.find(adapterId);
if(p != _adapters.end())
{
isReplicaGroup = false;
return p->second;
}
map<string, set<string> >::const_iterator q = _replicaGroups.find(adapterId);
if(q != _replicaGroups.end())
{
Ice::EndpointSeq endpoints;
Ice::ObjectPrx prx;
for(set<string>::const_iterator r = q->second.begin(); r != q->second.end(); ++r)
{
map<string, Ice::ObjectPrx>::const_iterator s = _adapters.find(*r);
if(s == _adapters.end())
{
continue; // TODO: Inconsistency
}
if(!prx)
{
prx = s->second;
}
Ice::EndpointSeq endpts = s->second->ice_getEndpoints();
copy(endpts.begin(), endpts.end(), back_inserter(endpoints));
}
if(prx)
{
isReplicaGroup = true;
return prx->ice_endpoints(endpoints);
}
}
isReplicaGroup = false;
return 0;
}
int
run(int argc, char* argv[], const CommunicatorPtr& communicator)
{
IceUtilInternal::Options opts;
opts.addOpt("", "cycle");
try
{
opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << argv[0] << ": " << e.reason << endl;
return EXIT_FAILURE;
}
PropertiesPtr properties = communicator->getProperties();
const char* managerProxyProperty = "IceStormAdmin.TopicManager.Default";
string managerProxy = properties->getProperty(managerProxyProperty);
if(managerProxy.empty())
{
cerr << argv[0] << ": property `" << managerProxyProperty << "' is not set" << endl;
return EXIT_FAILURE;
}
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(
communicator->stringToProxy(managerProxy));
if(!manager)
{
cerr << argv[0] << ": `" << managerProxy << "' is not running" << endl;
return EXIT_FAILURE;
}
TopicPrx topic;
while(true)
{
try
{
topic = manager->retrieve("single");
break;
}
// This can happen if the replica group loses the majority
// during retrieve. In this case we retry.
catch(const Ice::UnknownException&)
{
continue;
}
catch(const IceStorm::NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
}
assert(topic);
//
// Get a publisher object, create a twoway proxy and then cast to
// a Single object.
//
if(opts.isSet("cycle"))
{
Ice::ObjectPrx prx = topic->getPublisher()->ice_twoway();
vector<SinglePrx> single;
Ice::EndpointSeq endpoints = prx->ice_getEndpoints();
for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
{
if((*p)->toString().substr(0, 3) != "udp")
{
Ice::EndpointSeq e;
e.push_back(*p);
single.push_back(SinglePrx::uncheckedCast(prx->ice_endpoints(e)));
}
}
if(single.size() <= 1)
{
cerr << argv[0] << ": Not enough endpoints in publisher proxy" << endl;
return EXIT_FAILURE;
}
int which = 0;
for(int i = 0; i < 1000; ++i)
{
single[which]->event(i);
which = (which + 1) % static_cast<int>(single.size());
}
}
else
{
SinglePrx single = SinglePrx::uncheckedCast(topic->getPublisher()->ice_twoway());
for(int i = 0; i < 1000; ++i)
{
single->event(i);
}
}
return EXIT_SUCCESS;
}