THttpLongPollEngine.cxx

Go to the documentation of this file.

// $Id$
// Author: Sergey Linev   8/01/2018
 
/*************************************************************************
 * Copyright (C) 1995-2013, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
#include "THttpLongPollEngine.h"
 
#include "TError.h"
#include "THttpCallArg.h"
 
#include <cstring>
#include <cstdlib>
 
/** \class THttpLongPollEngine
\ingroup http
 
Emulation of websocket with long poll requests
 
Allows to send data from server to client without explicit request
 
Created automatically as fallback solution when normal WebSopcket connection cannot be established
*/
 
const std::string THttpLongPollEngine::gLongPollNope = "<<nope>>";
 
//////////////////////////////////////////////////////////////////////////
/// constructor
 
THttpLongPollEngine::THttpLongPollEngine(bool raw) : THttpWSEngine(), fRaw(raw)
{
}
 
//////////////////////////////////////////////////////////////////////////
/// Returns ID of the engine, created from this pointer
 
UInt_t THttpLongPollEngine::GetId() const
{
   const void *ptr = (const void *)this;
   return TString::Hash((void *)&ptr, sizeof(void *));
}
 
//////////////////////////////////////////////////////////////////////////
/// Clear request
///
/// normally called shortly before destructor
 
void THttpLongPollEngine::ClearHandle(Bool_t)
{
   std::shared_ptr<THttpCallArg> poll;
 
   {
      std::lock_guard<std::mutex> grd(fMutex);
      poll = std::move(fPoll);
   }
 
   if (poll) {
      poll->Set404();
      poll->NotifyCondition();
   }
}
 
//////////////////////////////////////////////////////////////////////////
/// Create raw buffer which should be send as reply
///
/// For the raw mode all information must be send via binary response
 
std::string THttpLongPollEngine::MakeBuffer(const void *buf, int len, const char *hdr)
{
   std::string res;
 
   if (!fRaw) {
      res.resize(len);
      std::copy((const char *)buf, (const char *)buf + len, res.begin());
      return res;
   }
 
   int hdrlen = hdr ? strlen(hdr) : 0;
   std::string hdrstr = "bin:";
   hdrstr.append(std::to_string(hdrlen));
 
   while ((hdrstr.length() + 1 + hdrlen) % 8 != 0)
      hdrstr.append(" ");
   hdrstr.append(":");
   if (hdrlen > 0)
      hdrstr.append(hdr);
 
   res.resize(hdrstr.length() + len);
   std::copy(hdrstr.begin(), hdrstr.begin() + hdrstr.length(), res.begin());
   std::copy((const char *)buf, (const char *)buf + len, res.begin() + hdrstr.length());
 
   return res;
}
 
//////////////////////////////////////////////////////////////////////////
/// Send binary data via connection
 
void THttpLongPollEngine::Send(const void *buf, int len)
{
   std::shared_ptr<THttpCallArg> poll;
 
   std::string sendbuf = MakeBuffer(buf, len);
 
   {
      std::lock_guard<std::mutex> grd(fMutex);
      if (fPoll) {
         poll = std::move(fPoll);
      } else if (fBufKind == kNoBuf)  {
         fBufKind = kBinBuf;
         std::swap(fBuf, sendbuf);
         return;
      }
   }
 
   if(!poll) {
      Error("Send", "Operation invoked before polling request obtained");
      return;
   }
 
   poll->SetBinaryContent(std::move(sendbuf));
   poll->NotifyCondition();
}
 
//////////////////////////////////////////////////////////////////////////
/// Send binary data with text header via connection
 
void THttpLongPollEngine::SendHeader(const char *hdr, const void *buf, int len)
{
   std::shared_ptr<THttpCallArg> poll;
 
   std::string sendbuf = MakeBuffer(buf, len, hdr);
 
   {
      std::lock_guard<std::mutex> grd(fMutex);
      if (fPoll) {
         poll = std::move(fPoll);
      } else if (fBufKind == kNoBuf)  {
         fBufKind = kBinBuf;
         if (!fRaw && hdr) fBufHeader = hdr;
         std::swap(fBuf, sendbuf);
         return;
      }
   }
 
   if(!poll) {
      Error("SendHeader", "Operation invoked before polling request obtained");
      return;
   }
 
   poll->SetBinaryContent(std::move(sendbuf));
   if (!fRaw)
      poll->SetExtraHeader("LongpollHeader", hdr);
   poll->NotifyCondition();
}
 
//////////////////////////////////////////////////////////////////////////
/// Send const char data
///
/// Either do it immediately or keep in internal buffer
 
void THttpLongPollEngine::SendCharStar(const char *buf)
{
   std::shared_ptr<THttpCallArg> poll;
 
   std::string sendbuf(fRaw ? "txt:" : "");
   sendbuf.append(buf);
 
   {
      std::lock_guard<std::mutex> grd(fMutex);
      if (fPoll) {
         poll = std::move(fPoll);
      } else if (fBufKind == kNoBuf) {
         fBufKind = fRaw ? kBinBuf : kTxtBuf;
         std::swap(fBuf, sendbuf);
         return;
      }
   }
 
   if(!poll) {
      Error("SendCharStart", "Operation invoked before polling request obtained");
      return;
   }
 
   if (fRaw) poll->SetBinaryContent(std::move(sendbuf));
        else poll->SetTextContent(std::move(sendbuf));
   poll->NotifyCondition();
}
 
//////////////////////////////////////////////////////////////////////////////
/// Preview data for given socket
///
/// Method called by WS handler before processing websocket data
/// Returns kTRUE when user should ignore such http request - it is for internal use
 
Bool_t THttpLongPollEngine::PreProcess(std::shared_ptr<THttpCallArg> &arg)
{
   if (!strstr(arg->GetQuery(), "&dummy"))
      return kFALSE;
 
   std::shared_ptr<THttpCallArg> poll;
 
   // if request cannot be postponed just reply it
   if (arg->CanPostpone()) {
      std::lock_guard<std::mutex> grd(fMutex);
      if (fBufKind != kNoBuf) {
         // there is data which can be send directly
         poll = arg;
      } else {
         arg->SetPostponed(); // mark http request as pending, http server should wait for notification
         poll = std::move(fPoll);
         fPoll = arg;         // keep reference on polling request
      }
 
   } else {
      poll = arg;
   }
 
   if (poll) {
      // if there buffered data, it will be provided
      PostProcess(poll);
      poll->NotifyCondition();         // inform http server that request is processed
   }
 
   // if arguments has "&dummy" string, user should not process it
   return kTRUE;
}
 
//////////////////////////////////////////////////////////////////////////////
/// Post process http request
///
/// Normally requests from client does not replied directly for longpoll socket
/// Therefore one can use such request to send data, which was submitted before to the queue
 
void THttpLongPollEngine::PostProcess(std::shared_ptr<THttpCallArg> &arg)
{
   EBufKind kind = kNoBuf;
   std::string sendbuf, sendhdr;
 
   {
      std::lock_guard<std::mutex> grd(fMutex);
      if (fBufKind != kNoBuf) {
         kind = fBufKind;
         fBufKind = kNoBuf;
         std::swap(sendbuf, fBuf);
         std::swap(sendhdr, fBufHeader);
      }
   }
 
   if (kind == kTxtBuf) {
      arg->SetTextContent(std::move(sendbuf));
   } else if (kind == kBinBuf) {
      arg->SetBinaryContent(std::move(sendbuf));
      if (!sendhdr.empty())
         arg->SetExtraHeader("LongpollHeader", sendhdr.c_str());
   } else if (fRaw) {
      arg->SetBinaryContent(std::string("txt:") + gLongPollNope);
   } else {
      arg->SetTextContent(std::string(gLongPollNope));
   }
}
 
//////////////////////////////////////////////////////////////////////////////
/// Indicate that polling requests is there or buffer empty and can be immediately invoked
 
Bool_t THttpLongPollEngine::CanSendDirectly()
{
   std::lock_guard<std::mutex> grd(fMutex);
   return fPoll || (fBufKind == kNoBuf) ? kTRUE : kFALSE;
}