couchbase 3.8.2 → 3.9.0

data/ext/couchbase/core/error_context/key_value.cxx

@@ -32,8 +32,31 @@ namespace couchbase::core
 auto
 make_key_value_error_context(std::error_code ec, const document_id& id) -> key_value_error_context
 {
-  return {
-    {}, ec, {}, {}, 0, {}, id.key(), id.bucket(), id.scope(), id.collection(), 0, {}, {}, {}, {},
+  return make_key_value_error_context(ec, id, 0, {});
+}
+
+auto
+make_key_value_error_context(std::error_code ec,
+                             const document_id& id,
+                             std::size_t retry_attempts,
+                             std::set<retry_reason> retry_reasons) -> key_value_error_context
+{
+  return key_value_error_context{
+    {},
+    ec,
+    {},
+    {},
+    retry_attempts,
+    std::move(retry_reasons),
+    id.key(),
+    id.bucket(),
+    id.scope(),
+    id.collection(),
+    0,
+    {},
+    {},
+    {},
+    {},
   };
 }
 

data/ext/couchbase/core/error_context/key_value.hxx

@@ -30,9 +30,43 @@
 
 namespace couchbase::core
 {
+/**
+ * Convenience overload that constructs a @ref key_value_error_context with zero retry attempts and
+ * an empty retry-reasons set.  Delegates to the four-argument overload.
+ *
+ * @param ec  Error code describing the failure.
+ * @param id  Document identifier carrying bucket/scope/collection/key.
+ * @return A fully initialised @ref key_value_error_context.
+ *
+ * @since 1.0.0
+ * @internal
+ */
 auto
 make_key_value_error_context(std::error_code ec, const document_id& id) -> key_value_error_context;
 
+/**
+ * Constructs a @ref key_value_error_context for a document-not-dispatched error path where the
+ * internal retry bookkeeping fields are available directly (e.g. from @ref queue_request), without
+ * requiring a Command/Response template instantiation.
+ *
+ * Fields that belong to the protocol exchange (opaque, status code, CAS, error-map info, extended
+ * error info, dispatched addresses) are left empty because no server response was received.
+ *
+ * @param ec          Error code describing the failure.
+ * @param id          Document identifier carrying bucket/scope/collection/key.
+ * @param retry_attempts Number of retry attempts already performed for the request.
+ * @param retry_reasons  Set of reasons recorded during those retry attempts.
+ * @return A fully initialised @ref key_value_error_context.
+ *
+ * @since 1.0.0
+ * @internal
+ */
+auto
+make_key_value_error_context(std::error_code ec,
+                             const document_id& id,
+                             std::size_t retry_attempts,
+                             std::set<retry_reason> retry_reasons) -> key_value_error_context;
+
 template<typename Command, typename Response>
 auto
 make_key_value_error_context(std::error_code ec,
@@ -58,43 +92,36 @@ make_key_value_error_context(std::error_code ec,
   auto retry_attempts = command->request.retries.retry_attempts();
   auto retry_reasons = command->request.retries.retry_reasons();
 
-  // Build node_id from the session that handled this request.
-  // The session carries the node_uuid (empty on pre-8.0 servers),
-  // canonical hostname, and port — we use these to construct the
-  // fallback identifier when nodeUUID is unavailable.
-  //
-  // Only construct a node_id once the session has actually been bound to a
-  // concrete node: either a non-empty UUID, or a non-empty canonical
-  // hostname *and* a non-zero canonical KV port. Otherwise the fallback
-  // hash of ("", "", 0) would yield a truthy-but-meaningless node_id and
-  // break the contract that a default-constructed node_id means "unknown".
+  // Build node_id from the session that handled this request. The session
+  // carries the node_uuid (empty on pre-8.0 servers), canonical hostname, and
+  // KV port — we feed these into internal_node_id::build, which preserves the
+  // "falsy = unknown" contract for not-yet-bound sessions by returning a
+  // default node_id when the (uuid, host, port) inputs are all empty/zero.
   couchbase::node_id dispatched_to_node_id{};
   if (command->session_) {
-    const auto& node_uuid = command->session_->node_uuid();
-    const auto& canonical_hostname = command->session_->canonical_hostname();
-    const auto canonical_port = command->session_->canonical_port_number();
-    if (!node_uuid.empty() || (!canonical_hostname.empty() && canonical_port != 0)) {
-      dispatched_to_node_id =
-        internal_node_id::build(node_uuid, canonical_hostname, canonical_port);
-    }
+    dispatched_to_node_id = internal_node_id::build(command->session_->node_uuid(),
+                                                    command->session_->canonical_hostname(),
+                                                    command->session_->canonical_port_number());
   }
 
-  return { command->id_,
-           ec,
-           command->last_dispatched_to_,
-           command->last_dispatched_from_,
-           retry_attempts,
-           std::move(retry_reasons),
-           std::move(dispatched_to_node_id),
-           key,
-           bucket,
-           scope,
-           collection,
-           opaque,
-           status,
-           response.cas(),
-           std::move(error_map_info),
-           response.error_info() };
+  return {
+    command->id(),
+    ec,
+    command->last_dispatched_to_,
+    command->last_dispatched_from_,
+    retry_attempts,
+    std::move(retry_reasons),
+    std::move(dispatched_to_node_id),
+    key,
+    bucket,
+    scope,
+    collection,
+    opaque,
+    status,
+    response.cas(),
+    std::move(error_map_info),
+    response.error_info(),
+  };
 }
 
 auto

data/ext/couchbase/core/error_context/key_value_error_context.hxx

@@ -83,21 +83,22 @@ public:
                           couchbase::cas cas,
                           std::optional<key_value_error_map_info> error_map_info,
                           std::optional<key_value_extended_error_info> extended_error_info)
-    : base_error_context{ std::move(operation_id),
-                          ec,
-                          std::move(last_dispatched_to),
-                          std::move(last_dispatched_from),
-                          retry_attempts,
-                          std::move(retry_reasons) }
-    , id_{ std::move(id) }
-    , bucket_{ std::move(bucket) }
-    , scope_{ std::move(scope) }
-    , collection_{ std::move(collection) }
-    , opaque_{ opaque }
-    , status_code_{ status_code }
-    , cas_{ cas }
-    , error_map_info_{ std::move(error_map_info) }
-    , extended_error_info_{ std::move(extended_error_info) }
+    : key_value_error_context{ std::move(operation_id),
+                               ec,
+                               std::move(last_dispatched_to),
+                               std::move(last_dispatched_from),
+                               retry_attempts,
+                               std::move(retry_reasons),
+                               couchbase::node_id{},
+                               std::move(id),
+                               std::move(bucket),
+                               std::move(scope),
+                               std::move(collection),
+                               opaque,
+                               status_code,
+                               cas,
+                               std::move(error_map_info),
+                               std::move(extended_error_info) }
   {
   }
 

data/ext/couchbase/core/error_context/search.hxx

@@ -35,6 +35,11 @@ struct search {
   std::string query{};
   std::optional<std::string> parameters{};
 
+  // The message the service reported, when it reported one. Over couchbase2 this is the gRPC
+  // status message, which is the only error detail that transport carries -- http_status and
+  // http_body stay empty there.
+  std::string first_error_message{};
+
   std::string method{};
   std::string path{};
   std::uint32_t http_status{};

data/ext/couchbase/core/error_context/search_json.hxx

@@ -48,6 +48,9 @@ struct traits<couchbase::core::error_context::search> {
     if (const auto& val = ctx.parameters; val.has_value()) {
       v["parameters"] = val.value();
     }
+    if (!ctx.first_error_message.empty()) {
+      v["first_error_message"] = ctx.first_error_message;
+    }
     if (const auto& reasons = ctx.retry_reasons; !reasons.empty()) {
       tao::json::value reasons_json = tao::json::empty_array;
       for (const auto& reason : reasons) {

data/ext/couchbase/core/error_context/subdocument_error_context.hxx

@@ -81,24 +81,25 @@ public:
                             std::optional<std::string> first_error_path,
                             std::optional<std::uint64_t> first_error_index,
                             bool deleted)
-    : key_value_error_context{ std::move(operation_id),
-                               ec,
-                               std::move(last_dispatched_to),
-                               std::move(last_dispatched_from),
-                               retry_attempts,
-                               std::move(retry_reasons),
-                               std::move(id),
-                               std::move(bucket),
-                               std::move(scope),
-                               std::move(collection),
-                               opaque,
-                               status_code,
-                               cas,
-                               std::move(error_map_info),
-                               std::move(extended_error_info) }
-    , first_error_path_{ std::move(first_error_path) }
-    , first_error_index_{ first_error_index }
-    , deleted_{ deleted }
+    : subdocument_error_context{ std::move(operation_id),
+                                 ec,
+                                 std::move(last_dispatched_to),
+                                 std::move(last_dispatched_from),
+                                 retry_attempts,
+                                 std::move(retry_reasons),
+                                 couchbase::node_id{},
+                                 std::move(id),
+                                 std::move(bucket),
+                                 std::move(scope),
+                                 std::move(collection),
+                                 opaque,
+                                 status_code,
+                                 cas,
+                                 std::move(error_map_info),
+                                 std::move(extended_error_info),
+                                 std::move(first_error_path),
+                                 first_error_index,
+                                 deleted }
   {
   }
 

data/ext/couchbase/core/error_context/view.hxx

@@ -36,6 +36,11 @@ struct view {
   std::string view_name{};
   std::vector<std::string> query_string{};
 
+  // The message the service reported, when it reported one. Over couchbase2 this is the gRPC
+  // status message, which is the only error detail that transport carries -- http_status and
+  // http_body stay empty there.
+  std::string first_error_message{};
+
   std::string method{};
   std::string path{};
   std::uint32_t http_status{};

data/ext/couchbase/core/free_form_http_request.cxx

@@ -19,16 +19,25 @@
 #include "io/http_streaming_response.hxx"
 #include "utils/movable_function.hxx"
 
+#include <couchbase/error_codes.hxx>
+
+#include <asio/io_context.hpp>
+#include <asio/steady_timer.hpp>
+
+#include <chrono>
+
 #include <cstddef>
 #include <cstdint>
 #include <memory>
+#include <mutex>
+#include <optional>
 #include <string>
 #include <system_error>
 #include <utility>
 
 namespace couchbase::core
 {
-class http_response_impl
+class http_response_impl : public std::enable_shared_from_this<http_response_impl>
 {
 public:
   http_response_impl() = default;
@@ -38,36 +47,222 @@ public:
   {
   }
 
+  http_response_impl(asio::io_context& io, std::string cached_data, std::size_t cached_chunk_size)
+    : cached_body_{ io::http_streaming_response_body{ io,
+                                                      nullptr,
+                                                      std::move(cached_data),
+                                                      true,
+                                                      cached_chunk_size } }
+  {
+  }
+
+  // Fault-injecting in-memory body (test seam): see http_response_body::create_in_memory_faulty.
+  http_response_impl(asio::io_context& io,
+                     std::string fault_data,
+                     std::size_t fault_chunk_size,
+                     std::error_code fault_terminal_ec,
+                     bool fault_stall)
+    : fault_deadline_{ std::make_shared<asio::steady_timer>(io) }
+    , fault_enabled_{ true }
+    , fault_data_{ std::move(fault_data) }
+    , fault_chunk_size_{ fault_chunk_size }
+    , fault_terminal_ec_{ fault_terminal_ec }
+    , fault_stall_{ fault_stall }
+  {
+  }
+
   [[nodiscard]] auto endpoint() const -> std::string
   {
-    return {};
+    if (cached_body_ || fault_enabled_) {
+      return {};
+    }
+    return streaming_resp_.dispatch_info().remote_address;
+  }
+
+  [[nodiscard]] auto dispatch_info() const -> io::http_dispatch_info
+  {
+    if (cached_body_ || fault_enabled_) {
+      return {};
+    }
+    return streaming_resp_.dispatch_info();
   }
 
   [[nodiscard]] auto status_code() const -> std::uint32_t
   {
+    if (cached_body_) {
+      return 200;
+    }
     return streaming_resp_.status_code();
   }
 
   [[nodiscard]] auto content_length() const -> std::size_t
   {
+    if (cached_body_) {
+      return 0;
+    }
     if (streaming_resp_.headers().find("content-length") == streaming_resp_.headers().end()) {
       return 0;
     }
     return std::stoul(streaming_resp_.headers().at("content-length"));
   }
 
-  void next_body(utils::movable_function<void(std::string, std::error_code)> callback)
+  void next_body(utils::movable_function<void(std::string, bool, std::error_code)> callback)
   {
+    if (fault_enabled_) {
+      // Handlers are invoked after the lock is dropped.
+      std::unique_lock<std::mutex> lock{ fault_mutex_ };
+      if (fault_cancelled_) {
+        const auto ec = fault_closed_ec_;
+        lock.unlock();
+        return callback({}, false, ec);
+      }
+      if (!fault_data_.empty()) {
+        std::string chunk;
+        if (fault_chunk_size_ == 0 || fault_data_.size() <= fault_chunk_size_) {
+          std::swap(chunk, fault_data_);
+        } else {
+          chunk = fault_data_.substr(0, fault_chunk_size_);
+          fault_data_.erase(0, fault_chunk_size_);
+        }
+        // has_more is always true here: whatever comes after the data (a stall, an injected
+        // terminal error, or a clean end) is delivered on a subsequent pull.
+        lock.unlock();
+        return callback(std::move(chunk), true, {});
+      }
+      if (fault_stall_) {
+        // Simulate a server that stopped sending mid-body: park the pull and never complete it
+        // until cancel() (close_body) or an expired deadline fires it.
+        fault_parked_ = std::move(callback);
+        return;
+      }
+      // Drained: no deadline is accepted from here on. The generation is bumped for the same
+      // reason close_body() bumps it -- cancel() does not stop a completion already queued -- so
+      // both drain paths supersede one identically rather than relying on fault_finished_ alone.
+      fault_finished_ = true;
+      ++fault_generation_;
+      fault_deadline_->cancel();
+      const auto ec = fault_terminal_ec_;
+      lock.unlock();
+      return callback({}, false, ec);
+    }
+    if (cached_body_) {
+      return cached_body_->next(std::move(callback));
+    }
     return streaming_resp_.body().next(std::move(callback));
   }
 
+  void cancel_body_deadline()
+  {
+    if (fault_enabled_) {
+      const std::scoped_lock lock{ fault_mutex_ };
+      ++fault_generation_;
+      fault_deadline_->cancel();
+      return;
+    }
+    if (cached_body_) {
+      return cached_body_->cancel_deadline();
+    }
+    return streaming_resp_.body().cancel_deadline();
+  }
+
+  auto set_body_deadline(std::chrono::time_point<std::chrono::steady_clock> deadline_tp,
+                         io::deadline_terminal on_expiry) -> io::deadline_state
+  {
+    if (fault_enabled_) {
+      const std::scoped_lock lock{ fault_mutex_ };
+      // A seam with no bytes left and no stall is terminal before the drain branch of next_body()
+      // has run. The real body answers body_already_ended in the same state -- reading_complete_
+      // with an empty cache -- and a seam that armed instead would hold the io_context open until
+      // it fired. fault_finished_ is recorded here, so a close_body() after this refusal keeps the
+      // configured terminal, as the real body refuses a close once drained.
+      if (fault_data_.empty() && !fault_stall_) {
+        fault_finished_ = true;
+      }
+      if (fault_cancelled_ || fault_finished_) {
+        return io::deadline_state::body_already_ended;
+      }
+      const auto generation = ++fault_generation_;
+      fault_deadline_->expires_at(deadline_tp);
+      fault_deadline_->async_wait([self = shared_from_this(), on_expiry, generation](auto ec) {
+        if (ec == asio::error::operation_aborted) {
+          return;
+        }
+        self->close_body_at_deadline(on_expiry, generation);
+      });
+      return io::deadline_state::armed;
+    }
+    if (cached_body_) {
+      return cached_body_->set_deadline(deadline_tp, on_expiry);
+    }
+    return streaming_resp_.body().set_deadline(deadline_tp, on_expiry);
+  }
+
+  void close_body_at_deadline(io::deadline_terminal on_expiry, std::uint64_t generation)
+  {
+    utils::movable_function<void(std::string, bool, std::error_code)> parked;
+    {
+      const std::scoped_lock lock{ fault_mutex_ };
+      // expires_at/cancel do not stop a completion already queued; ignore a superseded one.
+      if (generation != fault_generation_ || fault_cancelled_ || fault_finished_) {
+        return;
+      }
+      fault_cancelled_ = true;
+      fault_closed_ec_ = io::terminal_error_code(on_expiry);
+      fault_deadline_->cancel();
+      parked = std::move(fault_parked_);
+    }
+    if (parked) {
+      parked({}, false, io::terminal_error_code(on_expiry));
+    }
+  }
+
   void close_body()
   {
+    if (fault_enabled_) {
+      std::unique_lock<std::mutex> lock{ fault_mutex_ };
+      // First terminal wins, as in the real body. set_body_deadline() and
+      // close_body_at_deadline() test the same pair; a cancel arriving after the terminal path
+      // unlocked would otherwise change later pulls to request_canceled.
+      if (fault_cancelled_ || fault_finished_) {
+        return;
+      }
+      fault_cancelled_ = true;
+      ++fault_generation_;
+      fault_deadline_->cancel();
+      auto cb = std::move(fault_parked_);
+      const auto ec = fault_closed_ec_;
+      lock.unlock();
+      if (cb) {
+        cb({}, false, ec);
+      }
+      return;
+    }
+    if (cached_body_) {
+      return cached_body_->close();
+    }
     return streaming_resp_.body().close();
   }
 
 private:
   io::http_streaming_response streaming_resp_;
+  std::optional<io::http_streaming_response_body> cached_body_{};
+  // fault_mutex_ guards every fault_* member written after construction, including the timer:
+  // asio timers are not safe under concurrent use. fault_enabled_ is set once by the
+  // constructor and read unlocked. Only the fault seam owns a timer; the other bodies forward to an
+  // existing one.
+  mutable std::mutex fault_mutex_{};
+  std::shared_ptr<asio::steady_timer> fault_deadline_{};
+  // Fault-injection test seam (see the fault-injecting ctor and create_in_memory_faulty).
+  bool fault_enabled_{ false };
+  std::string fault_data_{};
+  std::size_t fault_chunk_size_{ 0 };
+  std::error_code fault_terminal_ec_{};
+  bool fault_stall_{ false };
+  bool fault_cancelled_{ false };
+  bool fault_finished_{ false };
+  std::uint64_t fault_generation_{ 0 };
+  std::error_code fault_closed_ec_{ errc::common::request_canceled };
+  utils::movable_function<void(std::string, bool, std::error_code)> fault_parked_{};
 };
 
 class buffered_http_response_impl
@@ -116,6 +311,11 @@ http_response::endpoint() const -> std::string
   return impl_->endpoint();
 }
 auto
+http_response::dispatch_info() const -> io::http_dispatch_info
+{
+  return impl_->dispatch_info();
+}
+auto
 http_response::status_code() const -> std::uint32_t
 {
   return impl_->status_code();
@@ -143,6 +343,39 @@ http_response_body::http_response_body(std::shared_ptr<http_response_impl> impl)
 {
 }
 
+auto
+http_response_body::create_in_memory(asio::io_context& io,
+                                     std::string data,
+                                     std::size_t cached_chunk_size) -> http_response_body
+{
+  return http_response_body{ std::make_shared<http_response_impl>(
+    io, std::move(data), cached_chunk_size) };
+}
+
+auto
+http_response_body::create_in_memory_faulty(asio::io_context& io,
+                                            std::string data,
+                                            std::size_t cached_chunk_size,
+                                            std::error_code terminal_ec,
+                                            bool stall) -> http_response_body
+{
+  return http_response_body{ std::make_shared<http_response_impl>(
+    io, std::move(data), cached_chunk_size, terminal_ec, stall) };
+}
+
+auto
+http_response_body::set_deadline(std::chrono::time_point<std::chrono::steady_clock> deadline_tp,
+                                 io::deadline_terminal on_expiry) -> io::deadline_state
+{
+  return impl_->set_body_deadline(deadline_tp, on_expiry);
+}
+
+void
+http_response_body::cancel_deadline()
+{
+  return impl_->cancel_body_deadline();
+}
+
 void
 http_response_body::cancel()
 {
@@ -150,7 +383,7 @@ http_response_body::cancel()
 }
 
 void
-http_response_body::next(utils::movable_function<void(std::string, std::error_code)> callback)
+http_response_body::next(utils::movable_function<void(std::string, bool, std::error_code)> callback)
 {
   return impl_->next_body(std::move(callback));
 }

data/ext/couchbase/core/free_form_http_request.hxx

@@ -15,14 +15,14 @@
 
 #pragma once
 
-#include <couchbase/build_config.hxx>
-
 #include "core/impl/bootstrap_error.hxx"
+#include "core/io/http_streaming_response.hxx"
 #include "service_type.hxx"
 #include "utils/movable_function.hxx"
 
 #include <chrono>
 #include <cinttypes>
+#include <cstddef>
 #include <map>
 #include <memory>
 #include <optional>
@@ -30,6 +30,11 @@
 #include <system_error>
 #include <vector>
 
+namespace asio
+{
+class io_context;
+} // namespace asio
+
 namespace couchbase
 {
 class retry_strategy;
@@ -78,9 +83,39 @@ class http_response_body
 public:
   explicit http_response_body(std::shared_ptr<http_response_impl> impl);
 
-  void next(utils::movable_function<void(std::string, std::error_code)> callback);
+  // cached_chunk_size > 0 makes the in-memory body deliver at most that many bytes per next()
+  // call (a test seam simulating a socket that dribbles the response out, so back-pressure can be
+  // exercised); 0 delivers the whole body in one chunk.
+  static auto create_in_memory(asio::io_context& io,
+                               std::string data,
+                               std::size_t cached_chunk_size = 0) -> http_response_body;
+
+  // Test-only fault-injection seam extending create_in_memory. The body first hands out `data` (in
+  // cached_chunk_size-byte slices, 0 = all at once), then once that is drained:
+  //   * if `stall` is true, the next pull never completes until cancel() or an expired deadline
+  //     fires it, delivering request_canceled or the deadline's error respectively — this is how
+  //     the row_streamer idle timer (and its read-only-aware timeout classification) is exercised
+  //     deterministically; otherwise
+  //   * the next pull's terminal carries `terminal_ec` (a simulated mid-stream transport error).
+  static auto create_in_memory_faulty(asio::io_context& io,
+                                      std::string data,
+                                      std::size_t cached_chunk_size,
+                                      std::error_code terminal_ec,
+                                      bool stall) -> http_response_body;
+
+  // See io::http_streaming_response_body::next: the bool is `has_more` (false marks end-of-stream).
+  // An empty data string with has_more==true is a valid mid-stream chunk, not the terminal.
+  void next(utils::movable_function<void(std::string, bool, std::error_code)> callback);
   void cancel();
 
+  // Closes the body with `on_expiry` at `deadline_tp`, whether or not a pull is outstanding.
+  // Optional.
+  [[nodiscard]] auto set_deadline(std::chrono::time_point<std::chrono::steady_clock> deadline_tp,
+                                  io::deadline_terminal on_expiry) -> io::deadline_state;
+  // See io::http_streaming_response_body::cancel_deadline: supersedes an armed deadline without
+  // ending the body.
+  void cancel_deadline();
+
 private:
   std::shared_ptr<http_response_impl> impl_;
 };
@@ -92,6 +127,9 @@ public:
   explicit http_response(io::http_streaming_response resp);
 
   [[nodiscard]] auto endpoint() const -> std::string;
+  // Where this response was dispatched. Empty for the in-memory/fault test bodies, which have no
+  // session behind them.
+  [[nodiscard]] auto dispatch_info() const -> io::http_dispatch_info;
   [[nodiscard]] auto status_code() const -> std::uint32_t;
   [[nodiscard]] auto content_length() const -> std::size_t;
 
@@ -102,13 +140,8 @@ private:
   std::shared_ptr<http_response_impl> impl_;
 };
 
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-using free_form_http_request_callback =
-  utils::movable_function<void(http_response response, couchbase::core::error_union err)>;
-#else
 using free_form_http_request_callback =
   utils::movable_function<void(http_response response, std::error_code ec)>;
-#endif
 
 class buffered_http_response_impl;