// // Disconnect from the remote peer. // virtual void close() { Talk::PeerPrx peer; { IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_lock); if(!_connected) { cout << ">>>> Not connected!" << endl; return; } _connected = false; peer = _peer; _peer = 0; } // // Try to notify the remote peer that we are disconnecting. // try { peer->disconnect(); Ice::ConnectionPtr con = peer->ice_getCachedConnection(); if(con) { con->close(false); } } catch(const Ice::Exception& ex) { cout << ">>>> Error: " << ex << endl; } }
void ReapThread::add(const ReapablePtr& reapable, int timeout, const Ice::ConnectionPtr& connection) { Lock sync(*this); if(_terminated) { return; } // // NOTE: registering a reapable with a null timeout is allowed. The reapable is reaped // only when the reaper thread is shutdown. // // // 10 seconds is the minimum permissable timeout. // if(timeout > 0 && timeout < 10) { timeout = 10; } ReapableItem item; item.item = reapable; item.connection = connection; item.timeout = timeout == 0 ? IceUtil::Time() : IceUtil::Time::seconds(timeout); _sessions.push_back(item); if(connection) { map<Ice::ConnectionPtr, set<ReapablePtr> >::iterator p = _connections.find(connection); if(p == _connections.end()) { p = _connections.insert(make_pair(connection, set<ReapablePtr>())).first; connection->setCloseCallback(_closeCallback); connection->setHeartbeatCallback(_heartbeatCallback); } p->second.insert(reapable); } if(timeout > 0) { // // If there is a new minimum wake interval then wake the reaping // thread. // if(calcWakeInterval()) { notify(); } // // Since we just added a new session with a non null timeout there // must be a non-zero wakeInterval. // assert(_wakeInterval != IceUtil::Time()); } }
void BlobjectI::ice_invoke_async(const Ice::AMD_Object_ice_invokePtr& amdCb, const vector<Ice::Byte>& inEncaps, const Ice::Current& current) { Ice::ConnectionPtr connection = getConnection(current); const bool twoway = current.requestId > 0; Ice::ObjectPrx obj = connection->createProxy(current.id); if(!twoway) { if(_startBatch) { _startBatch = false; _batchProxy = obj->ice_batchOneway(); } if(_batchProxy) { obj = _batchProxy; } if(!current.facet.empty()) { obj = obj->ice_facet(current.facet); } if(_batchProxy) { vector<Ice::Byte> out; obj->ice_invoke(current.operation, current.mode, inEncaps, out, current.ctx); amdCb->ice_response(true, vector<Ice::Byte>()); } else { CallbackPtr cb = new Callback(amdCb, false); Ice::Callback_Object_ice_invokePtr del = Ice::newCallback_Object_ice_invoke(cb, &Callback::response, &Callback::exception, &Callback::sent); obj->ice_oneway()->begin_ice_invoke(current.operation, current.mode, inEncaps, current.ctx, del); } } else { if(!current.facet.empty()) { obj = obj->ice_facet(current.facet); } CallbackPtr cb = new Callback(amdCb, true); Ice::Callback_Object_ice_invokePtr del = Ice::newCallback_Object_ice_invoke(cb, &Callback::response, &Callback::exception, &Callback::sent); obj->begin_ice_invoke(current.operation, current.mode, inEncaps, current.ctx, del); } }
void SearchLogicManagerI::update(const UpdateUnitSeq& updateUnits, const Ice::Current& ic) { const Ice::ConnectionPtr con = ic.con; if (con.get() != NULL) { MCE_DEBUG("SearchLogicManagerI::update" << updateUnits.size() << " objects. invoker is :" << con->toString() << ", facet=" << ic.facet << ", operation=" << ic.operation << ", requestId=" << ic.requestId << ", id.name=" << ic.id.name << ", id.category=" << ic.id.category << ", adapter.name=" << ic.adapter->getName()); } if (updateUnits.empty()) return; for(UpdateUnitSeq::const_iterator iter=updateUnits.begin(); iter!=updateUnits.end(); ++iter) { int user_id = iter->id; if (user_id >= 0) { (_vecMessageQueueThread.at(user_id % kMessageQueueThreadNum))->invoke(*iter); } } }
Int2SearchCacheResultMap SearchCacheManagerI::getSearchCacheList(const ::MyUtil::IntSeq& userIds, const Ice::Current& ic) { struct timeval tvStart; struct timeval tvStart1; struct timeval tvEnd; MyUtil::LongSeq uids; gettimeofday(&tvStart, NULL); Int2SearchCacheResultMap result; for (MyUtil::IntSeq::const_iterator it = userIds.begin(); it!= userIds.end(); ++it) { BinStringPtr binStrPtr = ObjectCacheHelper::instance().findObject<BinStringPtr> (*it); if (binStrPtr.get() != NULL) { SearchMemCacheDataPtr pSCData = new SearchMemCacheData(); char* pBuf = NULL; int len = 0; binStrPtr->getBuf(&pBuf, &len); if (pBuf==NULL || len <= 0) continue; if (pSCData->Unserialize(pBuf, len)) { result[*it] = pSCData->getProperties(); } } else { //scq if (*it != 0) { uids.push_back(*it); } } } gettimeofday(&tvStart1, NULL); if (!uids.empty()) _invokeLoad.invoke(uids); gettimeofday(&tvEnd, NULL); int start = tvStart.tv_sec*1000000 + tvStart.tv_usec; int start1 = tvStart1.tv_sec*1000000 + tvStart1.tv_usec; int end = tvEnd.tv_sec*1000000 + tvEnd.tv_usec; if ((end - start) > 5000) { const Ice::ConnectionPtr con = ic.con; if (con.get() != NULL) { MCE_INFO(con->toString() << " Get SearchCache List: time=" << end-start << "us " << "invokeLoad: time=" << end - start1 << "us total=" << userIds.size()); } } return result; }
void SessionRouterI::refreshSession(const Ice::ConnectionPtr& con) { RouterIPtr router; { IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this); router = getRouterImpl(con, Ice::Identity(), false); // getRouter updates the session timestamp. if(!router) { // // Close the connection otherwise the peer has no way to know that the // session has gone. // con->close(ICE_SCOPED_ENUM(ConnectionClose, Forcefully)); throw SessionNotExistException(); } } SessionPrx session = router->getSession(); if(session) { // // Ping the session to ensure it does not timeout. // session->begin_ice_ping(Ice::newCallback(new ACMPingCallback(this, con), &ACMPingCallback::finished)); } }
void ReapThread::connectionHeartbeat(const Ice::ConnectionPtr& con) { Lock sync(*this); map<Ice::ConnectionPtr, set<ReapablePtr> >::const_iterator p = _connections.find(con); if(p == _connections.end()) { con->setCloseCallback(0); con->setHeartbeatCallback(0); return; } for(set<ReapablePtr>::const_iterator q = p->second.begin(); q != p->second.end(); ++q) { (*q)->heartbeat(); } }
TimeoutPrx allTests(const Ice::CommunicatorPtr& communicator) { string sref = "timeout:default -p 12010"; Ice::ObjectPrx obj = communicator->stringToProxy(sref); test(obj); TimeoutPrx timeout = TimeoutPrx::checkedCast(obj); test(timeout); cout << "testing connect timeout... " << flush; { // // Expect ConnectTimeoutException. // TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(250)); to->holdAdapter(750); to->ice_getConnection()->close(true); // Force a reconnect. try { to->op(); test(false); } catch(const Ice::ConnectTimeoutException&) { // Expected. } } { // // Expect success. // timeout->op(); // Ensure adapter is active. TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(1000)); to->holdAdapter(500); to->ice_getConnection()->close(true); // Force a reconnect. try { to->op(); } catch(const Ice::ConnectTimeoutException&) { test(false); } } cout << "ok" << endl; cout << "testing read timeout... " << flush; { // // Expect TimeoutException. // TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(500)); try { to->sleep(750); test(false); } catch(const Ice::TimeoutException&) { // Expected. } } { // // Expect success. // timeout->op(); // Ensure adapter is active. TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(2000)); try { to->sleep(500); } catch(const Ice::TimeoutException&) { test(false); } } cout << "ok" << endl; cout << "testing write timeout... " << flush; { // // Expect TimeoutException. // TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(500)); to->holdAdapter(2000); try { ByteSeq seq(100000); to->sendData(seq); test(false); } catch(const Ice::TimeoutException&) { // Expected. } } { // // Expect success. // timeout->op(); // Ensure adapter is active. TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(1000)); to->holdAdapter(500); try { ByteSeq seq(100000); to->sendData(seq); } catch(const Ice::TimeoutException&) { test(false); } } cout << "ok" << endl; cout << "testing AMI read timeout... " << flush; { // // Expect TimeoutException. // TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(500)); CallbackPtr cb = new Callback(); to->begin_sleep(2000, newCallback_Timeout_sleep(cb, &Callback::responseEx, &Callback::exceptionEx)); cb->check(); } { // // Expect success. // timeout->op(); // Ensure adapter is active. TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(1000)); CallbackPtr cb = new Callback(); to->begin_sleep(500, newCallback_Timeout_sleep(cb, &Callback::response, &Callback::exception)); cb->check(); } cout << "ok" << endl; cout << "testing AMI write timeout... " << flush; { // // Expect TimeoutException. // TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(500)); to->holdAdapter(2000); ByteSeq seq(100000); CallbackPtr cb = new Callback(); to->begin_sendData(seq, newCallback_Timeout_sendData(cb, &Callback::responseEx, &Callback::exceptionEx)); cb->check(); } { // // Expect success. // timeout->op(); // Ensure adapter is active. TimeoutPrx to = TimeoutPrx::uncheckedCast(obj->ice_timeout(1000)); to->holdAdapter(500); ByteSeq seq(100000); CallbackPtr cb = new Callback(); to->begin_sendData(seq, newCallback_Timeout_sendData(cb, &Callback::response, &Callback::exception)); cb->check(); } cout << "ok" << endl; cout << "testing close timeout... " << flush; { TimeoutPrx to = TimeoutPrx::checkedCast(obj->ice_timeout(250)); Ice::ConnectionPtr connection = to->ice_getConnection(); timeout->holdAdapter(750); connection->close(false); try { connection->getInfo(); // getInfo() doesn't throw in the closing state. } catch(const Ice::LocalException&) { test(false); } IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500)); try { connection->getInfo(); test(false); } catch(const Ice::CloseConnectionException&) { // Expected. } timeout->op(); // Ensure adapter is active. } cout << "ok" << endl; cout << "testing timeout overrides... " << flush; { // // Test Ice.Override.Timeout. This property overrides all // endpoint timeouts. // Ice::InitializationData initData; initData.properties = communicator->getProperties()->clone(); initData.properties->setProperty("Ice.Override.Timeout", "500"); Ice::CommunicatorPtr comm = Ice::initialize(initData); TimeoutPrx to = TimeoutPrx::checkedCast(comm->stringToProxy(sref)); try { to->sleep(750); test(false); } catch(const Ice::TimeoutException&) { // Expected. } // // Calling ice_timeout() should have no effect. // timeout->op(); // Ensure adapter is active. to = TimeoutPrx::checkedCast(to->ice_timeout(1000)); try { to->sleep(750); test(false); } catch(const Ice::TimeoutException&) { // Expected. } comm->destroy(); } { // // Test Ice.Override.ConnectTimeout. // Ice::InitializationData initData; initData.properties = communicator->getProperties()->clone(); initData.properties->setProperty("Ice.Override.ConnectTimeout", "750"); Ice::CommunicatorPtr comm = Ice::initialize(initData); timeout->holdAdapter(1000); TimeoutPrx to = TimeoutPrx::uncheckedCast(comm->stringToProxy(sref)); try { to->op(); test(false); } catch(const Ice::ConnectTimeoutException&) { // Expected. } // // Calling ice_timeout() should have no effect on the connect timeout. // timeout->op(); // Ensure adapter is active. timeout->holdAdapter(1000); to = TimeoutPrx::uncheckedCast(to->ice_timeout(1250)); try { to->op(); test(false); } catch(const Ice::ConnectTimeoutException&) { // Expected. } // // Verify that timeout set via ice_timeout() is still used for requests. // to->op(); // Force connection. try { to->sleep(2000); test(false); } catch(const Ice::TimeoutException&) { // Expected. } comm->destroy(); } { // // Test Ice.Override.CloseTimeout. // Ice::InitializationData initData; initData.properties = communicator->getProperties()->clone(); initData.properties->setProperty("Ice.Override.CloseTimeout", "200"); Ice::CommunicatorPtr comm = Ice::initialize(initData); Ice::ConnectionPtr connection = comm->stringToProxy(sref)->ice_getConnection(); timeout->holdAdapter(750); IceUtil::Time now = IceUtil::Time::now(); comm->destroy(); test(IceUtil::Time::now() - now < IceUtil::Time::milliSeconds(500)); } cout << "ok" << endl; return timeout; }
void SessionHelperI::connected(const Glacier2::RouterPrxPtr& router, const Glacier2::SessionPrxPtr& session) { // // Remote invocation should be done without acquiring a mutex lock. // assert(router); Ice::ConnectionPtr conn = router->ice_getCachedConnection(); string category = router->getCategoryForClient(); Ice::Int acmTimeout = 0; try { acmTimeout = router->getACMTimeout(); } catch(const Ice::OperationNotExistException&) { } if(acmTimeout <= 0) { acmTimeout = static_cast<Ice::Int>(router->getSessionTimeout()); } // // We create the callback object adapter here because createObjectAdapter internally // makes synchronous RPCs to the router. We can't create the OA on-demand when the // client calls objectAdapter() or addWithUUID() because they can be called from the // GUI thread. // if(_useCallbacks) { _adapter = _communicator->createObjectAdapterWithRouter("", router); _adapter->activate(); } bool destroy; { IceUtil::Mutex::Lock sync(_mutex); _router = router; destroy = _destroy; if(!_destroy) { // // Cache the category. // _category = category; // // Assign the session after _destroy is checked. // _session = session; _connected = true; if(acmTimeout > 0) { Ice::ConnectionPtr connection = _router->ice_getCachedConnection(); assert(connection); connection->setACM(acmTimeout, IceUtil::None, Ice::HeartbeatAlways); #ifdef ICE_CPP11_MAPPING connection->setCloseCallback([self = shared_from_this()](Ice::ConnectionPtr) { self->destroy(); }); #else connection->setCloseCallback(ICE_MAKE_SHARED(CloseCallbackI, shared_from_this())); #endif } } } if(destroy) { // // connected() is only called from the ConnectThread so it is ok to // call destroyInternal here. // destroyInternal(new Disconnected(shared_from_this(), _callback)); } else { dispatchCallback(new Connected(_callback, shared_from_this()), conn); } }
void allTests(Test::TestHelper* helper) { Ice::CommunicatorPtr communicator = helper->communicator(); cout << "testing proxy endpoint information... " << flush; { Ice::ObjectPrxPtr p1 = communicator->stringToProxy("test -t:default -h tcphost -p 10000 -t 1200 -z --sourceAddress 10.10.10.10:" "udp -h udphost -p 10001 --interface eth0 --ttl 5 --sourceAddress 10.10.10.10:" "opaque -e 1.8 -t 100 -v ABCD"); Ice::EndpointSeq endps = p1->ice_getEndpoints(); Ice::EndpointInfoPtr info = endps[0]->getInfo(); Ice::TCPEndpointInfoPtr ipEndpoint = getTCPEndpointInfo(info); test(ipEndpoint); test(ipEndpoint->host == "tcphost"); test(ipEndpoint->port == 10000); test(ipEndpoint->timeout == 1200); #if !defined(ICE_OS_UWP) test(ipEndpoint->sourceAddress == "10.10.10.10"); #endif test(ipEndpoint->compress); test(!ipEndpoint->datagram()); test((ipEndpoint->type() == Ice::TCPEndpointType && !ipEndpoint->secure()) || (ipEndpoint->type() == Ice::SSLEndpointType && ipEndpoint->secure()) || (ipEndpoint->type() == Ice::WSEndpointType && !ipEndpoint->secure()) || (ipEndpoint->type() == Ice::WSSEndpointType && ipEndpoint->secure())); test((ipEndpoint->type() == Ice::TCPEndpointType && ICE_DYNAMIC_CAST(Ice::TCPEndpointInfo, info)) || (ipEndpoint->type() == Ice::SSLEndpointType && ICE_DYNAMIC_CAST(IceSSL::EndpointInfo, info)) || (ipEndpoint->type() == Ice::WSEndpointType && ICE_DYNAMIC_CAST(Ice::WSEndpointInfo, info)) || (ipEndpoint->type() == Ice::WSSEndpointType && ICE_DYNAMIC_CAST(Ice::WSEndpointInfo, info))); Ice::UDPEndpointInfoPtr udpEndpoint = ICE_DYNAMIC_CAST(Ice::UDPEndpointInfo, endps[1]->getInfo()); test(udpEndpoint); test(udpEndpoint->host == "udphost"); test(udpEndpoint->port == 10001); #if !defined(ICE_OS_UWP) test(udpEndpoint->sourceAddress == "10.10.10.10"); #endif test(udpEndpoint->mcastInterface == "eth0"); test(udpEndpoint->mcastTtl == 5); test(udpEndpoint->timeout == -1); test(!udpEndpoint->compress); test(!udpEndpoint->secure()); test(udpEndpoint->datagram()); test(udpEndpoint->type() == Ice::UDPEndpointType); Ice::OpaqueEndpointInfoPtr opaqueEndpoint = ICE_DYNAMIC_CAST(Ice::OpaqueEndpointInfo, endps[2]->getInfo()); test(opaqueEndpoint); Ice::EncodingVersion rev; rev.major = 1; rev.minor = 8; test(opaqueEndpoint->rawEncoding == rev); } cout << "ok" << endl; string defaultHost = communicator->getProperties()->getProperty("Ice.Default.Host"); #ifdef ICE_OS_UWP bool uwp = true; #else bool uwp = false; #endif if(!uwp || (communicator->getProperties()->getProperty("Ice.Default.Protocol") != "ssl" && communicator->getProperties()->getProperty("Ice.Default.Protocol") != "wss")) { cout << "test object adapter endpoint information... " << flush; { communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -h 127.0.0.1 -t 15000:udp -h 127.0.0.1"); Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter"); Ice::EndpointSeq endpoints = adapter->getEndpoints(); test(endpoints.size() == 2); Ice::EndpointSeq publishedEndpoints = adapter->getPublishedEndpoints(); test(endpoints == publishedEndpoints); Ice::TCPEndpointInfoPtr ipEndpoint = getTCPEndpointInfo(endpoints[0]->getInfo()); test(ipEndpoint); test(ipEndpoint->type() == Ice::TCPEndpointType || ipEndpoint->type() == Ice::SSLEndpointType || ipEndpoint->type() == Ice::WSEndpointType || ipEndpoint->type() == Ice::WSSEndpointType); test(ipEndpoint->host == "127.0.0.1"); test(ipEndpoint->port > 0); test(ipEndpoint->timeout == 15000); Ice::UDPEndpointInfoPtr udpEndpoint = ICE_DYNAMIC_CAST(Ice::UDPEndpointInfo, endpoints[1]->getInfo()); test(udpEndpoint); test(udpEndpoint->host == "127.0.0.1"); test(udpEndpoint->datagram()); test(udpEndpoint->port > 0); endpoints.pop_back(); test(endpoints.size() == 1); adapter->setPublishedEndpoints(endpoints); publishedEndpoints = adapter->getPublishedEndpoints(); test(endpoints == publishedEndpoints); adapter->destroy(); int port = helper->getTestPort(1); ostringstream portStr; portStr << port; communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -h * -p " + portStr.str()); communicator->getProperties()->setProperty("TestAdapter.PublishedEndpoints", helper->getTestEndpoint(1)); adapter = communicator->createObjectAdapter("TestAdapter"); endpoints = adapter->getEndpoints(); test(endpoints.size() >= 1); publishedEndpoints = adapter->getPublishedEndpoints(); test(publishedEndpoints.size() == 1); for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p) { ipEndpoint = getTCPEndpointInfo((*p)->getInfo()); test(ipEndpoint->port == port); } ipEndpoint = getTCPEndpointInfo(publishedEndpoints[0]->getInfo()); test(ipEndpoint->host == helper->getTestHost()); test(ipEndpoint->port == port); adapter->destroy(); } cout << "ok" << endl; } string endpoints = helper->getTestEndpoint() + ":" + helper->getTestEndpoint("udp") + " -c"; int port = helper->getTestPort(); Ice::ObjectPrxPtr base = communicator->stringToProxy("test:" + endpoints); TestIntfPrxPtr testIntf = ICE_CHECKED_CAST(TestIntfPrx, base); cout << "test connection endpoint information... " << flush; { Ice::EndpointInfoPtr info = base->ice_getConnection()->getEndpoint()->getInfo(); Ice::TCPEndpointInfoPtr tcpinfo = getTCPEndpointInfo(info); test(tcpinfo->port == port); test(!tcpinfo->compress); test(tcpinfo->host == defaultHost); ostringstream os; Ice::Context ctx = testIntf->getEndpointInfoAsContext(); test(ctx["host"] == tcpinfo->host); test(ctx["compress"] == "false"); istringstream is(ctx["port"]); int portCtx; is >> portCtx; test(portCtx > 0); info = base->ice_datagram()->ice_getConnection()->getEndpoint()->getInfo(); Ice::UDPEndpointInfoPtr udp = ICE_DYNAMIC_CAST(Ice::UDPEndpointInfo, info); test(udp); test(udp->port == portCtx); test(udp->host == defaultHost); } cout << "ok" << endl; cout << "testing connection information... " << flush; { Ice::ConnectionPtr connection = base->ice_getConnection(); connection->setBufferSize(1024, 2048); Ice::TCPConnectionInfoPtr info = getTCPConnectionInfo(connection->getInfo()); test(info); test(!info->incoming); test(info->adapterName.empty()); test(info->localPort > 0); test(info->remotePort == port); if(defaultHost == "127.0.0.1") { test(info->remoteAddress == defaultHost); test(info->localAddress == defaultHost); } #if !defined(ICE_OS_UWP) test(info->rcvSize >= 1024); test(info->sndSize >= 2048); #endif ostringstream os; Ice::Context ctx = testIntf->getConnectionInfoAsContext(); test(ctx["incoming"] == "true"); test(ctx["adapterName"] == "TestAdapter"); test(ctx["remoteAddress"] == info->localAddress); test(ctx["localAddress"] == info->remoteAddress); os.str(""); os << info->localPort; test(ctx["remotePort"] == os.str()); os.str(""); os << info->remotePort; test(ctx["localPort"] == os.str()); if(base->ice_getConnection()->type() == "ws" || base->ice_getConnection()->type() == "wss") { Ice::HeaderDict headers; Ice::WSConnectionInfoPtr wsinfo = ICE_DYNAMIC_CAST(Ice::WSConnectionInfo, connection->getInfo()); test(wsinfo); headers = wsinfo->headers; if(base->ice_getConnection()->type() == "wss") { IceSSL::ConnectionInfoPtr wssinfo = ICE_DYNAMIC_CAST(IceSSL::ConnectionInfo, wsinfo->underlying); test(wssinfo->verified); #if !defined(ICE_OS_UWP) && TARGET_OS_IPHONE==0 test(!wssinfo->certs.empty()); #endif } test(headers["Upgrade"] == "websocket"); test(headers["Connection"] == "Upgrade"); test(headers["Sec-WebSocket-Protocol"] == "ice.zeroc.com"); test(headers.find("Sec-WebSocket-Accept") != headers.end()); test(ctx["ws.Upgrade"] == "websocket"); test(ctx["ws.Connection"] == "Upgrade"); test(ctx["ws.Sec-WebSocket-Protocol"] == "ice.zeroc.com"); test(ctx["ws.Sec-WebSocket-Version"] == "13"); test(ctx.find("ws.Sec-WebSocket-Key") != ctx.end()); } connection = base->ice_datagram()->ice_getConnection(); connection->setBufferSize(2048, 1024); Ice::UDPConnectionInfoPtr udpinfo = ICE_DYNAMIC_CAST(Ice::UDPConnectionInfo, connection->getInfo()); test(!udpinfo->incoming); test(udpinfo->adapterName.empty()); test(udpinfo->localPort > 0); test(udpinfo->remotePort == port); if(defaultHost == "127.0.0.1") { test(udpinfo->remoteAddress == defaultHost); test(udpinfo->localAddress == defaultHost); } #if !defined(ICE_OS_UWP) test(udpinfo->rcvSize >= 2048); test(udpinfo->sndSize >= 1024); #endif } cout << "ok" << endl; testIntf->shutdown(); communicator->shutdown(); communicator->waitForShutdown(); }
Ice::ObjectPrx AdminSessionI::toProxy(const Ice::Identity& id, const Ice::ConnectionPtr& connection, const Ice::EncodingVersion& v) { return id.name.empty() ? Ice::ObjectPrx() : connection->createProxy(id)->ice_encodingVersion(v); }
bool Glacier2::Application::doMain(Ice::StringSeq& args, const Ice::InitializationData& initData, int& status) { // // Reset internal state variables from Ice.Application. The // remainder are reset at the end of this method. // IceInternal::Application::_callbackInProgress = false; IceInternal::Application::_destroyed = false; IceInternal::Application::_interrupted = false; bool restart = false; status = 0; try { IceInternal::Application::_communicator = Ice::initialize(args, initData); _router = Glacier2::RouterPrx::uncheckedCast(communicator()->getDefaultRouter()); if(!_router) { Error out(getProcessLogger()); out << IceInternal::Application::_appName << ": no glacier2 router configured"; status = 1; } else { // // The default is to destroy when a signal is received. // if(IceInternal::Application::_signalPolicy == Ice::HandleSignals) { destroyOnInterrupt(); } // If createSession throws, we're done. try { _session = createSession(); _createdSession = true; } catch(const Ice::LocalException& ex) { Error out(getProcessLogger()); out << IceInternal::Application::_appName << ": " << ex; status = 1; } if(_createdSession) { Ice::Int acmTimeout = 0; try { acmTimeout = _router->getACMTimeout(); } catch(const Ice::OperationNotExistException&) { } if(acmTimeout <= 0) { acmTimeout = static_cast<Ice::Int>(_router->getSessionTimeout()); } if(acmTimeout > 0) { Ice::ConnectionPtr connection = _router->ice_getCachedConnection(); assert(connection); connection->setACM(acmTimeout, IceUtil::None, Ice::HeartbeatAlways); connection->setCallback(new ConnectionCallbackI(this)); } _category = _router->getCategoryForClient(); IceUtilInternal::ArgVector a(args); status = runWithSession(a.argc, a.argv); } } } // We want to restart on those exceptions which indicate a // break down in communications, but not those exceptions that // indicate a programming logic error (ie: marshal, protocol // failure, etc). catch(const RestartSessionException&) { restart = true; } catch(const Ice::ConnectionRefusedException& ex) { Error out(getProcessLogger()); out << IceInternal::Application::_appName << ": " << ex; restart = true; } catch(const Ice::ConnectionLostException& ex) { Error out(getProcessLogger()); out << IceInternal::Application::_appName << ": " << ex; restart = true; } catch(const Ice::UnknownLocalException& ex) { Error out(getProcessLogger()); out << IceInternal::Application::_appName << ": " << ex; restart = true; } catch(const Ice::RequestFailedException& ex) { Error out(getProcessLogger()); out << IceInternal::Application::_appName << ": " << ex; restart = true; } catch(const Ice::TimeoutException& ex) { Error out(getProcessLogger()); out << IceInternal::Application::_appName << ": " << ex; restart = true; } catch(const Ice::LocalException& ex) { Error out(getProcessLogger()); out << IceInternal::Application::_appName << ": " << ex; status = 1; } catch(const std::exception& ex) { Error out(getProcessLogger()); out << IceInternal::Application::_appName << ": std::exception " << ex; status = 1; } catch(const std::string& ex) { Error out(getProcessLogger()); out << IceInternal::Application::_appName << ": c++ exception " << ex; status = 1; } catch(const char* ex) { Error out(getProcessLogger()); out << IceInternal::Application::_appName << ": char* exception " << ex; status = 1; } catch(...) { Error out(getProcessLogger()); out << IceInternal::Application::_appName << ": unknown exception"; status = 1; } // // Don't want any new interrupt and at this point (post-run), // it would not make sense to release a held signal to run // shutdown or destroy. // if(IceInternal::Application::_signalPolicy == HandleSignals) { ignoreInterrupt(); } { IceUtil::Mutex::Lock lock(*IceInternal::Application::mutex); while(IceInternal::Application::_callbackInProgress) { IceInternal::Application::_condVar->wait(lock); } if(IceInternal::Application::_destroyed) { IceInternal::Application::_communicator = 0; } else { IceInternal::Application::_destroyed = true; // // And _communicator != 0, meaning will be destroyed // next, _destroyed = true also ensures that any // remaining callback won't do anything // } IceInternal::Application::_application = 0; } if(_createdSession && _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 exception& ex) { // Not expected. Error out(getProcessLogger()); out << "unexpected exception when destroying the session:\n" << ex; } _router = 0; } if(IceInternal::Application::_communicator) { try { IceInternal::Application::_communicator->destroy(); } catch(const Ice::LocalException& ex) { Error out(getProcessLogger()); out << IceInternal::Application::_appName << ": " << ex; status = 1; } catch(const exception& ex) { Error out(getProcessLogger()); out << "unknown exception:\n" << ex; status = 1; } IceInternal::Application::_communicator = 0; } // // Reset internal state. We cannot reset the Application state // here, since _destroyed must remain true until we re-run // this method. // _adapter = 0; _router = 0; _session = 0; _createdSession = false; _category.clear(); return restart; }
TimeoutPrxPtr allTests(const Ice::CommunicatorPtr& communicator) { string sref = "timeout:" + getTestEndpoint(communicator, 0); Ice::ObjectPrxPtr obj = communicator->stringToProxy(sref); test(obj); TimeoutPrxPtr timeout = ICE_CHECKED_CAST(TimeoutPrx, obj); test(timeout); cout << "testing connect timeout... " << flush; { // // Expect ConnectTimeoutException. // TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_timeout(100)); timeout->holdAdapter(500); try { to->op(); test(false); } catch(const Ice::ConnectTimeoutException&) { // Expected. } } { // // Expect success. // timeout->op(); // Ensure adapter is active. TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_timeout(1000)); timeout->holdAdapter(500); try { to->op(); } catch(const Ice::ConnectTimeoutException&) { test(false); } } cout << "ok" << endl; // The sequence needs to be large enough to fill the write/recv buffers ByteSeq seq(2000000); cout << "testing connection timeout... " << flush; { // // Expect TimeoutException. // TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_timeout(100)); timeout->holdAdapter(500); try { to->sendData(seq); test(false); } catch(const Ice::TimeoutException&) { // Expected. } } { // // Expect success. // timeout->op(); // Ensure adapter is active. TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_timeout(1000)); timeout->holdAdapter(500); try { ByteSeq seq(1000000); to->sendData(seq); } catch(const Ice::TimeoutException&) { test(false); } } cout << "ok" << endl; cout << "testing invocation timeout... " << flush; { Ice::ConnectionPtr connection = obj->ice_getConnection(); TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_invocationTimeout(100)); test(connection == to->ice_getConnection()); try { to->sleep(750); test(false); } catch(const Ice::InvocationTimeoutException&) { } obj->ice_ping(); to = ICE_CHECKED_CAST(TimeoutPrx, obj->ice_invocationTimeout(500)); test(connection == to->ice_getConnection()); try { to->sleep(250); } catch(const Ice::InvocationTimeoutException&) { test(false); } test(connection == to->ice_getConnection()); } { // // Expect InvocationTimeoutException. // TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_invocationTimeout(100)); #ifdef ICE_CPP11_MAPPING auto f = to->sleep_async(750); try { f.get(); test(false); } catch(const Ice::InvocationTimeoutException&) { } catch(...) { test(false); } #else CallbackPtr cb = new Callback(); to->begin_sleep(750, newCallback_Timeout_sleep(cb, &Callback::responseEx, &Callback::exceptionEx)); cb->check(); #endif obj->ice_ping(); } { // // Expect success. // TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_invocationTimeout(500)); #ifdef ICE_CPP11_MAPPING auto f = to->sleep_async(250); try { f.get(); } catch(...) { test(false); } #else CallbackPtr cb = new Callback(); to->begin_sleep(250, newCallback_Timeout_sleep(cb, &Callback::response, &Callback::exception)); cb->check(); #endif } { // // Backward compatible connection timeouts // TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_invocationTimeout(-2)->ice_timeout(250)); Ice::ConnectionPtr con; try { con = to->ice_getConnection(); to->sleep(750); test(false); } catch(const Ice::TimeoutException&) { try { con->getInfo(); test(false); } catch(const Ice::TimeoutException&) { // Connection got closed as well. } } obj->ice_ping(); try { con = to->ice_getConnection(); #ifdef ICE_CPP11_MAPPING to->sleep_async(750).get(); #else to->end_sleep(to->begin_sleep(750)); #endif test(false); } catch(const Ice::TimeoutException&) { try { con->getInfo(); test(false); } catch(const Ice::TimeoutException&) { // Connection got closed as well. } } obj->ice_ping(); } cout << "ok" << endl; cout << "testing close timeout... " << flush; { TimeoutPrxPtr to = ICE_CHECKED_CAST(TimeoutPrx, obj->ice_timeout(250)); Ice::ConnectionPtr connection = to->ice_getConnection(); timeout->holdAdapter(600); connection->close(false); try { connection->getInfo(); // getInfo() doesn't throw in the closing state. } catch(const Ice::LocalException&) { test(false); } IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(650)); try { connection->getInfo(); test(false); } catch(const Ice::CloseConnectionException&) { // Expected. } timeout->op(); // Ensure adapter is active. } cout << "ok" << endl; cout << "testing timeout overrides... " << flush; { // // Test Ice.Override.Timeout. This property overrides all // endpoint timeouts. // Ice::InitializationData initData; initData.properties = communicator->getProperties()->clone(); initData.properties->setProperty("Ice.Override.Timeout", "250"); Ice::CommunicatorPtr comm = Ice::initialize(initData); TimeoutPrxPtr to = ICE_CHECKED_CAST(TimeoutPrx, comm->stringToProxy(sref)); timeout->holdAdapter(700); try { to->sendData(seq); test(false); } catch(const Ice::TimeoutException&) { // Expected. } // // Calling ice_timeout() should have no effect. // timeout->op(); // Ensure adapter is active. to = ICE_CHECKED_CAST(TimeoutPrx, to->ice_timeout(1000)); timeout->holdAdapter(500); try { to->sendData(seq); test(false); } catch(const Ice::TimeoutException&) { // Expected. } comm->destroy(); } { // // Test Ice.Override.ConnectTimeout. // Ice::InitializationData initData; initData.properties = communicator->getProperties()->clone(); initData.properties->setProperty("Ice.Override.ConnectTimeout", "250"); Ice::CommunicatorPtr comm = Ice::initialize(initData); timeout->holdAdapter(750); TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, comm->stringToProxy(sref)); try { to->op(); test(false); } catch(const Ice::ConnectTimeoutException&) { // Expected. } // // Calling ice_timeout() should have no effect on the connect timeout. // timeout->op(); // Ensure adapter is active. timeout->holdAdapter(750); to = ICE_UNCHECKED_CAST(TimeoutPrx, to->ice_timeout(1000)); try { to->op(); test(false); } catch(const Ice::ConnectTimeoutException&) { // Expected. } // // Verify that timeout set via ice_timeout() is still used for requests. // timeout->op(); // Ensure adapter is active. to = ICE_UNCHECKED_CAST(TimeoutPrx, to->ice_timeout(250)); to->ice_getConnection(); // Establish connection timeout->holdAdapter(750); try { to->sendData(seq); test(false); } catch(const Ice::TimeoutException&) { // Expected. } comm->destroy(); } { // // Test Ice.Override.CloseTimeout. // Ice::InitializationData initData; initData.properties = communicator->getProperties()->clone(); initData.properties->setProperty("Ice.Override.CloseTimeout", "250"); Ice::CommunicatorPtr comm = Ice::initialize(initData); Ice::ConnectionPtr connection = comm->stringToProxy(sref)->ice_getConnection(); timeout->holdAdapter(500); IceUtil::Time now = IceUtil::Time::now(); comm->destroy(); test(IceUtil::Time::now() - now < IceUtil::Time::milliSeconds(400)); } cout << "ok" << endl; cout << "testing invocation timeouts with collocated calls... " << flush; { communicator->getProperties()->setProperty("TimeoutCollocated.AdapterId", "timeoutAdapter"); Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TimeoutCollocated"); adapter->activate(); TimeoutPrxPtr timeout = ICE_UNCHECKED_CAST(TimeoutPrx, adapter->addWithUUID(ICE_MAKE_SHARED(TimeoutI))); timeout = timeout->ice_invocationTimeout(100); try { timeout->sleep(300); test(false); } catch(const Ice::InvocationTimeoutException&) { } try { #ifdef ICE_CPP11_MAPPING timeout->sleep_async(300).get(); #else timeout->end_sleep(timeout->begin_sleep(300)); #endif test(false); } catch(const Ice::InvocationTimeoutException&) { } TimeoutPrxPtr batchTimeout = timeout->ice_batchOneway(); batchTimeout->ice_ping(); batchTimeout->ice_ping(); batchTimeout->ice_ping(); // Keep the server thread pool busy. #ifdef ICE_CPP11_MAPPING timeout->ice_invocationTimeout(-1)->sleep_async(300); #else timeout->ice_invocationTimeout(-1)->begin_sleep(300); #endif try { batchTimeout->ice_flushBatchRequests(); test(false); } catch(const Ice::InvocationTimeoutException&) { } batchTimeout->ice_ping(); batchTimeout->ice_ping(); batchTimeout->ice_ping(); // Keep the server thread pool busy. #ifdef ICE_CPP11_MAPPING timeout->ice_invocationTimeout(-1)->sleep_async(300); #else timeout->ice_invocationTimeout(-1)->begin_sleep(300); #endif try { #ifdef ICE_CPP11_MAPPING batchTimeout->ice_flushBatchRequests_async().get(); #else batchTimeout->end_ice_flushBatchRequests(batchTimeout->begin_ice_flushBatchRequests()); #endif test(false); } catch(const Ice::InvocationTimeoutException&) { } adapter->destroy(); } cout << "ok" << endl; return timeout; }
int TalkApp::run(int argc, char*[]) { if(argc > 1) { cerr << appName() << ": too many arguments" << endl; return EXIT_FAILURE; } // // Create an object adapter with the name "Talk". Its endpoint is defined // in the configuration file 'config'. // Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Talk"); // // Install a servant with the well-known identity "peer". // PeerIPtr incomingPeer = new IncomingPeerI; PeerIPtr peer = incomingPeer; adapter->add(peer, communicator()->stringToIdentity("peer")); adapter->activate(); usage(); cout << ">>>> Ready." << endl; do { string s; cout << ""; getline(cin, s); if(!s.empty()) { if(s[0] == '/') { if(s.size() > 8 && s.substr(0, 8) == "/connect") { string::size_type sp = s.find(' '); if(sp == string::npos) { usage(); continue; } sp = s.find_first_not_of(' ', sp); if(sp == string::npos) { usage(); continue; } string addr = s.substr(sp); // // Generate a UUID for our callback servant. We have to pass this identity to // the remote peer so that it can invoke callbacks on the servant over a // bidirectional connection. // Ice::Identity id = communicator()->stringToIdentity(IceUtil::generateUUID()); PeerIPtr servant; try { // // Create a proxy for the remote peer using the address given by the user // and the well-known UUID for the talk service. // Talk::PeerPrx prx = Talk::PeerPrx::uncheckedCast( communicator()->stringToProxy( "peer:bt -a \"" + addr + "\" -u 6a193943-1754-4869-8d0a-ddc5f9a2b294")); cout << ">>>> Connecting to " << addr << endl; // // Configure an object adapter for the connection and add the servant. This enables // us to receive callbacks via this connection. Calling ice_getConnection() blocks // until the connection to the peer is established. // Ice::ConnectionPtr con = prx->ice_getConnection(); con->setAdapter(adapter); servant = new OutgoingPeerI(adapter, id, prx); adapter->add(servant, id); // // Now we're ready to notify the peer that we'd like to connect. // prx->connect(id); peer = servant; cout << ">>>> Connected to " << addr << endl; } catch(const Ice::Exception& ex) { cout << ">>>> " << ex << endl; if(servant) { adapter->remove(id); } } } else if(s == "/disconnect") { peer->close(); peer = incomingPeer; } else if(s == "/quit") { break; } else { usage(); } } else { peer->sendMessage(s); } } } while(cin.good()); communicator()->destroy(); return EXIT_SUCCESS; }