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; }
InternalRegistryPrxSeq InternalRegistryI::getReplicas(const Ice::Current&) const { InternalRegistryPrxSeq replicas; Ice::ObjectProxySeq proxies = _database->getObjectsByType(InternalRegistry::ice_staticId()); for(Ice::ObjectProxySeq::const_iterator p = proxies.begin(); p != proxies.end(); ++p) { replicas.push_back(InternalRegistryPrx::uncheckedCast(*p)); } return replicas; }
NodePrxSeq InternalRegistryI::getNodes(const Ice::Current&) const { NodePrxSeq nodes; Ice::ObjectProxySeq proxies = _database->getInternalObjectsByType(Node::ice_staticId()); for(Ice::ObjectProxySeq::const_iterator p = proxies.begin(); p != proxies.end(); ++p) { nodes.push_back(NodePrx::uncheckedCast(*p)); } return nodes; }
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(); } }
bool IceInternal::RouterInfo::addProxy(const Ice::ObjectPrxPtr& 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); #ifdef ICE_CPP11_MAPPING RouterInfoPtr self = this; _router->addProxies_async(proxies, [self, cookie](const Ice::ObjectProxySeq& proxies) { self->addProxyResponse(proxies, cookie); }, [self, cookie](exception_ptr e) { try { rethrow_exception(e); } catch(const Ice::Exception& ex) { self->addProxyException(ex, cookie); } }); #else _router->begin_addProxies(proxies, newCallback_Router_addProxies(this, &RouterInfo::addProxyResponse, &RouterInfo::addProxyException), cookie); #endif return false; }
Ice::ObjectProxySeq ObjectCache::getObjectsByType(const string& type) { Lock sync(*this); Ice::ObjectProxySeq proxies; map<string, TypeEntry>::const_iterator p = _types.find(type); if(p == _types.end()) { return proxies; } const vector<ObjectEntryPtr>& objects = p->second.getObjects(); for(vector<ObjectEntryPtr>::const_iterator q = objects.begin(); q != objects.end(); ++q) { proxies.push_back((*q)->getProxy()); } return proxies; }
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()); } } }
Dispatch::Dispatch(int npro, Ice::ObjectPrx& proxy, CollectorPrx& collector):nproc(npro){ processor = std::vector < Cannon::ProcessorPrx > (); IceGrid::QueryPrx query = IceGrid::QueryPrx::checkedCast(proxy); Ice::ObjectProxySeq seq; seq = query->findAllObjectsByType("::Cannon::Processor"); Cannon::ProcessorPrx pr; int size = seq.size(); for(auto i:seq){ std::cout << i <<std::endl; pr = Cannon::ProcessorPrx::checkedCast(i); processor.push_back(pr); } for(int i =0; i<size; i++){ processor[i]->init( (int)(i/(int)sqrt(nproc)) , (int)(i%(int)sqrt(nproc)) ,processor[getNorth(i)], processor[getLeft(i)],(int)sqrt(nproc), collector); } }
void ServiceI::start( const string& name, const CommunicatorPtr& communicator, const StringSeq& /*args*/) { PropertiesPtr properties = communicator->getProperties(); validateProperties(name, properties, communicator->getLogger()); int id = properties->getPropertyAsIntWithDefault(name + ".NodeId", -1); // If we are using a replicated deployment and if the topic // manager thread pool max size is not set then ensure it is set // to some suitably high number. This ensures no deadlocks in the // replicated case due to call forwarding from replicas to // coordinators. if(id != -1 && properties->getProperty(name + ".TopicManager.ThreadPool.SizeMax").empty()) { properties->setProperty(name + ".TopicManager.ThreadPool.SizeMax", "100"); } Ice::ObjectAdapterPtr topicAdapter = communicator->createObjectAdapter(name + ".TopicManager"); Ice::ObjectAdapterPtr publishAdapter = communicator->createObjectAdapter(name + ".Publish"); // // We use the name of the service for the name of the database environment. // string instanceName = properties->getPropertyWithDefault(name + ".InstanceName", "IceStorm"); Identity topicManagerId; topicManagerId.category = instanceName; topicManagerId.name = "TopicManager"; if(properties->getPropertyAsIntWithDefault(name+ ".Transient", 0) > 0) { _instance = new Instance(instanceName, name, communicator, publishAdapter, topicAdapter, 0); try { TransientTopicManagerImplPtr manager = new TransientTopicManagerImpl(_instance); _managerProxy = TopicManagerPrx::uncheckedCast(topicAdapter->add(manager, topicManagerId)); } catch(const Ice::Exception& ex) { _instance = 0; LoggerOutputBase s; s << "exception while starting IceStorm service " << name << ":\n"; s << ex; IceBox::FailureException e(__FILE__, __LINE__); e.reason = s.str(); throw e; } topicAdapter->activate(); publishAdapter->activate(); return; } if(id == -1) // No replication. { _instance = new Instance(instanceName, name, communicator, publishAdapter, topicAdapter); try { _manager = new TopicManagerImpl(_instance); _managerProxy = TopicManagerPrx::uncheckedCast(topicAdapter->add(_manager->getServant(), topicManagerId)); } catch(const Ice::Exception& ex) { _instance = 0; LoggerOutputBase s; s << "exception while starting IceStorm service " << name << ":\n"; s << ex; IceBox::FailureException e(__FILE__, __LINE__); e.reason = s.str(); throw e; } } else { // Here we want to create a map of id -> election node // proxies. map<int, NodePrx> nodes; string topicManagerAdapterId = properties->getProperty(name + ".TopicManager.AdapterId"); // We support two possible deployments. The first is a manual // deployment, the second is IceGrid. // // Here we check for the manual deployment const string prefix = name + ".Nodes."; Ice::PropertyDict props = properties->getPropertiesForPrefix(prefix); if(!props.empty()) { for(Ice::PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p) { int nodeid = atoi(p->first.substr(prefix.size()).c_str()); nodes[nodeid] = NodePrx::uncheckedCast(communicator->propertyToProxy(p->first)); } } else { // If adapter id's are defined for the topic manager or // node adapters then we consider this an IceGrid based // deployment. string nodeAdapterId = properties->getProperty(name + ".Node.AdapterId"); // Validate first that the adapter ids match for the node // and the topic manager otherwise some other deployment // is being used. const string suffix = ".TopicManager"; if(topicManagerAdapterId.empty() || nodeAdapterId.empty() || topicManagerAdapterId.replace( topicManagerAdapterId.find(suffix), suffix.size(), ".Node") != nodeAdapterId) { Ice::Error error(communicator->getLogger()); error << "deployment error: `" << topicManagerAdapterId << "' prefix does not match `" << nodeAdapterId << "'"; throw IceBox::FailureException(__FILE__, __LINE__, "IceGrid deployment is incorrect"); } // Determine the set of node id and node proxies. // // This is determined by locating all topic manager // replicas, and then working out the node for that // replica. // // We work out the node id by removing the instance // name. The node id must follow. // IceGrid::LocatorPrx locator = IceGrid::LocatorPrx::checkedCast(communicator->getDefaultLocator()); assert(locator); IceGrid::QueryPrx query = locator->getLocalQuery(); Ice::ObjectProxySeq replicas = query->findAllReplicas( communicator->stringToProxy(instanceName + "/TopicManager")); for(Ice::ObjectProxySeq::const_iterator p = replicas.begin(); p != replicas.end(); ++p) { string adapterid = (*p)->ice_getAdapterId(); // Replace TopicManager with the node endpoint. adapterid = adapterid.replace(adapterid.find(suffix), suffix.size(), ".Node"); // The adapter id must start with the instance name. if(adapterid.find(instanceName) != 0) { Ice::Error error(communicator->getLogger()); error << "deployment error: `" << adapterid << "' does not start with `" << instanceName << "'"; throw IceBox::FailureException(__FILE__, __LINE__, "IceGrid deployment is incorrect"); } // The node id follows. We find the first digit (the // start of the node id, and then the end of the // digits). string::size_type start = instanceName.size(); while(start < adapterid.size() && !IceUtilInternal::isDigit(adapterid[start])) { ++start; } string::size_type end = start; while(end < adapterid.size() && IceUtilInternal::isDigit(adapterid[end])) { ++end; } if(start == end) { // We must have at least one digit, otherwise there is // some sort of deployment error. Ice::Error error(communicator->getLogger()); error << "deployment error: node id does not follow instance name. instance name:" << instanceName << " adapter id: " << adapterid; throw IceBox::FailureException(__FILE__, __LINE__, "IceGrid deployment is incorrect"); } int nodeid = atoi(adapterid.substr(start, end-start).c_str()); ostringstream os; os << "node" << nodeid; Ice::Identity id; id.category = instanceName; id.name = os.str(); nodes[nodeid] = NodePrx::uncheckedCast((*p)->ice_adapterId(adapterid)->ice_identity(id)); } } if(nodes.size() < 3) { Ice::Error error(communicator->getLogger()); error << "Replication requires at least 3 Nodes"; throw IceBox::FailureException(__FILE__, __LINE__, "Replication requires at least 3 Nodes"); } try { // If the node thread pool size is not set then initialize // to the number of nodes + 1 and disable thread pool size // warnings. if(properties->getProperty(name + ".Node.ThreadPool.Size").empty()) { ostringstream os; os << nodes.size() + 1; properties->setProperty(name + ".Node.ThreadPool.Size", os.str()); properties->setProperty(name + ".Node.ThreadPool.SizeWarn", "0"); } if(properties->getProperty(name + ".Node.MessageSizeMax").empty()) { properties->setProperty(name + ".Node.MessageSizeMax", "0"); // No limit on data exchanged internally } Ice::ObjectAdapterPtr nodeAdapter = communicator->createObjectAdapter(name + ".Node"); _instance = new Instance(instanceName, name, communicator, publishAdapter, topicAdapter, nodeAdapter, nodes[id]); _instance->observers()->setMajority(static_cast<unsigned int>(nodes.size())/2); // Trace replication information. TraceLevelsPtr traceLevels = _instance->traceLevels(); if(traceLevels->election > 0) { Ice::Trace out(traceLevels->logger, traceLevels->electionCat); out << "I am node " << id << "\n"; for(map<int, NodePrx>::const_iterator p = nodes.begin(); p != nodes.end(); ++p) { out << "\tnode: " << p->first << " proxy: " << p->second->ice_toString() << "\n"; } } if(topicManagerAdapterId.empty()) { // We're not using an IceGrid deployment. Here we need // a proxy which is used to create proxies to the // replicas later. _managerProxy = TopicManagerPrx::uncheckedCast(topicAdapter->createProxy(topicManagerId)); } else { // If we're using IceGrid deployment we need to create // indirect proxies. _managerProxy = TopicManagerPrx::uncheckedCast(topicAdapter->createIndirectProxy(topicManagerId)); } _manager = new TopicManagerImpl(_instance); topicAdapter->add(_manager->getServant(), topicManagerId); ostringstream os; // The node object identity. os << "node" << id; Ice::Identity nodeid; nodeid.category = instanceName; nodeid.name = os.str(); NodeIPtr node = new NodeI(_instance, _manager, _managerProxy, id, nodes); _instance->setNode(node); nodeAdapter->add(node, nodeid); nodeAdapter->activate(); node->start(); } catch(const Ice::Exception& ex) { _instance = 0; LoggerOutputBase s; s << "exception while starting IceStorm service " << name << ":\n"; s << ex; IceBox::FailureException e(__FILE__, __LINE__); e.reason = s.str(); throw e; } } topicAdapter->add(new FinderI(TopicManagerPrx::uncheckedCast(topicAdapter->createProxy(topicManagerId))), communicator->stringToIdentity("IceStorm/Finder")); topicAdapter->activate(); publishAdapter->activate(); }
bool RegistryI::start(bool nowarn) { assert(_communicator); PropertiesPtr properties = _communicator->getProperties(); // // Initialize the database environment. // string dbPath = properties->getProperty("IceGrid.Registry.Data"); if(dbPath.empty()) { Error out(_communicator->getLogger()); out << "property `IceGrid.Registry.Data' is not set"; return false; } else { struct stat filestat; if(stat(dbPath.c_str(), &filestat) != 0 || !S_ISDIR(filestat.st_mode)) { Error out(_communicator->getLogger()); SyscallException ex(__FILE__, __LINE__); ex.error = getSystemErrno(); out << "property `IceGrid.Registry.Data' is set to an invalid path:\n" << ex; return false; } } // // Check that required properties are set and valid. // if(properties->getProperty("IceGrid.Registry.Client.Endpoints").empty()) { Error out(_communicator->getLogger()); out << "property `IceGrid.Registry.Client.Endpoints' is not set"; return false; } if(properties->getProperty("IceGrid.Registry.Server.Endpoints").empty()) { Error out(_communicator->getLogger()); out << "property `IceGrid.Registry.Server.Endpoints' is not set"; return false; } if(properties->getProperty("IceGrid.Registry.Internal.Endpoints").empty()) { Error out(_communicator->getLogger()); out << "property `IceGrid.Registry.Internal.Endpoints' is not set"; return false; } if(!properties->getProperty("IceGrid.Registry.SessionManager.Endpoints").empty()) { if(!nowarn) { Warning out(_communicator->getLogger()); out << "session manager endpoints `IceGrid.Registry.SessionManager.Endpoints' enabled"; } } properties->setProperty("Ice.PrintProcessId", "0"); properties->setProperty("Ice.ServerIdleTime", "0"); properties->setProperty("IceGrid.Registry.Client.AdapterId", ""); properties->setProperty("IceGrid.Registry.Server.AdapterId", ""); properties->setProperty("IceGrid.Registry.SessionManager.AdapterId", ""); properties->setProperty("IceGrid.Registry.Internal.AdapterId", ""); setupThreadPool(properties, "Ice.ThreadPool.Client", 1, 100); setupThreadPool(properties, "IceGrid.Registry.Client.ThreadPool", 1, 10); setupThreadPool(properties, "IceGrid.Registry.Server.ThreadPool", 1, 10); setupThreadPool(properties, "IceGrid.Registry.SessionManager.ThreadPool", 1, 10); setupThreadPool(properties, "IceGrid.Registry.Internal.ThreadPool", 1, 100); _replicaName = properties->getPropertyWithDefault("IceGrid.Registry.ReplicaName", "Master"); _master = _replicaName == "Master"; _sessionTimeout = properties->getPropertyAsIntWithDefault("IceGrid.Registry.SessionTimeout", 30); // // Get the instance name // if(_master) { _instanceName = properties->getProperty("IceGrid.InstanceName"); if(_instanceName.empty()) { if(_communicator->getDefaultLocator()) { _instanceName = _communicator->getDefaultLocator()->ice_getIdentity().category; } else { _instanceName = "IceGrid"; } } } else { if(properties->getProperty("Ice.Default.Locator").empty()) { Error out(_communicator->getLogger()); out << "property `Ice.Default.Locator' is not set"; return false; } _instanceName = _communicator->getDefaultLocator()->ice_getIdentity().category; } // // Ensure that nothing is running on this port. This is also // useful to ensure that we don't run twice the same instance of // the service too (which would cause the database environment of // the already running instance to be "corrupted".) // try { string endpoints = properties->getProperty("IceGrid.Registry.Client.Endpoints"); string strPrx = _instanceName + "/Locator:" + endpoints; _communicator->stringToProxy(strPrx)->ice_timeout(5000)->ice_ping(); Error out(_communicator->getLogger()); out << "an IceGrid registry is already running and listening on the client endpoints `" << endpoints << "'"; return false; } catch(const Ice::LocalException&) { } properties->setProperty("Freeze.DbEnv.Registry.DbHome", dbPath); properties->setProperty("Freeze.DbEnv.Registry.DbPrivate", "0"); // // Create the reaper thread. // _reaper = new ReapThread(); _reaper->start(); // // Create the internal registry object adapter. // ObjectAdapterPtr registryAdapter = _communicator->createObjectAdapter("IceGrid.Registry.Internal"); registryAdapter->activate(); // // Create the internal IceStorm service. // Identity registryTopicManagerId; registryTopicManagerId.category = _instanceName; registryTopicManagerId.name = "RegistryTopicManager"; _iceStorm = IceStorm::Service::create(_communicator, registryAdapter, registryAdapter, "IceGrid.Registry", registryTopicManagerId, "Registry"); const IceStorm::TopicManagerPrx topicManager = _iceStorm->getTopicManager(); // // Create the registry database. // _database = new Database(registryAdapter, topicManager, _instanceName, _traceLevels, getInfo()); _wellKnownObjects = new WellKnownObjectsManager(_database); // // Get the saved replica/node proxies and remove them from the // database. // Ice::ObjectProxySeq proxies; Ice::ObjectProxySeq::const_iterator p; NodePrxSeq nodes; proxies = _database->getInternalObjectsByType(Node::ice_staticId()); for(p = proxies.begin(); p != proxies.end(); ++p) { nodes.push_back(NodePrx::uncheckedCast(*p)); } InternalRegistryPrxSeq replicas; proxies = _database->getObjectsByType(InternalRegistry::ice_staticId()); for(p = proxies.begin(); p != proxies.end(); ++p) { replicas.push_back(InternalRegistryPrx::uncheckedCast(*p)); } // // NOTE: The internal registry object must be added only once the // node/replica proxies are retrieved and removed from the // database. Otherwise, if some replica/node register as soon as // the internal registry is setup we might clear valid proxies. // InternalRegistryPrx internalRegistry = setupInternalRegistry(registryAdapter); if(_master) { nodes = registerReplicas(internalRegistry, replicas, nodes); registerNodes(internalRegistry, nodes); } else { InternalReplicaInfoPtr info = _platform.getInternalReplicaInfo(); _session.create(_replicaName, info, _database, _wellKnownObjects, internalRegistry); registerNodes(internalRegistry, _session.getNodes(nodes)); } ObjectAdapterPtr serverAdapter = _communicator->createObjectAdapter("IceGrid.Registry.Server"); _clientAdapter = _communicator->createObjectAdapter("IceGrid.Registry.Client"); ObjectAdapterPtr sessionManagerAdapter; if(!properties->getProperty("IceGrid.Registry.SessionManager.Endpoints").empty()) { sessionManagerAdapter = _communicator->createObjectAdapter("IceGrid.Registry.SessionManager"); } Ice::Identity dummy; dummy.name = "dummy"; _wellKnownObjects->addEndpoint("Client", _clientAdapter->createDirectProxy(dummy)); _wellKnownObjects->addEndpoint("Server", serverAdapter->createDirectProxy(dummy)); if(sessionManagerAdapter) { _wellKnownObjects->addEndpoint("SessionManager", sessionManagerAdapter->createDirectProxy(dummy)); } _wellKnownObjects->addEndpoint("Internal", registryAdapter->createDirectProxy(dummy)); setupNullPermissionsVerifier(registryAdapter); if(!setupUserAccountMapper(registryAdapter)) { return false; } QueryPrx query = setupQuery(_clientAdapter); RegistryPrx registry = setupRegistry(_clientAdapter); Ice::LocatorRegistryPrx locatorRegistry = setupLocatorRegistry(serverAdapter); LocatorPrx internalLocator = setupLocator(_clientAdapter, registryAdapter, locatorRegistry, registry, query); // // Add a default servant locator to the client object adapter. The // default servant ensure that request on session objects are from // the same connection as the connection that created the session. // _sessionServantLocator = new SessionServantLocatorI(_clientAdapter, _instanceName); _clientAdapter->addServantLocator(_sessionServantLocator, ""); setupClientSessionFactory(registryAdapter, sessionManagerAdapter, internalLocator, nowarn); setupAdminSessionFactory(registryAdapter, sessionManagerAdapter, internalLocator, nowarn); _wellKnownObjects->finish(); if(_master) { _wellKnownObjects->registerAll(); } else { _session.registerAllWellKnownObjects(); } // // We are ready to go! // serverAdapter->activate(); _clientAdapter->activate(); if(sessionManagerAdapter) { sessionManagerAdapter->activate(); } return true; }
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& 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(); }
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); set<string> serverReplicaIds; serverReplicaIds.insert("Server1.ReplicatedAdapter"); serverReplicaIds.insert("Server2.ReplicatedAdapter"); serverReplicaIds.insert("Server3.ReplicatedAdapter"); set<string> svcReplicaIds; svcReplicaIds.insert("IceBox1.Service1.Service1"); svcReplicaIds.insert("IceBox1.Service2.Service2"); svcReplicaIds.insert("IceBox1.Service3.Service3"); cout << "testing Query::findAllReplicas... " << flush; { map<string, string> params; params["replicaGroup"] = "RoundRobin"; params["id"] = "Server1"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server2"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server3"; instantiateServer(admin, "Server", "localnode", params); TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("dummy@RoundRobin")); Ice::ObjectProxySeq objs = query->findAllReplicas(obj); test(objs.size() == 3); test(serverReplicaIds.find(objs[0]->ice_getAdapterId()) != serverReplicaIds.end()); test(serverReplicaIds.find(objs[1]->ice_getAdapterId()) != serverReplicaIds.end()); test(serverReplicaIds.find(objs[2]->ice_getAdapterId()) != serverReplicaIds.end()); obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("RoundRobin")); objs = query->findAllReplicas(obj); test(objs.size() == 3); test(serverReplicaIds.find(objs[0]->ice_getAdapterId()) != serverReplicaIds.end()); test(serverReplicaIds.find(objs[1]->ice_getAdapterId()) != serverReplicaIds.end()); test(serverReplicaIds.find(objs[2]->ice_getAdapterId()) != serverReplicaIds.end()); obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("dummy@dummy")); objs = query->findAllReplicas(obj); test(objs.empty()); obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("*****@*****.**")); objs = query->findAllReplicas(obj); test(objs.empty()); obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("dummy:tcp")); objs = query->findAllReplicas(obj); test(objs.empty()); obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("dummy@Ordered")); objs = query->findAllReplicas(obj); test(objs.empty()); removeServer(admin, "Server1"); removeServer(admin, "Server2"); removeServer(admin, "Server3"); } cout << "ok" << endl; cout << "testing replication with round-robin load balancing... " << flush; { map<string, string> params; params["replicaGroup"] = "RoundRobin"; params["id"] = "Server1"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server2"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server3"; instantiateServer(admin, "Server", "localnode", params); TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("RoundRobin")); obj = TestIntfPrx::uncheckedCast(obj->ice_locatorCacheTimeout(0)); obj = TestIntfPrx::uncheckedCast(obj->ice_connectionCached(false)); try { test(obj->getReplicaIdAndShutdown() == "Server1.ReplicatedAdapter"); test(obj->getReplicaIdAndShutdown() == "Server2.ReplicatedAdapter"); test(obj->getReplicaIdAndShutdown() == "Server3.ReplicatedAdapter"); admin->enableServer("Server1", false); admin->enableServer("Server2", false); admin->enableServer("Server3", false); try { obj->getReplicaId(); test(false); } catch(const Ice::NoEndpointException&) { } admin->enableServer("Server1", true); admin->enableServer("Server2", true); admin->enableServer("Server3", true); set<string> adapterIds; string previousId; while(adapterIds.size() != 3) { string id = obj->getReplicaId(); adapterIds.insert(id); if(adapterIds.size() == 1) { previousId = id; } else { test(previousId != id); previousId = id; } } int i; for(i = 0; i < 3; i++) { if(obj->getReplicaId() == "Server3.ReplicatedAdapter") { break; } } test(i != 3); test(obj->getReplicaId() == "Server1.ReplicatedAdapter"); test(obj->getReplicaId() == "Server2.ReplicatedAdapter"); test(obj->getReplicaId() == "Server3.ReplicatedAdapter"); test(obj->getReplicaIdAndShutdown() == "Server1.ReplicatedAdapter"); test(obj->getReplicaIdAndShutdown() == "Server2.ReplicatedAdapter"); test(obj->getReplicaIdAndShutdown() == "Server3.ReplicatedAdapter"); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } removeServer(admin, "Server1"); removeServer(admin, "Server2"); removeServer(admin, "Server3"); } { map<string, string> params; params["replicaGroup"] = "RoundRobin"; params["id"] = "IceBox1"; instantiateServer(admin, "IceBox", "localnode", params); TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("RoundRobin")); try { test(obj->getReplicaIdAndShutdown() == "IceBox1.Service1.Service1"); test(obj->getReplicaIdAndShutdown() == "IceBox1.Service2.Service2"); test(obj->getReplicaIdAndShutdown() == "IceBox1.Service3.Service3"); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } removeServer(admin, "IceBox1"); } cout << "ok" << endl; cout << "testing replication with ordered load balancing... " << flush; { map<string, string> params; params["replicaGroup"] = "Ordered"; params["id"] = "Server1"; params["priority"] = "3"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server2"; params["priority"] = "1"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server3"; params["priority"] = "2"; instantiateServer(admin, "Server", "localnode", params); TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("Ordered")); try { test(obj->getReplicaIdAndShutdown() == "Server2.ReplicatedAdapter"); admin->enableServer("Server2", false); test(obj->getReplicaIdAndShutdown() == "Server3.ReplicatedAdapter"); admin->enableServer("Server3", false); test(obj->getReplicaIdAndShutdown() == "Server1.ReplicatedAdapter"); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } removeServer(admin, "Server1"); removeServer(admin, "Server2"); removeServer(admin, "Server3"); } { map<string, string> params; params["replicaGroup"] = "Ordered"; params["id"] = "IceBox1"; instantiateServer(admin, "IceBox", "localnode", params); TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("Ordered")); try { test(obj->getReplicaIdAndShutdown() == "IceBox1.Service3.Service3"); test(obj->getReplicaIdAndShutdown() == "IceBox1.Service2.Service2"); test(obj->getReplicaIdAndShutdown() == "IceBox1.Service1.Service1"); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } removeServer(admin, "IceBox1"); } cout << "ok" << endl; cout << "testing replication with random load balancing... " << flush; { map<string, string> params; params["replicaGroup"] = "Random"; params["id"] = "Server1"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server2"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server3"; instantiateServer(admin, "Server", "localnode", params); TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("Random")); obj = TestIntfPrx::uncheckedCast(obj->ice_locatorCacheTimeout(0)); obj = TestIntfPrx::uncheckedCast(obj->ice_connectionCached(false)); set<string> replicaIds = serverReplicaIds; while(!replicaIds.empty()) { try { replicaIds.erase(obj->getReplicaId()); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } } admin->stopServer("Server1"); admin->stopServer("Server2"); admin->stopServer("Server3"); admin->enableServer("Server1", false); admin->enableServer("Server2", false); admin->enableServer("Server3", false); try { obj->getReplicaId(); test(false); } catch(const Ice::NoEndpointException&) { } admin->enableServer("Server1", true); admin->enableServer("Server2", true); admin->enableServer("Server3", true); replicaIds = serverReplicaIds; while(!replicaIds.empty()) { try { replicaIds.erase(obj->getReplicaIdAndShutdown()); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } } removeServer(admin, "Server1"); removeServer(admin, "Server2"); removeServer(admin, "Server3"); } { map<string, string> params; params["replicaGroup"] = "Random"; params["id"] = "IceBox1"; instantiateServer(admin, "IceBox", "localnode", params); TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("Random")); obj = TestIntfPrx::uncheckedCast(obj->ice_locatorCacheTimeout(0)); obj = TestIntfPrx::uncheckedCast(obj->ice_connectionCached(false)); set<string> replicaIds = svcReplicaIds; while(!replicaIds.empty()) { try { replicaIds.erase(obj->getReplicaId()); } catch(const Ice::ConnectionRefusedException&) { } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } } removeServer(admin, "IceBox1"); } cout << "ok" << endl; cout << "testing replication with adaptive load balancing... " << flush; { map<string, string> params; params["replicaGroup"] = "Adaptive"; params["id"] = "Server1"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server2"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server3"; instantiateServer(admin, "Server", "localnode", params); TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("Adaptive")); obj = TestIntfPrx::uncheckedCast(obj->ice_locatorCacheTimeout(0)); obj = TestIntfPrx::uncheckedCast(obj->ice_connectionCached(false)); set<string> replicaIds = serverReplicaIds; while(!replicaIds.empty()) { try { replicaIds.erase(obj->getReplicaId()); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } } removeServer(admin, "Server1"); removeServer(admin, "Server2"); removeServer(admin, "Server3"); } { map<string, string> params; params["replicaGroup"] = "Adaptive"; params["id"] = "IceBox1"; instantiateServer(admin, "IceBox", "localnode", params); TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("Adaptive")); obj = TestIntfPrx::uncheckedCast(obj->ice_locatorCacheTimeout(0)); obj = TestIntfPrx::uncheckedCast(obj->ice_connectionCached(false)); set<string> replicaIds = svcReplicaIds; while(!replicaIds.empty()) { try { replicaIds.erase(obj->getReplicaId()); } catch(const Ice::ConnectionRefusedException&) { } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } } removeServer(admin, "IceBox1"); } cout << "ok" << endl; cout << "testing filters... " << flush; { map<string, string> params; params["replicaGroup"] = "Ordered-Filtered"; params["id"] = "Server1"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server2"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server3"; instantiateServer(admin, "IceBox1", "localnode", params); Ice::LocatorPrx locator = comm->getDefaultLocator(); Ice::Context ctx; ctx["server"] = "Server3"; locator->ice_context(ctx); TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("Ordered-Filtered")); obj = TestIntfPrx::uncheckedCast(obj->ice_locatorCacheTimeout(0)); obj = TestIntfPrx::uncheckedCast(obj->ice_connectionCached(false)); try { ctx["server"] = "Server3"; test(obj->ice_locator(locator->ice_context(ctx))->getReplicaId() == "Server3.Service.Service"); ctx["server"] = "Server1"; test(obj->ice_locator(locator->ice_context(ctx))->getReplicaId() == "Server1.ReplicatedAdapter"); ctx["server"] = "Server2"; test(obj->ice_locator(locator->ice_context(ctx))->getReplicaId() == "Server2.ReplicatedAdapter"); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } try { ctx["server"] = "Server3"; test(query->ice_context(ctx)->findAllReplicas(obj)[0]->ice_getAdapterId() == "Server3.Service.Service"); ctx["server"] = "Server1"; test(query->ice_context(ctx)->findAllReplicas(obj)[0]->ice_getAdapterId() == "Server1.ReplicatedAdapter"); ctx["server"] = "Server2"; test(query->ice_context(ctx)->findAllReplicas(obj)[0]->ice_getAdapterId() == "Server2.ReplicatedAdapter"); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } try { ctx["server"] = "Server3"; test(query->ice_context(ctx)->findObjectByType("::Test::TestIntf2")->ice_getAdapterId() == "Server3.Service.Service"); ctx["server"] = "Server1"; test(query->ice_context(ctx)->findObjectByType("::Test::TestIntf2")->ice_getAdapterId() == "Server1.ReplicatedAdapter"); ctx["server"] = "Server2"; test(query->ice_context(ctx)->findObjectByType("::Test::TestIntf2")->ice_getAdapterId() == "Server2.ReplicatedAdapter"); ctx["server"] = "Server3"; test(query->ice_context(ctx)->findObjectByTypeOnLeastLoadedNode( "::Test::TestIntf2", LoadSample5)->ice_getAdapterId() == "Server3.Service.Service"); ctx["server"] = "Server1"; test(query->ice_context(ctx)->findObjectByTypeOnLeastLoadedNode( "::Test::TestIntf2", LoadSample5)->ice_getAdapterId() == "Server1.ReplicatedAdapter"); ctx["server"] = "Server2"; test(query->ice_context(ctx)->findObjectByTypeOnLeastLoadedNode( "::Test::TestIntf2", LoadSample5)->ice_getAdapterId() == "Server2.ReplicatedAdapter"); ctx["server"] = "Server3"; test(query->ice_context(ctx)->findAllObjectsByType("::Test::TestIntf2")[0]->ice_getAdapterId() == "Server3.Service.Service"); ctx["server"] = "Server1"; test(query->ice_context(ctx)->findAllObjectsByType("::Test::TestIntf2")[0]->ice_getAdapterId() == "Server1.ReplicatedAdapter"); ctx["server"] = "Server2"; test(query->ice_context(ctx)->findAllObjectsByType("::Test::TestIntf2")[0]->ice_getAdapterId() == "Server2.ReplicatedAdapter"); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } removeServer(admin, "Server1"); removeServer(admin, "Server2"); removeServer(admin, "Server3"); } { map<string, string> params; params["replicaGroup"] = "Unknown"; params["id"] = "UnknownServer"; instantiateServer(admin, "Server", "localnode", params); TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("Unknown")); obj->getReplicaId(); removeServer(admin, "UnknownServer"); } { map<string, string> params; params["replicaGroup"] = "Exclude"; params["id"] = "ExcludeServer"; instantiateServer(admin, "Server", "localnode", params); TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("Exclude")); obj = TestIntfPrx::uncheckedCast(obj->ice_locatorCacheTimeout(0)); obj = TestIntfPrx::uncheckedCast(obj->ice_connectionCached(false)); try { obj->getReplicaId(); test(false); } catch(const Ice::NoEndpointException&) { } Ice::LocatorPrx locator = comm->getDefaultLocator(); try { Ice::Context ctx; ctx["server"] = "Server2"; obj->ice_locator(locator->ice_context(ctx))->getReplicaId(); test(false); } catch(const Ice::NoEndpointException&) { } try { Ice::Context ctx; ctx["server"] = "Server3"; obj->ice_locator(locator->ice_context(ctx))->getReplicaId(); test(false); } catch(const Ice::NoEndpointException&) { } Ice::Context ctx; ctx["server"] = "Server1"; string id = obj->ice_locator(locator->ice_context(ctx))->getReplicaId(); removeServer(admin, "ExcludeServer"); } cout << "ok" << endl; cout << "testing load balancing n-replicas... " << flush; { TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("RoundRobin-2")); obj = TestIntfPrx::uncheckedCast(obj->ice_locatorCacheTimeout(-1)); obj = TestIntfPrx::uncheckedCast(obj->ice_connectionCached(false)); try { obj->ice_ping(); test(false); } catch(const Ice::NoEndpointException&) { } map<string, string> params; params["replicaGroup"] = "RoundRobin-2"; params["id"] = "Server1"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server2"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server3"; instantiateServer(admin, "Server", "localnode", params); try { set<string> replicaIds; set<string> expected; replicaIds.insert("Server1.ReplicatedAdapter"); replicaIds.insert("Server2.ReplicatedAdapter"); expected = replicaIds; while(!replicaIds.empty()) { string replicaId = obj->getReplicaId(); test(expected.find(replicaId) != expected.end()); replicaIds.erase(replicaId); } obj->ice_locatorCacheTimeout(0)->ice_ping(); replicaIds.insert("Server2.ReplicatedAdapter"); replicaIds.insert("Server3.ReplicatedAdapter"); expected = replicaIds; while(!replicaIds.empty()) { string replicaId = obj->getReplicaId(); test(expected.find(replicaId) != expected.end()); replicaIds.erase(replicaId); } obj->ice_locatorCacheTimeout(0)->ice_ping(); replicaIds.insert("Server3.ReplicatedAdapter"); replicaIds.insert("Server1.ReplicatedAdapter"); expected = replicaIds; while(!replicaIds.empty()) { string replicaId = obj->getReplicaId(); test(expected.find(replicaId) != expected.end()); replicaIds.erase(replicaId); } admin->stopServer("Server1"); admin->stopServer("Server2"); admin->stopServer("Server3"); obj->ice_locatorCacheTimeout(0)->ice_ping(); int nRetry = 500; while(replicaIds.size() != 2 && --nRetry > 0) { replicaIds.insert(obj->getReplicaId()); } test(replicaIds.size() == 2); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } removeServer(admin, "Server1"); removeServer(admin, "Server2"); removeServer(admin, "Server3"); } { TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("RoundRobin-All")); obj = TestIntfPrx::uncheckedCast(obj->ice_locatorCacheTimeout(-1)); obj = TestIntfPrx::uncheckedCast(obj->ice_connectionCached(false)); try { obj->ice_ping(); test(false); } catch(const Ice::NoEndpointException&) { } map<string, string> params; params["replicaGroup"] = "RoundRobin-All"; params["id"] = "Server1"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server2"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server3"; instantiateServer(admin, "Server", "localnode", params); try { set<string> replicaIds; set<string> expected; replicaIds.insert("Server1.ReplicatedAdapter"); replicaIds.insert("Server2.ReplicatedAdapter"); replicaIds.insert("Server3.ReplicatedAdapter"); expected = replicaIds; while(!replicaIds.empty()) { string replicaId = obj->getReplicaId(); test(expected.find(replicaId) != expected.end()); replicaIds.erase(replicaId); } obj->ice_locatorCacheTimeout(0)->ice_ping(); replicaIds.insert("Server1.ReplicatedAdapter"); replicaIds.insert("Server2.ReplicatedAdapter"); replicaIds.insert("Server3.ReplicatedAdapter"); expected = replicaIds; while(!replicaIds.empty()) { string replicaId = obj->getReplicaId(); test(expected.find(replicaId) != expected.end()); replicaIds.erase(replicaId); } } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } removeServer(admin, "Server1"); removeServer(admin, "Server2"); removeServer(admin, "Server3"); } cout << "ok" << endl; cout << "testing replication with inactive nodes... " << flush; { map<string, string> params; params["replicaGroup"] = "Random"; params["id"] = "Server1"; instantiateServer(admin, "Server", "inactivenode", params); params["id"] = "Server2"; instantiateServer(admin, "Server", "localnode", params); TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("Random")); test(obj->getReplicaId() == "Server2.ReplicatedAdapter"); // // Also make sure that findObjectByTypeOnLeastLoadedNode still work. // obj = TestIntfPrx::uncheckedCast(query->findObjectByTypeOnLeastLoadedNode("::Test::TestIntf", LoadSample1)); test(obj->getReplicaId() == "Server2.ReplicatedAdapter"); removeServer(admin, "Server1"); removeServer(admin, "Server2"); params["replicaGroup"] = "RoundRobin"; params["id"] = "Server1"; instantiateServer(admin, "Server", "inactivenode", params); params["id"] = "Server2"; instantiateServer(admin, "Server", "localnode", params); obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("RoundRobin")); test(obj->getReplicaId() == "Server2.ReplicatedAdapter"); removeServer(admin, "Server1"); removeServer(admin, "Server2"); params["replicaGroup"] = "Adaptive"; params["id"] = "Server1"; instantiateServer(admin, "Server", "inactivenode", params); params["id"] = "Server2"; instantiateServer(admin, "Server", "localnode", params); obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("Adaptive")); test(obj->getReplicaId() == "Server2.ReplicatedAdapter"); removeServer(admin, "Server1"); removeServer(admin, "Server2"); params["replicaGroup"] = "Random"; params["id"] = "IceBox1"; instantiateServer(admin, "IceBox", "localnode", params); params["id"] = "Server1"; instantiateServer(admin, "Server", "inactivenode", params); obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("Random")); test(svcReplicaIds.find(obj->getReplicaId()) != svcReplicaIds.end()); removeServer(admin, "IceBox1"); removeServer(admin, "Server1"); }; cout << "ok" << endl; cout << "testing replica group from different applications... " << flush; { map<string, string> params; params["replicaGroup"] = "Random"; params["id"] = "Server1"; instantiateServer(admin, "Server", "localnode", params); ApplicationUpdateDescriptor update; update.name = "Test"; update.removeReplicaGroups.push_back("Random"); try { admin->updateApplication(update); test(false); } catch(const DeploymentException&) { // The Random replica goup is used by Server1! } // // Add an application Test1 without replica groups and a // server that uses the Random replica group. // ApplicationInfo app = admin->getApplicationInfo("Test"); app.descriptor.name = "Test1"; app.descriptor.replicaGroups.clear(); app.descriptor.nodes.clear(); try { admin->addApplication(app.descriptor); } catch(const DeploymentException& ex) { cerr << ex << endl; test(false); } params["id"] = "Server2"; instantiateServer(admin, "Server", "localnode", params, "Test1"); try { admin->removeApplication("Test"); test(false); } catch(const DeploymentException&) { // Test has a replica group referenced by the Test1 application. } TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy("Random")); obj = TestIntfPrx::uncheckedCast(obj->ice_locatorCacheTimeout(0)); obj = TestIntfPrx::uncheckedCast(obj->ice_connectionCached(false)); set<string> replicaIds; replicaIds.insert("Server1.ReplicatedAdapter"); replicaIds.insert("Server2.ReplicatedAdapter"); while(!replicaIds.empty()) { try { replicaIds.erase(obj->getReplicaId()); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } } removeServer(admin, "Server2"); removeServer(admin, "Server1"); ReplicaGroupDescriptor replicaGroup; replicaGroup.id = "ReplicatedAdapterFromTest1"; replicaGroup.loadBalancing = new RandomLoadBalancingPolicy(); replicaGroup.loadBalancing->nReplicas = "0"; update = ApplicationUpdateDescriptor(); update.name = "Test1"; update.replicaGroups.push_back(replicaGroup); try { admin->updateApplication(update); } catch(const DeploymentException& ex) { cerr << ex.reason << endl; test(false); } params["replicaGroup"] = "ReplicatedAdapterFromTest1"; params["id"] = "Server1"; instantiateServer(admin, "Server", "localnode", params); try { admin->removeApplication("Test1"); test(false); } catch(const DeploymentException&) { // ReplicatedAdapterFromTest1 used by server from Test } update = ApplicationUpdateDescriptor(); update.name = "Test1"; update.removeReplicaGroups.push_back("ReplicatedAdapterFromTest1"); try { admin->updateApplication(update); test(false); } catch(const DeploymentException&) { // ReplicatedAdapterFromTest1 used by server from Test } removeServer(admin, "Server1"); try { admin->updateApplication(update); } catch(const DeploymentException& ex) { cerr << ex << endl; test(false); } admin->removeApplication("Test1"); }; cout << "ok" << endl; cout << "testing replica group with different server encoding support... " << flush; { vector<string> loadBalancings; loadBalancings.push_back("Random"); loadBalancings.push_back("RoundRobin"); loadBalancings.push_back("RoundRobin-All"); for(vector<string>::const_iterator p = loadBalancings.begin(); p != loadBalancings.end(); ++p) { map<string, string> params; params["replicaGroup"] = *p; params["id"] = "Server1"; params["encoding"] = "1.0"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server2"; params["encoding"] = "1.1"; instantiateServer(admin, "Server", "localnode", params); params["id"] = "Server3"; params["encoding"] = "1.0"; instantiateServer(admin, "Server", "localnode", params); TestIntfPrx obj = TestIntfPrx::uncheckedCast(comm->stringToProxy(*p)); obj = obj->ice_locatorCacheTimeout(0); obj = obj->ice_connectionCached(false); for(int i = 0; i < 30; ++i) { test(obj->getReplicaId() == "Server2.ReplicatedAdapter"); } obj = obj->ice_encodingVersion(Ice::Encoding_1_0); set<string> replicaIds = serverReplicaIds; while(!replicaIds.empty()) { try { replicaIds.erase(obj->getReplicaId()); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } } removeServer(admin, "Server1"); removeServer(admin, "Server2"); removeServer(admin, "Server3"); } }; cout << "ok" << endl; session->destroy(); }
void NodeSessionManager::createdSession(const NodeSessionPrx& session) { bool activated; { Lock sync(*this); activated = _activated; } // // Synchronize the servers if the session is active and if the // node adapter has been activated (otherwise, the servers will be // synced after the node adapter activation, see activate()). // // We also set the replica observer to receive notifications of // replica addition/removal. // if(session && activated) { try { session->setReplicaObserver(_node->getProxy()); syncServers(session); } catch(const Ice::LocalException&) { } return; } // // If there's no master session or if the node adapter isn't // activated yet, we retrieve a list of the replicas either from // the master or from the known replicas (the ones configured with // Ice.Default.Locator) and we try to establish connections to // each of the replicas. // InternalRegistryPrxSeq replicas; if(session) { assert(!activated); // The node adapter isn't activated yet so // we're not subscribed yet to the replica // observer topic. try { replicas = _thread->getRegistry()->getReplicas(); } catch(const Ice::LocalException&) { } } else { vector<Ice::AsyncResultPtr> results; for(vector<QueryPrx>::const_iterator q = _queryObjects.begin(); q != _queryObjects.end(); ++q) { results.push_back((*q)->begin_findAllObjectsByType(InternalRegistry::ice_staticId())); } map<Ice::Identity, Ice::ObjectPrx> proxies; for(vector<Ice::AsyncResultPtr>::const_iterator p = results.begin(); p != results.end(); ++p) { QueryPrx query = QueryPrx::uncheckedCast((*p)->getProxy()); if(isDestroyed()) { return; } try { Ice::ObjectProxySeq prxs = query->end_findAllObjectsByType(*p); for(Ice::ObjectProxySeq::const_iterator q = prxs.begin(); q != prxs.end(); ++q) { // // NOTE: We might override a good proxy here! We could improve this to make // sure that we don't override the proxy for replica N if that proxy was // obtained from replica N. // proxies[(*q)->ice_getIdentity()] = *q; } } catch(const Ice::LocalException&) { // IGNORE } } for(map<Ice::Identity, Ice::ObjectPrx>::const_iterator q = proxies.begin(); q != proxies.end(); ++q) { replicas.push_back(InternalRegistryPrx::uncheckedCast(q->second)); } } vector<NodeSessionKeepAliveThreadPtr> sessions; { Lock sync(*this); if(_destroyed) { return; } // // If the node adapter was activated since we last check, we don't need // to initialize the replicas here, it will be done by replicaInit(). // if(!session || !_activated) { _replicas.clear(); for(InternalRegistryPrxSeq::const_iterator p = replicas.begin(); p != replicas.end(); ++p) { if((*p)->ice_getIdentity() != _master->ice_getIdentity()) { _replicas.insert((*p)->ice_getIdentity()); NodeSessionKeepAliveThreadPtr session = addReplicaSession(*p); session->tryCreateSession(false); sessions.push_back(session); } } } } // // Wait for the creation. It's important to wait to ensure that // the replica sessions are created before the node adapter is // activated. // IceUtil::Time before = IceUtil::Time::now(); for(vector<NodeSessionKeepAliveThreadPtr>::const_iterator p = sessions.begin(); p != sessions.end(); ++p) { if(isDestroyed()) { return; } IceUtil::Time timeout = IceUtil::Time::seconds(5) - (IceUtil::Time::now() - before); if(timeout <= IceUtil::Time()) { break; } (*p)->tryCreateSession(true, timeout); } }