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); } }
ZEND_METHOD(Ice_ObjectPrx, ice_endpoints) { ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC); assert(_this); zval* zv; if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, const_cast<char*>("a"), &zv) == FAILURE) { RETURN_NULL(); } Ice::EndpointSeq seq; HashTable* arr = Z_ARRVAL_P(zv); HashPosition pos; void* data; zend_hash_internal_pointer_reset_ex(arr, &pos); while(zend_hash_get_current_data_ex(arr, &data, &pos) != FAILURE) { zval** val = reinterpret_cast<zval**>(data); if(Z_TYPE_PP(val) != IS_OBJECT) { runtimeError("expected an element of type Ice::Endpoint" TSRMLS_CC); RETURN_NULL(); } Ice::EndpointPtr endpoint; if(!fetchEndpoint(*val, endpoint TSRMLS_CC)) { RETURN_NULL(); } seq.push_back(endpoint); zend_hash_move_forward_ex(arr, &pos); } try { if(!_this->clone(return_value, _this->proxy->ice_endpoints(seq) TSRMLS_CC)) { RETURN_NULL(); } } catch(const IceUtil::Exception& ex) { throwException(ex TSRMLS_CC); RETURN_NULL(); } }
void NodeSessionManager::create(const NodeIPtr& node) { { Lock sync(*this); assert(!_node); const_cast<NodeIPtr&>(_node) = node; Ice::CommunicatorPtr communicator = _node->getCommunicator(); assert(communicator->getDefaultLocator()); Ice::Identity id = communicator->getDefaultLocator()->ice_getIdentity(); // // Initialize the IceGrid::Query objects. The IceGrid::Query // interface is used to lookup the registry proxy in case it // becomes unavailable. Since replicas might not always have // an up to date registry proxy, we need to query all the // replicas. // Ice::EndpointSeq endpoints = communicator->getDefaultLocator()->ice_getEndpoints(); id.name = "Query"; QueryPrx query = QueryPrx::uncheckedCast(communicator->stringToProxy(communicator->identityToString(id))); for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p) { Ice::EndpointSeq singleEndpoint; singleEndpoint.push_back(*p); _queryObjects.push_back(QueryPrx::uncheckedCast(query->ice_endpoints(singleEndpoint))); } id.name = "InternalRegistry-Master"; _master = InternalRegistryPrx::uncheckedCast(communicator->stringToProxy(communicator->identityToString(id))); _thread = new Thread(*this); _thread->start(); } // // Try to create the session. It's important that we wait for the // creation of the session as this will also try to create sessions // with replicas (see createdSession below) and this must be done // before the node is activated. // _thread->tryCreateSession(true, IceUtil::Time::seconds(3)); }
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; }