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