void
CallbackClient::run(int argc, char** argv)
{
Ice::PropertiesPtr properties = createTestProperties(argc, argv);
properties->setProperty("Ice.Warn.Connections", "0");
properties->setProperty("Ice.ThreadPool.Client.Serialize", "1");
Ice::CommunicatorHolder communicator = initialize(argc, argv, properties);
ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:" + getTestEndpoint(50));
Glacier2::RouterPrx router = Glacier2::RouterPrx::checkedCast(routerBase);
communicator->setDefaultRouter(router);
ObjectPrx base = communicator->stringToProxy("c/callback:" + getTestEndpoint());
Glacier2::SessionPrx session = router->createSession("userid", "abc123");
base->ice_ping();
CallbackPrx twoway = CallbackPrx::checkedCast(base);
CallbackPrx oneway = twoway->ice_oneway();
CallbackPrx batchOneway = twoway->ice_batchOneway();
communicator->getProperties()->setProperty("Ice.PrintAdapterReady", "0");
ObjectAdapterPtr adapter = communicator->createObjectAdapterWithRouter("CallbackReceiverAdapter", router);
adapter->activate();
string category = router->getCategoryForClient();
CallbackReceiverI* callbackReceiverImpl = new CallbackReceiverI;
ObjectPtr callbackReceiver = callbackReceiverImpl;
Identity callbackReceiverIdent;
callbackReceiverIdent.name = "callbackReceiver";
callbackReceiverIdent.category = category;
CallbackReceiverPrx twowayR =
CallbackReceiverPrx::uncheckedCast(adapter->add(callbackReceiver, callbackReceiverIdent));
CallbackReceiverPrx onewayR = twowayR->ice_oneway();
{
cout << "testing client request override... " << flush;
{
for(int i = 0; i < 5; i++)
{
oneway->initiateCallback(twowayR, 0);
oneway->initiateCallback(twowayR, 0);
callbackReceiverImpl->callbackOK(2, 0);
}
}
{
Ice::Context ctx;
ctx["_ovrd"] = "test";
for(int i = 0; i < 5; i++)
{
oneway->initiateCallback(twowayR, i, ctx);
oneway->initiateCallback(twowayR, i, ctx);
oneway->initiateCallback(twowayR, i, ctx);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100));
test(callbackReceiverImpl->callbackOK(1, i) < 3);
}
}
cout << "ok" << endl;
}
{
cout << "testing server request override... " << flush;
Ice::Context ctx;
ctx["serverOvrd"] = "test";
for(int i = 0; i < 5; i++)
{
oneway->initiateCallback(onewayR, i, ctx);
oneway->initiateCallback(onewayR, i, ctx);
oneway->initiateCallback(onewayR, i, ctx);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100));
test(callbackReceiverImpl->callbackOK(1, i) < 3);
}
oneway->initiateCallback(twowayR, 0);
test(callbackReceiverImpl->callbackOK(1, 0) == 0);
int count = 0;
int nRetry = 0;
do
{
callbackReceiverImpl->hold();
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallback(twowayR, 0);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200 + nRetry * 200));
callbackReceiverImpl->activate();
test(callbackReceiverImpl->callbackOK(1, 0) == 0);
count = callbackReceiverImpl->callbackWithPayloadOK(0);
callbackReceiverImpl->callbackWithPayloadOK(count);
}
while(count == 10 && nRetry++ < 10);
test(count < 10);
oneway->initiateCallbackWithPayload(twowayR);
oneway->initiateCallbackWithPayload(twowayR);
callbackReceiverImpl->hold();
oneway->initiateCallbackWithPayload(twowayR);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallbackWithPayload(twowayR);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1000));
callbackReceiverImpl->activate();
test(callbackReceiverImpl->callbackWithPayloadOK(4) == 0);
int remainingCallbacks = callbackReceiverImpl->callbackOK(1, 0);
//
// Occasionally, Glacier2 flushes in the middle of our 5
// callbacks, so we get more than 1 callback
// (in theory we could get up to 5 total - more than 1 extra is extremely unlikely)
//
// The sleep above is also important as we want to have enough
// time to receive this (these) extra callback(s).
//
test(remainingCallbacks <= 4);
if(remainingCallbacks > 0)
{
test(callbackReceiverImpl->callbackOK(remainingCallbacks, 0) == 0);
}
ctx["_fwd"] = "O";
oneway->initiateCallbackWithPayload(twowayR);
callbackReceiverImpl->hold();
oneway->initiateCallbackWithPayload(twowayR);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallbackWithPayload(twowayR);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200));
callbackReceiverImpl->activate();
test(callbackReceiverImpl->callbackWithPayloadOK(3) == 0);
remainingCallbacks = callbackReceiverImpl->callbackOK(1, 0);
// Unlikely but sometime we get more than just one callback if the flush
// occurs in the middle of our 5 callbacks.
test(remainingCallbacks <= 3);
if(remainingCallbacks > 0)
{
test(callbackReceiverImpl->callbackOK(remainingCallbacks, 0) == 0);
}
cout << "ok" << endl;
}
{
cout << "shutdown... " << flush;
twoway->shutdown();
try
{
router->destroySession();
}
catch(const Ice::LocalException&)
{
test(false);
}
communicator->setDefaultRouter(0);
ObjectPrx processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51));
Ice::ProcessPrx process = Ice::ProcessPrx::checkedCast(processBase);
process->shutdown();
try
{
process->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
cout << "ok" << endl;
}
}
}
virtual void
stress(const CallbackPrx& callback, const CallbackReceiverPrx& receiver)
{
try
{
CallbackPrx cb = CallbackPrx::uncheckedCast(callback->ice_twoway());
Context context;
context["_fwd"] = "t";
while(true)
{
cb->initiateCallbackWithPayload(receiver, context);
test(_callbackReceiver->callbackWithPayloadOK());
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
}
}
catch(const Ice::ConnectionLostException&)
{
// Session was destroyed.
}
catch(const Ice::ObjectNotExistException&)
{
// This might be raised by the CallbackI implementation if it can't invoke on the
// callback receiver because the session is being destroyed concurrently.
}
catch(const Ice::CommunicatorDestroyedException&)
{
// This might happen if the retry fails because the communicator is destroyed.
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
}
virtual void
stress(const CallbackPrx& callback, const CallbackReceiverPrx&)
{
try
{
CallbackPrx cb = CallbackPrx::uncheckedCast(callback->ice_twoway());
Context context;
context["_fwd"] = "t";
while(true)
{
cb->ice_ping(context);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1));
}
}
catch(const Ice::ConnectionLostException&)
{
}
catch(const Ice::CommunicatorDestroyedException&)
{
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
}
int
CallbackClient::runWithSession(int argc, char*[])
{
if(argc > 1)
{
cerr << appName() << ": too many arguments" << endl;
return EXIT_FAILURE;
}
Ice::Identity callbackReceiverIdent = createCallbackIdentity("callbackReceiver");
Ice::Identity callbackReceiverFakeIdent;
callbackReceiverFakeIdent.name = "callbackReceiver";
callbackReceiverFakeIdent.category = "fake";
Ice::ObjectPrx base = communicator()->propertyToProxy("Callback.Proxy");
CallbackPrx twoway = CallbackPrx::checkedCast(base);
CallbackPrx oneway = CallbackPrx::uncheckedCast(twoway->ice_oneway());
CallbackPrx batchOneway = CallbackPrx::uncheckedCast(twoway->ice_batchOneway());
objectAdapter()->add(new CallbackReceiverI, callbackReceiverIdent);
// Should never be called for the fake identity.
objectAdapter()->add(new CallbackReceiverI, callbackReceiverFakeIdent);
CallbackReceiverPrx twowayR = CallbackReceiverPrx::uncheckedCast(
objectAdapter()->createProxy(callbackReceiverIdent));
CallbackReceiverPrx onewayR = CallbackReceiverPrx::uncheckedCast(twowayR->ice_oneway());
string override;
bool fake = false;
menu();
char c = 'x';
do
{
cout << "==> ";
cin >> c;
if(c == 't')
{
Ice::Context context;
context["_fwd"] = "t";
if(!override.empty())
{
context["_ovrd"] = override;
}
twoway->initiateCallback(twowayR, context);
}
else if(c == 'o')
{
Ice::Context context;
context["_fwd"] = "o";
if(!override.empty())
{
context["_ovrd"] = override;
}
oneway->initiateCallback(onewayR, context);
}
virtual
void run()
{
CommunicatorPtr communicator = initialize(initData);
ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:default -p 12347 -t 10000");
Glacier2::RouterPrx router = Glacier2::RouterPrx::checkedCast(routerBase);
communicator->setDefaultRouter(router);
ostringstream os;
os << "userid-" << _id;
Glacier2::SessionPrx session = router->createSession(os.str(), "abc123");
communicator->getProperties()->setProperty("Ice.PrintAdapterReady", "");
ObjectAdapterPtr adapter = communicator->createObjectAdapterWithRouter("CallbackReceiverAdapter", router);
adapter->activate();
string category = router->getCategoryForClient();
{
Lock sync(*this);
_callbackReceiver = new CallbackReceiverI;
notify();
}
Identity ident;
ident.name = "callbackReceiver";
ident.category = category;
CallbackReceiverPrx receiver = CallbackReceiverPrx::uncheckedCast(adapter->add(_callbackReceiver, ident));
ObjectPrx base = communicator->stringToProxy("c1/callback:tcp -p 12010 -t 10000");
base = base->ice_oneway();
CallbackPrx callback = CallbackPrx::uncheckedCast(base);
//
// Block the CallbackReceiver in wait() to prevent the client from
// processing other incoming calls and wait to receive the callback.
//
callback->initiateWaitCallback(receiver);
test(_callbackReceiver->waitCallbackOK());
//
// Notify the main thread that the callback was received.
//
{
Lock sync(*this);
_callback = true;
notify();
}
//
// Callback the client with a large payload. This should cause
// the Glacier2 request queue thread to block trying to send the
// callback to the client because the client is currently blocked
// in CallbackReceiverI::waitCallback() and can't process more
// requests.
//
callback->initiateCallbackWithPayload(receiver);
test(_callbackReceiver->callbackWithPayloadOK());
try
{
router->destroySession();
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
catch(const Ice::LocalException&)
{
test(false);
}
communicator->destroy();
}
int
CallbackClient::run(int argc, char* argv[])
{
ObjectPrx routerBase;
{
cout << "testing stringToProxy for router... " << flush;
routerBase = communicator()->stringToProxy("Glacier2/router:default -p 12347 -t 10000");
cout << "ok" << endl;
}
Glacier2::RouterPrx router;
{
cout << "testing checked cast for router... " << flush;
router = Glacier2::RouterPrx::checkedCast(routerBase);
test(router);
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:tcp -p 12010 -t 10000");
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;
session = router->createSession("userid", "abc123");
cout << "ok" << endl;
}
{
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;
}
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);
test(callbackReceiverImpl->callbackOK());
cout << "ok" << endl;
}
{
cout << "testing twoway callback... " << flush;
Context context;
context["_fwd"] = "t";
twoway->initiateCallback(twowayR, context);
test(callbackReceiverImpl->callbackOK());
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";
AMI_Callback_initiateConcurrentCallbackIPtr cb0 = new AMI_Callback_initiateConcurrentCallbackI();
twoway->initiateConcurrentCallback_async(cb0, 0, twowayR, context);
AMI_Callback_initiateConcurrentCallbackIPtr cb1 = new AMI_Callback_initiateConcurrentCallbackI();
twoway->initiateConcurrentCallback_async(cb1, 1, twowayR, context);
AMI_Callback_initiateConcurrentCallbackIPtr cb2 = new AMI_Callback_initiateConcurrentCallbackI();
twoway->initiateConcurrentCallback_async(cb2, 2, twowayR, context);
test(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");
}
test(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(communicator()->stringToIdentity("c2/callback")));
otherCategoryTwoway->initiateCallback(twowayR, context);
test(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(communicator()->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(communicator()->stringToIdentity("_userid/callback")));
otherCategoryTwoway->initiateCallback(twowayR, context);
test(callbackReceiverImpl->callbackOK());
cout << "ok" << endl;
}
{
cout << "testing buffered mode... " << 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);
test(callbackReceiverImpl->callbackWithPayloadOK());
twoway->initiateCallbackWithPayload(twowayR, context);
test(callbackReceiverImpl->callbackWithPayloadOK());
twoway->initiateCallbackWithPayload(twowayR, context);
test(callbackReceiverImpl->callbackWithPayloadOK());
twoway->initiateCallbackWithPayload(twowayR, context);
test(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(IceUtil::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);
test(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;
}
{
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();
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
catch(const Ice::LocalException&)
{
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 adminBase;
{
cout << "testing stringToProxy for admin object... " << flush;
adminBase = communicator()->stringToProxy("Glacier2/admin:tcp -h 127.0.0.1 -p 12348 -t 10000");
cout << "ok" << endl;
}
/*
{
cout << "uninstalling router with admin object... " << flush;
adminBase->ice_router(0);
cout << "ok" << endl;
}
*/
Glacier2::AdminPrx admin;
{
cout << "testing checked cast for admin object... " << flush;
admin = Glacier2::AdminPrx::checkedCast(adminBase);
test(admin);
cout << "ok" << endl;
}
cout << "testing Glacier2 shutdown... " << flush;
admin->shutdown();
try
{
admin->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
cout << "ok" << endl;
}
}
return EXIT_SUCCESS;
}