ZEND_METHOD(Ice_ObjectPrx, ice_getEndpoints) { if(ZEND_NUM_ARGS() != 0) { WRONG_PARAM_COUNT; } ProxyPtr _this = Wrapper<ProxyPtr>::value(getThis() TSRMLS_CC); assert(_this); try { Ice::EndpointSeq endpoints = _this->proxy->ice_getEndpoints(); array_init(return_value); uint idx = 0; for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p, ++idx) { zval* elem; MAKE_STD_ZVAL(elem); if(!createEndpoint(elem, *p TSRMLS_CC)) { zval_ptr_dtor(&elem); RETURN_NULL(); } add_index_zval(return_value, idx, elem); } } catch(const IceUtil::Exception& ex) { throwException(ex TSRMLS_CC); RETURN_NULL(); } }
static PyObject* adapterGetPublishedEndpoints(ObjectAdapterObject* self) { assert(self->adapter); Ice::EndpointSeq endpoints; try { endpoints = (*self->adapter)->getPublishedEndpoints(); } catch(const Ice::Exception& ex) { setPythonException(ex); return 0; } int count = static_cast<int>(endpoints.size()); PyObjectHandle result = PyTuple_New(count); int i = 0; for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p, ++i) { PyObjectHandle endp = createEndpoint(*p); if(!endp.get()) { return 0; } PyTuple_SET_ITEM(result.get(), i, endp.release()); // PyTuple_SET_ITEM steals a reference. } return result.release(); }
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 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(); } }
int FleCSServer::run(int, char*[]) { try { shutdownOnInterrupt(); Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("FleCS"); FleCS::C2SPtr c2s = new C2SI; adapter->add(c2s, communicator()->stringToIdentity("c2s")); FleCS::SM2SPtr sm2s = new SM2SI; adapter->add(sm2s, communicator()->stringToIdentity("sm2s")); adapter->activate(); // Notify master that a server is on. // // No deadlock as long as the master do not notify the originating server. // server --(join)--> master --(notify)--> all other servers. // // Master needs to make sure that join service is serialized. FleCS::MasterPrx& m_prx = GetMasterProxy(); // Ask to join the system. Give my endpoint and get the existing // servers. Ice::EndpointSeq eps = adapter->getEndpoints(); // Assume that this server has one endpoint. if (eps.size() != 1) { _LOG("Unexpected"); exit(EXIT_FAILURE); } vector<string> existingServers; m_prx->Join((*eps.begin())->toString(), existingServers); AddServers(existingServers); communicator()->waitForShutdown(); return EXIT_SUCCESS; } catch (const exception& e) { _LOG(e.what()); } return EXIT_FAILURE; }
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)); }
Ice::ObjectPrxPtr LocatorRegistryI::findAdapter(const string& adapterId, bool& isReplicaGroup) const { Lock sync(*this); map<string, Ice::ObjectPrxPtr>::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::ObjectPrxPtr prx; for(set<string>::const_iterator r = q->second.begin(); r != q->second.end(); ++r) { map<string, Ice::ObjectPrxPtr>::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; }
string IceStormInternal::describeEndpoints(const Ice::ObjectPrx& proxy) { ostringstream os; if(proxy) { Ice::EndpointSeq endpoints = proxy->ice_getEndpoints(); for(Ice::EndpointSeq::const_iterator i = endpoints.begin(); i != endpoints.end(); ++i) { if(i != endpoints.begin()) { os << ", "; } os << "\"" << (*i)->toString() << "\""; } } else { os << "subscriber proxy is null"; } return os.str(); }
TestIntfPrxPtr createTestIntfPrx(vector<RemoteObjectAdapterPrxPtr>& adapters) { Ice::EndpointSeq endpoints; TestIntfPrxPtr test; for(vector<RemoteObjectAdapterPrxPtr>::const_iterator p = adapters.begin(); p != adapters.end(); ++p) { test = (*p)->getTestIntf(); Ice::EndpointSeq edpts = test->ice_getEndpoints(); endpoints.insert(endpoints.end(), edpts.begin(), edpts.end()); } return ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_endpoints(endpoints)); }
void allTests(Test::TestHelper* helper) { Ice::CommunicatorPtr communicator = helper->communicator(); cout << "testing proxy endpoint information... " << flush; { Ice::ObjectPrxPtr p1 = communicator->stringToProxy("test -t:default -h tcphost -p 10000 -t 1200 -z --sourceAddress 10.10.10.10:" "udp -h udphost -p 10001 --interface eth0 --ttl 5 --sourceAddress 10.10.10.10:" "opaque -e 1.8 -t 100 -v ABCD"); Ice::EndpointSeq endps = p1->ice_getEndpoints(); Ice::EndpointInfoPtr info = endps[0]->getInfo(); Ice::TCPEndpointInfoPtr ipEndpoint = getTCPEndpointInfo(info); test(ipEndpoint); test(ipEndpoint->host == "tcphost"); test(ipEndpoint->port == 10000); test(ipEndpoint->timeout == 1200); #if !defined(ICE_OS_UWP) test(ipEndpoint->sourceAddress == "10.10.10.10"); #endif test(ipEndpoint->compress); test(!ipEndpoint->datagram()); test((ipEndpoint->type() == Ice::TCPEndpointType && !ipEndpoint->secure()) || (ipEndpoint->type() == Ice::SSLEndpointType && ipEndpoint->secure()) || (ipEndpoint->type() == Ice::WSEndpointType && !ipEndpoint->secure()) || (ipEndpoint->type() == Ice::WSSEndpointType && ipEndpoint->secure())); test((ipEndpoint->type() == Ice::TCPEndpointType && ICE_DYNAMIC_CAST(Ice::TCPEndpointInfo, info)) || (ipEndpoint->type() == Ice::SSLEndpointType && ICE_DYNAMIC_CAST(IceSSL::EndpointInfo, info)) || (ipEndpoint->type() == Ice::WSEndpointType && ICE_DYNAMIC_CAST(Ice::WSEndpointInfo, info)) || (ipEndpoint->type() == Ice::WSSEndpointType && ICE_DYNAMIC_CAST(Ice::WSEndpointInfo, info))); Ice::UDPEndpointInfoPtr udpEndpoint = ICE_DYNAMIC_CAST(Ice::UDPEndpointInfo, endps[1]->getInfo()); test(udpEndpoint); test(udpEndpoint->host == "udphost"); test(udpEndpoint->port == 10001); #if !defined(ICE_OS_UWP) test(udpEndpoint->sourceAddress == "10.10.10.10"); #endif test(udpEndpoint->mcastInterface == "eth0"); test(udpEndpoint->mcastTtl == 5); test(udpEndpoint->timeout == -1); test(!udpEndpoint->compress); test(!udpEndpoint->secure()); test(udpEndpoint->datagram()); test(udpEndpoint->type() == Ice::UDPEndpointType); Ice::OpaqueEndpointInfoPtr opaqueEndpoint = ICE_DYNAMIC_CAST(Ice::OpaqueEndpointInfo, endps[2]->getInfo()); test(opaqueEndpoint); Ice::EncodingVersion rev; rev.major = 1; rev.minor = 8; test(opaqueEndpoint->rawEncoding == rev); } cout << "ok" << endl; string defaultHost = communicator->getProperties()->getProperty("Ice.Default.Host"); #ifdef ICE_OS_UWP bool uwp = true; #else bool uwp = false; #endif if(!uwp || (communicator->getProperties()->getProperty("Ice.Default.Protocol") != "ssl" && communicator->getProperties()->getProperty("Ice.Default.Protocol") != "wss")) { cout << "test object adapter endpoint information... " << flush; { communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -h 127.0.0.1 -t 15000:udp -h 127.0.0.1"); Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter"); Ice::EndpointSeq endpoints = adapter->getEndpoints(); test(endpoints.size() == 2); Ice::EndpointSeq publishedEndpoints = adapter->getPublishedEndpoints(); test(endpoints == publishedEndpoints); Ice::TCPEndpointInfoPtr ipEndpoint = getTCPEndpointInfo(endpoints[0]->getInfo()); test(ipEndpoint); test(ipEndpoint->type() == Ice::TCPEndpointType || ipEndpoint->type() == Ice::SSLEndpointType || ipEndpoint->type() == Ice::WSEndpointType || ipEndpoint->type() == Ice::WSSEndpointType); test(ipEndpoint->host == "127.0.0.1"); test(ipEndpoint->port > 0); test(ipEndpoint->timeout == 15000); Ice::UDPEndpointInfoPtr udpEndpoint = ICE_DYNAMIC_CAST(Ice::UDPEndpointInfo, endpoints[1]->getInfo()); test(udpEndpoint); test(udpEndpoint->host == "127.0.0.1"); test(udpEndpoint->datagram()); test(udpEndpoint->port > 0); endpoints.pop_back(); test(endpoints.size() == 1); adapter->setPublishedEndpoints(endpoints); publishedEndpoints = adapter->getPublishedEndpoints(); test(endpoints == publishedEndpoints); adapter->destroy(); int port = helper->getTestPort(1); ostringstream portStr; portStr << port; communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -h * -p " + portStr.str()); communicator->getProperties()->setProperty("TestAdapter.PublishedEndpoints", helper->getTestEndpoint(1)); adapter = communicator->createObjectAdapter("TestAdapter"); endpoints = adapter->getEndpoints(); test(endpoints.size() >= 1); publishedEndpoints = adapter->getPublishedEndpoints(); test(publishedEndpoints.size() == 1); for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p) { ipEndpoint = getTCPEndpointInfo((*p)->getInfo()); test(ipEndpoint->port == port); } ipEndpoint = getTCPEndpointInfo(publishedEndpoints[0]->getInfo()); test(ipEndpoint->host == helper->getTestHost()); test(ipEndpoint->port == port); adapter->destroy(); } cout << "ok" << endl; } string endpoints = helper->getTestEndpoint() + ":" + helper->getTestEndpoint("udp") + " -c"; int port = helper->getTestPort(); Ice::ObjectPrxPtr base = communicator->stringToProxy("test:" + endpoints); TestIntfPrxPtr testIntf = ICE_CHECKED_CAST(TestIntfPrx, base); cout << "test connection endpoint information... " << flush; { Ice::EndpointInfoPtr info = base->ice_getConnection()->getEndpoint()->getInfo(); Ice::TCPEndpointInfoPtr tcpinfo = getTCPEndpointInfo(info); test(tcpinfo->port == port); test(!tcpinfo->compress); test(tcpinfo->host == defaultHost); ostringstream os; Ice::Context ctx = testIntf->getEndpointInfoAsContext(); test(ctx["host"] == tcpinfo->host); test(ctx["compress"] == "false"); istringstream is(ctx["port"]); int portCtx; is >> portCtx; test(portCtx > 0); info = base->ice_datagram()->ice_getConnection()->getEndpoint()->getInfo(); Ice::UDPEndpointInfoPtr udp = ICE_DYNAMIC_CAST(Ice::UDPEndpointInfo, info); test(udp); test(udp->port == portCtx); test(udp->host == defaultHost); } cout << "ok" << endl; cout << "testing connection information... " << flush; { Ice::ConnectionPtr connection = base->ice_getConnection(); connection->setBufferSize(1024, 2048); Ice::TCPConnectionInfoPtr info = getTCPConnectionInfo(connection->getInfo()); test(info); test(!info->incoming); test(info->adapterName.empty()); test(info->localPort > 0); test(info->remotePort == port); if(defaultHost == "127.0.0.1") { test(info->remoteAddress == defaultHost); test(info->localAddress == defaultHost); } #if !defined(ICE_OS_UWP) test(info->rcvSize >= 1024); test(info->sndSize >= 2048); #endif ostringstream os; Ice::Context ctx = testIntf->getConnectionInfoAsContext(); test(ctx["incoming"] == "true"); test(ctx["adapterName"] == "TestAdapter"); test(ctx["remoteAddress"] == info->localAddress); test(ctx["localAddress"] == info->remoteAddress); os.str(""); os << info->localPort; test(ctx["remotePort"] == os.str()); os.str(""); os << info->remotePort; test(ctx["localPort"] == os.str()); if(base->ice_getConnection()->type() == "ws" || base->ice_getConnection()->type() == "wss") { Ice::HeaderDict headers; Ice::WSConnectionInfoPtr wsinfo = ICE_DYNAMIC_CAST(Ice::WSConnectionInfo, connection->getInfo()); test(wsinfo); headers = wsinfo->headers; if(base->ice_getConnection()->type() == "wss") { IceSSL::ConnectionInfoPtr wssinfo = ICE_DYNAMIC_CAST(IceSSL::ConnectionInfo, wsinfo->underlying); test(wssinfo->verified); #if !defined(ICE_OS_UWP) && TARGET_OS_IPHONE==0 test(!wssinfo->certs.empty()); #endif } test(headers["Upgrade"] == "websocket"); test(headers["Connection"] == "Upgrade"); test(headers["Sec-WebSocket-Protocol"] == "ice.zeroc.com"); test(headers.find("Sec-WebSocket-Accept") != headers.end()); test(ctx["ws.Upgrade"] == "websocket"); test(ctx["ws.Connection"] == "Upgrade"); test(ctx["ws.Sec-WebSocket-Protocol"] == "ice.zeroc.com"); test(ctx["ws.Sec-WebSocket-Version"] == "13"); test(ctx.find("ws.Sec-WebSocket-Key") != ctx.end()); } connection = base->ice_datagram()->ice_getConnection(); connection->setBufferSize(2048, 1024); Ice::UDPConnectionInfoPtr udpinfo = ICE_DYNAMIC_CAST(Ice::UDPConnectionInfo, connection->getInfo()); test(!udpinfo->incoming); test(udpinfo->adapterName.empty()); test(udpinfo->localPort > 0); test(udpinfo->remotePort == port); if(defaultHost == "127.0.0.1") { test(udpinfo->remoteAddress == defaultHost); test(udpinfo->localAddress == defaultHost); } #if !defined(ICE_OS_UWP) test(udpinfo->rcvSize >= 2048); test(udpinfo->sndSize >= 1024); #endif } cout << "ok" << endl; testIntf->shutdown(); communicator->shutdown(); communicator->waitForShutdown(); }
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; }
Ice::ObjectPrx ReplicaCache::getEndpoints(const string& name, const Ice::ObjectPrx& proxy) const { Ice::EndpointSeq endpoints; if(proxy) { Ice::EndpointSeq endpts = proxy->ice_getEndpoints(); endpoints.insert(endpoints.end(), endpts.begin(), endpts.end()); } Lock sync(*this); for(map<string, ReplicaEntryPtr>::const_iterator p = _entries.begin(); p != _entries.end(); ++p) { Ice::ObjectPrx prx = p->second->getSession()->getEndpoint(name); if(prx) { Ice::EndpointSeq endpts = prx->ice_getEndpoints(); endpoints.insert(endpoints.end(), endpts.begin(), endpts.end()); } } return _communicator->stringToProxy("dummy")->ice_endpoints(endpoints); }
void allTests(const Ice::CommunicatorPtr& comm) { IceGrid::RegistryPrx registry = IceGrid::RegistryPrx::checkedCast( comm->stringToProxy(comm->getDefaultLocator()->ice_getIdentity().category + "/Registry")); AdminSessionPrx session = registry->createAdminSession("foo", "bar"); session->ice_getConnection()->setACM(registry->getACMTimeout(), IceUtil::None, Ice::HeartbeatAlways); AdminPrx admin = session->getAdmin(); test(admin); map<string, string> params; params.clear(); params["id"] = "Master"; params["replicaName"] = ""; params["port"] = "12050"; instantiateServer(admin, "IceGridRegistry", params); params.clear(); params["id"] = "Slave1"; params["replicaName"] = "Slave1"; params["port"] = "12051"; instantiateServer(admin, "IceGridRegistry", params); params.clear(); params["id"] = "Slave2"; params["replicaName"] = "Slave2"; params["port"] = "12052"; instantiateServer(admin, "IceGridRegistry", params); Ice::LocatorPrx masterLocator = Ice::LocatorPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Locator-Master:default -p 12050")); Ice::LocatorPrx slave1Locator = Ice::LocatorPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Locator-Slave1:default -p 12051")); Ice::LocatorPrx slave2Locator = Ice::LocatorPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Locator-Slave2:default -p 12052")); Ice::LocatorPrx replicatedLocator = Ice::LocatorPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Locator:default -p 12050:default -p 12051")); AdminPrx masterAdmin, slave1Admin, slave2Admin; admin->startServer("Master"); masterAdmin = createAdminSession(masterLocator, ""); admin->startServer("Slave1"); slave1Admin = createAdminSession(slave1Locator, "Slave1"); // // Test replication and well-known objects: // // - Locator interface // - Query interface // // - Registry object // - RegistryUserAccountMapper // - SessionManager/SSLSessionManager // - AdminSessionManager/AdminSSLSessionManager // cout << "testing replicated locator and query interface... " << flush; { Ice::EndpointSeq endpoints; ObjectInfo info; info = masterAdmin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator")); ObjectInfo info1 = slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator")); test(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator")) == info); test(info.type == Ice::Locator::ice_staticId()); endpoints = info.proxy->ice_getEndpoints(); test(endpoints.size() == 2); test(endpoints[0]->toString().find("-p 12050") != string::npos); test(endpoints[1]->toString().find("-p 12051") != string::npos); info = masterAdmin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query")); test(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query")) == info); test(info.type == IceGrid::Query::ice_staticId()); endpoints = info.proxy->ice_getEndpoints(); test(endpoints.size() == 2); test(endpoints[0]->toString().find("-p 12050") != string::npos); test(endpoints[1]->toString().find("-p 12051") != string::npos); admin->startServer("Slave2"); slave2Admin = createAdminSession(slave2Locator, "Slave2"); info = masterAdmin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator")); // We eventually need to wait here for the update of the replicated objects to propagate to the replica. int nRetry = 0; while(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator")) != info && nRetry < maxRetry) { IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(sleepTime)); ++nRetry; } test(slave2Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator")) == info); test(info.type == Ice::Locator::ice_staticId()); endpoints = info.proxy->ice_getEndpoints(); test(endpoints.size() == 3); test(endpoints[0]->toString().find("-p 12050") != string::npos); test(endpoints[1]->toString().find("-p 12051") != string::npos); test(endpoints[2]->toString().find("-p 12052") != string::npos); info = masterAdmin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query")); // We eventually need to wait here for the update of the replicated objects to propagate to the replica. nRetry = 0; while(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query")) != info && nRetry < maxRetry) { IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(sleepTime)); ++nRetry; } test(slave2Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query")) == info); test(info.type == IceGrid::Query::ice_staticId()); endpoints = info.proxy->ice_getEndpoints(); test(endpoints.size() == 3); test(endpoints[0]->toString().find("-p 12050") != string::npos); test(endpoints[1]->toString().find("-p 12051") != string::npos); test(endpoints[2]->toString().find("-p 12052") != string::npos); slave2Admin->shutdown(); waitForServerState(admin, "Slave2", false); info = masterAdmin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator")); // We eventually need to wait here for the update of the replicated objects to propagate to the replica. nRetry = 0; while(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator")) != info && nRetry < maxRetry) { IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(sleepTime)); ++nRetry; } test(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Locator")) == info); test(info.type == Ice::Locator::ice_staticId()); endpoints = info.proxy->ice_getEndpoints(); test(endpoints.size() == 2); test(endpoints[0]->toString().find("-p 12050") != string::npos); test(endpoints[1]->toString().find("-p 12051") != string::npos); info = masterAdmin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query")); nRetry = 0; while(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query")) != info && nRetry < maxRetry) { IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(sleepTime)); ++nRetry; } test(slave1Admin->getObjectInfo(Ice::stringToIdentity("RepTestIceGrid/Query")) == info); test(info.type == IceGrid::Query::ice_staticId()); endpoints = info.proxy->ice_getEndpoints(); test(endpoints.size() == 2); test(endpoints[0]->toString().find("-p 12050") != string::npos); test(endpoints[1]->toString().find("-p 12051") != string::npos); QueryPrx query; query = QueryPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Query:" + endpoints[0]->toString())); Ice::ObjectProxySeq objs = query->findAllObjectsByType("::IceGrid::Registry"); test(objs.size() == 2); query = QueryPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Query:" + endpoints[1]->toString())); test(objs == query->findAllObjectsByType("::IceGrid::Registry")); } cout << "ok" << endl; cout << "testing well-known IceGrid objects... " << flush; { // // Test Registry well-known object (we have already tested // admin session creation for the creation of the admin // session above!) // RegistryPrx masterRegistry = RegistryPrx::checkedCast( comm->stringToProxy("RepTestIceGrid/Registry")->ice_locator(replicatedLocator)); RegistryPrx slave1Registry = RegistryPrx::checkedCast( comm->stringToProxy("RepTestIceGrid/Registry-Slave1")->ice_locator(replicatedLocator)); SessionPrx session = masterRegistry->createSession("dummy", "dummy"); session->destroy(); if(comm->getProperties()->getProperty("Ice.Default.Protocol") == "ssl") { session = masterRegistry->createSessionFromSecureConnection(); session->destroy(); } else { try { masterRegistry->createSessionFromSecureConnection(); } catch(const PermissionDeniedException&) { } } try { slave1Registry->createSession("dummy", ""); } catch(const PermissionDeniedException&) { } try { slave1Registry->createSessionFromSecureConnection(); } catch(const PermissionDeniedException&) { } // // Test registry user-account mapper. // UserAccountMapperPrx masterMapper = UserAccountMapperPrx::checkedCast( comm->stringToProxy("RepTestIceGrid/RegistryUserAccountMapper")->ice_locator(replicatedLocator)); UserAccountMapperPrx slave1Mapper = UserAccountMapperPrx::checkedCast( comm->stringToProxy("RepTestIceGrid/RegistryUserAccountMapper-Slave1")->ice_locator(replicatedLocator)); test(masterMapper->getUserAccount("Dummy User Account1") == "dummy1"); test(masterMapper->getUserAccount("Dummy User Account2") == "dummy2"); test(slave1Mapper->getUserAccount("Dummy User Account1") == "dummy1"); test(slave1Mapper->getUserAccount("Dummy User Account2") == "dummy2"); try { masterMapper->getUserAccount("unknown"); test(false); } catch(const UserAccountNotFoundException&) { } try { slave1Mapper->getUserAccount("unknown"); test(false); } catch(const UserAccountNotFoundException&) { } // // Test SessionManager, SSLSessionManager, // AdminSessionManager, AdminSSLSessionManager // comm->stringToProxy("RepTestIceGrid/SessionManager")->ice_locator(replicatedLocator)->ice_ping(); comm->stringToProxy("RepTestIceGrid/SSLSessionManager")->ice_locator(replicatedLocator)->ice_ping(); try { comm->stringToProxy("RepTestIceGrid/SessionManager-Slave1")->ice_locator(replicatedLocator)->ice_ping(); test(false); } catch(const Ice::NotRegisteredException&) { } try { comm->stringToProxy("RepTestIceGrid/SSLSessionManager-Slave1")->ice_locator(replicatedLocator)->ice_ping(); test(false); } catch(const Ice::NotRegisteredException&) { } comm->stringToProxy("RepTestIceGrid/AdminSessionManager")->ice_locator(replicatedLocator)->ice_ping(); comm->stringToProxy("RepTestIceGrid/AdminSSLSessionManager")->ice_locator(replicatedLocator)->ice_ping(); comm->stringToProxy("RepTestIceGrid/AdminSessionManager-Slave1")->ice_locator(replicatedLocator)->ice_ping(); comm->stringToProxy("RepTestIceGrid/AdminSSLSessionManager-Slave1")->ice_locator(replicatedLocator)->ice_ping(); } cout << "ok" << endl; // // Registry update test: // // - start master // - start slave1: keep slave1 up for each update // - start slave2: shutdown slave2 for each update // - ensure updates are correctly replicated // - updates to test: application/adapter/object // cout << "testing registry updates... " << flush; { ApplicationDescriptor app; app.name = "TestApp"; app.description = "added application"; AdapterInfo adpt; adpt.id = "TestAdpt"; adpt.proxy = comm->stringToProxy("dummy:tcp -p 12345 -h 127.0.0.1"); ObjectInfo obj; obj.proxy = comm->stringToProxy("dummy:tcp -p 12345 -h 127.0.0.1"); obj.type = "::Hello"; // // We use the locator registry from Slave1 to ensure that the // forwarding to the master work (the slave locator registry // forwards everything to the master). // Ice::LocatorRegistryPrx locatorRegistry = slave1Locator->getRegistry(); // // Test addition of application, adapter, object. // try { slave1Admin->addApplication(app); test(false); } catch(const DeploymentException&) { // Slave can't modify the database. } masterAdmin->addApplication(app); locatorRegistry->setAdapterDirectProxy(adpt.id, adpt.proxy); try { slave1Admin->addObjectWithType(obj.proxy, obj.type); test(false); } catch(const DeploymentException&) { // Slave can't modify the database } masterAdmin->addObjectWithType(obj.proxy, obj.type); admin->startServer("Slave2"); slave2Admin = createAdminSession(slave2Locator, "Slave2"); test(masterAdmin->getApplicationInfo("TestApp").descriptor.description == "added application"); test(slave1Admin->getApplicationInfo("TestApp").descriptor.description == "added application"); test(slave2Admin->getApplicationInfo("TestApp").descriptor.description == "added application"); test(masterAdmin->getAdapterInfo("TestAdpt")[0] == adpt); test(slave1Admin->getAdapterInfo("TestAdpt")[0] == adpt); test(slave2Admin->getAdapterInfo("TestAdpt")[0] == adpt); test(masterAdmin->getObjectInfo(obj.proxy->ice_getIdentity()) == obj); test(slave1Admin->getObjectInfo(obj.proxy->ice_getIdentity()) == obj); test(slave2Admin->getObjectInfo(obj.proxy->ice_getIdentity()) == obj); slave2Admin->shutdown(); waitForServerState(admin, "Slave2", false); // // Test sync of application. // app.description = "updated1 application"; try { slave1Admin->syncApplication(app); test(false); } catch(const DeploymentException&) { // Slave can't modify the database. } masterAdmin->syncApplication(app); admin->startServer("Slave2"); slave2Admin = createAdminSession(slave2Locator, "Slave2"); test(masterAdmin->getApplicationInfo("TestApp").descriptor.description == "updated1 application"); test(slave1Admin->getApplicationInfo("TestApp").descriptor.description == "updated1 application"); test(slave2Admin->getApplicationInfo("TestApp").descriptor.description == "updated1 application"); slave2Admin->shutdown(); waitForServerState(admin, "Slave2", false); // // Test update of application, adapter, object. // ApplicationUpdateDescriptor appUpdate; appUpdate.name = "TestApp"; appUpdate.description = new BoxedString("updated2 application"); try { slave1Admin->updateApplication(appUpdate); test(false); } catch(const DeploymentException&) { // Slave can't modify the database. } masterAdmin->updateApplication(appUpdate); adpt.replicaGroupId = "TestReplicaGroup"; locatorRegistry->setReplicatedAdapterDirectProxy(adpt.id, adpt.replicaGroupId, adpt.proxy); obj.proxy = comm->stringToProxy("dummy:tcp -p 12346 -h 127.0.0.1"); try { slave1Admin->updateObject(obj.proxy); test(false); } catch(const DeploymentException&) { // Slave can't modify the database } masterAdmin->updateObject(obj.proxy); admin->startServer("Slave2"); slave2Admin = createAdminSession(slave2Locator, "Slave2"); test(masterAdmin->getApplicationInfo("TestApp").descriptor.description == "updated2 application"); test(slave1Admin->getApplicationInfo("TestApp").descriptor.description == "updated2 application"); test(slave2Admin->getApplicationInfo("TestApp").descriptor.description == "updated2 application"); test(masterAdmin->getAdapterInfo("TestAdpt")[0] == adpt); test(slave1Admin->getAdapterInfo("TestAdpt")[0] == adpt); test(slave2Admin->getAdapterInfo("TestAdpt")[0] == adpt); test(masterAdmin->getObjectInfo(obj.proxy->ice_getIdentity()) == obj); test(slave1Admin->getObjectInfo(obj.proxy->ice_getIdentity()) == obj); test(slave2Admin->getObjectInfo(obj.proxy->ice_getIdentity()) == obj); slave2Admin->shutdown(); waitForServerState(admin, "Slave2", false); // // Test removal of application, adapter and object. try { slave1Admin->removeApplication("TestApp"); test(false); } catch(const DeploymentException&) { // Slave can't modify the database. } masterAdmin->removeApplication("TestApp"); try { slave1Admin->removeAdapter("TestAdpt"); test(false); } catch(const DeploymentException&) { // Slave can't modify the database. } masterAdmin->removeAdapter("TestAdpt"); try { slave1Admin->removeObject(obj.proxy->ice_getIdentity()); } catch(const DeploymentException&) { // Slave can't modify the database. } masterAdmin->removeObject(obj.proxy->ice_getIdentity()); admin->startServer("Slave2"); slave2Admin = createAdminSession(slave2Locator, "Slave2"); try { masterAdmin->getApplicationInfo("TestApp"); test(false); } catch(const ApplicationNotExistException&) { } try { slave1Admin->getApplicationInfo("TestApp"); test(false); } catch(const ApplicationNotExistException&) { } try { slave2Admin->getApplicationInfo("TestApp"); test(false); } catch(const ApplicationNotExistException&) { } try { masterAdmin->getAdapterInfo("TestAdpt"); test(false); } catch(const AdapterNotExistException&) { } try { slave1Admin->getAdapterInfo("TestAdpt"); test(false); } catch(const AdapterNotExistException&) { } try { slave2Admin->getAdapterInfo("TestAdpt"); test(false); } catch(const AdapterNotExistException&) { } try { masterAdmin->getObjectInfo(obj.proxy->ice_getIdentity()); test(false); } catch(const ObjectNotRegisteredException&) { } try { slave1Admin->getObjectInfo(obj.proxy->ice_getIdentity()); test(false); } catch(const ObjectNotRegisteredException&) { } try { slave2Admin->getObjectInfo(obj.proxy->ice_getIdentity()); test(false); } catch(const ObjectNotRegisteredException&) { } slave2Admin->shutdown(); waitForServerState(admin, "Slave2", false); } cout << "ok" << endl; params.clear(); params["id"] = "Node1"; instantiateServer(admin, "IceGridNode", params); // // Add an application which is using Node1. Otherwise, when a // registry restarts it would throw aways the proxy of the nodes // because the node isn't used by any application. // ApplicationDescriptor app; app.name = "DummyApp"; app.nodes["Node1"].description = "dummy node"; try { masterAdmin->addApplication(app); } catch(const Ice::Exception& ex) { cerr << ex << endl; test(false); } // // Test node session establishment. // // - start master, start slave1, start node, start slave2 // - shutdown slave1, start slave1 -> node should re-connect // - shutdown master // - shutdown slave2, start slave2 -> node should re-connect // - shutdown slave1 // - start master -> node connects to master // - start slave1 -> node connects to slave1 // cout << "testing node session establishment... " << flush; { admin->startServer("Node1"); waitForNodeState(masterAdmin, "Node1", true); waitForNodeState(slave1Admin, "Node1", true); admin->startServer("Slave2"); slave2Admin = createAdminSession(slave2Locator, "Slave2"); waitForNodeState(slave2Admin, "Node1", true); // Node should connect. slave1Admin->shutdown(); waitForServerState(admin, "Slave1", false); admin->startServer("Slave1"); slave1Admin = createAdminSession(slave1Locator, "Slave1"); try { test(slave1Admin->pingNode("Node1")); // Node should be re-connected. } catch(const NodeNotExistException&) { test(false); } masterAdmin->shutdown(); waitForServerState(admin, "Master", false); slave2Admin->shutdown(); waitForServerState(admin, "Slave2", false); admin->startServer("Slave2"); slave2Admin = createAdminSession(slave2Locator, "Slave2"); try { // // On slow environments, it can take a bit for the node to // re-establish the connection so we ping it twice. The // second should succeed. // slave2Admin->pingNode("Node1"); test(slave2Admin->pingNode("Node1")); // Node should be re-connected even if the master is down. } catch(const NodeNotExistException&) { test(false); } slave1Admin->shutdown(); waitForServerState(admin, "Slave1", false); admin->startServer("Master"); masterAdmin = createAdminSession(masterLocator, ""); try { test(masterAdmin->pingNode("Node1")); // Node should be re-connected. } catch(const NodeNotExistException&) { test(false); } admin->startServer("Slave1"); slave1Admin = createAdminSession(slave1Locator, "Slave1"); try { test(slave1Admin->pingNode("Node1")); // Node should be re-connected. } catch(const NodeNotExistException&) { test(false); } try { test(masterAdmin->pingNode("Node1")); } catch(const NodeNotExistException&) { test(false); } try { test(slave2Admin->pingNode("Node1")); } catch(const NodeNotExistException&) { test(false); } slave2Admin->shutdown(); waitForServerState(admin, "Slave2", false); admin->startServer("Slave2"); slave2Admin = createAdminSession(slave2Locator, "Slave2"); try { test(slave2Admin->pingNode("Node1")); } catch(const NodeNotExistException&) { test(false); } } cout << "ok" << endl; // // Testing updates with out-of-date replicas. // cout << "testing out-of-date replicas... " << flush; { ApplicationDescriptor app; app.name = "TestApp"; app.description = "added application"; ServerDescriptorPtr server = new ServerDescriptor(); server->id = "Server"; server->exe = comm->getProperties()->getProperty("ServerDir") + "/server"; server->pwd = "."; server->applicationDistrib = false; server->allocatable = false; addProperty(server, "Ice.Admin.Endpoints", "tcp -h 127.0.0.1"); server->activation = "on-demand"; AdapterDescriptor adapter; adapter.name = "TestAdapter"; adapter.id = "TestAdapter.Server"; adapter.registerProcess = false; adapter.serverLifetime = true; PropertyDescriptor property; property.name = "TestAdapter.Endpoints"; property.value = "default"; server->propertySet.properties.push_back(property); property.name = "Identity"; property.value = "test"; server->propertySet.properties.push_back(property); ObjectDescriptor object; object.id = Ice::stringToIdentity("test"); object.type = "::Test::TestIntf"; adapter.objects.push_back(object); server->adapters.push_back(adapter); app.nodes["Node1"].servers.push_back(server); masterAdmin->addApplication(app); try { comm->stringToProxy("test")->ice_locator(masterLocator)->ice_locatorCacheTimeout(0)->ice_ping(); comm->stringToProxy("test")->ice_locator(slave1Locator)->ice_locatorCacheTimeout(0)->ice_ping(); comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping(); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } masterAdmin->stopServer("Server"); // // Shutdown Slave2 and update application. // slave2Admin->shutdown(); waitForServerState(admin, "Slave2", false); ApplicationUpdateDescriptor update; update.name = "TestApp"; NodeUpdateDescriptor node; node.name = "Node1"; node.servers.push_back(server); update.nodes.push_back(node); property.name = "Dummy"; property.value = "val"; server->propertySet.properties.push_back(property); masterAdmin->updateApplication(update); try { comm->stringToProxy("test")->ice_locator(masterLocator)->ice_locatorCacheTimeout(0)->ice_ping(); comm->stringToProxy("test")->ice_locator(slave1Locator)->ice_locatorCacheTimeout(0)->ice_ping(); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } masterAdmin->shutdown(); waitForServerState(admin, "Master", false); admin->startServer("Slave2"); slave2Admin = createAdminSession(slave2Locator, "Slave2"); waitForNodeState(slave2Admin, "Node1", true); // Node should connect. try { slave2Admin->startServer("Server"); test(false); } catch(const DeploymentException&) { } try { comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping(); test(false); } catch(const Ice::NoEndpointException&) { } admin->startServer("Master"); masterAdmin = createAdminSession(masterLocator, ""); slave2Admin->shutdown(); waitForServerState(admin, "Slave2", false); admin->startServer("Slave2"); slave2Admin = createAdminSession(slave2Locator, "Slave2"); try { comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping(); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } // // Shutdown Node1 and update the application, then, shutdown // the master. // slave1Admin->shutdownNode("Node1"); waitForServerState(admin, "Node1", false); slave2Admin->shutdown(); waitForServerState(admin, "Slave2", false); property.name = "Dummy2"; property.value = "val"; server->propertySet.properties.push_back(property); masterAdmin->updateApplication(update); masterAdmin->shutdown(); waitForServerState(admin, "Master", false); // // Restart Node1 and Slave2, Slave2 still has the old version // of the server so it should be able to load it. Slave1 has // a more recent version, so it can't load it. // admin->startServer("Slave2"); slave2Admin = createAdminSession(slave2Locator, "Slave2"); admin->startServer("Node1"); waitForNodeState(slave2Admin, "Node1", true); slave1Admin->shutdown(); waitForServerState(admin, "Slave1", false); try { comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping(); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } admin->startServer("Slave1"); slave1Admin = createAdminSession(slave1Locator, "Slave1"); try { comm->stringToProxy("test")->ice_locator(slave1Locator)->ice_locatorCacheTimeout(0)->ice_ping(); } catch(const Ice::NoEndpointException&) { } try { comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping(); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } slave2Admin->stopServer("Server"); // // Start the master. This will re-load the server on the node // and update the out-of-date replicas. // admin->startServer("Master"); masterAdmin = createAdminSession(masterLocator, ""); slave1Admin->shutdown(); waitForServerState(admin, "Slave1", false); admin->startServer("Slave1"); slave1Admin = createAdminSession(slave1Locator, "Slave1"); slave2Admin->shutdownNode("Node1"); waitForServerState(admin, "Node1", false); admin->startServer("Node1"); slave2Admin->shutdown(); waitForServerState(admin, "Slave2", false); admin->startServer("Slave2"); slave2Admin = createAdminSession(slave2Locator, "Slave2"); waitForNodeState(masterAdmin, "Node1", true); waitForNodeState(slave1Admin, "Node1", true); waitForNodeState(slave2Admin, "Node1", true); try { comm->stringToProxy("test")->ice_locator(masterLocator)->ice_locatorCacheTimeout(0)->ice_ping(); comm->stringToProxy("test")->ice_locator(slave1Locator)->ice_locatorCacheTimeout(0)->ice_ping(); comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping(); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } slave2Admin->stopServer("Server"); masterAdmin->removeApplication("TestApp"); } cout << "ok" << endl; cout << "testing master upgrade... " << flush; { ApplicationDescriptor app; app.name = "TestApp"; app.description = "added application"; ServerDescriptorPtr server = new ServerDescriptor(); server->id = "Server"; server->exe = comm->getProperties()->getProperty("ServerDir") + "/server"; server->pwd = "."; server->applicationDistrib = false; server->allocatable = false; addProperty(server, "Ice.Admin.Endpoints", "tcp -h 127.0.0.1"); server->activation = "on-demand"; AdapterDescriptor adapter; adapter.name = "TestAdapter"; adapter.id = "TestAdapter.Server"; adapter.serverLifetime = true; adapter.registerProcess = false; PropertyDescriptor property; property.name = "TestAdapter.Endpoints"; property.value = "default"; server->propertySet.properties.push_back(property); property.name = "Identity"; property.value = "test"; server->propertySet.properties.push_back(property); ObjectDescriptor object; object.id = Ice::stringToIdentity("test"); object.type = "::Test::TestIntf"; adapter.objects.push_back(object); server->adapters.push_back(adapter); app.nodes["Node1"].servers.push_back(server); masterAdmin->addApplication(app); comm->stringToProxy("test")->ice_locator(masterLocator)->ice_locatorCacheTimeout(0)->ice_ping(); comm->stringToProxy("test")->ice_locator(slave1Locator)->ice_locatorCacheTimeout(0)->ice_ping(); comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping(); masterAdmin->stopServer("Server"); // // Shutdown the Master, update Slave1 to be the Master. // masterAdmin->shutdown(); waitForServerState(admin, "Master", false); slave1Admin->shutdown(); waitForServerState(admin, "Slave1", false); params.clear(); params["id"] = "Slave1"; params["port"] = "12051"; params["replicaName"] = "Master"; instantiateServer(admin, "IceGridRegistry", params); admin->startServer("Slave1"); slave1Locator = Ice::LocatorPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Locator-Master:default -p 12051")); slave1Admin = createAdminSession(slave1Locator, ""); waitForReplicaState(slave1Admin, "Slave2", true); ApplicationUpdateDescriptor update; update.name = "TestApp"; NodeUpdateDescriptor node; node.name = "Node1"; node.servers.push_back(server); update.nodes.push_back(node); property.name = "Dummy"; property.value = "val"; server->propertySet.properties.push_back(property); slave1Admin->updateApplication(update); comm->stringToProxy("test")->ice_locator(slave1Locator)->ice_locatorCacheTimeout(0)->ice_ping(); comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping(); slave1Admin->shutdown(); waitForServerState(admin, "Slave1", false); params.clear(); params["id"] = "Slave1"; params["replicaName"] = "Slave1"; params["port"] = "12051"; instantiateServer(admin, "IceGridRegistry", params); params.clear(); params["id"] = "Master"; params["replicaName"] = ""; params["port"] = "12050"; params["arg"] = "--initdb-from-replica=Slave2"; instantiateServer(admin, "IceGridRegistry", params); admin->startServer("Master"); masterAdmin = createAdminSession(masterLocator, ""); admin->startServer("Slave1"); slave1Locator = Ice::LocatorPrx::uncheckedCast(comm->stringToProxy("RepTestIceGrid/Locator-Slave1:default -p 12051")); slave1Admin = createAdminSession(slave1Locator, "Slave1"); comm->stringToProxy("test")->ice_locator(masterLocator)->ice_locatorCacheTimeout(0)->ice_ping(); comm->stringToProxy("test")->ice_locator(slave1Locator)->ice_locatorCacheTimeout(0)->ice_ping(); comm->stringToProxy("test")->ice_locator(slave2Locator)->ice_locatorCacheTimeout(0)->ice_ping(); masterAdmin->stopServer("Server"); waitForReplicaState(masterAdmin, "Slave1", true); waitForReplicaState(masterAdmin, "Slave2", true); ApplicationInfo info = masterAdmin->getApplicationInfo("TestApp"); test(info.revision == 2); masterAdmin->removeApplication("TestApp"); } cout << "ok" << endl; cout << "testing interop with registry and node using the 1.0 encoding... " << flush; { params.clear(); params["id"] = "Slave3"; params["replicaName"] = "Slave3"; params["port"] = "12053"; params["encoding"] = "1.0"; instantiateServer(admin, "IceGridRegistry", params); params.clear(); params["id"] = "Node2"; params["encoding"] = "1.0"; instantiateServer(admin, "IceGridNode", params); admin->startServer("Slave3"); waitForServerState(admin, "Slave3", true); waitForReplicaState(masterAdmin, "Slave3", true); admin->startServer("Node2"); waitForNodeState(masterAdmin, "Node2", true); Ice::LocatorPrx slave3Locator = Ice::LocatorPrx::uncheckedCast( comm->stringToProxy("RepTestIceGrid/Locator-Slave3 -e 1.0:default -p 12053")); IceGrid::AdminPrx slave3Admin = createAdminSession(slave3Locator, "Slave3"); waitForNodeState(slave3Admin, "Node2", true); ApplicationDescriptor app; app.name = "TestApp"; app.description = "added application"; ServerDescriptorPtr server = new ServerDescriptor(); server->id = "Server"; server->exe = comm->getProperties()->getProperty("ServerDir") + "/server"; server->pwd = "."; server->applicationDistrib = false; server->allocatable = false; addProperty(server, "Ice.Admin.Endpoints", "tcp -h 127.0.0.1"); server->activation = "on-demand"; AdapterDescriptor adapter; adapter.name = "TestAdapter"; adapter.id = "TestAdapter.Server"; adapter.serverLifetime = true; adapter.registerProcess = false; PropertyDescriptor property; property.name = "TestAdapter.Endpoints"; property.value = "default"; server->propertySet.properties.push_back(property); property.name = "Identity"; property.value = "test"; server->propertySet.properties.push_back(property); ObjectDescriptor object; object.id = Ice::stringToIdentity("test"); object.type = "::Test::TestIntf"; adapter.objects.push_back(object); server->adapters.push_back(adapter); app.nodes["Node2"].servers.push_back(server); masterAdmin->addApplication(app); comm->stringToProxy("test -e 1.0")->ice_locator( masterLocator->ice_encodingVersion(Ice::Encoding_1_0))->ice_locatorCacheTimeout(0)->ice_ping(); comm->stringToProxy("test -e 1.0")->ice_locator( slave1Locator->ice_encodingVersion(Ice::Encoding_1_0))->ice_locatorCacheTimeout(0)->ice_ping(); comm->stringToProxy("test -e 1.0")->ice_locator(slave3Locator)->ice_locatorCacheTimeout(0)->ice_ping(); masterAdmin->stopServer("Server"); } cout << "ok" << endl; slave1Admin->shutdownNode("Node1"); removeServer(admin, "Node1"); removeServer(admin, "Slave2"); slave1Admin->shutdown(); removeServer(admin, "Slave1"); masterAdmin->shutdown(); removeServer(admin, "Master"); }
void allTests(const Ice::CommunicatorPtr& communicator) { cout << "testing proxy endpoint information... " << flush; { Ice::ObjectPrx p1 = communicator->stringToProxy("test -t:default -h tcphost -p 10000 -t 1200 -z --sourceAddress 10.10.10.10:" "udp -h udphost -p 10001 --interface eth0 --ttl 5 --sourceAddress 10.10.10.10:" "opaque -e 1.8 -t 100 -v ABCD"); Ice::EndpointSeq endps = p1->ice_getEndpoints(); Ice::IPEndpointInfoPtr ipEndpoint = Ice::IPEndpointInfoPtr::dynamicCast(endps[0]->getInfo()); test(ipEndpoint); test(ipEndpoint->host == "tcphost"); test(ipEndpoint->port == 10000); test(ipEndpoint->timeout == 1200); #if !defined(ICE_OS_WINRT) test(ipEndpoint->sourceAddress == "10.10.10.10"); #endif test(ipEndpoint->compress); test(!ipEndpoint->datagram()); test((ipEndpoint->type() == Ice::TCPEndpointType && !ipEndpoint->secure()) || (ipEndpoint->type() == IceSSL::EndpointType && ipEndpoint->secure()) || (ipEndpoint->type() == Ice::WSEndpointType && !ipEndpoint->secure()) || (ipEndpoint->type() == Ice::WSSEndpointType && ipEndpoint->secure())); test((ipEndpoint->type() == Ice::TCPEndpointType && Ice::TCPEndpointInfoPtr::dynamicCast(ipEndpoint)) || (ipEndpoint->type() == IceSSL::EndpointType && IceSSL::EndpointInfoPtr::dynamicCast(ipEndpoint)) || (ipEndpoint->type() == Ice::WSEndpointType && Ice::EndpointInfoPtr::dynamicCast(ipEndpoint)) || (ipEndpoint->type() == Ice::WSSEndpointType && Ice::EndpointInfoPtr::dynamicCast(ipEndpoint))); Ice::UDPEndpointInfoPtr udpEndpoint = Ice::UDPEndpointInfoPtr::dynamicCast(endps[1]->getInfo()); test(udpEndpoint); test(udpEndpoint->host == "udphost"); test(udpEndpoint->port == 10001); #if !defined(ICE_OS_WINRT) test(udpEndpoint->sourceAddress == "10.10.10.10"); #endif test(udpEndpoint->mcastInterface == "eth0"); test(udpEndpoint->mcastTtl == 5); test(udpEndpoint->timeout == -1); test(!udpEndpoint->compress); test(!udpEndpoint->secure()); test(udpEndpoint->datagram()); test(udpEndpoint->type() == Ice::UDPEndpointType); Ice::OpaqueEndpointInfoPtr opaqueEndpoint = Ice::OpaqueEndpointInfoPtr::dynamicCast(endps[2]->getInfo()); test(opaqueEndpoint); Ice::EncodingVersion rev; rev.major = 1; rev.minor = 8; test(opaqueEndpoint->rawEncoding == rev); } cout << "ok" << endl; string defaultHost = communicator->getProperties()->getProperty("Ice.Default.Host"); cout << "test object adapter endpoint information... " << flush; { communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -t 15000:udp"); Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter"); Ice::EndpointSeq endpoints = adapter->getEndpoints(); test(endpoints.size() == 2); Ice::EndpointSeq publishedEndpoints = adapter->getPublishedEndpoints(); test(endpoints == publishedEndpoints); Ice::IPEndpointInfoPtr ipEndpoint = Ice::IPEndpointInfoPtr::dynamicCast(endpoints[0]->getInfo()); test(ipEndpoint); test(ipEndpoint->type() == Ice::TCPEndpointType || ipEndpoint->type() == IceSSL::EndpointType || ipEndpoint->type() == Ice::WSEndpointType || ipEndpoint->type() == Ice::WSSEndpointType); test(ipEndpoint->host == defaultHost); test(ipEndpoint->port > 0); test(ipEndpoint->timeout == 15000); Ice::UDPEndpointInfoPtr udpEndpoint = Ice::UDPEndpointInfoPtr::dynamicCast(endpoints[1]->getInfo()); test(udpEndpoint); test(udpEndpoint->host == defaultHost); test(udpEndpoint->datagram()); test(udpEndpoint->port > 0); adapter->destroy(); communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -h * -p 12020"); communicator->getProperties()->setProperty("TestAdapter.PublishedEndpoints", "default -h 127.0.0.1 -p 12020"); adapter = communicator->createObjectAdapter("TestAdapter"); endpoints = adapter->getEndpoints(); test(endpoints.size() >= 1); publishedEndpoints = adapter->getPublishedEndpoints(); test(publishedEndpoints.size() == 1); for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p) { ipEndpoint = Ice::IPEndpointInfoPtr::dynamicCast((*p)->getInfo()); test(ipEndpoint->port == 12020); } ipEndpoint = Ice::IPEndpointInfoPtr::dynamicCast(publishedEndpoints[0]->getInfo()); test(ipEndpoint->host == "127.0.0.1"); test(ipEndpoint->port == 12020); adapter->destroy(); } cout << "ok" << endl; Ice::ObjectPrx base = communicator->stringToProxy("test:default -p 12010:udp -p 12010 -c"); TestIntfPrx testIntf = TestIntfPrx::checkedCast(base); cout << "test connection endpoint information... " << flush; { Ice::EndpointInfoPtr info = base->ice_getConnection()->getEndpoint()->getInfo(); Ice::IPEndpointInfoPtr ipinfo = Ice::IPEndpointInfoPtr::dynamicCast(info); test(ipinfo->port == 12010); test(!ipinfo->compress); test(ipinfo->host == defaultHost); ostringstream os; Ice::Context ctx = testIntf->getEndpointInfoAsContext(); test(ctx["host"] == ipinfo->host); test(ctx["compress"] == "false"); istringstream is(ctx["port"]); int port; is >> port; test(port > 0); info = base->ice_datagram()->ice_getConnection()->getEndpoint()->getInfo(); Ice::UDPEndpointInfoPtr udp = Ice::UDPEndpointInfoPtr::dynamicCast(info); test(udp); test(udp->port == 12010); test(udp->host == defaultHost); } cout << "ok" << endl; cout << "testing connection information... " << flush; { Ice::IPConnectionInfoPtr info = Ice::IPConnectionInfoPtr::dynamicCast(base->ice_getConnection()->getInfo()); test(info); test(!info->incoming); test(info->adapterName.empty()); test(info->localPort > 0); test(info->remotePort == 12010); if(defaultHost == "127.0.0.1") { test(info->remoteAddress == defaultHost); test(info->localAddress == defaultHost); } ostringstream os; Ice::Context ctx = testIntf->getConnectionInfoAsContext(); test(ctx["incoming"] == "true"); test(ctx["adapterName"] == "TestAdapter"); test(ctx["remoteAddress"] == info->localAddress); test(ctx["localAddress"] == info->remoteAddress); os.str(""); os << info->localPort; test(ctx["remotePort"] == os.str()); os.str(""); os << info->remotePort; test(ctx["localPort"] == os.str()); info = Ice::IPConnectionInfoPtr::dynamicCast(base->ice_datagram()->ice_getConnection()->getInfo()); test(!info->incoming); test(info->adapterName.empty()); test(info->localPort > 0); test(info->remotePort == 12010); if(defaultHost == "127.0.0.1") { test(info->remoteAddress == defaultHost); test(info->localAddress == defaultHost); } } cout << "ok" << endl; testIntf->shutdown(); communicator->shutdown(); communicator->waitForShutdown(); }