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;
}
}
}
int
CallbackServer::run(int, char**)
{
communicator()->getProperties()->setProperty("CallbackAdapter.Endpoints", "tcp -p 12010");
ObjectAdapterPtr adapter = communicator()->createObjectAdapter("CallbackAdapter");
adapter->add(new CallbackI(), communicator()->stringToIdentity("c1/callback")); // The test allows "c1" as category.
adapter->add(new CallbackI(), communicator()->stringToIdentity("c2/callback")); // The test allows "c2" as category.
adapter->add(new CallbackI(), communicator()->stringToIdentity("c3/callback")); // The test rejects "c3" as category.
adapter->add(new CallbackI(), communicator()->stringToIdentity("_userid/callback")); // The test allows the prefixed userid.
adapter->activate();
communicator()->waitForShutdown();
return EXIT_SUCCESS;
}
ServerLocatorI(BackendPtr backend, ObjectAdapterPtr adapter) :
_backend(backend),
_adapter(adapter)
{
_registryPrx = LocatorRegistryPrx::uncheckedCast(adapter->add(new ServerLocatorRegistry,
Ice::stringToIdentity("registry")));
}
void
ServiceI::start(const CommunicatorPtr& communicator,
const ObjectAdapterPtr& topicAdapter,
const ObjectAdapterPtr& publishAdapter,
const string& name,
const Ice::Identity& id,
const string& /*dbEnv*/)
{
//
// For IceGrid we don't validate the properties as all sorts of
// non-IceStorm properties are included in the prefix.
//
//validateProperties(name, communicator->getProperties(), communicator->getLogger());
// This is for IceGrid only and as such we use a transient
// implementation of IceStorm.
string instanceName = communicator->getProperties()->getPropertyWithDefault(name + ".InstanceName", "IceStorm");
_instance = new Instance(instanceName, name, communicator, publishAdapter, topicAdapter, 0);
try
{
TransientTopicManagerImplPtr manager = new TransientTopicManagerImpl(_instance);
_managerProxy = TopicManagerPrx::uncheckedCast(topicAdapter->add(manager, id));
}
catch(const Ice::Exception& ex)
{
_instance = 0;
LoggerOutputBase s;
s << "exception while starting IceStorm service " << name << ":\n";
s << ex;
throw IceBox::FailureException(__FILE__, __LINE__, s.str());
}
}
ServerLocatorI(const BackendPtr& backend, const ObjectAdapterPtr& adapter) :
_backend(backend),
_adapter(adapter),
_registryPrx(
LocatorRegistryPrx::uncheckedCast(
adapter->add(new ServerLocatorRegistry, _adapter->getCommunicator()->stringToIdentity("registry"))))
{
}
int
CallbackServer::run(int, char**)
{
communicator()->getProperties()->setProperty("CallbackAdapter.Endpoints", "tcp -p 12010");
ObjectAdapterPtr adapter = communicator()->createObjectAdapter("CallbackAdapter");
adapter->add(new CallbackI(), communicator()->stringToIdentity("c/callback"));
adapter->activate();
communicator()->waitForShutdown();
return EXIT_SUCCESS;
}
int
SessionControlServer::run(int, char**)
{
communicator()->getProperties()->setProperty("SessionControlAdapter.Endpoints", "tcp -p 12010");
ObjectAdapterPtr adapter = communicator()->createObjectAdapter("SessionControlAdapter");
adapter->add(new SessionManagerI, communicator()->stringToIdentity("SessionManager"));
adapter->activate();
communicator()->waitForShutdown();
return EXIT_SUCCESS;
}
int
SessionControlServer::run(int, char*[])
{
//
// The server requires 3 separate server endpoints. One for the test
// controller that will coordinate the tests and the required
// configurations across the client and the router, an adapter for
// the session manager for the router to communicate with and
// finally, an adapter for the dummy backend server that the client
// will ultimately attempt to make calls on. The backend uses a
// servant locator that responds to each lookup with the same
// servant, allowing us to use any reference as long as the client
// expects to use a proxy for the correct type of object.
//
communicator()->getProperties()->setProperty("TestControllerAdapter.Endpoints",
getTestEndpoint(communicator(), 2, "tcp"));
ObjectAdapterPtr controllerAdapter = communicator()->createObjectAdapter("TestControllerAdapter");
TestControllerIPtr controller = new TestControllerI(getTestEndpoint(communicator(), 1));
controllerAdapter->add(controller, Ice::stringToIdentity("testController"));
controllerAdapter->activate();
communicator()->getProperties()->setProperty("SessionControlAdapter.Endpoints", getTestEndpoint(communicator(), 0));
ObjectAdapterPtr adapter = communicator()->createObjectAdapter("SessionControlAdapter");
adapter->add(new SessionManagerI(controller), Ice::stringToIdentity("SessionManager"));
adapter->activate();
BackendPtr backend = new BackendI;
communicator()->getProperties()->setProperty("BackendAdapter.Endpoints", getTestEndpoint(communicator(), 1));
ObjectAdapterPtr backendAdapter = communicator()->createObjectAdapter("BackendAdapter");
backendAdapter->addServantLocator(new ServantLocatorI(backend), "");
backendAdapter->activate();
Ice::LocatorPtr locator = new ServerLocatorI(backend, backendAdapter);
backendAdapter->add(locator, Ice::stringToIdentity("locator"));
communicator()->waitForShutdown();
return EXIT_SUCCESS;
}
virtual
void run()
{
CommunicatorPtr communicator = initialize(initData);
ObjectPrx routerBase = communicator->stringToProxy(
"Glacier2/router:" + TestHelper::getTestEndpoint(communicator->getProperties(), 50));
_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();
_callbackReceiver = new CallbackReceiverI;
Identity ident;
ident.name = "callbackReceiver";
ident.category = category;
CallbackReceiverPrx receiver = CallbackReceiverPrx::uncheckedCast(adapter->add(_callbackReceiver, ident));
ObjectPrx base = communicator->stringToProxy(
"c1/callback:" + TestHelper::getTestEndpoint(communicator->getProperties()));
base = base->ice_oneway();
CallbackPrx callback = CallbackPrx::uncheckedCast(base);
{
Lock sync(*this);
_initialized = true;
notifyAll();
}
{
Lock sync(*this);
while(!_notified)
{
wait();
}
}
//
// Stress the router until the connection is closed.
//
stress(callback, receiver);
communicator->destroy();
}
int
BackendServer::run(int argc, char* argv[])
{
string endpoints =
communicator()->getProperties()->getPropertyWithDefault("BackendAdapter.Endpoints",
"tcp -p 12010 -t 20000:ssl -p 12011 -t 20000");
communicator()->getProperties()->setProperty("BackendAdapter.Endpoints", endpoints);
ObjectAdapterPtr adapter = communicator()->createObjectAdapter("BackendAdapter");
BackendPtr backend = new BackendI;
Ice::LocatorPtr locator = new ServerLocatorI(backend, adapter);
adapter->add(locator, communicator()->stringToIdentity("locator"));
adapter->addServantLocator(new ServantLocatorI(backend), "");
adapter->activate();
communicator()->waitForShutdown();
return EXIT_SUCCESS;
}
int run(int argc, char* argv[]) {
Example::CallbackIPtr servant = new Example::CallbackI(communicator());
ObjectAdapterPtr adapter =
communicator()->createObjectAdapter("CallbackAdapter");
ObjectPrx proxy = adapter->add(
servant, communicator()->stringToIdentity("callback"));
cout << communicator()->proxyToString(proxy) << endl;
adapter->activate();
servant->start();
shutdownOnInterrupt();
communicator()->waitForShutdown();
servant->destroy();
return 0;
}
bool
IceBox::ServiceManagerI::start()
{
try
{
ServiceManagerPtr obj = this;
PropertiesPtr properties = _communicator->getProperties();
//
// Create an object adapter. Services probably should NOT share
// this object adapter, as the endpoint(s) for this object adapter
// will most likely need to be firewalled for security reasons.
//
ObjectAdapterPtr adapter;
if(properties->getProperty("IceBox.ServiceManager.Endpoints") != "")
{
adapter = _communicator->createObjectAdapter("IceBox.ServiceManager");
Identity identity;
identity.category = properties->getPropertyWithDefault("IceBox.InstanceName", "IceBox");
identity.name = "ServiceManager";
adapter->add(obj, identity);
}
//
// Parse the property set with the prefix "IceBox.Service.". These
// properties should have the following format:
//
// IceBox.Service.Foo=entry_point [args]
//
// We parse the service properties specified in IceBox.LoadOrder
// first, then the ones from remaining services.
//
const string prefix = "IceBox.Service.";
PropertyDict services = properties->getPropertiesForPrefix(prefix);
PropertyDict::iterator p;
StringSeq loadOrder = properties->getPropertyAsList("IceBox.LoadOrder");
vector<StartServiceInfo> servicesInfo;
for(StringSeq::const_iterator q = loadOrder.begin(); q != loadOrder.end(); ++q)
{
p = services.find(prefix + *q);
if(p == services.end())
{
FailureException ex(__FILE__, __LINE__);
ex.reason = "ServiceManager: no service definition for `" + *q + "'";
throw ex;
}
servicesInfo.push_back(StartServiceInfo(*q, p->second, _argv));
services.erase(p);
}
for(p = services.begin(); p != services.end(); ++p)
{
servicesInfo.push_back(StartServiceInfo(p->first.substr(prefix.size()), p->second, _argv));
}
//
// Check if some services are using the shared communicator in which
// case we create the shared communicator now with a property set which
// is the union of all the service properties (services which are using
// the shared communicator).
//
PropertyDict sharedCommunicatorServices = properties->getPropertiesForPrefix("IceBox.UseSharedCommunicator.");
if(!sharedCommunicatorServices.empty())
{
InitializationData initData;
initData.properties = createServiceProperties("SharedCommunicator");
for(vector<StartServiceInfo>::iterator q = servicesInfo.begin(); q != servicesInfo.end(); ++q)
{
if(properties->getPropertyAsInt("IceBox.UseSharedCommunicator." + q->name) <= 0)
{
continue;
}
//
// Load the service properties using the shared communicator properties as
// the default properties.
//
PropertiesPtr svcProperties = createProperties(q->args, initData.properties);
//
// Erase properties from the shared communicator which don't exist in the
// service properties (which include the shared communicator properties
// overriden by the service properties).
//
PropertyDict allProps = initData.properties->getPropertiesForPrefix("");
for(PropertyDict::iterator p = allProps.begin(); p != allProps.end(); ++p)
{
if(svcProperties->getProperty(p->first) == "")
{
initData.properties->setProperty(p->first, "");
}
}
//
// Add the service properties to the shared communicator properties.
//
PropertyDict props = svcProperties->getPropertiesForPrefix("");
for(PropertyDict::const_iterator r = props.begin(); r != props.end(); ++r)
{
initData.properties->setProperty(r->first, r->second);
}
//
// Parse <service>.* command line options (the Ice command line options
// were parsed by the createProperties above)
//
q->args = initData.properties->parseCommandLineOptions(q->name, q->args);
}
_sharedCommunicator = initialize(initData);
}
//
// Start the services.
//
for(vector<StartServiceInfo>::const_iterator r = servicesInfo.begin(); r != servicesInfo.end(); ++r)
{
start(r->name, r->entryPoint, r->args);
}
//
// We may want to notify external scripts that the services
// have started. This is done by defining the property:
//
// IceBox.PrintServicesReady=bundleName
//
// Where bundleName is whatever you choose to call this set of
// services. It will be echoed back as "bundleName ready".
//
// This must be done after start() has been invoked on the
// services.
//
string bundleName = properties->getProperty("IceBox.PrintServicesReady");
if(!bundleName.empty())
{
cout << bundleName << " ready" << endl;
}
//
// Register "this" as a facet to the Admin object, and then create
// Admin object
//
try
{
_communicator->addAdminFacet(this, "IceBox.ServiceManager");
//
// Add a Properties facet for each service
//
for(vector<ServiceInfo>::iterator r = _services.begin(); r != _services.end(); ++r)
{
const ServiceInfo& info = *r;
CommunicatorPtr communicator = info.communicator != 0 ? info.communicator : _sharedCommunicator;
_communicator->addAdminFacet(new PropertiesAdminI(communicator->getProperties()),
"IceBox.Service." + info.name + ".Properties");
}
_communicator->getAdmin();
}
catch(const ObjectAdapterDeactivatedException&)
{
//
// Expected if the communicator has been shutdown.
//
}
if(adapter)
{
try
{
adapter->activate();
}
catch(const ObjectAdapterDeactivatedException&)
{
//
// Expected if the communicator has been shutdown.
//
}
}
}
catch(const FailureException& ex)
{
Error out(_logger);
out << ex.reason;
stopAll();
return false;
}
catch(const Exception& ex)
{
Error out(_logger);
out << "ServiceManager: " << ex;
stopAll();
return false;
}
return true;
}
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
Client::run(StringSeq& originalArgs)
{
string commands;
bool debug;
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
opts.addOpt("e", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
opts.addOpt("i", "instanceName", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat);
opts.addOpt("H", "host", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat);
opts.addOpt("P", "port", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat);
opts.addOpt("u", "username", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat);
opts.addOpt("p", "password", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat);
opts.addOpt("S", "ssl");
opts.addOpt("d", "debug");
opts.addOpt("s", "server");
opts.addOpt("r", "replica", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat);
vector<string> args;
try
{
args = opts.parse(originalArgs);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << e.reason << endl;
usage();
return EXIT_FAILURE;
}
if(!args.empty())
{
cerr << _appName << ": too many arguments" << endl;
usage();
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage();
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
cout << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
if(opts.isSet("server"))
{
ObjectAdapterPtr adapter =
communicator()->createObjectAdapterWithEndpoints("FileParser", "tcp -h localhost");
adapter->activate();
ObjectPrx proxy = adapter->add(new FileParserI, communicator()->stringToIdentity("FileParser"));
cout << proxy << endl;
communicator()->waitForShutdown();
return EXIT_SUCCESS;
}
if(opts.isSet("e"))
{
vector<string> optargs = opts.argVec("e");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
commands += *i + ";";
}
}
debug = opts.isSet("debug");
bool ssl = communicator()->getProperties()->getPropertyAsInt("IceGridAdmin.AuthenticateUsingSSL");
if(opts.isSet("ssl"))
{
ssl = true;
}
string id = communicator()->getProperties()->getProperty("IceGridAdmin.Username");
if(!opts.optArg("username").empty())
{
id = opts.optArg("username");
}
string password = communicator()->getProperties()->getProperty("IceGridAdmin.Password");
if(!opts.optArg("password").empty())
{
password = opts.optArg("password");
}
string host = communicator()->getProperties()->getProperty("IceGridAdmin.Host");
if(!opts.optArg("host").empty())
{
host = opts.optArg("host");
}
string instanceName = communicator()->getProperties()->getProperty("IceGridAdmin.InstanceName");
if(!opts.optArg("instanceName").empty())
{
instanceName = opts.optArg("instanceName");
}
int port = communicator()->getProperties()->getPropertyAsInt("IceGridAdmin.Port");
if(!opts.optArg("port").empty())
{
istringstream is(opts.optArg("port"));
if(!(is >> port))
{
cerr << _appName << ": given port number is not a numeric value" << endl;
return EXIT_FAILURE;
}
}
int
run(int argc, char* argv[], const CommunicatorPtr& communicator)
{
IceUtilInternal::Options opts;
opts.addOpt("", "id", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "unsub");
try
{
opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << argv[0] << ": " << e.reason << endl;
return EXIT_FAILURE;
}
PropertiesPtr properties = communicator->getProperties();
const char* managerProxyProperty = "IceStormAdmin.TopicManager.Default";
string managerProxy = properties->getProperty(managerProxyProperty);
if(managerProxy.empty())
{
cerr << argv[0] << ": property `" << managerProxyProperty << "' is not set" << endl;
return EXIT_FAILURE;
}
ObjectPrx base = communicator->stringToProxy(managerProxy);
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(base);
if(!manager)
{
cerr << argv[0] << ": `" << managerProxy << "' is not running" << endl;
return EXIT_FAILURE;
}
ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("SingleAdapter", "default");
TopicPrx topic;
try
{
topic = manager->retrieve("single");
}
catch(const IceStorm::NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
Ice::ObjectPrx prx = adapter->add(new SingleI(), communicator->stringToIdentity(opts.optArg("id")));
if(opts.isSet("unsub"))
{
topic->unsubscribe(prx);
}
else
{
IceStorm::QoS qos;
qos["persistent"] = "true";
topic->subscribeAndGetPublisher(qos, prx);
}
return EXIT_SUCCESS;
}
bool
RouterService::start(int argc, char* argv[], int& status)
{
bool nowarn;
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
opts.addOpt("", "nowarn");
vector<string> args;
try
{
args = opts.parse(argc, const_cast<const char**>(argv));
}
catch(const IceUtilInternal::BadOptException& e)
{
error(e.reason);
usage(argv[0]);
return false;
}
if(opts.isSet("help"))
{
usage(argv[0]);
status = EXIT_SUCCESS;
return false;
}
if(opts.isSet("version"))
{
print(ICE_STRING_VERSION);
status = EXIT_SUCCESS;
return false;
}
nowarn = opts.isSet("nowarn");
if(!args.empty())
{
consoleErr << argv[0] << ": too many arguments" << endl;
usage(argv[0]);
return false;
}
PropertiesPtr properties = communicator()->getProperties();
//
// Initialize the client object adapter.
//
const string clientEndpointsProperty = "Glacier2.Client.Endpoints";
if(properties->getProperty(clientEndpointsProperty).empty())
{
error("property `" + clientEndpointsProperty + "' is not set");
return false;
}
if(properties->getPropertyAsInt("Glacier2.SessionTimeout") > 0 &&
properties->getProperty("Glacier2.Client.ACM.Timeout").empty())
{
ostringstream os;
os << properties->getPropertyAsInt("Glacier2.SessionTimeout");
properties->setProperty("Glacier2.Client.ACM.Timeout", os.str());
}
if(properties->getProperty("Glacier2.Client.ACM.Close").empty())
{
properties->setProperty("Glacier2.Client.ACM.Close", "4"); // Forcefull close on invocation and idle.
}
ObjectAdapterPtr clientAdapter = communicator()->createObjectAdapter("Glacier2.Client");
//
// Initialize the server object adapter only if server endpoints
// are defined.
//
const string serverEndpointsProperty = "Glacier2.Server.Endpoints";
ObjectAdapterPtr serverAdapter;
if(!properties->getProperty(serverEndpointsProperty).empty())
{
serverAdapter = communicator()->createObjectAdapter("Glacier2.Server");
}
string instanceName = communicator()->getProperties()->getPropertyWithDefault("Glacier2.InstanceName", "Glacier2");
vector<string> verifierProperties;
verifierProperties.push_back("Glacier2.PermissionsVerifier");
verifierProperties.push_back("Glacier2.SSLPermissionsVerifier");
Glacier2Internal::setupNullPermissionsVerifier(communicator(), instanceName, verifierProperties);
string verifierProperty = verifierProperties[0];
PermissionsVerifierPrx verifier;
ObjectPrx obj;
try
{
//
// We use propertyToProxy instead of stringToProxy because the property
// can provide proxy attributes
//
obj = communicator()->propertyToProxy(verifierProperty);
}
catch(const std::exception& ex)
{
ServiceError err(this);
err << "permissions verifier `" << communicator()->getProperties()->getProperty(verifierProperty)
<< "' is invalid:\n" << ex;
return false;
}
if(obj)
{
try
{
verifier = PermissionsVerifierPrx::checkedCast(obj);
if(!verifier)
{
ServiceError err(this);
err << "permissions verifier `" << communicator()->getProperties()->getProperty(verifierProperty)
<< "' is invalid";
return false;
}
}
catch(const Ice::Exception& ex)
{
if(!nowarn)
{
ServiceWarning warn(this);
warn << "unable to contact permissions verifier `"
<< communicator()->getProperties()->getProperty(verifierProperty) << "'\n" << ex;
}
verifier = PermissionsVerifierPrx::uncheckedCast(obj);
}
}
//
// Get the session manager if specified.
//
string sessionManagerProperty = "Glacier2.SessionManager";
string sessionManagerPropertyValue = properties->getProperty(sessionManagerProperty);
SessionManagerPrx sessionManager;
if(!sessionManagerPropertyValue.empty())
{
try
{
obj = communicator()->propertyToProxy(sessionManagerProperty);
}
catch(const std::exception& ex)
{
ServiceError err(this);
err << "session manager `" << sessionManagerPropertyValue << "' is invalid\n:" << ex;
return false;
}
try
{
sessionManager = SessionManagerPrx::checkedCast(obj);
if(!sessionManager)
{
error("session manager `" + sessionManagerPropertyValue + "' is invalid");
return false;
}
}
catch(const std::exception& ex)
{
if(!nowarn)
{
ServiceWarning warn(this);
warn << "unable to contact session manager `" << sessionManagerPropertyValue << "'\n" << ex;
}
sessionManager = SessionManagerPrx::uncheckedCast(obj);
}
sessionManager =
SessionManagerPrx::uncheckedCast(sessionManager->ice_connectionCached(false)->ice_locatorCacheTimeout(
properties->getPropertyAsIntWithDefault("Glacier2.SessionManager.LocatorCacheTimeout", 600)));
}
//
// Check for an SSL permissions verifier.
//
string sslVerifierProperty = verifierProperties[1];
SSLPermissionsVerifierPrx sslVerifier;
try
{
obj = communicator()->propertyToProxy(sslVerifierProperty);
}
catch(const std::exception& ex)
{
ServiceError err(this);
err << "ssl permissions verifier `" << communicator()->getProperties()->getProperty(sslVerifierProperty)
<< "' is invalid:\n" << ex;
return false;
}
if(obj)
{
try
{
sslVerifier = SSLPermissionsVerifierPrx::checkedCast(obj);
if(!sslVerifier)
{
ServiceError err(this);
err << "ssl permissions verifier `"
<< communicator()->getProperties()->getProperty(sslVerifierProperty)
<< "' is invalid";
}
}
catch(const Ice::Exception& ex)
{
if(!nowarn)
{
ServiceWarning warn(this);
warn << "unable to contact ssl permissions verifier `"
<< communicator()->getProperties()->getProperty(sslVerifierProperty) << "'\n"
<< ex;
}
sslVerifier = SSLPermissionsVerifierPrx::uncheckedCast(obj);
}
}
//
// Get the SSL session manager if specified.
//
string sslSessionManagerProperty = "Glacier2.SSLSessionManager";
string sslSessionManagerPropertyValue = properties->getProperty(sslSessionManagerProperty);
SSLSessionManagerPrx sslSessionManager;
if(!sslSessionManagerPropertyValue.empty())
{
try
{
obj = communicator()->propertyToProxy(sslSessionManagerProperty);
}
catch(const std::exception& ex)
{
ServiceError err(this);
err << "ssl session manager `" << sslSessionManagerPropertyValue << "' is invalid:\n" << ex;
return false;
}
try
{
sslSessionManager = SSLSessionManagerPrx::checkedCast(obj);
if(!sslSessionManager)
{
error("ssl session manager `" + sslSessionManagerPropertyValue + "' is invalid");
return false;
}
}
catch(const Ice::Exception& ex)
{
if(!nowarn)
{
ServiceWarning warn(this);
warn << "unable to contact ssl session manager `" << sslSessionManagerPropertyValue
<< "'\n" << ex;
}
sslSessionManager = SSLSessionManagerPrx::uncheckedCast(obj);
}
sslSessionManager =
SSLSessionManagerPrx::uncheckedCast(sslSessionManager->ice_connectionCached(false)->ice_locatorCacheTimeout(
properties->getPropertyAsIntWithDefault("Glacier2.SSLSessionManager.LocatorCacheTimeout", 600)));
}
if(!verifier && !sslVerifier)
{
error("Glacier2 requires a permissions verifier or password file");
return false;
}
//
// Create the instance object.
//
try
{
_instance = new Glacier2::Instance(communicator(), clientAdapter, serverAdapter);
}
catch(const Ice::InitializationException& ex)
{
error("Glacier2 initialization failed:\n" + ex.reason);
return false;
}
//
// Create the session router. The session router registers itself
// and all required servant locators, so no registration has to be
// done here.
//
_sessionRouter = new SessionRouterI(_instance, verifier, sessionManager, sslVerifier, sslSessionManager);
//
// Th session router is used directly as servant for the main
// Glacier2 router Ice object.
//
Identity routerId;
routerId.category = instanceName;
routerId.name = "router";
Glacier2::RouterPrx routerPrx = Glacier2::RouterPrx::uncheckedCast(clientAdapter->add(_sessionRouter, routerId));
//
// Add the Ice router finder object to allow retrieving the router
// proxy with just the endpoint information of the router.
//
Identity finderId;
finderId.category = "Ice";
finderId.name = "RouterFinder";
clientAdapter->add(new FinderI(routerPrx), finderId);
if(_instance->getObserver())
{
_instance->getObserver()->setObserverUpdater(_sessionRouter);
}
//
// Everything ok, let's go.
//
try
{
clientAdapter->activate();
if(serverAdapter)
{
serverAdapter->activate();
}
}
catch(const std::exception& ex)
{
{
ServiceError err(this);
err << "caught exception activating object adapters\n" << ex;
}
stop();
return false;
}
return true;
}
