void TopicImpl::unsubscribe(const Ice::ObjectPrx& subscriber) { TraceLevelsPtr traceLevels = _instance->traceLevels(); if(!subscriber) { if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); out << "unsubscribe with null subscriber."; } return; } Ice::Identity id = subscriber->ice_getIdentity(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); out << _name << ": unsubscribe: " << _instance->communicator()->identityToString(id); if(traceLevels->topic > 1) { out << " endpoints: " << IceStormInternal::describeEndpoints(subscriber); trace(out, _instance, _subscribers); } } IceUtil::Mutex::Lock sync(_subscribersMutex); Ice::IdentitySeq ids; ids.push_back(id); removeSubscribers(ids); }
bool IceInternal::RouterInfo::addProxy(const Ice::ObjectPrx& proxy, const AddProxyCallbackPtr& callback) { assert(proxy); { IceUtil::Mutex::Lock sync(*this); if(_identities.find(proxy->ice_getIdentity()) != _identities.end()) { // // Only add the proxy to the router if it's not already in our local map. // return true; } } Ice::ObjectProxySeq proxies; proxies.push_back(proxy); AddProxyCookiePtr cookie = new AddProxyCookie(callback, proxy); _router->begin_addProxies(proxies, newCallback_Router_addProxies(this, &RouterInfo::addProxyResponse, &RouterInfo::addProxyException), cookie); return false; }
Ice::ObjectPrx TransientTopicImpl::subscribeAndGetPublisher(const QoS& qos, const Ice::ObjectPrx& obj, const Ice::Current&) { if(!obj) { TraceLevelsPtr traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); out << _name << ": subscribe: null proxy"; } throw InvalidSubscriber("subscriber is a null proxy"); } Ice::Identity id = obj->ice_getIdentity(); TraceLevelsPtr traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); out << _name << ": subscribeAndGetPublisher: " << _instance->communicator()->identityToString(id); if(traceLevels->topic > 1) { out << " endpoints: " << IceStormInternal::describeEndpoints(obj) << " QoS: "; for(QoS::const_iterator p = qos.begin(); p != qos.end() ; ++p) { if(p != qos.begin()) { out << ','; } } } } Lock sync(*this); SubscriberRecord record; record.id = id; record.obj = obj; record.theQoS = qos; record.topicName = _name; record.link = false; record.cost = 0; vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), record.id); if(p != _subscribers.end()) { throw AlreadySubscribed(); } SubscriberPtr subscriber = Subscriber::create(_instance, record); _subscribers.push_back(subscriber); return subscriber->proxy(); }
orca::FQComponentName toComponentName( const Ice::ObjectPrx& homePrx ) { // THE OLD WAY: a Home was on the component's adapter // string adapt = homePrx->ice_getAdapterId(); // return orcaice::toComponentName( adapt ); // THE NEW WAY: a Home is a facet on the Admin interface Ice::Identity ident = homePrx->ice_getIdentity(); // cout<<"DEBUG: ident="<<ident.category<<"/"<<ident.name<<endl; return orcaice::toComponentName( ident ); }
void IceInternal::RouterInfo::addAndEvictProxies(const Ice::ObjectPrx& proxy, const Ice::ObjectProxySeq& evictedProxies) { IceUtil::Mutex::Lock sync(*this); // // Check if the proxy hasn't already been evicted by a concurrent addProxies call. // If it's the case, don't add it to our local map. // multiset<Identity>::iterator p = _evictedIdentities.find(proxy->ice_getIdentity()); if(p != _evictedIdentities.end()) { _evictedIdentities.erase(p); } else { // // If we successfully added the proxy to the router, // we add it to our local map. // _identities.insert(proxy->ice_getIdentity()); } // // We also must remove whatever proxies the router evicted. // for(Ice::ObjectProxySeq::const_iterator q = evictedProxies.begin(); q != evictedProxies.end(); ++q) { if(_identities.erase((*q)->ice_getIdentity()) == 0) { // // It's possible for the proxy to not have been // added yet in the local map if two threads // concurrently call addProxies. // _evictedIdentities.insert((*q)->ice_getIdentity()); } } }
Ice::ObjectProxySeq QueryI::findAllReplicas(const Ice::ObjectPrx& proxy, const Ice::Current&) const { if(!proxy) { return Ice::ObjectProxySeq(); } // // If the given proxy has an empty adapter id, we check if it's a // well-known object. If it's a well-known object we use the // registered proxy instead. // Ice::ObjectPrx prx = proxy; if(prx->ice_getAdapterId().empty()) { try { ObjectInfo info = _database->getObjectInfo(prx->ice_getIdentity()); prx = info.proxy; } catch(const ObjectNotRegisteredException&) { return Ice::ObjectProxySeq(); } } try { AdapterInfoSeq infos = _database->getAdapterInfo(prx->ice_getAdapterId()); if(infos.empty() || infos[0].replicaGroupId != prx->ice_getAdapterId()) { // The adapter id doesn't refer to a replica group or the replica group is empty. return Ice::ObjectProxySeq(); } Ice::ObjectProxySeq proxies; for(AdapterInfoSeq::const_iterator p = infos.begin(); p != infos.end(); ++p) { assert(!p->id.empty()); proxies.push_back(prx->ice_adapterId(p->id)); } return proxies; } catch(const AdapterNotExistException&) { return Ice::ObjectProxySeq(); } }
void AdminI::updateObject(const Ice::ObjectPrx& proxy, const ::Ice::Current&) { checkIsReadOnly(); if(!proxy) { throw DeploymentException("proxy is null"); } const Ice::Identity id = proxy->ice_getIdentity(); if(id.category == _database->getInstanceName()) { throw DeploymentException("updating object `" + _database->getCommunicator()->identityToString(id) + "' is not allowed:\nobjects with identity category `" + id.category + "' are managed by IceGrid"); } _database->updateObject(proxy); }
int ObserverTopic::subscribe(const Ice::ObjectPrx& obsv, const string& name) { Lock sync(*this); if(_topics.empty()) { return -1; } assert(obsv); try { IceStorm::QoS qos; qos["reliability"] = "ordered"; Ice::EncodingVersion v = IceInternal::getCompatibleEncoding(obsv->ice_getEncodingVersion()); map<Ice::EncodingVersion, IceStorm::TopicPrx>::const_iterator p = _topics.find(v); if(p == _topics.end()) { Ice::Warning out(_logger); out << "unsupported encoding version for observer `" << obsv << "'"; return -1; } initObserver(p->second->subscribeAndGetPublisher(qos, obsv->ice_twoway())); } catch(const IceStorm::AlreadySubscribed&) { throw ObserverAlreadyRegisteredException(obsv->ice_getIdentity()); } if(!name.empty()) { assert(_syncSubscribers.find(name) == _syncSubscribers.end()); _syncSubscribers.insert(name); addExpectedUpdate(_serial, name); return _serial; } return -1; }
void AdminI::addObjectWithType(const Ice::ObjectPrx& proxy, const string& type, const ::Ice::Current&) { checkIsReadOnly(); if(!proxy) { throw DeploymentException("proxy is null"); } const Ice::Identity id = proxy->ice_getIdentity(); if(id.category == _database->getInstanceName()) { throw DeploymentException("adding object `" + _database->getCommunicator()->identityToString(id) + "' is not allowed:\nobjects with identity category `" + id.category + "' are managed by IceGrid"); } ObjectInfo info; info.proxy = proxy; info.type = type; _database->addObject(info); }
void TransientTopicImpl::unsubscribe(const Ice::ObjectPrx& subscriber, const Ice::Current&) { TraceLevelsPtr traceLevels = _instance->traceLevels(); if(!subscriber) { if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); out << _name << ": unsubscribe: null proxy"; } throw InvalidSubscriber("subscriber is a null proxy"); } Ice::Identity id = subscriber->ice_getIdentity(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); out << _name << ": unsubscribe: " << _instance->communicator()->identityToString(id); if(traceLevels->topic > 1) { out << " endpoints: " << IceStormInternal::describeEndpoints(subscriber); } } Lock sync(*this); // First remove the subscriber from the subscribers list. Note // that its possible that the subscriber isn't in the list, but is // in the database if the subscriber was locally reaped. vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), id); if(p != _subscribers.end()) { (*p)->destroy(); _subscribers.erase(p); } }
IceGrid::QueryPrx getDefaultQuery( const orcaice::Context& context ) { Ice::CommunicatorPtr ic = context.communicator(); assert( ic ); Ice::ObjectPrx locatorPrx = ic->getDefaultLocator(); Ice::Identity locatorId = locatorPrx->ice_getIdentity(); Ice::Identity queryId; queryId.category = locatorId.category; queryId.name = "Query"; Ice::ObjectPrx objPrx = ic->stringToProxy( ic->identityToString( queryId ) ); IceGrid::QueryPrx queryPrx; try { // objPrx->ice_ping(); // string address = orcacm::connectionToRemoteAddress( queryPrx->ice_getConnection()->toString() ); // std::ostringstream os; // os<<"Registry ping successful: "<<data.address; // context.tracer().debug( os.str() ); queryPrx = IceGrid::QueryPrx::checkedCast( objPrx ); } catch ( const Ice::Exception& e ) { // what do we do? ostringstream os; os << "(while looking for IceGrid Query interface) :"<<e.what(); context.tracer().warning( os.str() ); } return queryPrx; }
void allTests(const Ice::CommunicatorPtr& comm) { IceGrid::RegistryPrx registry = IceGrid::RegistryPrx::checkedCast( comm->stringToProxy(comm->getDefaultLocator()->ice_getIdentity().category + "/Registry")); test(registry); IceGrid::QueryPrx query = IceGrid::QueryPrx::checkedCast( comm->stringToProxy(comm->getDefaultLocator()->ice_getIdentity().category + "/Query")); test(query); AdminSessionPrx session = registry->createAdminSession("foo", "bar"); session->ice_getConnection()->setACM(registry->getACMTimeout(), IceUtil::None, Ice::HeartbeatAlways); AdminPrx admin = session->getAdmin(); test(admin); cout << "testing server registration... " << flush; Ice::StringSeq serverIds = admin->getAllServerIds(); test(find(serverIds.begin(), serverIds.end(), "Server1") != serverIds.end()); test(find(serverIds.begin(), serverIds.end(), "Server2") != serverIds.end()); test(find(serverIds.begin(), serverIds.end(), "IceBox1") != serverIds.end()); test(find(serverIds.begin(), serverIds.end(), "IceBox2") != serverIds.end()); test(find(serverIds.begin(), serverIds.end(), "SimpleServer") != serverIds.end()); test(find(serverIds.begin(), serverIds.end(), "SimpleIceBox") != serverIds.end()); cout << "ok" << endl; cout << "testing adapter registration... " << flush; Ice::StringSeq adapterIds = admin->getAllAdapterIds(); test(find(adapterIds.begin(), adapterIds.end(), "Server1.Server") != adapterIds.end()); test(find(adapterIds.begin(), adapterIds.end(), "Server2.Server") != adapterIds.end()); test(find(adapterIds.begin(), adapterIds.end(), "SimpleServer.Server") != adapterIds.end()); test(find(adapterIds.begin(), adapterIds.end(), "IceBox1.Service1.Service1") != adapterIds.end()); test(find(adapterIds.begin(), adapterIds.end(), "IceBox1Service2Adapter") != adapterIds.end()); test(find(adapterIds.begin(), adapterIds.end(), "IceBox2.Service1.Service1") != adapterIds.end()); test(find(adapterIds.begin(), adapterIds.end(), "IceBox2Service2Adapter") != adapterIds.end()); test(find(adapterIds.begin(), adapterIds.end(), "SimpleIceBox.SimpleService.SimpleService") != adapterIds.end()); test(find(adapterIds.begin(), adapterIds.end(), "ReplicatedAdapter") != adapterIds.end()); cout << "ok" << endl; cout << "testing object registration... " << flush; Ice::ObjectProxySeq objs = query->findAllObjectsByType("::Test"); test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"Server1")) != objs.end()); test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"Server2")) != objs.end()); test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"SimpleServer")) != objs.end()); test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"IceBox1-Service1")) != objs.end()); test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"IceBox1-Service2")) != objs.end()); test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"IceBox2-Service1")) != objs.end()); test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"IceBox2-Service2")) != objs.end()); test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"SimpleIceBox-SimpleService")) != objs.end()); test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"ReplicatedObject")) != objs.end()); { test(identityToString(query->findObjectByType("::TestId1")->ice_getIdentity()) == "cat/name1"); test(identityToString(query->findObjectByType("::TestId2")->ice_getIdentity()) == "cat1/name1"); test(identityToString(query->findObjectByType("::TestId3")->ice_getIdentity()) == "cat1/name1-bis"); test(identityToString(query->findObjectByType("::TestId4")->ice_getIdentity()) == "c2\\/c2/n2\\/n2"); test(identityToString(query->findObjectByType("::TestId5")->ice_getIdentity()) == "n2\\/n2"); } { Ice::ObjectPrx obj = query->findObjectByType("::Test"); string id = identityToString(obj->ice_getIdentity()); test(id == "Server1" || id == "Server2" || id == "SimpleServer" || id == "IceBox1-Service1" || id == "IceBox1-Service2" || id == "IceBox2-Service1" || id == "IceBox2-Service2" || id == "SimpleIceBox-SimpleService" || "ReplicatedObject"); } { Ice::ObjectPrx obj = query->findObjectByTypeOnLeastLoadedNode("::Test", LoadSample5); string id = identityToString(obj->ice_getIdentity()); test(id == "Server1" || id == "Server2" || id == "SimpleServer" || id == "IceBox1-Service1" || id == "IceBox1-Service2" || id == "IceBox2-Service1" || id == "IceBox2-Service2" || id == "SimpleIceBox-SimpleService" || "ReplicatedObject"); } { Ice::ObjectPrx obj = query->findObjectByType("::Foo"); test(!obj); obj = query->findObjectByTypeOnLeastLoadedNode("::Foo", LoadSample15); test(!obj); } Ice::Identity encoding10_oneway; encoding10_oneway.name = "encoding10-oneway"; test(query->findObjectById(encoding10_oneway)->ice_getEncodingVersion() == Ice::Encoding_1_0); test(query->findObjectById(encoding10_oneway)->ice_isOneway()); Ice::Identity encoding10_secure; encoding10_secure.name = "encoding10-secure"; test(query->findObjectById(encoding10_secure)->ice_getEncodingVersion() == Ice::Encoding_1_0); test(query->findObjectById(encoding10_secure)->ice_isSecure()); Ice::Identity oaoptions; oaoptions.name = "oaoptions"; test(query->findObjectById(oaoptions)->ice_getEncodingVersion() == Ice::stringToEncodingVersion("1.2")); test(query->findObjectById(oaoptions)->ice_isTwoway()); Ice::Identity comoptions; comoptions.name = "communicatoroptions"; test(query->findObjectById(comoptions)->ice_getEncodingVersion() == Ice::stringToEncodingVersion("1.3")); test(query->findObjectById(comoptions)->ice_isTwoway()); Ice::Identity options34; options34.name = "34options"; test(query->findObjectById(options34)->ice_getEncodingVersion() == Ice::Encoding_1_0); Ice::Identity simpleServer; simpleServer.name = "SimpleServer"; test(query->findObjectById(simpleServer)->ice_getEncodingVersion() == Ice::Encoding_1_1); Ice::Identity replicated15; replicated15.name = "ReplicatedObject15"; test(query->findObjectById(replicated15)->ice_getEncodingVersion() == Ice::stringToEncodingVersion("1.5")); Ice::Identity replicated14; replicated14.name = "ReplicatedObject14"; test(query->findObjectById(replicated14)->ice_getEncodingVersion() == Ice::stringToEncodingVersion("1.4")); Ice::LocatorPrx locator = comm->getDefaultLocator(); test(query->findObjectById(encoding10_oneway) == locator->findObjectById(encoding10_oneway)); test(query->findObjectById(encoding10_secure) == locator->findObjectById(encoding10_secure)); test(query->findObjectById(oaoptions) == locator->findObjectById(oaoptions)); test(query->findObjectById(comoptions) == locator->findObjectById(comoptions)); test(query->findObjectById(options34) == locator->findObjectById(options34)); test(query->findObjectById(simpleServer) == locator->findObjectById(simpleServer)); test(query->findObjectById(replicated15) == locator->findObjectById(replicated15)); test(query->findObjectById(replicated14) == locator->findObjectById(replicated14)); cout << "ok" << endl; // // Ensure that all server and service objects are reachable. // // The identity for the test object in deployed server or services // is the name of the service or server. The object adapter name // is Adapter prefixed with the name of the service or // server. Ensure we can reach each object. // cout << "pinging server objects... " << flush; TestIntfPrx obj; obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**")); obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**")); obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**")); obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]")); obj = TestIntfPrx::checkedCast(comm->stringToProxy("IceBox1-Service2@IceBox1Service2Adapter")); obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]")); obj = TestIntfPrx::checkedCast(comm->stringToProxy("IceBox2-Service2@IceBox2Service2Adapter")); obj = TestIntfPrx::checkedCast( comm->stringToProxy("*****@*****.**")); cout << "ok" << endl; cout << "testing server configuration... " << flush; obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**")); test(obj->getProperty("Type") == "Server"); test(obj->getProperty("Name") == "Server1"); test(obj->getProperty("NameName") == "Server1Server1"); test(obj->getProperty("NameEscaped") == "${name}"); test(obj->getProperty("NameEscapeEscaped") == "$Server1"); test(obj->getProperty("NameEscapedEscapeEscaped") == "$${name}"); test(obj->getProperty("ManyEscape") == "$$$${name}"); test(obj->getProperty("TestServer1Identity") == "Server1"); test(obj->getProperty("LogFilePath") == "test-Server1.log"); test(obj->getProperty("LogFilePath-Server1") == "test.log"); test(obj->getProperty("PropertyWithSpaces") == " test "); // \ is escaped in C++ string literals test(obj->getProperty("WindowsPath") == "C:\\Program Files (x86)\\ZeroC\\"); test(obj->getProperty("UNCPath") == "\\\\server\\foo bar\\file"); test(obj->getProperty("PropertyWith=") == "foo=bar"); test(obj->getProperty("PropertyWithHash") == "foo#bar"); test(obj->getProperty("PropertyWithTab") == "foo\tbar"); test(obj->getProperty("PropertyWithEscapeSpace") == "foo\\ "); test(obj->getProperty("PropertyWithProperty") == "Plugin.EntryPoint=foo:bar --Ice.Config=\\\\\\server\\foo bar\\file.cfg"); cout << "ok" << endl; cout << "testing service configuration... " << flush; obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]")); test(obj->getProperty("Service1.Type") == "standard"); test(obj->getProperty("Service1.ServiceName") == "Service1"); test(obj->getProperty("TestService1Identity") == "IceBox1-Service1"); test(obj->getProperty("LogFilePath") == "test-Service1.log"); test(obj->getProperty("LogFilePath-Service1") == "test.log"); test(obj->getProperty("PropertyWithSpaces") == " test "); // \ is escaped in C++ string literals test(obj->getProperty("WindowsPath") == "C:\\Program Files (x86)\\ZeroC\\"); test(obj->getProperty("UNCPath") == "\\\\server\\foo bar\\file"); test(obj->getProperty("PropertyWith=") == "foo=bar"); test(obj->getProperty("PropertyWithHash") == "foo#bar"); test(obj->getProperty("PropertyWithTab") == "foo\tbar"); test(obj->getProperty("PropertyWithEscapeSpace") == "foo\\ "); test(obj->getProperty("PropertyWithProperty") == "Plugin.EntryPoint=foo:bar --Ice.Config=\\\\\\server\\foo bar\\file.cfg"); obj = TestIntfPrx::checkedCast(comm->stringToProxy("IceBox2-Service2@IceBox2Service2Adapter")); test(obj->getProperty("Service2.Type") == "nonstandard"); test(obj->getProperty("Service2.ServiceName") == "Service2"); test(obj->getProperty("Service2.DebugProperty") == ""); test(obj->getProperty("Service1.DebugProperty") == ""); cout << "ok" << endl; cout << "testing server options... " << flush; obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**")); test(obj->getProperty("Test.Test") == "2"); test(obj->getProperty("Test.Test1") == "0"); cout << "ok" << endl; cout << "testing variables... " << flush; vector<TestIntfPrx> proxies; obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**")); proxies.push_back(obj); obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]")); proxies.push_back(obj); obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**")); proxies.push_back(obj); obj = TestIntfPrx::checkedCast( comm->stringToProxy("*****@*****.**")); proxies.push_back(obj); for(vector<TestIntfPrx>::const_iterator p = proxies.begin(); p != proxies.end(); ++p) { test((*p)->getProperty("AppVarProp") == "AppVar"); test((*p)->getProperty("NodeVarProp") == "NodeVar"); test((*p)->getProperty("RecursiveAppVarProp") == "Test"); test((*p)->getProperty("AppVarOverridedProp") == "OverridedInNode"); test((*p)->getProperty("AppVarDefinedInNodeProp") == "localnode"); test((*p)->getProperty("EscapedAppVarProp") == "${escaped}"); test((*p)->getProperty("RecursiveEscapedAppVarProp") == "${escaped}"); test((*p)->getProperty("Recursive2EscapedAppVarProp") == "${escaped}"); test((*p)->getProperty("RecursiveNodeVarProp") == "localnode"); test((*p)->getProperty("TestDirProp") != "NotThisValue"); } cout << "ok" << endl; cout << "testing parameters... " << flush; obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**")); test(obj->getProperty("Param1Prop") == "Param1"); test(obj->getProperty("Param2Prop") == "AppVar"); test(obj->getProperty("ParamEscapedProp") == "${escaped}"); test(obj->getProperty("ParamDoubleEscapedProp") == "$escapedvalue"); test(obj->getProperty("AppVarOverridedByParamProp") == "Overrided"); test(obj->getProperty("NodeVarOverridedByParamProp") == "Test"); test(obj->getProperty("DefaultParamProp") == "VALUE"); obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**")); test(obj->getProperty("Param1Prop") == "Param12"); test(obj->getProperty("Param2Prop") == "OverridedInNode"); test(obj->getProperty("ParamEscapedProp") == "${escaped}"); test(obj->getProperty("ParamDoubleEscapedProp") == "$escapedvalue"); test(obj->getProperty("AppVarOverridedByParamProp") == "Overrided"); test(obj->getProperty("NodeVarOverridedByParamProp") == "Test"); test(obj->getProperty("DefaultParamProp") == "OTHERVALUE"); obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]")); test(obj->getProperty("AppVarOverridedByParamProp") == "Test"); test(obj->getProperty("NodeVarOverridedByParamProp") == "Overrided"); obj = TestIntfPrx::checkedCast(comm->stringToProxy("IceBox1-Service2@IceBox1Service2Adapter")); test(obj->getProperty("AppVarOverridedByParamProp") == "Test"); test(obj->getProperty("NodeVarOverridedByParamProp") == "Test"); obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]")); test(obj->getProperty("AppVarOverridedByParamProp") == "Test"); test(obj->getProperty("NodeVarOverridedByParamProp") == "Overrided"); obj = TestIntfPrx::checkedCast(comm->stringToProxy("IceBox2-Service2@IceBox2Service2Adapter")); test(obj->getProperty("AppVarOverridedByParamProp") == "Test"); test(obj->getProperty("NodeVarOverridedByParamProp") == "Test"); cout << "ok" << endl; cout << "testing descriptions... " << flush; // // NOTE: We can't test the following since // getApplicationDescriptor doesn't return the instantiated // application descriptor... // // ApplicationDescriptor desc = admin->getApplicationDescriptor("test"); // test(desc.description == "APP AppVar"); // test(desc.nodes["localnode"].description == "NODE NodeVar"); // test(desc.replicaGroups[0].description == "REPLICA GROUP AppVar"); // test(desc.nodes["localnode"].servers.size() == 2); // const int idx = desc.nodes["localnode"].servers[0]->id == "SimpleServer" ? 0 : 1; ServerInfo info = admin->getServerInfo("SimpleServer"); test(info.descriptor->id == "SimpleServer"); test(info.descriptor->description == "SERVER NodeVar"); test(info.descriptor->adapters[0].description == "ADAPTER NodeVar"); test(info.descriptor->dbEnvs[0].description == "DBENV NodeVar"); cout << "ok" << endl; cout << "testing property sets..." << flush; obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**")); test(obj->getProperty("AppProperty") == "AppVar"); test(obj->getProperty("AppProperty2") == "OverrideMe"); test(obj->getProperty("AppProperty21") == "Override"); test(obj->getProperty("NodeProperty") == "NodeVar"); obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**")); test(obj->getProperty("AppProperty") == "AppVar"); test(obj->getProperty("AppProperty2") == "OverrideMe"); test(obj->getProperty("AppProperty21") == "Override"); test(obj->getProperty("NodeProperty") == "NodeVar"); test(obj->getProperty("ServerInstanceProperty") == "Server2"); obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]")); test(obj->getProperty("AppProperty") == ""); // IceBox server properties aren't inherited for IceBox1 test(obj->getProperty("AppProperty2") == ""); test(obj->getProperty("AppProperty21") == ""); test(obj->getProperty("NodeProperty") == ""); obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]")); test(obj->getProperty("AppProperty") == "AppVar"); test(obj->getProperty("AppProperty2") == "OverrideMe"); test(obj->getProperty("AppProperty21") == "Override"); test(obj->getProperty("NodeProperty") == "NodeVar"); test(obj->getProperty("IceBoxInstanceProperty") == "IceBox2"); obj = TestIntfPrx::checkedCast(comm->stringToProxy("IceBox2-Service2@IceBox2Service2Adapter")); test(obj->getProperty("AppProperty") == "AppVar"); test(obj->getProperty("AppProperty2") == "OverrideMe"); test(obj->getProperty("AppProperty21") == "Override"); test(obj->getProperty("NodeProperty") == "NodeVar"); test(obj->getProperty("IceBoxInstanceProperty") == "IceBox2"); test(obj->getProperty("ServiceInstanceProperty") == "Service2"); obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**")); test(obj->getProperty("AppProperty") == "AppVar"); test(obj->getProperty("AppProperty2") == "OverrideMe"); test(obj->getProperty("AppProperty21") == "Override"); test(obj->getProperty("NodeProperty") == "NodeVar"); obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]")); test(obj->getProperty("ServerInstanceServiceProperty") == "service1"); obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]")); test(obj->getProperty("ServerInstanceServiceProperty") == "service4"); obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]")); test(obj->getProperty("IceBoxInstanceProperty") == "overriden"); cout << "ok" << endl; cout << "testing validation... " << flush; TemplateDescriptor templ; templ.parameters.push_back("name"); templ.parameters.push_back("nam3"); templ.parameters.push_back("nam2"); templ.parameters.push_back("nam3"); templ.descriptor = new ServerDescriptor(); ServerDescriptorPtr server = ServerDescriptorPtr::dynamicCast(templ.descriptor); server->id = "test"; server->exe = "${test.dir}/server"; server->applicationDistrib = false; server->allocatable = false; ApplicationDescriptor desc; desc.name = "App"; desc.serverTemplates["ServerTemplate"] = templ; try { admin->addApplication(desc); test(false); } catch(const DeploymentException& ex) { test(ex.reason.find("duplicate parameters") != string::npos); } catch(const Ice::Exception& ex) { cerr << ex << endl; test(false); } cout << "ok" << endl; logTests(comm, session); session->destroy(); }
int run(int, char* argv[], const CommunicatorPtr& communicator) { 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; } ObjectPrx base = communicator->stringToProxy(managerProxy); IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(base); if(!manager) { cerr << argv[0] << ": `" << managerProxy << "' is not running" << endl; return EXIT_FAILURE; } ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("SingleAdapter", "default:udp"); // // Test topic name that is too long // if(string(argv[1]) != "transient") { try { manager->create(string(512, 'A')); test(false); } catch(const Ice::UnknownException&) { } } TopicPrx topic; try { topic = manager->retrieve("single"); } catch(const IceStorm::NoSuchTopic& e) { cerr << argv[0] << ": NoSuchTopic: " << e.name << endl; return EXIT_FAILURE; } // // Test subscriber identity that is too long // if(string(argv[1]) != "transient") { try { Ice::ObjectPrx object = communicator->stringToProxy(string(512, 'A') + ":default -p 10000"); topic->subscribeAndGetPublisher(IceStorm::QoS(), object); test(false); } catch(const Ice::UnknownException&) { } } // // Create subscribers with different QoS. // vector<SingleIPtr> subscribers; vector<Ice::Identity> subscriberIdentities; { subscribers.push_back(new SingleI(communicator, "default")); Ice::ObjectPrx object = adapter->addWithUUID(subscribers.back())->ice_oneway(); subscriberIdentities.push_back(object->ice_getIdentity()); topic->subscribeAndGetPublisher(IceStorm::QoS(), object); } { subscribers.push_back(new SingleI(communicator, "oneway")); Ice::ObjectPrx object = adapter->addWithUUID(subscribers.back())->ice_oneway(); subscriberIdentities.push_back(object->ice_getIdentity()); topic->subscribeAndGetPublisher(IceStorm::QoS(), object); } { subscribers.push_back(new SingleI(communicator, "twoway")); Ice::ObjectPrx object = adapter->addWithUUID(subscribers.back()); subscriberIdentities.push_back(object->ice_getIdentity()); topic->subscribeAndGetPublisher(IceStorm::QoS(), object); } { subscribers.push_back(new SingleI(communicator, "batch")); Ice::ObjectPrx object = adapter->addWithUUID(subscribers.back())->ice_batchOneway(); subscriberIdentities.push_back(object->ice_getIdentity()); topic->subscribeAndGetPublisher(IceStorm::QoS(), object); } { subscribers.push_back(new SingleI(communicator, "twoway ordered")); // Ordered IceStorm::QoS qos; qos["reliability"] = "ordered"; Ice::ObjectPrx object = adapter->addWithUUID(subscribers.back()); subscriberIdentities.push_back(object->ice_getIdentity()); topic->subscribeAndGetPublisher(qos, object); } { // Use a separate adapter to ensure a separate connection is used for the subscriber // (otherwise, if multiple UDP subscribers use the same connection we might get high // packet loss, see bug 1784). ObjectAdapterPtr adpt = communicator->createObjectAdapterWithEndpoints("UdpAdapter3", "udp"); subscribers.push_back(new SingleI(communicator, "datagram")); Ice::ObjectPrx object = adpt->addWithUUID(subscribers.back())->ice_datagram(); subscriberIdentities.push_back(object->ice_getIdentity()); topic->subscribeAndGetPublisher(IceStorm::QoS(), object); adpt->activate(); } { // Use a separate adapter to ensure a separate connection is used for the subscriber // (otherwise, if multiple UDP subscribers use the same connection we might get high // packet loss, see bug 1784). ObjectAdapterPtr adpt = communicator->createObjectAdapterWithEndpoints("UdpAdapter4", "udp"); subscribers.push_back(new SingleI(communicator, "batch datagram")); Ice::ObjectPrx object = adpt->addWithUUID(subscribers.back())->ice_batchDatagram(); subscriberIdentities.push_back(object->ice_getIdentity()); topic->subscribeAndGetPublisher(IceStorm::QoS(), object); adpt->activate(); } adapter->activate(); vector<Ice::Identity> ids = topic->getSubscribers(); test(ids.size() == subscriberIdentities.size()); for(vector<Ice::Identity>::const_iterator i = ids.begin(); i != ids.end(); ++i) { test(find(subscriberIdentities.begin(), subscriberIdentities.end(), *i) != subscriberIdentities.end()); } for(vector<SingleIPtr>::const_iterator p = subscribers.begin(); p != subscribers.end(); ++p) { (*p)->waitForEvents(); } return EXIT_SUCCESS; }
void allTests(const Ice::CommunicatorPtr& communicator) { IceGrid::RegistryPrx registry = IceGrid::RegistryPrx::checkedCast( communicator->stringToProxy(communicator->getDefaultLocator()->ice_getIdentity().category + "/Registry")); test(registry); AdminSessionPrx session = registry->createAdminSession("foo", "bar"); session->ice_getConnection()->setACM(registry->getACMTimeout(), IceUtil::None, Ice::HeartbeatAlways); AdminPrx admin = session->getAdmin(); test(admin); cout << "starting router... " << flush; try { admin->startServer("Glacier2"); } catch(const ServerStartException& ex) { cerr << ex.reason << endl; test(false); } cout << "ok" << endl; const int allocationTimeout = 5000; Ice::ObjectPrx obj; Ice::ObjectPrx dummy; try { cout << "testing create session... " << flush; SessionPrx session1 = registry->createSession("Client1", ""); SessionPrx session2 = registry->createSession("Client2", ""); cout << "ok" << endl; cout << "testing allocate object by identity... " << flush; Ice::Identity allocatable = Ice::stringToIdentity("allocatable"); Ice::Identity allocatablebis = Ice::stringToIdentity("allocatablebis"); try { session1->allocateObjectById(Ice::stringToIdentity("dummy")); } catch(const ObjectNotRegisteredException&) { } try { session1->releaseObject(Ice::stringToIdentity("dummy")); } catch(const ObjectNotRegisteredException&) { } try { session1->allocateObjectById(Ice::stringToIdentity("nonallocatable")); test(false); } catch(const AllocationException&) { test(false); } catch(const ObjectNotRegisteredException&) { } try { session2->allocateObjectById(Ice::stringToIdentity("nonallocatable")); test(false); } catch(const AllocationException&) { test(false); } catch(const ObjectNotRegisteredException&) { } try { session1->releaseObject(Ice::stringToIdentity("nonallocatable")); test(false); } catch(const AllocationException&) { test(false); } catch(const ObjectNotRegisteredException&) { } try { session2->releaseObject(Ice::stringToIdentity("nonallocatable")); test(false); } catch(const AllocationException&) { test(false); } catch(const ObjectNotRegisteredException&) { } session1->allocateObjectById(allocatable); try { session1->allocateObjectById(allocatable); test(false); } catch(const AllocationException&) { } session1->setAllocationTimeout(0); session2->setAllocationTimeout(0); try { session2->allocateObjectById(allocatable); test(false); } catch(const AllocationTimeoutException&) { } try { session2->releaseObject(allocatable); test(false); } catch(const AllocationException&) { } session1->allocateObjectById(allocatablebis); try { session2->allocateObjectById(allocatablebis); test(false); } catch(const AllocationTimeoutException&) { } session1->releaseObject(allocatablebis); session2->allocateObjectById(allocatablebis); try { session1->allocateObjectById(allocatablebis); test(false); } catch(const AllocationTimeoutException&) { } session2->releaseObject(allocatablebis); session2->setAllocationTimeout(allocationTimeout); CallbackPtr asyncCB1 = new Callback(); IceGrid::Callback_Session_allocateObjectByIdPtr cb1 = IceGrid::newCallback_Session_allocateObjectById(asyncCB1, &Callback::response, &Callback::exception); session2->begin_allocateObjectById(allocatable, cb1); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!asyncCB1->hasResponse(dummy)); session1->releaseObject(allocatable); asyncCB1->waitResponse(__FILE__, __LINE__); test(asyncCB1->hasResponse(dummy)); session1->setAllocationTimeout(0); try { session1->allocateObjectById(allocatable); test(false); } catch(const AllocationTimeoutException&) { } try { session1->releaseObject(allocatable); test(false); } catch(const AllocationException&) { } session1->setAllocationTimeout(allocationTimeout); asyncCB1 = new Callback(); cb1 = IceGrid::newCallback_Session_allocateObjectById(asyncCB1, &Callback::response, &Callback::exception); session1->begin_allocateObjectById(allocatable, cb1); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!asyncCB1->hasResponse(dummy)); session2->releaseObject(allocatable); asyncCB1->waitResponse(__FILE__, __LINE__); test(asyncCB1->hasResponse(dummy)); session1->releaseObject(allocatable); cout << "ok" << endl; cout << "testing allocate object by type... " << flush; session1->setAllocationTimeout(0); session2->setAllocationTimeout(0); try { obj = session1->allocateObjectByType("::Unknown"); test(false); } catch(const AllocationTimeoutException&) { test(false); } catch(const AllocationException&) { } try { obj = session1->allocateObjectByType("::NotAllocatable"); test(false); } catch(const AllocationTimeoutException&) { test(false); } catch(const AllocationException&) { } obj = session1->allocateObjectByType("::Test"); test(obj && obj->ice_getIdentity().name == "allocatable"); try { session1->allocateObjectByType("::Test"); test(false); } catch(const AllocationException&) { } try { session2->allocateObjectByType("::Test"); test(false); } catch(const AllocationTimeoutException&) { } try { session2->releaseObject(obj->ice_getIdentity()); } catch(const AllocationException&) { } session1->releaseObject(obj->ice_getIdentity()); try { session1->releaseObject(obj->ice_getIdentity()); } catch(const AllocationException&) { } obj = session2->allocateObjectByType("::Test"); // Allocate the object test(obj && obj->ice_getIdentity().name == "allocatable"); try { session2->allocateObjectByType("::Test"); test(false); } catch(const AllocationException&) { } try { session1->allocateObjectByType("::Test"); test(false); } catch(const AllocationTimeoutException&) { } session1->allocateObjectByType("::TestBis"); try { session2->allocateObjectByType("::TestBis"); test(false); } catch(const AllocationTimeoutException&) { } session1->releaseObject(allocatablebis); session2->allocateObjectByType("::TestBis"); try { session1->allocateObjectByType("::TestBis"); test(false); } catch(const AllocationTimeoutException&) { } session2->releaseObject(allocatablebis); session1->setAllocationTimeout(allocationTimeout); CallbackPtr asyncCB3 = new Callback(); IceGrid::Callback_Session_allocateObjectByTypePtr cb3 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB3, &Callback::response, &Callback::exception); session1->begin_allocateObjectByType("::Test", cb3); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!asyncCB3->hasResponse(dummy)); session2->releaseObject(obj->ice_getIdentity()); asyncCB3->waitResponse(__FILE__, __LINE__); test(asyncCB3->hasResponse(obj)); session1->releaseObject(obj->ice_getIdentity()); cout << "ok" << endl; cout << "testing object allocation timeout... " << flush; session1->allocateObjectById(allocatable); IceUtil::Time time = IceUtil::Time::now(); session2->setAllocationTimeout(500); try { session2->allocateObjectById(allocatable); test(false); } catch(const AllocationTimeoutException&) { test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now()); } time = IceUtil::Time::now(); try { session2->allocateObjectById(allocatable); test(false); } catch(const AllocationTimeoutException&) { } test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now()); time = IceUtil::Time::now(); try { session2->allocateObjectByType("::Test"); test(false); } catch(const AllocationTimeoutException&) { } test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now()); session1->releaseObject(allocatable); session2->setAllocationTimeout(0); cout << "ok" << endl; cout << "testing server allocation... " << flush; session1->setAllocationTimeout(0); session2->setAllocationTimeout(0); Ice::Identity allocatable3 = Ice::stringToIdentity("allocatable3"); Ice::Identity allocatable4 = Ice::stringToIdentity("allocatable4"); session1->allocateObjectById(allocatable3); try { session2->allocateObjectById(allocatable3); test(false); } catch(const AllocationTimeoutException&) { } try { session2->allocateObjectById(allocatable4); test(false); } catch(const AllocationTimeoutException&) { } session1->allocateObjectById(allocatable4); session1->releaseObject(allocatable3); try { session2->allocateObjectById(allocatable3); test(false); } catch(const AllocationTimeoutException&) { } session1->releaseObject(allocatable4); session2->allocateObjectById(allocatable3); try { session1->allocateObjectById(allocatable3); test(false); } catch(const AllocationTimeoutException&) { } try { session1->allocateObjectById(allocatable4); test(false); } catch(const AllocationTimeoutException&) { } session2->allocateObjectById(allocatable4); session2->releaseObject(allocatable3); try { session1->allocateObjectById(allocatable3); test(false); } catch(const AllocationTimeoutException&) { } try { session1->allocateObjectByType("::TestServer1"); test(false); } catch(const AllocationException&) { } try { session1->allocateObjectByType("::TestServer2"); test(false); } catch(const AllocationException&) { } test(session2->allocateObjectByType("::TestServer1")); try { session2->allocateObjectByType("::TestServer1"); test(false); } catch(const AllocationException&) { } try { session2->allocateObjectByType("::TestServer2"); test(false); } catch(const AllocationException&) { } session2->releaseObject(allocatable3); session2->releaseObject(allocatable4); session1->allocateObjectById(allocatable3); session1->allocateObjectById(allocatable4); session2->setAllocationTimeout(allocationTimeout); asyncCB1 = new Callback(); cb1 = IceGrid::newCallback_Session_allocateObjectById(asyncCB1, &Callback::response, &Callback::exception); session2->begin_allocateObjectById(allocatable3, cb1); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!asyncCB1->hasResponse(dummy)); session1->releaseObject(allocatable3); test(!asyncCB1->hasResponse(dummy)); session1->releaseObject(allocatable4); asyncCB1->waitResponse(__FILE__, __LINE__); test(asyncCB1->hasResponse(dummy)); session2->releaseObject(allocatable3); session1->setAllocationTimeout(allocationTimeout); test(session2->allocateObjectByType("::TestServer1")); asyncCB3 = new Callback(); cb3 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB3, &Callback::response, &Callback::exception); session1->begin_allocateObjectByType("::TestServer2", cb3); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!asyncCB3->hasResponse(dummy)); session2->releaseObject(allocatable3); asyncCB3->waitResponse(__FILE__, __LINE__); test(asyncCB3->hasResponse(dummy)); session1->releaseObject(allocatable4); session1->setAllocationTimeout(0); session2->setAllocationTimeout(0); test(session1->allocateObjectByType("::TestMultipleByServer")); try { session2->allocateObjectByType("::TestMultipleByServer"); test(false); } catch(const AllocationException&) { } test(session1->allocateObjectByType("::TestMultipleByServer")); session1->releaseObject(Ice::stringToIdentity("allocatable31")); session1->releaseObject(Ice::stringToIdentity("allocatable41")); test(session2->allocateObjectByType("::TestMultipleByServer")); try { session1->allocateObjectByType("::TestMultipleByServer"); test(false); } catch(const AllocationException&) { } test(session2->allocateObjectByType("::TestMultipleByServer")); session2->releaseObject(Ice::stringToIdentity("allocatable31")); session2->releaseObject(Ice::stringToIdentity("allocatable41")); Ice::ObjectPrx obj1 = session1->allocateObjectByType("::TestMultipleServer"); test(obj1); Ice::ObjectPrx obj2 = session2->allocateObjectByType("::TestMultipleServer"); test(obj2); try { session1->allocateObjectByType("::TestMultipleServer"); test(false); } catch(const AllocationTimeoutException&) { } try { session2->allocateObjectByType("::TestMultipleServer"); test(false); } catch(const AllocationTimeoutException&) { } session1->releaseObject(obj1->ice_getIdentity()); obj1 = session2->allocateObjectByType("::TestMultipleServer"); session2->releaseObject(obj1->ice_getIdentity()); session2->releaseObject(obj2->ice_getIdentity()); cout << "ok" << endl; cout << "testing concurrent allocations... " << flush; session1->setAllocationTimeout(allocationTimeout); session2->setAllocationTimeout(allocationTimeout); session2->allocateObjectById(allocatable); CallbackPtr asyncCB11 = new Callback(); IceGrid::Callback_Session_allocateObjectByIdPtr cb11 = IceGrid::newCallback_Session_allocateObjectById(asyncCB11, &Callback::response, &Callback::exception); CallbackPtr asyncCB12 = new Callback(); IceGrid::Callback_Session_allocateObjectByIdPtr cb12 = IceGrid::newCallback_Session_allocateObjectById(asyncCB12, &Callback::response, &Callback::exception); session1->begin_allocateObjectById(allocatable, cb11); session1->begin_allocateObjectById(allocatable, cb12); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!asyncCB11->hasResponse(dummy)); test(!asyncCB12->hasResponse(dummy)); session2->releaseObject(allocatable); asyncCB11->waitResponse(__FILE__, __LINE__); asyncCB12->waitResponse(__FILE__, __LINE__); test(asyncCB11->hasResponse(dummy) ? asyncCB12->hasException() : asyncCB12->hasResponse(dummy)); test(asyncCB12->hasResponse(dummy) ? asyncCB11->hasException() : asyncCB11->hasResponse(dummy)); session1->releaseObject(allocatable); session2->allocateObjectById(allocatable); CallbackPtr asyncCB31 = new Callback(); IceGrid::Callback_Session_allocateObjectByTypePtr cb31 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB31, &Callback::response, &Callback::exception); CallbackPtr asyncCB32 = new Callback(); IceGrid::Callback_Session_allocateObjectByTypePtr cb32 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB32, &Callback::response, &Callback::exception); session1->begin_allocateObjectByType("::Test", cb31); session1->begin_allocateObjectByType("::Test", cb32); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!asyncCB31->hasResponse(dummy)); test(!asyncCB32->hasResponse(dummy)); session2->releaseObject(allocatable); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); do { IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200)); } while(!asyncCB31->hasResponse(dummy) && !asyncCB32->hasResponse(dummy)); test((asyncCB31->hasResponse(dummy) && dummy && !asyncCB32->hasResponse(dummy)) || (asyncCB32->hasResponse(dummy) && dummy && !asyncCB31->hasResponse(dummy))); session1->releaseObject(allocatable); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); CallbackPtr asyncCB33 = asyncCB31->hasResponse(dummy) ? asyncCB32 : asyncCB31; asyncCB33->waitResponse(__FILE__, __LINE__); test(asyncCB33->hasResponse(dummy) && dummy); session1->releaseObject(allocatable); session2->allocateObjectById(allocatable3); asyncCB11 = new Callback(); cb11 = IceGrid::newCallback_Session_allocateObjectById(asyncCB11, &Callback::response, &Callback::exception); asyncCB12 = new Callback(); cb12 = IceGrid::newCallback_Session_allocateObjectById(asyncCB12, &Callback::response, &Callback::exception); session1->begin_allocateObjectById(allocatable3, cb11); session1->begin_allocateObjectById(allocatable3, cb12); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!asyncCB11->hasResponse(dummy)); test(!asyncCB12->hasResponse(dummy)); session2->releaseObject(allocatable3); asyncCB11->waitResponse(__FILE__, __LINE__); asyncCB12->waitResponse(__FILE__, __LINE__); test(asyncCB11->hasResponse(dummy) ? asyncCB12->hasException() : asyncCB12->hasResponse(dummy)); test(asyncCB12->hasResponse(dummy) ? asyncCB11->hasException() : asyncCB11->hasResponse(dummy)); session1->releaseObject(allocatable3); session2->allocateObjectById(allocatable3); asyncCB31 = new Callback(); cb31 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB31, &Callback::response, &Callback::exception); asyncCB32 = new Callback(); cb32 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB32, &Callback::response, &Callback::exception); session1->begin_allocateObjectByType("::TestServer1", cb31); session1->begin_allocateObjectByType("::TestServer1", cb32); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!asyncCB31->hasResponse(dummy)); test(!asyncCB32->hasResponse(dummy)); session2->releaseObject(allocatable3); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); do { IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200)); } while(!asyncCB31->hasResponse(dummy) && !asyncCB32->hasResponse(dummy)); test((asyncCB31->hasResponse(dummy) && dummy && !asyncCB32->hasResponse(dummy)) || (asyncCB32->hasResponse(dummy) && dummy && !asyncCB31->hasResponse(dummy))); session1->releaseObject(allocatable3); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); asyncCB33 = asyncCB31->hasResponse(dummy) ? asyncCB32 : asyncCB31; asyncCB33->waitResponse(__FILE__, __LINE__); test(asyncCB33->hasResponse(dummy) && dummy); session1->releaseObject(allocatable3); session1->allocateObjectById(allocatable3); asyncCB31 = new Callback(); cb31 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB31, &Callback::response, &Callback::exception); asyncCB32 = new Callback(); cb32 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB32, &Callback::response, &Callback::exception); session1->begin_allocateObjectByType("::TestServer1", cb31); session1->begin_allocateObjectByType("::TestServer1", cb32); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!asyncCB31->hasResponse(dummy)); test(!asyncCB32->hasResponse(dummy)); session1->releaseObject(allocatable3); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); do { IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200)); } while(!asyncCB31->hasResponse(dummy) && !asyncCB32->hasResponse(dummy)); test((asyncCB31->hasResponse(dummy) && dummy && !asyncCB32->hasResponse(dummy)) || (asyncCB32->hasResponse(dummy) && dummy && !asyncCB31->hasResponse(dummy))); session1->releaseObject(allocatable3); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); asyncCB33 = asyncCB31->hasResponse(dummy) ? asyncCB32 : asyncCB31; asyncCB33->waitResponse(__FILE__, __LINE__); test(asyncCB33->hasResponse(dummy) && dummy); session1->releaseObject(allocatable3); cout << "ok" << endl; cout << "testing session destroy... " << flush; obj = session2->allocateObjectByType("::Test"); // Allocate the object test(obj && obj->ice_getIdentity().name == "allocatable"); session1->setAllocationTimeout(allocationTimeout); asyncCB3 = new Callback(); cb3 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB3, &Callback::response, &Callback::exception); session1->begin_allocateObjectByType("::Test", cb3); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!asyncCB3->hasResponse(dummy)); session2->destroy(); asyncCB3->waitResponse(__FILE__, __LINE__); test(asyncCB3->hasResponse(obj)); session1->destroy(); session2 = SessionPrx::uncheckedCast(registry->createSession("Client2", "")); session2->setAllocationTimeout(0); session2->allocateObjectById(allocatable); session2->destroy(); cout << "ok" << endl; cout << "testing application updates with allocated objects... " << flush; { SessionPrx session1 = registry->createSession("Client1", ""); SessionPrx session2 = registry->createSession("Client2", ""); ServerDescriptorPtr objectAllocOriginal = admin->getServerInfo("ObjectAllocation").descriptor; ServerDescriptorPtr objectAllocUpdate = ServerDescriptorPtr::dynamicCast(objectAllocOriginal->ice_clone()); ServerDescriptorPtr serverAllocOriginal = admin->getServerInfo("ServerAllocation").descriptor; ServerDescriptorPtr serverAllocUpdate = ServerDescriptorPtr::dynamicCast(serverAllocOriginal->ice_clone()); NodeUpdateDescriptor nodeUpdate; nodeUpdate.name = "localnode"; nodeUpdate.servers.push_back(objectAllocUpdate); nodeUpdate.servers.push_back(serverAllocUpdate); ApplicationUpdateDescriptor appUpdate; appUpdate.name = "Test"; appUpdate.nodes.push_back(nodeUpdate); { session1->allocateObjectById(allocatable3); Ice::AsyncResultPtr r2 = session2->begin_allocateObjectById(allocatable4); session1->allocateObjectById(allocatable4); session1->releaseObject(allocatable4); test(!r2->isCompleted()); serverAllocUpdate->allocatable = false; admin->updateApplication(appUpdate); test(!r2->isCompleted()); session1->releaseObject(allocatable3); session2->end_allocateObjectById(r2); session2->releaseObject(allocatable4); serverAllocUpdate->allocatable = true; admin->updateApplication(appUpdate); } { session1->allocateObjectById(allocatable); Ice::AsyncResultPtr r2 = session2->begin_allocateObjectById(allocatable); objectAllocUpdate->deactivationTimeout = "23"; admin->updateApplication(appUpdate); session1->releaseObject(allocatable); session2->end_allocateObjectById(r2); session2->releaseObject(allocatable); } { session1->allocateObjectById(allocatable); Ice::AsyncResultPtr r2 = session2->begin_allocateObjectById(allocatable); vector<ObjectDescriptor> allocatables = objectAllocUpdate->adapters[0].allocatables; objectAllocUpdate->adapters[0].allocatables.clear(); // Remove the allocatable object admin->updateApplication(appUpdate); try { session2->end_allocateObjectById(r2); test(false); } catch(const ObjectNotRegisteredException&) { } try { session1->releaseObject(allocatable); test(false); } catch(const ObjectNotRegisteredException&) { } objectAllocUpdate->adapters[0].allocatables = allocatables; admin->updateApplication(appUpdate); } session1->destroy(); session2->destroy(); } cout << "ok" << endl; cout << "testing allocation with Glacier2 session... " << flush; Ice::ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:default -p 12347"); Glacier2::RouterPrx router1 = Glacier2::RouterPrx::checkedCast(routerBase->ice_connectionId("client1")); test(router1); Glacier2::SessionPrx sessionBase = router1->createSession("test1", "abc123"); try { session1 = IceGrid::SessionPrx::checkedCast(sessionBase->ice_connectionId("client1")->ice_router(router1)); test(session1); session1->ice_ping(); Ice::ObjectPrx obj; obj = session1->allocateObjectById(allocatable)->ice_connectionId("client1")->ice_router(router1); obj->ice_ping(); session1->releaseObject(allocatable); try { obj->ice_ping(); } catch(const Ice::ObjectNotExistException&) { } obj = session1->allocateObjectById(allocatable3)->ice_connectionId("client1")->ice_router(router1); obj->ice_ping(); obj2 = communicator->stringToProxy("allocatable4")->ice_connectionId("client1")->ice_router(router1); obj2->ice_ping(); session1->releaseObject(allocatable3); try { obj->ice_ping(); } catch(const Ice::ObjectNotExistException&) { } try { obj2->ice_ping(); } catch(const Ice::ObjectNotExistException&) { } session1->destroy(); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } cout << "ok" << endl; cout << "stress test... " << flush; SessionPrx stressSession = registry->createSession("StressSession", ""); const int nClients = 10; int i; vector<StressClientPtr> clients; for(i = 0; i < nClients - 2; ++i) { if(IceUtilInternal::random(2) == 1) { clients.push_back(new StressClient(i, registry, false)); } else { clients.push_back(new StressClient(i, stressSession)); } clients.back()->start(); } clients.push_back(new StressClient(i++, registry, true)); clients.back()->start(); clients.push_back(new StressClient(i++, registry, true)); clients.back()->start(); for(vector<StressClientPtr>::const_iterator p = clients.begin(); p != clients.end(); ++p) { (*p)->notifyThread(); } // // Let the stress client run for a bit. // IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(8)); // // Terminate the stress clients. // for(vector<StressClientPtr>::const_iterator q = clients.begin(); q != clients.end(); ++q) { (*q)->terminate(); (*q)->getThreadControl().join(); } stressSession->destroy(); cout << "ok" << endl; } catch(const AllocationTimeoutException& ex) { cerr << ex << endl; test(false); } catch(const AllocationException& ex) { cerr << ex.reason << endl; test(false); } catch(const DeploymentException& ex) { cerr << ex.reason << endl; test(false); } cout << "shutting down router... " << flush; admin->stopServer("Glacier2"); cout << "ok" << endl; session->destroy(); }
virtual void run() { { Lock sync(*this); while(!_notified) { wait(); } } SessionPrx session; while(true) { { Lock sync(*this); if(_terminated) { if(!_session && session) { session->destroy(); } return; } } if(!session) { ostringstream os; os << "Client-" << _id; if(_session) { session = _session; } else { session = _registry->createSession(os.str(), ""); session->setAllocationTimeout(IceUtilInternal::random(200)); // 200ms timeout } } assert(session); session->keepAlive(); Ice::ObjectPrx object; switch(IceUtilInternal::random(_destroySession ? 4 : 2)) { case 0: object = allocate(session); break; case 1: object = allocateByType(session); break; case 2: assert(!_session); allocateAndDestroy(session); session = 0; break; case 3: assert(!_session); allocateByTypeAndDestroy(session); session = 0; break; } if(object) { IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(IceUtilInternal::random(20))); switch(IceUtilInternal::random(_destroySession ? 2 : 1)) { case 0: session->releaseObject(object->ice_getIdentity()); break; case 1: assert(!_session); session->destroy(); session = 0; break; } } } }
Ice::ObjectPrx TopicImpl::subscribeAndGetPublisher(const QoS& qos, const Ice::ObjectPrx& obj) { Ice::Identity id = obj->ice_getIdentity(); TraceLevelsPtr traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); out << _name << ": subscribeAndGetPublisher: " << _instance->communicator()->identityToString(id); if(traceLevels->topic > 1) { out << " endpoints: " << IceStormInternal::describeEndpoints(obj) << " QoS: "; for(QoS::const_iterator p = qos.begin(); p != qos.end() ; ++p) { if(p != qos.begin()) { out << ','; } } out << " subscriptions: "; trace(out, _instance, _subscribers); } } IceUtil::Mutex::Lock sync(_subscribersMutex); SubscriberRecord record; record.id = id; record.obj = obj; record.theQoS = qos; record.topicName = _name; record.link = false; record.cost = 0; vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), record.id); if(p != _subscribers.end()) { throw AlreadySubscribed(); } LogUpdate llu; SubscriberPtr subscriber = Subscriber::create(_instance, record); for(;;) { try { DatabaseConnectionPtr connection = _connectionPool->newConnection(); TransactionHolder txn(connection); SubscriberRecordKey key; key.topic = _id; key.id = subscriber->id(); SubscribersWrapperPtr subscribersWrapper = _connectionPool->getSubscribers(connection); subscribersWrapper->put(key, record); LLUWrapperPtr lluWrapper = _connectionPool->getLLU(connection); llu = lluWrapper->get(); llu.iteration++; lluWrapper->put(llu); txn.commit(); break; } catch(const DeadlockException&) { continue; } catch(const DatabaseException& ex) { halt(_instance->communicator(), ex); } } _subscribers.push_back(subscriber); _instance->observers()->addSubscriber(llu, _name, record); return subscriber->proxy(); }
void TopicImpl::subscribe(const QoS& origQoS, const Ice::ObjectPrx& obj) { Ice::Identity id = obj->ice_getIdentity(); TraceLevelsPtr traceLevels = _instance->traceLevels(); QoS qos = origQoS; if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); out << _name << ": subscribe: " << _instance->communicator()->identityToString(id); if(traceLevels->topic > 1) { out << " endpoints: " << IceStormInternal::describeEndpoints(obj) << " QoS: "; for(QoS::const_iterator p = qos.begin(); p != qos.end() ; ++p) { if(p != qos.begin()) { out << ','; } out << '[' << p->first << "," << p->second << ']'; } out << " subscriptions: "; trace(out, _instance, _subscribers); } } string reliability = "oneway"; { QoS::iterator p = qos.find("reliability"); if(p != qos.end()) { reliability = p->second; qos.erase(p); } } Ice::ObjectPrx newObj = obj; if(reliability == "batch") { if(newObj->ice_isDatagram()) { newObj = newObj->ice_batchDatagram(); } else { newObj = newObj->ice_batchOneway(); } } else if(reliability == "twoway") { newObj = newObj->ice_twoway(); } else if(reliability == "twoway ordered") { qos["reliability"] = "ordered"; newObj = newObj->ice_twoway(); } else // reliability == "oneway" { if(reliability != "oneway" && traceLevels->subscriber > 0) { Ice::Trace out(traceLevels->logger, traceLevels->subscriberCat); out << reliability <<" mode not understood."; } if(!newObj->ice_isDatagram()) { newObj = newObj->ice_oneway(); } } IceUtil::Mutex::Lock sync(_subscribersMutex); SubscriberRecord record; record.id = id; record.obj = newObj; record.theQoS = qos; record.topicName = _name; record.link = false; record.cost = 0; LogUpdate llu; vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), record.id); if(p != _subscribers.end()) { // If we already have this subscriber remove it from our // subscriber list and remove it from the database. (*p)->destroy(); _subscribers.erase(p); for(;;) { try { DatabaseConnectionPtr connection = _connectionPool->newConnection(); TransactionHolder txn(connection); SubscriberRecordKey key; key.topic = _id; key.id = record.id; SubscribersWrapperPtr subscribersWrapper = _connectionPool->getSubscribers(connection); subscribersWrapper->erase(key); LLUWrapperPtr lluWrapper = _connectionPool->getLLU(connection); llu = lluWrapper->get(); llu.iteration++; lluWrapper->put(llu); txn.commit(); break; } catch(const DeadlockException&) { continue; } catch(const DatabaseException& ex) { halt(_instance->communicator(), ex); } } Ice::IdentitySeq ids; ids.push_back(id); _instance->observers()->removeSubscriber(llu, _name, ids); } SubscriberPtr subscriber = Subscriber::create(_instance, record); for(;;) { try { DatabaseConnectionPtr connection = _connectionPool->newConnection(); TransactionHolder txn(connection); SubscriberRecordKey key; key.topic = _id; key.id = subscriber->id(); SubscribersWrapperPtr subscribersWrapper = _connectionPool->getSubscribers(connection); subscribersWrapper->put(key, record); // Update the LLU. LLUWrapperPtr lluWrapper = _connectionPool->getLLU(connection); llu = lluWrapper->get(); llu.iteration++; lluWrapper->put(llu); txn.commit(); break; } catch(const DeadlockException&) { continue; } catch(const DatabaseException& ex) { halt(_instance->communicator(), ex); } } _subscribers.push_back(subscriber); _instance->observers()->addSubscriber(llu, _name, record); }
SubscriberPtr Subscriber::create( const InstancePtr& instance, const SubscriberRecord& rec) { if(rec.link) { return new SubscriberLink(instance, rec); } else { PerSubscriberPublisherIPtr per = new PerSubscriberPublisherI(instance); Ice::Identity perId; perId.category = instance->instanceName(); perId.name = "topic." + rec.topicName + ".publish." + instance->communicator()->identityToString(rec.obj->ice_getIdentity()); Ice::ObjectPrx proxy = instance->publishAdapter()->add(per, perId); TraceLevelsPtr traceLevels = instance->traceLevels(); SubscriberPtr subscriber; try { int retryCount = 0; QoS::const_iterator p = rec.theQoS.find("retryCount"); if(p != rec.theQoS.end()) { retryCount = atoi(p->second.c_str()); } string reliability; p = rec.theQoS.find("reliability"); if(p != rec.theQoS.end()) { reliability = p->second; } if(!reliability.empty() && reliability != "ordered") { throw BadQoS("invalid reliability: " + reliability); } // // Override the timeout. // Ice::ObjectPrx newObj; try { newObj = rec.obj->ice_timeout(instance->sendTimeout()); } catch(const Ice::FixedProxyException&) { // // In the event IceStorm is collocated this could be a // fixed proxy in which case its not possible to set the // timeout. // newObj = rec.obj; } if(reliability == "ordered") { if(!newObj->ice_isTwoway()) { throw BadQoS("ordered reliability requires a twoway proxy"); } subscriber = new SubscriberTwoway(instance, rec, proxy, retryCount, 1, newObj); } else if(newObj->ice_isOneway() || newObj->ice_isDatagram()) { if(retryCount > 0) { throw BadQoS("non-zero retryCount QoS requires a twoway proxy"); } subscriber = new SubscriberOneway(instance, rec, proxy, retryCount, newObj); } else if(newObj->ice_isBatchOneway() || newObj->ice_isBatchDatagram()) { if(retryCount > 0) { throw BadQoS("non-zero retryCount QoS requires a twoway proxy"); } subscriber = new SubscriberBatch(instance, rec, proxy, retryCount, newObj); } else //if(newObj->ice_isTwoway()) { assert(newObj->ice_isTwoway()); subscriber = new SubscriberTwoway(instance, rec, proxy, retryCount, 5, newObj); } per->setSubscriber(subscriber); } catch(const Ice::Exception&) { instance->publishAdapter()->remove(proxy->ice_getIdentity()); throw; } return subscriber; } }
void allTests(const Ice::CommunicatorPtr& communicator) { SessionKeepAliveThreadPtr keepAlive = new SessionKeepAliveThread( communicator->getLogger(), IceUtil::Time::seconds(5)); keepAlive->start(); RegistryPrx registry = IceGrid::RegistryPrx::checkedCast(communicator->stringToProxy("IceGrid/Registry")); test(registry); AdminSessionPrx session = registry->createAdminSession("foo", "bar"); keepAlive->add(session); AdminPrx admin = session->getAdmin(); test(admin); cout << "starting router... " << flush; try { admin->startServer("Glacier2"); } catch(const ServerStartException& ex) { cerr << ex.reason << endl; test(false); } cout << "ok" << endl; const int allocationTimeout = 5000; Ice::ObjectPrx obj; Ice::ObjectPrx dummy; try { cout << "testing create session... " << flush; SessionPrx session1 = registry->createSession("Client1", ""); SessionPrx session2 = registry->createSession("Client2", ""); keepAlive->add(session1); keepAlive->add(session2); cout << "ok" << endl; cout << "testing allocate object by identity... " << flush; Ice::Identity allocatable = communicator->stringToIdentity("allocatable"); Ice::Identity allocatablebis = communicator->stringToIdentity("allocatablebis"); try { session1->allocateObjectById(communicator->stringToIdentity("dummy")); } catch(const ObjectNotRegisteredException&) { } try { session1->releaseObject(communicator->stringToIdentity("dummy")); } catch(const ObjectNotRegisteredException&) { } try { session1->allocateObjectById(communicator->stringToIdentity("nonallocatable")); test(false); } catch(const AllocationException&) { test(false); } catch(const ObjectNotRegisteredException&) { } try { session2->allocateObjectById(communicator->stringToIdentity("nonallocatable")); test(false); } catch(const AllocationException&) { test(false); } catch(const ObjectNotRegisteredException&) { } try { session1->releaseObject(communicator->stringToIdentity("nonallocatable")); test(false); } catch(const AllocationException&) { test(false); } catch(const ObjectNotRegisteredException&) { } try { session2->releaseObject(communicator->stringToIdentity("nonallocatable")); test(false); } catch(const AllocationException&) { test(false); } catch(const ObjectNotRegisteredException&) { } session1->allocateObjectById(allocatable); try { session1->allocateObjectById(allocatable); test(false); } catch(const AllocationException&) { } session1->setAllocationTimeout(0); session2->setAllocationTimeout(0); try { session2->allocateObjectById(allocatable); test(false); } catch(const AllocationTimeoutException&) { } try { session2->releaseObject(allocatable); test(false); } catch(const AllocationException&) { } session1->allocateObjectById(allocatablebis); try { session2->allocateObjectById(allocatablebis); test(false); } catch(const AllocationTimeoutException&) { } session1->releaseObject(allocatablebis); session2->allocateObjectById(allocatablebis); try { session1->allocateObjectById(allocatablebis); test(false); } catch(const AllocationTimeoutException&) { } session2->releaseObject(allocatablebis); session2->setAllocationTimeout(allocationTimeout); AllocateObjectByIdCallbackPtr cb1 = new AllocateObjectByIdCallback(); session2->allocateObjectById_async(cb1, allocatable); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!cb1->hasResponse(dummy)); session1->releaseObject(allocatable); cb1->waitResponse(__FILE__, __LINE__); test(cb1->hasResponse(dummy)); session1->setAllocationTimeout(0); try { session1->allocateObjectById(allocatable); test(false); } catch(const AllocationTimeoutException&) { } try { session1->releaseObject(allocatable); test(false); } catch(const AllocationException&) { } session1->setAllocationTimeout(allocationTimeout); cb1 = new AllocateObjectByIdCallback(); session1->allocateObjectById_async(cb1, allocatable); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!cb1->hasResponse(dummy)); session2->releaseObject(allocatable); cb1->waitResponse(__FILE__, __LINE__); test(cb1->hasResponse(dummy)); session1->releaseObject(allocatable); cout << "ok" << endl; cout << "testing allocate object by type... " << flush; session1->setAllocationTimeout(0); session2->setAllocationTimeout(0); try { obj = session1->allocateObjectByType("::Unknown"); test(false); } catch(const AllocationTimeoutException&) { test(false); } catch(const AllocationException&) { } try { obj = session1->allocateObjectByType("::NotAllocatable"); test(false); } catch(const AllocationTimeoutException&) { test(false); } catch(const AllocationException&) { } obj = session1->allocateObjectByType("::Test"); test(obj && obj->ice_getIdentity().name == "allocatable"); try { session1->allocateObjectByType("::Test"); test(false); } catch(const AllocationException&) { } try { session2->allocateObjectByType("::Test"); test(false); } catch(const AllocationTimeoutException&) { } try { session2->releaseObject(obj->ice_getIdentity()); } catch(const AllocationException&) { } session1->releaseObject(obj->ice_getIdentity()); try { session1->releaseObject(obj->ice_getIdentity()); } catch(const AllocationException&) { } obj = session2->allocateObjectByType("::Test"); // Allocate the object test(obj && obj->ice_getIdentity().name == "allocatable"); try { session2->allocateObjectByType("::Test"); test(false); } catch(const AllocationException&) { } try { session1->allocateObjectByType("::Test"); test(false); } catch(const AllocationTimeoutException&) { } session1->allocateObjectByType("::TestBis"); try { session2->allocateObjectByType("::TestBis"); test(false); } catch(const AllocationTimeoutException&) { } session1->releaseObject(allocatablebis); session2->allocateObjectByType("::TestBis"); try { session1->allocateObjectByType("::TestBis"); test(false); } catch(const AllocationTimeoutException&) { } session2->releaseObject(allocatablebis); session1->setAllocationTimeout(allocationTimeout); AllocateObjectByTypeCallbackPtr cb3 = new AllocateObjectByTypeCallback(); session1->allocateObjectByType_async(cb3, "::Test"); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!cb3->hasResponse(dummy)); session2->releaseObject(obj->ice_getIdentity()); cb3->waitResponse(__FILE__, __LINE__); test(cb3->hasResponse(obj)); session1->releaseObject(obj->ice_getIdentity()); cout << "ok" << endl; cout << "testing object allocation timeout... " << flush; session1->allocateObjectById(allocatable); IceUtil::Time time = IceUtil::Time::now(); session2->setAllocationTimeout(500); try { session2->allocateObjectById(allocatable); test(false); } catch(const AllocationTimeoutException&) { test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now()); } time = IceUtil::Time::now(); try { session2->allocateObjectById(allocatable); test(false); } catch(const AllocationTimeoutException&) { } test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now()); time = IceUtil::Time::now(); try { session2->allocateObjectByType("::Test"); test(false); } catch(const AllocationTimeoutException&) { } test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now()); session1->releaseObject(allocatable); session2->setAllocationTimeout(0); cout << "ok" << endl; cout << "testing server allocation... " << flush; session1->setAllocationTimeout(0); session2->setAllocationTimeout(0); Ice::Identity allocatable3 = communicator->stringToIdentity("allocatable3"); Ice::Identity allocatable4 = communicator->stringToIdentity("allocatable4"); session1->allocateObjectById(allocatable3); try { session2->allocateObjectById(allocatable3); test(false); } catch(const AllocationTimeoutException&) { } try { session2->allocateObjectById(allocatable4); test(false); } catch(const AllocationTimeoutException&) { } session1->allocateObjectById(allocatable4); session1->releaseObject(allocatable3); try { session2->allocateObjectById(allocatable3); test(false); } catch(const AllocationTimeoutException&) { } session1->releaseObject(allocatable4); session2->allocateObjectById(allocatable3); try { session1->allocateObjectById(allocatable3); test(false); } catch(const AllocationTimeoutException&) { } try { session1->allocateObjectById(allocatable4); test(false); } catch(const AllocationTimeoutException&) { } session2->allocateObjectById(allocatable4); session2->releaseObject(allocatable3); try { session1->allocateObjectById(allocatable3); test(false); } catch(const AllocationTimeoutException&) { } try { session1->allocateObjectByType("::TestServer1"); test(false); } catch(AllocationException&) { } try { session1->allocateObjectByType("::TestServer2"); test(false); } catch(AllocationException&) { } test(session2->allocateObjectByType("::TestServer1")); try { session2->allocateObjectByType("::TestServer1"); test(false); } catch(AllocationException&) { } try { session2->allocateObjectByType("::TestServer2"); test(false); } catch(AllocationException&) { } session2->releaseObject(allocatable3); session2->releaseObject(allocatable4); session1->allocateObjectById(allocatable3); session1->allocateObjectById(allocatable4); session2->setAllocationTimeout(allocationTimeout); cb1 = new AllocateObjectByIdCallback(); session2->allocateObjectById_async(cb1, allocatable3); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!cb1->hasResponse(dummy)); session1->releaseObject(allocatable3); test(!cb1->hasResponse(dummy)); session1->releaseObject(allocatable4); cb1->waitResponse(__FILE__, __LINE__); test(cb1->hasResponse(dummy)); session2->releaseObject(allocatable3); session1->setAllocationTimeout(allocationTimeout); test(session2->allocateObjectByType("::TestServer1")); cb3 = new AllocateObjectByTypeCallback(); session1->allocateObjectByType_async(cb3, "::TestServer2"); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!cb3->hasResponse(dummy)); session2->releaseObject(allocatable3); cb3->waitResponse(__FILE__, __LINE__); test(cb3->hasResponse(dummy)); session1->releaseObject(allocatable4); session1->setAllocationTimeout(0); session2->setAllocationTimeout(0); test(session1->allocateObjectByType("::TestMultipleByServer")); try { session2->allocateObjectByType("::TestMultipleByServer"); test(false); } catch(AllocationException&) { } test(session1->allocateObjectByType("::TestMultipleByServer")); session1->releaseObject(communicator->stringToIdentity("allocatable31")); session1->releaseObject(communicator->stringToIdentity("allocatable41")); test(session2->allocateObjectByType("::TestMultipleByServer")); try { session1->allocateObjectByType("::TestMultipleByServer"); test(false); } catch(AllocationException&) { } test(session2->allocateObjectByType("::TestMultipleByServer")); session2->releaseObject(communicator->stringToIdentity("allocatable31")); session2->releaseObject(communicator->stringToIdentity("allocatable41")); Ice::ObjectPrx obj1 = session1->allocateObjectByType("::TestMultipleServer"); test(obj1); Ice::ObjectPrx obj2 = session2->allocateObjectByType("::TestMultipleServer"); test(obj2); try { session1->allocateObjectByType("::TestMultipleServer"); test(false); } catch(AllocationTimeoutException&) { } try { session2->allocateObjectByType("::TestMultipleServer"); test(false); } catch(AllocationTimeoutException&) { } session1->releaseObject(obj1->ice_getIdentity()); obj1 = session2->allocateObjectByType("::TestMultipleServer"); session2->releaseObject(obj1->ice_getIdentity()); session2->releaseObject(obj2->ice_getIdentity()); cout << "ok" << endl; cout << "testing concurrent allocations... " << flush; session1->setAllocationTimeout(allocationTimeout); session2->setAllocationTimeout(allocationTimeout); session2->allocateObjectById(allocatable); AllocateObjectByIdCallbackPtr cb11 = new AllocateObjectByIdCallback(); AllocateObjectByIdCallbackPtr cb12 = new AllocateObjectByIdCallback(); session1->allocateObjectById_async(cb11, allocatable); session1->allocateObjectById_async(cb12, allocatable); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!cb11->hasResponse(dummy)); test(!cb12->hasResponse(dummy)); session2->releaseObject(allocatable); cb11->waitResponse(__FILE__, __LINE__); cb12->waitResponse(__FILE__, __LINE__); test(cb11->hasResponse(dummy) ? cb12->hasException() : cb12->hasResponse(dummy)); test(cb12->hasResponse(dummy) ? cb11->hasException() : cb11->hasResponse(dummy)); session1->releaseObject(allocatable); session2->allocateObjectById(allocatable); AllocateObjectByTypeCallbackPtr cb31 = new AllocateObjectByTypeCallback(); AllocateObjectByTypeCallbackPtr cb32 = new AllocateObjectByTypeCallback(); session1->allocateObjectByType_async(cb31, "::Test"); session1->allocateObjectByType_async(cb32, "::Test"); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!cb31->hasResponse(dummy)); test(!cb32->hasResponse(dummy)); session2->releaseObject(allocatable); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); do { IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200)); } while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy)); test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) || cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy)); session1->releaseObject(allocatable); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); AllocateObjectByTypeCallbackPtr cb33 = cb31->hasResponse(dummy) ? cb32 : cb31; cb33->waitResponse(__FILE__, __LINE__); test(cb33->hasResponse(dummy) && dummy); session1->releaseObject(allocatable); session2->allocateObjectById(allocatable3); cb11 = new AllocateObjectByIdCallback(); cb12 = new AllocateObjectByIdCallback(); session1->allocateObjectById_async(cb11, allocatable3); session1->allocateObjectById_async(cb12, allocatable3); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!cb11->hasResponse(dummy)); test(!cb12->hasResponse(dummy)); session2->releaseObject(allocatable3); cb11->waitResponse(__FILE__, __LINE__); cb12->waitResponse(__FILE__, __LINE__); test(cb11->hasResponse(dummy) ? cb12->hasException() : cb12->hasResponse(dummy)); test(cb12->hasResponse(dummy) ? cb11->hasException() : cb11->hasResponse(dummy)); session1->releaseObject(allocatable3); session2->allocateObjectById(allocatable3); cb31 = new AllocateObjectByTypeCallback(); cb32 = new AllocateObjectByTypeCallback(); session1->allocateObjectByType_async(cb31, "::TestServer1"); session1->allocateObjectByType_async(cb32, "::TestServer1"); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!cb31->hasResponse(dummy)); test(!cb32->hasResponse(dummy)); session2->releaseObject(allocatable3); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); do { IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200)); } while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy)); test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) || cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy)); session1->releaseObject(allocatable3); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); cb33 = cb31->hasResponse(dummy) ? cb32 : cb31; cb33->waitResponse(__FILE__, __LINE__); test(cb33->hasResponse(dummy) && dummy); session1->releaseObject(allocatable3); session1->allocateObjectById(allocatable3); cb31 = new AllocateObjectByTypeCallback(); cb32 = new AllocateObjectByTypeCallback(); session1->allocateObjectByType_async(cb31, "::TestServer1"); session1->allocateObjectByType_async(cb32, "::TestServer1"); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!cb31->hasResponse(dummy)); test(!cb32->hasResponse(dummy)); session1->releaseObject(allocatable3); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); do { IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200)); } while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy)); test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) || cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy)); session1->releaseObject(allocatable3); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300)); cb33 = cb31->hasResponse(dummy) ? cb32 : cb31; cb33->waitResponse(__FILE__, __LINE__); test(cb33->hasResponse(dummy) && dummy); session1->releaseObject(allocatable3); cout << "ok" << endl; cout << "testing session destroy... " << flush; obj = session2->allocateObjectByType("::Test"); // Allocate the object test(obj && obj->ice_getIdentity().name == "allocatable"); session1->setAllocationTimeout(allocationTimeout); cb3 = new AllocateObjectByTypeCallback(); session1->allocateObjectByType_async(cb3, "::Test"); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); test(!cb3->hasResponse(dummy)); session2->destroy(); cb3->waitResponse(__FILE__, __LINE__); test(cb3->hasResponse(obj)); session1->destroy(); session2 = SessionPrx::uncheckedCast(registry->createSession("Client2", "")); session2->setAllocationTimeout(0); session2->allocateObjectById(allocatable); session2->destroy(); cout << "ok" << endl; cout << "testing allocation with Glacier2 session... " << flush; Ice::ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:default -p 12347"); Glacier2::RouterPrx router1 = Glacier2::RouterPrx::checkedCast(routerBase->ice_connectionId("client1")); test(router1); Glacier2::SessionPrx sessionBase = router1->createSession("test1", "abc123"); try { session1 = IceGrid::SessionPrx::checkedCast(sessionBase->ice_connectionId("client1")->ice_router(router1)); test(session1); session1->ice_ping(); Ice::ObjectPrx obj; obj = session1->allocateObjectById(allocatable)->ice_connectionId("client1")->ice_router(router1); obj->ice_ping(); session1->releaseObject(allocatable); try { obj->ice_ping(); } catch(const Ice::ObjectNotExistException&) { } obj = session1->allocateObjectById(allocatable3)->ice_connectionId("client1")->ice_router(router1); obj->ice_ping(); obj2 = communicator->stringToProxy("allocatable4")->ice_connectionId("client1")->ice_router(router1); obj2->ice_ping(); session1->releaseObject(allocatable3); try { obj->ice_ping(); } catch(const Ice::ObjectNotExistException&) { } try { obj2->ice_ping(); } catch(const Ice::ObjectNotExistException&) { } session1->destroy(); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } cout << "ok" << endl; cout << "stress test... " << flush; SessionPrx stressSession = registry->createSession("StressSession", ""); keepAlive->add(stressSession); const int nClients = 10; int i; vector<StressClientPtr> clients; for(i = 0; i < nClients - 2; ++i) { if(IceUtil::random(2) == 1) { clients.push_back(new StressClient(i, registry, false)); } else { clients.push_back(new StressClient(i, stressSession)); } clients.back()->start(); } clients.push_back(new StressClient(i++, registry, true)); clients.back()->start(); clients.push_back(new StressClient(i++, registry, true)); clients.back()->start(); for(vector<StressClientPtr>::const_iterator p = clients.begin(); p != clients.end(); ++p) { (*p)->notifyThread(); } // // Let the stress client run for a bit. // IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(8)); // // Terminate the stress clients. // for(vector<StressClientPtr>::const_iterator q = clients.begin(); q != clients.end(); ++q) { (*q)->terminate(); (*q)->getThreadControl().join(); } stressSession->destroy(); cout << "ok" << endl; } catch(const AllocationTimeoutException& ex) { cerr << ex << endl; test(false); } catch(const AllocationException& ex) { cerr << ex.reason << endl; test(false); } cout << "shutting down router... " << flush; admin->stopServer("Glacier2"); cout << "ok" << endl; keepAlive->terminate(); keepAlive->getThreadControl().join(); keepAlive = 0; session->destroy(); }
Ice::ObjectPrx TopicImpl::subscribeAndGetPublisher(const QoS& qos, const Ice::ObjectPrx& obj) { if(!obj) { TraceLevelsPtr traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); out << _name << ": subscribeAndGetPublisher: null proxy"; } throw InvalidSubscriber("subscriber is a null proxy"); } Ice::Identity id = obj->ice_getIdentity(); TraceLevelsPtr traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); out << _name << ": subscribeAndGetPublisher: " << _instance->communicator()->identityToString(id); if(traceLevels->topic > 1) { out << " endpoints: " << IceStormInternal::describeEndpoints(obj) << " QoS: "; for(QoS::const_iterator p = qos.begin(); p != qos.end() ; ++p) { if(p != qos.begin()) { out << ','; } } out << " subscriptions: "; trace(out, _instance, _subscribers); } } IceUtil::Mutex::Lock sync(_subscribersMutex); SubscriberRecord record; record.id = id; record.obj = obj; record.theQoS = qos; record.topicName = _name; record.link = false; record.cost = 0; vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), record.id); if(p != _subscribers.end()) { throw AlreadySubscribed(); } LogUpdate llu; SubscriberPtr subscriber = Subscriber::create(_instance, record); try { IceDB::ReadWriteTxn txn(_instance->dbEnv()); SubscriberRecordKey key; key.topic = _id; key.id = subscriber->id(); _subscriberMap.put(txn, key, record); llu = getIncrementedLLU(txn, _lluMap); txn.commit(); } catch(const IceDB::LMDBException& ex) { logError(_instance->communicator(), ex); throw; // will become UnknownException in caller } _subscribers.push_back(subscriber); _instance->observers()->addSubscriber(llu, _name, record); return subscriber->proxy(); }
bool operator()(const Ice::ObjectPrx& p1, const string& id) const { return p1->ice_getIdentity() == Ice::stringToIdentity(id); }
void TransientTopicImpl::subscribe(const QoS& origQoS, const Ice::ObjectPrx& obj, const Ice::Current&) { if(!obj) { TraceLevelsPtr traceLevels = _instance->traceLevels(); if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); out << _name << ": subscribe: null proxy"; } throw InvalidSubscriber("subscriber is a null proxy"); } Ice::Identity id = obj->ice_getIdentity(); TraceLevelsPtr traceLevels = _instance->traceLevels(); QoS qos = origQoS; if(traceLevels->topic > 0) { Ice::Trace out(traceLevels->logger, traceLevels->topicCat); out << _name << ": subscribe: " << _instance->communicator()->identityToString(id); if(traceLevels->topic > 1) { out << " endpoints: " << IceStormInternal::describeEndpoints(obj) << " QoS: "; for(QoS::const_iterator p = qos.begin(); p != qos.end() ; ++p) { if(p != qos.begin()) { out << ','; } out << '[' << p->first << "," << p->second << ']'; } } } string reliability = "oneway"; { QoS::iterator p = qos.find("reliability"); if(p != qos.end()) { reliability = p->second; qos.erase(p); } } Ice::ObjectPrx newObj = obj; if(reliability == "batch") { if(newObj->ice_isDatagram()) { newObj = newObj->ice_batchDatagram(); } else { newObj = newObj->ice_batchOneway(); } } else if(reliability == "twoway") { newObj = newObj->ice_twoway(); } else if(reliability == "twoway ordered") { qos["reliability"] = "ordered"; newObj = newObj->ice_twoway(); } else // reliability == "oneway" { if(reliability != "oneway" && traceLevels->subscriber > 0) { Ice::Trace out(traceLevels->logger, traceLevels->subscriberCat); out << reliability <<" mode not understood."; } if(!newObj->ice_isDatagram()) { newObj = newObj->ice_oneway(); } } Lock sync(*this); SubscriberRecord record; record.id = id; record.obj = newObj; record.theQoS = qos; record.topicName = _name; record.link = false; record.cost = 0; vector<SubscriberPtr>::iterator p = find(_subscribers.begin(), _subscribers.end(), record.id); if(p != _subscribers.end()) { // If we already have this subscriber remove it from our // subscriber list and remove it from the database. (*p)->destroy(); _subscribers.erase(p); } SubscriberPtr subscriber = Subscriber::create(_instance, record); _subscribers.push_back(subscriber); }
void ServerLocatorRegistry::addObject(const Ice::ObjectPrx& object) { _objects[object->ice_getIdentity()] = object; }