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; }