couchbase 3.8.0 → 3.8.2

data/ext/couchbase/core/operations/management/scope_drop.cxx

@@ -24,13 +24,11 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
-scope_drop_request::encode_to(encoded_request_type& encoded,
-                              http_context& /* context */) const -> std::error_code
+scope_drop_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+  -> std::error_code
 {
   encoded.method = "DELETE";
   encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}",
@@ -45,13 +43,14 @@ scope_drop_request::make_response(error_context::http&& ctx,
 {
   scope_drop_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
-    switch (encoded.status_code) {
+    switch (const auto& body = encoded.body.data(); encoded.status_code) {
       case 400:
         response.ctx.ec = errc::common::unsupported_operation;
         break;
       case 404: {
-        const std::regex scope_not_found("Scope with name .+ is not found");
-        if (std::regex_search(encoded.body.data(), scope_not_found)) {
+        const auto prefix_pos = body.find("Scope with name ");
+        if (prefix_pos != std::string_view::npos &&
+            body.find(" is not found", prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::common::scope_not_found;
         } else {
           response.ctx.ec = errc::common::bucket_not_found;
@@ -60,7 +59,7 @@ scope_drop_request::make_response(error_context::http&& ctx,
       case 200: {
         tao::json::value payload{};
         try {
-          payload = utils::json::parse(encoded.body.data());
+          payload = utils::json::parse(body);
         } catch (const tao::pegtl::parse_error&) {
           response.ctx.ec = errc::common::parsing_failure;
           return response;
@@ -68,7 +67,7 @@ scope_drop_request::make_response(error_context::http&& ctx,
         response.uid = std::stoull(payload.at("uid").get_string(), nullptr, 16);
       } break;
       default:
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec = extract_common_error_code(encoded.status_code, body);
         break;
     }
   }

data/ext/couchbase/core/topology/configuration.cxx

@@ -17,6 +17,7 @@
 
 #include "configuration.hxx"
 
+#include "core/impl/node_id.hxx"
 #include "core/logger/logger.hxx"
 #include "core/service_type_fmt.hxx"
 #include "core/utils/crc32.hxx"
@@ -171,6 +172,26 @@ configuration::node::endpoint(const std::string& network, service_type type, boo
   return fmt::format("{}:{}", hostname_for(network), p);
 }
 
+auto
+configuration::node::effective_node_id(bool is_tls) const -> couchbase::node_id
+{
+  return internal_node_id::build(node_uuid, hostname, port_or(service_type::key_value, is_tls, 0));
+}
+
+auto
+configuration::effective_node_ids(bool is_tls) const -> std::vector<couchbase::node_id>
+{
+  std::vector<couchbase::node_id> result;
+  result.reserve(nodes.size());
+  for (const auto& n : nodes) {
+    if (n.port_or(service_type::key_value, is_tls, 0) == 0) {
+      continue;
+    }
+    result.push_back(n.effective_node_id(is_tls));
+  }
+  return result;
+}
+
 auto
 configuration::has_node(const std::string& network,
                         service_type type,

data/ext/couchbase/core/topology/configuration.hxx

@@ -21,6 +21,8 @@
 #include "core/platform/uuid.h"
 #include "core/service_type.hxx"
 
+#include <couchbase/node_id.hxx>
+
 #include <map>
 #include <optional>
 #include <set>
@@ -83,10 +85,36 @@ struct configuration {
 
     [[nodiscard]] auto endpoint(const std::string& network, service_type type, bool is_tls) const
       -> std::optional<std::string>;
+
+    /**
+     * Returns a node_id built from this node's UUID (when available on
+     * Server 8.0.1+) with fallback to a deterministic hash of hostname +
+     * KV port for older servers.
+     *
+     * The KV port selected mirrors what mcbp_session uses for the same node
+     * (TLS port when @p is_tls, plain port otherwise), ensuring that the
+     * node_id surfaced on the request side via collection::node_id_for
+     * matches the node_id attached to results and errors.
+     */
+    [[nodiscard]] auto effective_node_id(bool is_tls) const -> couchbase::node_id;
   };
 
   [[nodiscard]] auto select_network(const std::string& bootstrap_hostname) const -> std::string;
 
+  /**
+   * Returns one node_id per cluster node that currently serves the
+   * key-value service over the requested transport. Nodes that do not
+   * expose a KV port for @p is_tls are filtered out — without a KV port
+   * the fallback hash would be derived from a meaningless port=0 and
+   * could collide with a sibling node that is also missing its KV port.
+   *
+   * The returned vector preserves topology order; callers that want a
+   * set semantic should hash the entries themselves (couchbase::node_id
+   * is hashable). Topology nodes are unique by construction, so no
+   * dedup is performed here.
+   */
+  [[nodiscard]] auto effective_node_ids(bool is_tls) const -> std::vector<couchbase::node_id>;
+
   using vbucket_map = typename std::vector<std::vector<std::int16_t>>;
 
   std::optional<std::int64_t> epoch{};