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;
}
}
}
void
CallbackI::initiateCallbackWithPayload_async(const AMD_Callback_initiateCallbackWithPayloadPtr& cb,
const CallbackReceiverPrx& proxy,
const Current& current)
{
Ice::Context::const_iterator p = current.ctx.find("serverOvrd");
Ice::Context ctx = current.ctx;
if(p != current.ctx.end())
{
ctx["_ovrd"] = p->second;
}
Ice::ByteSeq seq(1000 * 1024, 0);
if(proxy->ice_isTwoway())
{
AsyncCBPtr acb = new AsyncCB();
proxy->begin_callbackWithPayload(seq, ctx,
newCallback_CallbackReceiver_callbackWithPayload(
acb,
&AsyncCB::responseCallbackWithPayload,
&AsyncCB::exceptionCallbackWithPayload),
newCookie(cb));
}
else
{
proxy->callbackWithPayload(seq, ctx);
cb->ice_response();
}
}
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);
}
void
CallbackI::initiateCallbackEx_async(const AMD_Callback_initiateCallbackExPtr& cb,
const CallbackReceiverPrx& proxy, const Current& current)
{
if(proxy->ice_isTwoway())
{
proxy->callbackEx_async(new AMI_CallbackReceiver_callbackExI(cb), current.ctx);
}
else
{
proxy->callbackEx(current.ctx);
cb->ice_response();
}
}
void
CallbackI::initiateWaitCallback_async(const AMD_Callback_initiateWaitCallbackPtr& cb,
const CallbackReceiverPrx& proxy,
const Current& current)
{
proxy->waitCallback_async(new AMI_CallbackReceiver_waitCallbackI(cb));
}
void
CallbackI::initiateConcurrentCallback_async(const AMD_Callback_initiateConcurrentCallbackPtr& cb,
Int number,
const CallbackReceiverPrx& proxy,
const Current& current)
{
proxy->concurrentCallback_async(new AMI_CallbackReceiver_concurrentCallbackI(cb), number, current.ctx);
}
void
CallbackI::initiateCallbackEx_async(const AMD_Callback_initiateCallbackExPtr& cb,
const CallbackReceiverPrx& proxy, const Current& current)
{
if(proxy->ice_isTwoway())
{
AsyncCBPtr acb = new AsyncCB();
proxy->begin_callbackEx(current.ctx,
newCallback_CallbackReceiver_callbackEx(acb, &AsyncCB::responseCallbackEx, &AsyncCB::exceptionCallbackEx),
newCookie(cb));
}
else
{
proxy->callbackEx(current.ctx);
cb->ice_response();
}
}
void
CallbackI::initiateCallbackWithPayload_async(const AMD_Callback_initiateCallbackWithPayloadPtr& cb,
const CallbackReceiverPrx& proxy,
const Current& current)
{
Ice::ByteSeq seq(1000 * 1024, 0);
proxy->callbackWithPayload_async(new AMI_CallbackReceiver_callbackWithPayloadI(cb), seq);
}
void
CallbackI::initiateWaitCallback_async(const AMD_Callback_initiateWaitCallbackPtr& cb,
const CallbackReceiverPrx& proxy,
const Current& current)
{
AsyncCBPtr acb = new AsyncCB();
proxy->begin_waitCallback(current.ctx,
newCallback_CallbackReceiver_waitCallback(acb, &AsyncCB::responseWaitCallback, &AsyncCB::exceptionWaitCallback),
newCookie(cb));
}
void
CallbackI::initiateCallbackWithPayload_async(const AMD_Callback_initiateCallbackWithPayloadPtr& cb,
const CallbackReceiverPrx& proxy,
const Current& current)
{
Ice::ByteSeq seq(1000 * 1024, 0);
AsyncCBPtr acb = new AsyncCB();
proxy->begin_callbackWithPayload(seq, current.ctx,
newCallback_CallbackReceiver_callbackWithPayload(acb, &AsyncCB::responseCallbackWithPayload,
&AsyncCB::exceptionCallbackWithPayload),
newCookie(cb));
}
void
CallbackI::initiateConcurrentCallback_async(const AMD_Callback_initiateConcurrentCallbackPtr& cb,
Int number,
const CallbackReceiverPrx& proxy,
const Current& current)
{
AsyncCBPtr acb = new AsyncCB();
proxy->begin_concurrentCallback(number, current.ctx,
newCallback_CallbackReceiver_concurrentCallback(acb, &AsyncCB::responseConcurrentCallback,
&AsyncCB::exceptionConcurrentCallback),
newCookie(cb));
}
void
CallbackSenderI::initiateCallback(const CallbackReceiverPrx& proxy, const Ice::Current& current)
{
printf("initiating callback\n"); fflush(stdout);
try
{
proxy->callback(current.ctx);
}
catch(const Ice::Exception& ex)
{
fprintf(stderr, "%s\n", ex.toString().c_str());
}
}
void
CallbackSenderI::initiateCallback(const CallbackReceiverPrx& proxy, const Current&)
{
cout << "initiating callback" << endl;
try
{
proxy->callback();
}
catch(const Exception& ex)
{
cout << ex << endl;
}
}
void
CallbackI::initiateCallback(const CallbackReceiverPrx& proxy, const Ice::Current& current)
{
cout << "initiating callback to: " << current.adapter->getCommunicator()->proxyToString(proxy) << endl;
try
{
proxy->callback();
}
catch(const Ice::Exception& ex)
{
cout << ex << endl;
}
}
void
CallbackI::initiateCallback_async(const AMD_Callback_initiateCallbackPtr& cb,
const CallbackReceiverPrx& proxy, int token, const Current& current)
{
Ice::Context::const_iterator p = current.ctx.find("serverOvrd");
Ice::Context ctx = current.ctx;
if(p != current.ctx.end())
{
ctx["_ovrd"] = p->second;
}
if(proxy->ice_isTwoway())
{
AsyncCBPtr acb = new AsyncCB();
proxy->begin_callback(token, ctx,
newCallback_CallbackReceiver_callback(acb, &AsyncCB::responseCallback, &AsyncCB::exceptionCallback),
newCookie(cb));
}
else
{
proxy->callback(token, ctx);
cb->ice_response();
}
}
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;
}
int
run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
{
if(argc > 1)
{
fprintf(stderr, "%s: too many arguments\n", argv[0]);
return EXIT_FAILURE;
}
Ice::PropertiesPtr properties = communicator->getProperties();
const char* proxyProperty = "CallbackSender.Proxy";
string proxy = properties->getProperty(proxyProperty);
if(proxy.empty())
{
fprintf(stderr, "%s: property `%s' not set\n", argv[0], proxyProperty);
return EXIT_FAILURE;
}
Ice::ObjectPrx base = communicator->stringToProxy(proxy);
CallbackSenderPrx twoway = CallbackSenderPrx::checkedCast(base->ice_twoway()->ice_timeout(-1));
if(!twoway)
{
fprintf(stderr, "%s: invalid proxy\n", argv[0]);
return EXIT_FAILURE;
}
CallbackSenderPrx oneway = twoway->ice_oneway();
#ifdef ICEE_HAS_BATCH
CallbackSenderPrx batchOneway = twoway->ice_batchOneway();
#endif
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("Callback.Client");
CallbackReceiverPtr cr = new CallbackReceiverI;
adapter->add(cr, communicator->stringToIdentity("callbackReceiver"));
adapter->activate();
CallbackReceiverPrx twowayR = CallbackReceiverPrx::uncheckedCast(
adapter->createProxy(communicator->stringToIdentity("callbackReceiver")));
CallbackReceiverPrx onewayR = twowayR->ice_oneway();
menu();
char c = EOF;
do
{
try
{
printf("==> "); fflush(stdout);
do
{
c = getchar();
}
while(c != EOF && c == '\n');
if(c == 't')
{
twoway->initiateCallback(twowayR);
}
else if(c == 'o')
{
oneway->initiateCallback(onewayR);
}
#ifdef ICEE_HAS_BATCH
else if(c == 'O')
{
batchOneway->initiateCallback(onewayR);
}
else if(c == 'f')
{
batchOneway->ice_flushBatchRequests();
}
#endif
else if(c == 's')
{
twoway->shutdown();
}
else if(c == 'x')
{
// Nothing to do
}
else if(c == '?')
{
menu();
}
else
{
printf("unknown command `%c'\n", c);
menu();
}
}
catch(const Ice::Exception& ex)
{
fprintf(stderr, "%s\n", ex.toString().c_str());
}
}
while(c != EOF && c != 'x');
return EXIT_SUCCESS;
}
int
CallbackClient::run(int argc, char* argv[])
{
//
// Since this is an interactive demo we want the custom interrupt
// callback to be called when the process is interrupted.
//
callbackOnInterrupt();
CallbackSenderPrx twoway = CallbackSenderPrx::checkedCast(
communicator()->propertyToProxy("Callback.CallbackServer")->
ice_twoway()->ice_timeout(-1)->ice_secure(false));
if(!twoway)
{
cerr << appName() << ": invalid proxy" << endl;
return EXIT_FAILURE;
}
CallbackSenderPrx oneway = CallbackSenderPrx::uncheckedCast(twoway->ice_oneway());
CallbackSenderPrx batchOneway = CallbackSenderPrx::uncheckedCast(twoway->ice_batchOneway());
CallbackSenderPrx datagram = CallbackSenderPrx::uncheckedCast(twoway->ice_datagram());
CallbackSenderPrx batchDatagram = CallbackSenderPrx::uncheckedCast(twoway->ice_batchDatagram());
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Callback.Client");
adapter->add(new CallbackReceiverI, communicator()->stringToIdentity("callbackReceiver"));
adapter->activate();
CallbackReceiverPrx twowayR = CallbackReceiverPrx::uncheckedCast(
adapter->createProxy(communicator()->stringToIdentity("callbackReceiver")));
CallbackReceiverPrx onewayR = CallbackReceiverPrx::uncheckedCast(twowayR->ice_oneway());
CallbackReceiverPrx datagramR = CallbackReceiverPrx::uncheckedCast(twowayR->ice_datagram());
bool secure = false;
string secureStr = "";
menu();
char c;
do
{
try
{
cout << "==> ";
cin >> c;
if(c == 't')
{
twoway->initiateCallback(twowayR);
}
else if(c == 'o')
{
oneway->initiateCallback(onewayR);
}
else if(c == 'O')
{
batchOneway->initiateCallback(onewayR);
}
else if(c == 'd')
{
if(secure)
{
cout << "secure datagrams are not supported" << endl;
}
else
{
datagram->initiateCallback(datagramR);
}
}
else if(c == 'D')
{
if(secure)
{
cout << "secure datagrams are not supported" << endl;
}
else
{
batchDatagram->initiateCallback(datagramR);
}
}
else if(c == 'f')
{
communicator()->flushBatchRequests();
}
else if(c == 'S')
{
secure = !secure;
secureStr = secure ? "s" : "";
twoway = CallbackSenderPrx::uncheckedCast(twoway->ice_secure(secure));
oneway = CallbackSenderPrx::uncheckedCast(oneway->ice_secure(secure));
batchOneway = CallbackSenderPrx::uncheckedCast(batchOneway->ice_secure(secure));
datagram = CallbackSenderPrx::uncheckedCast(datagram->ice_secure(secure));
batchDatagram = CallbackSenderPrx::uncheckedCast(batchDatagram->ice_secure(secure));
twowayR = CallbackReceiverPrx::uncheckedCast(twowayR->ice_secure(secure));
onewayR = CallbackReceiverPrx::uncheckedCast(onewayR->ice_secure(secure));
datagramR = CallbackReceiverPrx::uncheckedCast(datagramR->ice_secure(secure));
if(secure)
{
cout << "secure mode is now on" << endl;
}
else
{
cout << "secure mode is now off" << endl;
}
}
else if(c == 's')
{
twoway->shutdown();
}
else if(c == 'x')
{
// Nothing to do
}
else if(c == '?')
{
menu();
}
else
{
cout << "unknown command `" << c << "'" << endl;
menu();
}
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
}
}
while(cin.good() && c != 'x');
return EXIT_SUCCESS;
}
