Alternate timeout method.

kinyoklion · kinyoklion · commit fd469e040818 · 2025-10-17T18:04:13.000-07:00
diff --git a/libs/internal/src/network/curl_requester.cpp b/libs/internal/src/network/curl_requester.cpp
@@ -225,13 +225,19 @@ void CurlRequester::PerformRequestWithMulti(std::shared_ptr<CurlMultiManager> mu
 
     // Add handle to multi manager for async processing
     // Headers will be freed automatically by CurlMultiManager
-    multi_manager->add_handle(curl, headers, [ctx](std::shared_ptr<CURL> easy, CURLcode result) {
+    multi_manager->add_handle(curl, headers, [ctx](std::shared_ptr<CURL> easy, CurlMultiManager::Result result) {
         // This callback runs on the executor when the request completes
 
+        // Handle read timeout (shouldn't happen for regular requests, but handle it anyway)
+        if (result.type == CurlMultiManager::Result::Type::ReadTimeout) {
+            ctx->callback(HttpResult("Request timed out"));
+            return;
+        }
+
         // Check for errors
-        if (result != CURLE_OK) {
+        if (result.curl_code != CURLE_OK) {
             std::string error_message = kErrorCurlPrefix;
-            error_message += curl_easy_strerror(result);
+            error_message += curl_easy_strerror(result.curl_code);
             ctx->callback(HttpResult(error_message));
             return;
         }
diff --git a/libs/networking/include/launchdarkly/network/curl_multi_manager.hpp b/libs/networking/include/launchdarkly/network/curl_multi_manager.hpp
@@ -11,6 +11,7 @@
 #include <map>
 #include <memory>
 #include <mutex>
+#include <optional>
 
 namespace launchdarkly::network {
 
@@ -33,11 +34,32 @@ using SocketHandle = boost::asio::ip::tcp::socket;
  */
 class CurlMultiManager : public std::enable_shared_from_this<CurlMultiManager> {
 public:
+    /**
+     * Result of a CURL operation - either CURLcode or read timeout.
+     */
+    struct Result {
+        enum class Type {
+            CurlCode,
+            ReadTimeout
+        };
+
+        Type type;
+        CURLcode curl_code;  // Only valid if type == CurlCode
+
+        static Result FromCurlCode(CURLcode code) {
+            return Result{Type::CurlCode, code};
+        }
+
+        static Result FromReadTimeout() {
+            return Result{Type::ReadTimeout, CURLE_OK};
+        }
+    };
+
     /**
      * Callback invoked when an easy handle completes (success or error).
-     * Parameters: CURL* easy handle, CURLcode result
+     * Parameters: CURL* easy handle, Result
      */
-    using CompletionCallback = std::function<void(std::shared_ptr<CURL>, CURLcode)>;
+    using CompletionCallback = std::function<void(std::shared_ptr<CURL>, Result)>;
 
     /**
      * Create a CurlMultiManager on the given executor.
@@ -59,10 +81,12 @@ class CurlMultiManager : public std::enable_shared_from_this<CurlMultiManager> {
      * @param easy The CURL easy handle (must be configured)
      * @param headers The curl_slist headers (will be freed automatically)
      * @param callback Called when the transfer completes
+     * @param read_timeout Optional read timeout duration
      */
     void add_handle(const std::shared_ptr<CURL>& easy,
                     curl_slist* headers,
-                    CompletionCallback callback);
+                    CompletionCallback callback,
+                    std::optional<std::chrono::milliseconds> read_timeout = std::nullopt);
 
 private:
     explicit CurlMultiManager(boost::asio::any_io_executor executor);
@@ -86,6 +110,9 @@ class CurlMultiManager : public std::enable_shared_from_this<CurlMultiManager> {
     // Check for completed transfers
     void check_multi_info();
 
+    // Handle read timeout for a specific handle
+    void handle_read_timeout(CURL* easy);
+
     // Per-socket data
     struct SocketInfo {
         curl_socket_t sockfd;
@@ -98,6 +125,15 @@ class CurlMultiManager : public std::enable_shared_from_this<CurlMultiManager> {
 
     void start_socket_monitor(SocketInfo* socket_info, int action);
 
+    // Reset read timeout timer for a handle
+    void reset_read_timeout(CURL* easy);
+
+    // Per-handle read timeout data
+    struct HandleTimeoutInfo {
+        std::optional<std::chrono::milliseconds> timeout_duration;
+        std::shared_ptr<boost::asio::steady_timer> timer;
+    };
+
     boost::asio::any_io_executor executor_;
     // CURLM* multi_handle_;
     std::unique_ptr<CURLM, decltype(&curl_multi_cleanup)> multi_handle_;
@@ -107,6 +143,7 @@ class CurlMultiManager : public std::enable_shared_from_this<CurlMultiManager> {
     std::map<CURL*, CompletionCallback> callbacks_;
     std::map<CURL*, curl_slist*> headers_;
     std::map<CURL*, std::shared_ptr<CURL>> handles_;
+    std::map<CURL*, HandleTimeoutInfo> handle_timeouts_;
     std::map<curl_socket_t, SocketInfo> sockets_; // Managed socket info
     int still_running_{0};
 };
diff --git a/libs/networking/src/curl_multi_manager.cpp b/libs/networking/src/curl_multi_manager.cpp
@@ -48,7 +48,8 @@ CurlMultiManager::~CurlMultiManager() {
 
 void CurlMultiManager::add_handle(const std::shared_ptr<CURL>& easy,
                                   curl_slist* headers,
-                                  CompletionCallback callback) {
+                                  CompletionCallback callback,
+                                  std::optional<std::chrono::milliseconds> read_timeout) {
     if (const CURLMcode rc = curl_multi_add_handle(
             multi_handle_.get(), easy.get());
         rc != CURLM_OK) {
@@ -67,6 +68,24 @@ void CurlMultiManager::add_handle(const std::shared_ptr<CURL>& easy,
         callbacks_[easy.get()] = std::move(callback);
         headers_[easy.get()] = headers;
         handles_[easy.get()] = easy;
+
+        // Setup read timeout timer if specified
+        if (read_timeout) {
+            auto timer = std::make_shared<boost::asio::steady_timer>(executor_);
+            handle_timeouts_[easy.get()] = HandleTimeoutInfo{read_timeout, timer};
+
+            // Start the timeout timer
+            timer->expires_after(*read_timeout);
+            auto weak_self = weak_from_this();
+            CURL* easy_ptr = easy.get();
+            timer->async_wait([weak_self, easy_ptr](const boost::system::error_code& ec) {
+                if (!ec) {
+                    if (auto self = weak_self.lock()) {
+                        self->handle_read_timeout(easy_ptr);
+                    }
+                }
+            });
+        }
     }
 }
 
@@ -79,6 +98,9 @@ int CurlMultiManager::socket_callback(CURL* easy,
 
     std::lock_guard lock(manager->mutex_);
 
+    // Reset read timeout on any socket activity
+    manager->reset_read_timeout(easy);
+
     if (what == CURL_POLL_REMOVE) {
         // Remove socket from managed container
         if (const auto it = manager->sockets_.find(s);
@@ -177,6 +199,13 @@ void CurlMultiManager::check_multi_info() {
                     headers = header_it->second;
                     headers_.erase(header_it);
                 }
+
+                // Cancel and remove timeout timer
+                if (auto timeout_it = handle_timeouts_.find(easy);
+                    timeout_it != handle_timeouts_.end()) {
+                    timeout_it->second.timer->cancel();
+                    handle_timeouts_.erase(timeout_it);
+                }
             }
 
             // Remove from multi handle
@@ -197,7 +226,7 @@ void CurlMultiManager::check_multi_info() {
             if (callback) {
                 boost::asio::post(executor_, [callback = std::move(callback),
                                       result, handle]() {
-                                      callback(handle, result);
+                                      callback(handle, Result::FromCurlCode(result));
                                   });
             }
         }
@@ -243,7 +272,7 @@ void CurlMultiManager::start_socket_monitor(SocketInfo* socket_info,
             // Use weak_ptr in capture to avoid circular reference
             socket_info->read_handler = std::make_shared<std::function<void
                 ()>>();
-            std::weak_ptr<std::function<void()>> weak_read_handler = socket_info
+            std::weak_ptr weak_read_handler = socket_info
                 ->read_handler;
             *socket_info->read_handler = [weak_self, sockfd, weak_handle,
                     weak_read_handler]() {
@@ -328,6 +357,83 @@ void CurlMultiManager::start_socket_monitor(SocketInfo* socket_info,
         }
     }
 }
+
+void CurlMultiManager::reset_read_timeout(CURL* easy) {
+    // Must be called with mutex_ locked
+    auto timeout_it = handle_timeouts_.find(easy);
+    if (timeout_it != handle_timeouts_.end() && timeout_it->second.timer) {
+        auto& timeout_info = timeout_it->second;
+        timeout_info.timer->cancel();
+        timeout_info.timer->expires_after(*timeout_info.timeout_duration);
+
+        auto weak_self = weak_from_this();
+        CURL* easy_ptr = easy;
+        timeout_info.timer->async_wait([weak_self, easy_ptr](const boost::system::error_code& ec) {
+            if (!ec) {
+                if (auto self = weak_self.lock()) {
+                    self->handle_read_timeout(easy_ptr);
+                }
+            }
+        });
+    }
+}
+
+void CurlMultiManager::handle_read_timeout(CURL* easy) {
+    CompletionCallback callback;
+    curl_slist* headers = nullptr;
+    std::shared_ptr<CURL> handle;
+
+    {
+        std::lock_guard lock(mutex_);
+
+        // Check if handle still exists
+        auto it = callbacks_.find(easy);
+        if (it == callbacks_.end()) {
+            return;  // Handle already completed
+        }
+
+        // Get and remove callback
+        callback = std::move(it->second);
+        callbacks_.erase(it);
+
+        // Get and remove headers
+        if (auto header_it = headers_.find(easy);
+            header_it != headers_.end()) {
+            headers = header_it->second;
+            headers_.erase(header_it);
+        }
+
+        // Get and remove handle
+        if (auto handle_it = handles_.find(easy);
+            handle_it != handles_.end()) {
+            handle = handle_it->second;
+            handles_.erase(handle_it);
+        }
+
+        // Remove timeout info
+        if (auto timeout_it = handle_timeouts_.find(easy);
+            timeout_it != handle_timeouts_.end()) {
+            timeout_it->second.timer->cancel();
+            handle_timeouts_.erase(timeout_it);
+        }
+    }
+
+    // Remove from multi handle
+    curl_multi_remove_handle(multi_handle_.get(), easy);
+
+    // Free headers
+    if (headers) {
+        curl_slist_free_all(headers);
+    }
+
+    // Invoke completion callback with read timeout result
+    if (callback) {
+        boost::asio::post(executor_, [callback = std::move(callback),
+                                      handle]() {
+                                      callback(handle, Result::FromReadTimeout());
+                                  });
+    }
+}
 } // namespace launchdarkly::network
 
 #endif  // LD_CURL_NETWORKING
diff --git a/libs/server-sent-events/src/curl_client.cpp b/libs/server-sent-events/src/curl_client.cpp
@@ -441,12 +441,24 @@ void CurlClient::PerformRequestWithMulti(
     // Add handle to multi manager for async processing
     // Headers will be freed automatically by CurlMultiManager
     std::weak_ptr<RequestContext> weak_context = context;
-    multi_manager->add_handle(curl, headers, [weak_context](std::shared_ptr<CURL> easy, CURLcode res) {
+    multi_manager->add_handle(curl, headers, [weak_context](std::shared_ptr<CURL> easy, CurlMultiManager::Result result) {
         auto context = weak_context.lock();
         if (!context) {
             return;
         }
 
+        // Check if this was a read timeout from the multi manager
+        if (result.type == CurlMultiManager::Result::Type::ReadTimeout) {
+            if (!context->is_shutting_down()) {
+                context->error(errors::ReadTimeout{context->read_timeout});
+                context->backoff("read timeout - no data received");
+            }
+            return;
+        }
+
+        // Handle CURLcode result
+        CURLcode res = result.curl_code;
+
         // Get response code
         long response_code = 0;
         curl_easy_getinfo(easy.get(), CURLINFO_RESPONSE_CODE, &response_code);
@@ -524,7 +536,7 @@ void CurlClient::PerformRequestWithMulti(
             ss << "HTTP status " << static_cast<int>(status);
             context->backoff(ss.str());
         }
-    });
+    }, context->read_timeout);
 }
 
 void CurlClient::async_shutdown(std::function<void()> completion) {
