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