couchbase 4.7.0-dev.1 → 4.7.1

package/deps/couchbase-cxx-client/CMakeLists.txt

@@ -21,7 +21,7 @@ endif()
 
 project(
   couchbase_cxx_client
-  VERSION "1.3.1"
+  VERSION "1.3.2"
   LANGUAGES CXX C)
 message(
   STATUS
@@ -128,6 +128,7 @@ set(couchbase_cxx_client_FILES
     core/impl/doc_id_query.cxx
     core/impl/error.cxx
     core/impl/error_context.cxx
+    core/impl/node_id.cxx
     core/impl/expiry.cxx
     core/impl/fail_fast_retry_strategy.cxx
     core/impl/field_level_encryption_error_category.cxx
@@ -436,6 +437,7 @@ set(couchbase_cxx_client_FILES
     core/transactions/utils.cxx
     core/utils/binary.cxx
     core/utils/connection_string.cxx
+    core/utils/contains_string.cxx
     core/utils/duration_parser.cxx
     core/utils/json.cxx
     core/utils/json_streaming_lexer.cxx

package/deps/couchbase-cxx-client/README.md

@@ -22,9 +22,9 @@ CPMAddPackage(
   NAME
   couchbase_cxx_client
   GIT_TAG
-  1.3.1
+  1.3.2
   VERSION
-  1.3.1
+  1.3.2
   GITHUB_REPOSITORY
   "couchbase/couchbase-cxx-client"
   OPTIONS

package/deps/couchbase-cxx-client/core/error_context/base_error_context.hxx

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include <couchbase/node_id.hxx>
 #include <couchbase/retry_reason.hxx>
 
 #include <cstdint>
@@ -74,6 +75,23 @@ public:
   {
   }
 
+  base_error_context(std::string operation_id,
+                     std::error_code ec,
+                     std::optional<std::string> last_dispatched_to,
+                     std::optional<std::string> last_dispatched_from,
+                     std::size_t retry_attempts,
+                     std::set<retry_reason> retry_reasons,
+                     couchbase::node_id last_dispatched_to_node_id)
+    : operation_id_{ std::move(operation_id) }
+    , ec_{ ec }
+    , last_dispatched_to_{ std::move(last_dispatched_to) }
+    , last_dispatched_from_{ std::move(last_dispatched_from) }
+    , retry_attempts_{ retry_attempts }
+    , retry_reasons_{ std::move(retry_reasons) }
+    , last_dispatched_to_node_id_{ std::move(last_dispatched_to_node_id) }
+  {
+  }
+
   [[nodiscard]] virtual auto operation_id() const -> const std::string&
   {
     return operation_id_;
@@ -173,6 +191,19 @@ public:
     return retry_reasons_.count(reason) > 0;
   }
 
+  /**
+   * Identity of the cluster node that last handled this request.
+   *
+   * @return node_id (default-constructed / falsy when unknown)
+   *
+   * @since 1.3.2
+   * @uncommitted
+   */
+  [[nodiscard]] virtual auto last_dispatched_to_node_id() const -> const couchbase::node_id&
+  {
+    return last_dispatched_to_node_id_;
+  }
+
 private:
   std::string operation_id_{};
   std::error_code ec_{};
@@ -180,5 +211,6 @@ private:
   std::optional<std::string> last_dispatched_from_{};
   std::size_t retry_attempts_{ 0 };
   std::set<retry_reason> retry_reasons_{};
+  couchbase::node_id last_dispatched_to_node_id_{};
 };
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/error_context/key_value.cxx

@@ -51,6 +51,7 @@ make_subdocument_error_context(const key_value_error_context& ctx,
     ctx.last_dispatched_from(),
     ctx.retry_attempts(),
     ctx.retry_reasons(),
+    ctx.last_dispatched_to_node_id(),
     ctx.id(),
     ctx.bucket(),
     ctx.scope(),

package/deps/couchbase-cxx-client/core/error_context/key_value.hxx

@@ -20,6 +20,7 @@
 #include "subdocument_error_context.hxx"
 
 #include "core/document_id.hxx"
+#include "core/impl/node_id.hxx"
 #include "key_value_error_context.hxx"
 
 #include <optional>
@@ -57,12 +58,34 @@ 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".
+  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);
+    }
+  }
+
   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,

package/deps/couchbase-cxx-client/core/error_context/key_value_error_context.hxx

@@ -101,6 +101,41 @@ public:
   {
   }
 
+  key_value_error_context(std::string operation_id,
+                          std::error_code ec,
+                          std::optional<std::string> last_dispatched_to,
+                          std::optional<std::string> last_dispatched_from,
+                          std::size_t retry_attempts,
+                          std::set<retry_reason> retry_reasons,
+                          couchbase::node_id dispatched_to_node_id,
+                          std::string id,
+                          std::string bucket,
+                          std::string scope,
+                          std::string collection,
+                          std::uint32_t opaque,
+                          std::optional<key_value_status_code> status_code,
+                          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),
+                          std::move(dispatched_to_node_id) }
+    , 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) }
+  {
+  }
+
   /**
    * Returns identifier (key) of the document referenced in the operation.
    *

package/deps/couchbase-cxx-client/core/error_context/subdocument_error_context.hxx

@@ -102,6 +102,47 @@ public:
   {
   }
 
+  subdocument_error_context(std::string operation_id,
+                            std::error_code ec,
+                            std::optional<std::string> last_dispatched_to,
+                            std::optional<std::string> last_dispatched_from,
+                            std::size_t retry_attempts,
+                            std::set<retry_reason> retry_reasons,
+                            couchbase::node_id dispatched_to_node_id,
+                            std::string id,
+                            std::string bucket,
+                            std::string scope,
+                            std::string collection,
+                            std::uint32_t opaque,
+                            std::optional<key_value_status_code> status_code,
+                            couchbase::cas cas,
+                            std::optional<key_value_error_map_info> error_map_info,
+                            std::optional<key_value_extended_error_info> extended_error_info,
+                            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(dispatched_to_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) }
+    , first_error_path_{ std::move(first_error_path) }
+    , first_error_index_{ first_error_index }
+    , deleted_{ deleted }
+  {
+  }
+
   /**
    * Returns path of the operation that generated first error
    *

package/deps/couchbase-cxx-client/core/impl/binary_collection.cxx

@@ -19,6 +19,7 @@
 
 #include "core/cluster.hxx"
 #include "core/impl/error.hxx"
+#include "core/impl/invoke_with_node_id.hxx"
 #include "core/impl/observability_recorder.hxx"
 #include "core/operations/document_append.hxx"
 #include "core/operations/document_decrement.hxx"
@@ -53,6 +54,8 @@
 
 namespace couchbase
 {
+using core::impl::invoke_with_node_id;
+
 class binary_collection_impl : public std::enable_shared_from_this<binary_collection_impl>
 {
 public:
@@ -113,10 +116,13 @@ public:
         [obs_rec = std::move(obs_rec), handler = std::move(handler)](auto&& resp) mutable {
           obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
           if (resp.ctx.ec()) {
-            return handler(core::impl::make_error(std::move(resp.ctx)), mutation_result{});
+            invoke_with_node_id(
+              std::move(handler), core::impl::make_error(std::move(resp.ctx)), mutation_result{});
+            return;
           }
-          return handler(core::impl::make_error(std::move(resp.ctx)),
-                         mutation_result{ resp.cas, std::move(resp.token) });
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              mutation_result{ resp.cas, std::move(resp.token) });
         });
     }
 
@@ -131,39 +137,44 @@ public:
       { options.retry_strategy },
       obs_rec->operation_span(),
     };
-    return core_.execute(std::move(request),
-                         [core = core_,
-                          id = std::move(id),
-                          options,
-                          obs_rec = std::move(obs_rec),
-                          handler = std::move(handler)](auto&& resp) mutable {
-                           if (resp.ctx.ec()) {
-                             obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
-                             return handler(core::impl::make_error(std::move(resp.ctx)),
-                                            mutation_result{ resp.cas, std::move(resp.token) });
-                           }
-
-                           auto token = resp.token;
-                           core::impl::initiate_observe_poll(
-                             core,
-                             std::move(id),
-                             token,
-                             options.timeout,
-                             options.persist_to,
-                             options.replicate_to,
-                             [obs_rec = std::move(obs_rec),
-                              resp = std::forward<decltype(resp)>(resp),
-                              handler = std::move(handler)](std::error_code ec) mutable {
-                               obs_rec->finish(resp.ctx.retry_attempts(), ec);
-                               if (ec) {
-                                 resp.ctx.override_ec(ec);
-                                 return handler(core::impl::make_error(std::move(resp.ctx)),
-                                                mutation_result{});
-                               }
-                               return handler(core::impl::make_error(std::move(resp.ctx)),
-                                              mutation_result{ resp.cas, std::move(resp.token) });
-                             });
-                         });
+    return core_.execute(
+      std::move(request),
+      [core = core_,
+       id = std::move(id),
+       options,
+       obs_rec = std::move(obs_rec),
+       handler = std::move(handler)](auto&& resp) mutable {
+        if (resp.ctx.ec()) {
+          obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              mutation_result{ resp.cas, std::move(resp.token) });
+          return;
+        }
+
+        auto token = resp.token;
+        core::impl::initiate_observe_poll(
+          core,
+          std::move(id),
+          token,
+          options.timeout,
+          options.persist_to,
+          options.replicate_to,
+          [obs_rec = std::move(obs_rec),
+           resp = std::forward<decltype(resp)>(resp),
+           handler = std::move(handler)](std::error_code ec) mutable {
+            obs_rec->finish(resp.ctx.retry_attempts(), ec);
+            if (ec) {
+              resp.ctx.override_ec(ec);
+              invoke_with_node_id(
+                std::move(handler), core::impl::make_error(std::move(resp.ctx)), mutation_result{});
+              return;
+            }
+            invoke_with_node_id(std::move(handler),
+                                core::impl::make_error(std::move(resp.ctx)),
+                                mutation_result{ resp.cas, std::move(resp.token) });
+          });
+      });
   }
 
   void prepend(std::string document_key,
@@ -197,10 +208,13 @@ public:
         [obs_rec = std::move(obs_rec), handler = std::move(handler)](auto&& resp) mutable {
           obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
           if (resp.ctx.ec()) {
-            return handler(core::impl::make_error(std::move(resp.ctx)), mutation_result{});
+            invoke_with_node_id(
+              std::move(handler), core::impl::make_error(std::move(resp.ctx)), mutation_result{});
+            return;
           }
-          return handler(core::impl::make_error(std::move(resp.ctx)),
-                         mutation_result{ resp.cas, std::move(resp.token) });
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              mutation_result{ resp.cas, std::move(resp.token) });
         });
     }
 
@@ -215,39 +229,44 @@ public:
       { options.retry_strategy },
       obs_rec->operation_span(),
     };
-    return core_.execute(std::move(request),
-                         [obs_rec = std::move(obs_rec),
-                          core = core_,
-                          id = std::move(id),
-                          options,
-                          handler = std::move(handler)](auto&& resp) mutable {
-                           if (resp.ctx.ec()) {
-                             obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
-                             return handler(core::impl::make_error(std::move(resp.ctx)),
-                                            mutation_result{ resp.cas, std::move(resp.token) });
-                           }
-
-                           auto token = resp.token;
-                           core::impl::initiate_observe_poll(
-                             core,
-                             std::move(id),
-                             token,
-                             options.timeout,
-                             options.persist_to,
-                             options.replicate_to,
-                             [obs_rec = std::move(obs_rec),
-                              resp = std::forward<decltype(resp)>(resp),
-                              handler = std::move(handler)](std::error_code ec) mutable {
-                               obs_rec->finish(resp.ctx.retry_attempts(), ec);
-                               if (ec) {
-                                 resp.ctx.override_ec(ec);
-                                 return handler(core::impl::make_error(std::move(resp.ctx)),
-                                                mutation_result{});
-                               }
-                               return handler(core::impl::make_error(std::move(resp.ctx)),
-                                              mutation_result{ resp.cas, std::move(resp.token) });
-                             });
-                         });
+    return core_.execute(
+      std::move(request),
+      [obs_rec = std::move(obs_rec),
+       core = core_,
+       id = std::move(id),
+       options,
+       handler = std::move(handler)](auto&& resp) mutable {
+        if (resp.ctx.ec()) {
+          obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              mutation_result{ resp.cas, std::move(resp.token) });
+          return;
+        }
+
+        auto token = resp.token;
+        core::impl::initiate_observe_poll(
+          core,
+          std::move(id),
+          token,
+          options.timeout,
+          options.persist_to,
+          options.replicate_to,
+          [obs_rec = std::move(obs_rec),
+           resp = std::forward<decltype(resp)>(resp),
+           handler = std::move(handler)](std::error_code ec) mutable {
+            obs_rec->finish(resp.ctx.retry_attempts(), ec);
+            if (ec) {
+              resp.ctx.override_ec(ec);
+              invoke_with_node_id(
+                std::move(handler), core::impl::make_error(std::move(resp.ctx)), mutation_result{});
+              return;
+            }
+            invoke_with_node_id(std::move(handler),
+                                core::impl::make_error(std::move(resp.ctx)),
+                                mutation_result{ resp.cas, std::move(resp.token) });
+          });
+      });
   }
 
   void decrement(std::string document_key,
@@ -282,10 +301,13 @@ public:
           obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
 
           if (resp.ctx.ec()) {
-            return handler(core::impl::make_error(std::move(resp.ctx)), counter_result{});
+            invoke_with_node_id(
+              std::move(handler), core::impl::make_error(std::move(resp.ctx)), counter_result{});
+            return;
           }
-          return handler(core::impl::make_error(std::move(resp.ctx)),
-                         counter_result{ resp.cas, std::move(resp.token), resp.content });
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              counter_result{ resp.cas, std::move(resp.token), resp.content });
         });
     }
 
@@ -310,8 +332,10 @@ public:
        handler = std::move(handler)](auto&& resp) mutable {
         if (resp.ctx.ec()) {
           obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
-          return handler(core::impl::make_error(std::move(resp.ctx)),
-                         counter_result{ resp.cas, std::move(resp.token), resp.content });
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              counter_result{ resp.cas, std::move(resp.token), resp.content });
+          return;
         }
 
         auto token = resp.token;
@@ -328,10 +352,13 @@ public:
             obs_rec->finish(resp.ctx.retry_attempts(), ec);
             if (ec) {
               resp.ctx.override_ec(ec);
-              return handler(core::impl::make_error(std::move(resp.ctx)), counter_result{});
+              invoke_with_node_id(
+                std::move(handler), core::impl::make_error(std::move(resp.ctx)), counter_result{});
+              return;
             }
-            return handler(core::impl::make_error(std::move(resp.ctx)),
-                           counter_result{ resp.cas, std::move(resp.token), resp.content });
+            invoke_with_node_id(std::move(handler),
+                                core::impl::make_error(std::move(resp.ctx)),
+                                counter_result{ resp.cas, std::move(resp.token), resp.content });
           });
       });
   }
@@ -367,10 +394,13 @@ public:
         [obs_rec = std::move(obs_rec), handler = std::move(handler)](auto&& resp) mutable {
           obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
           if (resp.ctx.ec()) {
-            return handler(core::impl::make_error(std::move(resp.ctx)), counter_result{});
+            invoke_with_node_id(
+              std::move(handler), core::impl::make_error(std::move(resp.ctx)), counter_result{});
+            return;
           }
-          return handler(core::impl::make_error(std::move(resp.ctx)),
-                         counter_result{ resp.cas, std::move(resp.token), resp.content });
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              counter_result{ resp.cas, std::move(resp.token), resp.content });
         });
     }
 
@@ -395,8 +425,10 @@ public:
        handler = std::move(handler)](auto&& resp) mutable {
         if (resp.ctx.ec()) {
           obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
-          return handler(core::impl::make_error(std::move(resp.ctx)),
-                         counter_result{ resp.cas, std::move(resp.token), resp.content });
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              counter_result{ resp.cas, std::move(resp.token), resp.content });
+          return;
         }
 
         auto token = resp.token;
@@ -413,10 +445,13 @@ public:
             obs_rec->finish(resp.ctx.retry_attempts(), ec);
             if (ec) {
               resp.ctx.override_ec(ec);
-              return handler(core::impl::make_error(std::move(resp.ctx)), counter_result{});
+              invoke_with_node_id(
+                std::move(handler), core::impl::make_error(std::move(resp.ctx)), counter_result{});
+              return;
             }
-            return handler(core::impl::make_error(std::move(resp.ctx)),
-                           counter_result{ resp.cas, std::move(resp.token), resp.content });
+            invoke_with_node_id(std::move(handler),
+                                core::impl::make_error(std::move(resp.ctx)),
+                                counter_result{ resp.cas, std::move(resp.token), resp.content });
           });
       });
   }