couchbase 3.5.1 → 3.5.2

data/ext/couchbase/core/operations/document_decrement.cxx

@@ -22,32 +22,35 @@
 
 namespace couchbase::core::operations
 {
-std::error_code
-decrement_request::encode_to(decrement_request::encoded_request_type& encoded, mcbp_context&& /* context */) const
+auto
+decrement_request::encode_to(decrement_request::encoded_request_type& encoded,
+                             mcbp_context&& /* context */) const -> std::error_code
 {
-    encoded.opaque(opaque);
-    encoded.partition(partition);
-    encoded.body().id(id);
-    encoded.body().delta(delta);
-    if (initial_value) {
-        encoded.body().initial_value(initial_value.value());
-        encoded.body().expiry(expiry);
-    } else {
-        encoded.body().initial_value(0);
-        encoded.body().expiry(0xffff'ffff);
-    }
-    return {};
+  encoded.opaque(opaque);
+  encoded.partition(partition);
+  encoded.body().id(id);
+  encoded.body().delta(delta);
+  if (initial_value) {
+    encoded.body().initial_value(initial_value.value());
+    encoded.body().expiry(expiry);
+  } else {
+    encoded.body().initial_value(0);
+    encoded.body().expiry(0xffff'ffff);
+  }
+  return {};
 }
 
-decrement_response
-decrement_request::make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const
+auto
+decrement_request::make_response(key_value_error_context&& ctx,
+                                 const encoded_response_type& encoded) const -> decrement_response
 {
-    decrement_response response{ std::move(ctx) };
-    if (!response.ctx.ec()) {
-        response.cas = encoded.cas();
-        response.content = encoded.body().content();
-        response.token = couchbase::utils::build_mutation_token(encoded.body().token(), partition, response.ctx.bucket());
-    }
-    return response;
+  decrement_response response{ std::move(ctx) };
+  if (!response.ctx.ec()) {
+    response.cas = encoded.cas();
+    response.content = encoded.body().content();
+    response.token = couchbase::utils::build_mutation_token(
+      encoded.body().token(), partition, response.ctx.bucket());
+  }
+  return response;
 }
 } // namespace couchbase::core::operations

data/ext/couchbase/core/operations/document_decrement.hxx

@@ -34,31 +34,34 @@ namespace couchbase::core::operations
 {
 
 struct decrement_response {
-    key_value_error_context ctx;
-    std::uint64_t content{};
-    couchbase::cas cas{};
-    mutation_token token{};
+  key_value_error_context ctx;
+  std::uint64_t content{};
+  couchbase::cas cas{};
+  mutation_token token{};
 };
 
 struct decrement_request {
-    using response_type = decrement_response;
-    using encoded_request_type = protocol::client_request<protocol::decrement_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::decrement_response_body>;
+  using response_type = decrement_response;
+  using encoded_request_type = protocol::client_request<protocol::decrement_request_body>;
+  using encoded_response_type = protocol::client_response<protocol::decrement_response_body>;
 
-    document_id id;
-    std::uint16_t partition{};
-    std::uint32_t opaque{};
-    std::uint32_t expiry{ 0 };
-    std::uint64_t delta{ 1 };
-    std::optional<std::uint64_t> initial_value{};
-    couchbase::durability_level durability_level{ durability_level::none };
-    std::optional<std::chrono::milliseconds> timeout{};
-    io::retry_context<false> retries{};
-    std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
+  document_id id;
+  std::uint16_t partition{};
+  std::uint32_t opaque{};
+  std::uint32_t expiry{ 0 };
+  std::uint64_t delta{ 1 };
+  std::optional<std::uint64_t> initial_value{};
+  couchbase::durability_level durability_level{ durability_level::none };
+  std::optional<std::chrono::milliseconds> timeout{};
+  io::retry_context<false> retries{};
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context) const;
+  [[nodiscard]] auto encode_to(encoded_request_type& encoded,
+                               mcbp_context&& context) const -> std::error_code;
 
-    [[nodiscard]] decrement_response make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] auto make_response(key_value_error_context&& ctx,
+                                   const encoded_response_type& encoded) const
+    -> decrement_response;
 };
 
 using decrement_request_with_legacy_durability = impl::with_legacy_durability<decrement_request>;
@@ -76,6 +79,7 @@ struct supports_durability<couchbase::core::operations::decrement_request> : pub
 };
 
 template<>
-struct supports_parent_span<couchbase::core::operations::decrement_request> : public std::true_type {
+struct supports_parent_span<couchbase::core::operations::decrement_request>
+  : public std::true_type {
 };
 } // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_exists.cxx

@@ -21,30 +21,32 @@
 
 namespace couchbase::core::operations
 {
-std::error_code
-exists_request::encode_to(exists_request::encoded_request_type& encoded, mcbp_context&& /* context */) const
+auto
+exists_request::encode_to(exists_request::encoded_request_type& encoded,
+                          mcbp_context&& /* context */) const -> std::error_code
 {
-    encoded.opaque(opaque);
-    encoded.partition(partition);
-    encoded.body().id(id);
-    return {};
+  encoded.opaque(opaque);
+  encoded.partition(partition);
+  encoded.body().id(id);
+  return {};
 }
 
-exists_response
-exists_request::make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const
+auto
+exists_request::make_response(key_value_error_context&& ctx,
+                              const encoded_response_type& encoded) const -> exists_response
 {
-    exists_response response{ std::move(ctx) };
-    if (!response.ctx.ec()) {
-        response.cas = encoded.cas();
-        response.deleted = encoded.body().is_deleted();
-        response.flags = encoded.body().flags();
-        response.expiry = encoded.body().expiry();
-        response.sequence_number = encoded.body().sequence_number();
-        response.datatype = encoded.body().datatype();
-        response.document_exists = !response.deleted;
-    } else if (response.ctx.ec() == errc::key_value::document_not_found) {
-        response.ctx.override_ec({});
-    }
-    return response;
+  exists_response response{ std::move(ctx) };
+  if (!response.ctx.ec()) {
+    response.cas = encoded.cas();
+    response.deleted = encoded.body().is_deleted();
+    response.flags = encoded.body().flags();
+    response.expiry = encoded.body().expiry();
+    response.sequence_number = encoded.body().sequence_number();
+    response.datatype = encoded.body().datatype();
+    response.document_exists = !response.deleted;
+  } else if (response.ctx.ec() == errc::key_value::document_not_found) {
+    response.ctx.override_ec({});
+  }
+  return response;
 }
 } // namespace couchbase::core::operations

data/ext/couchbase/core/operations/document_exists.hxx

@@ -30,36 +30,38 @@ namespace couchbase::core::operations
 {
 
 struct exists_response {
-    key_value_error_context ctx;
-    bool deleted{};
-    couchbase::cas cas{};
-    std::uint32_t flags{};
-    std::uint32_t expiry{};
-    std::uint64_t sequence_number{};
-    std::uint8_t datatype{};
-    bool document_exists{ false };
+  key_value_error_context ctx;
+  bool deleted{};
+  couchbase::cas cas{};
+  std::uint32_t flags{};
+  std::uint32_t expiry{};
+  std::uint64_t sequence_number{};
+  std::uint8_t datatype{};
+  bool document_exists{ false };
 
-    [[nodiscard]] inline bool exists() const
-    {
-        return document_exists;
-    }
+  [[nodiscard]] inline auto exists() const -> bool
+  {
+    return document_exists;
+  }
 };
 
 struct exists_request {
-    using response_type = exists_response;
-    using encoded_request_type = protocol::client_request<protocol::get_meta_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::get_meta_response_body>;
+  using response_type = exists_response;
+  using encoded_request_type = protocol::client_request<protocol::get_meta_request_body>;
+  using encoded_response_type = protocol::client_response<protocol::get_meta_response_body>;
 
-    document_id id;
-    std::uint16_t partition{};
-    std::uint32_t opaque{};
-    std::optional<std::chrono::milliseconds> timeout{};
-    io::retry_context<false> retries{};
-    std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
+  document_id id;
+  std::uint16_t partition{};
+  std::uint32_t opaque{};
+  std::optional<std::chrono::milliseconds> timeout{};
+  io::retry_context<false> retries{};
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context) const;
+  [[nodiscard]] auto encode_to(encoded_request_type& encoded,
+                               mcbp_context&& context) const -> std::error_code;
 
-    [[nodiscard]] exists_response make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] auto make_response(key_value_error_context&& ctx,
+                                   const encoded_response_type& encoded) const -> exists_response;
 };
 
 } // namespace couchbase::core::operations

data/ext/couchbase/core/operations/document_get.cxx

@@ -21,24 +21,26 @@
 
 namespace couchbase::core::operations
 {
-std::error_code
-get_request::encode_to(get_request::encoded_request_type& encoded, mcbp_context&& /* context */) const
+auto
+get_request::encode_to(get_request::encoded_request_type& encoded,
+                       mcbp_context&& /* context */) const -> std::error_code
 {
-    encoded.opaque(opaque);
-    encoded.partition(partition);
-    encoded.body().id(id);
-    return {};
+  encoded.opaque(opaque);
+  encoded.partition(partition);
+  encoded.body().id(id);
+  return {};
 }
 
-get_response
-get_request::make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const
+auto
+get_request::make_response(key_value_error_context&& ctx,
+                           const encoded_response_type& encoded) const -> get_response
 {
-    get_response response{ std::move(ctx) };
-    if (!response.ctx.ec()) {
-        response.value = encoded.body().value();
-        response.cas = encoded.cas();
-        response.flags = encoded.body().flags();
-    }
-    return response;
+  get_response response{ std::move(ctx) };
+  if (!response.ctx.ec()) {
+    response.value = encoded.body().value();
+    response.cas = encoded.cas();
+    response.flags = encoded.body().flags();
+  }
+  return response;
 }
 } // namespace couchbase::core::operations

data/ext/couchbase/core/operations/document_get.hxx

@@ -30,27 +30,29 @@ namespace couchbase::core::operations
 {
 
 struct get_response {
-    key_value_error_context ctx;
-    std::vector<std::byte> value{};
-    couchbase::cas cas{};
-    std::uint32_t flags{};
+  key_value_error_context ctx;
+  std::vector<std::byte> value{};
+  couchbase::cas cas{};
+  std::uint32_t flags{};
 };
 
 struct get_request {
-    using response_type = get_response;
-    using encoded_request_type = protocol::client_request<protocol::get_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::get_response_body>;
+  using response_type = get_response;
+  using encoded_request_type = protocol::client_request<protocol::get_request_body>;
+  using encoded_response_type = protocol::client_response<protocol::get_response_body>;
 
-    document_id id;
-    std::uint16_t partition{};
-    std::uint32_t opaque{};
-    std::optional<std::chrono::milliseconds> timeout{};
-    io::retry_context<true> retries{};
-    std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
+  document_id id;
+  std::uint16_t partition{};
+  std::uint32_t opaque{};
+  std::optional<std::chrono::milliseconds> timeout{};
+  io::retry_context<true> retries{};
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context) const;
+  [[nodiscard]] auto encode_to(encoded_request_type& encoded,
+                               mcbp_context&& context) const -> std::error_code;
 
-    [[nodiscard]] get_response make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] auto make_response(key_value_error_context&& ctx,
+                                   const encoded_response_type& encoded) const -> get_response;
 };
 } // namespace couchbase::core::operations
 

data/ext/couchbase/core/operations/document_get_all_replicas.hxx

@@ -19,6 +19,8 @@
 
 #include "core/error_context/key_value.hxx"
 #include "core/impl/get_replica.hxx"
+#include "core/impl/replica_utils.hxx"
+#include "core/logger/logger.hxx"
 #include "core/operations/document_get.hxx"
 #include "core/operations/operation_traits.hxx"
 #include "core/utils/movable_function.hxx"
@@ -31,110 +33,137 @@
 namespace couchbase::core::operations
 {
 struct get_all_replicas_response {
-    struct entry {
-        std::vector<std::byte> value{};
-        couchbase::cas cas{};
-        std::uint32_t flags{};
-        bool replica{ true };
-    };
-    key_value_error_context ctx{};
-    std::vector<entry> entries{};
+  struct entry {
+    std::vector<std::byte> value{};
+    couchbase::cas cas{};
+    std::uint32_t flags{};
+    bool replica{ true };
+  };
+  key_value_error_context ctx{};
+  std::vector<entry> entries{};
 };
 
 struct get_all_replicas_request {
-    using response_type = get_all_replicas_response;
-    using encoded_request_type = core::protocol::client_request<core::protocol::get_replica_request_body>;
-    using encoded_response_type = core::protocol::client_response<core::protocol::get_replica_response_body>;
+  using response_type = get_all_replicas_response;
+  using encoded_request_type =
+    core::protocol::client_request<core::protocol::get_replica_request_body>;
+  using encoded_response_type =
+    core::protocol::client_response<core::protocol::get_replica_response_body>;
 
-    core::document_id id;
-    std::optional<std::chrono::milliseconds> timeout{};
+  core::document_id id;
+  std::optional<std::chrono::milliseconds> timeout{};
+  couchbase::read_preference read_preference{ couchbase::read_preference::no_preference };
 
-    template<typename Core, typename Handler>
-    void execute(Core core, Handler handler)
-    {
-        core->with_bucket_configuration(
-          id.bucket(),
-          [core, id = id, timeout = timeout, h = std::forward<Handler>(handler)](std::error_code ec,
-                                                                                 const topology::configuration& config) mutable {
-              if (ec) {
-                  return h(response_type{ make_key_value_error_context(ec, id) });
-              }
-              using handler_type = utils::movable_function<void(response_type)>;
+  template<typename Core, typename Handler>
+  void execute(Core core, Handler handler)
+  {
+    core->with_bucket_configuration(
+      id.bucket(),
+      [core,
+       id = id,
+       timeout = timeout,
+       read_preference = read_preference,
+       h = std::forward<Handler>(handler)](std::error_code ec,
+                                           const topology::configuration& config) mutable {
+        if (ec) {
+          return h(response_type{ make_key_value_error_context(ec, id) });
+        }
+        const auto [e, origin] = core->origin();
+        if (e) {
+          return h(response_type{ make_key_value_error_context(e, id) });
+        }
 
-              struct replica_context {
-                  replica_context(handler_type handler, std::uint32_t expected_responses)
-                    : handler_(std::move(handler))
-                    , expected_responses_(expected_responses)
-                  {
-                  }
+        auto nodes =
+          impl::effective_nodes(id, config, read_preference, origin.options().server_group);
+        if (nodes.empty()) {
+          CB_LOG_DEBUG(
+            "Unable to retrieve replicas for \"{}\", server_group={}, number_of_replicas={}",
+            id,
+            origin.options().server_group,
+            config.num_replicas.value_or(0));
+          return h(response_type{
+            make_key_value_error_context(errc::key_value::document_irretrievable, id) });
+        }
 
-                  handler_type handler_;
-                  std::uint32_t expected_responses_;
-                  bool done_{ false };
-                  std::mutex mutex_{};
-                  std::vector<get_all_replicas_response::entry> result_{};
-              };
-              auto ctx = std::make_shared<replica_context>(std::move(h), config.num_replicas.value_or(0U) + 1U);
+        using handler_type = utils::movable_function<void(response_type)>;
 
-              for (std::size_t idx = 1U; idx <= config.num_replicas.value_or(0U); ++idx) {
-                  document_id replica_id{ id };
-                  replica_id.node_index(idx);
-                  core->execute(impl::get_replica_request{ std::move(replica_id), timeout }, [ctx](impl::get_replica_response&& resp) {
-                      handler_type local_handler{};
-                      {
-                          std::scoped_lock lock(ctx->mutex_);
-                          if (ctx->done_) {
-                              return;
-                          }
-                          --ctx->expected_responses_;
-                          if (resp.ctx.ec()) {
-                              if (ctx->expected_responses_ > 0) {
-                                  // just ignore the response
-                                  return;
-                              }
-                          } else {
-                              ctx->result_.emplace_back(
-                                get_all_replicas_response::entry{ std::move(resp.value), resp.cas, resp.flags, true /* replica */ });
-                          }
-                          if (ctx->expected_responses_ == 0) {
-                              ctx->done_ = true;
-                              std::swap(local_handler, ctx->handler_);
-                          }
-                      }
-                      if (local_handler) {
-                          return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
-                      }
-                  });
-              }
+        struct replica_context {
+          replica_context(handler_type handler, std::size_t expected_responses)
+            : handler_(std::move(handler))
+            , expected_responses_(expected_responses)
+          {
+          }
+
+          handler_type handler_;
+          std::size_t expected_responses_;
+          bool done_{ false };
+          std::mutex mutex_{};
+          std::vector<get_all_replicas_response::entry> result_{};
+        };
+        auto ctx = std::make_shared<replica_context>(std::move(h), nodes.size());
 
-              core->execute(get_request{ document_id{ id }, {}, {}, timeout }, [ctx](get_response&& resp) {
-                  handler_type local_handler{};
-                  {
-                      std::scoped_lock lock(ctx->mutex_);
-                      if (ctx->done_) {
-                          return;
-                      }
-                      --ctx->expected_responses_;
-                      if (resp.ctx.ec()) {
-                          if (ctx->expected_responses_ > 0) {
-                              // just ignore the response
-                              return;
-                          }
-                      } else {
-                          ctx->result_.emplace_back(
-                            get_all_replicas_response::entry{ std::move(resp.value), resp.cas, resp.flags, false /* replica */ });
-                      }
-                      if (ctx->expected_responses_ == 0) {
-                          ctx->done_ = true;
-                          std::swap(local_handler, ctx->handler_);
-                      }
+        for (const auto& node : nodes) {
+          if (node.is_replica) {
+            document_id replica_id{ id };
+            replica_id.node_index(node.index);
+            core->execute(
+              impl::get_replica_request{ std::move(replica_id), timeout }, [ctx](auto&& resp) {
+                handler_type local_handler{};
+                {
+                  std::scoped_lock lock(ctx->mutex_);
+                  if (ctx->done_) {
+                    return;
                   }
-                  if (local_handler) {
-                      return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
+                  --ctx->expected_responses_;
+                  if (resp.ctx.ec()) {
+                    if (ctx->expected_responses_ > 0) {
+                      // just ignore the response
+                      return;
+                    }
+                  } else {
+                    ctx->result_.emplace_back(get_all_replicas_response::entry{
+                      std::move(resp.value), resp.cas, resp.flags, true /* replica */ });
                   }
+                  if (ctx->expected_responses_ == 0) {
+                    ctx->done_ = true;
+                    std::swap(local_handler, ctx->handler_);
+                  }
+                }
+                if (local_handler) {
+                  return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
+                }
               });
-          });
-    }
+          } else {
+            core->execute(get_request{ document_id{ id }, {}, {}, timeout }, [ctx](auto&& resp) {
+              handler_type local_handler{};
+              {
+                std::scoped_lock lock(ctx->mutex_);
+                if (ctx->done_) {
+                  return;
+                }
+                --ctx->expected_responses_;
+                if (resp.ctx.ec()) {
+                  if (ctx->expected_responses_ > 0) {
+                    // just ignore the response
+                    return;
+                  }
+                } else {
+                  ctx->result_.emplace_back(get_all_replicas_response::entry{
+                    std::move(resp.value), resp.cas, resp.flags, false /* active */ });
+                }
+                if (ctx->expected_responses_ == 0) {
+                  ctx->done_ = true;
+                  std::swap(local_handler, ctx->handler_);
+                }
+              }
+              if (local_handler) {
+                return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
+              }
+            });
+          }
+        }
+      });
+  }
 };
 
 template<>

data/ext/couchbase/core/operations/document_get_and_lock.cxx

@@ -21,25 +21,28 @@
 
 namespace couchbase::core::operations
 {
-std::error_code
-get_and_lock_request::encode_to(get_and_lock_request::encoded_request_type& encoded, mcbp_context&& /* context */) const
+auto
+get_and_lock_request::encode_to(get_and_lock_request::encoded_request_type& encoded,
+                                mcbp_context&& /* context */) const -> std::error_code
 {
-    encoded.opaque(opaque);
-    encoded.partition(partition);
-    encoded.body().id(id);
-    encoded.body().lock_time(lock_time);
-    return {};
+  encoded.opaque(opaque);
+  encoded.partition(partition);
+  encoded.body().id(id);
+  encoded.body().lock_time(lock_time);
+  return {};
 }
 
-get_and_lock_response
-get_and_lock_request::make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const
+auto
+get_and_lock_request::make_response(key_value_error_context&& ctx,
+                                    const encoded_response_type& encoded) const
+  -> get_and_lock_response
 {
-    get_and_lock_response response{ std::move(ctx) };
-    if (!response.ctx.ec()) {
-        response.value = encoded.body().value();
-        response.cas = encoded.cas();
-        response.flags = encoded.body().flags();
-    }
-    return response;
+  get_and_lock_response response{ std::move(ctx) };
+  if (!response.ctx.ec()) {
+    response.value = encoded.body().value();
+    response.cas = encoded.cas();
+    response.flags = encoded.body().flags();
+  }
+  return response;
 }
 } // namespace couchbase::core::operations