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; }