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