[PSL-1229] pasteld: handle keep-alive connections (#260)

* [PSL-1229] pasteld: handle keep-alive connections

 pasteld v2.2.6
 Added separate class to keep information about HTTP Connection.
 Now requests coming from the existing keep-alive http connection create
 only HTTPRequest object without connection info.
 HTTPRequest object lifetime is now limited to http_request_cb callback.
 Save http connections only in unordered_map with client socket as a key (CHttpWorkerContext).
 - added accept error handler.
 - improved logging

 other changes:
  - returned c++20/gcc-11 changes for Linux
  - added Ctrl-C console handler for Windows to shutdown pasteld
  - improved shutdown when pasteld is still in initialization mode (added some checks to exit earlier)

* pasteld v2.2.6-beta2:

- fixed race condition on accepting new connections

* pasteld v2.2.6-beta3

Enhanced the synchronization and notification handling mechanisms in the CHttpWorkerContext class to prevent potential race conditions, ensure robust operation of the event loop, avoid indefinite waits that could lead to deadlocks, and handle potential failures of event_base_loopbreak.
Key Changes:
- Condition Variable Notifications:
Replaced m_LoopCond.notify_one() with m_LoopCond.notify_all() to ensure that all waiting threads are notified of changes to the event loop state.
This is critical in scenarios where multiple threads might be waiting for the same condition.

- Mutex Locking During Notification:
Ensured that m_LoopMutex is locked while calling m_LoopCond.notify_all().
This prevents race conditions by ensuring that notifications and state changes are properly synchronized.

- Timed Wait for Condition Variable:
Changed the indefinite wait on m_LoopCond.wait to a timed wait using m_LoopCond.wait_for.
This avoids the risk of threads waiting indefinitely, which can lead to deadlocks, and allows periodic checks for the event loop state and shutdown conditions.

- Handling Potential Failures of event_base_loopbreak:
Added logic to repeatedly call event_base_loopbreak in a loop to ensure that the event base loop actually exits, handling cases where event_base_loopbreak might fail on the first call.

Author: akobrin1

Makefile.am

@@ -126,6 +126,9 @@ analyze:
 test:
 	./qa/test-suite/full_test_suite.py $(filter-out $@,$(MAKECMDGOALS))
 
+dump:
+	objdump --disassemble src/pasteld | c++filt > pasteld_dump.txt
+
 .INTERMEDIATE: $(COVERAGE_INFO)
 
 DISTCHECK_CONFIGURE_FLAGS = --enable-man

configure.ac

@@ -3,7 +3,7 @@ AC_PREREQ([2.60])
 define(_CLIENT_VERSION_MAJOR, 2)
 define(_CLIENT_VERSION_MINOR, 2)
 define(_CLIENT_VERSION_REVISION, 6)
-define(_CLIENT_VERSION_BUILD, 0)
+define(_CLIENT_VERSION_BUILD, 2)
 define(_ZC_BUILD_VAL,
     m4_if(m4_eval(_CLIENT_VERSION_BUILD < 25), 1, m4_incr(_CLIENT_VERSION_BUILD),
         m4_eval(_CLIENT_VERSION_BUILD < 50), 1, 

src/clientversion.h

@@ -17,7 +17,7 @@
 #define CLIENT_VERSION_MAJOR 2
 #define CLIENT_VERSION_MINOR 2
 #define CLIENT_VERSION_REVISION 6
-#define CLIENT_VERSION_BUILD 0
+#define CLIENT_VERSION_BUILD 2
 
 //! Set to true for release, false for prerelease or test build
 #define CLIENT_VERSION_IS_RELEASE true

src/httpserver.cpp

@@ -12,6 +12,7 @@
 #include <thread>
 #include <functional>
 #include <atomic>
+#include <chrono>
 
 #include <compat.h>
 
@@ -44,6 +45,7 @@
 #endif
 
 using namespace std;
+using namespace std::chrono_literals;
 
 unique_ptr<CHTTPServer> gl_HttpServer;
 
@@ -719,6 +721,7 @@ CHttpWorkerContext::CHttpWorkerContext(const size_t nWorkerID) noexcept :
     m_base(nullptr),
     m_http(nullptr),
     m_bEvent(false),
+    m_bInEventLoop(false),
     m_nWorkerID(nWorkerID),
     CServiceThread(strprintf("httpevloop%zu", nWorkerID).c_str())
 {}
@@ -768,9 +771,29 @@ void CHttpWorkerContext::execute()
 {
     while (event_base_got_exit(m_base) == 0)
     {
+        {
+            unique_lock<mutex> lock(m_LoopMutex);
+            m_bInEventLoop = true;
+            m_LoopCond.notify_all();
+        }
+
         event_base_loop(m_base, EVLOOP_NO_EXIT_ON_EMPTY);
+
         if (event_base_got_break(m_base))
+        {
+            {
+                unique_lock<mutex> lock(m_LoopMutex);
+                m_bInEventLoop = false;
+                m_LoopCond.notify_all();
+            }
+
             WaitForEvent();
+        }
+    }
+    {
+        unique_lock<mutex> lock(m_LoopMutex);
+        m_bInEventLoop = false;
+        m_LoopCond.notify_all();
     }
     LogPrint("http", "[%s] event loop exiting\n", m_sLoopName);
 }
@@ -833,8 +856,19 @@ void CHttpWorkerContext::AddHttpConnection(http_connection_t &&pHttpConnection)
     }
 
     // break worker event loop to process new http connection
-    event_base_loopbreak(m_base);
-    this_thread::yield();
+    while (m_bInEventLoop && !shouldStop())
+    {
+        event_base_loopbreak(m_base);
+        unique_lock<mutex> lock(m_LoopMutex);
+        bool bRes = m_LoopCond.wait_for(lock, 100ms, [this] { return !m_bInEventLoop.load() || shouldStop(); });
+        if (bRes)
+			break;
+    }
+    if (shouldStop())
+    {
+        LogPrint("http", "[%s] Cannot process new HTTP connection - shutting down\n", m_sLoopName);
+        return;
+    }
     evhttp_get_request(m_http, clientSocket, &addr, addrlen);
 
     // notify the worker event loop that it can enter the event loop again

src/httpserver.h

@@ -182,6 +182,10 @@ class CHttpWorkerContext : public CServiceThread
     evhttp* m_http;      // HTTP server
     std::string m_sLoopName; // name of the event loop
     std::atomic_bool m_bEvent;
+    std::atomic_bool m_bInEventLoop;
+
+    CWaitableCriticalSection m_LoopMutex;
+    CConditionVariable m_LoopCond;
 
     CWaitableCriticalSection m_mutex;
     CConditionVariable m_cond;