void
Server::run(int argc, char** argv)
{
#ifdef ICE_STATIC_LIBS
Ice::registerPluginFactory("Test", createTestTransport, false);
#endif
Ice::PropertiesPtr properties = createTestProperties(argc, argv);
//
// This test kills connections, so we don't want warnings.
//
properties->setProperty("Ice.Warn.Connections", "0");
properties->setProperty("Ice.MessageSizeMax", "50000");
//
// This test relies on filling the TCP send/recv buffer, so
// we rely on a fixed value for these buffers.
//
properties->setProperty("Ice.TCP.RcvSize", "50000");
//
// Setup the test transport plug-in.
//
properties->setProperty("Ice.Plugin.Test", "TestTransport:createTestTransport");
string defaultProtocol = properties->getPropertyWithDefault("Ice.Default.Protocol", "tcp");
properties->setProperty("Ice.Default.Protocol", "test-" + defaultProtocol);
Ice::CommunicatorHolder communicator = initialize(argc, argv, properties);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint(0));
communicator->getProperties()->setProperty("ControllerAdapter.Endpoints", getTestEndpoint(1, "tcp"));
communicator->getProperties()->setProperty("ControllerAdapter.ThreadPool.Size", "1");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
Ice::ObjectAdapterPtr adapter2 = communicator->createObjectAdapter("ControllerAdapter");
#ifdef ICE_CPP11_MAPPING
shared_ptr<PluginI> plugin = dynamic_pointer_cast<PluginI>(communicator->getPluginManager()->getPlugin("Test"));
#else
PluginI* plugin = dynamic_cast<PluginI*>(communicator->getPluginManager()->getPlugin("Test").get());
#endif
assert(plugin);
ConfigurationPtr configuration = plugin->getConfiguration();
BackgroundControllerIPtr backgroundController = ICE_MAKE_SHARED(BackgroundControllerI, adapter, configuration);
adapter->add(ICE_MAKE_SHARED(BackgroundI, backgroundController), Ice::stringToIdentity("background"));
adapter->add(ICE_MAKE_SHARED(LocatorI, backgroundController), Ice::stringToIdentity("locator"));
adapter->add(ICE_MAKE_SHARED(RouterI, backgroundController), Ice::stringToIdentity("router"));
adapter->activate();
adapter2->add(backgroundController, Ice::stringToIdentity("backgroundController"));
adapter2->activate();
communicator->waitForShutdown();
}
void
Server::run(int argc, char** argv)
{
#ifdef ICE_STATIC_LIBS
Ice::registerIceDiscovery();
#endif
Ice::CommunicatorHolder communicator = initialize(argc, argv);
Ice::PropertiesPtr properties = communicator->getProperties();
int num = argc == 2 ? atoi(argv[1]) : 0;
properties->setProperty("ControlAdapter.Endpoints", getTestEndpoint(num));
{
ostringstream os;
os << "control" << num;
properties->setProperty("ControlAdapter.AdapterId", os.str());
}
properties->setProperty("ControlAdapter.ThreadPool.Size", "1");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("ControlAdapter");
{
ostringstream os;
os << "controller" << num;
adapter->add(ICE_MAKE_SHARED(ControllerI), Ice::stringToIdentity(os.str()));
}
adapter->activate();
serverReady();
communicator->waitForShutdown();
}
void
Server::run(int argc, char** argv)
{
Ice::PropertiesPtr properties = createTestProperties(argc, argv);
#if TARGET_OS_IPHONE != 0
//
// COMPILERFIX: Disable connect timeout introduced for
// workaround to iOS device hangs when using SSL
//
properties->setProperty("Ice.Override.ConnectTimeout", "");
#endif
//
// This test kills connections, so we don't want warnings.
//
properties->setProperty("Ice.Warn.Connections", "0");
//
// The client sends large messages to cause the transport
// buffers to fill up.
//
properties->setProperty("Ice.MessageSizeMax", "20000");
//
// Limit the recv buffer size, this test relies on the socket
// send() blocking after sending a given amount of data.
//
properties->setProperty("Ice.TCP.RcvSize", "50000");
Ice::CommunicatorHolder communicator = initialize(argc, argv, properties);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
communicator->getProperties()->setProperty("ControllerAdapter.Endpoints", getTestEndpoint(1));
communicator->getProperties()->setProperty("ControllerAdapter.ThreadPool.Size", "1");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(TimeoutI), Ice::stringToIdentity("timeout"));
adapter->activate();
Ice::ObjectAdapterPtr controllerAdapter = communicator->createObjectAdapter("ControllerAdapter");
controllerAdapter->add(ICE_MAKE_SHARED(ControllerI, adapter), Ice::stringToIdentity("controller"));
controllerAdapter->activate();
serverReady();
communicator->waitForShutdown();
}
void
Collocated::run(int argc, char** argv)
{
Ice::CommunicatorHolder communicator = initialize(argc, argv);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
//
// 2 threads are necessary to dispatch the collocated transient() call with AMI
//
communicator->getProperties()->setProperty("TestAdapter.ThreadPool.Size", "2");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
ServantLocatorPtr locator = ICE_MAKE_SHARED(ServantLocatorI);
adapter->addServantLocator(locator, "");
TestIntfPrxPtr allTests(TestHelper*);
allTests(this);
adapter->waitForDeactivate();
}
void
Server::run(int argc, char** argv)
{
Ice::CommunicatorHolder communicator = initialize(argc, argv);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(TestIntfI), Ice::stringToIdentity("test"));
adapter->activate();
serverReady();
communicator->waitForShutdown();
}
void
Server::run(int argc, char** argv)
{
Ice::CommunicatorHolder communicator = initialize(argc, argv);
Ice::PropertiesPtr properties = communicator->getProperties();
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint() + " -t 10000");
//
// First try to use an invalid priority.
//
communicator->getProperties()->setProperty("Ice.ThreadPool.Server.ThreadPriority", "1024");
try
{
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
test(false);
}
catch(const IceUtil::ThreadSyscallException&)
{
//expected
}
catch(...)
{
test(false);
}
//
// Now set the priority correctly.
//
#ifdef _WIN32
communicator->getProperties()->setProperty("Ice.ThreadPool.Server.ThreadPriority", "1");
#else
communicator->getProperties()->setProperty("Ice.ThreadPool.Server.ThreadPriority", "50");
#endif
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
Ice::ObjectPtr object = ICE_MAKE_SHARED(PriorityI, adapter);
adapter->add(object, Ice::stringToIdentity("test"));
adapter->activate();
communicator->waitForShutdown();
}
void
ServerAMD::run(int argc, char** argv)
{
Ice::PropertiesPtr properties = createTestProperties(argc, argv);
#ifndef ICE_CPP11_MAPPING
properties->setProperty("Ice.CollectObjects", "1");
#endif
Ice::CommunicatorHolder communicator = initialize(argc, argv, properties);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(InitialI), Ice::stringToIdentity("initial"));
adapter->activate();
serverReady();
communicator->waitForShutdown();
}
void
ServerAMD::run(int argc, char** argv)
{
Ice::PropertiesPtr properties = createTestProperties(argc, argv);
properties->setProperty("Ice.Warn.Connections", "0");
properties->setProperty("Ice.Warn.Dispatch", "0");
Ice::CommunicatorHolder communicator = initialize(argc, argv, properties);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(MyDerivedClassI), Ice::stringToIdentity("test"));
adapter->activate();
serverReady();
communicator->waitForShutdown();
}
void
Server::run(int argc, char** argv)
{
setProcessStringConverter(ICE_MAKE_SHARED(Test::StringConverterI));
setProcessWstringConverter(ICE_MAKE_SHARED(Test::WstringConverterI));
Ice::CommunicatorHolder communicator = initialize(argc, argv);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(TestIntfI), Ice::stringToIdentity("TEST"));
adapter->add(ICE_MAKE_SHARED(Test1::WstringClassI), Ice::stringToIdentity("WSTRING1"));
adapter->add(ICE_MAKE_SHARED(Test2::WstringClassI), Ice::stringToIdentity("WSTRING2"));
adapter->activate();
serverReady();
communicator->waitForShutdown();
}
void
ServerAMD::run(int argc, char** argv)
{
Ice::PropertiesPtr properties = createTestProperties(argc, argv);
//
// Its possible to have batch oneway requests dispatched after
// the adapter is deactivated due to thread scheduling so we
// supress this warning.
//
properties->setProperty("Ice.Warn.Dispatch", "0");
Ice::CommunicatorHolder communicator = initialize(argc, argv, properties);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(MyDerivedClassI), Ice::stringToIdentity("test"));
adapter->activate();
serverReady();
communicator->waitForShutdown();
}
int
main(int argc, char* argv[])
{
#ifdef ICE_STATIC_LIBS
Ice::registerIceSSL();
#endif
try
{
Ice::InitializationData initData;
initData.properties = Ice::createProperties(argc, argv);
Ice::CommunicatorHolder ich = Ice::initialize(argc, argv, initData);
assert(initData.properties != ich->getProperties());
return run(argc, argv, ich.communicator(), initData);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
return EXIT_FAILURE;
}
}
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
Client::run(int argc, char** argv)
{
Ice::CommunicatorHolder communicator = initialize(argc, argv);
instance = this;
string protocol = getTestProtocol();
string host = getTestHost();
_initData.properties = Ice::createProperties(argc, argv, communicator->getProperties());
_initData.properties->setProperty("Ice.Default.Router", "Glacier2/router:" + getTestEndpoint(50));
DispatcherPtr dispatcher = new Dispatcher();
dispatcher->start();
#ifdef ICE_CPP11_MAPPING
_initData.dispatcher = [dispatcher](std::function<void()> call, const std::shared_ptr<Ice::Connection>& conn)
{
dispatcher->dispatch(call, conn);
};
#else
_initData.dispatcher = dispatcher;
#endif
_factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(FailSessionCallback));
//
// Test to create a session with wrong userid/password
//
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
cout << "testing SessionHelper connect with wrong userid/password... " << flush;
_session = _factory->connect("userid", "xxx");
//
// Wait for connectFailed callback
//
_monitor.timedWait(IceUtil::Time::seconds(30));
test(!_session->isConnected());
}
_factory->destroy();
//
// Test to interrupt connection establishment
//
_initData.properties->setProperty("Ice.Default.Router", "");
_factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(InterruptConnectCallback));
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
cout << "testing SessionHelper connect interrupt... " << flush;
_factory->setRouterHost(host);
_factory->setPort(getTestPort(_initData.properties, 1));
_factory->setProtocol(protocol);
_session = _factory->connect("userid", "abc123");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100));
_session->destroy();
//
// Wait for connectFailed callback
//
_monitor.timedWait(IceUtil::Time::seconds(30));
test(!_session->isConnected());
}
_factory->destroy();
_factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(SuccessSessionCallback));
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
cout << "testing SessionHelper connect... " << flush;
_factory->setRouterHost(host);
_factory->setPort(getTestPort(_initData.properties, 50));
_factory->setProtocol(protocol);
_session = _factory->connect("userid", "abc123");
//
// Wait for connect callback
//
_monitor.timedWait(IceUtil::Time::seconds(30));
cout << "testing SessionHelper isConnected after connect... " << flush;
test(_session->isConnected());
cout << "ok" << endl;
cout << "testing SessionHelper categoryForClient after connect... " << flush;
try
{
test(!_session->categoryForClient().empty());
}
catch(const Glacier2::SessionNotExistException&)
{
test(false);
}
cout << "ok" << endl;
test(!_session->session());
cout << "testing stringToProxy for server object... " << flush;
Ice::ObjectPrxPtr base =
_session->communicator()->stringToProxy("callback:" + getTestEndpoint(_session->communicator()->getProperties()));
cout << "ok" << endl;
cout << "pinging server after session creation... " << flush;
base->ice_ping();
cout << "ok" << endl;
cout << "testing checked cast for server object... " << flush;
CallbackPrxPtr twoway = ICE_CHECKED_CAST(CallbackPrx, base);
test(twoway);
cout << "ok" << endl;
cout << "testing server shutdown... " << flush;
twoway->shutdown();
cout << "ok" << endl;
test(_session->communicator());
cout << "testing SessionHelper destroy... " << flush;
_session->destroy();
//
// Wait for disconnected callback
//
_monitor.wait();
cout << "testing SessionHelper isConnected after destroy... " << flush;
test(_session->isConnected() == false);
cout << "ok" << endl;
cout << "testing SessionHelper categoryForClient after destroy... " << flush;
try
{
test(!_session->categoryForClient().empty());
test(false);
}
catch(const Glacier2::SessionNotExistException&)
{
}
cout << "ok" << endl;
cout << "testing SessionHelper session after destroy... " << flush;
test(_session->session() == ICE_NULLPTR);
cout << "ok" << endl;
cout << "testing SessionHelper communicator after destroy... " << flush;
try
{
test(_session->communicator());
_session->communicator()->stringToProxy("dummy");
test(false);
}
catch(const Ice::CommunicatorDestroyedException&)
{
}
cout << "ok" << endl;
cout << "uninstalling router with communicator... " << flush;
communicator->setDefaultRouter(0);
cout << "ok" << endl;
Ice::ObjectPrxPtr processBase;
{
cout << "testing stringToProxy for process object... " << flush;
processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51));
cout << "ok" << endl;
}
Ice::ProcessPrxPtr process;
{
cout << "testing checked cast for admin object... " << flush;
process = ICE_CHECKED_CAST(Ice::ProcessPrx, processBase);
test(process != 0);
cout << "ok" << endl;
}
cout << "testing Glacier2 shutdown... " << flush;
process->shutdown();
try
{
process->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
cout << "ok" << endl;
}
}
_factory->destroy();
_factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(AfterShutdownSessionCallback));
//
// Wait a bit to ensure glaci2router has been shutdown.
//
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100));
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
cout << "testing SessionHelper connect after router shutdown... " << flush;
_factory->setRouterHost(host);
_factory->setPort(getTestPort(_initData.properties, 50));
_factory->setProtocol(protocol);
_session = _factory->connect("userid", "abc123");
//
// Wait for connectFailed callback
//
_monitor.wait();
cout << "testing SessionHelper isConnect after connect failure... " << flush;
test(_session->isConnected() == false);
cout << "ok" << endl;
cout << "testing SessionHelper communicator after connect failure... " << flush;
try
{
test(_session->communicator());
_session->communicator()->stringToProxy("dummy");
test(false);
}
catch(const Ice::CommunicatorDestroyedException&)
{
}
cout << "ok" << endl;
cout << "testing SessionHelper destroy after connect failure... " << flush;
_session->destroy();
cout << "ok" << endl;
}
_factory->destroy();
if(dispatcher)
{
dispatcher->destroy();
dispatcher->getThreadControl().join();
}
}
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;
}
}
}