void clearThreadLocalDataForThisThread()
{
ThreadLocalData * pTld = gpTldPtr->get();
gpTldPtr->reset(NULL);
{
Lock lock(*gpTldInstancesMutex);
eraseRemove(*gpTldInstances, pTld);
}
delete pTld;
}
void CmdLine::parseCmdLine(const vector<string>& mArgs)
{
deque<string> args{begin(mArgs), end(mArgs)};
if(mArgs.size() == 0) {
log("no command specified!");
return;
}
Cmd& cmd(findCmd(args.front()));
args.pop_front();
// Find all flags, put them in cFlags, remove them from mArgs
vector<string> cFlags;
for(const auto& s : args)
{
if(startsWith(s, flagPrefixShort) || startsWith(s, flagPrefixLong))
{
cFlags.push_back(s);
if(cFlags.size() > cmd.getFlagCount()) throw runtime_error("Incorrect number of flags for command " + cmd.getNamesString() + " , correct number is '" + toStr(cmd.getFlagCount()) + "'");
}
}
for(const auto& f : cFlags) eraseRemove(args, f);
// Find args, put them in cArgs
vector<string> cArgs;
for(unsigned int i{cmd.getArgCount()}; i > 0; --i)
{
if(args.empty()) throw runtime_error("Incorrect number of args for command " + cmd.getNamesString() + " , correct number is '" + toStr(cmd.getArgCount()) + "'");
cArgs.push_back(args.front());
args.pop_front();
}
// Remaining string in args must be optargs
vector<string> cOptArgs;
while(!args.empty())
{
cOptArgs.push_back(args.front());
if(cOptArgs.size() > cmd.getOptArgCount()) throw runtime_error("Incorrect number of optargs for command " + cmd.getNamesString() + " , correct number is '" + toStr(cmd.getOptArgCount()) + "'");
args.pop_front();
}
for(unsigned int i{0}; i < cArgs.size(); ++i)
cmd.setArgValue(i, cArgs[i]);
for(unsigned int i{0}; i < cOptArgs.size(); ++i)
cmd.setOptArgValue(i, cOptArgs[i]);
for(const auto& f : cFlags)
cmd.activateFlag(f);
cmd();
}
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 Timeline::del(Command& mCommand) { eraseRemove(commands, &mCommand); commandManager.del(mCommand); }
int MulticastClientTransport::send(
ClientTransportCallback & clientStub,
const std::vector<ByteBuffer> & data,
unsigned int timeoutMs)
{
// NB: As the same buffer is sent on all transports, the transports and
// filters should never modify the buffer. Any transport that transforms
// data needs to do so in a separate per-transport buffer.
RCF_UNUSED_VARIABLE(timeoutMs);
RCF_LOG_2()(lengthByteBuffers(data))(timeoutMs)
<< "MulticastClientTransport::send() - entry.";
mLastRequestSize = lengthByteBuffers(data);
mRunningTotalBytesSent += mLastRequestSize;
bringInNewTransports();
Lock lock(mClientTransportsMutex);
std::size_t transportsInitial = mClientTransports.size();
PublishCompletionInfo info( mClientTransports.size() );
// Setup completion handlers.
std::vector<PublishCompletionHandler> handlers( mClientTransports.size() );
for (std::size_t i=0; i<mClientTransports.size(); ++i)
{
ClientTransport * pTransport = (*mClientTransports[i]).get();
handlers[i] = PublishCompletionHandler(pTransport, &info);
}
// Async send on all transports.
for (std::size_t i=0; i<handlers.size(); ++i)
{
try
{
handlers[i].mpClientTransport->setAsync(true);
handlers[i].mpClientTransport->send(handlers[i], data, 0);
}
catch(const Exception &e)
{
Exception err( _RcfError_SyncPublishError(e.what()) );
handlers[i].onError(err);
}
}
// Wait for async completions.
boost::uint32_t completionDurationMs = 0;
{
Timer timer;
info.wait(timeoutMs);
completionDurationMs = timer.getDurationMs();
}
// Cancel any outstanding sends.
for (std::size_t i=0; i<handlers.size(); ++i)
{
if (!handlers[i].mCompleted)
{
(*mClientTransports[i])->cancel();
RCF_LOG_2()(i)
<< "MulticastClientTransport::send() - cancel send.";
}
}
// Wait for canceled ops to complete.
boost::uint32_t cancelDurationMs = 0;
{
Timer timer;
info.wait(timeoutMs);
cancelDurationMs = timer.getDurationMs();
}
RCF_ASSERT(info.getCompletionCount() == handlers.size());
// Close and remove any subscriber transports with errors.
std::size_t transportsRemoved = 0;
for (std::size_t i=0; i<handlers.size(); ++i)
{
RCF_ASSERT(handlers[i].mCompleted);
if (!handlers[i].mOk)
{
mClientTransports[i] = ClientTransportAutoPtrPtr();
++transportsRemoved;
RCF_LOG_2()(i)(handlers[i].mCompleted)(handlers[i].mOk)(handlers[i].mError)
<< "MulticastClientTransport::send() - remove subscriber transport.";
}
}
eraseRemove(mClientTransports, ClientTransportAutoPtrPtr());
clientStub.onSendCompleted();
std::size_t transportsFinal = transportsInitial - transportsRemoved;
RCF_LOG_2()
(lengthByteBuffers(data))(completionDurationMs)(cancelDurationMs)(transportsInitial)(transportsFinal)
<< "MulticastClientTransport::send() - exit.";
return 1;
}
