void
instantiateServer(const AdminPrx& admin, const string& templ, const string& node, const map<string, string>& params,
const string& application = string("Test"))
{
ServerInstanceDescriptor desc;
desc._cpp_template = templ;
desc.parameterValues = params;
NodeUpdateDescriptor nodeUpdate;
nodeUpdate.name = node;
nodeUpdate.serverInstances.push_back(desc);
ApplicationUpdateDescriptor update;
update.name = application;
update.nodes.push_back(nodeUpdate);
try
{
admin->updateApplication(update);
}
catch(const DeploymentException& ex)
{
cerr << ex.reason << endl;
test(false);
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
assert(params.find("id") != params.end());
try
{
admin->startServer(params.find("id")->second);
}
catch(const NodeUnreachableException&)
{
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
}
void
removeServer(const AdminPrx& admin, const string& id)
{
try
{
admin->enableServer(id, false); // Makes sure the server isn't activated on-demand after the stop.
admin->stopServer(id);
}
catch(const ServerStopException&)
{
}
catch(const NodeUnreachableException&)
{
}
catch(const Ice::UserException& ex)
{
cerr << ex << endl;
test(false);
}
ServerInfo info = admin->getServerInfo(id);
NodeUpdateDescriptor nodeUpdate;
nodeUpdate.name = info.node;
nodeUpdate.removeServers.push_back(id);
ApplicationUpdateDescriptor update;
update.name = info.application;
update.nodes.push_back(nodeUpdate);
try
{
admin->updateApplication(update);
}
catch(const DeploymentException& ex)
{
cerr << ex.reason << endl;
test(false);
}
}
void
allTests(const Ice::CommunicatorPtr& communicator)
{
IceGrid::RegistryPrx registry = IceGrid::RegistryPrx::checkedCast(
communicator->stringToProxy(communicator->getDefaultLocator()->ice_getIdentity().category + "/Registry"));
test(registry);
AdminSessionPrx session = registry->createAdminSession("foo", "bar");
session->ice_getConnection()->setACM(registry->getACMTimeout(), IceUtil::None, Ice::HeartbeatAlways);
AdminPrx admin = session->getAdmin();
test(admin);
cout << "starting router... " << flush;
try
{
admin->startServer("Glacier2");
}
catch(const ServerStartException& ex)
{
cerr << ex.reason << endl;
test(false);
}
cout << "ok" << endl;
const int allocationTimeout = 5000;
Ice::ObjectPrx obj;
Ice::ObjectPrx dummy;
try
{
cout << "testing create session... " << flush;
SessionPrx session1 = registry->createSession("Client1", "");
SessionPrx session2 = registry->createSession("Client2", "");
cout << "ok" << endl;
cout << "testing allocate object by identity... " << flush;
Ice::Identity allocatable = Ice::stringToIdentity("allocatable");
Ice::Identity allocatablebis = Ice::stringToIdentity("allocatablebis");
try
{
session1->allocateObjectById(Ice::stringToIdentity("dummy"));
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session1->releaseObject(Ice::stringToIdentity("dummy"));
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session1->allocateObjectById(Ice::stringToIdentity("nonallocatable"));
test(false);
}
catch(const AllocationException&)
{
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session2->allocateObjectById(Ice::stringToIdentity("nonallocatable"));
test(false);
}
catch(const AllocationException&)
{
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session1->releaseObject(Ice::stringToIdentity("nonallocatable"));
test(false);
}
catch(const AllocationException&)
{
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session2->releaseObject(Ice::stringToIdentity("nonallocatable"));
test(false);
}
catch(const AllocationException&)
{
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
session1->allocateObjectById(allocatable);
try
{
session1->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationException&)
{
}
session1->setAllocationTimeout(0);
session2->setAllocationTimeout(0);
try
{
session2->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session2->releaseObject(allocatable);
test(false);
}
catch(const AllocationException&)
{
}
session1->allocateObjectById(allocatablebis);
try
{
session2->allocateObjectById(allocatablebis);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->releaseObject(allocatablebis);
session2->allocateObjectById(allocatablebis);
try
{
session1->allocateObjectById(allocatablebis);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session2->releaseObject(allocatablebis);
session2->setAllocationTimeout(allocationTimeout);
CallbackPtr asyncCB1 = new Callback();
IceGrid::Callback_Session_allocateObjectByIdPtr cb1 = IceGrid::newCallback_Session_allocateObjectById(asyncCB1,
&Callback::response,
&Callback::exception);
session2->begin_allocateObjectById(allocatable, cb1);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!asyncCB1->hasResponse(dummy));
session1->releaseObject(allocatable);
asyncCB1->waitResponse(__FILE__, __LINE__);
test(asyncCB1->hasResponse(dummy));
session1->setAllocationTimeout(0);
try
{
session1->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session1->releaseObject(allocatable);
test(false);
}
catch(const AllocationException&)
{
}
session1->setAllocationTimeout(allocationTimeout);
asyncCB1 = new Callback();
cb1 = IceGrid::newCallback_Session_allocateObjectById(asyncCB1,
&Callback::response,
&Callback::exception);
session1->begin_allocateObjectById(allocatable, cb1);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!asyncCB1->hasResponse(dummy));
session2->releaseObject(allocatable);
asyncCB1->waitResponse(__FILE__, __LINE__);
test(asyncCB1->hasResponse(dummy));
session1->releaseObject(allocatable);
cout << "ok" << endl;
cout << "testing allocate object by type... " << flush;
session1->setAllocationTimeout(0);
session2->setAllocationTimeout(0);
try
{
obj = session1->allocateObjectByType("::Unknown");
test(false);
}
catch(const AllocationTimeoutException&)
{
test(false);
}
catch(const AllocationException&)
{
}
try
{
obj = session1->allocateObjectByType("::NotAllocatable");
test(false);
}
catch(const AllocationTimeoutException&)
{
test(false);
}
catch(const AllocationException&)
{
}
obj = session1->allocateObjectByType("::Test");
test(obj && obj->ice_getIdentity().name == "allocatable");
try
{
session1->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationException&)
{
}
try
{
session2->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session2->releaseObject(obj->ice_getIdentity());
}
catch(const AllocationException&)
{
}
session1->releaseObject(obj->ice_getIdentity());
try
{
session1->releaseObject(obj->ice_getIdentity());
}
catch(const AllocationException&)
{
}
obj = session2->allocateObjectByType("::Test"); // Allocate the object
test(obj && obj->ice_getIdentity().name == "allocatable");
try
{
session2->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationException&)
{
}
try
{
session1->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->allocateObjectByType("::TestBis");
try
{
session2->allocateObjectByType("::TestBis");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->releaseObject(allocatablebis);
session2->allocateObjectByType("::TestBis");
try
{
session1->allocateObjectByType("::TestBis");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session2->releaseObject(allocatablebis);
session1->setAllocationTimeout(allocationTimeout);
CallbackPtr asyncCB3 = new Callback();
IceGrid::Callback_Session_allocateObjectByTypePtr cb3 =
IceGrid::newCallback_Session_allocateObjectByType(asyncCB3, &Callback::response, &Callback::exception);
session1->begin_allocateObjectByType("::Test", cb3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!asyncCB3->hasResponse(dummy));
session2->releaseObject(obj->ice_getIdentity());
asyncCB3->waitResponse(__FILE__, __LINE__);
test(asyncCB3->hasResponse(obj));
session1->releaseObject(obj->ice_getIdentity());
cout << "ok" << endl;
cout << "testing object allocation timeout... " << flush;
session1->allocateObjectById(allocatable);
IceUtil::Time time = IceUtil::Time::now();
session2->setAllocationTimeout(500);
try
{
session2->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationTimeoutException&)
{
test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now());
}
time = IceUtil::Time::now();
try
{
session2->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now());
time = IceUtil::Time::now();
try
{
session2->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now());
session1->releaseObject(allocatable);
session2->setAllocationTimeout(0);
cout << "ok" << endl;
cout << "testing server allocation... " << flush;
session1->setAllocationTimeout(0);
session2->setAllocationTimeout(0);
Ice::Identity allocatable3 = Ice::stringToIdentity("allocatable3");
Ice::Identity allocatable4 = Ice::stringToIdentity("allocatable4");
session1->allocateObjectById(allocatable3);
try
{
session2->allocateObjectById(allocatable3);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session2->allocateObjectById(allocatable4);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->allocateObjectById(allocatable4);
session1->releaseObject(allocatable3);
try
{
session2->allocateObjectById(allocatable3);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->releaseObject(allocatable4);
session2->allocateObjectById(allocatable3);
try
{
session1->allocateObjectById(allocatable3);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session1->allocateObjectById(allocatable4);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session2->allocateObjectById(allocatable4);
session2->releaseObject(allocatable3);
try
{
session1->allocateObjectById(allocatable3);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session1->allocateObjectByType("::TestServer1");
test(false);
}
catch(const AllocationException&)
{
}
try
{
session1->allocateObjectByType("::TestServer2");
test(false);
}
catch(const AllocationException&)
{
}
test(session2->allocateObjectByType("::TestServer1"));
try
{
session2->allocateObjectByType("::TestServer1");
test(false);
}
catch(const AllocationException&)
{
}
try
{
session2->allocateObjectByType("::TestServer2");
test(false);
}
catch(const AllocationException&)
{
}
session2->releaseObject(allocatable3);
session2->releaseObject(allocatable4);
session1->allocateObjectById(allocatable3);
session1->allocateObjectById(allocatable4);
session2->setAllocationTimeout(allocationTimeout);
asyncCB1 = new Callback();
cb1 = IceGrid::newCallback_Session_allocateObjectById(asyncCB1, &Callback::response, &Callback::exception);
session2->begin_allocateObjectById(allocatable3, cb1);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!asyncCB1->hasResponse(dummy));
session1->releaseObject(allocatable3);
test(!asyncCB1->hasResponse(dummy));
session1->releaseObject(allocatable4);
asyncCB1->waitResponse(__FILE__, __LINE__);
test(asyncCB1->hasResponse(dummy));
session2->releaseObject(allocatable3);
session1->setAllocationTimeout(allocationTimeout);
test(session2->allocateObjectByType("::TestServer1"));
asyncCB3 = new Callback();
cb3 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB3, &Callback::response, &Callback::exception);
session1->begin_allocateObjectByType("::TestServer2", cb3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!asyncCB3->hasResponse(dummy));
session2->releaseObject(allocatable3);
asyncCB3->waitResponse(__FILE__, __LINE__);
test(asyncCB3->hasResponse(dummy));
session1->releaseObject(allocatable4);
session1->setAllocationTimeout(0);
session2->setAllocationTimeout(0);
test(session1->allocateObjectByType("::TestMultipleByServer"));
try
{
session2->allocateObjectByType("::TestMultipleByServer");
test(false);
}
catch(const AllocationException&)
{
}
test(session1->allocateObjectByType("::TestMultipleByServer"));
session1->releaseObject(Ice::stringToIdentity("allocatable31"));
session1->releaseObject(Ice::stringToIdentity("allocatable41"));
test(session2->allocateObjectByType("::TestMultipleByServer"));
try
{
session1->allocateObjectByType("::TestMultipleByServer");
test(false);
}
catch(const AllocationException&)
{
}
test(session2->allocateObjectByType("::TestMultipleByServer"));
session2->releaseObject(Ice::stringToIdentity("allocatable31"));
session2->releaseObject(Ice::stringToIdentity("allocatable41"));
Ice::ObjectPrx obj1 = session1->allocateObjectByType("::TestMultipleServer");
test(obj1);
Ice::ObjectPrx obj2 = session2->allocateObjectByType("::TestMultipleServer");
test(obj2);
try
{
session1->allocateObjectByType("::TestMultipleServer");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session2->allocateObjectByType("::TestMultipleServer");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->releaseObject(obj1->ice_getIdentity());
obj1 = session2->allocateObjectByType("::TestMultipleServer");
session2->releaseObject(obj1->ice_getIdentity());
session2->releaseObject(obj2->ice_getIdentity());
cout << "ok" << endl;
cout << "testing concurrent allocations... " << flush;
session1->setAllocationTimeout(allocationTimeout);
session2->setAllocationTimeout(allocationTimeout);
session2->allocateObjectById(allocatable);
CallbackPtr asyncCB11 = new Callback();
IceGrid::Callback_Session_allocateObjectByIdPtr cb11 =
IceGrid::newCallback_Session_allocateObjectById(asyncCB11, &Callback::response, &Callback::exception);
CallbackPtr asyncCB12 = new Callback();
IceGrid::Callback_Session_allocateObjectByIdPtr cb12 =
IceGrid::newCallback_Session_allocateObjectById(asyncCB12, &Callback::response, &Callback::exception);
session1->begin_allocateObjectById(allocatable, cb11);
session1->begin_allocateObjectById(allocatable, cb12);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!asyncCB11->hasResponse(dummy));
test(!asyncCB12->hasResponse(dummy));
session2->releaseObject(allocatable);
asyncCB11->waitResponse(__FILE__, __LINE__);
asyncCB12->waitResponse(__FILE__, __LINE__);
test(asyncCB11->hasResponse(dummy) ? asyncCB12->hasException() : asyncCB12->hasResponse(dummy));
test(asyncCB12->hasResponse(dummy) ? asyncCB11->hasException() : asyncCB11->hasResponse(dummy));
session1->releaseObject(allocatable);
session2->allocateObjectById(allocatable);
CallbackPtr asyncCB31 = new Callback();
IceGrid::Callback_Session_allocateObjectByTypePtr cb31 =
IceGrid::newCallback_Session_allocateObjectByType(asyncCB31, &Callback::response, &Callback::exception);
CallbackPtr asyncCB32 = new Callback();
IceGrid::Callback_Session_allocateObjectByTypePtr cb32 =
IceGrid::newCallback_Session_allocateObjectByType(asyncCB32, &Callback::response, &Callback::exception);
session1->begin_allocateObjectByType("::Test", cb31);
session1->begin_allocateObjectByType("::Test", cb32);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!asyncCB31->hasResponse(dummy));
test(!asyncCB32->hasResponse(dummy));
session2->releaseObject(allocatable);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
do
{
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200));
}
while(!asyncCB31->hasResponse(dummy) && !asyncCB32->hasResponse(dummy));
test((asyncCB31->hasResponse(dummy) && dummy && !asyncCB32->hasResponse(dummy)) ||
(asyncCB32->hasResponse(dummy) && dummy && !asyncCB31->hasResponse(dummy)));
session1->releaseObject(allocatable);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
CallbackPtr asyncCB33 = asyncCB31->hasResponse(dummy) ? asyncCB32 : asyncCB31;
asyncCB33->waitResponse(__FILE__, __LINE__);
test(asyncCB33->hasResponse(dummy) && dummy);
session1->releaseObject(allocatable);
session2->allocateObjectById(allocatable3);
asyncCB11 = new Callback();
cb11 = IceGrid::newCallback_Session_allocateObjectById(asyncCB11, &Callback::response, &Callback::exception);
asyncCB12 = new Callback();
cb12 = IceGrid::newCallback_Session_allocateObjectById(asyncCB12, &Callback::response, &Callback::exception);
session1->begin_allocateObjectById(allocatable3, cb11);
session1->begin_allocateObjectById(allocatable3, cb12);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!asyncCB11->hasResponse(dummy));
test(!asyncCB12->hasResponse(dummy));
session2->releaseObject(allocatable3);
asyncCB11->waitResponse(__FILE__, __LINE__);
asyncCB12->waitResponse(__FILE__, __LINE__);
test(asyncCB11->hasResponse(dummy) ? asyncCB12->hasException() : asyncCB12->hasResponse(dummy));
test(asyncCB12->hasResponse(dummy) ? asyncCB11->hasException() : asyncCB11->hasResponse(dummy));
session1->releaseObject(allocatable3);
session2->allocateObjectById(allocatable3);
asyncCB31 = new Callback();
cb31 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB31, &Callback::response, &Callback::exception);
asyncCB32 = new Callback();
cb32 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB32, &Callback::response, &Callback::exception);
session1->begin_allocateObjectByType("::TestServer1", cb31);
session1->begin_allocateObjectByType("::TestServer1", cb32);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!asyncCB31->hasResponse(dummy));
test(!asyncCB32->hasResponse(dummy));
session2->releaseObject(allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
do
{
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200));
}
while(!asyncCB31->hasResponse(dummy) && !asyncCB32->hasResponse(dummy));
test((asyncCB31->hasResponse(dummy) && dummy && !asyncCB32->hasResponse(dummy)) ||
(asyncCB32->hasResponse(dummy) && dummy && !asyncCB31->hasResponse(dummy)));
session1->releaseObject(allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
asyncCB33 = asyncCB31->hasResponse(dummy) ? asyncCB32 : asyncCB31;
asyncCB33->waitResponse(__FILE__, __LINE__);
test(asyncCB33->hasResponse(dummy) && dummy);
session1->releaseObject(allocatable3);
session1->allocateObjectById(allocatable3);
asyncCB31 = new Callback();
cb31 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB31, &Callback::response, &Callback::exception);
asyncCB32 = new Callback();
cb32 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB32, &Callback::response, &Callback::exception);
session1->begin_allocateObjectByType("::TestServer1", cb31);
session1->begin_allocateObjectByType("::TestServer1", cb32);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!asyncCB31->hasResponse(dummy));
test(!asyncCB32->hasResponse(dummy));
session1->releaseObject(allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
do
{
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200));
}
while(!asyncCB31->hasResponse(dummy) && !asyncCB32->hasResponse(dummy));
test((asyncCB31->hasResponse(dummy) && dummy && !asyncCB32->hasResponse(dummy)) ||
(asyncCB32->hasResponse(dummy) && dummy && !asyncCB31->hasResponse(dummy)));
session1->releaseObject(allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
asyncCB33 = asyncCB31->hasResponse(dummy) ? asyncCB32 : asyncCB31;
asyncCB33->waitResponse(__FILE__, __LINE__);
test(asyncCB33->hasResponse(dummy) && dummy);
session1->releaseObject(allocatable3);
cout << "ok" << endl;
cout << "testing session destroy... " << flush;
obj = session2->allocateObjectByType("::Test"); // Allocate the object
test(obj && obj->ice_getIdentity().name == "allocatable");
session1->setAllocationTimeout(allocationTimeout);
asyncCB3 = new Callback();
cb3 = IceGrid::newCallback_Session_allocateObjectByType(asyncCB3, &Callback::response, &Callback::exception);
session1->begin_allocateObjectByType("::Test", cb3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!asyncCB3->hasResponse(dummy));
session2->destroy();
asyncCB3->waitResponse(__FILE__, __LINE__);
test(asyncCB3->hasResponse(obj));
session1->destroy();
session2 = SessionPrx::uncheckedCast(registry->createSession("Client2", ""));
session2->setAllocationTimeout(0);
session2->allocateObjectById(allocatable);
session2->destroy();
cout << "ok" << endl;
cout << "testing application updates with allocated objects... " << flush;
{
SessionPrx session1 = registry->createSession("Client1", "");
SessionPrx session2 = registry->createSession("Client2", "");
ServerDescriptorPtr objectAllocOriginal = admin->getServerInfo("ObjectAllocation").descriptor;
ServerDescriptorPtr objectAllocUpdate = ServerDescriptorPtr::dynamicCast(objectAllocOriginal->ice_clone());
ServerDescriptorPtr serverAllocOriginal = admin->getServerInfo("ServerAllocation").descriptor;
ServerDescriptorPtr serverAllocUpdate = ServerDescriptorPtr::dynamicCast(serverAllocOriginal->ice_clone());
NodeUpdateDescriptor nodeUpdate;
nodeUpdate.name = "localnode";
nodeUpdate.servers.push_back(objectAllocUpdate);
nodeUpdate.servers.push_back(serverAllocUpdate);
ApplicationUpdateDescriptor appUpdate;
appUpdate.name = "Test";
appUpdate.nodes.push_back(nodeUpdate);
{
session1->allocateObjectById(allocatable3);
Ice::AsyncResultPtr r2 = session2->begin_allocateObjectById(allocatable4);
session1->allocateObjectById(allocatable4);
session1->releaseObject(allocatable4);
test(!r2->isCompleted());
serverAllocUpdate->allocatable = false;
admin->updateApplication(appUpdate);
test(!r2->isCompleted());
session1->releaseObject(allocatable3);
session2->end_allocateObjectById(r2);
session2->releaseObject(allocatable4);
serverAllocUpdate->allocatable = true;
admin->updateApplication(appUpdate);
}
{
session1->allocateObjectById(allocatable);
Ice::AsyncResultPtr r2 = session2->begin_allocateObjectById(allocatable);
objectAllocUpdate->deactivationTimeout = "23";
admin->updateApplication(appUpdate);
session1->releaseObject(allocatable);
session2->end_allocateObjectById(r2);
session2->releaseObject(allocatable);
}
{
session1->allocateObjectById(allocatable);
Ice::AsyncResultPtr r2 = session2->begin_allocateObjectById(allocatable);
vector<ObjectDescriptor> allocatables = objectAllocUpdate->adapters[0].allocatables;
objectAllocUpdate->adapters[0].allocatables.clear(); // Remove the allocatable object
admin->updateApplication(appUpdate);
try
{
session2->end_allocateObjectById(r2);
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session1->releaseObject(allocatable);
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
objectAllocUpdate->adapters[0].allocatables = allocatables;
admin->updateApplication(appUpdate);
}
session1->destroy();
session2->destroy();
}
cout << "ok" << endl;
cout << "testing allocation with Glacier2 session... " << flush;
Ice::ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:default -p 12347");
Glacier2::RouterPrx router1 = Glacier2::RouterPrx::checkedCast(routerBase->ice_connectionId("client1"));
test(router1);
Glacier2::SessionPrx sessionBase = router1->createSession("test1", "abc123");
try
{
session1 = IceGrid::SessionPrx::checkedCast(sessionBase->ice_connectionId("client1")->ice_router(router1));
test(session1);
session1->ice_ping();
Ice::ObjectPrx obj;
obj = session1->allocateObjectById(allocatable)->ice_connectionId("client1")->ice_router(router1);
obj->ice_ping();
session1->releaseObject(allocatable);
try
{
obj->ice_ping();
}
catch(const Ice::ObjectNotExistException&)
{
}
obj = session1->allocateObjectById(allocatable3)->ice_connectionId("client1")->ice_router(router1);
obj->ice_ping();
obj2 = communicator->stringToProxy("allocatable4")->ice_connectionId("client1")->ice_router(router1);
obj2->ice_ping();
session1->releaseObject(allocatable3);
try
{
obj->ice_ping();
}
catch(const Ice::ObjectNotExistException&)
{
}
try
{
obj2->ice_ping();
}
catch(const Ice::ObjectNotExistException&)
{
}
session1->destroy();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "stress test... " << flush;
SessionPrx stressSession = registry->createSession("StressSession", "");
const int nClients = 10;
int i;
vector<StressClientPtr> clients;
for(i = 0; i < nClients - 2; ++i)
{
if(IceUtilInternal::random(2) == 1)
{
clients.push_back(new StressClient(i, registry, false));
}
else
{
clients.push_back(new StressClient(i, stressSession));
}
clients.back()->start();
}
clients.push_back(new StressClient(i++, registry, true));
clients.back()->start();
clients.push_back(new StressClient(i++, registry, true));
clients.back()->start();
for(vector<StressClientPtr>::const_iterator p = clients.begin(); p != clients.end(); ++p)
{
(*p)->notifyThread();
}
//
// Let the stress client run for a bit.
//
IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(8));
//
// Terminate the stress clients.
//
for(vector<StressClientPtr>::const_iterator q = clients.begin(); q != clients.end(); ++q)
{
(*q)->terminate();
(*q)->getThreadControl().join();
}
stressSession->destroy();
cout << "ok" << endl;
}
catch(const AllocationTimeoutException& ex)
{
cerr << ex << endl;
test(false);
}
catch(const AllocationException& ex)
{
cerr << ex.reason << endl;
test(false);
}
catch(const DeploymentException& ex)
{
cerr << ex.reason << endl;
test(false);
}
cout << "shutting down router... " << flush;
admin->stopServer("Glacier2");
cout << "ok" << endl;
session->destroy();
}
void
allTests(const Ice::CommunicatorPtr& communicator)
{
RegistryPrx registry = IceGrid::RegistryPrx::checkedCast(communicator->stringToProxy("IceGrid/Registry"));
test(registry);
AdminSessionPrx session = registry->createAdminSession("foo", "bar");
SessionKeepAliveThreadPtr keepAlive = new SessionKeepAliveThread(session, registry->getSessionTimeout()/2);
keepAlive->start();
AdminPrx admin = session->getAdmin();
test(admin);
cout << "testing distributions... " << flush;
{
admin->startServer("Test.IcePatch2");
admin->startServer("IcePatch2-Direct");
TestIntfPrx test;
test = TestIntfPrx::uncheckedCast(communicator->stringToProxy("server-all"));
test(test->getServerFile("rootfile") == "");
try
{
admin->patchServer("server-all", true);
}
catch(const PatchException& ex)
{
copy(ex.reasons.begin(), ex.reasons.end(), ostream_iterator<string>(cerr, "\n"));
test(false);
}
test(test->getServerFile("rootfile") == "rootfile");
test(test->getServerFile("dir1/file1") == "dummy-file1");
test(test->getServerFile("dir1/file2") == "dummy-file2");
test(test->getServerFile("dir2/file3") == "dummy-file3");
test(test->getApplicationFile("rootfile") == "");
test(test->getApplicationFile("dir1/file1") == "");
test(test->getApplicationFile("dir1/file2") == "");
test(test->getApplicationFile("dir2/file3") == "dummy-file3");
test = TestIntfPrx::uncheckedCast(communicator->stringToProxy("server-all-direct"));
test(test->getServerFile("rootfile") == "");
test(test->getServerFile("dir1/file1") == "");
test(test->getServerFile("dir1/file2") == "");
test(test->getServerFile("dir2/file3") == "");
test(test->getApplicationFile("rootfile") == "");
test(test->getApplicationFile("dir1/file1") == "");
test(test->getApplicationFile("dir1/file2") == "");
test(test->getApplicationFile("dir2/file3") == "dummy-file3");
try
{
admin->patchServer("server-all-direct", true);
}
catch(const PatchException& ex)
{
copy(ex.reasons.begin(), ex.reasons.end(), ostream_iterator<string>(cerr, "\n"));
test(false);
}
test(test->getServerFile("rootfile") == "rootfile");
test(test->getServerFile("dir1/file1") == "dummy-file1");
test(test->getServerFile("dir1/file2") == "dummy-file2");
test(test->getServerFile("dir2/file3") == "dummy-file3");
test(test->getApplicationFile("rootfile") == "");
test(test->getApplicationFile("dir1/file1") == "");
test(test->getApplicationFile("dir1/file2") == "");
test(test->getApplicationFile("dir2/file3") == "dummy-file3");
try
{
admin->patchApplication("Test", true);
}
catch(const PatchException& ex)
{
copy(ex.reasons.begin(), ex.reasons.end(), ostream_iterator<string>(cerr, "\n"));
test(false);
}
test = TestIntfPrx::uncheckedCast(communicator->stringToProxy("server-dir1"));
test(test->getServerFile("rootfile") == "");
test(test->getServerFile("dir1/file1") == "dummy-file1");
test(test->getServerFile("dir1/file2") == "dummy-file2");
test(test->getServerFile("dir2/file3") == "");
test(test->getApplicationFile("rootfile") == "");
test(test->getApplicationFile("dir1/file1") == "");
test(test->getApplicationFile("dir1/file2") == "");
test(test->getApplicationFile("dir2/file3") == "dummy-file3");
admin->stopServer("Test.IcePatch2");
admin->stopServer("IcePatch2-Direct");
}
cout << "ok" << endl;
cout << "testing distributions after update... " << flush;
{
ApplicationUpdateDescriptor update;
update.name = "Test";
update.variables["icepatch.directory"] = "${test.dir}/data/updated";
admin->updateApplication(update);
admin->startServer("Test.IcePatch2");
admin->startServer("IcePatch2-Direct");
TestIntfPrx test;
test = TestIntfPrx::uncheckedCast(communicator->stringToProxy("server-all"));
test(test->getServerFile("rootfile") == "rootfile");
try
{
admin->patchServer("server-all", true);
}
catch(const PatchException& ex)
{
copy(ex.reasons.begin(), ex.reasons.end(), ostream_iterator<string>(cerr, "\n"));
test(false);
}
test(test->getServerFile("rootfile") == "rootfile-updated!");
test(test->getServerFile("dir1/file1") == "");
test(test->getServerFile("dir1/file2") == "dummy-file2-updated!");
test(test->getServerFile("dir2/file3") == "dummy-file3");
test(test->getServerFile("dir2/file4") == "dummy-file4");
test(test->getApplicationFile("rootfile") == "");
test(test->getApplicationFile("dir1/file1") == "");
test(test->getApplicationFile("dir1/file2") == "");
test(test->getApplicationFile("dir2/file3") == "dummy-file3");
test(test->getApplicationFile("dir2/file4") == "dummy-file4");
try
{
admin->patchServer("server-all-direct", true);
}
catch(const PatchException& ex)
{
copy(ex.reasons.begin(), ex.reasons.end(), ostream_iterator<string>(cerr, "\n"));
test(false);
}
test = TestIntfPrx::uncheckedCast(communicator->stringToProxy("server-all-direct"));
test(test->getServerFile("rootfile") == "rootfile-updated!");
test(test->getServerFile("dir1/file1") == "");
test(test->getServerFile("dir1/file2") == "dummy-file2-updated!");
test(test->getServerFile("dir2/file3") == "dummy-file3");
test(test->getServerFile("dir2/file4") == "dummy-file4");
test(test->getApplicationFile("rootfile") == "");
test(test->getApplicationFile("dir1/file1") == "");
test(test->getApplicationFile("dir1/file2") == "");
test(test->getApplicationFile("dir2/file3") == "dummy-file3");
test(test->getApplicationFile("dir2/file4") == "dummy-file4");
try
{
admin->patchApplication("Test", true);
}
catch(const PatchException& ex)
{
copy(ex.reasons.begin(), ex.reasons.end(), ostream_iterator<string>(cerr, "\n"));
test(false);
}
test = TestIntfPrx::uncheckedCast(communicator->stringToProxy("server-dir1"));
test(test->getServerFile("rootfile") == "");
test(test->getServerFile("dir1/file1") == "");
test(test->getServerFile("dir1/file2") == "dummy-file2-updated!");
test(test->getServerFile("dir2/file3") == "");
test(test->getServerFile("dir2/file4") == "");
test(test->getApplicationFile("rootfile") == "");
test(test->getApplicationFile("dir1/file1") == "");
test(test->getApplicationFile("dir1/file2") == "");
test(test->getApplicationFile("dir2/file3") == "dummy-file3");
test(test->getApplicationFile("dir2/file4") == "dummy-file4");
admin->stopServer("Test.IcePatch2");
admin->stopServer("IcePatch2-Direct");
}
cout << "ok" << endl;
cout << "testing application distrib configuration... " << flush;
try
{
ApplicationDescriptor app = admin->getApplicationInfo("Test").descriptor;
admin->removeApplication("Test");
app.variables["icepatch.directory"] = "${test.dir}/data/original";
test(app.nodes["localnode"].servers[2]->id == "server-dir1");
app.nodes["localnode"].servers[2]->applicationDistrib = false;
admin->addApplication(app);
admin->startServer("Test.IcePatch2");
try
{
admin->patchServer("server-dir1", true);
}
catch(const PatchException& ex)
{
copy(ex.reasons.begin(), ex.reasons.end(), ostream_iterator<string>(cerr, "\n"));
test(false);
}
TestIntfPrx test = TestIntfPrx::uncheckedCast(communicator->stringToProxy("server-dir1"));
test(test->getServerFile("rootfile") == "");
test(test->getServerFile("dir1/file1") == "dummy-file1");
test(test->getServerFile("dir1/file2") == "dummy-file2");
test(test->getServerFile("dir2/file3") == "");
test(test->getApplicationFile("rootfile") == "");
test(test->getApplicationFile("dir1/file1") == "");
test(test->getApplicationFile("dir1/file2") == "");
test(test->getApplicationFile("dir2/file3") == "");
admin->removeApplication("Test");
admin->addApplication(app);
admin->startServer("Test.IcePatch2");
admin->startServer("IcePatch2-Direct");
try
{
admin->patchApplication("Test", true);
}
catch(const PatchException& ex)
{
copy(ex.reasons.begin(), ex.reasons.end(), ostream_iterator<string>(cerr, "\n"));
test(false);
}
test = TestIntfPrx::uncheckedCast(communicator->stringToProxy("server-dir1"));
test(test->getServerFile("rootfile") == "");
test(test->getServerFile("dir1/file1") == "dummy-file1");
test(test->getServerFile("dir1/file2") == "dummy-file2");
test(test->getServerFile("dir2/file3") == "");
test(test->getApplicationFile("rootfile") == "");
test(test->getApplicationFile("dir1/file1") == "");
test(test->getApplicationFile("dir1/file2") == "");
test(test->getApplicationFile("dir2/file3") == "dummy-file3");
admin->removeApplication("Test");
app.distrib.icepatch = "";
admin->addApplication(app);
admin->startServer("Test.IcePatch2");
admin->startServer("IcePatch2-Direct");
try
{
admin->patchServer("server-dir1", true);
}
catch(const PatchException& ex)
{
copy(ex.reasons.begin(), ex.reasons.end(), ostream_iterator<string>(cerr, "\n"));
test(false);
}
test = TestIntfPrx::uncheckedCast(communicator->stringToProxy("server-dir1"));
test(test->getServerFile("rootfile") == "");
test(test->getServerFile("dir1/file1") == "dummy-file1");
test(test->getServerFile("dir1/file2") == "dummy-file2");
test(test->getServerFile("dir2/file3") == "");
test(test->getApplicationFile("rootfile") == "");
test(test->getApplicationFile("dir1/file1") == "");
test(test->getApplicationFile("dir1/file2") == "");
test(test->getApplicationFile("dir2/file3") == "");
test = TestIntfPrx::uncheckedCast(communicator->stringToProxy("server-all"));
test(test->getServerFile("rootfile") == "");
test(test->getServerFile("dir1/file1") == "");
test(test->getServerFile("dir1/file2") == "");
test(test->getServerFile("dir2/file3") == "");
try
{
admin->patchApplication("Test", true);
}
catch(const PatchException& ex)
{
copy(ex.reasons.begin(), ex.reasons.end(), ostream_iterator<string>(cerr, "\n"));
test(false);
}
test(test->getServerFile("rootfile") == "rootfile");
test(test->getServerFile("dir1/file1") == "dummy-file1");
test(test->getServerFile("dir1/file2") == "dummy-file2");
test(test->getServerFile("dir2/file3") == "dummy-file3");
}
catch(const DeploymentException& ex)
{
cerr << ex << ":\n" << ex.reason << endl;
test(false);
}
cout << "ok" << endl;
keepAlive->destroy();
keepAlive->getThreadControl().join();
keepAlive = 0;
session->destroy();
}
void
allTests(const Ice::CommunicatorPtr& communicator)
{
IceGrid::RegistryPrx registry = IceGrid::RegistryPrx::checkedCast(
communicator->stringToProxy(communicator->getDefaultLocator()->ice_getIdentity().category + "/Registry"));
test(registry);
AdminSessionPrx session = registry->createAdminSession("foo", "bar");
session->ice_getConnection()->setACM(registry->getACMTimeout(), IceUtil::None, Ice::HeartbeatAlways);
AdminPrx admin = session->getAdmin();
test(admin);
Ice::PropertiesPtr properties = communicator->getProperties();
{
ApplicationDescriptor testApp;
testApp.name = "TestApp";
admin->addApplication(testApp);
ApplicationUpdateDescriptor empty;
empty.name = "TestApp";
NodeUpdateDescriptor node;
node.name = "localnode";
empty.nodes.push_back(node);
ApplicationUpdateDescriptor update = empty;
cout << "testing server add... " << flush;
ServerDescriptorPtr server = new ServerDescriptor();
server->id = "Server";
server->exe = properties->getProperty("TestDir") + "/server";
server->pwd = ".";
server->applicationDistrib = false;
server->allocatable = false;
addProperty(server, "Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
AdapterDescriptor adapter;
adapter.name = "Server";
adapter.id = "ServerAdapter";
adapter.registerProcess = false;
adapter.serverLifetime = false;
addProperty(server, "Server.Endpoints", "default");
ObjectDescriptor object;
object.id = communicator->stringToIdentity("test");
object.type = "::Test::TestIntf";
adapter.objects.push_back(object);
server->adapters.push_back(adapter);
update.nodes[0].servers.push_back(server);
admin->updateApplication(update);
update.nodes[0].servers[0]->id = "Server2";
try
{
admin->updateApplication(update);
test(false);
}
catch(const DeploymentException&)
{
// Adapter already exists
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
update.nodes[0].servers[0]->adapters[0].id = "ServerAdapter2";
try
{
admin->updateApplication(update);
test(false);
}
catch(const DeploymentException&)
{
// Object already exists
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
update.nodes[0].servers[0]->adapters[0].objects[0].id = communicator->stringToIdentity("test2");
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
TemplateDescriptor templ;
templ.parameters.push_back("name");
templ.descriptor = new ServerDescriptor();
server = ServerDescriptorPtr::dynamicCast(templ.descriptor);
server->id = "${name}";
server->exe = "${test.dir}/server";
server->pwd = ".";
server->applicationDistrib = false;
server->allocatable = false;
addProperty(server, "Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
adapter = AdapterDescriptor();
adapter.name = "Server";
adapter.id = "${server}";
adapter.registerProcess = false;
adapter.serverLifetime = false;
addProperty(server, "Server.Endpoints", "default");
object = ObjectDescriptor();
object.id = communicator->stringToIdentity("${server}");
object.type = "::Test::TestIntf";
adapter.objects.push_back(object);
server->adapters.push_back(adapter);
update = empty;
update.serverTemplates["ServerTemplate"] = templ;
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
update = empty;
ServerInstanceDescriptor instance;
instance._cpp_template = "ServerTemplate";
update.nodes[0].serverInstances.push_back(instance);
try
{
admin->updateApplication(update);
test(false);
}
catch(const DeploymentException&)
{
// Missing parameter
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
update = empty;
update.variables["test.dir"] = properties->getProperty("TestDir");
update.variables["variable"] = "";
instance = ServerInstanceDescriptor();
instance._cpp_template = "ServerTemplate";
instance.parameterValues["name"] = "Server1";
update.nodes[0].serverInstances.push_back(instance);
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing server remove... " << flush;
update = empty;
update.nodes[0].removeServers.push_back("Server2");
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
try
{
admin->getServerInfo("Server2");
test(false);
}
catch(const ServerNotExistException&)
{
}
try
{
admin->updateApplication(update);
}
catch(const DeploymentException& ex)
{
cerr << ex.reason << endl;
test(false);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
update = empty;
update.removeServerTemplates.push_back("ServerTemplate");
try
{
admin->updateApplication(update);
test(false);
}
catch(const DeploymentException&)
{
// Server without template!
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
update = empty;
update.nodes[0].removeServers.push_back("Server1");
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
try
{
admin->getServerInfo("Server1");
test(false);
}
catch(const ServerNotExistException&)
{
}
update = empty;
update.removeServerTemplates.push_back("ServerTemplate");
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing server update... " << flush;
ServerInfo info = admin->getServerInfo("Server");
test(info.descriptor);
addProperty(info.descriptor, "test", "test");
update = empty;
update.nodes[0].servers.push_back(info.descriptor);
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
info = admin->getServerInfo("Server");
test(info.descriptor);
test(getProperty(info.descriptor->propertySet.properties, "test") == "test");
update = empty;
update.serverTemplates["ServerTemplate"] = templ;
instance = ServerInstanceDescriptor();
instance._cpp_template = "ServerTemplate";
instance.parameterValues["name"] = "Server1";
update.nodes[0].serverInstances.push_back(instance);
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
update = empty;
addProperty(server, "test", "test");
assert(templ.descriptor == server);
update.serverTemplates["ServerTemplate"] = templ;
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
info = admin->getServerInfo("Server1");
test(info.descriptor);
test(getProperty(info.descriptor->propertySet.properties, "test") == "test");
info = admin->getServerInfo("Server");
test(info.descriptor);
adapter = AdapterDescriptor();
adapter.id = "Server1";
adapter.serverLifetime = false;
adapter.registerProcess = false;
info.descriptor->adapters.push_back(adapter);
update = empty;
update.nodes[0].servers.push_back(info.descriptor);
try
{
admin->updateApplication(update);
test(false);
}
catch(const DeploymentException&)
{
// Adapter already exists
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
info = admin->getServerInfo("Server");
test(info.descriptor);
adapter = AdapterDescriptor();
adapter.id = "ServerX";
adapter.serverLifetime = false;
adapter.registerProcess = false;
object = ObjectDescriptor();
object.id = communicator->stringToIdentity("test");
adapter.objects.push_back(object);
info.descriptor->adapters.push_back(adapter);
update = empty;
update.nodes[0].servers.push_back(info.descriptor);
try
{
admin->updateApplication(update);
test(false);
}
catch(const DeploymentException&)
{
// Object already exists
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
info = admin->getServerInfo("Server");
test(info.descriptor);
object = ObjectDescriptor();
object.id = communicator->stringToIdentity("test");
info.descriptor->adapters[0].objects.push_back(object);
update = empty;
update.nodes[0].servers.push_back(info.descriptor);
try
{
admin->updateApplication(update);
test(false);
}
catch(const DeploymentException&)
{
// Object already exists
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
info = admin->getServerInfo("Server");
test(info.descriptor);
object = ObjectDescriptor();
object.id = communicator->stringToIdentity("test1");
info.descriptor->adapters[0].allocatables.push_back(object);
update = empty;
update.nodes[0].servers.push_back(info.descriptor);
try
{
admin->updateApplication(update);
test(true);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
info = admin->getServerInfo("Server");
test(info.descriptor);
object = ObjectDescriptor();
object.id = communicator->stringToIdentity("test1");
info.descriptor->adapters[0].allocatables.push_back(object);
update = empty;
update.nodes[0].servers.push_back(info.descriptor);
try
{
admin->updateApplication(update);
test(false);
}
catch(const DeploymentException&)
{
// Object already exists
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
info = admin->getServerInfo("Server");
test(info.descriptor);
object = ObjectDescriptor();
object.id = communicator->stringToIdentity("test");
info.descriptor->adapters[0].allocatables.push_back(object);
update = empty;
update.nodes[0].servers.push_back(info.descriptor);
try
{
admin->updateApplication(update);
test(true);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
info = admin->getServerInfo("Server");
test(info.descriptor);
object = ObjectDescriptor();
object.id = communicator->stringToIdentity("test");
info.descriptor->adapters[0].allocatables.push_back(object);
update = empty;
update.nodes[0].servers.push_back(info.descriptor);
try
{
admin->updateApplication(update);
test(false);
}
catch(const DeploymentException&)
{
// Object already exists
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
admin->removeApplication("TestApp");
cout << "ok" << endl;
}
{
ApplicationDescriptor testApp;
testApp.name = "TestApp";
admin->addApplication(testApp);
ApplicationUpdateDescriptor empty;
empty.name = "TestApp";
NodeUpdateDescriptor node;
node.name = "localnode";
empty.nodes.push_back(node);
ApplicationUpdateDescriptor update = empty;
cout << "testing icebox server add... " << flush;
ServiceDescriptorPtr service = new ServiceDescriptor();
service->name = "Service1";
service->entry = "TestService:create";
AdapterDescriptor adapter;
adapter.name = "${service}";
adapter.id = "${server}.${service}";
adapter.registerProcess = false;
adapter.serverLifetime = false;
addProperty(service, "${service}.Endpoints", "default");
service->adapters.push_back(adapter);
IceBoxDescriptorPtr server = new IceBoxDescriptor();
server->id = "IceBox";
string iceboxExe = "/icebox";
#if defined(__linux)
# if defined(__i386)
iceboxExe += "32";
# endif
# if defined(ICE_CPP11)
iceboxExe += "++11";
# endif
#endif
#if defined(_WIN32) && !defined(NDEBUG)
iceboxExe += "d";
#endif
server->exe = properties->getProperty("IceBinDir") + iceboxExe;
server->applicationDistrib = false;
server->allocatable = false;
addProperty(server, "Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
server->services.resize(3);
server->services[0].descriptor = ServiceDescriptorPtr::dynamicCast(service->ice_clone());
service->name = "Service2";
server->services[1].descriptor = ServiceDescriptorPtr::dynamicCast(service->ice_clone());
service->name = "Service3";
server->services[2].descriptor = ServiceDescriptorPtr::dynamicCast(service->ice_clone());
update.nodes[0].servers.push_back(server);
try
{
admin->updateApplication(update);
}
catch(const DeploymentException& ex)
{
cerr << ex.reason << endl;
test(false);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing service add... " << flush;
service->name = "First";
server->services.resize(4);
server->services[3].descriptor = service;
try
{
admin->updateApplication(update);
}
catch(const DeploymentException& ex)
{
cerr << ex.reason << endl;
test(false);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing service remove... " << flush;
server->services.resize(3);
try
{
admin->updateApplication(update);
}
catch(const DeploymentException& ex)
{
cerr << ex.reason << endl;
test(false);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
admin->removeApplication("TestApp");
}
{
cout << "testing node add... " << flush;
ApplicationDescriptor testApp;
testApp.name = "TestApp";
NodeDescriptor node;
node.variables["nodename"] = "node1";
testApp.nodes["node1"] = node;
try
{
admin->addApplication(testApp);
}
catch(const DeploymentException& ex)
{
cerr << ex.reason << endl;
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
ApplicationUpdateDescriptor update;
update.name = "TestApp";
NodeUpdateDescriptor nodeUpdate;
nodeUpdate.name = "node2";
nodeUpdate.variables["nodename"] = "node2";
update.nodes.push_back(nodeUpdate);
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
testApp = admin->getApplicationInfo("TestApp").descriptor;
test(testApp.nodes.size() == 2);
test(testApp.nodes["node1"].variables["nodename"] == "node1");
test(testApp.nodes["node2"].variables["nodename"] == "node2");
cout << "ok" << endl;
cout << "testing node update... " << flush;
nodeUpdate.name = "node2";
nodeUpdate.variables["nodename"] = "node2updated";
update.nodes.back() = nodeUpdate;
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
testApp = admin->getApplicationInfo("TestApp").descriptor;
test(testApp.nodes.size() == 2);
test(testApp.nodes["node1"].variables["nodename"] == "node1");
test(testApp.nodes["node2"].variables["nodename"] == "node2updated");
cout << "ok" << endl;
cout << "testing node remove... " << flush;
update.nodes.clear();
update.removeNodes.push_back("node1");
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
testApp = admin->getApplicationInfo("TestApp").descriptor;
test(testApp.nodes.size() == 1);
test(testApp.nodes["node2"].variables["nodename"] == "node2updated");
admin->removeApplication("TestApp");
cout << "ok" << endl;
}
{
cout << "testing variable update... " << flush;
ServerDescriptorPtr server = new ServerDescriptor();
server->id = "${name}";
server->exe = "server";
server->pwd = ".";
server->applicationDistrib = false;
server->allocatable = false;
addProperty(server, "ApplicationVar", "${appvar}");
addProperty(server, "NodeVar", "${nodevar}");
addProperty(server, "ServerParamVar", "${serverparamvar}");
TemplateDescriptor templ;
templ.parameters.push_back("name");
templ.parameters.push_back("serverparamvar");
templ.descriptor = server;
ApplicationDescriptor testApp;
testApp.name = "TestApp";
testApp.variables["appvar"] = "AppValue";
testApp.serverTemplates["ServerTemplate"] = templ;
NodeDescriptor node;
node.variables["nodevar"] = "NodeValue";
ServerInstanceDescriptor serverInstance;
serverInstance._cpp_template = "ServerTemplate";
serverInstance.parameterValues["name"] = "Server";
serverInstance.parameterValues["serverparamvar"] = "ServerParamValue";
node.serverInstances.push_back(serverInstance);
testApp.nodes["node1"] = node;
try
{
admin->addApplication(testApp);
}
catch(const DeploymentException& ex)
{
cerr << ex.reason << endl;
test(false);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
ApplicationUpdateDescriptor empty;
empty.name = "TestApp";
ApplicationUpdateDescriptor update = empty;
update.removeVariables.push_back("appvar");
try
{
admin->updateApplication(update);
test(false);
}
catch(const DeploymentException&)
{
// Missing app variable
//cerr << ex.reason << endl;
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
update = empty;
NodeUpdateDescriptor nodeUpdate;
nodeUpdate.name = "node1";
nodeUpdate.removeVariables.push_back("nodevar");
update.nodes.push_back(nodeUpdate);
try
{
admin->updateApplication(update);
test(false);
}
catch(const DeploymentException&)
{
// Missing node variable
//cerr << ex.reason << endl;
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
update = empty;
serverInstance = ServerInstanceDescriptor();
serverInstance._cpp_template = "ServerTemplate";
serverInstance.parameterValues["name"] = "Server";
nodeUpdate = NodeUpdateDescriptor();
nodeUpdate.name = "node1";
nodeUpdate.serverInstances.push_back(serverInstance);
update.nodes.push_back(nodeUpdate);
try
{
admin->updateApplication(update);
test(false);
}
catch(const DeploymentException&)
{
// Missing parameter
//cerr << ex.reason << endl;
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
ServerInfo serverBefore = admin->getServerInfo("Server");
ApplicationDescriptor origApp = admin->getApplicationInfo("TestApp").descriptor;
update = empty;
update.variables["nodevar"] = "appoverride";
nodeUpdate = NodeUpdateDescriptor();
nodeUpdate.name = "node1";
nodeUpdate.variables["serverparamvar"] = "nodeoverride";
update.nodes.push_back(nodeUpdate);
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
ServerInfo serverAfter = admin->getServerInfo("Server");
test(serverBefore.descriptor->propertySet == serverAfter.descriptor->propertySet);
update = empty;
nodeUpdate = NodeUpdateDescriptor();
nodeUpdate.name = "node1";
nodeUpdate.variables["appvar"] = "nodeoverride";
update.nodes.push_back(nodeUpdate);
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
serverAfter = admin->getServerInfo("Server");
PropertyDescriptorSeq newProps = serverAfter.descriptor->propertySet.properties;
test(getProperty(serverAfter.descriptor->propertySet.properties, "ApplicationVar") == "nodeoverride");
test(getProperty(serverAfter.descriptor->propertySet.properties, "NodeVar") == "NodeValue");
test(getProperty(serverAfter.descriptor->propertySet.properties, "ServerParamVar") == "ServerParamValue");
admin->removeApplication("TestApp");
cout << "ok" << endl;
}
{
cout << "testing property set update... " << flush;
ServiceDescriptorPtr service = new ServiceDescriptor();
service->name = "${name}";
service->entry = "dummy";
addProperty(service, "ServiceProp", "test");
TemplateDescriptor svcTempl;
svcTempl.parameters.push_back("name");
svcTempl.descriptor = service;
ServiceInstanceDescriptor serviceInstance;
serviceInstance._cpp_template = "ServiceTemplate";
serviceInstance.parameterValues["name"] = "Service";
serviceInstance.propertySet.properties.push_back(createProperty("ServiceInstanceProp", "test"));
IceBoxDescriptorPtr server = new IceBoxDescriptor();
server->id = "${name}";
server->exe = "server";
server->pwd = ".";
server->applicationDistrib = false;
server->allocatable = false;
server->propertySet.references.push_back("ApplicationPropertySet");
server->propertySet.references.push_back("NodePropertySet");
addProperty(server, "ServerProp", "test");
server->services.push_back(serviceInstance);
TemplateDescriptor templ;
templ.parameters.push_back("name");
templ.descriptor = server;
ApplicationDescriptor testApp;
testApp.name = "TestApp";
testApp.variables["appvar"] = "AppValue";
testApp.serverTemplates["ServerTemplate"] = templ;
testApp.serviceTemplates["ServiceTemplate"] = svcTempl;
testApp.propertySets["ApplicationPropertySet"].properties.push_back(createProperty("ApplicationProp","test"));
testApp.propertySets["ApplicationPropertySet1"].properties.push_back(createProperty("ApplicationProp", "d"));
NodeDescriptor node;
node.variables["nodevar"] = "NodeValue";
node.propertySets["NodePropertySet"].properties.push_back(createProperty("NodeProp", "test"));
node.propertySets["NodePropertySet1"].properties.push_back(createProperty("NodeProp", "test"));
ServerInstanceDescriptor serverInstance;
serverInstance._cpp_template = "ServerTemplate";
serverInstance.parameterValues["name"] = "Server";
serverInstance.propertySet.properties.push_back(createProperty("ServerInstanceProp", "test"));
node.serverInstances.push_back(serverInstance);
testApp.nodes["node1"] = node;
try
{
admin->addApplication(testApp);
}
catch(const DeploymentException& ex)
{
cerr << ex.reason << endl;
test(false);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
ServerInfo info = admin->getServerInfo("Server");
test(hasProperty(info.descriptor, "ServerProp", "test"));
test(hasProperty(info.descriptor, "NodeProp", "test"));
test(hasProperty(info.descriptor, "ApplicationProp", "test"));
test(hasProperty(info.descriptor, "ServerInstanceProp", "test"));
ServiceDescriptorPtr svc = IceBoxDescriptorPtr::dynamicCast(info.descriptor)->services[0].descriptor;
test(hasProperty(svc, "ServiceProp", "test"));
ApplicationUpdateDescriptor empty;
empty.name = "TestApp";
ApplicationUpdateDescriptor update;
update = empty;
service->propertySet.properties.clear();
addProperty(service, "ServiceProp", "updated");
svcTempl.descriptor = service;
update.serviceTemplates["ServiceTemplate"] = svcTempl;
admin->updateApplication(update);
info = admin->getServerInfo("Server");
svc = IceBoxDescriptorPtr::dynamicCast(info.descriptor)->services[0].descriptor;
test(hasProperty(svc, "ServiceProp", "updated"));
update = empty;
serviceInstance.propertySet.properties.clear();
serviceInstance.propertySet.properties.push_back(createProperty("ServiceInstanceProp", "updated"));
server->services.clear();
server->services.push_back(serviceInstance);
templ.descriptor = server;
update.serverTemplates["ServerTemplate"] = templ;
admin->updateApplication(update);
info = admin->getServerInfo("Server");
svc = IceBoxDescriptorPtr::dynamicCast(info.descriptor)->services[0].descriptor;
test(hasProperty(svc, "ServiceInstanceProp", "updated"));
update = empty;
server->propertySet.properties.clear();
addProperty(server, "ServerProp", "updated");
templ.descriptor = server;
update.serverTemplates["ServerTemplate"] = templ;
admin->updateApplication(update);
info = admin->getServerInfo("Server");
test(hasProperty(info.descriptor, "ServerProp", "updated"));
update = empty;
serverInstance.propertySet.properties.clear();
serverInstance.propertySet.properties.push_back(createProperty("ServerInstanceProp", "updated"));
NodeUpdateDescriptor nodeUpdate;
nodeUpdate.name = "node1";
nodeUpdate.serverInstances.push_back(serverInstance);
update.nodes.push_back(nodeUpdate);
admin->updateApplication(update);
info = admin->getServerInfo("Server");
test(hasProperty(info.descriptor, "ServerInstanceProp", "updated"));
update = empty;
nodeUpdate.name = "node1";
nodeUpdate.serverInstances.clear();
nodeUpdate.propertySets["NodePropertySet"].properties.clear();
nodeUpdate.propertySets["NodePropertySet"].properties.push_back(
createProperty("NodeProp", "updated"));
nodeUpdate.removePropertySets.push_back("NodePropertySet1");
update.nodes.push_back(nodeUpdate);
admin->updateApplication(update);
info = admin->getServerInfo("Server");
test(hasProperty(info.descriptor, "NodeProp", "updated"));
ApplicationDescriptor updatedApplication = admin->getApplicationInfo("TestApp").descriptor;
test(updatedApplication.nodes["node1"].propertySets.find("NodePropertySet1") ==
updatedApplication.nodes["node1"].propertySets.end());
update = empty;
update.propertySets["ApplicationPropertySet"].properties.clear();
update.propertySets["ApplicationPropertySet"].properties.push_back(
createProperty("ApplicationProp", "updated"));
update.removePropertySets.push_back("ApplicationPropertySet1");
admin->updateApplication(update);
info = admin->getServerInfo("Server");
test(hasProperty(info.descriptor, "ApplicationProp", "updated"));
updatedApplication = admin->getApplicationInfo("TestApp").descriptor;
test(updatedApplication.propertySets.find("ApplicationPropertySet1") ==
updatedApplication.propertySets.end());
admin->removeApplication("TestApp");
cout << "ok" << endl;
}
{
cout << "testing description update... " << flush;
ApplicationDescriptor testApp;
testApp.name = "TestApp";
testApp.description = "Description";
try
{
admin->addApplication(testApp);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
testApp = admin->getApplicationInfo("TestApp").descriptor;
test(testApp.description == "Description");
ApplicationUpdateDescriptor update;
update.name = "TestApp";
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
testApp = admin->getApplicationInfo("TestApp").descriptor;
test(testApp.description == "Description");
update.description = new BoxedString("updatedDescription");
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
testApp = admin->getApplicationInfo("TestApp").descriptor;
test(testApp.description == "updatedDescription");
update.description = new BoxedString("");
try
{
admin->updateApplication(update);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
testApp = admin->getApplicationInfo("TestApp").descriptor;
test(testApp.description == "");
admin->removeApplication("TestApp");
cout << "ok" << endl;
}
{
cout << "testing server node move... " << flush;
ApplicationDescriptor nodeApp;
nodeApp.name = "NodeApp";
ServerDescriptorPtr server = new ServerDescriptor();
server->id = "node-${index}";
#if defined(NDEBUG) || !defined(_WIN32)
server->exe = properties->getProperty("IceBinDir") + "/icegridnode";
#else
server->exe = properties->getProperty("IceBinDir") + "/icegridnoded";
#endif
server->pwd = ".";
server->applicationDistrib = false;
server->allocatable = false;
server->options.push_back("--nowarn");
addProperty(server, "IceGrid.Node.Name", "node-${index}");
addProperty(server, "IceGrid.Node.Data", properties->getProperty("TestDir") + "/db/node-${index}");
addProperty(server, "IceGrid.Node.Endpoints", "default");
addProperty(server, "IceGrid.Node.PropertiesOverride", properties->getProperty("NodePropertiesOverride"));
addProperty(server, "Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
nodeApp.serverTemplates["nodeTemplate"].descriptor = server;
nodeApp.serverTemplates["nodeTemplate"].parameters.push_back("index");
ServerInstanceDescriptor instance;
instance._cpp_template = "nodeTemplate";
instance.parameterValues["index"] = "1";
nodeApp.nodes["localnode"].serverInstances.push_back(instance);
instance.parameterValues["index"] = "2";
nodeApp.nodes["localnode"].serverInstances.push_back(instance);
try
{
admin->addApplication(nodeApp);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
admin->startServer("node-1");
admin->startServer("node-2");
//
// We need to wait because the node might not be fully started
// here (the node adapter isn't indirect, so we can't use the
// wait-for-activation feature here.)
//
int retry = 0;
while(retry < 20)
{
try
{
if(admin->pingNode("node-1") && admin->pingNode("node-2"))
{
break;
}
}
catch(const NodeNotExistException&)
{
}
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
++retry;
}
test(admin->pingNode("node-1"));
test(admin->pingNode("node-2"));
ApplicationDescriptor testApp;
testApp.name = "TestApp";
server = new ServerDescriptor();
server->id = "Server";
server->exe = properties->getProperty("TestDir") + "/server";
server->pwd = ".";
server->applicationDistrib = false;
server->allocatable = false;
addProperty(server, "Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
AdapterDescriptor adapter;
adapter.name = "Server";
adapter.id = "ServerAdapter";
adapter.registerProcess = false;
adapter.serverLifetime = true;
server->adapters.push_back(adapter);
addProperty(server, "Server.Endpoints", "default");
testApp.nodes["node-1"].servers.push_back(server);
try
{
admin->addApplication(testApp);
}
catch(const DeploymentException& ex)
{
cerr << ex.reason << endl;
test(false);
}
try
{
admin->startServer("Server");
test(admin->getServerState("Server") == Active);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
ApplicationUpdateDescriptor update;
update.name = "TestApp";
NodeUpdateDescriptor nodeUpdate;
nodeUpdate.name = "node-1";
nodeUpdate.removeServers.push_back("Server");
update.nodes.push_back(nodeUpdate);
nodeUpdate.name = "node-2";
nodeUpdate.servers.push_back(server);
nodeUpdate.removeServers.clear();
update.nodes.push_back(nodeUpdate);
try
{
admin->updateApplication(update);
}
catch(const DeploymentException& ex)
{
cerr << ex.reason << endl;
test(false);
}
while(true)
{
try
{
test(admin->getServerInfo("Server").node == "node-2" && admin->getServerState("Server") == Inactive);
admin->startServer("Server");
test(admin->getServerState("Server") == Active);
break;
}
catch(const DeploymentException&)
{
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200));
}
}
IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(1));
update = ApplicationUpdateDescriptor();
update.name = "TestApp";
nodeUpdate = NodeUpdateDescriptor();
nodeUpdate.name = "node-2";
nodeUpdate.removeServers.push_back("Server");
update.nodes.push_back(nodeUpdate);
nodeUpdate = NodeUpdateDescriptor();
nodeUpdate.name = "unknownNode";
nodeUpdate.servers.push_back(server);
update.nodes.push_back(nodeUpdate);
try
{
admin->updateApplication(update);
}
catch(const DeploymentException& ex)
{
cerr << ex.reason << endl;
test(false);
}
try
{
admin->getServerState("Server");
test(false);
}
catch(const NodeUnreachableException&)
{
}
try
{
admin->removeApplication("TestApp");
}
catch(const DeploymentException& ex)
{
cerr << ex.reason << endl;
test(false);
}
admin->stopServer("node-1");
admin->stopServer("node-2");
try
{
admin->removeApplication("NodeApp");
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
}
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();
}