void
CallbackClient::run(int argc, char** argv)
{
//
// We must disable connection warnings, because we attempt to ping
// the router before session establishment, as well as after
// session destruction. Both will cause a ConnectionLostException.
//
initData.properties = createTestProperties(argc, argv);
initData.properties->setProperty("Ice.Warn.Connections", "0");
Ice::CommunicatorHolder communicator = initialize(argc, argv, initData);
ObjectPrx routerBase;
{
cout << "testing stringToProxy for router... " << flush;
routerBase = communicator->stringToProxy("Glacier2/router:" + getTestEndpoint(50));
cout << "ok" << endl;
}
Glacier2::RouterPrx router;
{
cout << "testing checked cast for router... " << flush;
router = Glacier2::RouterPrx::checkedCast(routerBase);
test(router);
cout << "ok" << endl;
}
{
cout << "testing router finder... " << flush;
Ice::RouterFinderPrx finder =
RouterFinderPrx::uncheckedCast(communicator->stringToProxy("Ice/RouterFinder:" + getTestEndpoint(50)));
test(finder->getRouter()->ice_getIdentity() == router->ice_getIdentity());
cout << "ok" << endl;
}
{
cout << "installing router with communicator... " << flush;
communicator->setDefaultRouter(router);
cout << "ok" << endl;
}
{
cout << "getting the session timeout... " << flush;
Ice::Long timeout = router->getSessionTimeout();
test(timeout == 30);
cout << "ok" << endl;
}
ObjectPrx base;
{
cout << "testing stringToProxy for server object... " << flush;
base = communicator->stringToProxy("c1/callback:" + getTestEndpoint());
cout << "ok" << endl;
}
{
cout << "trying to ping server before session creation... " << flush;
try
{
base->ice_ping();
test(false);
}
catch(const ConnectionLostException&)
{
cout << "ok" << endl;
}
}
Glacier2::SessionPrx session;
{
cout << "trying to create session with wrong password... " << flush;
try
{
session = router->createSession("userid", "xxx");
test(false);
}
catch(const Glacier2::PermissionDeniedException&)
{
cout << "ok" << endl;
}
}
{
cout << "trying to destroy non-existing session... " << flush;
try
{
router->destroySession();
test(false);
}
catch(const Glacier2::SessionNotExistException&)
{
cout << "ok" << endl;
}
}
{
cout << "creating session with correct password... " << flush;
try
{
session = router->createSession("userid", "abc123");
cout << "ok" << endl;
}
catch(const Glacier2::PermissionDeniedException& ex)
{
cerr << ex << ":\n" << ex.reason << endl;
test(false);
}
}
{
cout << "trying to create a second session... " << flush;
try
{
router->createSession("userid", "abc123");
test(false);
}
catch(const Glacier2::CannotCreateSessionException&)
{
cout << "ok" << endl;
}
}
{
cout << "pinging server after session creation... " << flush;
base->ice_ping();
cout << "ok" << endl;
}
{
cout << "pinging object with client endpoint... " << flush;
Ice::ObjectPrx baseC = communicator->stringToProxy("collocated:" + getTestEndpoint(50));
try
{
baseC->ice_ping();
}
catch(const Ice::ObjectNotExistException&)
{
}
cout << "ok" << endl;
}
CallbackPrx twoway;
{
cout << "testing checked cast for server object... " << flush;
twoway = CallbackPrx::checkedCast(base);
test(twoway);
cout << "ok" << endl;
}
ObjectAdapterPtr adapter;
{
cout << "creating and activating callback receiver adapter with router... " << flush;
communicator->getProperties()->setProperty("Ice.PrintAdapterReady", "0");
adapter = communicator->createObjectAdapterWithRouter("CallbackReceiverAdapter", router);
adapter->activate();
cout << "ok" << endl;
}
string category;
{
cout << "getting category from router... " << flush;
category = router->getCategoryForClient();
cout << "ok" << endl;
}
CallbackReceiverI* callbackReceiverImpl;
ObjectPtr callbackReceiver;
CallbackReceiverPrx twowayR;
CallbackReceiverPrx fakeTwowayR;
{
cout << "creating and adding callback receiver object... " << flush;
callbackReceiverImpl = new CallbackReceiverI;
callbackReceiver = callbackReceiverImpl;
Identity callbackReceiverIdent;
callbackReceiverIdent.name = "callbackReceiver";
callbackReceiverIdent.category = category;
twowayR = CallbackReceiverPrx::uncheckedCast(adapter->add(callbackReceiver, callbackReceiverIdent));
Identity fakeCallbackReceiverIdent;
fakeCallbackReceiverIdent.name = "callbackReceiver";
fakeCallbackReceiverIdent.category = "dummy";
fakeTwowayR = CallbackReceiverPrx::uncheckedCast(adapter->add(callbackReceiver, fakeCallbackReceiverIdent));
cout << "ok" << endl;
}
{
cout << "testing oneway callback... " << flush;
CallbackPrx oneway = CallbackPrx::uncheckedCast(twoway->ice_oneway());
CallbackReceiverPrx onewayR = CallbackReceiverPrx::uncheckedCast(twowayR->ice_oneway());
Context context;
context["_fwd"] = "o";
oneway->initiateCallback(onewayR, context);
oneway->initiateCallback(onewayR, context);
oneway->initiateCallback(onewayR, context);
oneway->initiateCallback(onewayR, context);
callbackReceiverImpl->callbackOK(4);
cout << "ok" << endl;
}
{
cout << "testing twoway callback... " << flush;
Context context;
context["_fwd"] = "t";
twoway->initiateCallback(twowayR, context);
twoway->initiateCallback(twowayR, context);
twoway->initiateCallback(twowayR, context);
twoway->initiateCallback(twowayR, context);
callbackReceiverImpl->callbackOK(4);
cout << "ok" << endl;
}
{
cout << "testing batch oneway callback... " << flush;
Context context;
context["_fwd"] = "O";
CallbackPrx batchOneway = CallbackPrx::uncheckedCast(twoway->ice_batchOneway());
CallbackReceiverPrx onewayR = CallbackReceiverPrx::uncheckedCast(twowayR->ice_oneway());
batchOneway->initiateCallback(onewayR, context);
batchOneway->initiateCallback(onewayR, context);
batchOneway->initiateCallback(onewayR, context);
batchOneway->initiateCallback(onewayR, context);
batchOneway->initiateCallback(onewayR, context);
batchOneway->initiateCallback(onewayR, context);
batchOneway->ice_flushBatchRequests();
callbackReceiverImpl->callbackOK(6);
cout << "ok" << endl;
}
//
// Send 3 twoway request to callback the receiver. The callback
// receiver only reply to the callback once it received the 3
// callbacks. This test ensures that Glacier2 doesn't serialize
// twoway requests (see bug 337 for more information).
//
{
cout << "testing concurrent twoway callback... " << flush;
Context context;
context["_fwd"] = "t";
AsyncCallbackPtr cb0 = new AsyncCallback();
twoway->begin_initiateConcurrentCallback(0, twowayR, context,
newCallback_Callback_initiateConcurrentCallback(cb0, &AsyncCallback::response, &AsyncCallback::exception));
AsyncCallbackPtr cb1 = new AsyncCallback();
twoway->begin_initiateConcurrentCallback(1, twowayR, context,
newCallback_Callback_initiateConcurrentCallback(cb1, &AsyncCallback::response, &AsyncCallback::exception));
AsyncCallbackPtr cb2 = new AsyncCallback();
twoway->begin_initiateConcurrentCallback(2, twowayR, context,
newCallback_Callback_initiateConcurrentCallback(cb2, &AsyncCallback::response, &AsyncCallback::exception));
callbackReceiverImpl->answerConcurrentCallbacks(3);
test(cb0->waitResponse() == 0);
test(cb1->waitResponse() == 1);
test(cb2->waitResponse() == 2);
cout << "ok" << endl;
}
{
cout << "ditto, but with user exception... " << flush;
Context context;
context["_fwd"] = "t";
try
{
twoway->initiateCallbackEx(twowayR, context);
test(false);
}
catch(const CallbackException& ex)
{
test(ex.someValue == 3.14);
test(ex.someString == "3.14");
}
callbackReceiverImpl->callbackOK();
cout << "ok" << endl;
}
{
cout << "trying twoway callback with fake category... " << flush;
Context context;
context["_fwd"] = "t";
try
{
twoway->initiateCallback(fakeTwowayR, context);
test(false);
}
catch(const ObjectNotExistException&)
{
cout << "ok" << endl;
}
}
{
cout << "testing whether other allowed category is accepted... " << flush;
Context context;
context["_fwd"] = "t";
CallbackPrx otherCategoryTwoway = CallbackPrx::uncheckedCast(
twoway->ice_identity(stringToIdentity("c2/callback")));
otherCategoryTwoway->initiateCallback(twowayR, context);
callbackReceiverImpl->callbackOK();
cout << "ok" << endl;
}
{
cout << "testing whether disallowed category gets rejected... " << flush;
Context context;
context["_fwd"] = "t";
try
{
CallbackPrx otherCategoryTwoway = CallbackPrx::uncheckedCast(
twoway->ice_identity(stringToIdentity("c3/callback")));
otherCategoryTwoway->initiateCallback(twowayR, context);
test(false);
}
catch(const ObjectNotExistException&)
{
cout << "ok" << endl;
}
}
{
cout << "testing whether user-id as category is accepted... " << flush;
Context context;
context["_fwd"] = "t";
CallbackPrx otherCategoryTwoway = CallbackPrx::uncheckedCast(
twoway->ice_identity(stringToIdentity("_userid/callback")));
otherCategoryTwoway->initiateCallback(twowayR, context);
callbackReceiverImpl->callbackOK();
cout << "ok" << endl;
}
{
cout << "testing with blocking clients... " << flush;
//
// Start 3 misbehaving clients.
//
const int nClients = 3; // Passwords need to be added to the password file if more clients are needed.
int i;
vector<MisbehavedClientPtr> clients;
for(i = 0; i < nClients; ++i)
{
clients.push_back(new MisbehavedClient(i));
clients.back()->start();
clients.back()->waitForCallback();
}
//
// Sleep for one second to make sure the router starts sending
// the callback with the payload to the clients.
//
IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(1));
//
// Initiate few callbacks with a large payload. Because of
// the buffered mode, this shouldn't block even though the
// misbehaved client are not answering their callback
// requests.
//
Context context;
context["_fwd"] = "t";
twoway->initiateCallbackWithPayload(twowayR, context);
callbackReceiverImpl->callbackWithPayloadOK();
twoway->initiateCallbackWithPayload(twowayR, context);
callbackReceiverImpl->callbackWithPayloadOK();
twoway->initiateCallbackWithPayload(twowayR, context);
callbackReceiverImpl->callbackWithPayloadOK();
twoway->initiateCallbackWithPayload(twowayR, context);
callbackReceiverImpl->callbackWithPayloadOK();
for(vector<MisbehavedClientPtr>::const_iterator p = clients.begin(); p != clients.end(); ++p)
{
(*p)->notifyWaitCallback();
(*p)->getThreadControl().join();
}
cout << "ok" << endl;
}
{
cout << "stress test... " << flush;
const int nClients = 3; // Passwords need to be added to the password file if more clients are needed.
int i;
vector<StressClientPtr> clients;
for(i = 0; i < nClients; ++i)
{
switch(IceUtilInternal::random(3))
{
case 0:
clients.push_back(new PingStressClient(i));
break;
case 1:
clients.push_back(new CallbackStressClient(i));
break;
case 2:
clients.push_back(new CallbackWithPayloadStressClient(i));
break;
default:
assert(false);
break;
}
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(3));
//
// Send some callbacks.
//
Context context;
context["_fwd"] = "t";
twoway->initiateCallback(twowayR);
callbackReceiverImpl->callbackOK();
//
// Kill the stress clients.
//
for(vector<StressClientPtr>::const_iterator q = clients.begin(); q != clients.end(); ++q)
{
(*q)->kill();
(*q)->getThreadControl().join();
}
cout << "ok" << endl;
}
if(argc >= 2 && strcmp(argv[1], "--shutdown") == 0)
{
cout << "testing server shutdown... " << flush;
twoway->shutdown();
// No ping, otherwise the router prints a warning message if it's
// started with --Ice.Warn.Connections.
cout << "ok" << endl;
/*
try
{
base->ice_ping();
test(false);
}
// If we use the glacier router, the exact exception reason gets
// lost.
catch(const UnknownLocalException&)
{
cout << "ok" << endl;
}
*/
}
{
cout << "destroying session... " << flush;
try
{
router->destroySession();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
}
{
cout << "trying to ping server after session destruction... " << flush;
try
{
base->ice_ping();
test(false);
}
catch(const ConnectionLostException&)
{
cout << "ok" << endl;
}
}
if(argc >= 2 && strcmp(argv[1], "--shutdown") == 0)
{
{
cout << "uninstalling router with communicator... " << flush;
communicator->setDefaultRouter(0);
cout << "ok" << endl;
}
ObjectPrx processBase;
{
cout << "testing stringToProxy for admin process facet... " << flush;
processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51));
cout << "ok" << endl;
}
Ice::ProcessPrx process;
{
cout << "testing checked cast for process facet... " << flush;
process = Ice::ProcessPrx::checkedCast(processBase);
test(process);
cout << "ok" << endl;
}
cout << "testing Glacier2 shutdown... " << flush;
process->shutdown();
try
{
process->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
cout << "ok" << endl;
}
}
}
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, const string& ref)
{
ServerManagerPrx manager = ServerManagerPrx::checkedCast(communicator->stringToProxy(ref));
TestLocatorPrx locator = TestLocatorPrx::uncheckedCast(communicator->getDefaultLocator());
test(manager);
TestLocatorRegistryPrx registry = TestLocatorRegistryPrx::checkedCast(locator->getRegistry());
test(registry);
cout << "testing stringToProxy... " << flush;
Ice::ObjectPrx base = communicator->stringToProxy("test @ TestAdapter");
Ice::ObjectPrx base2 = communicator->stringToProxy("test @ TestAdapter");
Ice::ObjectPrx base3 = communicator->stringToProxy("test");
Ice::ObjectPrx base4 = communicator->stringToProxy("ServerManager");
Ice::ObjectPrx base5 = communicator->stringToProxy("test2");
Ice::ObjectPrx base6 = communicator->stringToProxy("test @ ReplicatedAdapter");
cout << "ok" << endl;
cout << "testing ice_locator and ice_getLocator... " << flush;
test(Ice::proxyIdentityEqual(base->ice_getLocator(), communicator->getDefaultLocator()));
Ice::LocatorPrx anotherLocator = Ice::LocatorPrx::uncheckedCast(communicator->stringToProxy("anotherLocator"));
base = base->ice_locator(anotherLocator);
test(Ice::proxyIdentityEqual(base->ice_getLocator(), anotherLocator));
communicator->setDefaultLocator(0);
base = communicator->stringToProxy("test @ TestAdapter");
test(!base->ice_getLocator());
base = base->ice_locator(anotherLocator);
test(Ice::proxyIdentityEqual(base->ice_getLocator(), anotherLocator));
communicator->setDefaultLocator(locator);
base = communicator->stringToProxy("test @ TestAdapter");
test(Ice::proxyIdentityEqual(base->ice_getLocator(), communicator->getDefaultLocator()));
//
// We also test ice_router/ice_getRouter (perhaps we should add a
// test/Ice/router test?)
//
test(!base->ice_getRouter());
Ice::RouterPrx anotherRouter = Ice::RouterPrx::uncheckedCast(communicator->stringToProxy("anotherRouter"));
base = base->ice_router(anotherRouter);
test(Ice::proxyIdentityEqual(base->ice_getRouter(), anotherRouter));
Ice::RouterPrx router = Ice::RouterPrx::uncheckedCast(communicator->stringToProxy("dummyrouter"));
communicator->setDefaultRouter(router);
base = communicator->stringToProxy("test @ TestAdapter");
test(Ice::proxyIdentityEqual(base->ice_getRouter(), communicator->getDefaultRouter()));
communicator->setDefaultRouter(0);
base = communicator->stringToProxy("test @ TestAdapter");
test(!base->ice_getRouter());
cout << "ok" << endl;
cout << "starting server... " << flush;
manager->startServer();
cout << "ok" << endl;
cout << "testing checked cast... " << flush;
TestIntfPrx obj = TestIntfPrx::checkedCast(base);
test(obj);
TestIntfPrx obj2 = TestIntfPrx::checkedCast(base2);
test(obj2);
TestIntfPrx obj3 = TestIntfPrx::checkedCast(base3);
test(obj3);
ServerManagerPrx obj4 = ServerManagerPrx::checkedCast(base4);
test(obj4);
TestIntfPrx obj5 = TestIntfPrx::checkedCast(base5);
test(obj5);
TestIntfPrx obj6 = TestIntfPrx::checkedCast(base6);
test(obj6);
cout << "ok" << endl;
cout << "testing id@AdapterId indirect proxy... " << flush;
obj->shutdown();
manager->startServer();
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing id@ReplicaGroupId indirect proxy... " << flush;
obj->shutdown();
manager->startServer();
try
{
obj6->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing identity indirect proxy... " << flush;
obj->shutdown();
manager->startServer();
try
{
obj3->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
try
{
obj3->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj3->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj5->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing proxy with unknown identity... " << flush;
try
{
base = communicator->stringToProxy("unknown/unknown");
base->ice_ping();
test(false);
}
catch (const Ice::NotRegisteredException& ex)
{
test(ex.kindOfObject == "object");
test(ex.id == "unknown/unknown");
}
cout << "ok" << endl;
cout << "testing proxy with unknown adapter... " << flush;
try
{
base = communicator->stringToProxy("test @ TestAdapterUnknown");
base->ice_ping();
test(false);
}
catch (const Ice::NotRegisteredException& ex)
{
test(ex.kindOfObject == "object adapter");
test(ex.id == "TestAdapterUnknown");
}
cout << "ok" << endl;
cout << "testing locator cache timeout... " << flush;
int count = locator->getRequestCount();
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
test(++count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
test(++count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
test(count == locator->getRequestCount());
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1300));
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
test(++count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
count += 2;
test(count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout
test(count == locator->getRequestCount());
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1300));
communicator->stringToProxy("test")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout
count += 2;
test(count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(-1)->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_locatorCacheTimeout(-1)->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_ping();
test(count == locator->getRequestCount());
test(communicator->stringToProxy("test")->ice_locatorCacheTimeout(99)->ice_getLocatorCacheTimeout() == 99);
cout << "ok" << endl;
cout << "testing proxy from server... " << flush;
obj = TestIntfPrx::checkedCast(communicator->stringToProxy("test@TestAdapter"));
HelloPrx hello = obj->getHello();
test(hello->ice_getAdapterId() == "TestAdapter");
hello->sayHello();
hello = obj->getReplicatedHello();
test(hello->ice_getAdapterId() == "ReplicatedAdapter");
hello->sayHello();
cout << "ok" << endl;
cout << "testing locator request queuing... " << flush;
hello = obj->getReplicatedHello()->ice_locatorCacheTimeout(0)->ice_connectionCached(false);
count = locator->getRequestCount();
hello->ice_ping();
test(++count == locator->getRequestCount());
int i;
list<Ice::AsyncResultPtr> results;
AMICallbackPtr cb = new AMICallback;
for(i = 0; i < 1000; i++)
{
Ice::AsyncResultPtr result = hello->begin_sayHello(
newCallback_Hello_sayHello(cb, &AMICallback::response1, &AMICallback::exception1));
results.push_back(result);
}
while(!results.empty())
{
Ice::AsyncResultPtr result = results.front();
results.pop_front();
result->waitForCompleted();
}
test(locator->getRequestCount() > count && locator->getRequestCount() < count + 999);
if(locator->getRequestCount() > count + 800)
{
cout << "queuing = " << locator->getRequestCount() - count;
}
count = locator->getRequestCount();
hello = hello->ice_adapterId("unknown");
for(i = 0; i < 1000; i++)
{
Ice::AsyncResultPtr result = hello->begin_sayHello(
newCallback_Hello_sayHello(cb, &AMICallback::response2, &AMICallback::exception2));
results.push_back(result);
}
while(!results.empty())
{
Ice::AsyncResultPtr result = results.front();
results.pop_front();
result->waitForCompleted();
}
// Take into account the retries.
test(locator->getRequestCount() > count && locator->getRequestCount() < count + 1999);
if(locator->getRequestCount() > count + 800)
{
cout << "queuing = " << locator->getRequestCount() - count;
}
cout << "ok" << endl;
cout << "testing adapter locator cache... " << flush;
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
test(false);
}
catch(const Ice::NotRegisteredException& ex)
{
test(ex.kindOfObject == "object adapter");
test(ex.id == "TestAdapter3");
}
registry->setAdapterDirectProxy("TestAdapter3", locator->findAdapterById("TestAdapter"));
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
registry->setAdapterDirectProxy("TestAdapter3", communicator->stringToProxy("dummy:tcp"));
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_locatorCacheTimeout(0)->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
registry->setAdapterDirectProxy("TestAdapter3", locator->findAdapterById("TestAdapter"));
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
cout << "ok" <<endl;
cout << "testing well-known object locator cache... " << flush;
registry->addObject(communicator->stringToProxy("test3@TestUnknown"));
try
{
communicator->stringToProxy("test3")->ice_ping();
test(false);
}
catch(const Ice::NotRegisteredException& ex)
{
test(ex.kindOfObject == "object adapter");
test(ex.id == "TestUnknown");
}
registry->addObject(communicator->stringToProxy("test3@TestAdapter4")); // Update
registry->setAdapterDirectProxy("TestAdapter4", communicator->stringToProxy("dummy:tcp"));
try
{
communicator->stringToProxy("test3")->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
registry->setAdapterDirectProxy("TestAdapter4", locator->findAdapterById("TestAdapter"));
try
{
communicator->stringToProxy("test3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
registry->setAdapterDirectProxy("TestAdapter4", communicator->stringToProxy("dummy:tcp"));
try
{
communicator->stringToProxy("test3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
try
{
communicator->stringToProxy("test@TestAdapter4")->ice_locatorCacheTimeout(0)->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
communicator->stringToProxy("test@TestAdapter4")->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
communicator->stringToProxy("test3")->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
registry->addObject(communicator->stringToProxy("test3@TestAdapter"));
try
{
communicator->stringToProxy("test3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
registry->addObject(communicator->stringToProxy("test4"));
try
{
communicator->stringToProxy("test4")->ice_ping();
test(false);
}
catch(const Ice::NoEndpointException&)
{
}
cout << "ok" << endl;
cout << "testing locator cache background updates... " << flush;
{
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.BackgroundLocatorCacheUpdates", "1");
Ice::CommunicatorPtr ic = Ice::initialize(initData);
registry->setAdapterDirectProxy("TestAdapter5", locator->findAdapterById("TestAdapter"));
registry->addObject(communicator->stringToProxy("test3@TestAdapter"));
int count = locator->getRequestCount();
ic->stringToProxy("test@TestAdapter5")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
ic->stringToProxy("test3")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
count += 3;
test(count == locator->getRequestCount());
registry->setAdapterDirectProxy("TestAdapter5", 0);
registry->addObject(communicator->stringToProxy("test3:tcp"));
ic->stringToProxy("test@TestAdapter5")->ice_locatorCacheTimeout(10)->ice_ping(); // 10s timeout.
ic->stringToProxy("test3")->ice_locatorCacheTimeout(10)->ice_ping(); // 10s timeout.
test(count == locator->getRequestCount());
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1200));
// The following request should trigger the background updates but still use the cached endpoints
// and therefore succeed.
ic->stringToProxy("test@TestAdapter5")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
ic->stringToProxy("test3")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
try
{
while(true)
{
ic->stringToProxy("test@TestAdapter5")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
}
}
catch(const Ice::LocalException&)
{
// Expected to fail once they endpoints have been updated in the background.
}
try
{
while(true)
{
ic->stringToProxy("test3")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
}
}
catch(const Ice::LocalException&)
{
// Expected to fail once they endpoints have been updated in the background.
}
ic->destroy();
}
cout << "ok" << endl;
cout << "testing proxy from server after shutdown... " << flush;
hello = obj->getReplicatedHello();
obj->shutdown();
manager->startServer();
hello->sayHello();
cout << "ok" << endl;
cout << "testing object migration... " << flush;
hello = HelloPrx::checkedCast(communicator->stringToProxy("hello"));
obj->migrateHello();
// TODO: enable after fixing ICE-5489
//hello->ice_getConnection()->close(false);
hello->sayHello();
obj->migrateHello();
hello->sayHello();
obj->migrateHello();
hello->sayHello();
cout << "ok" << endl;
cout << "testing locator encoding resolution... " << flush;
hello = HelloPrx::checkedCast(communicator->stringToProxy("hello"));
count = locator->getRequestCount();
communicator->stringToProxy("test@TestAdapter")->ice_encodingVersion(Ice::Encoding_1_1)->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter10")->ice_encodingVersion(Ice::Encoding_1_0)->ice_ping();
test(++count == locator->getRequestCount());
communicator->stringToProxy("test -e 1.0@TestAdapter10-2")->ice_ping();
test(++count == locator->getRequestCount());
cout << "ok" << endl;
cout << "shutdown server... " << flush;
obj->shutdown();
cout << "ok" << endl;
cout << "testing whether server is gone... " << flush;
try
{
obj2->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
obj3->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
obj5->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
cout << "ok" << endl;
cout << "testing indirect proxies to collocated objects... " << flush;
//
// Set up test for calling a collocated object through an indirect, adapterless reference.
//
Ice::PropertiesPtr properties = communicator->getProperties();
properties->setProperty("Ice.PrintAdapterReady", "0");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("Hello", "default");
adapter->setLocator(locator);
Ice::Identity id;
id.name = IceUtil::generateUUID();
registry->addObject(adapter->add(new HelloI, id));
adapter->activate();
try
{
HelloPrx helloPrx = HelloPrx::checkedCast(communicator->stringToProxy(communicator->identityToString(id)));
Ice::ConnectionPtr connection = helloPrx->ice_getConnection();
test(false);
}
catch(const Ice::CollocationOptimizationException&)
{
}
adapter->deactivate();
cout << "ok" << endl;
cout << "shutdown server manager... " << flush;
manager->shutdown();
cout << "ok" << endl;
}
void
allTests(const Ice::CommunicatorPtr& communicator)
{
SessionKeepAliveThreadPtr keepAlive = new SessionKeepAliveThread(
communicator->getLogger(), IceUtil::Time::seconds(5));
keepAlive->start();
RegistryPrx registry = IceGrid::RegistryPrx::checkedCast(communicator->stringToProxy("IceGrid/Registry"));
test(registry);
AdminSessionPrx session = registry->createAdminSession("foo", "bar");
keepAlive->add(session);
AdminPrx admin = session->getAdmin();
test(admin);
cout << "starting router... " << flush;
try
{
admin->startServer("Glacier2");
}
catch(const ServerStartException& ex)
{
cerr << ex.reason << endl;
test(false);
}
cout << "ok" << endl;
const int allocationTimeout = 5000;
Ice::ObjectPrx obj;
Ice::ObjectPrx dummy;
try
{
cout << "testing create session... " << flush;
SessionPrx session1 = registry->createSession("Client1", "");
SessionPrx session2 = registry->createSession("Client2", "");
keepAlive->add(session1);
keepAlive->add(session2);
cout << "ok" << endl;
cout << "testing allocate object by identity... " << flush;
Ice::Identity allocatable = communicator->stringToIdentity("allocatable");
Ice::Identity allocatablebis = communicator->stringToIdentity("allocatablebis");
try
{
session1->allocateObjectById(communicator->stringToIdentity("dummy"));
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session1->releaseObject(communicator->stringToIdentity("dummy"));
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session1->allocateObjectById(communicator->stringToIdentity("nonallocatable"));
test(false);
}
catch(const AllocationException&)
{
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session2->allocateObjectById(communicator->stringToIdentity("nonallocatable"));
test(false);
}
catch(const AllocationException&)
{
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session1->releaseObject(communicator->stringToIdentity("nonallocatable"));
test(false);
}
catch(const AllocationException&)
{
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session2->releaseObject(communicator->stringToIdentity("nonallocatable"));
test(false);
}
catch(const AllocationException&)
{
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
session1->allocateObjectById(allocatable);
try
{
session1->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationException&)
{
}
session1->setAllocationTimeout(0);
session2->setAllocationTimeout(0);
try
{
session2->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session2->releaseObject(allocatable);
test(false);
}
catch(const AllocationException&)
{
}
session1->allocateObjectById(allocatablebis);
try
{
session2->allocateObjectById(allocatablebis);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->releaseObject(allocatablebis);
session2->allocateObjectById(allocatablebis);
try
{
session1->allocateObjectById(allocatablebis);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session2->releaseObject(allocatablebis);
session2->setAllocationTimeout(allocationTimeout);
AllocateObjectByIdCallbackPtr cb1 = new AllocateObjectByIdCallback();
session2->allocateObjectById_async(cb1, allocatable);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb1->hasResponse(dummy));
session1->releaseObject(allocatable);
cb1->waitResponse(__FILE__, __LINE__);
test(cb1->hasResponse(dummy));
session1->setAllocationTimeout(0);
try
{
session1->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session1->releaseObject(allocatable);
test(false);
}
catch(const AllocationException&)
{
}
session1->setAllocationTimeout(allocationTimeout);
cb1 = new AllocateObjectByIdCallback();
session1->allocateObjectById_async(cb1, allocatable);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb1->hasResponse(dummy));
session2->releaseObject(allocatable);
cb1->waitResponse(__FILE__, __LINE__);
test(cb1->hasResponse(dummy));
session1->releaseObject(allocatable);
cout << "ok" << endl;
cout << "testing allocate object by type... " << flush;
session1->setAllocationTimeout(0);
session2->setAllocationTimeout(0);
try
{
obj = session1->allocateObjectByType("::Unknown");
test(false);
}
catch(const AllocationTimeoutException&)
{
test(false);
}
catch(const AllocationException&)
{
}
try
{
obj = session1->allocateObjectByType("::NotAllocatable");
test(false);
}
catch(const AllocationTimeoutException&)
{
test(false);
}
catch(const AllocationException&)
{
}
obj = session1->allocateObjectByType("::Test");
test(obj && obj->ice_getIdentity().name == "allocatable");
try
{
session1->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationException&)
{
}
try
{
session2->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session2->releaseObject(obj->ice_getIdentity());
}
catch(const AllocationException&)
{
}
session1->releaseObject(obj->ice_getIdentity());
try
{
session1->releaseObject(obj->ice_getIdentity());
}
catch(const AllocationException&)
{
}
obj = session2->allocateObjectByType("::Test"); // Allocate the object
test(obj && obj->ice_getIdentity().name == "allocatable");
try
{
session2->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationException&)
{
}
try
{
session1->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->allocateObjectByType("::TestBis");
try
{
session2->allocateObjectByType("::TestBis");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->releaseObject(allocatablebis);
session2->allocateObjectByType("::TestBis");
try
{
session1->allocateObjectByType("::TestBis");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session2->releaseObject(allocatablebis);
session1->setAllocationTimeout(allocationTimeout);
AllocateObjectByTypeCallbackPtr cb3 = new AllocateObjectByTypeCallback();
session1->allocateObjectByType_async(cb3, "::Test");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb3->hasResponse(dummy));
session2->releaseObject(obj->ice_getIdentity());
cb3->waitResponse(__FILE__, __LINE__);
test(cb3->hasResponse(obj));
session1->releaseObject(obj->ice_getIdentity());
cout << "ok" << endl;
cout << "testing object allocation timeout... " << flush;
session1->allocateObjectById(allocatable);
IceUtil::Time time = IceUtil::Time::now();
session2->setAllocationTimeout(500);
try
{
session2->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationTimeoutException&)
{
test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now());
}
time = IceUtil::Time::now();
try
{
session2->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now());
time = IceUtil::Time::now();
try
{
session2->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now());
session1->releaseObject(allocatable);
session2->setAllocationTimeout(0);
cout << "ok" << endl;
cout << "testing server allocation... " << flush;
session1->setAllocationTimeout(0);
session2->setAllocationTimeout(0);
Ice::Identity allocatable3 = communicator->stringToIdentity("allocatable3");
Ice::Identity allocatable4 = communicator->stringToIdentity("allocatable4");
session1->allocateObjectById(allocatable3);
try
{
session2->allocateObjectById(allocatable3);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session2->allocateObjectById(allocatable4);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->allocateObjectById(allocatable4);
session1->releaseObject(allocatable3);
try
{
session2->allocateObjectById(allocatable3);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->releaseObject(allocatable4);
session2->allocateObjectById(allocatable3);
try
{
session1->allocateObjectById(allocatable3);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session1->allocateObjectById(allocatable4);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session2->allocateObjectById(allocatable4);
session2->releaseObject(allocatable3);
try
{
session1->allocateObjectById(allocatable3);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session1->allocateObjectByType("::TestServer1");
test(false);
}
catch(AllocationException&)
{
}
try
{
session1->allocateObjectByType("::TestServer2");
test(false);
}
catch(AllocationException&)
{
}
test(session2->allocateObjectByType("::TestServer1"));
try
{
session2->allocateObjectByType("::TestServer1");
test(false);
}
catch(AllocationException&)
{
}
try
{
session2->allocateObjectByType("::TestServer2");
test(false);
}
catch(AllocationException&)
{
}
session2->releaseObject(allocatable3);
session2->releaseObject(allocatable4);
session1->allocateObjectById(allocatable3);
session1->allocateObjectById(allocatable4);
session2->setAllocationTimeout(allocationTimeout);
cb1 = new AllocateObjectByIdCallback();
session2->allocateObjectById_async(cb1, allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb1->hasResponse(dummy));
session1->releaseObject(allocatable3);
test(!cb1->hasResponse(dummy));
session1->releaseObject(allocatable4);
cb1->waitResponse(__FILE__, __LINE__);
test(cb1->hasResponse(dummy));
session2->releaseObject(allocatable3);
session1->setAllocationTimeout(allocationTimeout);
test(session2->allocateObjectByType("::TestServer1"));
cb3 = new AllocateObjectByTypeCallback();
session1->allocateObjectByType_async(cb3, "::TestServer2");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb3->hasResponse(dummy));
session2->releaseObject(allocatable3);
cb3->waitResponse(__FILE__, __LINE__);
test(cb3->hasResponse(dummy));
session1->releaseObject(allocatable4);
session1->setAllocationTimeout(0);
session2->setAllocationTimeout(0);
test(session1->allocateObjectByType("::TestMultipleByServer"));
try
{
session2->allocateObjectByType("::TestMultipleByServer");
test(false);
}
catch(AllocationException&)
{
}
test(session1->allocateObjectByType("::TestMultipleByServer"));
session1->releaseObject(communicator->stringToIdentity("allocatable31"));
session1->releaseObject(communicator->stringToIdentity("allocatable41"));
test(session2->allocateObjectByType("::TestMultipleByServer"));
try
{
session1->allocateObjectByType("::TestMultipleByServer");
test(false);
}
catch(AllocationException&)
{
}
test(session2->allocateObjectByType("::TestMultipleByServer"));
session2->releaseObject(communicator->stringToIdentity("allocatable31"));
session2->releaseObject(communicator->stringToIdentity("allocatable41"));
Ice::ObjectPrx obj1 = session1->allocateObjectByType("::TestMultipleServer");
test(obj1);
Ice::ObjectPrx obj2 = session2->allocateObjectByType("::TestMultipleServer");
test(obj2);
try
{
session1->allocateObjectByType("::TestMultipleServer");
test(false);
}
catch(AllocationTimeoutException&)
{
}
try
{
session2->allocateObjectByType("::TestMultipleServer");
test(false);
}
catch(AllocationTimeoutException&)
{
}
session1->releaseObject(obj1->ice_getIdentity());
obj1 = session2->allocateObjectByType("::TestMultipleServer");
session2->releaseObject(obj1->ice_getIdentity());
session2->releaseObject(obj2->ice_getIdentity());
cout << "ok" << endl;
cout << "testing concurrent allocations... " << flush;
session1->setAllocationTimeout(allocationTimeout);
session2->setAllocationTimeout(allocationTimeout);
session2->allocateObjectById(allocatable);
AllocateObjectByIdCallbackPtr cb11 = new AllocateObjectByIdCallback();
AllocateObjectByIdCallbackPtr cb12 = new AllocateObjectByIdCallback();
session1->allocateObjectById_async(cb11, allocatable);
session1->allocateObjectById_async(cb12, allocatable);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb11->hasResponse(dummy));
test(!cb12->hasResponse(dummy));
session2->releaseObject(allocatable);
cb11->waitResponse(__FILE__, __LINE__);
cb12->waitResponse(__FILE__, __LINE__);
test(cb11->hasResponse(dummy) ? cb12->hasException() : cb12->hasResponse(dummy));
test(cb12->hasResponse(dummy) ? cb11->hasException() : cb11->hasResponse(dummy));
session1->releaseObject(allocatable);
session2->allocateObjectById(allocatable);
AllocateObjectByTypeCallbackPtr cb31 = new AllocateObjectByTypeCallback();
AllocateObjectByTypeCallbackPtr cb32 = new AllocateObjectByTypeCallback();
session1->allocateObjectByType_async(cb31, "::Test");
session1->allocateObjectByType_async(cb32, "::Test");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb31->hasResponse(dummy));
test(!cb32->hasResponse(dummy));
session2->releaseObject(allocatable);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
do
{
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200));
}
while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy));
test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) ||
cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy));
session1->releaseObject(allocatable);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
AllocateObjectByTypeCallbackPtr cb33 = cb31->hasResponse(dummy) ? cb32 : cb31;
cb33->waitResponse(__FILE__, __LINE__);
test(cb33->hasResponse(dummy) && dummy);
session1->releaseObject(allocatable);
session2->allocateObjectById(allocatable3);
cb11 = new AllocateObjectByIdCallback();
cb12 = new AllocateObjectByIdCallback();
session1->allocateObjectById_async(cb11, allocatable3);
session1->allocateObjectById_async(cb12, allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb11->hasResponse(dummy));
test(!cb12->hasResponse(dummy));
session2->releaseObject(allocatable3);
cb11->waitResponse(__FILE__, __LINE__);
cb12->waitResponse(__FILE__, __LINE__);
test(cb11->hasResponse(dummy) ? cb12->hasException() : cb12->hasResponse(dummy));
test(cb12->hasResponse(dummy) ? cb11->hasException() : cb11->hasResponse(dummy));
session1->releaseObject(allocatable3);
session2->allocateObjectById(allocatable3);
cb31 = new AllocateObjectByTypeCallback();
cb32 = new AllocateObjectByTypeCallback();
session1->allocateObjectByType_async(cb31, "::TestServer1");
session1->allocateObjectByType_async(cb32, "::TestServer1");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb31->hasResponse(dummy));
test(!cb32->hasResponse(dummy));
session2->releaseObject(allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
do
{
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200));
}
while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy));
test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) ||
cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy));
session1->releaseObject(allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
cb33 = cb31->hasResponse(dummy) ? cb32 : cb31;
cb33->waitResponse(__FILE__, __LINE__);
test(cb33->hasResponse(dummy) && dummy);
session1->releaseObject(allocatable3);
session1->allocateObjectById(allocatable3);
cb31 = new AllocateObjectByTypeCallback();
cb32 = new AllocateObjectByTypeCallback();
session1->allocateObjectByType_async(cb31, "::TestServer1");
session1->allocateObjectByType_async(cb32, "::TestServer1");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb31->hasResponse(dummy));
test(!cb32->hasResponse(dummy));
session1->releaseObject(allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
do
{
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200));
}
while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy));
test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) ||
cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy));
session1->releaseObject(allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
cb33 = cb31->hasResponse(dummy) ? cb32 : cb31;
cb33->waitResponse(__FILE__, __LINE__);
test(cb33->hasResponse(dummy) && dummy);
session1->releaseObject(allocatable3);
cout << "ok" << endl;
cout << "testing session destroy... " << flush;
obj = session2->allocateObjectByType("::Test"); // Allocate the object
test(obj && obj->ice_getIdentity().name == "allocatable");
session1->setAllocationTimeout(allocationTimeout);
cb3 = new AllocateObjectByTypeCallback();
session1->allocateObjectByType_async(cb3, "::Test");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb3->hasResponse(dummy));
session2->destroy();
cb3->waitResponse(__FILE__, __LINE__);
test(cb3->hasResponse(obj));
session1->destroy();
session2 = SessionPrx::uncheckedCast(registry->createSession("Client2", ""));
session2->setAllocationTimeout(0);
session2->allocateObjectById(allocatable);
session2->destroy();
cout << "ok" << endl;
cout << "testing allocation with Glacier2 session... " << flush;
Ice::ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:default -p 12347");
Glacier2::RouterPrx router1 = Glacier2::RouterPrx::checkedCast(routerBase->ice_connectionId("client1"));
test(router1);
Glacier2::SessionPrx sessionBase = router1->createSession("test1", "abc123");
try
{
session1 = IceGrid::SessionPrx::checkedCast(sessionBase->ice_connectionId("client1")->ice_router(router1));
test(session1);
session1->ice_ping();
Ice::ObjectPrx obj;
obj = session1->allocateObjectById(allocatable)->ice_connectionId("client1")->ice_router(router1);
obj->ice_ping();
session1->releaseObject(allocatable);
try
{
obj->ice_ping();
}
catch(const Ice::ObjectNotExistException&)
{
}
obj = session1->allocateObjectById(allocatable3)->ice_connectionId("client1")->ice_router(router1);
obj->ice_ping();
obj2 = communicator->stringToProxy("allocatable4")->ice_connectionId("client1")->ice_router(router1);
obj2->ice_ping();
session1->releaseObject(allocatable3);
try
{
obj->ice_ping();
}
catch(const Ice::ObjectNotExistException&)
{
}
try
{
obj2->ice_ping();
}
catch(const Ice::ObjectNotExistException&)
{
}
session1->destroy();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "stress test... " << flush;
SessionPrx stressSession = registry->createSession("StressSession", "");
keepAlive->add(stressSession);
const int nClients = 10;
int i;
vector<StressClientPtr> clients;
for(i = 0; i < nClients - 2; ++i)
{
if(IceUtil::random(2) == 1)
{
clients.push_back(new StressClient(i, registry, false));
}
else
{
clients.push_back(new StressClient(i, stressSession));
}
clients.back()->start();
}
clients.push_back(new StressClient(i++, registry, true));
clients.back()->start();
clients.push_back(new StressClient(i++, registry, true));
clients.back()->start();
for(vector<StressClientPtr>::const_iterator p = clients.begin(); p != clients.end(); ++p)
{
(*p)->notifyThread();
}
//
// Let the stress client run for a bit.
//
IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(8));
//
// Terminate the stress clients.
//
for(vector<StressClientPtr>::const_iterator q = clients.begin(); q != clients.end(); ++q)
{
(*q)->terminate();
(*q)->getThreadControl().join();
}
stressSession->destroy();
cout << "ok" << endl;
}
catch(const AllocationTimeoutException& ex)
{
cerr << ex << endl;
test(false);
}
catch(const AllocationException& ex)
{
cerr << ex.reason << endl;
test(false);
}
cout << "shutting down router... " << flush;
admin->stopServer("Glacier2");
cout << "ok" << endl;
keepAlive->terminate();
keepAlive->getThreadControl().join();
keepAlive = 0;
session->destroy();
}
TimeoutPrx
allTests(const Ice::CommunicatorPtr& communicator)
{
string sref = "timeout:default -p 12010";
Ice::ObjectPrx obj = communicator->stringToProxy(sref);
test(obj);
TimeoutPrx timeout = TimeoutPrx::checkedCast(obj);
test(timeout);
cout << "testing connect timeout... " << flush;
{
//
// Expect ConnectTimeoutException.
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(100));
timeout->holdAdapter(500);
try
{
to->op();
test(false);
}
catch(const Ice::ConnectTimeoutException&)
{
// Expected.
}
}
{
//
// Expect success.
//
timeout->op(); // Ensure adapter is active.
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(1000));
timeout->holdAdapter(500);
try
{
to->op();
}
catch(const Ice::ConnectTimeoutException&)
{
test(false);
}
}
cout << "ok" << endl;
// The sequence needs to be large enough to fill the write/recv buffers
ByteSeq seq(2000000);
cout << "testing connection timeout... " << flush;
{
//
// Expect TimeoutException.
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(100));
timeout->holdAdapter(500);
try
{
to->sendData(seq);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
}
{
//
// Expect success.
//
timeout->op(); // Ensure adapter is active.
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(1000));
timeout->holdAdapter(500);
try
{
ByteSeq seq(1000000);
to->sendData(seq);
}
catch(const Ice::TimeoutException&)
{
test(false);
}
}
cout << "ok" << endl;
cout << "testing invocation timeout... " << flush;
{
Ice::ConnectionPtr connection = obj->ice_getConnection();
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_invocationTimeout(100));
test(connection == to->ice_getConnection());
try
{
to->sleep(750);
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
obj->ice_ping();
to = TimeoutPrx::checkedCast(obj->ice_invocationTimeout(500));
test(connection == to->ice_getConnection());
try
{
to->sleep(250);
}
catch(const Ice::InvocationTimeoutException&)
{
test(false);
}
test(connection == to->ice_getConnection());
}
{
//
// Expect InvocationTimeoutException.
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_invocationTimeout(100));
CallbackPtr cb = new Callback();
to->begin_sleep(750, newCallback_Timeout_sleep(cb, &Callback::responseEx, &Callback::exceptionEx));
cb->check();
obj->ice_ping();
}
{
//
// Expect success.
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_invocationTimeout(500));
CallbackPtr cb = new Callback();
to->begin_sleep(250, newCallback_Timeout_sleep(cb, &Callback::response, &Callback::exception));
cb->check();
}
{
//
// Backward compatible connection timeouts
//
TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_invocationTimeout(-2)->ice_timeout(100));
Ice::ConnectionPtr con;
try
{
con = to->ice_getConnection();
to->sleep(750);
test(false);
}
catch(const Ice::TimeoutException&)
{
try
{
con->getInfo();
test(false);
}
catch(const Ice::TimeoutException&)
{
// Connection got closed as well.
}
}
obj->ice_ping();
try
{
con = to->ice_getConnection();
to->end_sleep(to->begin_sleep(750));
test(false);
}
catch(const Ice::TimeoutException&)
{
try
{
con->getInfo();
test(false);
}
catch(const Ice::TimeoutException&)
{
// Connection got closed as well.
}
}
obj->ice_ping();
}
cout << "ok" << endl;
cout << "testing close timeout... " << flush;
{
TimeoutPrx to = TimeoutPrx::checkedCast(obj->ice_timeout(100));
Ice::ConnectionPtr connection = to->ice_getConnection();
timeout->holdAdapter(500);
connection->close(false);
try
{
connection->getInfo(); // getInfo() doesn't throw in the closing state.
}
catch(const Ice::LocalException&)
{
test(false);
}
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
try
{
connection->getInfo();
test(false);
}
catch(const Ice::CloseConnectionException&)
{
// Expected.
}
timeout->op(); // Ensure adapter is active.
}
cout << "ok" << endl;
cout << "testing timeout overrides... " << flush;
{
//
// Test Ice.Override.Timeout. This property overrides all
// endpoint timeouts.
//
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.Override.Timeout", "100");
Ice::CommunicatorPtr comm = Ice::initialize(initData);
TimeoutPrx to = TimeoutPrx::checkedCast(comm->stringToProxy(sref));
timeout->holdAdapter(500);
try
{
to->sendData(seq);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
//
// Calling ice_timeout() should have no effect.
//
timeout->op(); // Ensure adapter is active.
to = TimeoutPrx::checkedCast(to->ice_timeout(1000));
timeout->holdAdapter(500);
try
{
to->sendData(seq);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
comm->destroy();
}
{
//
// Test Ice.Override.ConnectTimeout.
//
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.Override.ConnectTimeout", "250");
Ice::CommunicatorPtr comm = Ice::initialize(initData);
timeout->holdAdapter(750);
TimeoutPrx to = TimeoutPrx::uncheckedCast(comm->stringToProxy(sref));
try
{
to->op();
test(false);
}
catch(const Ice::ConnectTimeoutException&)
{
// Expected.
}
//
// Calling ice_timeout() should have no effect on the connect timeout.
//
timeout->op(); // Ensure adapter is active.
timeout->holdAdapter(750);
to = TimeoutPrx::uncheckedCast(to->ice_timeout(1000));
try
{
to->op();
test(false);
}
catch(const Ice::ConnectTimeoutException&)
{
// Expected.
}
//
// Verify that timeout set via ice_timeout() is still used for requests.
//
timeout->op(); // Ensure adapter is active.
to = TimeoutPrx::uncheckedCast(to->ice_timeout(100));
to->ice_getConnection(); // Establish connection
timeout->holdAdapter(750);
try
{
to->sendData(seq);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
comm->destroy();
}
{
//
// Test Ice.Override.CloseTimeout.
//
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.Override.CloseTimeout", "100");
Ice::CommunicatorPtr comm = Ice::initialize(initData);
Ice::ConnectionPtr connection = comm->stringToProxy(sref)->ice_getConnection();
timeout->holdAdapter(500);
IceUtil::Time now = IceUtil::Time::now();
comm->destroy();
test(IceUtil::Time::now() - now < IceUtil::Time::milliSeconds(400));
}
cout << "ok" << endl;
cout << "testing invocation timeouts with collocated calls... " << flush;
{
communicator->getProperties()->setProperty("TimeoutCollocated.AdapterId", "timeoutAdapter");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TimeoutCollocated");
adapter->activate();
TimeoutPrx timeout = TimeoutPrx::uncheckedCast(adapter->addWithUUID(new TimeoutI()));
timeout = timeout->ice_invocationTimeout(100);
try
{
timeout->sleep(300);
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
try
{
timeout->end_sleep(timeout->begin_sleep(300));
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
TimeoutPrx batchTimeout = timeout->ice_batchOneway();
batchTimeout->ice_ping();
batchTimeout->ice_ping();
batchTimeout->ice_ping();
timeout->ice_invocationTimeout(-1)->begin_sleep(300); // Keep the server thread pool busy.
try
{
batchTimeout->ice_flushBatchRequests();
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
batchTimeout->ice_ping();
batchTimeout->ice_ping();
batchTimeout->ice_ping();
timeout->ice_invocationTimeout(-1)->begin_sleep(300); // Keep the server thread pool busy.
try
{
batchTimeout->end_ice_flushBatchRequests(batchTimeout->begin_ice_flushBatchRequests());
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
adapter->destroy();
}
cout << "ok" << endl;
return timeout;
}
MetricsPrx
allTests(const Ice::CommunicatorPtr& communicator, const CommunicatorObserverIPtr& obsv)
{
MetricsPrx metrics = MetricsPrx::checkedCast(communicator->stringToProxy("metrics:default -p 12010"));
cout << "testing metrics admin facet checkedCast... " << flush;
Ice::ObjectPrx admin = communicator->getAdmin()->ice_collocationOptimized(false);
Ice::PropertiesAdminPrx clientProps = Ice::PropertiesAdminPrx::checkedCast(admin, "Properties");
IceMX::MetricsAdminPrx clientMetrics = IceMX::MetricsAdminPrx::checkedCast(admin, "Metrics");
test(clientProps && clientMetrics);
admin = metrics->getAdmin();
Ice::PropertiesAdminPrx serverProps = Ice::PropertiesAdminPrx::checkedCast(admin, "Properties");
IceMX::MetricsAdminPrx serverMetrics = IceMX::MetricsAdminPrx::checkedCast(admin, "Metrics");
test(serverProps && serverMetrics);
UpdateCallbackI* update = new UpdateCallbackI(serverProps);
Ice::NativePropertiesAdminPtr::dynamicCast(communicator->findAdminFacet("Properties"))->addUpdateCallback(update);
cout << "ok" << endl;
Ice::PropertyDict props;
cout << "testing group by none..." << flush;
props["IceMX.Metrics.View.GroupBy"] = "none";
updateProps(clientProps, serverProps, update, props);
#ifndef ICE_OS_WINRT
int threadCount = 4;
#else
int threadCount = 3; // No endpoint host resolver thread with WinRT.
#endif
Ice::Long timestamp;
IceMX::MetricsView view = clientMetrics->getMetricsView("View", timestamp);
test(view["Connection"].size() == 1 && view["Connection"][0]->current == 1 && view["Connection"][0]->total == 1);
test(view["Thread"].size() == 1 && view["Thread"][0]->current == threadCount &&
view["Thread"][0]->total == threadCount);
cout << "ok" << endl;
cout << "testing group by id..." << flush;
props["IceMX.Metrics.View.GroupBy"] = "id";
updateProps(clientProps, serverProps, update, props);
metrics->ice_ping();
metrics->ice_ping();
metrics->ice_connectionId("Con1")->ice_ping();
metrics->ice_connectionId("Con1")->ice_ping();
metrics->ice_connectionId("Con1")->ice_ping();
view = clientMetrics->getMetricsView("View", timestamp);
test(static_cast<int>(view["Thread"].size()) == threadCount);
test(view["Connection"].size() == 2);
test(view["Invocation"].size() == 1);
IceMX::InvocationMetricsPtr invoke = IceMX::InvocationMetricsPtr::dynamicCast(view["Invocation"][0]);
test(invoke->id.find("[ice_ping]") > 0 && invoke->current == 0 && invoke->total == 5);
test(invoke->remotes.size() == 2);
test(invoke->remotes[0]->total = 2);
test(invoke->remotes[1]->total = 3);
view = serverMetrics->getMetricsView("View", timestamp);
test(view["Thread"].size() > 4);
test(view["Connection"].size() == 2);
test(view["Dispatch"].size() == 1);
test(view["Dispatch"][0]->current <= 1 && view["Dispatch"][0]->total == 5);
test(view["Dispatch"][0]->id.find("[ice_ping]") > 0);
metrics->ice_getConnection()->close(false);
metrics->ice_connectionId("Con1")->ice_getConnection()->close(false);
waitForCurrent(clientMetrics, "View", "Connection", 0);
waitForCurrent(serverMetrics, "View", "Connection", 0);
clearView(clientProps, serverProps, update);
cout << "ok" << endl;
cout << "testing connection metrics... " << flush;
props["IceMX.Metrics.View.Map.Connection.GroupBy"] = "none";
updateProps(clientProps, serverProps, update, props, "Connection");
test(clientMetrics->getMetricsView("View", timestamp)["Connection"].empty());
test(serverMetrics->getMetricsView("View", timestamp)["Connection"].empty());
metrics->ice_ping();
IceMX::ConnectionMetricsPtr cm1, sm1, cm2, sm2;
cm1 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]);
sm1 = IceMX::ConnectionMetricsPtr::dynamicCast(serverMetrics->getMetricsView("View", timestamp)["Connection"][0]);
sm1 = getServerConnectionMetrics(serverMetrics, 25);
test(cm1->total == 1 && sm1->total == 1);
metrics->ice_ping();
cm2 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]);
sm2 = getServerConnectionMetrics(serverMetrics, 50);
test(cm2->sentBytes - cm1->sentBytes == 45); // 45 for ice_ping request
test(cm2->receivedBytes - cm1->receivedBytes == 25); // 25 bytes for ice_ping response
test(sm2->receivedBytes - sm1->receivedBytes == 45);
test(sm2->sentBytes - sm1->sentBytes == 25);
cm1 = cm2;
sm1 = sm2;
Test::ByteSeq bs;
metrics->opByteS(bs);
cm2 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]);
sm2 = getServerConnectionMetrics(serverMetrics, sm1->sentBytes + cm2->receivedBytes - cm1->receivedBytes);
Ice::Long requestSz = cm2->sentBytes - cm1->sentBytes;
Ice::Long replySz = cm2->receivedBytes - cm1->receivedBytes;
cm1 = cm2;
sm1 = sm2;
bs.resize(456);
metrics->opByteS(bs);
cm2 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]);
sm2 = getServerConnectionMetrics(serverMetrics, sm1->sentBytes + replySz);
// 4 is for the seq variable size
test(cm2->sentBytes - cm1->sentBytes == requestSz + static_cast<int>(bs.size()) + 4);
test(cm2->receivedBytes - cm1->receivedBytes == replySz);
test(sm2->receivedBytes - sm1->receivedBytes == requestSz + static_cast<int>(bs.size()) + 4);
test(sm2->sentBytes - sm1->sentBytes == replySz);
cm1 = cm2;
sm1 = sm2;
bs.resize(1024 * 1024 * 10); // Try with large amount of data which should be sent in several chunks
metrics->opByteS(bs);
cm2 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]);
sm2 = getServerConnectionMetrics(serverMetrics, sm1->sentBytes + replySz);
// 4 is for the seq variable size
test(cm2->sentBytes - cm1->sentBytes == requestSz + static_cast<int>(bs.size()) + 4);
test(cm2->receivedBytes - cm1->receivedBytes == replySz);
test(sm2->receivedBytes - sm1->receivedBytes == requestSz + static_cast<int>(bs.size()) + 4);
test(sm2->sentBytes - sm1->sentBytes == replySz);
props["IceMX.Metrics.View.Map.Connection.GroupBy"] = "state";
updateProps(clientProps, serverProps, update, props, "Connection");
map<string, IceMX::MetricsPtr> map;
map = toMap(serverMetrics->getMetricsView("View", timestamp)["Connection"]);
test(map["active"]->current == 1);
ControllerPrx controller = ControllerPrx::checkedCast(communicator->stringToProxy("controller:default -p 12011"));
controller->hold();
map = toMap(clientMetrics->getMetricsView("View", timestamp)["Connection"]);
test(map["active"]->current == 1);
map = toMap(serverMetrics->getMetricsView("View", timestamp)["Connection"]);
test(map["holding"]->current == 1);
metrics->ice_getConnection()->close(false);
map = toMap(clientMetrics->getMetricsView("View", timestamp)["Connection"]);
test(map["closing"]->current == 1);
map = toMap(serverMetrics->getMetricsView("View", timestamp)["Connection"]);
test(map["holding"]->current == 1);
controller->resume();
map = toMap(serverMetrics->getMetricsView("View", timestamp)["Connection"]);
test(map["holding"]->current == 0);
props["IceMX.Metrics.View.Map.Connection.GroupBy"] = "none";
updateProps(clientProps, serverProps, update, props, "Connection");
metrics->ice_getConnection()->close(false);
metrics->ice_timeout(500)->ice_ping();
controller->hold();
try
{
metrics->ice_timeout(500)->ice_ping();
test(false);
}
catch(const Ice::TimeoutException&)
{
}
controller->resume();
cm1 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]);
while(true)
{
sm1 = IceMX::ConnectionMetricsPtr::dynamicCast(
serverMetrics->getMetricsView("View", timestamp)["Connection"][0]);
if(sm1-> failures >= 2)
{
break;
}
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
}
test(cm1->failures == 2 && sm1->failures >= 1);
checkFailure(clientMetrics, "Connection", cm1->id, "Ice::TimeoutException", 1);
checkFailure(clientMetrics, "Connection", cm1->id, "Ice::ConnectTimeoutException", 1);
checkFailure(serverMetrics, "Connection", sm1->id, "Ice::ConnectionLostException");
MetricsPrx m = metrics->ice_timeout(500)->ice_connectionId("Con1");
m->ice_ping();
testAttribute(clientMetrics, clientProps, update, "Connection", "parent", "Communicator");
//testAttribute(clientMetrics, clientProps, update, "Connection", "id", "");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpoint", "tcp -h 127.0.0.1 -p 12010 -t 500");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointType", "1");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointIsDatagram", "false");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointIsSecure", "false");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointTimeout", "500");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointCompress", "false");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointHost", "127.0.0.1");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointPort", "12010");
testAttribute(clientMetrics, clientProps, update, "Connection", "incoming", "false");
testAttribute(clientMetrics, clientProps, update, "Connection", "adapterName", "");
testAttribute(clientMetrics, clientProps, update, "Connection", "connectionId", "Con1");
testAttribute(clientMetrics, clientProps, update, "Connection", "localHost", "127.0.0.1");
//testAttribute(clientMetrics, clientProps, update, "Connection", "localPort", "");
testAttribute(clientMetrics, clientProps, update, "Connection", "remoteHost", "127.0.0.1");
testAttribute(clientMetrics, clientProps, update, "Connection", "remotePort", "12010");
testAttribute(clientMetrics, clientProps, update, "Connection", "mcastHost", "");
testAttribute(clientMetrics, clientProps, update, "Connection", "mcastPort", "");
m->ice_getConnection()->close(false);
waitForCurrent(clientMetrics, "View", "Connection", 0);
waitForCurrent(serverMetrics, "View", "Connection", 0);
cout << "ok" << endl;
cout << "testing connection establishment metrics... " << flush;
props["IceMX.Metrics.View.Map.ConnectionEstablishment.GroupBy"] = "id";
updateProps(clientProps, serverProps, update, props, "ConnectionEstablishment");
test(clientMetrics->getMetricsView("View", timestamp)["ConnectionEstablishment"].empty());
metrics->ice_ping();
test(clientMetrics->getMetricsView("View", timestamp)["ConnectionEstablishment"].size() == 1);
IceMX::MetricsPtr m1 = clientMetrics->getMetricsView("View", timestamp)["ConnectionEstablishment"][0];
test(m1->current == 0 && m1->total == 1 && m1->id == "127.0.0.1:12010");
metrics->ice_getConnection()->close(false);
controller->hold();
try
{
communicator->stringToProxy("test:tcp -p 12010 -h 127.0.0.1")->ice_timeout(10)->ice_ping();
test(false);
}
catch(const Ice::ConnectTimeoutException&)
{
}
catch(const Ice::LocalException&)
{
test(false);
}
controller->resume();
test(clientMetrics->getMetricsView("View", timestamp)["ConnectionEstablishment"].size() == 1);
m1 = clientMetrics->getMetricsView("View", timestamp)["ConnectionEstablishment"][0];
test(m1->id == "127.0.0.1:12010" && m1->total == 3 && m1->failures == 2);
checkFailure(clientMetrics, "ConnectionEstablishment", m1->id, "Ice::ConnectTimeoutException", 2);
Connect c(metrics);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "parent", "Communicator", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "id", "127.0.0.1:12010", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpoint",
"tcp -h 127.0.0.1 -p 12010", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointType", "1", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointIsDatagram", "false", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointIsSecure", "false", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointTimeout", "-1", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointCompress", "false", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointHost", "127.0.0.1", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointPort", "12010", c);
cout << "ok" << endl;
//
// Ice doesn't do any endpoint lookup with WinRT, the WinRT
// runtime takes care of if.
//
#ifndef ICE_OS_WINRT
cout << "testing endpoint lookup metrics... " << flush;
props["IceMX.Metrics.View.Map.ConnectionEstablishment.GroupBy"] = "id";
updateProps(clientProps, serverProps, update, props, "EndpointLookup");
test(clientMetrics->getMetricsView("View", timestamp)["EndpointLookup"].empty());
Ice::ObjectPrx prx = communicator->stringToProxy("metrics:default -p 12010 -h localhost");
prx->ice_ping();
test(clientMetrics->getMetricsView("View", timestamp)["EndpointLookup"].size() == 1);
m1 = clientMetrics->getMetricsView("View", timestamp)["EndpointLookup"][0];
test(m1->current <= 1 && m1->total == 1 && m1->id == "tcp -h localhost -p 12010");
prx->ice_getConnection()->close(false);
bool dnsException = false;
try
{
communicator->stringToProxy("test:tcp -t 500 -p 12010 -h unknownfoo.zeroc.com")->ice_ping();
test(false);
}
catch(const Ice::DNSException&)
{
dnsException = true;
}
catch(const Ice::LocalException&)
{
// Some DNS servers don't fail on unknown DNS names.
}
test(clientMetrics->getMetricsView("View", timestamp)["EndpointLookup"].size() == 2);
m1 = clientMetrics->getMetricsView("View", timestamp)["EndpointLookup"][1];
test(m1->id == "tcp -h unknownfoo.zeroc.com -p 12010 -t 500" && m1->total == 2 &&
(!dnsException || m1->failures == 2));
if(dnsException)
{
checkFailure(clientMetrics, "EndpointLookup", m1->id, "Ice::DNSException", 2);
}
c = Connect(prx);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "parent", "Communicator", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "id", "tcp -h localhost -p 12010", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpoint",
"tcp -h localhost -p 12010", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointType", "1", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointIsDatagram", "false", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointIsSecure", "false", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointTimeout", "-1", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointCompress", "false", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointHost", "localhost", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointPort", "12010", c);
cout << "ok" << endl;
#endif
cout << "testing dispatch metrics... " << flush;
props["IceMX.Metrics.View.Map.Dispatch.GroupBy"] = "operation";
updateProps(clientProps, serverProps, update, props, "Dispatch");
test(serverMetrics->getMetricsView("View", timestamp)["Dispatch"].empty());
metrics->op();
try
{
metrics->opWithUserException();
test(false);
}
catch(const Test::UserEx&)
{
}
try
{
metrics->opWithRequestFailedException();
test(false);
}
catch(const Ice::RequestFailedException&)
{
}
try
{
metrics->opWithLocalException();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
metrics->opWithUnknownException();
test(false);
}
catch(const Ice::UnknownException&)
{
}
try
{
metrics->fail();
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
map = toMap(serverMetrics->getMetricsView("View", timestamp)["Dispatch"]);
test(map.size() == 6);
IceMX::DispatchMetricsPtr dm1 = IceMX::DispatchMetricsPtr::dynamicCast(map["op"]);
test(dm1->current <= 1 && dm1->total == 1 && dm1->failures == 0 && dm1->userException == 0);
test(dm1->size == 21 && dm1->replySize == 7);
dm1 = IceMX::DispatchMetricsPtr::dynamicCast(map["opWithUserException"]);
test(dm1->current <= 1 && dm1->total == 1 && dm1->failures == 0 && dm1->userException == 1);
test(dm1->size == 38 && dm1->replySize == 23);
dm1 = IceMX::DispatchMetricsPtr::dynamicCast(map["opWithLocalException"]);
test(dm1->current <= 1 && dm1->total == 1 && dm1->failures == 1 && dm1->userException == 0);
checkFailure(serverMetrics, "Dispatch", dm1->id, "Ice::SyscallException", 1);
test(dm1->size == 39 && dm1->replySize > 7); // Reply contains the exception stack depending on the OS.
dm1 = IceMX::DispatchMetricsPtr::dynamicCast(map["opWithRequestFailedException"]);
test(dm1->current <= 1 && dm1->total == 1 && dm1->failures == 1 && dm1->userException == 0);
checkFailure(serverMetrics, "Dispatch", dm1->id, "Ice::ObjectNotExistException", 1);
test(dm1->size == 47 && dm1->replySize == 40);
dm1 = IceMX::DispatchMetricsPtr::dynamicCast(map["opWithUnknownException"]);
test(dm1->current <= 1 && dm1->total == 1 && dm1->failures == 1 && dm1->userException == 0);
checkFailure(serverMetrics, "Dispatch", dm1->id, "unknown", 1);
test(dm1->size == 41 && dm1->replySize == 23);
InvokeOp op(metrics);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "parent", "TestAdapter", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "id", "metrics [op]", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpoint", "tcp -h 127.0.0.1 -p 12010", op);
//testAttribute(serverMetrics, serverProps, update, "Dispatch", "connection", "", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointType", "1", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointIsDatagram", "false", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointIsSecure", "false", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointTimeout", "-1", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointCompress", "false", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointHost", "127.0.0.1", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointPort", "12010", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "incoming", "true", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "adapterName", "TestAdapter", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "connectionId", "", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "localHost", "127.0.0.1", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "localPort", "12010", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "remoteHost", "127.0.0.1", op);
//testAttribute(serverMetrics, serverProps, update, "Dispatch", "remotePort", "12010", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "mcastHost", "", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "mcastPort", "", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "operation", "op", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "identity", "metrics", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "facet", "", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "mode", "twoway", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "context.entry1", "test", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "context.entry2", "", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "context.entry3", "", op);
cout << "ok" << endl;
cout << "testing invocation metrics... " << flush;
props["IceMX.Metrics.View.Map.Invocation.GroupBy"] = "operation";
props["IceMX.Metrics.View.Map.Invocation.Map.Remote.GroupBy"] = "localPort";
updateProps(clientProps, serverProps, update, props, "Invocation");
test(serverMetrics->getMetricsView("View", timestamp)["Invocation"].empty());
CallbackPtr cb = new Callback();
metrics->op();
metrics->end_op(metrics->begin_op());
metrics->begin_op(newCallback_Metrics_op(cb, &Callback::response, &Callback::exception));
cb->waitForResponse();
// User exception
try
{
metrics->opWithUserException();
test(false);
}
catch(const Test::UserEx&)
{
}
try
{
metrics->end_opWithUserException(metrics->begin_opWithUserException());
test(false);
}
catch(const Test::UserEx&)
{
}
metrics->begin_opWithUserException(newCallback_Metrics_opWithUserException(
cb, &Callback::response, &Callback::exception));
cb->waitForResponse();
// Request failed exception
try
{
metrics->opWithRequestFailedException();
test(false);
}
catch(const Ice::RequestFailedException&)
{
}
try
{
metrics->end_opWithRequestFailedException(metrics->begin_opWithRequestFailedException());
test(false);
}
catch(const Ice::RequestFailedException&)
{
}
metrics->begin_opWithRequestFailedException(newCallback_Metrics_opWithRequestFailedException(
cb, &Callback::response, &Callback::exception));
cb->waitForResponse();
// Local exception
try
{
metrics->opWithLocalException();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
metrics->end_opWithLocalException(metrics->begin_opWithLocalException());
test(false);
}
catch(const Ice::LocalException&)
{
}
metrics->begin_opWithLocalException(newCallback_Metrics_opWithLocalException(
cb, &Callback::response, &Callback::exception));
cb->waitForResponse();
// Unknown exception
try
{
metrics->opWithUnknownException();
test(false);
}
catch(const Ice::UnknownException&)
{
}
try
{
metrics->end_opWithUnknownException(metrics->begin_opWithUnknownException());
test(false);
}
catch(const Ice::UnknownException&)
{
}
metrics->begin_opWithUnknownException(newCallback_Metrics_opWithUnknownException(
cb, &Callback::response, &Callback::exception));
cb->waitForResponse();
// Fail
try
{
metrics->fail();
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
try
{
metrics->end_fail(metrics->begin_fail());
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
metrics->begin_fail(newCallback_Metrics_fail(cb, &Callback::response, &Callback::exception));
cb->waitForResponse();
map = toMap(clientMetrics->getMetricsView("View", timestamp)["Invocation"]);
test(map.size() == 6);
IceMX::InvocationMetricsPtr im1;
IceMX::RemoteMetricsPtr rim1;
im1 = IceMX::InvocationMetricsPtr::dynamicCast(map["op"]);
test(im1->current <= 1 && im1->total == 3 && im1->failures == 0 && im1->retry == 0 && im1->remotes.size() == 1);
rim1 = IceMX::RemoteMetricsPtr::dynamicCast(im1->remotes[0]);
test(rim1->current == 0 && rim1->total == 3 && rim1->failures == 0);
test(rim1->size == 63 && rim1->replySize == 21);
im1 = IceMX::InvocationMetricsPtr::dynamicCast(map["opWithUserException"]);
test(im1->current <= 1 && im1->total == 3 && im1->failures == 0 && im1->retry == 0 && im1->remotes.size() == 1);
rim1 = IceMX::RemoteMetricsPtr::dynamicCast(im1->remotes[0]);
test(rim1->current == 0 && rim1->total == 3 && rim1->failures == 0);
test(rim1->size == 114 && rim1->replySize == 69);
test(im1->userException == 3);
im1 = IceMX::InvocationMetricsPtr::dynamicCast(map["opWithLocalException"]);
test(im1->current <= 1 && im1->total == 3 && im1->failures == 3 && im1->retry == 0 && im1->remotes.size() == 1);
rim1 = IceMX::RemoteMetricsPtr::dynamicCast(im1->remotes[0]);
test(rim1->current == 0 && rim1->total == 3 && rim1->failures == 0);
test(rim1->size == 117 && rim1->replySize > 7);
checkFailure(clientMetrics, "Invocation", im1->id, "Ice::UnknownLocalException", 3);
im1 = IceMX::InvocationMetricsPtr::dynamicCast(map["opWithRequestFailedException"]);
test(im1->current <= 1 && im1->total == 3 && im1->failures == 3 && im1->retry == 0 && im1->remotes.size() == 1);
rim1 = IceMX::RemoteMetricsPtr::dynamicCast(im1->remotes[0]);
test(rim1->current == 0 && rim1->total == 3 && rim1->failures == 0);
test(rim1->size == 141 && rim1->replySize == 120);
checkFailure(clientMetrics, "Invocation", im1->id, "Ice::ObjectNotExistException", 3);
im1 = IceMX::InvocationMetricsPtr::dynamicCast(map["opWithUnknownException"]);
test(im1->current <= 1 && im1->total == 3 && im1->failures == 3 && im1->retry == 0 && im1->remotes.size() == 1);
rim1 = IceMX::RemoteMetricsPtr::dynamicCast(im1->remotes[0]);
test(rim1->current == 0 && rim1->total == 3 && rim1->failures == 0);
test(rim1->size == 123 && rim1->replySize == 69);
checkFailure(clientMetrics, "Invocation", im1->id, "Ice::UnknownException", 3);
im1 = IceMX::InvocationMetricsPtr::dynamicCast(map["fail"]);
test(im1->current <= 1 && im1->total == 3 && im1->failures == 3 && im1->retry == 3 && im1->remotes.size() == 6);
test(im1->remotes[0]->current == 0 && im1->remotes[0]->total == 1 && im1->remotes[0]->failures == 1);
test(im1->remotes[1]->current == 0 && im1->remotes[1]->total == 1 && im1->remotes[1]->failures == 1);
test(im1->remotes[2]->current == 0 && im1->remotes[2]->total == 1 && im1->remotes[2]->failures == 1);
test(im1->remotes[3]->current == 0 && im1->remotes[3]->total == 1 && im1->remotes[3]->failures == 1);
test(im1->remotes[4]->current == 0 && im1->remotes[4]->total == 1 && im1->remotes[4]->failures == 1);
test(im1->remotes[5]->current == 0 && im1->remotes[5]->total == 1 && im1->remotes[5]->failures == 1);
checkFailure(clientMetrics, "Invocation", im1->id, "Ice::ConnectionLostException", 3);
testAttribute(clientMetrics, clientProps, update, "Invocation", "parent", "Communicator", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "id", "metrics -t -e 1.1 [op]", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "operation", "op", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "identity", "metrics", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "facet", "", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "encoding", "1.1", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "mode", "twoway", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "proxy",
"metrics -t -e 1.1:tcp -h 127.0.0.1 -p 12010", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "context.entry1", "test", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "context.entry2", "", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "context.entry3", "", op);
cout << "ok" << endl;
cout << "testing metrics view enable/disable..." << flush;
Ice::StringSeq disabledViews;
props["IceMX.Metrics.View.GroupBy"] = "none";
props["IceMX.Metrics.View.Disabled"] = "0";
updateProps(clientProps, serverProps, update, props, "Thread");
test(!clientMetrics->getMetricsView("View", timestamp)["Thread"].empty());
test(clientMetrics->getMetricsViewNames(disabledViews).size() == 1 && disabledViews.empty());
props["IceMX.Metrics.View.Disabled"] = "1";
updateProps(clientProps, serverProps, update, props, "Thread");
test(clientMetrics->getMetricsView("View", timestamp)["Thread"].empty());
test(clientMetrics->getMetricsViewNames(disabledViews).empty() && disabledViews.size() == 1);
clientMetrics->enableMetricsView("View");
test(!clientMetrics->getMetricsView("View", timestamp)["Thread"].empty());
test(clientMetrics->getMetricsViewNames(disabledViews).size() == 1 && disabledViews.empty());
clientMetrics->disableMetricsView("View");
test(clientMetrics->getMetricsView("View", timestamp)["Thread"].empty());
test(clientMetrics->getMetricsViewNames(disabledViews).empty() && disabledViews.size() == 1);
try
{
clientMetrics->enableMetricsView("UnknownView");
}
catch(const IceMX::UnknownMetricsView&)
{
}
cout << "ok" << endl;
cout << "testing instrumentation observer delegate... " << flush;
test(obsv->threadObserver->getTotal() > 0);
test(obsv->connectionObserver->getTotal() > 0);
test(obsv->connectionEstablishmentObserver->getTotal() > 0);
#ifndef ICE_OS_WINRT
test(obsv->endpointLookupObserver->getTotal() > 0);
#endif
test(obsv->dispatchObserver->getTotal() > 0);
test(obsv->invocationObserver->getTotal() > 0);
test(obsv->invocationObserver->remoteObserver->getTotal() > 0);
test(obsv->threadObserver->getCurrent() > 0);
test(obsv->connectionObserver->getCurrent() > 0);
test(obsv->connectionEstablishmentObserver->getCurrent() == 0);
#ifndef ICE_OS_WINRT
test(obsv->endpointLookupObserver->getCurrent() == 0);
#endif
test(obsv->dispatchObserver->getCurrent() == 0);
test(obsv->invocationObserver->getCurrent() == 0);
test(obsv->invocationObserver->remoteObserver->getCurrent() == 0);
test(obsv->threadObserver->getFailedCount() == 0);
test(obsv->connectionObserver->getFailedCount() > 0);
test(obsv->connectionEstablishmentObserver->getFailedCount() > 0);
#ifndef ICE_OS_WINRT
test(obsv->endpointLookupObserver->getFailedCount() > 0);
#endif
//test(obsv->dispatchObserver->getFailedCount() > 0);
test(obsv->invocationObserver->getFailedCount() > 0);
test(obsv->invocationObserver->remoteObserver->getFailedCount() > 0);
test(obsv->threadObserver->states > 0);
test(obsv->connectionObserver->received > 0 && obsv->connectionObserver->sent > 0);
//test(obsv->dispatchObserver->userExceptionCount > 0);
test(obsv->invocationObserver->userExceptionCount > 0 && obsv->invocationObserver->retriedCount > 0);
test(obsv->invocationObserver->remoteObserver->replySize > 0);
cout << "ok" << endl;
return metrics;
}
bool
isAdminInterfaceReachable( const Context& context, const orca::FQComponentName& fqName, const std::string& interfaceType,
std::string& diagnostic )
{
std::string facetName;
try {
facetName = orcaice::toAdminFacet( fqName, interfaceType );
}
catch ( const std::exception& e ) {
std::stringstream ss;
ss << "(while pinging Admin interface of type '" << interfaceType << "'): "<<e.what();
diagnostic = ss.str();
return false;
}
//
// This is the generic proxy to the Admin object. Cannot be used as such because it does not have a default facet.
//
Ice::ObjectPrx objectPrx = orcaice::getComponentAdmin( context, fqName );
if ( !objectPrx )
throw gbxutilacfr::Exception( ERROR_INFO,
"Registry returned null admin proxy for component "+fqName.platform+"/"+fqName.component );
// std::cout<<"DEBUG: "<<__func__<<"(): got admin proxy ="<<objectPrx->ice_toString()<<std::endl;
//
// Change proxy to the user-supplied facet name.
//
objectPrx = objectPrx->ice_facet( facetName );
// try to ping
try {
objectPrx->ice_ping();
}
catch ( const Ice::ConnectionRefusedException& e )
{
std::stringstream ss;
ss << "(while pinging Admin interface with facet '" << facetName << "') cannot reach the adaptor: "<<e.what();
diagnostic = ss.str();
return false;
}
catch ( const Ice::ObjectNotExistException& e )
{
std::stringstream ss;
ss << "(while pinging Admin interface with facet '" << facetName << "') reached the adaptor but not the interface: "<<e.what();
diagnostic = ss.str();
return false;
}
catch ( const Ice::FacetNotExistException& e )
{
std::stringstream ss;
ss << "(while pinging Admin interface with facet '" << facetName << "') reached the adaptor and the interface but not the facet: "<<e.what();
diagnostic = ss.str();
return false;
}
catch ( const std::exception& e )
{
std::stringstream ss;
ss << "(while pinging Admin interface with facet '" << facetName << "') something unexpected: "<<e.what();
diagnostic = ss.str();
return false;
}
return true;
}
void
allTests(const Ice::CommunicatorPtr& communicator, const string& ref)
{
ServerManagerPrx manager = ServerManagerPrx::checkedCast(communicator->stringToProxy(ref));
TestLocatorPrx locator = TestLocatorPrx::uncheckedCast(communicator->getDefaultLocator());
test(manager);
cout << "testing stringToProxy... " << flush;
Ice::ObjectPrx base = communicator->stringToProxy("test @ TestAdapter");
Ice::ObjectPrx base2 = communicator->stringToProxy("test @ TestAdapter");
Ice::ObjectPrx base3 = communicator->stringToProxy("test");
Ice::ObjectPrx base4 = communicator->stringToProxy("ServerManager");
Ice::ObjectPrx base5 = communicator->stringToProxy("test2");
Ice::ObjectPrx base6 = communicator->stringToProxy("test @ ReplicatedAdapter");
cout << "ok" << endl;
cout << "testing ice_locator and ice_getLocator... " << flush;
test(Ice::proxyIdentityEqual(base->ice_getLocator(), communicator->getDefaultLocator()));
Ice::LocatorPrx anotherLocator = Ice::LocatorPrx::uncheckedCast(communicator->stringToProxy("anotherLocator"));
base = base->ice_locator(anotherLocator);
test(Ice::proxyIdentityEqual(base->ice_getLocator(), anotherLocator));
communicator->setDefaultLocator(0);
base = communicator->stringToProxy("test @ TestAdapter");
test(!base->ice_getLocator());
base = base->ice_locator(anotherLocator);
test(Ice::proxyIdentityEqual(base->ice_getLocator(), anotherLocator));
communicator->setDefaultLocator(locator);
base = communicator->stringToProxy("test @ TestAdapter");
test(Ice::proxyIdentityEqual(base->ice_getLocator(), communicator->getDefaultLocator()));
//
// We also test ice_router/ice_getRouter (perhaps we should add a
// test/Ice/router test?)
//
test(!base->ice_getRouter());
Ice::RouterPrx anotherRouter = Ice::RouterPrx::uncheckedCast(communicator->stringToProxy("anotherRouter"));
base = base->ice_router(anotherRouter);
test(Ice::proxyIdentityEqual(base->ice_getRouter(), anotherRouter));
Ice::RouterPrx router = Ice::RouterPrx::uncheckedCast(communicator->stringToProxy("dummyrouter"));
communicator->setDefaultRouter(router);
base = communicator->stringToProxy("test @ TestAdapter");
test(Ice::proxyIdentityEqual(base->ice_getRouter(), communicator->getDefaultRouter()));
communicator->setDefaultRouter(0);
base = communicator->stringToProxy("test @ TestAdapter");
test(!base->ice_getRouter());
cout << "ok" << endl;
cout << "starting server... " << flush;
manager->startServer();
cout << "ok" << endl;
cout << "testing checked cast... " << flush;
TestIntfPrx obj = TestIntfPrx::checkedCast(base);
obj = TestIntfPrx::checkedCast(communicator->stringToProxy("test@TestAdapter"));
obj = TestIntfPrx::checkedCast(communicator->stringToProxy("test @TestAdapter"));
obj = TestIntfPrx::checkedCast(communicator->stringToProxy("test@ TestAdapter"));
test(obj);
TestIntfPrx obj2 = TestIntfPrx::checkedCast(base2);
test(obj2);
TestIntfPrx obj3 = TestIntfPrx::checkedCast(base3);
test(obj3);
ServerManagerPrx obj4 = ServerManagerPrx::checkedCast(base4);
test(obj4);
TestIntfPrx obj5 = TestIntfPrx::checkedCast(base5);
test(obj5);
TestIntfPrx obj6 = TestIntfPrx::checkedCast(base6);
test(obj6);
cout << "ok" << endl;
cout << "testing id@AdapterId indirect proxy... " << flush;
obj->shutdown();
manager->startServer();
try
{
obj2 = TestIntfPrx::checkedCast(base2);
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing id@ReplicaGroupId indirect proxy... " << flush;
obj->shutdown();
manager->startServer();
try
{
obj6 = TestIntfPrx::checkedCast(base6);
obj6->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing identity indirect proxy... " << flush;
obj->shutdown();
manager->startServer();
try
{
obj3 = TestIntfPrx::checkedCast(base3);
obj3->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
try
{
obj2 = TestIntfPrx::checkedCast(base2);
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj2 = TestIntfPrx::checkedCast(base2);
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
try
{
obj3 = TestIntfPrx::checkedCast(base3);
obj3->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj2 = TestIntfPrx::checkedCast(base2);
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj3 = TestIntfPrx::checkedCast(base3);
obj3->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj2 = TestIntfPrx::checkedCast(base2);
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj5 = TestIntfPrx::checkedCast(base5);
obj5->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing proxy with unknown identity... " << flush;
try
{
base = communicator->stringToProxy("unknown/unknown");
base->ice_ping();
test(false);
}
catch (const Ice::NotRegisteredException& ex)
{
test(ex.kindOfObject == "object");
test(ex.id == "unknown/unknown");
}
cout << "ok" << endl;
cout << "testing proxy with unknown adapter... " << flush;
try
{
base = communicator->stringToProxy("test @ TestAdapterUnknown");
base->ice_ping();
test(false);
}
catch (const Ice::NotRegisteredException& ex)
{
test(ex.kindOfObject == "object adapter");
test(ex.id == "TestAdapterUnknown");
}
cout << "ok" << endl;
cout << "testing locator cache timeout... " << flush;
int count = locator->getRequestCount();
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
test(++count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
test(++count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
test(count == locator->getRequestCount());
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1200));
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
test(++count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
count += 2;
test(count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout
test(count == locator->getRequestCount());
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1200));
communicator->stringToProxy("test")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout
count += 2;
test(count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(-1)->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_locatorCacheTimeout(-1)->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_ping();
test(count == locator->getRequestCount());
test(communicator->stringToProxy("test")->ice_locatorCacheTimeout(99)->ice_getLocatorCacheTimeout() == 99);
cout << "ok" << endl;
cout << "testing proxy from server... " << flush;
HelloPrx hello = obj->getHello();
test(hello->ice_getAdapterId() == "TestAdapter");
hello->sayHello();
hello = obj->getReplicatedHello();
test(hello->ice_getAdapterId() == "ReplicatedAdapter");
hello->sayHello();
cout << "ok" << endl;
cout << "testing proxy from server after shutdown... " << flush;
obj->shutdown();
manager->startServer();
hello->sayHello();
cout << "ok" << endl;
cout << "testing object migration... " << flush;
hello = HelloPrx::checkedCast(communicator->stringToProxy("hello"));
obj->migrateHello();
hello->sayHello();
obj->migrateHello();
hello->sayHello();
obj->migrateHello();
hello->sayHello();
cout << "ok" << endl;
cout << "shutdown server... " << flush;
obj->shutdown();
cout << "ok" << endl;
cout << "testing whether server is gone... " << flush;
try
{
obj2->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
obj3->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
obj5->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
cout << "ok" << endl;
cout << "testing indirect proxies to collocated objects... " << flush;
//
// Set up test for calling a collocated object through an indirect, adapterless reference.
//
Ice::PropertiesPtr properties = communicator->getProperties();
properties->setProperty("Ice.PrintAdapterReady", "0");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("Hello", "default");
adapter->setLocator(locator);
TestLocatorRegistryPrx registry = TestLocatorRegistryPrx::checkedCast(locator->getRegistry());
test(registry);
Ice::Identity id;
id.name = IceUtil::generateUUID();
registry->addObject(adapter->add(new HelloI, id));
adapter->activate();
try
{
HelloPrx helloPrx = HelloPrx::checkedCast(communicator->stringToProxy(communicator->identityToString(id)));
Ice::ConnectionPtr connection = helloPrx->ice_getConnection();
test(false);
}
catch(const Ice::CollocationOptimizationException&)
{
}
adapter->deactivate();
cout << "ok" << endl;
cout << "shutdown server manager... " << flush;
manager->shutdown();
cout << "ok" << endl;
}