couchbase 4.7.0-dev.1 → 4.7.1

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

@@ -75,6 +75,17 @@ error::error(std::error_code ec,
 {
 }
 
+error::error(std::error_code ec,
+             std::string message,
+             couchbase::error_context ctx,
+             couchbase::node_id node_id)
+  : ec_{ ec }
+  , message_{ std::move(message) }
+  , ctx_{ std::move(ctx) }
+  , node_id_{ std::move(node_id) }
+{
+}
+
 auto
 error::ec() const -> std::error_code
 {
@@ -103,6 +114,12 @@ error::cause() const -> std::optional<error>
   return *cause_;
 }
 
+auto
+error::node_id() const -> const couchbase::node_id&
+{
+  return node_id_;
+}
+
 error::operator bool() const
 {
   return ec_.value() != 0;
@@ -164,19 +181,27 @@ make_error(const core::error_context::http& core_ctx) -> couchbase::error
 auto
 make_error(const couchbase::core::key_value_error_context& core_ctx) -> couchbase::error
 {
+  // Always preserve the node_id so that callers on both success and error
+  // paths can identify which node handled the request.
   if (!core_ctx.ec()) {
-    return {};
+    return { {}, {}, {}, core_ctx.last_dispatched_to_node_id() };
   }
-  return { core_ctx.ec(), {}, internal_error_context::build_error_context(core_ctx) };
+  return { core_ctx.ec(),
+           {},
+           internal_error_context::build_error_context(core_ctx),
+           core_ctx.last_dispatched_to_node_id() };
 }
 
 auto
 make_error(const couchbase::core::subdocument_error_context& core_ctx) -> couchbase::error
 {
   if (!core_ctx.ec()) {
-    return {};
+    return { {}, {}, {}, core_ctx.last_dispatched_to_node_id() };
   }
-  return { core_ctx.ec(), {}, internal_error_context::build_error_context(core_ctx) };
+  return { core_ctx.ec(),
+           {},
+           internal_error_context::build_error_context(core_ctx),
+           core_ctx.last_dispatched_to_node_id() };
 }
 
 auto

package/deps/couchbase-cxx-client/core/impl/invoke_with_node_id.hxx

@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <couchbase/error.hxx>
+
+#include <utility>
+
+namespace couchbase::core::impl
+{
+/**
+ * Forwards (err, result) to the caller's handler, propagating the node_id
+ * carried by the error (which make_error populates for KV contexts) onto
+ * the result. Using a plain function template avoids the extra std::function
+ * allocation a type-erasing wrapper would introduce for the sole purpose of
+ * setting node_id - that extra allocation was the source of the 18
+ * "Potential memory leak" reports clang-static-analyzer flagged against the
+ * previous wrap_with_node_id helper. The handler is taken by forwarding
+ * reference and perfect-forwarded to the invocation so that callers moving
+ * an rvalue handler consume it without an intermediate copy.
+ */
+template<typename Handler, typename Result>
+void
+invoke_with_node_id(Handler&& handler, couchbase::error err, Result result)
+{
+  result.node_id(err.node_id());
+  std::forward<Handler>(handler)(std::move(err), std::move(result));
+}
+} // namespace couchbase::core::impl

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

@@ -0,0 +1,110 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "node_id.hxx"
+
+#include "core/utils/crc32.hxx"
+
+#include <spdlog/fmt/bundled/core.h>
+
+#include <cstdint>
+#include <string>
+
+namespace couchbase
+{
+
+namespace
+{
+/**
+ * Produces a stable, opaque hex string from hostname + KV port.
+ *
+ * Uses CRC32 (already in-tree for vBucket mapping) rather than a
+ * cryptographic hash — collision resistance across a handful of cluster
+ * nodes is more than sufficient, and this avoids pulling in OpenSSL headers.
+ */
+auto
+derive_fallback_id(const std::string& hostname, std::uint16_t port) -> std::string
+{
+  auto input = fmt::format("{}:{}", hostname, port);
+  auto crc = core::utils::hash_crc32(input.data(), input.size());
+  return fmt::format("{:08x}", crc);
+}
+} // namespace
+
+node_id::node_id(std::string node_uuid, std::string hostname, std::uint16_t port)
+  : node_uuid_{ std::move(node_uuid) }
+  , hostname_{ std::move(hostname) }
+  , port_{ port }
+  , id_{ node_uuid_.empty() ? derive_fallback_id(hostname_, port_) : node_uuid_ }
+{
+}
+
+auto
+node_id::id() const -> const std::string&
+{
+  return id_;
+}
+
+auto
+node_id::node_uuid() const -> const std::string&
+{
+  return node_uuid_;
+}
+
+auto
+node_id::hostname() const -> const std::string&
+{
+  return hostname_;
+}
+
+auto
+node_id::port() const -> std::uint16_t
+{
+  return port_;
+}
+
+node_id::
+operator bool() const
+{
+  return !id_.empty();
+}
+
+auto
+node_id::operator==(const node_id& other) const -> bool
+{
+  return id_ == other.id_;
+}
+
+auto
+node_id::operator!=(const node_id& other) const -> bool
+{
+  return !(*this == other);
+}
+
+auto
+node_id::operator<(const node_id& other) const -> bool
+{
+  return id_ < other.id_;
+}
+
+auto
+internal_node_id::build(std::string node_uuid, std::string hostname, std::uint16_t port) -> node_id
+{
+  return { std::move(node_uuid), std::move(hostname), port };
+}
+
+} // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/node_id.hxx

@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <couchbase/node_id.hxx>
+
+#include <cstdint>
+#include <string>
+
+namespace couchbase
+{
+
+/**
+ * Internal factory for constructing node_id instances from core-level data.
+ *
+ * This class is a friend of node_id and provides the only way to construct
+ * a non-default node_id outside the couchbase namespace.
+ */
+class internal_node_id
+{
+public:
+  static auto build(std::string node_uuid, std::string hostname, std::uint16_t port) -> node_id;
+};
+
+} // namespace couchbase

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

@@ -0,0 +1,67 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <optional>
+#include <string>
+
+namespace couchbase::core::io
+{
+/**
+ * Decide whether a freshly received cluster map belongs to this session and must
+ * therefore be accepted.
+ *
+ * A session's bucket binding is fixed for its entire lifetime (set once in the
+ * constructor, never reassigned), so the rule reduces to a single invariant:
+ * the bucket identity carried by the configuration must match the bucket identity
+ * of the session.
+ *
+ *   - a cluster-level (bucket-less) session accepts only cluster-level configs;
+ *   - a bucket-level session accepts only configs for *its own* bucket.
+ *
+ * @param config_bucket   bucket name embedded in the configuration payload
+ *                        (std::nullopt  =>  cluster-level / GCCCP config)
+ * @param session_bucket  bucket this session is bound to
+ *                        (std::nullopt  =>  cluster-level / GCCCP session)
+ * @return true if the configuration must be accepted, false if it must be ignored
+ */
+[[nodiscard]] inline auto
+configuration_belongs_to_session(const std::optional<std::string>& config_bucket,
+                                 const std::optional<std::string>& session_bucket) -> bool
+{
+  // Stage 1 — cluster-level config for a cluster-level session.
+  // Neither side names a bucket: this is a GCCCP (cluster) map and the session is
+  // not bound to any bucket, so the config belongs here. Accept.
+  if (!config_bucket.has_value() && !session_bucket.has_value()) {
+    return true;
+  }
+
+  // Stage 2 — cardinality mismatch: exactly one side names a bucket. Reject.
+  // Either a bucket-less config arrived on a bucket-bound session, or a bucket
+  // config arrived on a cluster-level session. In both cases the config does not
+  // belong to this session.
+  if (config_bucket.has_value() != session_bucket.has_value()) {
+    return false;
+  }
+
+  // Stage 3 — both sides name a bucket: accept only if it is the *same* bucket.
+  // Reaching here guarantees both optionals are engaged, so value() is safe.
+  // Guards against applying another bucket's map to this session.
+  return config_bucket.value() == session_bucket.value();
+}
+} // namespace couchbase::core::io

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

@@ -251,45 +251,45 @@ public:
             app_telemetry_meter_,
             options_.default_timeout_for(request.type));
 #endif
-          cmd->start([start = std::chrono::steady_clock::now(),
-                      self = shared_from_this(),
-                      type,
-                      cmd,
-                      handler =
-                        collector->build_reporter()](operations::http_noop_response&& resp) {
-            diag::ping_state state = diag::ping_state::ok;
-            std::optional<std::string> error{};
-            if (auto ec = resp.ctx.ec; ec) {
-              if (ec == errc::common::unambiguous_timeout ||
-                  ec == errc::common::ambiguous_timeout) {
-                state = diag::ping_state::timeout;
-              } else {
-                state = diag::ping_state::error;
+          cmd->start(
+            [start = std::chrono::steady_clock::now(),
+             self = shared_from_this(),
+             type,
+             cmd,
+             handler = collector->build_reporter()](operations::http_noop_response&& resp) {
+              diag::ping_state state = diag::ping_state::ok;
+              std::optional<std::string> error{};
+              if (auto ec = resp.ctx.ec; ec) {
+                if (ec == errc::common::unambiguous_timeout ||
+                    ec == errc::common::ambiguous_timeout) {
+                  state = diag::ping_state::timeout;
+                } else {
+                  state = diag::ping_state::error;
+                }
+                error.emplace(fmt::format("code={}, message={}, http_code={}",
+                                          ec.value(),
+                                          ec.message(),
+                                          resp.ctx.http_status));
               }
-              error.emplace(fmt::format("code={}, message={}, http_code={}",
-                                        ec.value(),
-                                        ec.message(),
-                                        resp.ctx.http_status));
-            }
-            auto remote_address = cmd->session_->remote_address();
-            // If not connected, the remote address will be empty.  Better to
-            // give the user some context on the "attempted" remote address.
-            if (remote_address.empty()) {
-              remote_address =
-                fmt::format("{}:{}", cmd->session_->hostname(), cmd->session_->port());
-            }
-            handler->report(
-              diag::endpoint_ping_info{ type,
-                                        cmd->session_->id(),
-                                        std::chrono::duration_cast<std::chrono::microseconds>(
-                                          std::chrono::steady_clock::now() - start),
-                                        remote_address,
-                                        cmd->session_->local_address(),
-                                        state,
-                                        {},
-                                        error });
-            self->check_in(type, cmd->session_);
-          });
+              auto remote_address = cmd->session_->remote_address();
+              // If not connected, the remote address will be empty.  Better to
+              // give the user some context on the "attempted" remote address.
+              if (remote_address.empty()) {
+                remote_address =
+                  fmt::format("{}:{}", cmd->session_->hostname(), cmd->session_->port());
+              }
+              handler->report(
+                diag::endpoint_ping_info{ type,
+                                          cmd->session_->id(),
+                                          std::chrono::duration_cast<std::chrono::microseconds>(
+                                            std::chrono::steady_clock::now() - start),
+                                          remote_address,
+                                          cmd->session_->local_address(),
+                                          state,
+                                          {},
+                                          error });
+              self->check_in(type, cmd->session_);
+            });
 
           cmd->set_command_session(session);
           if (!session->is_connected()) {
@@ -402,9 +402,20 @@ public:
       return;
     }
     if (!session->is_connected()) {
-      CB_LOG_DEBUG("{} HTTP session never connected.  Skipping check-in", session->log_prefix());
-      return session.reset();
+      {
+        std::scoped_lock lock(sessions_mutex_);
+        if (auto pend_it = pending_sessions_.find(type); pend_it != pending_sessions_.end()) {
+          pend_it->second.remove_if([id = session->id()](const auto& s) {
+            return !s || s->id() == id;
+          });
+        }
+      }
+      CB_LOG_DEBUG("{} HTTP session never connected.  Ensured session is not in pending.",
+                   session->log_prefix());
+      return;
     }
+    bool should_stop = false;
+    std::chrono::milliseconds idle_timeout{};
     {
       std::scoped_lock lock(config_mutex_);
       if (!session->keep_alive() || !config_.has_node(options_.network,
@@ -412,22 +423,34 @@ public:
                                                       options_.enable_tls,
                                                       session->hostname(),
                                                       session->port())) {
-        return asio::post(session->get_executor(), [session]() {
-          session->stop();
-        });
+        should_stop = true;
+      } else {
+        idle_timeout = options_.idle_http_connection_timeout;
       }
     }
+    if (should_stop) {
+      return asio::post(session->get_executor(), [session]() {
+        session->stop();
+      });
+    }
     if (!session->is_stopped()) {
-      session->set_idle(options_.idle_http_connection_timeout);
+      // set_idle() arms the idle timer via async_wait — it never calls stop() inline,
+      // so on_stop cannot re-enter sessions_mutex_ here. It must precede publication to
+      // idle_sessions_ so a concurrent check_out's reset_idle() finds a pending timer.
+      session->set_idle(idle_timeout);
       CB_LOG_DEBUG("{} put HTTP session back to idle connections", session->log_prefix());
       std::scoped_lock lock(sessions_mutex_);
       idle_sessions_[type].push_back(session);
-      busy_sessions_[type].remove_if([id = session->id()](const auto& s) -> bool {
-        return !s || s->id() == id;
-      });
-      pending_sessions_[type].remove_if([id = session->id()](const auto& s) -> bool {
-        return !s || s->id() == id;
-      });
+      if (auto busy_it = busy_sessions_.find(type); busy_it != busy_sessions_.end()) {
+        busy_it->second.remove_if([id = session->id()](const auto& s) -> bool {
+          return !s || s->id() == id;
+        });
+      }
+      if (auto pend_it = pending_sessions_.find(type); pend_it != pending_sessions_.end()) {
+        pend_it->second.remove_if([id = session->id()](const auto& s) -> bool {
+          return !s || s->id() == id;
+        });
+      }
     }
   }
 
@@ -741,13 +764,30 @@ private:
     }
 
     session->on_stop([type, id = session->id(), self = this->shared_from_this()]() {
-      const std::scoped_lock inner_lock(self->sessions_mutex_);
-      self->busy_sessions_[type].remove_if([&id](const auto& s) {
-        return !s || s->id() == id;
-      });
-      self->idle_sessions_[type].remove_if([&id](const auto& s) {
-        return !s || s->id() == id;
-      });
+      // Declared outside the lock so destructors run after sessions_mutex_ is released.
+      // cppcheck-suppress variableScope
+      std::vector<std::shared_ptr<http_session>> dropped;
+      {
+        const std::scoped_lock inner_lock(self->sessions_mutex_);
+        for (auto* map :
+             { &self->busy_sessions_, &self->idle_sessions_, &self->pending_sessions_ }) {
+          auto map_it = map->find(type);
+          if (map_it == map->end()) {
+            continue;
+          }
+          auto& list = map_it->second;
+          for (auto it = list.begin(); it != list.end();) {
+            if (!*it || (*it)->id() == id) {
+              if (*it) {
+                dropped.push_back(std::move(*it));
+              }
+              it = list.erase(it);
+            } else {
+              ++it;
+            }
+          }
+        }
+      }
     });
     return session;
   }

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

@@ -22,6 +22,7 @@
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
 #include "core/columnar/background_bootstrap_listener.hxx"
 #endif
+#include "configuration_belongs_to_session.hxx"
 #include "core/config_listener.hxx"
 #include "core/diagnostics.hxx"
 #include "core/impl/bootstrap_error.hxx"
@@ -634,14 +635,9 @@ class mcbp_session_impl
                 }
               }
               std::optional<topology::configuration> config = req.body().config();
-              if (session_ && config.has_value()) {
-                if ((!config->bucket.has_value() && req.body().bucket().empty()) ||
-                    (session_->bucket_name_.has_value() && !req.body().bucket().empty() &&
-                     // TODO(CXXCBC-549)
-                     // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-                     session_->bucket_name_.value() == req.body().bucket())) {
-                  session_->update_configuration(std::move(config.value()));
-                }
+              if (session_ && config.has_value() &&
+                  configuration_belongs_to_session(config->bucket, session_->bucket_name_)) {
+                session_->update_configuration(std::move(config.value()));
               }
             } break;
             default:
@@ -824,14 +820,9 @@ class mcbp_session_impl
                 }
               }
               std::optional<topology::configuration> config = req.body().config();
-              if (session_ && config.has_value()) {
-                if ((!config->bucket.has_value() && req.body().bucket().empty()) ||
-                    (session_->bucket_name_.has_value() && !req.body().bucket().empty() &&
-                     // TODO(CXXCBC-549)
-                     // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-                     session_->bucket_name_.value() == req.body().bucket())) {
-                  session_->update_configuration(std::move(config.value()));
-                }
+              if (session_ && config.has_value() &&
+                  configuration_belongs_to_session(config->bucket, session_->bucket_name_)) {
+                session_->update_configuration(std::move(config.value()));
               }
             } break;
             default:

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

@@ -18,6 +18,7 @@
 #pragma once
 
 #include <couchbase/error_codes.hxx>
+#include <couchbase/node_id.hxx>
 
 #include "core/error_context/key_value.hxx"
 #include "core/impl/get_replica.hxx"
@@ -40,6 +41,7 @@ struct get_all_replicas_response {
     couchbase::cas cas{};
     std::uint32_t flags{};
     bool replica{ true };
+    couchbase::node_id dispatched_to_node_id{};
   };
   key_value_error_context ctx{};
   std::vector<entry> entries{};
@@ -156,8 +158,12 @@ struct get_all_replicas_request {
                       return;
                     }
                   } else {
-                    ctx->result_.emplace_back(get_all_replicas_response::entry{
-                      std::move(resp.value), resp.cas, resp.flags, true /* replica */ });
+                    ctx->result_.emplace_back(
+                      get_all_replicas_response::entry{ std::move(resp.value),
+                                                        resp.cas,
+                                                        resp.flags,
+                                                        true /* replica */,
+                                                        resp.ctx.last_dispatched_to_node_id() });
                   }
                   if (ctx->expected_responses_ == 0) {
                     ctx->done_ = true;
@@ -203,8 +209,12 @@ struct get_all_replicas_request {
                       return;
                     }
                   } else {
-                    ctx->result_.emplace_back(get_all_replicas_response::entry{
-                      std::move(resp.value), resp.cas, resp.flags, false /* active */ });
+                    ctx->result_.emplace_back(
+                      get_all_replicas_response::entry{ std::move(resp.value),
+                                                        resp.cas,
+                                                        resp.flags,
+                                                        false /* active */,
+                                                        resp.ctx.last_dispatched_to_node_id() });
                   }
                   if (ctx->expected_responses_ == 0) {
                     ctx->done_ = true;

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

@@ -210,14 +210,13 @@ get_projected_request::make_response(key_value_error_context&& ctx,
           response.ctx.override_ec(errc::common::parsing_failure);
           return response;
         }
-        tao::json::value new_doc;
+        tao::json::value new_doc = tao::json::empty_object;
         for (const auto& projection : projections) {
           if (auto value_to_apply = subdoc_lookup(full_doc, projection)) {
             subdoc_apply_projection(new_doc, projection, *value_to_apply, preserve_array_indexes);
-          } else {
-            response.ctx.override_ec(errc::key_value::path_not_found);
-            return response;
           }
+          // We ignore paths that were not found, similar to how we ignore them in the subdoc
+          // multi-lookup below.
         }
         response.value = utils::json::generate_binary(new_doc);
       }

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

@@ -28,6 +28,7 @@
 
 #include <couchbase/codec/encoded_value.hxx>
 #include <couchbase/error_codes.hxx>
+#include <couchbase/node_id.hxx>
 
 #include <functional>
 #include <memory>
@@ -50,6 +51,7 @@ struct lookup_in_all_replicas_response {
     couchbase::cas cas{};
     bool deleted{ false };
     bool is_replica{ true };
+    couchbase::node_id dispatched_to_node_id{};
   };
   subdocument_error_context ctx{};
   std::vector<entry> entries{};
@@ -203,6 +205,7 @@ struct lookup_in_all_replicas_request {
                       top_entry.cas = resp.cas;
                       top_entry.deleted = resp.deleted;
                       top_entry.is_replica = true;
+                      top_entry.dispatched_to_node_id = resp.ctx.last_dispatched_to_node_id();
                       for (auto& field : resp.fields) {
                         lookup_in_all_replicas_response::entry::lookup_in_entry lookup_in_entry{};
                         lookup_in_entry.path = field.path;
@@ -267,6 +270,7 @@ struct lookup_in_all_replicas_request {
                         top_entry.cas = resp.cas;
                         top_entry.deleted = resp.deleted;
                         top_entry.is_replica = false;
+                        top_entry.dispatched_to_node_id = resp.ctx.last_dispatched_to_node_id();
                         for (auto& field : resp.fields) {
                           lookup_in_all_replicas_response::entry::lookup_in_entry lookup_in_entry{};
                           lookup_in_entry.path = field.path;