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
SessionHelperI::destroyInternal(const Ice::DispatcherCallPtr& disconnected)
{
assert(_destroy);
Ice::CommunicatorPtr communicator;
Glacier2::RouterPrx router;
{
IceUtil::Mutex::Lock sync(_mutex);
router = _router;
_router = 0;
_connected = false;
communicator = _communicator;
}
if(router)
{
try
{
router->destroySession();
}
catch(const Ice::ConnectionLostException&)
{
//
// Expected if another thread invoked on an object from the session concurrently.
//
}
catch(const Glacier2::SessionNotExistException&)
{
//
// This can also occur.
//
}
catch(const std::exception& ex)
{
//
// Not expected.
//
if(communicator)
{
Ice::Warning warn(communicator->getLogger());
warn << "SessionHelper: unexpected exception when destroying the session:\n" << ex;
}
}
}
if(communicator)
{
try
{
communicator->destroy();
}
catch(...)
{
}
communicator = 0;
}
dispatchCallback(disconnected, 0);
}
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;
}
int
SessionControlClient::run(int argc, char* argv[])
{
//
// We initialize the controller on a separate port because we want
// to bypass the router for test control operations.
//
cout << "accessing test controller... " << flush;
Ice::InitializationData initData;
initData.properties = communicator()->getProperties();
Ice::CommunicatorPtr controlComm = Ice::initialize(argc, argv, initData);
TestControllerPrx controller = TestControllerPrx::checkedCast(
controlComm->stringToProxy("testController:tcp -p 12013"));
test(controller);
TestToken currentState;
TestToken newState;
currentState.expectedResult = false;
currentState.config = 0;
currentState.caseIndex = 0;
currentState.code = Initial;
controller->step(0, currentState, newState);
currentState = newState;
cout << "ok" << endl;
cout << "getting router... " << flush;
ObjectPrx routerBase = communicator()->stringToProxy("Glacier2/router:default -p 12347");
Glacier2::RouterPrx router = Glacier2::RouterPrx::checkedCast(routerBase);
test(router);
communicator()->setDefaultRouter(router);
cout << "ok" << endl;
Glacier2::SessionPrx sessionBase = router->createSession("userid", "abc123");
Test::TestSessionPrx currentSession = Test::TestSessionPrx::checkedCast(sessionBase);
bool printOk = false;
while(currentState.code == Running)
{
controller->step(currentSession, currentState, newState);
currentState = newState;
if(currentState.code != Running)
{
cout << "ok" << endl;
break;
}
//
// If we are running the first case for this configuration, print the configuration description.
//
if(currentState.caseIndex == 0)
{
if(printOk)
{
cout << "ok" << endl;
}
else
{
printOk = true;
}
cout << currentState.description << "... " << flush;
}
if(currentState.expectedResult)
{
BackendPrx prx = BackendPrx::uncheckedCast(communicator()->stringToProxy(currentState.testReference));
try
{
prx->check();
}
catch(const Exception& ex)
{
cerr << ex << endl;
test(false);
}
}
else
{
BackendPrx prx = BackendPrx::uncheckedCast(communicator()->stringToProxy(currentState.testReference));
try
{
prx->check();
test(false);
}
catch(const ObjectNotExistException&)
{
}
catch(const Exception& ex)
{
cerr << ex << endl;
test(false);
}
}
}
//
// Cleanup.
//
router->destroySession();
cout << "testing shutdown... " << flush;
try
{
//
// Shut down the test server.
//
currentSession = Test::TestSessionPrx::uncheckedCast(router->createSession("userid", "abc123"));
currentSession->shutdown();
}
catch(const Glacier2::CannotCreateSessionException& ex)
{
cerr << ex.reason << endl;
throw ex;
}
//
// Shut down the router.
//
communicator()->setDefaultRouter(0);
ObjectPrx processBase = communicator()->stringToProxy("Glacier2/admin -f Process:tcp -p 12348");
Ice::ProcessPrx process = Ice::ProcessPrx::checkedCast(processBase);
test(process);
process->shutdown();
try
{
process->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
cout << "ok" << endl;
}
try
{
controlComm->destroy();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
return EXIT_SUCCESS;
}
int
AttackClient::run(int, char**)
{
ObjectPrx routerBase = communicator()->stringToProxy("Glacier2/router:" + getTestEndpoint(communicator(), 10));
Glacier2::RouterPrx router = Glacier2::RouterPrx::checkedCast(routerBase);
test(router);
communicator()->setDefaultRouter(router);
PropertyDict::const_iterator p;
PropertyDict badProxies = communicator()->getProperties()->getPropertiesForPrefix("Reject.Proxy.");
for(p = badProxies.begin(); p != badProxies.end(); ++p)
{
try
{
Glacier2::SessionPrx session = router->createSession("userid", "abc123");
}
catch(const Glacier2::CannotCreateSessionException&)
{
test("Unable to create new session" == 0);
}
BackendPrx backend = BackendPrx::uncheckedCast(communicator()->stringToProxy(p->second));
try
{
backend->ice_ping();
cerr << "Test failed on : " << p->second << endl;
test("Expected exception" == 0);
}
catch(const ConnectionLostException&)
{
//
// This is ok.
//
}
catch(const CloseConnectionException&)
{
//
// This is also ok.
//
}
catch(const ObjectNotExistException&)
{
//
// This is ok for non-address filters.
//
try
{
router->destroySession();
}
catch(...)
{
}
}
catch(const LocalException& e)
{
cerr << e << endl;
test("Unexpected local exception" == 0);
}
}
PropertyDict goodProxies = communicator()->getProperties()->getPropertiesForPrefix("Accept.Proxy.");
for(p = goodProxies.begin(); p != goodProxies.end(); ++p)
{
try
{
Glacier2::SessionPrx session = router->createSession("userid", "abc123");
}
catch(const Glacier2::CannotCreateSessionException&)
{
test("Unable to create new session" == 0);
}
BackendPrx backend = BackendPrx::uncheckedCast(communicator()->stringToProxy(p->second));
try
{
backend->ice_ping();
}
catch(const LocalException& ex)
{
cerr << p->second << endl;
cerr << ex << endl;
test("Unexpected local exception" == 0);
}
try
{
router->destroySession();
}
catch(const LocalException&)
{
//
// Expected.
//
}
}
//
// Stop using router and communicate with backend and router directly
// to shut things down.
//
communicator()->setDefaultRouter(0);
try
{
BackendPrx backend = BackendPrx::checkedCast(communicator()->stringToProxy("dummy:tcp -p 12010"));
backend->shutdown();
}
catch(const Ice::LocalException&)
{
test(false);
}
ObjectPrx processBase = communicator()->stringToProxy("Glacier2/admin -f Process:" +
getTestEndpoint(communicator(), 11));
Ice::ProcessPrx process = Ice::ProcessPrx::checkedCast(processBase);
test(process);
process->shutdown();
try
{
process->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
cout << "ok" << endl;
}
return EXIT_SUCCESS;
}
int
CallbackClient::run(int, char**)
{
Glacier2::RouterPrx router = Glacier2::RouterPrx::uncheckedCast(
communicator()->stringToProxy("Glacier2/router:tcp -h 127.0.0.1 -p 12347"));
communicator()->setDefaultRouter(router);
//
// First try to create a non ssl sessions.
//
cout << "creating non-ssl session with tcp connection... ";
try
{
Glacier2::SessionPrx session = router->createSession("nossl", "");
session->ice_ping();
router->destroySession();
}
catch(const Glacier2::PermissionDeniedException&)
{
test(false);
}
cout << "ok" << endl;
cout << "creating ssl session with tcp connection... ";
try
{
Glacier2::SessionPrx session = router->createSessionFromSecureConnection();
test(false);
}
catch(const Glacier2::PermissionDeniedException&)
{
}
cout << "ok" << endl;
//
// Switch to using the SSL router. First, clear the router. Then
// set a new SSL based router.
//
communicator()->setDefaultRouter(Glacier2::RouterPrx());
router = Glacier2::RouterPrx::uncheckedCast(
communicator()->stringToProxy("Glacier2/router:ssl -h 127.0.0.1 -p 12348"));
communicator()->setDefaultRouter(router);
//
// Next try to create a non ssl session. This should succeed.
//
cout << "creating non-ssl session with ssl connection... ";
try
{
Glacier2::SessionPrx session = router->createSession("ssl", "");
session->ice_ping();
router->destroySession();
}
catch(const Glacier2::PermissionDeniedException&)
{
test(false);
}
cout << "ok" << endl;
cout << "creating ssl session with ssl connection... ";
try
{
Glacier2::SessionPrx session = router->createSessionFromSecureConnection();
session->ice_ping();
router->destroySession();
}
catch(const Glacier2::PermissionDeniedException&)
{
test(false);
}
cout << "ok" << endl;
communicator()->setDefaultRouter(0);
Ice::ProcessPrx process = Ice::ProcessPrx::checkedCast(
communicator()->stringToProxy("Glacier2/admin -f Process:tcp -h 127.0.0.1 -p 12349"));
process->shutdown();
return EXIT_SUCCESS;
}