couchbase 4.4.1-dev.1 → 4.4.1

package/deps/couchbase-cxx-client/core/io/http_session_manager.hxx

@@ -17,7 +17,13 @@
 
 #pragma once
 
+#include <couchbase/build_config.hxx>
+
 #include "core/config_listener.hxx"
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+#include "core/columnar/bootstrap_notification_subscriber.hxx"
+#endif
+#include "core/logger/logger.hxx"
 #include "core/operations/http_noop.hxx"
 #include "core/service_type.hxx"
 #include "core/tracing/noop_tracer.hxx"
@@ -31,15 +37,24 @@
 
 #include <chrono>
 #include <optional>
+#include <queue>
 #include <random>
 
 namespace couchbase::core::io
 {
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+class http_session_manager
+  : public std::enable_shared_from_this<http_session_manager>
+  , public config_listener
+  , public columnar::bootstrap_notification_subscriber
+{
+#else
 class http_session_manager
   : public std::enable_shared_from_this<http_session_manager>
   , public config_listener
 {
+#endif
 public:
   http_session_manager(std::string client_id, asio::io_context& ctx, asio::ssl::context& tls)
     : client_id_(std::move(client_id))
@@ -64,20 +79,56 @@ public:
     return config_.capabilities;
   }
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  void notify_bootstrap_error(const impl::bootstrap_error& error) override
+  {
+    CB_LOG_DEBUG("Received bootstrap error notification. code={}, ec_message={}, message={}, "
+                 "allow_fast_fail={}.",
+                 error.ec.value(),
+                 error.ec.message(),
+                 error.error_message,
+                 allow_fast_fail_ ? "true" : "false");
+    if (allow_fast_fail_) {
+      std::scoped_lock bootstrap_error_lock(last_bootstrap_error_mutex_);
+      last_bootstrap_error_ = error;
+    }
+  }
+
+  void notify_bootstrap_success(const std::string& session_id) override
+  {
+    CB_LOG_DEBUG("Received successful bootstrap notification.  Session={}.", session_id);
+    std::scoped_lock bootstrap_error_lock(last_bootstrap_error_mutex_);
+    allow_fast_fail_ = false;
+    last_bootstrap_error_.reset();
+  }
+#endif
+
   void update_config(topology::configuration config) override
   {
-    std::scoped_lock config_lock(config_mutex_, sessions_mutex_);
-    config_ = std::move(config);
-    for (auto& [type, sessions] : idle_sessions_) {
-      sessions.remove_if([&opts = options_, &cfg = config_](const auto& session) {
-        return session && !cfg.has_node(opts.network,
-                                        session->type(),
-                                        opts.enable_tls,
-                                        session->hostname(),
-                                        session->port());
-      });
+    {
+      std::scoped_lock config_lock(config_mutex_, sessions_mutex_);
+      config_ = std::move(config);
+      for (auto& [type, sessions] : idle_sessions_) {
+        sessions.remove_if([&opts = options_, &cfg = config_](const auto& session) {
+          return session && !cfg.has_node(opts.network,
+                                          session->type(),
+                                          opts.enable_tls,
+                                          session->hostname(),
+                                          session->port());
+        });
+      }
     }
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    drain_deferred_queue({});
+#endif
+  }
+
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  void set_dispatch_timeout(const std::chrono::milliseconds timeout)
+  {
+    dispatch_timeout_ = timeout;
   }
+#endif
 
   void set_configuration(const topology::configuration& config, const cluster_options& options)
   {
@@ -88,10 +139,23 @@ public:
       std::uniform_int_distribution<std::size_t> dis(0, config.nodes.size() - 1);
       next_index = dis(gen);
     }
-    std::scoped_lock lock(config_mutex_, next_index_mutex_);
-    options_ = options;
-    next_index_ = next_index;
-    config_ = config;
+    {
+      std::scoped_lock lock(config_mutex_, next_index_mutex_);
+      options_ = options;
+      next_index_ = next_index;
+      config_ = config;
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+      if (!configured_) {
+        configured_ = true;
+      }
+      if (allow_fast_fail_) {
+        allow_fast_fail_ = false;
+      }
+#endif
+    }
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    drain_deferred_queue({});
+#endif
   }
 
   void export_diag_info(diag::diagnostics_result& res)
@@ -145,8 +209,19 @@ public:
           operations::http_noop_request request{};
           request.type = type;
           request.timeout = timeout;
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+          auto cmd = std::make_shared<operations::http_command<operations::http_noop_request>>(
+            ctx_,
+            request,
+            tracer_,
+            meter_,
+            options_.default_timeout_for(request.type),
+            dispatch_timeout_);
+#else
           auto cmd = std::make_shared<operations::http_command<operations::http_noop_request>>(
             ctx_, request, tracer_, meter_, options_.default_timeout_for(request.type));
+#endif
+
           cmd->start(
             [start = std::chrono::steady_clock::now(),
              self = shared_from_this(),
@@ -197,9 +272,17 @@ public:
 
   auto check_out(service_type type,
                  const couchbase::core::cluster_credentials& credentials,
-                 const std::string& preferred_node)
+                 std::string preferred_node,
+                 const std::string& undesired_node = {})
     -> std::pair<std::error_code, std::shared_ptr<http_session>>
   {
+    if (preferred_node.empty() && !undesired_node.empty()) {
+      auto [hostname, port] = pick_random_node(type, undesired_node);
+      if (port != 0) {
+        preferred_node = fmt::format("{}:{}", hostname, port);
+      }
+    }
+
     std::scoped_lock lock(sessions_mutex_);
     idle_sessions_[type].remove_if([](const auto& s) {
       return !s;
@@ -216,10 +299,15 @@ public:
           break;
         }
       } else {
+        auto [hostname, port] = split_host_port(preferred_node);
+
         auto ptr = std::find_if(idle_sessions_[type].begin(),
                                 idle_sessions_[type].end(),
-                                [preferred_node](const auto& s) {
-                                  return s->remote_address() == preferred_node;
+                                [&preferred_node, &h = hostname, &p = port](const auto& s) {
+                                  // Check for a match using both the unresolved hostname & IP
+                                  // address
+                                  return (s->remote_address() == preferred_node ||
+                                          (s->hostname() == h && s->port() == std::to_string(p)));
                                 });
         if (ptr != idle_sessions_[type].end()) {
           session = *ptr;
@@ -228,7 +316,6 @@ public:
             break;
           }
         } else {
-          auto [hostname, port] = split_host_port(preferred_node);
           session = create_session(type, credentials, hostname, port);
           break;
         }
@@ -256,6 +343,9 @@ public:
 
   void check_in(service_type type, std::shared_ptr<http_session> session)
   {
+    if (!session) {
+      return;
+    }
     if (!session->is_connected()) {
       CB_LOG_DEBUG("{} HTTP session never connected.  Skipping check-in", session->log_prefix());
       return session.reset();
@@ -285,6 +375,9 @@ public:
 
   void close()
   {
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    drain_deferred_queue(errc::common::request_canceled);
+#endif
     std::scoped_lock lock(sessions_mutex_);
     for (auto& [type, sessions] : idle_sessions_) {
       for (auto& s : sessions) {
@@ -302,6 +395,11 @@ public:
                Handler&& handler,
                const couchbase::core::cluster_credentials& credentials)
   {
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    if (!configured_) {
+      return defer_command(request, std::move(handler), credentials);
+    }
+#endif
     std::string preferred_node;
     if constexpr (http_traits::supports_sticky_node_v<Request>) {
       if (request.send_to_node) {
@@ -316,8 +414,18 @@ public:
       return handler(request.make_response(std::move(ctx), response_type{}));
     }
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    auto cmd = std::make_shared<operations::http_command<Request>>(
+      ctx_,
+      request,
+      tracer_,
+      meter_,
+      options_.default_timeout_for(request.type),
+      dispatch_timeout_);
+#else
     auto cmd = std::make_shared<operations::http_command<Request>>(
       ctx_, request, tracer_, meter_, options_.default_timeout_for(request.type));
+#endif
     cmd->start([self = shared_from_this(), cmd, handler = std::forward<Handler>(handler)](
                  std::error_code ec, io::http_response&& msg) mutable {
       using command_type = typename decltype(cmd)::element_type;
@@ -346,6 +454,113 @@ public:
     }
   }
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  void connect_then_send_pending_op(
+    std::shared_ptr<http_session> session,
+    const std::string& preferred_node,
+    std::chrono::time_point<std::chrono::steady_clock> dispatch_deadline,
+    std::chrono::time_point<std::chrono::steady_clock> deadline,
+    utils::movable_function<void(std::error_code, std::shared_ptr<http_session>)> callback)
+#else
+  void connect_then_send_pending_op(
+    std::shared_ptr<http_session> session,
+    const std::string& preferred_node,
+    std::chrono::time_point<std::chrono::steady_clock> deadline,
+    utils::movable_function<void(std::error_code, std::shared_ptr<http_session>)> callback)
+#endif
+  {
+    session->connect([self = shared_from_this(),
+                      session,
+                      preferred_node = std::move(preferred_node),
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+                      dispatch_deadline,
+#endif
+                      deadline,
+                      cb = std::move(callback)]() mutable {
+      if (!session->is_connected()) {
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+        auto now = std::chrono::steady_clock::now();
+        if (dispatch_deadline < now || deadline < now) {
+          session->stop();
+          return;
+        }
+#else
+        if (deadline < std::chrono::steady_clock::now()) {
+          session->stop();
+          return;
+        }
+#endif
+
+        // stop this session and create a new one w/ new hostname + port
+        session->stop();
+        auto [hostname, port] = preferred_node.empty()
+                                  ? self->next_node(session->type())
+                                  : self->lookup_node(session->type(), preferred_node);
+        if (port == 0) {
+          cb(errc::common::service_not_available, {});
+          return;
+        }
+        auto new_session =
+          self->create_session(session->type(), session->credentials(), hostname, port);
+        if (new_session->is_connected()) {
+          {
+            std::scoped_lock inner_lock(self->sessions_mutex_);
+            self->busy_sessions_[new_session->type()].push_back(new_session);
+          }
+          cb({}, new_session);
+        } else {
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+          self->connect_then_send_pending_op(
+            new_session, preferred_node, dispatch_deadline, deadline, cb);
+#else
+          self->connect_then_send_pending_op(new_session, preferred_node, deadline, cb);
+#endif
+        }
+      } else {
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+        auto now = std::chrono::steady_clock::now();
+        if (dispatch_deadline < now || deadline < now) {
+          session->stop();
+          return;
+        }
+#else
+        if (deadline < std::chrono::steady_clock::now()) {
+          session->stop();
+          return;
+        }
+#endif
+        {
+          std::scoped_lock inner_lock(self->sessions_mutex_);
+          self->busy_sessions_[session->type()].push_back(session);
+        }
+        cb({}, session);
+      }
+    });
+  }
+
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  void add_to_deferred_queue(utils::movable_function<void(std::error_code)> command)
+  {
+    const std::scoped_lock lock_for_deferred_commands(deferred_commands_mutex_);
+    deferred_commands_.emplace(std::move(command));
+  }
+
+  [[nodiscard]] auto dispatch_timeout() const -> std::chrono::milliseconds
+  {
+    return dispatch_timeout_;
+  }
+
+  [[nodiscard]] auto is_configured() const -> bool
+  {
+    return configured_;
+  }
+
+  [[nodiscard]] auto last_bootstrap_error() const -> std::optional<impl::bootstrap_error>
+  {
+    return last_bootstrap_error_;
+  }
+#endif
+
 private:
   template<typename Request>
   void connect_then_send(std::shared_ptr<http_session> session,
@@ -359,10 +574,18 @@ private:
                       preferred_node = std::move(preferred_node),
                       reuse_session]() mutable {
       if (!session->is_connected()) {
-        if (cmd->deadline_expired()) {
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+        auto now = std::chrono::steady_clock::now();
+        if (cmd->dispatch_deadline_expiry() < now || cmd->deadline_expiry() < now) {
+          // The http command will stop its session when the deadline expires.
+          return;
+        }
+#else
+        if (cmd->deadline_expiry() < std::chrono::steady_clock::now()) {
           // The http command will stop its session when the deadline expires.
           return;
         }
+#endif
         if (reuse_session) {
           return self->connect_then_send(session, cmd, preferred_node, reuse_session);
         }
@@ -432,6 +655,110 @@ private:
     return session;
   }
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  template<typename Request, typename Handler>
+  void defer_command(Request request,
+                     Handler&& handler,
+                     const couchbase::core::cluster_credentials& credentials)
+  {
+    {
+      std::scoped_lock bootstrap_error_lock(last_bootstrap_error_mutex_);
+      if (last_bootstrap_error_.has_value()) {
+        typename Request::error_context_type ctx{};
+        ctx.ec = last_bootstrap_error_.value().ec;
+        using response_type = typename Request::encoded_response_type;
+        return handler(request.make_response(std::move(ctx), response_type{}));
+      }
+    }
+    auto cmd = std::make_shared<operations::http_command<Request>>(
+      ctx_,
+      request,
+      tracer_,
+      meter_,
+      options_.default_timeout_for(request.type),
+      dispatch_timeout_);
+    cmd->start([self = shared_from_this(), cmd, handler = std::forward<Handler>(handler)](
+                 std::error_code ec, io::http_response&& msg) mutable {
+      using command_type = typename decltype(cmd)::element_type;
+      using encoded_response_type = typename command_type::encoded_response_type;
+      using error_context_type = typename command_type::error_context_type;
+      encoded_response_type resp{ std::move(msg) };
+      error_context_type ctx{};
+      if (self->last_bootstrap_error_.has_value() && ec == errc::common::unambiguous_timeout) {
+        CB_LOG_DEBUG("Timeout caused by bootstrap error. code={}, ec_message={}, message={}.",
+                     self->last_bootstrap_error_.value().ec.value(),
+                     self->last_bootstrap_error_.value().ec.message(),
+                     self->last_bootstrap_error_.value().error_message);
+        ctx.ec = self->last_bootstrap_error_.value().ec;
+      } else {
+        ctx.ec = ec;
+      }
+      ctx.client_context_id = cmd->client_context_id_;
+      ctx.method = cmd->encoded.method;
+      ctx.path = cmd->encoded.path;
+      ctx.http_status = resp.status_code;
+      ctx.http_body = resp.body.data();
+      if (cmd->session_) {
+        ctx.last_dispatched_from = cmd->session_->local_address();
+        ctx.last_dispatched_to = cmd->session_->remote_address();
+        ctx.hostname = cmd->session_->http_context().hostname;
+        ctx.port = cmd->session_->http_context().port;
+      }
+      handler(cmd->request.make_response(std::move(ctx), std::move(resp)));
+      self->check_in(cmd->request.type, cmd->session_);
+    });
+    CB_LOG_DEBUG(R"(Adding HTTP request to deferred queue: {}, client_context_id="{}")",
+                 cmd->request.type,
+                 cmd->client_context_id_);
+    add_to_deferred_queue(
+      [self = shared_from_this(), cmd, request, credentials](std::error_code ec) mutable {
+        if (ec) {
+          using response_type = typename Request::encoded_response_type;
+          return cmd->invoke_handler(ec, response_type{});
+        }
+
+        // don't do anything if the command wasn't dispatched or has already timed out
+        auto now = std::chrono::steady_clock::now();
+        if (cmd->dispatch_deadline_expiry() < now || cmd->deadline_expiry() < now) {
+          return;
+        }
+        std::string preferred_node;
+        if constexpr (http_traits::supports_sticky_node_v<Request>) {
+          if (request.send_to_node) {
+            preferred_node = *request.send_to_node;
+          }
+        }
+        auto [error, session] = self->check_out(request.type, credentials, preferred_node);
+        if (error) {
+          using response_type = typename Request::encoded_response_type;
+          return cmd->invoke_handler(error, response_type{});
+        }
+        cmd->set_command_session(session);
+        if (!session->is_connected()) {
+          self->connect_then_send(session, cmd, preferred_node);
+        } else {
+          cmd->send_to();
+        }
+      });
+  }
+
+  void drain_deferred_queue(std::error_code ec)
+  {
+    std::queue<utils::movable_function<void(std::error_code)>> commands{};
+    {
+      const std::scoped_lock lock(deferred_commands_mutex_);
+      std::swap(deferred_commands_, commands);
+    }
+    if (!commands.empty()) {
+      CB_LOG_TRACE("Draining deferred operation queue, size={}", commands.size());
+    }
+    while (!commands.empty()) {
+      commands.front()(ec);
+      commands.pop();
+    }
+  }
+#endif
+
   auto next_node(service_type type) -> std::pair<std::string, std::uint16_t>
   {
     std::scoped_lock lock(config_mutex_);
@@ -476,6 +803,36 @@ private:
     return { hostname, port };
   }
 
+  auto pick_random_node(service_type type,
+                        const std::string& undesired_node) -> std::pair<std::string, std::uint16_t>
+  {
+    std::vector<topology::configuration::node> candidate_nodes{};
+    {
+      const std::scoped_lock lock(config_mutex_);
+      std::copy_if(config_.nodes.begin(),
+                   config_.nodes.end(),
+                   std::back_inserter(candidate_nodes),
+                   [this, type, &undesired_node](const topology::configuration::node& node) {
+                     auto endpoint = node.endpoint(options_.network, type, options_.enable_tls);
+                     return endpoint.has_value() && (endpoint.value() != undesired_node);
+                   });
+    }
+
+    if (candidate_nodes.empty()) {
+      // Could not find any other nodes
+      return { "", static_cast<std::uint16_t>(0U) };
+    }
+
+    std::vector<topology::configuration::node> selected{};
+    std::sample(candidate_nodes.begin(),
+                candidate_nodes.end(),
+                std::back_inserter(selected),
+                1,
+                std::mt19937{ std::random_device{}() });
+    return { selected.at(0).hostname_for(options_.network),
+             selected.at(0).port_or(options_.network, type, options_.enable_tls, 0) };
+  }
+
   std::string client_id_;
   asio::io_context& ctx_;
   asio::ssl::context& tls_;
@@ -491,5 +848,14 @@ private:
   std::mutex next_index_mutex_{};
   std::mutex sessions_mutex_{};
   query_cache query_cache_{};
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  std::atomic_bool configured_{ false };
+  std::chrono::milliseconds dispatch_timeout_{};
+  std::atomic_bool allow_fast_fail_{ true };
+  std::queue<utils::movable_function<void(std::error_code)>> deferred_commands_{};
+  std::mutex deferred_commands_mutex_{};
+  std::optional<impl::bootstrap_error> last_bootstrap_error_;
+  std::mutex last_bootstrap_error_mutex_{};
+#endif
 };
 } // namespace couchbase::core::io

package/deps/couchbase-cxx-client/core/io/http_streaming_parser.cxx

@@ -0,0 +1,166 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "http_streaming_parser.hxx"
+
+#include <llhttp.h>
+
+#include <algorithm>
+#include <cctype>
+#include <memory>
+#include <utility>
+
+namespace
+{
+inline auto
+static_on_status(llhttp_t* parser, const char* at, std::size_t length) -> int
+{
+  auto* wrapper = static_cast<couchbase::core::io::http_streaming_parser*>(parser->data);
+  wrapper->status_message.assign(at, length);
+  wrapper->status_code = parser->status_code;
+  return 0;
+}
+
+inline auto
+static_on_header_field(llhttp_t* parser, const char* at, std::size_t length) -> int
+{
+  auto* wrapper = static_cast<couchbase::core::io::http_streaming_parser*>(parser->data);
+  wrapper->header_field.assign(at, length);
+  std::transform(wrapper->header_field.begin(),
+                 wrapper->header_field.end(),
+                 wrapper->header_field.begin(),
+                 [](unsigned char c) {
+                   return std::tolower(c);
+                 });
+  return 0;
+}
+
+inline auto
+static_on_header_value(llhttp_t* parser, const char* at, std::size_t length) -> int
+{
+  auto* wrapper = static_cast<couchbase::core::io::http_streaming_parser*>(parser->data);
+  wrapper->headers[wrapper->header_field] = std::string(at, length);
+  return 0;
+}
+
+inline auto
+static_on_headers_complete(llhttp_t* parser) -> int
+{
+  auto* wrapper = static_cast<couchbase::core::io::http_streaming_parser*>(parser->data);
+  wrapper->headers_complete = true;
+  return 0;
+}
+
+inline auto
+static_on_body(llhttp_t* parser, const char* at, std::size_t length) -> int
+{
+  auto* wrapper = static_cast<couchbase::core::io::http_streaming_parser*>(parser->data);
+  wrapper->body_chunk.append(std::string_view{ at, length });
+  return 0;
+}
+
+inline auto
+static_on_message_complete(llhttp_t* parser) -> int
+{
+  auto* wrapper = static_cast<couchbase::core::io::http_streaming_parser*>(parser->data);
+  wrapper->complete = true;
+  return 0;
+}
+} // namespace
+
+namespace couchbase::core::io
+{
+struct http_streaming_parser_state {
+  llhttp_settings_t settings{};
+  llhttp_t parser{};
+};
+
+http_streaming_parser::http_streaming_parser()
+{
+  state_ = std::make_shared<http_streaming_parser_state>();
+  llhttp_settings_init(&state_->settings);
+  state_->settings.on_status = static_on_status;
+  state_->settings.on_header_field = static_on_header_field;
+  state_->settings.on_header_value = static_on_header_value;
+  state_->settings.on_headers_complete = static_on_headers_complete;
+  state_->settings.on_body = static_on_body;
+  state_->settings.on_message_complete = static_on_message_complete;
+  llhttp_init(&state_->parser, HTTP_RESPONSE, &state_->settings);
+  state_->parser.data = this;
+}
+
+http_streaming_parser::http_streaming_parser(http_streaming_parser&& other) noexcept
+  : status_code{ other.status_code }
+  , status_message{ std::move(other.status_message) }
+  , headers{ std::move(other.headers) }
+  , body_chunk{ std::move(other.body_chunk) }
+  , header_field{ std::move(other.header_field) }
+  , headers_complete{ other.headers_complete }
+  , complete{ other.complete }
+{
+  if (state_) {
+    state_->parser.data = this;
+  }
+}
+
+auto
+http_streaming_parser::operator=(couchbase::core::io::http_streaming_parser&& other) noexcept
+  -> http_streaming_parser&
+{
+  status_code = other.status_code;
+  status_message = std::move(other.status_message);
+  headers = std::move(other.headers);
+  body_chunk = std::move(other.body_chunk);
+  header_field = std::move(other.header_field);
+  headers_complete = other.headers_complete;
+  complete = other.complete;
+  if (state_) {
+    state_->parser.data = this;
+  }
+  return *this;
+}
+
+void
+http_streaming_parser::reset()
+{
+  status_code = {};
+  status_message = {};
+  headers = {};
+  body_chunk = {};
+  header_field = {};
+  headers_complete = false;
+  complete = false;
+  llhttp_init(&state_->parser, HTTP_RESPONSE, &state_->settings);
+}
+
+auto
+http_streaming_parser::error_message() const -> const char*
+{
+  return llhttp_errno_name(llhttp_get_errno(&state_->parser));
+}
+
+auto
+http_streaming_parser::feed(const char* data,
+                            std::size_t data_len) const -> http_streaming_parser::feeding_result
+{
+  auto error = llhttp_execute(&state_->parser, data, data_len);
+  if (error != HPE_OK) {
+    return { true, complete, headers_complete, error_message() };
+  }
+  return { false, complete, headers_complete };
+}
+} // namespace couchbase::core::io