IceSSL::SSLEngine::SSLEngine(const Ice::CommunicatorPtr& communicator) :
_initialized(false),
_communicator(communicator),
_logger(communicator->getLogger()),
_trustManager(new TrustManager(communicator))
{
}
void
SessionHelperI::destroyInternal(const Ice::DispatcherCallPtr& disconnected)
{
assert(_destroy);
Ice::CommunicatorPtr communicator;
Glacier2::RouterPrxPtr router;
{
IceUtil::Mutex::Lock sync(_mutex);
router = _router;
_router = ICE_NULLPTR;
_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 = ICE_NULLPTR;
}
dispatchCallback(disconnected, ICE_NULLPTR);
}
void client::closeSession() {
IceUtil::RecMutex::Lock lock(mutex);
__sf = NULL;
Ice::ObjectAdapterPtr oldOa = __oa;
__oa = Ice::ObjectAdapterPtr();
Ice::CommunicatorPtr oldIc = __ic;
__ic = Ice::CommunicatorPtr();
// Only possible if improperly configured
if (! oldIc) {
return; // EARLY EXIT!
}
if (oldOa) {
try {
oldOa->deactivate();
} catch (const std::exception& ex) {
stringstream msg;
msg << "While deactivating adapter : " << ex.what() << std::endl;
oldIc->getLogger()->warning(msg.str());
}
}
__previous = Ice::InitializationData();
__previous.properties = oldIc->getProperties()->clone();
try {
getRouter(oldIc)->destroySession();
} catch (const Glacier2::SessionNotExistException& snee) {
// ok. We don't want it to exist
oldIc->destroy();
} catch (const Ice::ConnectionLostException& cle) {
// ok. Exception will always be thrown.
oldIc->destroy();
} catch (const Ice::ConnectionRefusedException& cre) {
// ok. Server probably went down
oldIc->destroy();
} catch (const Ice::ConnectTimeoutException& cre) {
// ok. Server probably went down
oldIc->destroy();
} catch (const omero::ClientError& ce) {
// This is called by getRouter() if a router is not configured.
// If there isn't one, then we can't be connected. That's alright.
// Most likely called during ~client
oldIc->destroy();
} catch (...) {
oldIc->destroy();
throw;
}
}
Glacier2::Instance::Instance(const Ice::CommunicatorPtr& communicator, const Ice::ObjectAdapterPtr& clientAdapter,
const Ice::ObjectAdapterPtr& serverAdapter) :
_communicator(communicator),
_properties(communicator->getProperties()),
_logger(communicator->getLogger()),
_clientAdapter(clientAdapter),
_serverAdapter(serverAdapter)
{
if(_properties->getPropertyAsIntWithDefault(serverBuffered, 1) > 0)
{
IceUtil::Time sleepTime = IceUtil::Time::milliSeconds(_properties->getPropertyAsInt(serverSleepTime));
const_cast<RequestQueueThreadPtr&>(_serverRequestQueueThread) = new RequestQueueThread(sleepTime);
try
{
_serverRequestQueueThread->start();
}
catch(const IceUtil::Exception&)
{
_serverRequestQueueThread->destroy();
throw;
}
}
if(_properties->getPropertyAsIntWithDefault(clientBuffered, 1) > 0)
{
IceUtil::Time sleepTime = IceUtil::Time::milliSeconds(_properties->getPropertyAsInt(clientSleepTime));
const_cast<RequestQueueThreadPtr&>(_clientRequestQueueThread) = new RequestQueueThread(sleepTime);
try
{
_clientRequestQueueThread->start();
}
catch(const IceUtil::Exception&)
{
_clientRequestQueueThread->destroy();
throw;
}
}
const_cast<ProxyVerifierPtr&>(_proxyVerifier) = new ProxyVerifier(communicator);
//
// If an Ice metrics observer is setup on the communicator, also
// enable metrics for IceStorm.
//
IceInternal::CommunicatorObserverIPtr o =
IceInternal::CommunicatorObserverIPtr::dynamicCast(communicator->getObserver());
if(o)
{
const_cast<Glacier2::Instrumentation::RouterObserverPtr&>(_observer) =
new RouterObserverI(o->getFacet(),
_properties->getPropertyWithDefault("Glacier2.InstanceName", "Glacier2"));
}
}
TraceLevels::TraceLevels(const Ice::CommunicatorPtr& communicator, const string& prefix) :
admin(0),
adminCat("Admin"),
application(0),
applicationCat("Application"),
node(0),
nodeCat("Node"),
replica(0),
replicaCat("Replica"),
server(0),
serverCat("Server"),
adapter(0),
adapterCat("Adapter"),
object(0),
objectCat("Object"),
activator(0),
activatorCat("Activator"),
patch(0),
patchCat("Patch"),
locator(0),
locatorCat("Locator"),
session(0),
sessionCat("Session"),
discovery(0),
discoveryCat("Discovery"),
logger(communicator->getLogger())
{
Ice::PropertiesPtr properties = communicator->getProperties();
string keyBase = prefix + ".Trace.";
const_cast<int&>(admin) = properties->getPropertyAsInt(keyBase + adminCat);
const_cast<int&>(application) = properties->getPropertyAsInt(keyBase + applicationCat);
const_cast<int&>(node) = properties->getPropertyAsInt(keyBase + nodeCat);
const_cast<int&>(replica) = properties->getPropertyAsInt(keyBase + replicaCat);
const_cast<int&>(server) = properties->getPropertyAsInt(keyBase + serverCat);
const_cast<int&>(adapter) = properties->getPropertyAsInt(keyBase + adapterCat);
const_cast<int&>(object) = properties->getPropertyAsInt(keyBase + objectCat);
const_cast<int&>(activator) = properties->getPropertyAsInt(keyBase + activatorCat);
const_cast<int&>(patch) = properties->getPropertyAsInt(keyBase + patchCat);
const_cast<int&>(locator) = properties->getPropertyAsInt(keyBase + locatorCat);
const_cast<int&>(session) = properties->getPropertyAsInt(keyBase + sessionCat);
const_cast<int&>(discovery) = properties->getPropertyAsInt(keyBase + discoveryCat);
}
ThrowerPrx
allTests(const Ice::CommunicatorPtr& communicator)
{
cout << "testing ice_print()/what()... " << flush;
{
A a;
string aMsg = "Test::A";
Ice::UnknownLocalException ule("thisFile", 99);
string uleMsg = "thisFile:99: Ice::UnknownLocalException:\nunknown local exception";
//
// Test ice_print().
//
{
stringstream str;
a.ice_print(str);
test(str.str() == aMsg);
}
{
stringstream str;
ule.ice_print(str);
test(str.str() == uleMsg);
}
//
// Test operator<<().
//
{
stringstream str;
str << a;
test(str.str() == aMsg);
}
{
stringstream str;
str << ule;
test(str.str() == uleMsg);
}
//
// Test what(). (Called twice because of lazy initialization in what().)
//
test(aMsg == a.what());
test(aMsg == a.what());
test(uleMsg == ule.what());
test(uleMsg == ule.what());
{
E ex("E");
ostringstream os;
ex.ice_print(os);
test(os.str() == "Test::E");
test(ex.data == "E");
}
//
// Test custom ice_print
//
{
F ex("F");
ostringstream os;
ex.ice_print(os);
test(os.str() == "Test::F data:'F'");
test(ex.data == "F");
}
{
G ex(__FILE__, __LINE__, "G");
ostringstream os;
ex.ice_print(os);
test(endsWith(os.str(), "Test::G"));
test(ex.data == "G");
}
{
H ex(__FILE__, __LINE__, "H");
ostringstream os;
ex.ice_print(os);
test(endsWith(os.str(), "Test::H data:'H'"));
test(ex.data == "H");
}
}
cout << "ok" << endl;
cout << "testing object adapter registration exceptions... " << flush;
{
Ice::ObjectAdapterPtr first;
try
{
first = communicator->createObjectAdapter("TestAdapter0");
test(false);
}
catch(const Ice::InitializationException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected
}
string host = communicator->getProperties()->getPropertyAsIntWithDefault("Ice.IPv6", 0) == 0 ?
"127.0.0.1" : "\"0:0:0:0:0:0:0:1\"";
communicator->getProperties()->setProperty("TestAdapter0.Endpoints", "default -h " + host);
first = communicator->createObjectAdapter("TestAdapter0");
try
{
Ice::ObjectAdapterPtr second = communicator->createObjectAdapter("TestAdapter0");
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected
}
try
{
Ice::ObjectAdapterPtr second =
communicator->createObjectAdapterWithEndpoints("TestAdapter0", "ssl -h foo -p 12011");
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected.
}
first->deactivate();
}
cout << "ok" << endl;
cout << "testing servant registration exceptions... " << flush;
{
string host = communicator->getProperties()->getPropertyAsIntWithDefault("Ice.IPv6", 0) == 0 ?
"127.0.0.1" : "\"0:0:0:0:0:0:0:1\"";
communicator->getProperties()->setProperty("TestAdapter1.Endpoints", "default -h " + host);
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter1");
Ice::ObjectPtr obj = new EmptyI;
adapter->add(obj, communicator->stringToIdentity("x"));
try
{
adapter->add(obj, communicator->stringToIdentity("x"));
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
try
{
adapter->add(obj, communicator->stringToIdentity(""));
}
catch(const Ice::IllegalIdentityException& ex)
{
test(ex.id.name == "");
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
try
{
adapter->add(0, communicator->stringToIdentity("x"));
}
catch(const Ice::IllegalServantException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
adapter->remove(communicator->stringToIdentity("x"));
try
{
adapter->remove(communicator->stringToIdentity("x"));
test(false);
}
catch(const Ice::NotRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
adapter->deactivate();
}
cout << "ok" << endl;
cout << "testing servant locator registrations exceptions... " << flush;
{
string host = communicator->getProperties()->getPropertyAsIntWithDefault("Ice.IPv6", 0) == 0 ?
"127.0.0.1" : "\"0:0:0:0:0:0:0:1\"";
communicator->getProperties()->setProperty("TestAdapter2.Endpoints", "default -h " + host);
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter2");
Ice::ServantLocatorPtr loc = new ServantLocatorI;
adapter->addServantLocator(loc, "x");
try
{
adapter->addServantLocator(loc, "x");
test(false);
}
catch(const Ice::AlreadyRegisteredException&)
{
}
adapter->deactivate();
}
cout << "ok" << endl;
cout << "testing object factory registration exception... " << flush;
{
Ice::ObjectFactoryPtr of = new ObjectFactoryI;
communicator->addObjectFactory(of, "x");
try
{
communicator->addObjectFactory(of, "x");
test(false);
}
catch(const Ice::AlreadyRegisteredException&)
{
}
}
cout << "ok" << endl;
cout << "testing stringToProxy... " << flush;
string ref = "thrower:default -p 12010";
Ice::ObjectPrx base = communicator->stringToProxy(ref);
test(base);
cout << "ok" << endl;
cout << "testing checked cast... " << flush;
ThrowerPrx thrower = ThrowerPrx::checkedCast(base);
test(thrower);
test(thrower == base);
cout << "ok" << endl;
cout << "catching exact types... " << flush;
try
{
thrower->throwAasA(1);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(const Ice::Exception& ex)
{
cout << ex << endl;
test(false);
}
catch(...)
{
test(false);
}
try
{
thrower->throwAorDasAorD(1);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwAorDasAorD(-1);
test(false);
}
catch(const D& ex)
{
test(ex.dMem == -1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwBasB(1, 2);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasC(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
try
{
thrower->throwModA(1, 2);
test(false);
}
catch(const Mod::A& ex)
{
test(ex.aMem == 1);
test(ex.a2Mem == 2);
}
catch(const Ice::OperationNotExistException&)
{
//
// This operation is not supported in Java.
//
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching base types... " << flush;
try
{
thrower->throwBasB(1, 2);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasC(1, 2, 3);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwModA(1, 2);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(const Ice::OperationNotExistException&)
{
//
// This operation is not supported in Java.
//
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching derived types... " << flush;
try
{
thrower->throwBasA(1, 2);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasA(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasB(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
if(thrower->supportsUndeclaredExceptions())
{
cout << "catching unknown user exception... " << flush;
try
{
thrower->throwUndeclaredA(1);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(const Ice::Exception& ex)
{
cout << ex << endl;
cout << ex.ice_stackTrace() << endl;
test(false);
}
catch(...)
{
test(false);
}
try
{
thrower->throwUndeclaredB(1, 2);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwUndeclaredC(1, 2, 3);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
}
if(thrower->ice_getConnection())
{
cout << "testing memory limit marshal exception..." << flush;
try
{
thrower->throwMemoryLimitException(Ice::ByteSeq());
test(false);
}
catch(const Ice::MemoryLimitException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwMemoryLimitException(Ice::ByteSeq(20 * 1024)); // 20KB
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(communicator->stringToProxy("thrower:default -p 12011"));
try
{
thrower2->throwMemoryLimitException(Ice::ByteSeq(2 * 1024 * 1024)); // 2MB (no limits)
}
catch(const Ice::MemoryLimitException&)
{
}
ThrowerPrx thrower3 = ThrowerPrx::uncheckedCast(communicator->stringToProxy("thrower:default -p 12012"));
try
{
thrower3->throwMemoryLimitException(Ice::ByteSeq(1024)); // 1KB limit
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
cout << "ok" << endl;
}
cout << "catching object not exist exception... " << flush;
Ice::Identity id = communicator->stringToIdentity("does not exist");
try
{
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower->ice_identity(id));
thrower2->throwAasA(1);
// thrower2->ice_ping();
test(false);
}
catch(const Ice::ObjectNotExistException& ex)
{
test(ex.id == id);
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching facet not exist exception... " << flush;
try
{
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower, "no such facet");
try
{
thrower2->ice_ping();
test(false);
}
catch(const Ice::FacetNotExistException& ex)
{
test(ex.facet == "no such facet");
}
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching operation not exist exception... " << flush;
try
{
WrongOperationPrx thrower2 = WrongOperationPrx::uncheckedCast(thrower);
thrower2->noSuchOperation();
test(false);
}
catch(const Ice::OperationNotExistException& ex)
{
test(ex.operation == "noSuchOperation");
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching unknown local exception... " << flush;
try
{
thrower->throwLocalException();
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwLocalExceptionIdempotent();
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(const Ice::OperationNotExistException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching unknown non-Ice exception... " << flush;
try
{
thrower->throwNonIceException();
test(false);
}
catch(const Ice::UnknownException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "testing asynchronous exceptions... " << flush;
try
{
thrower->throwAfterResponse();
}
catch(...)
{
test(false);
}
try
{
thrower->throwAfterException();
}
catch(const A&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching exact types with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasA);
thrower->begin_throwAasA(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAorDasAorDPtr callback =
newCallback_Thrower_throwAorDasAorD(cb, &Callback::response, &Callback::exception_AorDasAorD);
thrower->begin_throwAorDasAorD(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAorDasAorDPtr callback =
newCallback_Thrower_throwAorDasAorD(cb, &Callback::response, &Callback::exception_AorDasAorD);
thrower->begin_throwAorDasAorD(-1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwBasBPtr callback =
newCallback_Thrower_throwBasB(cb, &Callback::response, &Callback::exception_BasB);
thrower->begin_throwBasB(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasCPtr callback =
newCallback_Thrower_throwCasC(cb, &Callback::response, &Callback::exception_CasC);
thrower->begin_throwCasC(1, 2, 3, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwModAPtr callback =
newCallback_Thrower_throwModA(cb, &Callback::response, &Callback::exception_ModA);
thrower->begin_throwModA(1, 2, callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching derived types with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwBasAPtr callback =
newCallback_Thrower_throwBasA(cb, &Callback::response, &Callback::exception_BasA);
thrower->begin_throwBasA(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasAPtr callback =
newCallback_Thrower_throwCasA(cb, &Callback::response, &Callback::exception_CasA);
thrower->begin_throwCasA(1, 2, 3, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasBPtr callback =
newCallback_Thrower_throwCasB(cb, &Callback::response, &Callback::exception_CasB);
thrower->begin_throwCasB(1, 2, 3, callback);
cb->check();
}
cout << "ok" << endl;
if(thrower->supportsUndeclaredExceptions())
{
cout << "catching unknown user exception with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredAPtr callback =
newCallback_Thrower_throwUndeclaredA(cb, &Callback::response, &Callback::exception_UndeclaredA);
thrower->begin_throwUndeclaredA(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredBPtr callback =
newCallback_Thrower_throwUndeclaredB(cb, &Callback::response, &Callback::exception_UndeclaredB);
thrower->begin_throwUndeclaredB(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredCPtr callback =
newCallback_Thrower_throwUndeclaredC(cb, &Callback::response, &Callback::exception_UndeclaredC);
thrower->begin_throwUndeclaredC(1, 2, 3, callback);
cb->check();
}
cout << "ok" << endl;
}
cout << "catching object not exist exception with new AMI mapping... " << flush;
{
id = communicator->stringToIdentity("does not exist");
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower->ice_identity(id));
CallbackPtr cb = new Callback(communicator);
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasAObjectNotExist);
thrower2->begin_throwAasA(1, callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching facet not exist exception with new AMI mapping... " << flush;
{
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower, "no such facet");
CallbackPtr cb = new Callback;
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasAFacetNotExist);
thrower2->begin_throwAasA(1, callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching operation not exist exception with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_WrongOperation_noSuchOperationPtr callback =
newCallback_WrongOperation_noSuchOperation(cb, &Callback::response,
&Callback::exception_noSuchOperation);
WrongOperationPrx thrower4 = WrongOperationPrx::uncheckedCast(thrower);
thrower4->begin_noSuchOperation(callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching unknown local exception with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwLocalExceptionPtr callback =
newCallback_Thrower_throwLocalException(cb, &Callback::response, &Callback::exception_LocalException);
thrower->begin_throwLocalException(callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwLocalExceptionIdempotentPtr callback =
newCallback_Thrower_throwLocalExceptionIdempotent(cb, &Callback::response,
&Callback::exception_LocalException);
thrower->begin_throwLocalExceptionIdempotent(callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching unknown non-Ice exception with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwNonIceExceptionPtr callback =
newCallback_Thrower_throwNonIceException(cb, &Callback::response, &Callback::exception_NonIceException);
thrower->begin_throwNonIceException(callback);
cb->check();
}
cout << "ok" << endl;
return thrower;
}
ThrowerPrxPtr
allTests(const Ice::CommunicatorPtr& communicator)
{
cout << "testing ice_print()/what()... " << flush;
{
A a;
string aMsg = "Test::A";
Ice::UnknownLocalException ule("thisFile", 99);
string uleMsg = "thisFile:99: Ice::UnknownLocalException:\nunknown local exception";
//
// Test ice_print().
//
{
stringstream str;
a.ice_print(str);
test(str.str() == aMsg);
}
{
stringstream str;
ule.ice_print(str);
test(str.str() == uleMsg);
}
//
// Test operator<<().
//
{
stringstream str;
str << a;
test(str.str() == aMsg);
}
{
stringstream str;
str << ule;
test(str.str() == uleMsg);
}
//
// Test what(). (Called twice because of lazy initialization in what().)
//
test(aMsg == a.what());
test(aMsg == a.what());
test(uleMsg == ule.what());
test(uleMsg == ule.what());
{
E ex("E");
ostringstream os;
ex.ice_print(os);
test(os.str() == "Test::E");
test(ex.data == "E");
}
//
// Test custom ice_print
//
{
F ex("F");
ostringstream os;
ex.ice_print(os);
test(os.str() == "Test::F data:'F'");
test(ex.data == "F");
}
{
G ex(__FILE__, __LINE__, "G");
ostringstream os;
ex.ice_print(os);
test(endsWith(os.str(), "Test::G"));
test(ex.data == "G");
}
{
H ex(__FILE__, __LINE__, "H");
ostringstream os;
ex.ice_print(os);
test(endsWith(os.str(), "Test::H data:'H'"));
test(ex.data == "H");
}
}
cout << "ok" << endl;
string localOAEndpoint;
{
ostringstream ostr;
if(communicator->getProperties()->getProperty("Ice.Default.Protocol") == "bt")
{
ostr << "default -a *";
}
else
{
ostr << "default -h *";
}
localOAEndpoint = ostr.str();
}
cout << "testing object adapter registration exceptions... " << flush;
{
Ice::ObjectAdapterPtr first;
try
{
first = communicator->createObjectAdapter("TestAdapter0");
test(false);
}
catch(const Ice::InitializationException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected
}
communicator->getProperties()->setProperty("TestAdapter0.Endpoints", localOAEndpoint);
first = communicator->createObjectAdapter("TestAdapter0");
try
{
Ice::ObjectAdapterPtr second = communicator->createObjectAdapter("TestAdapter0");
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected
}
try
{
Ice::ObjectAdapterPtr second =
communicator->createObjectAdapterWithEndpoints("TestAdapter0", "ssl -h foo -p 12011");
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected.
}
first->deactivate();
}
cout << "ok" << endl;
cout << "testing servant registration exceptions... " << flush;
{
communicator->getProperties()->setProperty("TestAdapter1.Endpoints", localOAEndpoint);
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter1");
Ice::ObjectPtr obj = ICE_MAKE_SHARED(EmptyI);
adapter->add(obj, communicator->stringToIdentity("x"));
try
{
adapter->add(obj, communicator->stringToIdentity("x"));
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
try
{
adapter->add(obj, communicator->stringToIdentity(""));
}
catch(const Ice::IllegalIdentityException& ex)
{
test(ex.id.name == "");
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
try
{
adapter->add(0, communicator->stringToIdentity("x"));
}
catch(const Ice::IllegalServantException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
adapter->remove(communicator->stringToIdentity("x"));
try
{
adapter->remove(communicator->stringToIdentity("x"));
test(false);
}
catch(const Ice::NotRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
adapter->deactivate();
}
cout << "ok" << endl;
cout << "testing servant locator registrations exceptions... " << flush;
{
communicator->getProperties()->setProperty("TestAdapter2.Endpoints", localOAEndpoint);
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter2");
Ice::ServantLocatorPtr loc = ICE_MAKE_SHARED(ServantLocatorI);
adapter->addServantLocator(loc, "x");
try
{
adapter->addServantLocator(loc, "x");
test(false);
}
catch(const Ice::AlreadyRegisteredException&)
{
}
adapter->deactivate();
}
cout << "ok" << endl;
cout << "testing value factory registration exception... " << flush;
{
#ifdef ICE_CPP11_MAPPING
communicator->addValueFactory(
[](const std::string&)
{
return nullptr;
},
"x");
try
{
communicator->addValueFactory(
[](const std::string&)
{
return nullptr;
},
"x");
test(false);
}
catch(const Ice::AlreadyRegisteredException&)
{
}
#else
Ice::ValueFactoryPtr vf = new ValueFactoryI;
communicator->addValueFactory(vf, "x");
try
{
communicator->addValueFactory(vf, "x");
test(false);
}
catch(const Ice::AlreadyRegisteredException&)
{
}
#endif
}
cout << "ok" << endl;
cout << "testing stringToProxy... " << flush;
string ref = "thrower:" + getTestEndpoint(communicator, 0);
Ice::ObjectPrxPtr base = communicator->stringToProxy(ref);
test(base);
cout << "ok" << endl;
cout << "testing checked cast... " << flush;
ThrowerPrxPtr thrower = ICE_CHECKED_CAST(ThrowerPrx, base);
test(thrower);
#ifdef ICE_CPP11_MAPPING
test(Ice::targetEquals(thrower, base));
#else
test(thrower == base);
#endif
cout << "ok" << endl;
cout << "catching exact types... " << flush;
try
{
thrower->throwAasA(1);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(const Ice::Exception& ex)
{
cout << ex << endl;
test(false);
}
catch(...)
{
test(false);
}
try
{
thrower->throwAorDasAorD(1);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwAorDasAorD(-1);
test(false);
}
catch(const D& ex)
{
test(ex.dMem == -1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwBasB(1, 2);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasC(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
try
{
thrower->throwModA(1, 2);
test(false);
}
catch(const Mod::A& ex)
{
test(ex.aMem == 1);
test(ex.a2Mem == 2);
}
catch(const Ice::OperationNotExistException&)
{
//
// This operation is not supported in Java.
//
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching base types... " << flush;
try
{
thrower->throwBasB(1, 2);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasC(1, 2, 3);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwModA(1, 2);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(const Ice::OperationNotExistException&)
{
//
// This operation is not supported in Java.
//
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching derived types... " << flush;
try
{
thrower->throwBasA(1, 2);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasA(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasB(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
if(thrower->supportsUndeclaredExceptions())
{
cout << "catching unknown user exception... " << flush;
try
{
thrower->throwUndeclaredA(1);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(const Ice::Exception& ex)
{
cout << ex << endl;
cout << ex.ice_stackTrace() << endl;
test(false);
}
catch(...)
{
test(false);
}
try
{
thrower->throwUndeclaredB(1, 2);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwUndeclaredC(1, 2, 3);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
}
if(thrower->ice_getConnection())
{
cout << "testing memory limit marshal exception..." << flush;
try
{
thrower->throwMemoryLimitException(Ice::ByteSeq());
test(false);
}
catch(const Ice::MemoryLimitException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwMemoryLimitException(Ice::ByteSeq(20 * 1024)); // 20KB
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
ThrowerPrxPtr thrower2 =
ICE_UNCHECKED_CAST(ThrowerPrx, communicator->stringToProxy("thrower:" + getTestEndpoint(communicator, 1)));
try
{
thrower2->throwMemoryLimitException(Ice::ByteSeq(2 * 1024 * 1024)); // 2MB (no limits)
}
catch(const Ice::MemoryLimitException&)
{
}
ThrowerPrxPtr thrower3 =
ICE_UNCHECKED_CAST(ThrowerPrx, communicator->stringToProxy("thrower:" + getTestEndpoint(communicator, 2)));
try
{
thrower3->throwMemoryLimitException(Ice::ByteSeq(1024)); // 1KB limit
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
cout << "ok" << endl;
}
cout << "catching object not exist exception... " << flush;
Ice::Identity id = communicator->stringToIdentity("does not exist");
try
{
ThrowerPrxPtr thrower2 = ICE_UNCHECKED_CAST(ThrowerPrx, thrower->ice_identity(id));
thrower2->throwAasA(1);
// thrower2->ice_ping();
test(false);
}
catch(const Ice::ObjectNotExistException& ex)
{
test(ex.id == id);
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching facet not exist exception... " << flush;
try
{
#ifdef ICE_CPP11_MAPPING
ThrowerPrxPtr thrower2 = Ice::uncheckedCast<ThrowerPrx>(thrower, "no such facet");
#else
ThrowerPrxPtr thrower2 = ThrowerPrx::uncheckedCast(thrower, "no such facet");
#endif
try
{
thrower2->ice_ping();
test(false);
}
catch(const Ice::FacetNotExistException& ex)
{
test(ex.facet == "no such facet");
}
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching operation not exist exception... " << flush;
try
{
WrongOperationPrxPtr thrower2 = ICE_UNCHECKED_CAST(WrongOperationPrx, thrower);
thrower2->noSuchOperation();
test(false);
}
catch(const Ice::OperationNotExistException& ex)
{
test(ex.operation == "noSuchOperation");
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching unknown local exception... " << flush;
try
{
thrower->throwLocalException();
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwLocalExceptionIdempotent();
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(const Ice::OperationNotExistException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching unknown non-Ice exception... " << flush;
try
{
thrower->throwNonIceException();
test(false);
}
catch(const Ice::UnknownException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "testing asynchronous exceptions... " << flush;
try
{
thrower->throwAfterResponse();
}
catch(...)
{
test(false);
}
try
{
thrower->throwAfterException();
}
catch(const A&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching exact types with new AMI mapping... " << flush;
#ifdef ICE_CPP11_MAPPING
{
auto f = thrower->throwAasA_async(1);
try
{
f.get();
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(const Ice::Exception&)
{
test(false);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwAorDasAorD_async(1);
try
{
f.get();
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwAorDasAorD_async(-1);
try
{
f.get();
test(false);
}
catch(const D& ex)
{
test(ex.dMem == -1);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwBasB_async(1, 2);
try
{
f.get();
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwCasC_async(1, 2, 3);
try
{
f.get();
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwModA_async(1, 2);
try
{
f.get();
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(const Ice::OperationNotExistException&)
{
//
// This operation is not supported in Java.
//
}
catch(...)
{
test(false);
}
}
//
// repeat with callback API and no exception callback
//
{
promise<bool> sent;
thrower->throwAasA_async(1,
[]()
{
test(false);
},
nullptr,
[&](bool value)
{
sent.set_value(value);
});
sent.get_future().get(); // Wait for sent
}
{
promise<bool> sent;
thrower->throwAorDasAorD_async(1,
[]()
{
test(false);
},
nullptr,
[&](bool value)
{
sent.set_value(value);
});
sent.get_future().get(); // Wait for sent
}
{
promise<bool> sent;
thrower->throwAorDasAorD_async(-1,
[]()
{
test(false);
},
nullptr,
[&](bool value)
{
sent.set_value(value);
});
sent.get_future().get(); // Wait for sent
}
{
promise<bool> sent;
thrower->throwBasB_async(1, 2,
[]()
{
test(false);
},
nullptr,
[&](bool value)
{
sent.set_value(value);
});
sent.get_future().get(); // Wait for sent
}
{
promise<bool> sent;
thrower->throwCasC_async(1, 2, 3,
[]()
{
test(false);
},
nullptr,
[&](bool value)
{
sent.set_value(value);
});
sent.get_future().get(); // Wait for sent
}
{
promise<bool> sent;
thrower->throwModA_async(1, 2,
[]()
{
test(false);
},
nullptr,
[&](bool value)
{
sent.set_value(value);
});
sent.get_future().get(); // Wait for sent
}
#else
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasA);
thrower->begin_throwAasA(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAorDasAorDPtr callback =
newCallback_Thrower_throwAorDasAorD(cb, &Callback::response, &Callback::exception_AorDasAorD);
thrower->begin_throwAorDasAorD(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAorDasAorDPtr callback =
newCallback_Thrower_throwAorDasAorD(cb, &Callback::response, &Callback::exception_AorDasAorD);
thrower->begin_throwAorDasAorD(-1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwBasBPtr callback =
newCallback_Thrower_throwBasB(cb, &Callback::response, &Callback::exception_BasB);
thrower->begin_throwBasB(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasCPtr callback =
newCallback_Thrower_throwCasC(cb, &Callback::response, &Callback::exception_CasC);
thrower->begin_throwCasC(1, 2, 3, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwModAPtr callback =
newCallback_Thrower_throwModA(cb, &Callback::response, &Callback::exception_ModA);
thrower->begin_throwModA(1, 2, callback);
cb->check();
}
#endif
cout << "ok" << endl;
cout << "catching derived types with new AMI mapping... " << flush;
#ifdef ICE_CPP11_MAPPING
{
auto f = thrower->throwBasA_async(1, 2);
try
{
f.get();
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwCasA_async(1, 2, 3);
try
{
f.get();
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwCasB_async(1, 2, 3);
try
{
f.get();
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
}
#else
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwBasAPtr callback =
newCallback_Thrower_throwBasA(cb, &Callback::response, &Callback::exception_BasA);
thrower->begin_throwBasA(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasAPtr callback =
newCallback_Thrower_throwCasA(cb, &Callback::response, &Callback::exception_CasA);
thrower->begin_throwCasA(1, 2, 3, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasBPtr callback =
newCallback_Thrower_throwCasB(cb, &Callback::response, &Callback::exception_CasB);
thrower->begin_throwCasB(1, 2, 3, callback);
cb->check();
}
#endif
cout << "ok" << endl;
if(thrower->supportsUndeclaredExceptions())
{
cout << "catching unknown user exception with new AMI mapping... " << flush;
#ifdef ICE_CPP11_MAPPING
{
auto f = thrower->throwUndeclaredA_async(1);
try
{
f.get();
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(const Ice::Exception& ex)
{
cout << ex << endl;
cout << ex.ice_stackTrace() << endl;
test(false);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwUndeclaredB_async(1, 2);
try
{
f.get();
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwUndeclaredC_async(1, 2, 3);
try
{
f.get();
}
catch(const Ice::UnknownUserException&)
{
}
catch(...)
{
test(false);
}
}
#else
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredAPtr callback =
newCallback_Thrower_throwUndeclaredA(cb, &Callback::response, &Callback::exception_UndeclaredA);
thrower->begin_throwUndeclaredA(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredBPtr callback =
newCallback_Thrower_throwUndeclaredB(cb, &Callback::response, &Callback::exception_UndeclaredB);
thrower->begin_throwUndeclaredB(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredCPtr callback =
newCallback_Thrower_throwUndeclaredC(cb, &Callback::response, &Callback::exception_UndeclaredC);
thrower->begin_throwUndeclaredC(1, 2, 3, callback);
cb->check();
}
#endif
cout << "ok" << endl;
}
cout << "catching object not exist exception with new AMI mapping... " << flush;
{
#ifdef ICE_CPP11_MAPPING
id = communicator->stringToIdentity("does not exist");
shared_ptr<ThrowerPrx> thrower2 = Ice::uncheckedCast<ThrowerPrx>(thrower->ice_identity(id));
auto f = thrower2->throwAasA_async(1);
try
{
f.get();
}
catch(const Ice::ObjectNotExistException& ex)
{
test(ex.id == id);
}
catch(...)
{
test(false);
}
#else
id = communicator->stringToIdentity("does not exist");
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower->ice_identity(id));
CallbackPtr cb = new Callback(communicator);
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasAObjectNotExist);
thrower2->begin_throwAasA(1, callback);
cb->check();
#endif
}
cout << "ok" << endl;
cout << "catching facet not exist exception with new AMI mapping... " << flush;
{
#ifdef ICE_CPP11_MAPPING
shared_ptr<ThrowerPrx> thrower2 = Ice::uncheckedCast<ThrowerPrx>(thrower, "no such facet");
auto f = thrower2->throwAasA_async(1);
try
{
f.get();
}
catch(const Ice::FacetNotExistException& ex)
{
test(ex.facet == "no such facet");
}
#else
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower, "no such facet");
CallbackPtr cb = new Callback;
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasAFacetNotExist);
thrower2->begin_throwAasA(1, callback);
cb->check();
#endif
}
cout << "ok" << endl;
cout << "catching operation not exist exception with new AMI mapping... " << flush;
{
#ifdef ICE_CPP11_MAPPING
shared_ptr<WrongOperationPrx> thrower4 = Ice::uncheckedCast<WrongOperationPrx>(thrower);
auto f = thrower4->noSuchOperation_async();
try
{
f.get();
}
catch(const Ice::OperationNotExistException& ex)
{
test(ex.operation == "noSuchOperation");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
Callback_WrongOperation_noSuchOperationPtr callback =
newCallback_WrongOperation_noSuchOperation(cb, &Callback::response,
&Callback::exception_noSuchOperation);
WrongOperationPrx thrower4 = WrongOperationPrx::uncheckedCast(thrower);
thrower4->begin_noSuchOperation(callback);
cb->check();
#endif
}
cout << "ok" << endl;
cout << "catching unknown local exception with new AMI mapping... " << flush;
#ifdef ICE_CPP11_MAPPING
{
auto f = thrower->throwLocalException_async();
try
{
f.get();
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwLocalExceptionIdempotent_async();
try
{
f.get();
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(const Ice::OperationNotExistException&)
{
}
catch(...)
{
test(false);
}
}
#else
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwLocalExceptionPtr callback =
newCallback_Thrower_throwLocalException(cb, &Callback::response, &Callback::exception_LocalException);
thrower->begin_throwLocalException(callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwLocalExceptionIdempotentPtr callback =
newCallback_Thrower_throwLocalExceptionIdempotent(cb, &Callback::response,
&Callback::exception_LocalException);
thrower->begin_throwLocalExceptionIdempotent(callback);
cb->check();
}
#endif
cout << "ok" << endl;
cout << "catching unknown non-Ice exception with new AMI mapping... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto f = thrower->throwNonIceException_async();
try
{
f.get();
test(false);
}
catch(const Ice::UnknownException&)
{
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
Callback_Thrower_throwNonIceExceptionPtr callback =
newCallback_Thrower_throwNonIceException(cb, &Callback::response, &Callback::exception_NonIceException);
thrower->begin_throwNonIceException(callback);
cb->check();
#endif
}
cout << "ok" << endl;
return thrower;
}
void
allTests(const Ice::CommunicatorPtr& communicator)
{
SessionKeepAliveThreadPtr keepAlive = new SessionKeepAliveThread(
communicator->getLogger(), IceUtil::Time::seconds(5));
keepAlive->start();
RegistryPrx registry = IceGrid::RegistryPrx::checkedCast(communicator->stringToProxy("IceGrid/Registry"));
test(registry);
AdminSessionPrx session = registry->createAdminSession("foo", "bar");
keepAlive->add(session);
AdminPrx admin = session->getAdmin();
test(admin);
cout << "starting router... " << flush;
try
{
admin->startServer("Glacier2");
}
catch(const ServerStartException& ex)
{
cerr << ex.reason << endl;
test(false);
}
cout << "ok" << endl;
const int allocationTimeout = 5000;
Ice::ObjectPrx obj;
Ice::ObjectPrx dummy;
try
{
cout << "testing create session... " << flush;
SessionPrx session1 = registry->createSession("Client1", "");
SessionPrx session2 = registry->createSession("Client2", "");
keepAlive->add(session1);
keepAlive->add(session2);
cout << "ok" << endl;
cout << "testing allocate object by identity... " << flush;
Ice::Identity allocatable = communicator->stringToIdentity("allocatable");
Ice::Identity allocatablebis = communicator->stringToIdentity("allocatablebis");
try
{
session1->allocateObjectById(communicator->stringToIdentity("dummy"));
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session1->releaseObject(communicator->stringToIdentity("dummy"));
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session1->allocateObjectById(communicator->stringToIdentity("nonallocatable"));
test(false);
}
catch(const AllocationException&)
{
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session2->allocateObjectById(communicator->stringToIdentity("nonallocatable"));
test(false);
}
catch(const AllocationException&)
{
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session1->releaseObject(communicator->stringToIdentity("nonallocatable"));
test(false);
}
catch(const AllocationException&)
{
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
try
{
session2->releaseObject(communicator->stringToIdentity("nonallocatable"));
test(false);
}
catch(const AllocationException&)
{
test(false);
}
catch(const ObjectNotRegisteredException&)
{
}
session1->allocateObjectById(allocatable);
try
{
session1->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationException&)
{
}
session1->setAllocationTimeout(0);
session2->setAllocationTimeout(0);
try
{
session2->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session2->releaseObject(allocatable);
test(false);
}
catch(const AllocationException&)
{
}
session1->allocateObjectById(allocatablebis);
try
{
session2->allocateObjectById(allocatablebis);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->releaseObject(allocatablebis);
session2->allocateObjectById(allocatablebis);
try
{
session1->allocateObjectById(allocatablebis);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session2->releaseObject(allocatablebis);
session2->setAllocationTimeout(allocationTimeout);
AllocateObjectByIdCallbackPtr cb1 = new AllocateObjectByIdCallback();
session2->allocateObjectById_async(cb1, allocatable);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb1->hasResponse(dummy));
session1->releaseObject(allocatable);
cb1->waitResponse(__FILE__, __LINE__);
test(cb1->hasResponse(dummy));
session1->setAllocationTimeout(0);
try
{
session1->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session1->releaseObject(allocatable);
test(false);
}
catch(const AllocationException&)
{
}
session1->setAllocationTimeout(allocationTimeout);
cb1 = new AllocateObjectByIdCallback();
session1->allocateObjectById_async(cb1, allocatable);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb1->hasResponse(dummy));
session2->releaseObject(allocatable);
cb1->waitResponse(__FILE__, __LINE__);
test(cb1->hasResponse(dummy));
session1->releaseObject(allocatable);
cout << "ok" << endl;
cout << "testing allocate object by type... " << flush;
session1->setAllocationTimeout(0);
session2->setAllocationTimeout(0);
try
{
obj = session1->allocateObjectByType("::Unknown");
test(false);
}
catch(const AllocationTimeoutException&)
{
test(false);
}
catch(const AllocationException&)
{
}
try
{
obj = session1->allocateObjectByType("::NotAllocatable");
test(false);
}
catch(const AllocationTimeoutException&)
{
test(false);
}
catch(const AllocationException&)
{
}
obj = session1->allocateObjectByType("::Test");
test(obj && obj->ice_getIdentity().name == "allocatable");
try
{
session1->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationException&)
{
}
try
{
session2->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session2->releaseObject(obj->ice_getIdentity());
}
catch(const AllocationException&)
{
}
session1->releaseObject(obj->ice_getIdentity());
try
{
session1->releaseObject(obj->ice_getIdentity());
}
catch(const AllocationException&)
{
}
obj = session2->allocateObjectByType("::Test"); // Allocate the object
test(obj && obj->ice_getIdentity().name == "allocatable");
try
{
session2->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationException&)
{
}
try
{
session1->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->allocateObjectByType("::TestBis");
try
{
session2->allocateObjectByType("::TestBis");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->releaseObject(allocatablebis);
session2->allocateObjectByType("::TestBis");
try
{
session1->allocateObjectByType("::TestBis");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session2->releaseObject(allocatablebis);
session1->setAllocationTimeout(allocationTimeout);
AllocateObjectByTypeCallbackPtr cb3 = new AllocateObjectByTypeCallback();
session1->allocateObjectByType_async(cb3, "::Test");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb3->hasResponse(dummy));
session2->releaseObject(obj->ice_getIdentity());
cb3->waitResponse(__FILE__, __LINE__);
test(cb3->hasResponse(obj));
session1->releaseObject(obj->ice_getIdentity());
cout << "ok" << endl;
cout << "testing object allocation timeout... " << flush;
session1->allocateObjectById(allocatable);
IceUtil::Time time = IceUtil::Time::now();
session2->setAllocationTimeout(500);
try
{
session2->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationTimeoutException&)
{
test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now());
}
time = IceUtil::Time::now();
try
{
session2->allocateObjectById(allocatable);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now());
time = IceUtil::Time::now();
try
{
session2->allocateObjectByType("::Test");
test(false);
}
catch(const AllocationTimeoutException&)
{
}
test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now());
session1->releaseObject(allocatable);
session2->setAllocationTimeout(0);
cout << "ok" << endl;
cout << "testing server allocation... " << flush;
session1->setAllocationTimeout(0);
session2->setAllocationTimeout(0);
Ice::Identity allocatable3 = communicator->stringToIdentity("allocatable3");
Ice::Identity allocatable4 = communicator->stringToIdentity("allocatable4");
session1->allocateObjectById(allocatable3);
try
{
session2->allocateObjectById(allocatable3);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session2->allocateObjectById(allocatable4);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->allocateObjectById(allocatable4);
session1->releaseObject(allocatable3);
try
{
session2->allocateObjectById(allocatable3);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session1->releaseObject(allocatable4);
session2->allocateObjectById(allocatable3);
try
{
session1->allocateObjectById(allocatable3);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session1->allocateObjectById(allocatable4);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
session2->allocateObjectById(allocatable4);
session2->releaseObject(allocatable3);
try
{
session1->allocateObjectById(allocatable3);
test(false);
}
catch(const AllocationTimeoutException&)
{
}
try
{
session1->allocateObjectByType("::TestServer1");
test(false);
}
catch(AllocationException&)
{
}
try
{
session1->allocateObjectByType("::TestServer2");
test(false);
}
catch(AllocationException&)
{
}
test(session2->allocateObjectByType("::TestServer1"));
try
{
session2->allocateObjectByType("::TestServer1");
test(false);
}
catch(AllocationException&)
{
}
try
{
session2->allocateObjectByType("::TestServer2");
test(false);
}
catch(AllocationException&)
{
}
session2->releaseObject(allocatable3);
session2->releaseObject(allocatable4);
session1->allocateObjectById(allocatable3);
session1->allocateObjectById(allocatable4);
session2->setAllocationTimeout(allocationTimeout);
cb1 = new AllocateObjectByIdCallback();
session2->allocateObjectById_async(cb1, allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb1->hasResponse(dummy));
session1->releaseObject(allocatable3);
test(!cb1->hasResponse(dummy));
session1->releaseObject(allocatable4);
cb1->waitResponse(__FILE__, __LINE__);
test(cb1->hasResponse(dummy));
session2->releaseObject(allocatable3);
session1->setAllocationTimeout(allocationTimeout);
test(session2->allocateObjectByType("::TestServer1"));
cb3 = new AllocateObjectByTypeCallback();
session1->allocateObjectByType_async(cb3, "::TestServer2");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb3->hasResponse(dummy));
session2->releaseObject(allocatable3);
cb3->waitResponse(__FILE__, __LINE__);
test(cb3->hasResponse(dummy));
session1->releaseObject(allocatable4);
session1->setAllocationTimeout(0);
session2->setAllocationTimeout(0);
test(session1->allocateObjectByType("::TestMultipleByServer"));
try
{
session2->allocateObjectByType("::TestMultipleByServer");
test(false);
}
catch(AllocationException&)
{
}
test(session1->allocateObjectByType("::TestMultipleByServer"));
session1->releaseObject(communicator->stringToIdentity("allocatable31"));
session1->releaseObject(communicator->stringToIdentity("allocatable41"));
test(session2->allocateObjectByType("::TestMultipleByServer"));
try
{
session1->allocateObjectByType("::TestMultipleByServer");
test(false);
}
catch(AllocationException&)
{
}
test(session2->allocateObjectByType("::TestMultipleByServer"));
session2->releaseObject(communicator->stringToIdentity("allocatable31"));
session2->releaseObject(communicator->stringToIdentity("allocatable41"));
Ice::ObjectPrx obj1 = session1->allocateObjectByType("::TestMultipleServer");
test(obj1);
Ice::ObjectPrx obj2 = session2->allocateObjectByType("::TestMultipleServer");
test(obj2);
try
{
session1->allocateObjectByType("::TestMultipleServer");
test(false);
}
catch(AllocationTimeoutException&)
{
}
try
{
session2->allocateObjectByType("::TestMultipleServer");
test(false);
}
catch(AllocationTimeoutException&)
{
}
session1->releaseObject(obj1->ice_getIdentity());
obj1 = session2->allocateObjectByType("::TestMultipleServer");
session2->releaseObject(obj1->ice_getIdentity());
session2->releaseObject(obj2->ice_getIdentity());
cout << "ok" << endl;
cout << "testing concurrent allocations... " << flush;
session1->setAllocationTimeout(allocationTimeout);
session2->setAllocationTimeout(allocationTimeout);
session2->allocateObjectById(allocatable);
AllocateObjectByIdCallbackPtr cb11 = new AllocateObjectByIdCallback();
AllocateObjectByIdCallbackPtr cb12 = new AllocateObjectByIdCallback();
session1->allocateObjectById_async(cb11, allocatable);
session1->allocateObjectById_async(cb12, allocatable);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb11->hasResponse(dummy));
test(!cb12->hasResponse(dummy));
session2->releaseObject(allocatable);
cb11->waitResponse(__FILE__, __LINE__);
cb12->waitResponse(__FILE__, __LINE__);
test(cb11->hasResponse(dummy) ? cb12->hasException() : cb12->hasResponse(dummy));
test(cb12->hasResponse(dummy) ? cb11->hasException() : cb11->hasResponse(dummy));
session1->releaseObject(allocatable);
session2->allocateObjectById(allocatable);
AllocateObjectByTypeCallbackPtr cb31 = new AllocateObjectByTypeCallback();
AllocateObjectByTypeCallbackPtr cb32 = new AllocateObjectByTypeCallback();
session1->allocateObjectByType_async(cb31, "::Test");
session1->allocateObjectByType_async(cb32, "::Test");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb31->hasResponse(dummy));
test(!cb32->hasResponse(dummy));
session2->releaseObject(allocatable);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
do
{
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200));
}
while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy));
test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) ||
cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy));
session1->releaseObject(allocatable);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
AllocateObjectByTypeCallbackPtr cb33 = cb31->hasResponse(dummy) ? cb32 : cb31;
cb33->waitResponse(__FILE__, __LINE__);
test(cb33->hasResponse(dummy) && dummy);
session1->releaseObject(allocatable);
session2->allocateObjectById(allocatable3);
cb11 = new AllocateObjectByIdCallback();
cb12 = new AllocateObjectByIdCallback();
session1->allocateObjectById_async(cb11, allocatable3);
session1->allocateObjectById_async(cb12, allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb11->hasResponse(dummy));
test(!cb12->hasResponse(dummy));
session2->releaseObject(allocatable3);
cb11->waitResponse(__FILE__, __LINE__);
cb12->waitResponse(__FILE__, __LINE__);
test(cb11->hasResponse(dummy) ? cb12->hasException() : cb12->hasResponse(dummy));
test(cb12->hasResponse(dummy) ? cb11->hasException() : cb11->hasResponse(dummy));
session1->releaseObject(allocatable3);
session2->allocateObjectById(allocatable3);
cb31 = new AllocateObjectByTypeCallback();
cb32 = new AllocateObjectByTypeCallback();
session1->allocateObjectByType_async(cb31, "::TestServer1");
session1->allocateObjectByType_async(cb32, "::TestServer1");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb31->hasResponse(dummy));
test(!cb32->hasResponse(dummy));
session2->releaseObject(allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
do
{
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200));
}
while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy));
test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) ||
cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy));
session1->releaseObject(allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
cb33 = cb31->hasResponse(dummy) ? cb32 : cb31;
cb33->waitResponse(__FILE__, __LINE__);
test(cb33->hasResponse(dummy) && dummy);
session1->releaseObject(allocatable3);
session1->allocateObjectById(allocatable3);
cb31 = new AllocateObjectByTypeCallback();
cb32 = new AllocateObjectByTypeCallback();
session1->allocateObjectByType_async(cb31, "::TestServer1");
session1->allocateObjectByType_async(cb32, "::TestServer1");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb31->hasResponse(dummy));
test(!cb32->hasResponse(dummy));
session1->releaseObject(allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
do
{
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200));
}
while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy));
test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) ||
cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy));
session1->releaseObject(allocatable3);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
cb33 = cb31->hasResponse(dummy) ? cb32 : cb31;
cb33->waitResponse(__FILE__, __LINE__);
test(cb33->hasResponse(dummy) && dummy);
session1->releaseObject(allocatable3);
cout << "ok" << endl;
cout << "testing session destroy... " << flush;
obj = session2->allocateObjectByType("::Test"); // Allocate the object
test(obj && obj->ice_getIdentity().name == "allocatable");
session1->setAllocationTimeout(allocationTimeout);
cb3 = new AllocateObjectByTypeCallback();
session1->allocateObjectByType_async(cb3, "::Test");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
test(!cb3->hasResponse(dummy));
session2->destroy();
cb3->waitResponse(__FILE__, __LINE__);
test(cb3->hasResponse(obj));
session1->destroy();
session2 = SessionPrx::uncheckedCast(registry->createSession("Client2", ""));
session2->setAllocationTimeout(0);
session2->allocateObjectById(allocatable);
session2->destroy();
cout << "ok" << endl;
cout << "testing allocation with Glacier2 session... " << flush;
Ice::ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:default -p 12347");
Glacier2::RouterPrx router1 = Glacier2::RouterPrx::checkedCast(routerBase->ice_connectionId("client1"));
test(router1);
Glacier2::SessionPrx sessionBase = router1->createSession("test1", "abc123");
try
{
session1 = IceGrid::SessionPrx::checkedCast(sessionBase->ice_connectionId("client1")->ice_router(router1));
test(session1);
session1->ice_ping();
Ice::ObjectPrx obj;
obj = session1->allocateObjectById(allocatable)->ice_connectionId("client1")->ice_router(router1);
obj->ice_ping();
session1->releaseObject(allocatable);
try
{
obj->ice_ping();
}
catch(const Ice::ObjectNotExistException&)
{
}
obj = session1->allocateObjectById(allocatable3)->ice_connectionId("client1")->ice_router(router1);
obj->ice_ping();
obj2 = communicator->stringToProxy("allocatable4")->ice_connectionId("client1")->ice_router(router1);
obj2->ice_ping();
session1->releaseObject(allocatable3);
try
{
obj->ice_ping();
}
catch(const Ice::ObjectNotExistException&)
{
}
try
{
obj2->ice_ping();
}
catch(const Ice::ObjectNotExistException&)
{
}
session1->destroy();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "stress test... " << flush;
SessionPrx stressSession = registry->createSession("StressSession", "");
keepAlive->add(stressSession);
const int nClients = 10;
int i;
vector<StressClientPtr> clients;
for(i = 0; i < nClients - 2; ++i)
{
if(IceUtil::random(2) == 1)
{
clients.push_back(new StressClient(i, registry, false));
}
else
{
clients.push_back(new StressClient(i, stressSession));
}
clients.back()->start();
}
clients.push_back(new StressClient(i++, registry, true));
clients.back()->start();
clients.push_back(new StressClient(i++, registry, true));
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(8));
//
// Terminate the stress clients.
//
for(vector<StressClientPtr>::const_iterator q = clients.begin(); q != clients.end(); ++q)
{
(*q)->terminate();
(*q)->getThreadControl().join();
}
stressSession->destroy();
cout << "ok" << endl;
}
catch(const AllocationTimeoutException& ex)
{
cerr << ex << endl;
test(false);
}
catch(const AllocationException& ex)
{
cerr << ex.reason << endl;
test(false);
}
cout << "shutting down router... " << flush;
admin->stopServer("Glacier2");
cout << "ok" << endl;
keepAlive->terminate();
keepAlive->getThreadControl().join();
keepAlive = 0;
session->destroy();
}
Instance::Instance(
const string& instanceName,
const string& name,
const Ice::CommunicatorPtr& communicator,
const Ice::ObjectAdapterPtr& publishAdapter,
const Ice::ObjectAdapterPtr& topicAdapter,
const Ice::ObjectAdapterPtr& nodeAdapter,
const NodePrx& nodeProxy) :
_instanceName(instanceName),
_serviceName(name),
_communicator(communicator),
_publishAdapter(publishAdapter),
_topicAdapter(topicAdapter),
_nodeAdapter(nodeAdapter),
_nodeProxy(nodeProxy),
_traceLevels(new TraceLevels(name, communicator->getProperties(), communicator->getLogger())),
_discardInterval(IceUtil::Time::seconds(communicator->getProperties()->getPropertyAsIntWithDefault(
name + ".Discard.Interval", 60))), // default one minute.
_flushInterval(IceUtil::Time::milliSeconds(communicator->getProperties()->getPropertyAsIntWithDefault(
name + ".Flush.Timeout", 1000))), // default one second.
// default one minute.
_sendTimeout(communicator->getProperties()->getPropertyAsIntWithDefault(name + ".Send.Timeout", 60 * 1000)),
_topicReaper(new TopicReaper())
{
try
{
__setNoDelete(true);
Ice::PropertiesPtr properties = communicator->getProperties();
if(properties->getProperty(name + ".TopicManager.AdapterId").empty())
{
string p = properties->getProperty(name + ".ReplicatedTopicManagerEndpoints");
if(!p.empty())
{
const_cast<Ice::ObjectPrx&>(_topicReplicaProxy) = communicator->stringToProxy("dummy:" + p);
}
p = properties->getProperty(name + ".ReplicatedPublishEndpoints");
if(!p.empty())
{
const_cast<Ice::ObjectPrx&>(_publisherReplicaProxy) = communicator->stringToProxy("dummy:" + p);
}
}
_observers = new Observers(this);
_batchFlusher = new IceUtil::Timer();
_timer = new IceUtil::Timer();
//
// If an Ice metrics observer is setup on the communicator, also
// enable metrics for IceStorm.
//
IceInternal::CommunicatorObserverIPtr o =
IceInternal::CommunicatorObserverIPtr::dynamicCast(communicator->getObserver());
if(o)
{
_observer = new TopicManagerObserverI(o->getFacet());
}
}
catch(...)
{
shutdown();
destroy();
__setNoDelete(false);
throw;
}
__setNoDelete(false);
}
