void opString(const Ice::AsyncResultPtr& result)
{
string cmp = testString;
if(_useCookie)
{
CookiePtr cookie = CookiePtr::dynamicCast(result->getCookie());
cmp = cookie->getString();
}
Ice::ByteSeq outParams;
if(result->getProxy()->end_ice_invoke(outParams, result))
{
Ice::InputStream in(_communicator, result->getProxy()->ice_getEncodingVersion(), outParams);
in.startEncapsulation();
string s;
in.read(s);
test(s == cmp);
in.read(s);
test(s == cmp);
in.endEncapsulation();
called();
}
else
{
test(false);
}
}
void opException(const Ice::AsyncResultPtr& result)
{
if(_useCookie)
{
CookiePtr cookie = CookiePtr::dynamicCast(result->getCookie());
test(cookie->getString() == testString);
}
Ice::ByteSeq outParams;
if(result->getProxy()->end_ice_invoke(outParams, result))
{
test(false);
}
else
{
Ice::InputStreamPtr in = Ice::createInputStream(_communicator, outParams);
try
{
in->throwException();
}
catch(const Test::MyException&)
{
called();
}
catch(...)
{
test(false);
}
}
}
void opString(const Ice::AsyncResultPtr& result)
{
string cmp = testString;
if(_useCookie)
{
CookiePtr cookie = CookiePtr::dynamicCast(result->getCookie());
cmp = cookie->getString();
}
Ice::ByteSeq outParams;
if(result->getProxy()->end_ice_invoke(outParams, result))
{
Ice::InputStreamPtr in = Ice::createInputStream(_communicator, outParams);
string s;
in->read(s);
test(s == cmp);
in->read(s);
test(s == cmp);
called();
}
else
{
test(false);
};
}
::std::string
IceProxy::com::pera::base::runtime::remote::RobotRemoteService::end_runLocalRobotStart(const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __com__pera__base__runtime__remote__RobotRemoteService__runLocalRobotStart_name);
::std::string __ret;
bool __ok = __result->__wait();
try
{
if(!__ok)
{
try
{
__result->__throwUserException();
}
catch(const ::com::pera::base::runtime::remote::RemoteException&)
{
throw;
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__startReadParams();
__is->read(__ret);
__result->__endReadParams();
return __ret;
}
catch(const ::Ice::LocalException& ex)
{
__result->__getObserver().failed(ex.ice_name());
throw;
}
}
void opException(const Ice::AsyncResultPtr& result)
{
if(_useCookie)
{
CookiePtr cookie = CookiePtr::dynamicCast(result->getCookie());
test(cookie->getString() == testString);
}
Ice::ByteSeq outParams;
if(result->getProxy()->end_ice_invoke(outParams, result))
{
test(false);
}
else
{
Ice::InputStream in(_communicator, result->getProxy()->ice_getEncodingVersion(), outParams);
in.startEncapsulation();
try
{
in.throwException();
}
catch(const Test::MyException&)
{
in.endEncapsulation();
called();
}
catch(...)
{
test(false);
}
}
}
::RoboCompGetAprilTags::listaMarcas
IceProxy::RoboCompGetAprilTags::GetAprilTags::end_checkMarcas(const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __RoboCompGetAprilTags__GetAprilTags__checkMarcas_name);
::RoboCompGetAprilTags::listaMarcas __ret;
bool __ok = __result->__wait();
try
{
if(!__ok)
{
try
{
__result->__throwUserException();
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__startReadParams();
__is->read(__ret);
__result->__endReadParams();
return __ret;
}
catch(const ::Ice::LocalException& ex)
{
__result->__getObserver().failed(ex.ice_name());
throw;
}
}
void
IceProxy::com::pera::base::runtime::remote::RobotRemoteService::end_runRobotStop(const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __com__pera__base__runtime__remote__RobotRemoteService__runRobotStop_name);
bool __ok = __result->__wait();
try
{
if(!__ok)
{
try
{
__result->__throwUserException();
}
catch(const ::com::pera::base::runtime::remote::RemoteException&)
{
throw;
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
__result->__readEmptyParams();
}
catch(const ::Ice::LocalException& ex)
{
__result->__getObserver().failed(ex.ice_name());
throw;
}
}
bool
IceProxy::RoboCompPlanning::Planning::end_getNextAction(::RoboCompPlanning::Plan& solution, const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __RoboCompPlanning__Planning__getNextAction_name);
bool __ret;
bool __ok = __result->__wait();
try
{
if(!__ok)
{
try
{
__result->__throwUserException();
}
catch(const ::RoboCompPlanning::ServerException&)
{
throw;
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__startReadParams();
__is->read(solution);
__is->read(__ret);
__result->__endReadParams();
return __ret;
}
catch(const ::Ice::LocalException& ex)
{
__result->__getObserver().failed(ex.ice_name());
throw;
}
}
void
IceProxy::OWSMODULE::DataOperation::end_CheckState(::OWSMODULE::OWSTask& task, const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __OWSMODULE__DataOperation__CheckState_name);
bool __ok = __result->__wait();
try
{
if(!__ok)
{
try
{
__result->__throwUserException();
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__startReadParams();
__is->read(task);
__result->__endReadParams();
}
catch(const ::Ice::LocalException& ex)
{
__result->__getObserver().failed(ex.ice_name());
throw;
}
}
::Ice::Int
IceProxy::CoreSpace::CoreBase::end_sub(const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __CoreSpace__CoreBase__sub_name);
::Ice::Int __ret;
bool __ok = __result->__wait();
try
{
if(!__ok)
{
try
{
__result->__throwUserException();
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__startReadParams();
__is->read(__ret);
__result->__endReadParams();
return __ret;
}
catch(const ::Ice::LocalException& ex)
{
__result->__getObserver().failed(ex.ice_name());
throw;
}
}
::Ice::Int
IceProxy::OWSMODULE::DataOperation::end_ReadData(::OWSMODULE::byteSeq& DataBlock, const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __OWSMODULE__DataOperation__ReadData_name);
::Ice::Int __ret;
bool __ok = __result->__wait();
try
{
if(!__ok)
{
try
{
__result->__throwUserException();
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__startReadParams();
__is->read(DataBlock);
__is->read(__ret);
__result->__endReadParams();
return __ret;
}
catch(const ::Ice::LocalException& ex)
{
__result->__getObserver().failed(ex.ice_name());
throw;
}
}
void
IceProxy::RoboCompGenericBase::GenericBase::end_getBasePose(::Ice::Int& x, ::Ice::Int& z, ::Ice::Float& alpha, const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __RoboCompGenericBase__GenericBase__getBasePose_name);
bool __ok = __result->__wait();
try
{
if(!__ok)
{
try
{
__result->__throwUserException();
}
catch(const ::RoboCompGenericBase::HardwareFailedException&)
{
throw;
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__startReadParams();
__is->read(x);
__is->read(z);
__is->read(alpha);
__result->__endReadParams();
}
catch(const ::Ice::LocalException& ex)
{
__result->__getObserver().failed(ex.ice_name());
throw;
}
}
::std::string
IceProxy::pera::Demo601Server::PeraDemo601ServerService::end_InvokeMethod(const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __pera__Demo601Server__PeraDemo601ServerService__InvokeMethod_name);
::std::string __ret;
bool __ok = __result->__wait();
try
{
if(!__ok)
{
try
{
__result->__throwUserException();
}
catch(const ::pera::Demo601Server::InvokeException&)
{
throw;
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__startReadParams();
__is->read(__ret);
__result->__endReadParams();
return __ret;
}
catch(const ::Ice::LocalException& ex)
{
__result->__getObserver().failed(ex.ice_name());
throw;
}
}
bool
IceProxy::kelp::cmd2kcn::end_delSelfConfig(const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __kelp__cmd2kcn__delSelfConfig_name);
bool __ret;
bool __ok = __result->__wait();
try
{
if(!__ok)
{
try
{
__result->__throwUserException();
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__startReadParams();
__is->read(__ret);
__result->__endReadParams();
return __ret;
}
catch(const ::Ice::LocalException& ex)
{
__result->__getObserver().failed(ex.ice_name());
throw;
}
}
void
IceProxy::RoboCompJoyStick::JoyStick::end_readJoyStickBufferedData(::RoboCompJoyStick::JoyStickBufferedData& gbd, const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __RoboCompJoyStick__JoyStick__readJoyStickBufferedData_name);
bool __ok = __result->__wait();
try
{
if(!__ok)
{
try
{
__result->__throwUserException();
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__startReadParams();
__is->read(gbd);
__result->__endReadParams();
}
catch(const ::Ice::LocalException& ex)
{
__result->__getObserver().failed(ex.ice_name());
throw;
}
}
void
SubscriberOneway::flush()
{
IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock);
//
// If the subscriber isn't online we're done.
//
if(_state != SubscriberStateOnline || _events.empty())
{
return;
}
// Send up to _maxOutstanding pending events.
while(_outstanding < _maxOutstanding && !_events.empty())
{
//
// Dequeue the head event, count one more outstanding AMI
// request.
//
EventDataPtr e = _events.front();
_events.erase(_events.begin());
if(_observer)
{
_observer->outstanding(1);
}
try
{
Ice::AsyncResultPtr result = _obj->begin_ice_invoke(
e->op, e->mode, e->data, e->context, Ice::newCallback_Object_ice_invoke(this,
&SubscriberOneway::exception,
&SubscriberOneway::sent));
if(!result->sentSynchronously())
{
++_outstanding;
}
else if(_observer)
{
_observer->delivered(1);
}
}
catch(const Ice::Exception& ex)
{
error(true, ex);
return;
}
}
if(_events.empty() && _outstanding == 0 && _shutdown)
{
_lock.notify();
}
}
::std::string IceProxy::zerocexample::MessageIce::end_getContent(const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __zerocexample__MessageIce__getContent_name);
::std::string __ret;
if (!__result->__wait())
{
try
{
__result->__throwUserException();
}
catch (const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__startReadParams();
__is->read(__ret);
__result->__endReadParams();
return __ret;
}
void
IceProxy::GlobalTable::DistributedMap::end_putNget(::std::string& counts, const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __GlobalTable__DistributedMap__putNget_name);
if(!__result->__wait())
{
try
{
__result->__throwUserException();
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__getIs();
__is->startReadEncaps();
__is->read(counts);
__is->endReadEncaps();
}
void
IceProxy::Ice::Object::__end(const ::Ice::AsyncResultPtr& __result, const std::string& operation) const
{
AsyncResult::__check(__result, this, operation);
bool __ok = __result->__wait();
if(_reference->getMode() == Reference::ModeTwoway)
{
if(!__ok)
{
try
{
__result->__throwUserException();
}
catch(const UserException& __ex)
{
throw UnknownUserException(__FILE__, __LINE__, __ex.ice_id());
}
}
__result->__readEmptyParams();
}
}
::MCS::LocFoup
IceProxy::MCS::MESLink::end_GetFoup(const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __MCS__MESLink__GetFoup_name);
::MCS::LocFoup __ret;
if(!__result->__wait())
{
try
{
__result->__throwUserException();
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__getIs();
__is->startReadEncaps();
__ret.__read(__is);
__is->endReadEncaps();
return __ret;
}
void
NodeI::Update::completed(const Ice::AsyncResultPtr& result)
{
try
{
result->throwLocalException();
finished(true);
}
catch(const Ice::LocalException&)
{
finished(false);
}
}
virtual void
completed(const ::Ice::AsyncResultPtr& result) const
{
try
{
AsyncResult::__check(result, _communicator.get(), __flushBatchRequests_name);
result->__wait();
}
catch(const ::Ice::Exception&)
{
_exception(current_exception());
}
}
::std::string
IceProxy::HSFoward::HSBnsProc::end_amdfun(const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __HSFoward__HSBnsProc__amdfun_name);
::std::string __ret;
if(!__result->__wait())
{
try
{
__result->__throwUserException();
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__getIs();
__is->startReadEncaps();
__is->read(__ret);
__is->endReadEncaps();
return __ret;
}
::Ice::Int
IceProxy::loggerice::loggerctrl::end_Register(const ::Ice::AsyncResultPtr& __result)
{
::Ice::AsyncResult::__check(__result, this, __loggerice__loggerctrl__Register_name);
::Ice::Int __ret;
if(!__result->__wait())
{
try
{
__result->__throwUserException();
}
catch(const ::Ice::UserException& __ex)
{
throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
}
}
::IceInternal::BasicStream* __is = __result->__getIs();
__is->startReadEncaps();
__is->read(__ret);
__is->endReadEncaps();
return __ret;
}
void finished(const Ice::AsyncResultPtr& result)
{
DetectorPrx detector = DetectorPrx::uncheckedCast(result->getProxy());
try
{
detector->end_process(result);
localAndClientMsg(VLogger::DEBUG, NULL, "FinishedCallback: detector finished.\n");
}
catch (const Ice::Exception& e)
{
localAndClientMsg(VLogger::WARN, NULL, "Exception: %s\n",
e.ice_name().c_str());
}
mFinished = true;
}
void
Subscriber::completed(const Ice::AsyncResultPtr& result)
{
try
{
result->throwLocalException();
IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock);
// Decrement the _outstanding count.
--_outstanding;
assert(_outstanding >= 0 && _outstanding < _maxOutstanding);
if(_observer)
{
_observer->delivered(_outstandingCount);
}
//
// A successful response means we're no longer retrying, we're
// back active.
//
_currentRetry = 0;
if(_events.empty() && _outstanding == 0 && _shutdown)
{
_lock.notify();
}
else
{
flush();
}
}
catch(const Ice::LocalException& ex)
{
error(true, ex);
}
}
void
SubscriberBatch::doFlush()
{
IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock);
//
// If the subscriber isn't online we're done.
//
if(_state != SubscriberStateOnline)
{
return;
}
EventDataSeq v;
v.swap(_events);
assert(!v.empty());
if(_observer)
{
_outstandingCount = static_cast<Ice::Int>(v.size());
_observer->outstanding(_outstandingCount);
}
try
{
vector<Ice::Byte> dummy;
for(EventDataSeq::const_iterator p = v.begin(); p != v.end(); ++p)
{
_obj->ice_invoke((*p)->op, (*p)->mode, (*p)->data, dummy, (*p)->context);
}
Ice::AsyncResultPtr result = _obj->begin_ice_flushBatchRequests(
Ice::newCallback_Object_ice_flushBatchRequests(this,
&SubscriberBatch::exception,
&SubscriberBatch::sent));
if(result->sentSynchronously())
{
--_outstanding;
assert(_outstanding == 0);
if(_observer)
{
_observer->delivered(_outstandingCount);
}
}
}
catch(const Ice::Exception& ex)
{
error(false, ex);
return;
}
if(_events.empty() && _outstanding == 0 && _shutdown)
{
_lock.notify();
}
// This is significantly faster than the async version, but it can
// block the calling thread. Bad news!
//_obj->ice_flushBatchRequests();
}
void
allTests(const Ice::CommunicatorPtr& communicator, const string& ref)
{
ServerManagerPrx manager = ServerManagerPrx::checkedCast(communicator->stringToProxy(ref));
TestLocatorPrx locator = TestLocatorPrx::uncheckedCast(communicator->getDefaultLocator());
test(manager);
TestLocatorRegistryPrx registry = TestLocatorRegistryPrx::checkedCast(locator->getRegistry());
test(registry);
cout << "testing stringToProxy... " << flush;
Ice::ObjectPrx base = communicator->stringToProxy("test @ TestAdapter");
Ice::ObjectPrx base2 = communicator->stringToProxy("test @ TestAdapter");
Ice::ObjectPrx base3 = communicator->stringToProxy("test");
Ice::ObjectPrx base4 = communicator->stringToProxy("ServerManager");
Ice::ObjectPrx base5 = communicator->stringToProxy("test2");
Ice::ObjectPrx base6 = communicator->stringToProxy("test @ ReplicatedAdapter");
cout << "ok" << endl;
cout << "testing ice_locator and ice_getLocator... " << flush;
test(Ice::proxyIdentityEqual(base->ice_getLocator(), communicator->getDefaultLocator()));
Ice::LocatorPrx anotherLocator = Ice::LocatorPrx::uncheckedCast(communicator->stringToProxy("anotherLocator"));
base = base->ice_locator(anotherLocator);
test(Ice::proxyIdentityEqual(base->ice_getLocator(), anotherLocator));
communicator->setDefaultLocator(0);
base = communicator->stringToProxy("test @ TestAdapter");
test(!base->ice_getLocator());
base = base->ice_locator(anotherLocator);
test(Ice::proxyIdentityEqual(base->ice_getLocator(), anotherLocator));
communicator->setDefaultLocator(locator);
base = communicator->stringToProxy("test @ TestAdapter");
test(Ice::proxyIdentityEqual(base->ice_getLocator(), communicator->getDefaultLocator()));
//
// We also test ice_router/ice_getRouter (perhaps we should add a
// test/Ice/router test?)
//
test(!base->ice_getRouter());
Ice::RouterPrx anotherRouter = Ice::RouterPrx::uncheckedCast(communicator->stringToProxy("anotherRouter"));
base = base->ice_router(anotherRouter);
test(Ice::proxyIdentityEqual(base->ice_getRouter(), anotherRouter));
Ice::RouterPrx router = Ice::RouterPrx::uncheckedCast(communicator->stringToProxy("dummyrouter"));
communicator->setDefaultRouter(router);
base = communicator->stringToProxy("test @ TestAdapter");
test(Ice::proxyIdentityEqual(base->ice_getRouter(), communicator->getDefaultRouter()));
communicator->setDefaultRouter(0);
base = communicator->stringToProxy("test @ TestAdapter");
test(!base->ice_getRouter());
cout << "ok" << endl;
cout << "starting server... " << flush;
manager->startServer();
cout << "ok" << endl;
cout << "testing checked cast... " << flush;
TestIntfPrx obj = TestIntfPrx::checkedCast(base);
test(obj);
TestIntfPrx obj2 = TestIntfPrx::checkedCast(base2);
test(obj2);
TestIntfPrx obj3 = TestIntfPrx::checkedCast(base3);
test(obj3);
ServerManagerPrx obj4 = ServerManagerPrx::checkedCast(base4);
test(obj4);
TestIntfPrx obj5 = TestIntfPrx::checkedCast(base5);
test(obj5);
TestIntfPrx obj6 = TestIntfPrx::checkedCast(base6);
test(obj6);
cout << "ok" << endl;
cout << "testing id@AdapterId indirect proxy... " << flush;
obj->shutdown();
manager->startServer();
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing id@ReplicaGroupId indirect proxy... " << flush;
obj->shutdown();
manager->startServer();
try
{
obj6->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing identity indirect proxy... " << flush;
obj->shutdown();
manager->startServer();
try
{
obj3->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
try
{
obj3->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj3->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj2->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
obj->shutdown();
manager->startServer();
try
{
obj5->ice_ping();
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
cout << "testing proxy with unknown identity... " << flush;
try
{
base = communicator->stringToProxy("unknown/unknown");
base->ice_ping();
test(false);
}
catch (const Ice::NotRegisteredException& ex)
{
test(ex.kindOfObject == "object");
test(ex.id == "unknown/unknown");
}
cout << "ok" << endl;
cout << "testing proxy with unknown adapter... " << flush;
try
{
base = communicator->stringToProxy("test @ TestAdapterUnknown");
base->ice_ping();
test(false);
}
catch (const Ice::NotRegisteredException& ex)
{
test(ex.kindOfObject == "object adapter");
test(ex.id == "TestAdapterUnknown");
}
cout << "ok" << endl;
cout << "testing locator cache timeout... " << flush;
int count = locator->getRequestCount();
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
test(++count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
test(++count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
test(count == locator->getRequestCount());
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1300));
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
test(++count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
count += 2;
test(count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout
test(count == locator->getRequestCount());
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1300));
communicator->stringToProxy("test")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout
count += 2;
test(count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_locatorCacheTimeout(-1)->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_locatorCacheTimeout(-1)->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter")->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test")->ice_ping();
test(count == locator->getRequestCount());
test(communicator->stringToProxy("test")->ice_locatorCacheTimeout(99)->ice_getLocatorCacheTimeout() == 99);
cout << "ok" << endl;
cout << "testing proxy from server... " << flush;
obj = TestIntfPrx::checkedCast(communicator->stringToProxy("test@TestAdapter"));
HelloPrx hello = obj->getHello();
test(hello->ice_getAdapterId() == "TestAdapter");
hello->sayHello();
hello = obj->getReplicatedHello();
test(hello->ice_getAdapterId() == "ReplicatedAdapter");
hello->sayHello();
cout << "ok" << endl;
cout << "testing locator request queuing... " << flush;
hello = obj->getReplicatedHello()->ice_locatorCacheTimeout(0)->ice_connectionCached(false);
count = locator->getRequestCount();
hello->ice_ping();
test(++count == locator->getRequestCount());
int i;
list<Ice::AsyncResultPtr> results;
AMICallbackPtr cb = new AMICallback;
for(i = 0; i < 1000; i++)
{
Ice::AsyncResultPtr result = hello->begin_sayHello(
newCallback_Hello_sayHello(cb, &AMICallback::response1, &AMICallback::exception1));
results.push_back(result);
}
while(!results.empty())
{
Ice::AsyncResultPtr result = results.front();
results.pop_front();
result->waitForCompleted();
}
test(locator->getRequestCount() > count && locator->getRequestCount() < count + 999);
if(locator->getRequestCount() > count + 800)
{
cout << "queuing = " << locator->getRequestCount() - count;
}
count = locator->getRequestCount();
hello = hello->ice_adapterId("unknown");
for(i = 0; i < 1000; i++)
{
Ice::AsyncResultPtr result = hello->begin_sayHello(
newCallback_Hello_sayHello(cb, &AMICallback::response2, &AMICallback::exception2));
results.push_back(result);
}
while(!results.empty())
{
Ice::AsyncResultPtr result = results.front();
results.pop_front();
result->waitForCompleted();
}
// Take into account the retries.
test(locator->getRequestCount() > count && locator->getRequestCount() < count + 1999);
if(locator->getRequestCount() > count + 800)
{
cout << "queuing = " << locator->getRequestCount() - count;
}
cout << "ok" << endl;
cout << "testing adapter locator cache... " << flush;
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
test(false);
}
catch(const Ice::NotRegisteredException& ex)
{
test(ex.kindOfObject == "object adapter");
test(ex.id == "TestAdapter3");
}
registry->setAdapterDirectProxy("TestAdapter3", locator->findAdapterById("TestAdapter"));
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
registry->setAdapterDirectProxy("TestAdapter3", communicator->stringToProxy("dummy:tcp"));
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_locatorCacheTimeout(0)->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
registry->setAdapterDirectProxy("TestAdapter3", locator->findAdapterById("TestAdapter"));
try
{
communicator->stringToProxy("test@TestAdapter3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
cout << "ok" <<endl;
cout << "testing well-known object locator cache... " << flush;
registry->addObject(communicator->stringToProxy("test3@TestUnknown"));
try
{
communicator->stringToProxy("test3")->ice_ping();
test(false);
}
catch(const Ice::NotRegisteredException& ex)
{
test(ex.kindOfObject == "object adapter");
test(ex.id == "TestUnknown");
}
registry->addObject(communicator->stringToProxy("test3@TestAdapter4")); // Update
registry->setAdapterDirectProxy("TestAdapter4", communicator->stringToProxy("dummy:tcp"));
try
{
communicator->stringToProxy("test3")->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
registry->setAdapterDirectProxy("TestAdapter4", locator->findAdapterById("TestAdapter"));
try
{
communicator->stringToProxy("test3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
registry->setAdapterDirectProxy("TestAdapter4", communicator->stringToProxy("dummy:tcp"));
try
{
communicator->stringToProxy("test3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
try
{
communicator->stringToProxy("test@TestAdapter4")->ice_locatorCacheTimeout(0)->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
communicator->stringToProxy("test@TestAdapter4")->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
communicator->stringToProxy("test3")->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
registry->addObject(communicator->stringToProxy("test3@TestAdapter"));
try
{
communicator->stringToProxy("test3")->ice_ping();
}
catch(const Ice::LocalException&)
{
test(false);
}
registry->addObject(communicator->stringToProxy("test4"));
try
{
communicator->stringToProxy("test4")->ice_ping();
test(false);
}
catch(const Ice::NoEndpointException&)
{
}
cout << "ok" << endl;
cout << "testing locator cache background updates... " << flush;
{
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.BackgroundLocatorCacheUpdates", "1");
Ice::CommunicatorPtr ic = Ice::initialize(initData);
registry->setAdapterDirectProxy("TestAdapter5", locator->findAdapterById("TestAdapter"));
registry->addObject(communicator->stringToProxy("test3@TestAdapter"));
int count = locator->getRequestCount();
ic->stringToProxy("test@TestAdapter5")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
ic->stringToProxy("test3")->ice_locatorCacheTimeout(0)->ice_ping(); // No locator cache.
count += 3;
test(count == locator->getRequestCount());
registry->setAdapterDirectProxy("TestAdapter5", 0);
registry->addObject(communicator->stringToProxy("test3:tcp"));
ic->stringToProxy("test@TestAdapter5")->ice_locatorCacheTimeout(10)->ice_ping(); // 10s timeout.
ic->stringToProxy("test3")->ice_locatorCacheTimeout(10)->ice_ping(); // 10s timeout.
test(count == locator->getRequestCount());
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1200));
// The following request should trigger the background updates but still use the cached endpoints
// and therefore succeed.
ic->stringToProxy("test@TestAdapter5")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
ic->stringToProxy("test3")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
try
{
while(true)
{
ic->stringToProxy("test@TestAdapter5")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
}
}
catch(const Ice::LocalException&)
{
// Expected to fail once they endpoints have been updated in the background.
}
try
{
while(true)
{
ic->stringToProxy("test3")->ice_locatorCacheTimeout(1)->ice_ping(); // 1s timeout.
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
}
}
catch(const Ice::LocalException&)
{
// Expected to fail once they endpoints have been updated in the background.
}
ic->destroy();
}
cout << "ok" << endl;
cout << "testing proxy from server after shutdown... " << flush;
hello = obj->getReplicatedHello();
obj->shutdown();
manager->startServer();
hello->sayHello();
cout << "ok" << endl;
cout << "testing object migration... " << flush;
hello = HelloPrx::checkedCast(communicator->stringToProxy("hello"));
obj->migrateHello();
// TODO: enable after fixing ICE-5489
//hello->ice_getConnection()->close(false);
hello->sayHello();
obj->migrateHello();
hello->sayHello();
obj->migrateHello();
hello->sayHello();
cout << "ok" << endl;
cout << "testing locator encoding resolution... " << flush;
hello = HelloPrx::checkedCast(communicator->stringToProxy("hello"));
count = locator->getRequestCount();
communicator->stringToProxy("test@TestAdapter")->ice_encodingVersion(Ice::Encoding_1_1)->ice_ping();
test(count == locator->getRequestCount());
communicator->stringToProxy("test@TestAdapter10")->ice_encodingVersion(Ice::Encoding_1_0)->ice_ping();
test(++count == locator->getRequestCount());
communicator->stringToProxy("test -e 1.0@TestAdapter10-2")->ice_ping();
test(++count == locator->getRequestCount());
cout << "ok" << endl;
cout << "shutdown server... " << flush;
obj->shutdown();
cout << "ok" << endl;
cout << "testing whether server is gone... " << flush;
try
{
obj2->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
obj3->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
obj5->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
}
cout << "ok" << endl;
cout << "testing indirect proxies to collocated objects... " << flush;
//
// Set up test for calling a collocated object through an indirect, adapterless reference.
//
Ice::PropertiesPtr properties = communicator->getProperties();
properties->setProperty("Ice.PrintAdapterReady", "0");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("Hello", "default");
adapter->setLocator(locator);
Ice::Identity id;
id.name = IceUtil::generateUUID();
registry->addObject(adapter->add(new HelloI, id));
adapter->activate();
try
{
HelloPrx helloPrx = HelloPrx::checkedCast(communicator->stringToProxy(communicator->identityToString(id)));
Ice::ConnectionPtr connection = helloPrx->ice_getConnection();
test(false);
}
catch(const Ice::CollocationOptimizationException&)
{
}
adapter->deactivate();
cout << "ok" << endl;
cout << "shutdown server manager... " << flush;
manager->shutdown();
cout << "ok" << endl;
}
void
allTests(const Ice::CommunicatorPtr& communicator)
{
string sref = "test:" + getTestEndpoint(communicator, 0);
Ice::ObjectPrxPtr obj = communicator->stringToProxy(sref);
test(obj);
Test::TestIntfPrxPtr p = ICE_UNCHECKED_CAST(Test::TestIntfPrx, obj);
sref = "testController:" + getTestEndpoint(communicator, 1, "tcp");
obj = communicator->stringToProxy(sref);
test(obj);
Test::TestIntfControllerPrxPtr testController = ICE_UNCHECKED_CAST(Test::TestIntfControllerPrx, obj);
cout << "testing dispatcher... " << flush;
{
p->op();
CallbackPtr cb = ICE_MAKE_SHARED(Callback);
#ifdef ICE_CPP11_MAPPING
p->opAsync(
[cb]()
{
cb->response();
},
[cb](exception_ptr err)
{
try
{
rethrow_exception(err);
}
catch(const Ice::Exception& ex)
{
cb->exception(ex);
}
});
cb->check();
auto i = p->ice_adapterId("dummy");
i->opAsync(
[cb]()
{
cb->response();
},
[cb](exception_ptr err)
{
try
{
rethrow_exception(err);
}
catch(const Ice::Exception& ex)
{
cb->exception(ex);
}
});
cb->check();
{
//
// Expect InvocationTimeoutException.
//
auto to = p->ice_invocationTimeout(250);
to->sleepAsync(500,
[cb]()
{
cb->responseEx();
},
[cb](exception_ptr err)
{
try
{
rethrow_exception(err);
}
catch(const Ice::Exception& ex)
{
cb->exceptionEx(ex);
}
});
cb->check();
}
testController->holdAdapter();
Ice::ByteSeq seq;
seq.resize(1024); // Make sure the request doesn't compress too well.
for(Ice::ByteSeq::iterator q = seq.begin(); q != seq.end(); ++q)
{
*q = static_cast<Ice::Byte>(IceUtilInternal::random(255));
}
vector<shared_ptr<promise<void>>> completed;
while(true)
{
auto s = make_shared<promise<bool>>();
auto fs = s->get_future();
auto c = make_shared<promise<void>>();
p->opWithPayloadAsync(seq,
[=]()
{
c->set_value();
},
[=](exception_ptr)
{
c->set_value();
},
[=](bool sent)
{
s->set_value(sent);
});
completed.push_back(c);
if(fs.wait_for(chrono::milliseconds(0)) != future_status::ready || !fs.get())
{
break;
}
}
testController->resumeAdapter();
for(auto& c : completed)
{
c->get_future().get();
}
#else
Test::Callback_TestIntf_opPtr callback = Test::newCallback_TestIntf_op(cb,
&Callback::response,
&Callback::exception);
p->begin_op(callback);
cb->check();
Test::TestIntfPrx i = p->ice_adapterId("dummy");
i->begin_op(callback);
cb->check();
{
//
// Expect InvocationTimeoutException.
//
Test::TestIntfPrx to = p->ice_invocationTimeout(250);
to->begin_sleep(500, Test::newCallback_TestIntf_sleep(cb, &Callback::responseEx, &Callback::exceptionEx));
cb->check();
}
testController->holdAdapter();
Test::Callback_TestIntf_opWithPayloadPtr callback2 =
Test::newCallback_TestIntf_opWithPayload(cb, &Callback::payload, &Callback::ignoreEx, &Callback::sent);
Ice::ByteSeq seq;
seq.resize(1024); // Make sure the request doesn't compress too well.
for(Ice::ByteSeq::iterator q = seq.begin(); q != seq.end(); ++q)
{
*q = static_cast<Ice::Byte>(IceUtilInternal::random(255));
}
Ice::AsyncResultPtr result;
while((result = p->begin_opWithPayload(seq, callback2))->sentSynchronously());
testController->resumeAdapter();
result->waitForCompleted();
#endif
}
cout << "ok" << endl;
p->shutdown();
}
void
allTests(const Ice::CommunicatorPtr& communicator)
{
cout << "testing stringToProxy... " << flush;
string ref = "hold:" + getTestEndpoint(communicator, 0);
Ice::ObjectPrxPtr base = communicator->stringToProxy(ref);
test(base);
string refSerialized = "hold:" + getTestEndpoint(communicator, 1);
Ice::ObjectPrxPtr baseSerialized = communicator->stringToProxy(refSerialized);
test(base);
cout << "ok" << endl;
cout << "testing checked cast... " << flush;
HoldPrxPtr hold = ICE_CHECKED_CAST(HoldPrx, base);
test(hold);
#ifdef ICE_CPP11_MAPPING
test(Ice::targetEquals(hold, base));
#else
test(hold == base);
#endif
HoldPrxPtr holdSerialized = ICE_CHECKED_CAST(HoldPrx, baseSerialized);
test(holdSerialized);
#ifdef ICE_CPP11_MAPPING
test(Ice::targetEquals(holdSerialized, baseSerialized));
#else
test(holdSerialized == baseSerialized);
#endif
cout << "ok" << endl;
cout << "changing state between active and hold rapidly... " << flush;
int i;
for(i = 0; i < 100; ++i)
{
hold->putOnHold(0);
}
for(i = 0; i < 100; ++i)
{
hold->ice_oneway()->putOnHold(0);
}
for(i = 0; i < 100; ++i)
{
holdSerialized->putOnHold(0);
}
for(i = 0; i < 100; ++i)
{
holdSerialized->ice_oneway()->putOnHold(0);
}
cout << "ok" << endl;
cout << "testing without serialize mode... " << flush;
{
ConditionPtr cond = new Condition(true);
int value = 0;
#ifdef ICE_CPP11_MAPPING
shared_ptr<promise<void>> completed;
while(cond->value())
{
completed = make_shared<promise<void>>();
promise<bool> sent;
hold->set_async(value + 1, IceUtilInternal::random(5),
[cond, expected = value, completed](int value)
{
if(value != expected)
{
cond->set(false);
}
completed->set_value();
},
[completed](exception_ptr)
{
completed->set_value();
},
[&sent](bool sentSynchronously)
{
sent.set_value(sentSynchronously);
});
++value;
if(value % 100 == 0)
{
sent.get_future().get();;
}
if(value > 1000000)
{
// Don't continue, it's possible that out-of-order dispatch doesn't occur
// after 100000 iterations and we don't want the test to last for too long
// when this occurs.
break;
}
}
test(value > 100000 || !cond->value());
completed->get_future().get();
#else
Ice::AsyncResultPtr result;
while(cond->value())
{
result = hold->begin_set(value + 1,
IceUtilInternal::random(5),
newCallback_Hold_set(new SetCB(cond, value), &SetCB::response, &SetCB::exception));
++value;
if(value % 100 == 0)
{
result->waitForSent();
}
if(value > 1000000)
{
// Don't continue, it's possible that out-of-order dispatch doesn't occur
// after 100000 iterations and we don't want the test to last for too long
// when this occurs.
break;
}
}
test(value > 100000 || !cond->value());
result->waitForCompleted();
#endif
}
cout << "ok" << endl;
cout << "testing with serialize mode... " << flush;
{
ConditionPtr cond = new Condition(true);
int value = 0;
#ifdef ICE_CPP11_MAPPING
shared_ptr<promise<void>> completed;
while(value < 3000 && cond->value())
{
completed = make_shared<promise<void>>();
promise<bool> sent;
holdSerialized->set_async(
value + 1,
IceUtilInternal::random(1),
[cond, expected = value, completed](int value)
{
if(value != expected)
{
cond->set(false);
}
completed->set_value();
},
[completed](exception_ptr)
{
completed->set_value();
},
[&sent](bool sentSynchronously)
{
sent.set_value(sentSynchronously);
});
++value;
if(value % 100 == 0)
{
sent.get_future().get();
}
}
#else
Ice::AsyncResultPtr result;
while(value < 3000 && cond->value())
{
result = holdSerialized->begin_set(value + 1,
IceUtilInternal::random(1),
newCallback_Hold_set(new SetCB(cond, value),
&SetCB::response,
&SetCB::exception));
++value;
if(value % 100 == 0)
{
result->waitForSent();
}
}
result->waitForCompleted();
#endif
test(cond->value());
for(int i = 0; i < 10000; ++i)
{
holdSerialized->ice_oneway()->setOneway(value + 1, value);
++value;
if((i % 100) == 0)
{
holdSerialized->ice_oneway()->putOnHold(1);
}
}
}
cout << "ok" << endl;
cout << "testing serialization... " << flush;
{
int value = 0;
holdSerialized->set(value, 0);
#ifdef ICE_CPP11_MAPPING
shared_ptr<promise<void>> completed;
for(int i = 0; i < 10000; ++i)
{
completed = make_shared<promise<void>>();
// Create a new proxy for each request
holdSerialized->ice_oneway()->setOneway_async(value + 1, value,
nullptr,
[](exception_ptr)
{
},
[completed](bool sentSynchronously)
{
completed->set_value();
});
++value;
if((i % 100) == 0)
{
completed->get_future().get();
holdSerialized->ice_ping(); // Ensure everything's dispatched
holdSerialized->ice_getConnection()->close(false);
}
}
completed->get_future().get();
#else
Ice::AsyncResultPtr result;
for(int i = 0; i < 10000; ++i)
{
// Create a new proxy for each request
result = holdSerialized->ice_oneway()->begin_setOneway(value + 1, value);
++value;
if((i % 100) == 0)
{
result->waitForSent();
holdSerialized->ice_ping(); // Ensure everything's dispatched
holdSerialized->ice_getConnection()->close(false);
}
}
result->waitForCompleted();
#endif
}
cout << "ok" << endl;
cout << "testing waitForHold... " << flush;
{
hold->waitForHold();
hold->waitForHold();
for(i = 0; i < 1000; ++i)
{
hold->ice_oneway()->ice_ping();
if((i % 20) == 0)
{
hold->putOnHold(0);
}
}
hold->putOnHold(-1);
hold->ice_ping();
hold->putOnHold(-1);
hold->ice_ping();
}
cout << "ok" << endl;
cout << "changing state to hold and shutting down server... " << flush;
hold->shutdown();
cout << "ok" << endl;
}
