couchbase 3.7.0 → 3.8.0

data/ext/couchbase/core/io/http_session_manager.hxx

@@ -28,6 +28,7 @@
 #include "core/metrics/meter_wrapper.hxx"
 #include "core/operations/http_noop.hxx"
 #include "core/service_type.hxx"
+#include "core/tls_context_provider.hxx"
 #include "core/tracing/noop_tracer.hxx"
 #include "core/tracing/tracer_wrapper.hxx"
 #include "http_command.hxx"
@@ -58,10 +59,14 @@ class http_session_manager
 {
 #endif
 public:
-  http_session_manager(std::string client_id, asio::io_context& ctx, asio::ssl::context& tls)
+  http_session_manager(std::string client_id,
+                       asio::io_context& ctx,
+                       tls_context_provider& tls,
+                       origin& origin)
     : client_id_(std::move(client_id))
     , ctx_(ctx)
     , tls_(tls)
+    , origin_(origin)
   {
   }
 
@@ -192,8 +197,7 @@ public:
   template<typename Collector>
   void ping(std::set<service_type> services,
             std::optional<std::chrono::milliseconds> timeout,
-            std::shared_ptr<Collector> collector,
-            const couchbase::core::cluster_credentials& credentials)
+            std::shared_ptr<Collector> collector)
   {
     std::array known_types{
       service_type::query, service_type::analytics, service_type::search,
@@ -212,7 +216,16 @@ public:
         std::uint16_t port = node.port_or(options_.network, type, options_.enable_tls, 0);
         if (port != 0) {
           const auto& hostname = node.hostname_for(options_.network);
-          auto session = create_session(type, credentials, hostname, port, node.node_uuid);
+          const auto& canonical_hostname = node.hostname;
+          std::uint16_t canonical_port = node.port_or(type, options_.enable_tls, 0);
+          auto session = create_session(type,
+                                        node_details{
+                                          hostname,
+                                          port,
+                                          node.node_uuid,
+                                          canonical_hostname,
+                                          canonical_port,
+                                        });
           if (session->is_connected()) {
             std::scoped_lock lock(sessions_mutex_);
             busy_sessions_[type].push_back(session);
@@ -238,47 +251,26 @@ 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,
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-                      handler = collector->build_reporter()](error_union err,
-                                                             io::http_response&& msg) {
-            diag::ping_state state = diag::ping_state::ok;
-            std::optional<std::string> error{};
-            if (!std::holds_alternative<std::monostate>(err)) {
-              auto ec = std::holds_alternative<impl::bootstrap_error>(err)
-                          ? std::get<impl::bootstrap_error>(err).ec
-                          : std::get<std::error_code>(err);
-              if (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(), msg.status_code));
-              }
-            }
-#else
-                      handler = collector->build_reporter()](std::error_code ec,
-                                                             io::http_response&& msg) {
+                      handler =
+                        collector->build_reporter()](operations::http_noop_response&& resp) {
             diag::ping_state state = diag::ping_state::ok;
             std::optional<std::string> error{};
-            if (ec) {
+            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(), msg.status_code));
+              error.emplace(fmt::format("code={}, message={}, http_code={}",
+                                        ec.value(),
+                                        ec.message(),
+                                        resp.ctx.http_status));
             }
-#endif
             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.
@@ -310,19 +302,34 @@ public:
     }
   }
 
+  struct node_details {
+    std::string hostname{};
+    std::uint16_t port{};
+    std::string node_uuid{};
+    std::string canonical_hostname{};
+    std::uint16_t canonical_port{};
+  };
+
   auto check_out(service_type type,
-                 const couchbase::core::cluster_credentials& credentials,
-                 std::string preferred_node,
-                 const std::string& undesired_node = {})
+                 std::string preferred_node_address,
+                 const std::string& undesired_node_address = {})
     -> std::pair<std::error_code, std::shared_ptr<http_session>>
   {
-    std::string node_uuid{};
-
-    if (preferred_node.empty() && !undesired_node.empty()) {
-      auto [hostname, port, uuid] = pick_random_node(type, undesired_node);
-      if (port != 0) {
-        preferred_node = fmt::format("{}:{}", hostname, port);
-        node_uuid = uuid;
+    node_details preferred_node{};
+
+    if (preferred_node_address.empty() && !undesired_node_address.empty()) {
+      // This is currently only used by Columnar to avoid the node
+      // that was last used and to satisfy the requirement for retrying on a different randomly
+      // selected node (as opposed to any node we have an idle session to).
+      if (auto n = pick_random_node(type, undesired_node_address); n.port != 0) {
+        preferred_node_address = fmt::format("{}:{}", n.hostname, n.port);
+        preferred_node = std::move(n);
+      }
+    } else if (!preferred_node_address.empty()) {
+      // A 'sticky' node was specified. We should populate the node details.
+      preferred_node = lookup_node(type, preferred_node_address);
+      if (preferred_node.port == 0) {
+        return { errc::common::service_not_available, nullptr };
       }
     }
 
@@ -338,21 +345,21 @@ public:
     });
     std::shared_ptr<http_session> session{};
     while (!idle_sessions_[type].empty()) {
-      if (preferred_node.empty()) {
+      if (preferred_node_address.empty()) {
         session = idle_sessions_[type].front();
         idle_sessions_[type].pop_front();
         if (session->reset_idle()) {
           break;
         }
       } else {
-        auto [hostname, port] = split_host_port(preferred_node);
-
         auto ptr = std::find_if(idle_sessions_[type].begin(),
                                 idle_sessions_[type].end(),
-                                [&preferred_node, &h = hostname, &p = port](const auto& s) {
+                                [&preferred_node_address,
+                                 &h = preferred_node.hostname,
+                                 &p = preferred_node.port](const auto& s) {
                                   // Check for a match using both the unresolved hostname & IP
                                   // address
-                                  return (s->remote_address() == preferred_node ||
+                                  return (s->remote_address() == preferred_node_address ||
                                           (s->hostname() == h && s->port() == std::to_string(p)));
                                 });
         if (ptr != idle_sessions_[type].end()) {
@@ -362,7 +369,7 @@ public:
             break;
           }
         } else {
-          session = create_session(type, credentials, hostname, port, node_uuid);
+          session = create_session(type, preferred_node);
           break;
         }
       }
@@ -374,12 +381,12 @@ public:
       session.reset();
     }
     if (!session) {
-      auto [hostname, port, uuid] =
-        preferred_node.empty() ? next_node(type) : lookup_node(type, preferred_node);
-      if (port == 0) {
+      auto node = preferred_node_address.empty() ? next_node(type)
+                                                 : lookup_node(type, preferred_node_address);
+      if (node.port == 0) {
         return { errc::common::service_not_available, nullptr };
       }
-      session = create_session(type, credentials, hostname, port, uuid);
+      session = create_session(type, node);
     }
     if (session->is_connected()) {
       busy_sessions_[type].push_back(session);
@@ -462,13 +469,11 @@ public:
   }
 
   template<typename Request, typename Handler>
-  void execute(Request request,
-               Handler&& handler,
-               const couchbase::core::cluster_credentials& credentials)
+  void execute(Request request, Handler&& handler)
   {
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
     if (!configured_) {
-      return defer_command(request, std::move(handler), credentials);
+      return defer_command(request, std::move(handler));
     }
 #endif
     std::string preferred_node;
@@ -477,12 +482,12 @@ public:
         preferred_node = *request.send_to_node;
       }
     }
-    auto [error, session] = check_out(request.type, credentials, preferred_node);
+    auto [error, session] = check_out(request.type, preferred_node);
     if (error) {
       typename Request::error_context_type ctx{};
       ctx.ec = error;
-      using response_type = typename Request::encoded_response_type;
-      return handler(request.make_response(std::move(ctx), response_type{}));
+      using encoded_response_type = typename Request::encoded_response_type;
+      return handler(request.make_response(std::move(ctx), encoded_response_type{}));
     }
 
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
@@ -494,8 +499,6 @@ public:
       app_telemetry_meter_,
       options_.default_timeout_for(request.type),
       dispatch_timeout_);
-    cmd->start([self = shared_from_this(), cmd, handler = std::forward<Handler>(handler)](
-                 error_union err, io::http_response&& msg) mutable {
 #else
     auto cmd = std::make_shared<operations::http_command<Request>>(
       ctx_,
@@ -504,42 +507,12 @@ public:
       meter_,
       app_telemetry_meter_,
       options_.default_timeout_for(request.type));
-    cmd->start([self = shared_from_this(), cmd, handler = std::forward<Handler>(handler)](
-                 std::error_code ec, io::http_response&& msg) mutable {
 #endif
-      using command_type = typename decltype(cmd)::element_type;
-      using encoded_response_type = typename command_type::encoded_response_type;
-      using error_context_type = typename command_type::error_context_type;
-      encoded_response_type resp{ std::move(msg) };
-      error_context_type ctx{};
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-      if (!std::holds_alternative<std::monostate>(err)) {
-        if (std::holds_alternative<impl::bootstrap_error>(err)) {
-          auto bootstrap_error = std::get<impl::bootstrap_error>(err);
-          if (bootstrap_error.ec == errc::common::unambiguous_timeout) {
-            CB_LOG_DEBUG("Timeout caused by bootstrap error. code={}, ec_message={}, message={}.",
-                         bootstrap_error.ec.value(),
-                         bootstrap_error.ec.message(),
-                         bootstrap_error.error_message);
-          }
-          ctx.ec = bootstrap_error.ec;
-        } else {
-          ctx.ec = std::get<std::error_code>(err);
-        }
-      }
-#else
-      ctx.ec = ec;
-#endif
-      ctx.client_context_id = cmd->client_context_id_;
-      ctx.method = cmd->encoded.method;
-      ctx.path = cmd->encoded.path;
-      ctx.http_status = resp.status_code;
-      ctx.http_body = resp.body.data();
-      ctx.last_dispatched_from = cmd->session_->local_address();
-      ctx.last_dispatched_to = cmd->session_->remote_address();
-      ctx.hostname = cmd->session_->http_context().hostname;
-      ctx.port = cmd->session_->http_context().port;
-      handler(cmd->request.make_response(std::move(ctx), std::move(resp)));
+
+    using response_type = typename Request::response_type;
+    cmd->start([self = shared_from_this(), cmd, handler = std::forward<Handler>(handler)](
+                 response_type&& resp) mutable {
+      handler(std::move(resp));
       self->check_in(cmd->request.type, cmd->session_);
     });
     cmd->set_command_session(session);
@@ -596,15 +569,14 @@ public:
 
         // stop this session and create a new one w/ new hostname + port
         session->stop();
-        auto [hostname, port, node_uuid] = preferred_node.empty()
-                                             ? self->next_node(session->type())
-                                             : self->lookup_node(session->type(), preferred_node);
-        if (port == 0) {
+        const auto node = preferred_node.empty()
+                            ? self->next_node(session->type())
+                            : self->lookup_node(session->type(), preferred_node);
+        if (node.port == 0) {
           cb(errc::common::service_not_available, {});
           return;
         }
-        auto new_session =
-          self->create_session(session->type(), session->credentials(), hostname, port, node_uuid);
+        auto new_session = self->create_session(session->type(), node);
         if (new_session->is_connected()) {
           {
             const std::scoped_lock inner_lock(self->sessions_mutex_);
@@ -704,15 +676,14 @@ private:
         }
         // stop this session and create a new one w/ new hostname + port
         session->stop();
-        auto [hostname, port, node_uuid] = preferred_node.empty()
-                                             ? self->next_node(session->type())
-                                             : self->lookup_node(session->type(), preferred_node);
-        if (port == 0) {
+        const auto node = preferred_node.empty()
+                            ? self->next_node(session->type())
+                            : self->lookup_node(session->type(), preferred_node);
+        if (node.port == 0) {
           cmd->invoke_handler(errc::common::service_not_available, {});
           return;
         }
-        auto new_session =
-          self->create_session(session->type(), session->credentials(), hostname, port, node_uuid);
+        auto new_session = self->create_session(session->type(), node);
         cmd->set_command_session(new_session);
         if (new_session->is_connected()) {
           std::scoped_lock inner_lock(self->sessions_mutex_);
@@ -729,38 +700,48 @@ private:
     });
   }
 
-  auto create_session(service_type type,
-                      const couchbase::core::cluster_credentials& credentials,
-                      const std::string& hostname,
-                      std::uint16_t port,
-                      const std::string& node_uuid) -> std::shared_ptr<http_session>
+  auto create_session(service_type type, const node_details& node) -> std::shared_ptr<http_session>
   {
     std::shared_ptr<http_session> session;
     if (options_.enable_tls) {
-      session = std::make_shared<http_session>(
-        type,
-        client_id_,
-        node_uuid,
-        ctx_,
-        tls_,
-        credentials,
-        hostname,
-        std::to_string(port),
-        http_context{ config_, options_, query_cache_, hostname, port });
+      session = std::make_shared<http_session>(type,
+                                               client_id_,
+                                               node.node_uuid,
+                                               ctx_,
+                                               tls_,
+                                               origin_,
+                                               node.hostname,
+                                               std::to_string(node.port),
+                                               http_context{
+                                                 config_,
+                                                 options_,
+                                                 query_cache_,
+                                                 node.hostname,
+                                                 node.port,
+                                                 node.canonical_hostname,
+                                                 node.canonical_port,
+                                               });
     } else {
-      session = std::make_shared<http_session>(
-        type,
-        client_id_,
-        node_uuid,
-        ctx_,
-        credentials,
-        hostname,
-        std::to_string(port),
-        http_context{ config_, options_, query_cache_, hostname, port });
+      session = std::make_shared<http_session>(type,
+                                               client_id_,
+                                               node.node_uuid,
+                                               ctx_,
+                                               origin_,
+                                               node.hostname,
+                                               std::to_string(node.port),
+                                               http_context{
+                                                 config_,
+                                                 options_,
+                                                 query_cache_,
+                                                 node.hostname,
+                                                 node.port,
+                                                 node.canonical_hostname,
+                                                 node.canonical_port,
+                                               });
     }
 
     session->on_stop([type, id = session->id(), self = this->shared_from_this()]() {
-      std::scoped_lock inner_lock(self->sessions_mutex_);
+      const std::scoped_lock inner_lock(self->sessions_mutex_);
       self->busy_sessions_[type].remove_if([&id](const auto& s) {
         return !s || s->id() == id;
       });
@@ -773,9 +754,7 @@ private:
 
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
   template<typename Request, typename Handler>
-  void defer_command(Request request,
-                     Handler&& handler,
-                     const couchbase::core::cluster_credentials& credentials)
+  void defer_command(Request request, Handler&& handler)
   {
     {
       std::scoped_lock bootstrap_error_lock(last_bootstrap_error_mutex_);
@@ -794,74 +773,44 @@ private:
       app_telemetry_meter_,
       options_.default_timeout_for(request.type),
       dispatch_timeout_);
+    using response_type = typename Request::response_type;
     cmd->start([self = shared_from_this(), cmd, handler = std::forward<Handler>(handler)](
-                 error_union err, io::http_response&& msg) mutable {
-      using command_type = typename decltype(cmd)::element_type;
-      using encoded_response_type = typename command_type::encoded_response_type;
-      using error_context_type = typename command_type::error_context_type;
-      encoded_response_type resp{ std::move(msg) };
-      error_context_type ctx{};
-      if (!std::holds_alternative<std::monostate>(err)) {
-        if (std::holds_alternative<impl::bootstrap_error>(err)) {
-          auto bootstrap_error = std::get<impl::bootstrap_error>(err);
-          if (bootstrap_error.ec == errc::common::unambiguous_timeout) {
-            CB_LOG_DEBUG("Timeout caused by bootstrap error. code={}, ec_message={}, message={}.",
-                         bootstrap_error.ec.value(),
-                         bootstrap_error.ec.message(),
-                         bootstrap_error.error_message);
-          }
-          ctx.ec = bootstrap_error.ec;
-        } else {
-          ctx.ec = std::get<std::error_code>(err);
-        }
-      }
-      ctx.client_context_id = cmd->client_context_id_;
-      ctx.method = cmd->encoded.method;
-      ctx.path = cmd->encoded.path;
-      ctx.http_status = resp.status_code;
-      ctx.http_body = resp.body.data();
-      if (cmd->session_) {
-        ctx.last_dispatched_from = cmd->session_->local_address();
-        ctx.last_dispatched_to = cmd->session_->remote_address();
-        ctx.hostname = cmd->session_->http_context().hostname;
-        ctx.port = cmd->session_->http_context().port;
-      }
-      handler(cmd->request.make_response(std::move(ctx), std::move(resp)));
+                 response_type&& resp) mutable {
+      handler(std::move(resp));
       self->check_in(cmd->request.type, cmd->session_);
     });
     CB_LOG_DEBUG(R"(Adding HTTP request to deferred queue: {}, client_context_id="{}")",
                  cmd->request.type,
                  cmd->client_context_id_);
-    add_to_deferred_queue(
-      [self = shared_from_this(), cmd, request, credentials](error_union err) mutable {
-        if (!std::holds_alternative<std::monostate>(err)) {
-          using response_type = typename Request::encoded_response_type;
-          return cmd->invoke_handler(err, response_type{});
-        }
+    add_to_deferred_queue([self = shared_from_this(), cmd, request](error_union err) mutable {
+      if (!std::holds_alternative<std::monostate>(err)) {
+        using response_type = typename Request::encoded_response_type;
+        return cmd->invoke_handler(err, response_type{});
+      }
 
-        // don't do anything if the command wasn't dispatched or has already timed out
-        auto now = std::chrono::steady_clock::now();
-        if (cmd->dispatch_deadline_expiry() < now || cmd->deadline_expiry() < now) {
-          return;
-        }
-        std::string preferred_node;
-        if constexpr (http_traits::supports_sticky_node_v<Request>) {
-          if (request.send_to_node) {
-            preferred_node = *request.send_to_node;
-          }
-        }
-        auto [error, session] = self->check_out(request.type, credentials, preferred_node);
-        if (error) {
-          using response_type = typename Request::encoded_response_type;
-          return cmd->invoke_handler(error, response_type{});
-        }
-        cmd->set_command_session(session);
-        if (!session->is_connected()) {
-          self->connect_then_send(session, cmd, preferred_node);
-        } else {
-          cmd->send_to();
+      // don't do anything if the command wasn't dispatched or has already timed out
+      auto now = std::chrono::steady_clock::now();
+      if (cmd->dispatch_deadline_expiry() < now || cmd->deadline_expiry() < now) {
+        return;
+      }
+      std::string preferred_node;
+      if constexpr (http_traits::supports_sticky_node_v<Request>) {
+        if (request.send_to_node) {
+          preferred_node = *request.send_to_node;
         }
-      });
+      }
+      auto [error, session] = self->check_out(request.type, preferred_node);
+      if (error) {
+        using response_type = typename Request::encoded_response_type;
+        return cmd->invoke_handler(error, response_type{});
+      }
+      cmd->set_command_session(session);
+      if (!session->is_connected()) {
+        self->connect_then_send(session, cmd, preferred_node);
+      } else {
+        cmd->send_to();
+      }
+    });
   }
 
   void drain_deferred_queue(error_union err)
@@ -881,34 +830,29 @@ private:
   }
 #endif
 
-  auto next_node(service_type type) -> std::tuple<std::string, std::uint16_t, std::string>
+  auto next_node(service_type type) -> node_details
   {
     std::scoped_lock lock(config_mutex_);
     auto candidates = config_.nodes.size();
     while (candidates > 0) {
       --candidates;
-      std::scoped_lock index_lock(next_index_mutex_);
+      const std::scoped_lock index_lock(next_index_mutex_);
       const auto& node = config_.nodes[next_index_];
       next_index_ = (next_index_ + 1) % config_.nodes.size();
-      std::uint16_t port = node.port_or(options_.network, type, options_.enable_tls, 0);
+      const std::uint16_t port = node.port_or(options_.network, type, options_.enable_tls, 0);
       if (port != 0) {
         return {
-          node.hostname_for(options_.network),
-          port,
-          node.node_uuid,
+          node.hostname_for(options_.network),        port, node.node_uuid, node.hostname,
+          node.port_or(type, options_.enable_tls, 0),
         };
       }
     }
-    return {
-      "",
-      static_cast<std::uint16_t>(0U),
-      "",
-    };
+    return {};
   }
 
   auto split_host_port(const std::string& address) -> std::pair<std::string, std::uint16_t>
   {
-    auto last_colon = address.find_last_of(':');
+    const auto last_colon = address.find_last_of(':');
     if (last_colon == std::string::npos || address.size() - 1 == last_colon) {
       return { "", static_cast<std::uint16_t>(0U) };
     }
@@ -917,30 +861,22 @@ private:
     return { hostname, port };
   }
 
-  auto lookup_node(service_type type, const std::string& preferred_node)
-    -> std::tuple<std::string, std::uint16_t, std::string>
+  auto lookup_node(service_type type, const std::string& preferred_node_address) -> node_details
   {
-    std::scoped_lock lock(config_mutex_);
-    auto [hostname, port] = split_host_port(preferred_node);
+    const std::scoped_lock lock(config_mutex_);
+    auto [hostname, port] = split_host_port(preferred_node_address);
     for (const auto& node : config_.nodes) {
       if (node.hostname_for(options_.network) == hostname &&
           node.port_or(options_.network, type, options_.enable_tls, 0) == port) {
         return {
-          hostname,
-          port,
-          node.node_uuid,
+          hostname, port, node.node_uuid, node.hostname, node.port_or(type, options_.enable_tls, 0),
         };
       }
     }
-    return {
-      "",
-      static_cast<std::uint16_t>(0U),
-      "",
-    };
+    return {};
   }
 
-  auto pick_random_node(service_type type, const std::string& undesired_node)
-    -> std::tuple<std::string, std::uint16_t, std::string>
+  auto pick_random_node(service_type type, const std::string& undesired_node) -> node_details
   {
     std::vector<topology::configuration::node> candidate_nodes{};
     {
@@ -956,11 +892,7 @@ private:
 
     if (candidate_nodes.empty()) {
       // Could not find any other nodes
-      return {
-        "",
-        static_cast<std::uint16_t>(0U),
-        "",
-      };
+      return {};
     }
 
     std::vector<topology::configuration::node> selected{};
@@ -974,12 +906,15 @@ private:
       first_selected.hostname_for(options_.network),
       first_selected.port_or(options_.network, type, options_.enable_tls, 0),
       first_selected.node_uuid,
+      first_selected.hostname,
+      first_selected.port_or(type, options_.enable_tls, 0),
     };
   }
 
   std::string client_id_;
   asio::io_context& ctx_;
-  asio::ssl::context& tls_;
+  tls_context_provider& tls_;
+  origin& origin_;
   std::shared_ptr<tracing::tracer_wrapper> tracer_{ nullptr };
   std::shared_ptr<metrics::meter_wrapper> meter_{ nullptr };
   std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter_{ nullptr };

data/ext/couchbase/core/io/http_traits.hxx

@@ -28,13 +28,6 @@ struct supports_sticky_node : public std::false_type {
 template<typename T>
 inline constexpr bool supports_sticky_node_v = supports_sticky_node<T>::value;
 
-template<typename T>
-struct supports_parent_span : public std::false_type {
-};
-
-template<typename T>
-inline constexpr bool supports_parent_span_v = supports_parent_span<T>::value;
-
 template<typename T>
 struct supports_readonly : public std::false_type {
 };