couchbase 4.3.1 → 4.4.0

package/deps/couchbase-cxx-client/core/operations/document_lookup_in_any_replica.hxx

@@ -19,12 +19,14 @@
 
 #include "core/error_context/key_value.hxx"
 #include "core/impl/lookup_in_replica.hxx"
+#include "core/impl/replica_utils.hxx"
 #include "core/impl/subdoc/command.hxx"
 #include "core/operations/document_lookup_in.hxx"
 #include "core/operations/operation_traits.hxx"
 #include "core/utils/movable_function.hxx"
 #include "couchbase/codec/encoded_value.hxx"
 #include "couchbase/error_codes.hxx"
+#include "couchbase/read_preference.hxx"
 
 #include <functional>
 #include <memory>
@@ -33,161 +35,204 @@
 namespace couchbase::core::operations
 {
 struct lookup_in_any_replica_response {
-    struct entry {
-        std::string path;
-        codec::binary value;
-        std::size_t original_index;
-        bool exists;
-        protocol::subdoc_opcode opcode;
-        key_value_status_code status;
-        std::error_code ec{};
-    };
-    subdocument_error_context ctx{};
-    couchbase::cas cas{};
-    std::vector<entry> fields{};
-    bool deleted{ false };
-    bool is_replica{ true };
+  struct entry {
+    std::string path;
+    codec::binary value;
+    std::size_t original_index;
+    bool exists;
+    protocol::subdoc_opcode opcode;
+    key_value_status_code status;
+    std::error_code ec{};
+  };
+  subdocument_error_context ctx{};
+  couchbase::cas cas{};
+  std::vector<entry> fields{};
+  bool deleted{ false };
+  bool is_replica{ true };
 };
 
 struct lookup_in_any_replica_request {
-    using response_type = lookup_in_any_replica_response;
-    using encoded_request_type = core::protocol::client_request<core::protocol::lookup_in_replica_request_body>;
-    using encoded_response_type = core::protocol::client_response<core::protocol::lookup_in_replica_response_body>;
+  using response_type = lookup_in_any_replica_response;
+  using encoded_request_type =
+    core::protocol::client_request<core::protocol::lookup_in_replica_request_body>;
+  using encoded_response_type =
+    core::protocol::client_response<core::protocol::lookup_in_replica_response_body>;
 
-    core::document_id id;
-    std::vector<couchbase::core::impl::subdoc::command> specs{};
-    std::optional<std::chrono::milliseconds> timeout{};
-    std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
+  core::document_id id;
+  std::vector<couchbase::core::impl::subdoc::command> specs{};
+  std::optional<std::chrono::milliseconds> timeout{};
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
+  couchbase::read_preference read_preference{ couchbase::read_preference::no_preference };
 
-    template<typename Core, typename Handler>
-    void execute(Core core, Handler handler)
-    {
-        core->open_bucket(id.bucket(),
-                          [core, id = id, timeout = timeout, specs = specs, parent_span = parent_span, h = std::forward<Handler>(handler)](
-                            std::error_code ec) mutable {
-                              if (ec) {
-                                  std::optional<std::string> first_error_path{};
-                                  std::optional<std::size_t> first_error_index{};
-                                  h(response_type{ make_subdocument_error_context(
-                                    make_key_value_error_context(ec, id), ec, first_error_path, first_error_index, false) });
-                                  return;
-                              }
-                              return core->with_bucket_configuration(
-                                id.bucket(),
-                                [core, id = id, timeout = timeout, specs = specs, parent_span = parent_span, h = std::forward<Handler>(h)](
-                                  std::error_code ec, const topology::configuration& config) mutable {
-                                    if (!config.capabilities.supports_subdoc_read_replica()) {
-                                        ec = errc::common::feature_not_available;
-                                    }
+  template<typename Core, typename Handler>
+  void execute(Core core, Handler handler)
+  {
+    core->open_bucket(
+      id.bucket(),
+      [core,
+       id = id,
+       timeout = timeout,
+       specs = specs,
+       parent_span = parent_span,
+       read_preference = read_preference,
+       h = std::forward<Handler>(handler)](std::error_code ec) mutable {
+        if (ec) {
+          std::optional<std::string> first_error_path{};
+          std::optional<std::size_t> first_error_index{};
+          h(response_type{ make_subdocument_error_context(make_key_value_error_context(ec, id),
+                                                          ec,
+                                                          first_error_path,
+                                                          first_error_index,
+                                                          false) });
+          return;
+        }
+        return core->with_bucket_configuration(
+          id.bucket(),
+          [core, id, timeout, specs, parent_span, read_preference, h = std::forward<Handler>(h)](
+            std::error_code ec, const topology::configuration& config) mutable {
+            if (!config.capabilities.supports_subdoc_read_replica()) {
+              ec = errc::common::feature_not_available;
+            }
+            const auto [e, origin] = core->origin();
+            if (e && !ec) {
+              ec = e;
+            }
 
-                                    if (ec) {
-                                        std::optional<std::string> first_error_path{};
-                                        std::optional<std::size_t> first_error_index{};
-                                        return h(response_type{ make_subdocument_error_context(
-                                          make_key_value_error_context(ec, id), ec, first_error_path, first_error_index, false) });
-                                    }
-                                    using handler_type = utils::movable_function<void(response_type)>;
+            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));
+              ec = errc::key_value::document_irretrievable;
+            }
+
+            if (ec) {
+              return h(response_type{ make_subdocument_error_context(
+                make_key_value_error_context(ec, id), ec, {}, {}, false) });
+            }
+
+            if (ec) {
+              std::optional<std::string> first_error_path{};
+              std::optional<std::size_t> first_error_index{};
+              return h(
+                response_type{ make_subdocument_error_context(make_key_value_error_context(ec, id),
+                                                              ec,
+                                                              first_error_path,
+                                                              first_error_index,
+                                                              false) });
+            }
+
+            using handler_type = utils::movable_function<void(response_type)>;
 
-                                    struct replica_context {
-                                        replica_context(handler_type&& handler, std::uint32_t expected_responses)
-                                          : handler_(std::move(handler))
-                                          , expected_responses_(expected_responses)
-                                        {
-                                        }
+            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::uint32_t expected_responses_;
-                                        bool done_{ false };
-                                        std::mutex mutex_{};
-                                    };
-                                    auto ctx = std::make_shared<replica_context>(std::move(h), config.num_replicas.value_or(0U) + 1U);
+              handler_type handler_;
+              std::size_t expected_responses_;
+              bool done_{ false };
+              std::mutex mutex_{};
+            };
+            auto ctx = std::make_shared<replica_context>(std::move(h), nodes.size());
 
-                                    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::lookup_in_replica_request{ std::move(replica_id), specs, timeout, parent_span },
-                                                      [ctx](impl::lookup_in_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;
-                                                                  }
-                                                                  // consider document irretrievable and give up
-                                                                  resp.ctx.override_ec(errc::key_value::document_irretrievable);
-                                                              }
-                                                              ctx->done_ = true;
-                                                              std::swap(local_handler, ctx->handler_);
-                                                          }
-                                                          if (local_handler) {
-                                                              response_type res{};
-                                                              res.ctx = resp.ctx;
-                                                              res.cas = resp.cas;
-                                                              res.deleted = resp.deleted;
-                                                              res.is_replica = true;
-                                                              for (auto& field : resp.fields) {
-                                                                  auto lookup_in_entry = lookup_in_any_replica_response::entry{};
-                                                                  lookup_in_entry.path = field.path;
-                                                                  lookup_in_entry.value = field.value;
-                                                                  lookup_in_entry.status = field.status;
-                                                                  lookup_in_entry.ec = field.ec;
-                                                                  lookup_in_entry.exists = field.exists;
-                                                                  lookup_in_entry.original_index = field.original_index;
-                                                                  lookup_in_entry.opcode = field.opcode;
-                                                                  res.fields.emplace_back(lookup_in_entry);
-                                                              }
-                                                              return local_handler(res);
-                                                          }
-                                                      });
+            for (const auto& node : nodes) {
+              if (node.is_replica) {
+                document_id replica_id{ id };
+                replica_id.node_index(node.index);
+                core->execute(
+                  impl::lookup_in_replica_request{
+                    std::move(replica_id), specs, timeout, parent_span },
+                  [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;
+                        }
+                        // consider document irretrievable and give up
+                        resp.ctx.override_ec(errc::key_value::document_irretrievable);
+                      }
+                      ctx->done_ = true;
+                      std::swap(local_handler, ctx->handler_);
+                    }
+                    if (local_handler) {
+                      response_type res{};
+                      res.ctx = resp.ctx;
+                      res.cas = resp.cas;
+                      res.deleted = resp.deleted;
+                      res.is_replica = true;
+                      for (auto& field : resp.fields) {
+                        auto lookup_in_entry = lookup_in_any_replica_response::entry{};
+                        lookup_in_entry.path = field.path;
+                        lookup_in_entry.value = field.value;
+                        lookup_in_entry.status = field.status;
+                        lookup_in_entry.ec = field.ec;
+                        lookup_in_entry.exists = field.exists;
+                        lookup_in_entry.original_index = field.original_index;
+                        lookup_in_entry.opcode = field.opcode;
+                        res.fields.emplace_back(lookup_in_entry);
+                      }
+                      return local_handler(res);
+                    }
+                  });
+              } else {
+                core->execute(lookup_in_request{ id, {}, {}, false, specs, 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;
                                     }
-                                    core->execute(lookup_in_request{ id, {}, {}, false, specs, timeout }, [ctx](lookup_in_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;
-                                                }
-                                                // consider document irretrievable and give up
-                                                resp.ctx.override_ec(errc::key_value::document_irretrievable);
-                                            }
-                                            ctx->done_ = true;
-                                            std::swap(local_handler, ctx->handler_);
-                                        }
-                                        if (local_handler) {
-                                            auto res = response_type{};
-                                            res.ctx = resp.ctx;
-                                            res.cas = resp.cas;
-                                            res.deleted = resp.deleted;
-                                            res.is_replica = false;
-                                            for (auto& field : resp.fields) {
-                                                auto lookup_in_entry = lookup_in_any_replica_response::entry{};
-                                                lookup_in_entry.path = field.path;
-                                                lookup_in_entry.value = field.value;
-                                                lookup_in_entry.status = field.status;
-                                                lookup_in_entry.ec = field.ec;
-                                                lookup_in_entry.exists = field.exists;
-                                                lookup_in_entry.original_index = field.original_index;
-                                                lookup_in_entry.opcode = field.opcode;
-                                                res.fields.emplace_back(lookup_in_entry);
-                                            }
-                                            return local_handler(res);
-                                        }
-                                    });
-                                });
-                          });
-    }
+                                    // consider document irretrievable and give up
+                                    resp.ctx.override_ec(errc::key_value::document_irretrievable);
+                                  }
+                                  ctx->done_ = true;
+                                  std::swap(local_handler, ctx->handler_);
+                                }
+                                if (local_handler) {
+                                  auto res = response_type{};
+                                  res.ctx = resp.ctx;
+                                  res.cas = resp.cas;
+                                  res.deleted = resp.deleted;
+                                  res.is_replica = false;
+                                  for (auto& field : resp.fields) {
+                                    auto lookup_in_entry = lookup_in_any_replica_response::entry{};
+                                    lookup_in_entry.path = field.path;
+                                    lookup_in_entry.value = field.value;
+                                    lookup_in_entry.status = field.status;
+                                    lookup_in_entry.ec = field.ec;
+                                    lookup_in_entry.exists = field.exists;
+                                    lookup_in_entry.original_index = field.original_index;
+                                    lookup_in_entry.opcode = field.opcode;
+                                    res.fields.emplace_back(lookup_in_entry);
+                                  }
+                                  return local_handler(res);
+                                }
+                              });
+              }
+            }
+          });
+      });
+  }
 };
 
 template<>

package/deps/couchbase-cxx-client/core/operations/document_mutate_in.cxx

@@ -25,94 +25,112 @@
 
 namespace couchbase::core::operations
 {
-std::error_code
-mutate_in_request::encode_to(mutate_in_request::encoded_request_type& encoded, mcbp_context&& context)
+auto
+mutate_in_request::encode_to(mutate_in_request::encoded_request_type& encoded,
+                             mcbp_context&& context) -> std::error_code
 {
-    if (store_semantics == couchbase::store_semantics::upsert && !cas.empty()) {
-        return errc::common::invalid_argument;
-    }
-    if (create_as_deleted && !context.supports_feature(protocol::hello_feature::subdoc_create_as_deleted)) {
-        return errc::common::unsupported_operation;
-    }
-    for (std::size_t i = 0; i < specs.size(); ++i) {
-        auto& entry = specs[i];
-        entry.original_index_ = i;
-    }
-    std::stable_sort(specs.begin(), specs.end(), [](const auto& lhs, const auto& rhs) {
-        /* move XATTRs to the beginning of the vector */
-        return core::impl::subdoc::has_xattr_path_flag(lhs.flags_) && !core::impl::subdoc::has_xattr_path_flag(rhs.flags_);
-    });
+  if (store_semantics == couchbase::store_semantics::upsert && !cas.empty()) {
+    return errc::common::invalid_argument;
+  }
+  if (create_as_deleted &&
+      !context.supports_feature(protocol::hello_feature::subdoc_create_as_deleted)) {
+    return errc::common::unsupported_operation;
+  }
+  for (std::size_t i = 0; i < specs.size(); ++i) {
+    auto& entry = specs[i];
+    entry.original_index_ = i;
 
-    encoded.opaque(opaque);
-    encoded.partition(partition);
-    encoded.body().id(id);
-    encoded.cas(cas);
-    if (expiry) {
-        encoded.body().expiry(*expiry);
-    }
-    encoded.body().access_deleted(access_deleted);
-    encoded.body().create_as_deleted(create_as_deleted);
-    encoded.body().store_semantics(store_semantics);
-    encoded.body().specs(specs);
-    if (preserve_expiry) {
-        encoded.body().preserve_expiry();
+    if (impl::subdoc::has_binary_value_path_flag(specs[i].flags_) &&
+        !context.supports_feature(protocol::hello_feature::subdoc_binary_xattr)) {
+      impl::subdoc::reset_binary_value_path_flag(specs[i].flags_);
     }
-    return {};
+  }
+  std::stable_sort(specs.begin(), specs.end(), [](const auto& lhs, const auto& rhs) {
+    /* move XATTRs to the beginning of the vector */
+    return core::impl::subdoc::has_xattr_path_flag(lhs.flags_) &&
+           !core::impl::subdoc::has_xattr_path_flag(rhs.flags_);
+  });
+
+  encoded.opaque(opaque);
+  encoded.partition(partition);
+  encoded.body().id(id);
+  encoded.cas(cas);
+  if (expiry) {
+    encoded.body().expiry(*expiry);
+  }
+  encoded.body().access_deleted(access_deleted);
+  encoded.body().create_as_deleted(create_as_deleted);
+  encoded.body().store_semantics(store_semantics);
+  encoded.body().specs(specs);
+  if (preserve_expiry) {
+    encoded.body().preserve_expiry();
+  }
+
+  if (context.supports_feature(protocol::hello_feature::subdoc_binary_xattr) && flags) {
+    encoded.body().user_flags(flags.value());
+  }
+
+  return {};
 }
 
-mutate_in_response
-mutate_in_request::make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const
+auto
+mutate_in_request::make_response(key_value_error_context&& ctx,
+                                 const encoded_response_type& encoded) const -> mutate_in_response
 {
-    bool deleted = false;
-    couchbase::cas response_cas{};
-    couchbase::mutation_token response_token{};
-    std::vector<mutate_in_response::entry> fields{};
-    std::error_code ec = ctx.ec();
-    std::optional<std::size_t> first_error_index{};
-    std::optional<std::string> first_error_path{};
+  bool deleted = false;
+  couchbase::cas response_cas{};
+  couchbase::mutation_token response_token{};
+  std::vector<mutate_in_response::entry> fields{};
+  std::error_code ec = ctx.ec();
+  std::optional<std::size_t> first_error_index{};
+  std::optional<std::string> first_error_path{};
 
-    if (encoded.status() == key_value_status_code::subdoc_success_deleted ||
-        encoded.status() == key_value_status_code::subdoc_multi_path_failure_deleted) {
-        deleted = true;
+  if (encoded.status() == key_value_status_code::subdoc_success_deleted ||
+      encoded.status() == key_value_status_code::subdoc_multi_path_failure_deleted) {
+    deleted = true;
+  }
+  if (!ctx.ec()) {
+    fields.resize(specs.size());
+    fields.resize(specs.size());
+    for (size_t i = 0; i < specs.size(); ++i) {
+      const auto& req_entry = specs[i];
+      fields[i].original_index = req_entry.original_index_;
+      fields[i].path = req_entry.path_;
+      fields[i].opcode = static_cast<protocol::subdoc_opcode>(req_entry.opcode_);
+      fields[i].status = key_value_status_code::success;
     }
-    if (!ctx.ec()) {
-        fields.resize(specs.size());
-        fields.resize(specs.size());
-        for (size_t i = 0; i < specs.size(); ++i) {
-            const auto& req_entry = specs[i];
-            fields[i].original_index = req_entry.original_index_;
-            fields[i].path = req_entry.path_;
-            fields[i].opcode = static_cast<protocol::subdoc_opcode>(req_entry.opcode_);
-            fields[i].status = key_value_status_code::success;
-        }
-        for (const auto& entry : encoded.body().fields()) {
-            if (entry.status == key_value_status_code::success) {
-                fields[entry.index].value = utils::to_binary(entry.value);
-            } else {
-                first_error_index = entry.index;
-                first_error_path = fields[entry.index].path;
-                fields[entry.index].status = entry.status;
-                fields[entry.index].ec =
-                  protocol::map_status_code(protocol::client_opcode::subdoc_multi_mutation, static_cast<std::uint16_t>(entry.status));
-                ec = fields[entry.index].ec;
-                break;
-            }
-        }
-        if (!ec) {
-            response_cas = encoded.cas();
-            response_token = couchbase::utils::build_mutation_token(encoded.body().token(), partition, ctx.bucket());
-        }
-        std::sort(fields.begin(), fields.end(), [](const auto& lhs, const auto& rhs) { return lhs.original_index < rhs.original_index; });
-    } else if (store_semantics == couchbase::store_semantics::insert &&
-               (ctx.ec() == errc::common::cas_mismatch || ctx.status_code() == key_value_status_code::not_stored)) {
-        ec = errc::key_value::document_exists;
+    for (const auto& entry : encoded.body().fields()) {
+      if (entry.status == key_value_status_code::success) {
+        fields[entry.index].value = utils::to_binary(entry.value);
+      } else {
+        first_error_index = entry.index;
+        first_error_path = fields[entry.index].path;
+        fields[entry.index].status = entry.status;
+        fields[entry.index].ec = protocol::map_status_code(
+          protocol::client_opcode::subdoc_multi_mutation, static_cast<std::uint16_t>(entry.status));
+        ec = fields[entry.index].ec;
+        break;
+      }
     }
-    return mutate_in_response{
-        make_subdocument_error_context(ctx, ec, first_error_path, first_error_index, deleted),
-        response_cas,
-        std::move(response_token),
-        std::move(fields),
-        deleted,
-    };
+    if (!ec) {
+      response_cas = encoded.cas();
+      response_token =
+        couchbase::utils::build_mutation_token(encoded.body().token(), partition, ctx.bucket());
+    }
+    std::sort(fields.begin(), fields.end(), [](const auto& lhs, const auto& rhs) {
+      return lhs.original_index < rhs.original_index;
+    });
+  } else if (store_semantics == couchbase::store_semantics::insert &&
+             (ctx.ec() == errc::common::cas_mismatch ||
+              ctx.status_code() == key_value_status_code::not_stored)) {
+    ec = errc::key_value::document_exists;
+  }
+  return mutate_in_response{
+    make_subdocument_error_context(ctx, ec, first_error_path, first_error_index, deleted),
+    response_cas,
+    std::move(response_token),
+    std::move(fields),
+    deleted,
+  };
 }
 } // namespace couchbase::core::operations