couchbase 3.7.0 → 3.8.1

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,66 +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,
-#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) {
+          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(), msg.status_code));
+                error.emplace(fmt::format("code={}, message={}, http_code={}",
+                                          ec.value(),
+                                          ec.message(),
+                                          resp.ctx.http_status));
               }
-            }
-#else
-                      handler = collector->build_reporter()](std::error_code ec,
-                                                             io::http_response&& msg) {
-            diag::ping_state state = diag::ping_state::ok;
-            std::optional<std::string> error{};
-            if (ec) {
-              if (ec == errc::common::unambiguous_timeout ||
-                  ec == errc::common::ambiguous_timeout) {
-                state = diag::ping_state::timeout;
-              } else {
-                state = diag::ping_state::error;
+              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());
               }
-              error.emplace(fmt::format(
-                "code={}, message={}, http_code={}", ec.value(), ec.message(), msg.status_code));
-            }
-#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.
-            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_);
-          });
+              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()) {
@@ -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);
@@ -395,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,
@@ -405,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;
+        });
+      }
     }
   }
 
@@ -462,13 +492,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 +505,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 +522,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 +530,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 +592,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 +699,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,53 +723,78 @@ 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_);
-      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;
   }
 
 #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 +813,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 +870,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 +901,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 +932,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 +946,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 };