http: improve cleanup of websocket connection

net/http/inc/THttpWSHandler.h

@@ -41,7 +41,7 @@ private:
 
    Int_t PerformSend(std::shared_ptr<THttpWSEngine> engine);
 
-   void RemoveEngine(std::shared_ptr<THttpWSEngine> &engine);
+   void RemoveEngine(std::shared_ptr<THttpWSEngine> &engine, Bool_t terminate = kFALSE);
 
    Int_t CompleteSend(std::shared_ptr<THttpWSEngine> &engine);
 

net/http/src/TCivetweb.cxx

@@ -38,9 +38,19 @@ protected:
 public:
    TCivetwebWSEngine(struct mg_connection *conn) : THttpWSEngine(), fWSconn(conn) {}
 
+   virtual ~TCivetwebWSEngine()
+   {
+      TCivetwebWSEngine::ClearHandle(kTRUE);
+   }
+
    virtual UInt_t GetId() const { return TString::Hash((void *)&fWSconn, sizeof(void *)); }
 
-   virtual void ClearHandle() { fWSconn = nullptr; }
+   virtual void ClearHandle(Bool_t terminate) override
+   {
+      if (fWSconn && terminate)
+         mg_websocket_write(fWSconn, MG_WEBSOCKET_OPCODE_CONNECTION_CLOSE, nullptr, 0);
+      fWSconn = nullptr;
+   }
 
    virtual void Send(const void *buf, int len)
    {

net/http/src/THttpLongPollEngine.cxx

@@ -28,7 +28,6 @@
 
 const std::string THttpLongPollEngine::gLongPollNope = "<<nope>>";
 
-
 //////////////////////////////////////////////////////////////////////////
 /// constructor
 
@@ -36,6 +35,14 @@ THttpLongPollEngine::THttpLongPollEngine(bool raw) : THttpWSEngine(), fRaw(raw)
 {
 }
 
+//////////////////////////////////////////////////////////////////////////
+/// destructor
+
+THttpLongPollEngine::~THttpLongPollEngine()
+{
+   // THttpLongPollEngine::ClearHandle(kTRUE);
+}
+
 //////////////////////////////////////////////////////////////////////////
 /// returns ID of the engine, created from this pointer
 
@@ -46,9 +53,9 @@ UInt_t THttpLongPollEngine::GetId() const
 }
 
 //////////////////////////////////////////////////////////////////////////
-/// clear request, waiting for next portion of data
+/// clear request, normally called shortly before destructor
 
-void THttpLongPollEngine::ClearHandle()
+void THttpLongPollEngine::ClearHandle(Bool_t)
 {
    std::shared_ptr<THttpCallArg> poll;
 

net/http/src/THttpLongPollEngine.h

@@ -36,10 +36,11 @@ protected:
 
 public:
    THttpLongPollEngine(bool raw = false);
+   virtual ~THttpLongPollEngine();
 
    virtual UInt_t GetId() const override;
 
-   virtual void ClearHandle() override;
+   virtual void ClearHandle(Bool_t) override;
 
    virtual void Send(const void *buf, int len) override;
 

net/http/src/THttpWSEngine.h

@@ -27,7 +27,7 @@ private:
    friend class THttpWSHandler;
 
    bool fMTSend{false};     ///<!  true when send operation runs, set under locked fMutex from WSHandler
-   bool fDisabled{false};   ///<!  set shortly before cleanup
+   bool fDisabled{false};   ///<!  true shortly before cleanup, set under locked fMutex from WSHandler
 
    std::mutex fDataMutex;                              ///<! protects data submited for send operation
    enum { kNone, kData, kHeader, kText } fKind{kNone}; ///<! kind of operation
@@ -47,12 +47,9 @@ protected:
 public:
    virtual ~THttpWSEngine() {}
 
-   /// Returns kTRUE when handle is deactivated and need to be destroyed
-   Bool_t IsDisabled() const { return fDisabled; }
-
    virtual UInt_t GetId() const = 0;
 
-   virtual void ClearHandle() = 0;
+   virtual void ClearHandle(Bool_t) = 0;
 
    virtual void Send(const void *buf, int len) = 0;
 

net/http/src/THttpWSHandler.cxx

@@ -133,8 +133,10 @@ std::shared_ptr<THttpWSEngine> THttpWSHandler::FindEngine(UInt_t wsid, Bool_t bo
 ////////////////////////////////////////////////////////////////////////////////
 /// Remove and destroy WS connection
 
-void THttpWSHandler::RemoveEngine(std::shared_ptr<THttpWSEngine> &engine)
+void THttpWSHandler::RemoveEngine(std::shared_ptr<THttpWSEngine> &engine, Bool_t terminate)
 {
+   if (!engine) return;
+
    {
       std::lock_guard<std::mutex> grd(fMutex);
 
@@ -149,7 +151,7 @@ void THttpWSHandler::RemoveEngine(std::shared_ptr<THttpWSEngine> &engine)
          }
    }
 
-   engine->ClearHandle();
+   engine->ClearHandle(terminate);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -178,7 +180,7 @@ Bool_t THttpWSHandler::HandleWS(std::shared_ptr<THttpCallArg> &arg)
 
       if (engine) {
          Error("HandleWS", "WS engine with similar id exists %u", arg->GetWSId());
-         RemoveEngine(engine);
+         RemoveEngine(engine, kTRUE);
       }
 
       engine = arg->TakeWSEngine();
@@ -189,7 +191,7 @@ Bool_t THttpWSHandler::HandleWS(std::shared_ptr<THttpCallArg> &arg)
 
       if (!ProcessWS(arg.get())) {
          // if connection refused, remove engine again
-         RemoveEngine(engine);
+         RemoveEngine(engine, kTRUE);
          return kFALSE;
       }
 
@@ -199,10 +201,7 @@ Bool_t THttpWSHandler::HandleWS(std::shared_ptr<THttpCallArg> &arg)
    if (arg->IsMethod("WS_CLOSE")) {
       // connection is closed, one can remove handle
 
-      if (engine) {
-         engine->ClearHandle();
-         RemoveEngine(engine);
-      }
+      RemoveEngine(engine);
 
       return ProcessWS(arg.get());
    }
@@ -227,8 +226,7 @@ void THttpWSHandler::CloseWS(UInt_t wsid)
 {
    auto engine = FindEngine(wsid);
 
-   if (engine)
-      RemoveEngine(engine);
+   RemoveEngine(engine, kTRUE);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -253,7 +251,7 @@ Int_t THttpWSHandler::RunSendingThrd(std::shared_ptr<THttpWSEngine> engine)
 
       Int_t sendcnt = fSendCnt, loopcnt(0);
 
-      while (!IsDisabled() && !engine->IsDisabled()) {
+      while (!IsDisabled() && !engine->fDisabled) {
          gSystem->ProcessEvents();
          // if send counter changed - current send operation is completed
          if (sendcnt != fSendCnt)