Curl keep alive

sdk/core/azure-core/inc/azure/core/http/curl_transport.hpp

@@ -13,6 +13,7 @@
 #include "azure/core/nullable.hpp"
 
 #include <chrono>
+#include <ctime>
 #include <memory>
 #include <string>
 
@@ -26,6 +27,32 @@ namespace Azure { namespace Core { namespace Http {
      *
      */
     constexpr std::chrono::milliseconds DefaultConnectionTimeout = std::chrono::minutes(5);
+
+    /**
+     * @brief The configuration options for the keep-alive feature.
+     *
+     * @remark The keep-alive feature allows the SDK to reuse the same connection to the service for
+     * multiple requests.
+     */
+    class KeepAliveOptions {
+    public:
+      /**
+       * @brief The time in seconds that the host will allow an idle connection to remain open
+       * before it is closed.
+       *
+       * @remark A connection is idle if no data is sent or received by a host. A host
+       * may keep an idle connection open for longer than timeout seconds, but the host should
+       * attempt to retain a connection for at least timeout seconds.
+       *
+       */
+      std::chrono::seconds ConnectionTimeout = std::chrono::seconds(0);
+
+      /**
+       * @brief The maximum number of requests that a host will allow over a single connection.
+       *
+       */
+      std::size_t MaxRequests = (size_t)0;
+    };
   } // namespace _detail
 
   /**
@@ -151,6 +178,15 @@ namespace Azure { namespace Core { namespace Http {
      */
     bool HttpKeepAlive = true;
 
+    /**
+     * @brief Options specified in the keep-alive request header
+     *
+     * @remark The keep-alive feature allows the SDK to reuse the same connection to the service for
+     * multiple requests. This field is populated if the Keep-Alive header is present in the
+     * request.
+     */
+    Azure::Nullable<Azure::Core::Http::_detail::KeepAliveOptions> KeepAliveOptions;
+
     /**
      * @brief This option determines whether libcurl verifies the authenticity of the peer's
      * certificate.

sdk/core/azure-core/src/http/curl/curl.cpp

@@ -2220,10 +2220,17 @@ std::unique_ptr<CurlNetworkConnection> CurlConnectionPool::ExtractOrCreateCurlCo
         {
           g_curlConnectionPool.ConnectionPoolIndex.erase(hostPoolIndex);
         }
-
-        Log::Write(Logger::Level::Verbose, LogMsgPrefix + "Re-using connection from the pool.");
-        // return connection ref
-        return connection;
+        if (!connection->IsExpired())
+        {
+          connection->IncreaseUsageCount();
+          Log::Write(Logger::Level::Verbose, LogMsgPrefix + "Re-using connection from the pool.");
+          // return connection ref
+          return connection;
+        }
+        else
+        {
+          Log::Write(Logger::Level::Verbose, LogMsgPrefix + "Connection expired. Discarding.");
+        } 
       }
     }
   }
@@ -2235,6 +2242,45 @@ std::unique_ptr<CurlNetworkConnection> CurlConnectionPool::ExtractOrCreateCurlCo
   return std::make_unique<CurlConnection>(request, options, hostDisplayName, connectionKey);
 }
 
+Azure::Core::Http::_detail::KeepAliveOptions CurlConnection::ParseKeepAliveHeader(
+    std::string const& keepAlive)
+{
+  Azure::Core::Http::_detail::KeepAliveOptions keepAliveOptions;
+  // Parse the Keep-Alive header to determine if the connection should be kept alive.
+  // The Keep-Alive header is in the format of:
+  // Keep-Alive: timeout=5, max=1000
+  // The timeout is the number of seconds the connection is allowed to be idle before it is closed.
+  // The max is the maximum number of requests that can be made on the connection before it is
+  // closed.
+  // If the header is not present, the connection will be kept alive for the lifetime of the
+  // application.
+  std::string const timeoutKey = "timeout=";
+  std::string const maxKey = "max=";
+  auto timeoutPos = keepAlive.find(timeoutKey);
+  auto maxPos = keepAlive.find(maxKey);
+  if (timeoutPos != std::string::npos)
+  {
+    auto timeoutEnd = keepAlive.find(',', timeoutPos);
+    if (timeoutEnd == std::string::npos)
+    {
+      timeoutEnd = keepAlive.size();
+    }
+    keepAliveOptions.ConnectionTimeout = std::chrono::seconds(std::stoi(keepAlive.substr(
+        timeoutPos + timeoutKey.size(), timeoutEnd - timeoutPos - timeoutKey.size())));
+  }
+  if (maxPos != std::string::npos)
+  {
+    auto maxEnd = keepAlive.find(',', maxPos);
+    if (maxEnd == std::string::npos)
+    {
+      maxEnd = keepAlive.size();
+    }
+    keepAliveOptions.MaxRequests
+        = std::stoi(keepAlive.substr(maxPos + maxKey.size(), maxEnd - maxPos - maxKey.size()));
+  }
+  return keepAliveOptions;
+}
+
 // Move the connection back to the connection pool. Push it to the front so it becomes the
 // first connection to be picked next time some one ask for a connection to the pool (LIFO)
 void CurlConnectionPool::MoveConnectionBackToPool(
@@ -2246,9 +2292,9 @@ void CurlConnectionPool::MoveConnectionBackToPool(
     return; // The server has asked us to not re-use this connection.
   }
 
-  if (connection->IsShutdown())
+  if (connection->IsShutdown() || connection->IsExpired())
   {
-    // Can't re-used a shut down connection
+    // Can't re-used a shut down connection or an expired connection
     return;
   }
 
@@ -2309,8 +2355,22 @@ CurlConnection::CurlConnection(
         _detail::DefaultFailedToGetNewConnectionTemplate + hostDisplayName + ". "
         + std::string("curl_easy_init returned Null"));
   }
+
   CURLcode result;
 
+  if (request.GetHeader("connection").HasValue() && request.GetHeader("keep-alive").HasValue())
+  {
+    auto connectionHeader = Azure::Core::_internal::StringExtensions::ToLower(
+        request.GetHeader("connection").Value());
+    auto keepAliveHeader = Azure::Core::_internal::StringExtensions::ToLower(
+        request.GetHeader("keep-alive").Value());
+
+    if (connectionHeader == "keep-alive")
+    {
+      m_keepAliveOptions = ParseKeepAliveHeader(keepAliveHeader);
+    }
+  }
+
   if (options.EnableCurlTracing)
   {
     if (!SetLibcurlOption(

sdk/core/azure-core/src/http/curl/curl_connection_private.hpp

@@ -134,6 +134,20 @@ namespace Azure { namespace Core {
        * @return `true` is the connection was shut it down; otherwise, `false`.
        */
       bool IsShutdown() const { return m_isShutDown; }
+
+      size_t m_usedCount = 0;
+      /**
+       * @brief Increase the usage count.
+       *
+       */
+      void IncreaseUsageCount() { m_usedCount++; };
+
+      /**
+       * @brief Get the connection usage count.
+       *
+       * @return The usage count
+       */
+      const size_t GetUsageCount() { return m_usedCount; }
     };
 
     /**
@@ -145,6 +159,7 @@ namespace Azure { namespace Core {
       Azure::Core::_internal::UniqueHandle<CURL> m_handle;
       curl_socket_t m_curlSocket;
       std::chrono::steady_clock::time_point m_lastUseTime;
+      std::chrono::steady_clock::time_point m_firstUseTime = std::chrono::steady_clock::now();
       std::string m_connectionKey;
       // CRL validation is disabled by default to be consistent with WinHTTP behavior
       bool m_enableCrlValidation{false};
@@ -161,6 +176,8 @@ namespace Azure { namespace Core {
       static int CurlSslCtxCallback(CURL* curl, void* sslctx, void* parm);
       int SslCtxCallback(CURL* curl, void* sslctx);
       int VerifyCertificateError(int ok, X509_STORE_CTX* storeContext);
+      Azure::Core::Http::_detail::KeepAliveOptions ParseKeepAliveHeader(std::string const& keepAlive);
+      Azure::Nullable<Azure::Core::Http::_detail::KeepAliveOptions> m_keepAliveOptions;
 
     public:
       /**
@@ -201,6 +218,23 @@ namespace Azure { namespace Core {
        */
       bool IsExpired() override
       {
+        // if we have keep alive options and we haven reached the max requests declare expired
+        if (m_keepAliveOptions.HasValue() && m_keepAliveOptions.Value().MaxRequests > 0
+            && m_keepAliveOptions.Value().MaxRequests > m_usedCount)
+        {
+          return true;
+        }
+
+        // if we have keep alive options and we have a connection timeout and the connection time
+        // frame has passed declare expired
+        if (m_keepAliveOptions.HasValue()
+            && m_keepAliveOptions.Value().ConnectionTimeout > std::chrono::seconds(0)
+            && m_firstUseTime + m_keepAliveOptions.Value().ConnectionTimeout
+                < std::chrono::steady_clock::now())
+        {
+          return true;
+        }
+
         auto connectionOnWaitingTimeMs = std::chrono::duration_cast<std::chrono::milliseconds>(
             std::chrono::steady_clock::now() - this->m_lastUseTime);
         return connectionOnWaitingTimeMs.count() >= _detail::DefaultConnectionExpiredMilliseconds;