void ObjectFactoryService::cycleCleanup(
int timeoutMs)
{
RCF::ThreadInfoPtr tiPtr = getTlsThreadInfoPtr();
RCF::ThreadPool & threadPool = tiPtr->getThreadPool();
if (timeoutMs == 0)
{
cleanupStubMap(mClientStubTimeoutS);
}
else
{
Lock lock(mCleanupThresholdMutex);
if (!threadPool.shouldStop())
{
if (mCleanupIntervalS)
{
unsigned int cleanupIntervalMs = 1000*mCleanupIntervalS;
mCleanupThresholdCondition.timed_wait(lock, cleanupIntervalMs);
}
else
{
mCleanupThresholdCondition.wait(lock);
}
if (!threadPool.shouldStop())
{
cleanupStubMap(mClientStubTimeoutS);
}
}
}
}
bool FileIoThreadPool::ioTask()
{
FileIoRequestPtr opPtr;
{
RCF::Lock lock(mOpsMutex);
while (mOpsQueued.empty() && !mStopFlag)
{
mOpsCondition.timed_wait(lock, 1000);
}
if (mOpsQueued.empty() || mStopFlag)
{
return false;
}
RCF_ASSERT_GT(mOpsQueued.size() , 0);
mOpsInProgress.push_back( mOpsQueued.front() );
mOpsQueued.pop_front();
opPtr = mOpsInProgress.back();
}
RCF::ThreadInfoPtr threadInfoPtr = RCF::getThreadInfoPtr();
if (threadInfoPtr)
{
threadInfoPtr->notifyBusy();
}
// This is the part that blocks.
opPtr->doTransfer();
// Unregister op.
unregisterOp(opPtr);
// Notify completion.
{
RCF::Lock lock(mCompletionMutex);
opPtr->mCompleted = true;
mCompletionCondition.notify_all();
}
return false;
}
void UdpServerTransport::cycle(int timeoutMs)
{
RCF::ThreadInfoPtr tiPtr = getTlsThreadInfoPtr();
RCF::ThreadPool & threadPool = tiPtr->getThreadPool();
if (threadPool.shouldStop())
{
return;
}
// poll the UDP socket for messages, and read a message if one is available
fd_set fdSet;
FD_ZERO(&fdSet);
FD_SET( static_cast<SOCKET>(mFd), &fdSet);
timeval timeout;
timeout.tv_sec = timeoutMs/1000;
timeout.tv_usec = 1000*(timeoutMs%1000);
int ret = Platform::OS::BsdSockets::select(
mFd+1,
&fdSet,
NULL,
NULL,
timeoutMs < 0 ? NULL : &timeout);
int err = Platform::OS::BsdSockets::GetLastError();
if (ret == 1)
{
SessionStatePtr sessionStatePtr = getTlsUdpSessionStatePtr();
if (sessionStatePtr.get() == NULL)
{
sessionStatePtr = SessionStatePtr(new SessionState(*this));
sessionStatePtr->mSessionPtr = getSessionManager().createSession();
sessionStatePtr->mSessionPtr->setSessionState(*sessionStatePtr);
setTlsUdpSessionStatePtr(sessionStatePtr);
}
{
// read a message
ReallocBufferPtr &readVecPtr =
sessionStatePtr->mReadVecPtr;
if (readVecPtr.get() == NULL || !readVecPtr.unique())
{
readVecPtr.reset( new ReallocBuffer());
}
ReallocBuffer &buffer = *readVecPtr;
SockAddrStorage from;
int fromlen = sizeof(from);
memset(&from, 0, sizeof(from));
buffer.resize(4);
int len = Platform::OS::BsdSockets::recvfrom(
mFd,
&buffer[0],
4,
MSG_PEEK,
(sockaddr *) &from,
&fromlen);
err = Platform::OS::BsdSockets::GetLastError();
sessionStatePtr->mRemoteAddress.init(
(sockaddr&) from,
fromlen,
mIpAddress.getType());
if (!isIpAllowed(sessionStatePtr->mRemoteAddress))
{
RCF_LOG_2()(sessionStatePtr->mRemoteAddress.getIp())
<< "Client IP does not match server's IP access rules. Closing connection.";
discardPacket(mFd);
}
else if ( len == 4
|| (len == -1 && err == Platform::OS::BsdSockets::ERR_EMSGSIZE))
{
unsigned int dataLength = 0;
memcpy(&dataLength, &buffer[0], 4);
networkToMachineOrder(&dataLength, 4, 1);
if (getMaxMessageLength() && dataLength > getMaxMessageLength())
{
ByteBuffer byteBuffer;
encodeServerError(getSessionManager(), byteBuffer, RcfError_ServerMessageLength);
byteBuffer.expandIntoLeftMargin(4);
* (boost::uint32_t *) ( byteBuffer.getPtr() ) =
static_cast<boost::uint32_t>(byteBuffer.getLength()-4);
RCF::machineToNetworkOrder(byteBuffer.getPtr(), 4, 1);
char *buffer = byteBuffer.getPtr();
std::size_t bufferLen = byteBuffer.getLength();
sockaddr * pRemoteAddr = NULL;
Platform::OS::BsdSockets::socklen_t remoteAddrSize = 0;
sessionStatePtr->mRemoteAddress.getSockAddr(pRemoteAddr, remoteAddrSize);
int len = sendto(
mFd,
buffer,
static_cast<int>(bufferLen),
0,
pRemoteAddr,
remoteAddrSize);
RCF_UNUSED_VARIABLE(len);
discardPacket(mFd);
}
else
{
buffer.resize(4+dataLength);
memset(&from, 0, sizeof(from));
fromlen = sizeof(from);
len = Platform::OS::BsdSockets::recvfrom(
mFd,
&buffer[0],
4+dataLength,
0,
(sockaddr *) &from,
&fromlen);
if (static_cast<unsigned int>(len) == 4+dataLength)
{
getSessionManager().onReadCompleted(sessionStatePtr->mSessionPtr);
}
}
}
else
{
discardPacket(mFd);
}
}
}
else if (ret == 0)
{
//RCF_LOG_4()(mFd)(mPort)(timeoutMs) << "UdpServerTransport - no messages received within polling interval.";
}
else if (ret == -1)
{
Exception e(
_RcfError_Socket("select()"),
err,
RcfSubsystem_Os);
RCF_THROW(e)(mFd)(mIpAddress.string())(err);
}
}