void MulticastClientTransport::dropIdleTransports()
{
bringInNewTransports();
Lock lock(mClientTransportsMutex);
bool needToRemove = false;
ClientTransportList::iterator iter;
for (iter = mClientTransports.begin(); iter != mClientTransports.end(); ++iter)
{
RCF::ClientTransport & transport = ***iter;
RcfSessionWeakPtr rcfSessionWeakPtr = transport.getRcfSession();
if ( rcfSessionWeakPtr == RcfSessionWeakPtr() )
{
// HTTP/HTTPS connections do not hold on to the RcfSession and can't receive pings.
continue;
}
RcfSessionPtr rcfSessionPtr = rcfSessionWeakPtr.lock();
if (!rcfSessionPtr)
{
RCF_LOG_2() << "Dropping subscription. Subscriber has closed connection.";
iter->reset();
needToRemove = true;
}
else
{
boost::uint32_t pingIntervalMs = rcfSessionPtr->getPingIntervalMs();
if (pingIntervalMs)
{
RCF::Timer pingTimer( rcfSessionPtr->getPingTimestamp() );
if (pingTimer.elapsed(5000 + 2*pingIntervalMs))
{
std::string subscriberUrl = rcfSessionPtr->getClientAddress().string();
RCF_LOG_2()(subscriberUrl)(pingIntervalMs)
<< "Dropping subscription. Subscriber has not sent pings within the expected ping interval.";
iter->reset();
needToRemove = true;
}
}
}
}
if (needToRemove)
{
eraseRemove(mClientTransports, ClientTransportAutoPtrPtr());
}
}
void ClientStub::setTransportProtocol(TransportProtocol protocol)
{
if (mTransportProtocol != protocol)
{
mTransportProtocol = protocol;
RcfSessionWeakPtr sessionWeakPtr = getTransport().getRcfSession();
bool isRegularConnection = (sessionWeakPtr == RcfSessionWeakPtr());
if (isRegularConnection)
{
disconnect();
clearTransportFilters();
}
else
{
mSetTransportProtocol = true;
}
}
}
void PublishingService::addSubscriberTransport(
RcfSession &rcfSession,
const std::string &publisherName,
ClientTransportAutoPtrPtr clientTransportAutoPtrPtr)
{
PublisherPtr publisherPtr;
{
Lock lock(mPublishersMutex);
if ( mPublishers.find(publisherName) != mPublishers.end() )
{
publisherPtr = mPublishers[publisherName].lock();
}
}
if ( publisherPtr )
{
AsioNetworkSession& networkSession = static_cast<AsioNetworkSession&>(rcfSession.getNetworkSession());
// For now we assume the presence of wire filters indicates a HTTP/HTTPS connection.
if ( networkSession.mWireFilters.size() > 0 )
{
// This doesn't actually close anything, it just takes the session out of the server IO loop.
rcfSession.setCloseSessionAfterWrite(true);
(*clientTransportAutoPtrPtr)->setRcfSession(RcfSessionWeakPtr());
std::size_t wireFilterCount = networkSession.mWireFilters.size();
RCF_ASSERT(wireFilterCount == 1 || wireFilterCount == 2);
RCF_UNUSED_VARIABLE(wireFilterCount);
ConnectedClientTransport& connClientTransport = static_cast<ConnectedClientTransport&>(**clientTransportAutoPtrPtr);
connClientTransport.setWireFilters(networkSession.mWireFilters);
networkSession.mWireFilters.clear();
networkSession.setTransportFilters(std::vector<FilterPtr>());
}
MulticastClientTransport &multicastClientTransport =
static_cast<MulticastClientTransport &>(
publisherPtr->mRcfClientPtr->getClientStub().getTransport());
multicastClientTransport.addTransport(*clientTransportAutoPtrPtr);
}
}
