couchbase 4.4.1-dev.2 → 4.4.2

package/deps/couchbase-cxx-client/core/cluster.cxx

@@ -15,40 +15,138 @@
  *   limitations under the License.
  */
 
-#include "couchbase/build_config.hxx"
+#include <couchbase/build_config.hxx>
 
 #include "cluster.hxx"
 
 #include "bucket.hxx"
 #include "capella_ca.hxx"
+#include "core/diagnostics.hxx"
 #include "core/impl/get_replica.hxx"
 #include "core/impl/lookup_in_replica.hxx"
 #include "core/impl/observe_seqno.hxx"
 #include "core/io/http_command.hxx"
+#include "core/io/http_message.hxx"
 #include "core/io/http_session_manager.hxx"
-#include "core/io/mcbp_command.hxx"
 #include "core/io/mcbp_session.hxx"
-#include "core/management/analytics_link.hxx"
-#include "core/mcbp/completion_token.hxx"
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+#include "core/io/config_tracker.hxx"
+#endif
+#include "core/logger/logger.hxx"
+#include "core/management/analytics_link_azure_blob_external.hxx"
+#include "core/management/analytics_link_couchbase_remote.hxx"
+#include "core/management/analytics_link_s3_external.hxx"
 #include "core/mcbp/queue_request.hxx"
+#include "core/meta/version.hxx"
 #include "core/metrics/logging_meter.hxx"
 #include "core/metrics/noop_meter.hxx"
-#include "core/operations.hxx"
-#include "core/operations/management/analytics.hxx"
-#include "core/operations/management/bucket.hxx"
+#include "core/operations/document_analytics.hxx"
+#include "core/operations/document_append.hxx"
+#include "core/operations/document_decrement.hxx"
+#include "core/operations/document_exists.hxx"
+#include "core/operations/document_get.hxx"
+#include "core/operations/document_get_all_replicas.hxx"
+#include "core/operations/document_get_and_lock.hxx"
+#include "core/operations/document_get_and_touch.hxx"
+#include "core/operations/document_get_any_replica.hxx"
+#include "core/operations/document_get_projected.hxx"
+#include "core/operations/document_increment.hxx"
+#include "core/operations/document_insert.hxx"
+#include "core/operations/document_lookup_in.hxx"
+#include "core/operations/document_lookup_in_all_replicas.hxx"
+#include "core/operations/document_lookup_in_any_replica.hxx"
+#include "core/operations/document_mutate_in.hxx"
+#include "core/operations/document_prepend.hxx"
+#include "core/operations/document_query.hxx"
+#include "core/operations/document_remove.hxx"
+#include "core/operations/document_replace.hxx"
+#include "core/operations/document_search.hxx"
+#include "core/operations/document_touch.hxx"
+#include "core/operations/document_unlock.hxx"
+#include "core/operations/document_upsert.hxx"
+#include "core/operations/document_view.hxx"
+#include "core/operations/http_noop.hxx"
+#include "core/operations/management/analytics_dataset_create.hxx"
+#include "core/operations/management/analytics_dataset_drop.hxx"
+#include "core/operations/management/analytics_dataset_get_all.hxx"
+#include "core/operations/management/analytics_dataverse_create.hxx"
+#include "core/operations/management/analytics_dataverse_drop.hxx"
+#include "core/operations/management/analytics_get_pending_mutations.hxx"
+#include "core/operations/management/analytics_index_create.hxx"
+#include "core/operations/management/analytics_index_drop.hxx"
+#include "core/operations/management/analytics_index_get_all.hxx"
+#include "core/operations/management/analytics_link_connect.hxx"
+#include "core/operations/management/analytics_link_create.hxx"
+#include "core/operations/management/analytics_link_disconnect.hxx"
+#include "core/operations/management/analytics_link_drop.hxx"
+#include "core/operations/management/analytics_link_get_all.hxx"
+#include "core/operations/management/analytics_link_replace.hxx"
+#include "core/operations/management/bucket_create.hxx"
 #include "core/operations/management/bucket_describe.hxx"
+#include "core/operations/management/bucket_drop.hxx"
+#include "core/operations/management/bucket_flush.hxx"
+#include "core/operations/management/bucket_get.hxx"
+#include "core/operations/management/bucket_get_all.hxx"
+#include "core/operations/management/bucket_update.hxx"
+#include "core/operations/management/change_password.hxx"
 #include "core/operations/management/cluster_describe.hxx"
 #include "core/operations/management/cluster_developer_preview_enable.hxx"
-#include "core/operations/management/collections.hxx"
-#include "core/operations/management/eventing.hxx"
+#include "core/operations/management/collection_create.hxx"
+#include "core/operations/management/collection_drop.hxx"
+#include "core/operations/management/collection_update.hxx"
+#include "core/operations/management/collections_manifest_get.hxx"
+#include "core/operations/management/eventing_deploy_function.hxx"
+#include "core/operations/management/eventing_drop_function.hxx"
+#include "core/operations/management/eventing_get_all_functions.hxx"
+#include "core/operations/management/eventing_get_function.hxx"
+#include "core/operations/management/eventing_get_status.hxx"
+#include "core/operations/management/eventing_pause_function.hxx"
+#include "core/operations/management/eventing_resume_function.hxx"
+#include "core/operations/management/eventing_undeploy_function.hxx"
+#include "core/operations/management/eventing_upsert_function.hxx"
 #include "core/operations/management/freeform.hxx"
-#include "core/operations/management/query.hxx"
-#include "core/operations/management/search.hxx"
-#include "core/operations/management/user.hxx"
-#include "core/operations/management/view.hxx"
+#include "core/operations/management/group_drop.hxx"
+#include "core/operations/management/group_get.hxx"
+#include "core/operations/management/group_get_all.hxx"
+#include "core/operations/management/group_upsert.hxx"
+#include "core/operations/management/query_index_build.hxx"
+#include "core/operations/management/query_index_build_deferred.hxx"
+#include "core/operations/management/query_index_create.hxx"
+#include "core/operations/management/query_index_drop.hxx"
+#include "core/operations/management/query_index_get_all.hxx"
+#include "core/operations/management/query_index_get_all_deferred.hxx"
+#include "core/operations/management/role_get_all.hxx"
+#include "core/operations/management/scope_create.hxx"
+#include "core/operations/management/scope_drop.hxx"
+#include "core/operations/management/scope_get_all.hxx"
+#include "core/operations/management/search_get_stats.hxx"
+#include "core/operations/management/search_index_analyze_document.hxx"
+#include "core/operations/management/search_index_control_ingest.hxx"
+#include "core/operations/management/search_index_control_plan_freeze.hxx"
+#include "core/operations/management/search_index_control_query.hxx"
+#include "core/operations/management/search_index_drop.hxx"
+#include "core/operations/management/search_index_get.hxx"
+#include "core/operations/management/search_index_get_all.hxx"
+#include "core/operations/management/search_index_get_documents_count.hxx"
+#include "core/operations/management/search_index_get_stats.hxx"
+#include "core/operations/management/search_index_upsert.hxx"
+#include "core/operations/management/user_drop.hxx"
+#include "core/operations/management/user_get.hxx"
+#include "core/operations/management/user_get_all.hxx"
+#include "core/operations/management/user_upsert.hxx"
+#include "core/operations/management/view_index_drop.hxx"
+#include "core/operations/management/view_index_get.hxx"
+#include "core/operations/management/view_index_get_all.hxx"
+#include "core/operations/management/view_index_upsert.hxx"
+#include "core/platform/uuid.h"
+#include "core/protocol/hello_feature.hxx"
+#include "core/service_type.hxx"
+#include "core/tls_verify_mode.hxx"
+#include "core/topology/capabilities.hxx"
 #include "core/tracing/noop_tracer.hxx"
 #include "core/tracing/threshold_logging_tracer.hxx"
 #include "core/utils/join_strings.hxx"
+#include "core/utils/movable_function.hxx"
 #include "crud_component.hxx"
 #include "dispatcher.hxx"
 #include "impl/dns_srv_tracker.hxx"
@@ -56,10 +154,31 @@
 #include "ping_collector.hxx"
 #include "ping_reporter.hxx"
 
-#include <asio/ssl.hpp>
-#include <fstream>
+#include <couchbase/codec/tao_json_serializer.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/retry_reason.hxx>
+
+#include <asio/bind_executor.hpp>
+#include <asio/executor_work_guard.hpp>
+#include <asio/post.hpp>
+#include <asio/ssl/verify_mode.hpp>
+#include <fmt/core.h>
+
+#include <atomic>
+#include <chrono>
+#include <cstring>
+#include <fmt/format.h>
+#include <map>
 #include <memory>
-#include <thread>
+#include <mutex>
+#include <optional>
+#include <set>
+#include <string>
+#include <system_error>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 namespace couchbase::core
 {
@@ -81,12 +200,17 @@ public:
   {
   }
 
+  ping_collector_impl(const ping_collector_impl&) = delete;
+  ping_collector_impl(ping_collector_impl&&) = delete;
+  auto operator=(const ping_collector_impl&) -> ping_collector_impl& = delete;
+  auto operator=(ping_collector_impl&&) -> ping_collector_impl& = delete;
+
   ~ping_collector_impl() override
   {
     invoke_handler();
   }
 
-  [[nodiscard]] diag::ping_result& result()
+  [[nodiscard]] auto result() -> diag::ping_result&
   {
     return res_;
   }
@@ -115,17 +239,19 @@ public:
   }
 };
 
+namespace
+{
 template<typename Request>
-bool
+auto
 is_feature_supported(const Request& /* request */,
-                     const configuration_capabilities& /* capabilities */)
+                     const configuration_capabilities& /* capabilities */) -> bool
 {
   return true;
 }
 
-bool
+auto
 is_feature_supported(const operations::search_request& request,
-                     const configuration_capabilities& capabilities)
+                     const configuration_capabilities& capabilities) -> bool
 {
   if (request.scope_name && !capabilities.supports_scoped_search_indexes()) {
     return false;
@@ -137,25 +263,33 @@ is_feature_supported(const operations::search_request& request,
   return true;
 }
 
-bool
+auto
 is_feature_supported(const operations::management::search_index_upsert_request& request,
-                     const configuration_capabilities& capabilities)
+                     const configuration_capabilities& capabilities) -> bool
 {
-  if (request.index.is_vector_index() && !capabilities.supports_vector_search()) {
-    return false;
-  }
-  return true;
+  return !request.index.is_vector_index() || capabilities.supports_vector_search();
 }
+} // namespace
 
 class cluster_impl : public std::enable_shared_from_this<cluster_impl>
 {
 public:
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
   explicit cluster_impl(asio::io_context& ctx)
     : ctx_(ctx)
     , work_(asio::make_work_guard(ctx_))
     , session_manager_(std::make_shared<io::http_session_manager>(id_, ctx_, tls_))
+    , retry_backoff_(ctx_)
   {
   }
+#else
+  explicit cluster_impl(asio::io_context& ctx)
+    : ctx_(ctx)
+    , work_(asio::make_work_guard(ctx_))
+    , session_manager_(std::make_shared<io::http_session_manager>(id_, ctx_, tls_))
+  {
+  }
+#endif
 
   auto io_context() -> asio::io_context&
   {
@@ -257,6 +391,8 @@ public:
             [self, hostname = std::move(hostname), handler = std::move(handler)](
               origin::node_list nodes, std::error_code ec) mutable {
               if (ec) {
+                // TODO(CXXCBC-549): clang-tidy-19 reports potential memory leak here
+                // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
                 return self->close([ec, handler = std::move(handler)]() mutable {
                   handler(ec);
                 });
@@ -275,6 +411,64 @@ public:
     do_open(std::move(handler));
   }
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  void open_in_background(couchbase::core::origin origin,
+                          utils::movable_function<void(std::error_code)>&& handler)
+  {
+    if (stopped_) {
+      return handler(errc::network::cluster_closed);
+    }
+    if (background_open_started_) {
+      CB_LOG_DEBUG("Background open already started for cluster, id: \"{}\"", id_);
+      return handler({});
+    }
+    if (origin.get_nodes().empty()) {
+      stopped_ = true;
+      work_.reset();
+      return handler(errc::common::invalid_argument);
+    }
+
+    origin_ = std::move(origin);
+    CB_LOG_DEBUG(R"(open cluster in background, id: "{}", core version: "{}", {})",
+                 id_,
+                 couchbase::core::meta::sdk_semver(),
+                 origin_.to_json());
+    // ignore the enable_tracing flag if a tracer was passed in
+    if (nullptr != origin_.options().tracer) {
+      tracer_ = origin_.options().tracer;
+    } else {
+      if (origin_.options().enable_tracing) {
+        tracer_ = std::make_shared<tracing::threshold_logging_tracer>(
+          ctx_, origin_.options().tracing_options);
+      } else {
+        tracer_ = std::make_shared<tracing::noop_tracer>();
+      }
+    }
+    tracer_->start();
+    // ignore the metrics options if a meter was passed in.
+    if (nullptr != origin_.options().meter) {
+      meter_ = origin_.options().meter;
+    } else {
+      if (origin_.options().enable_metrics) {
+        meter_ = std::make_shared<metrics::logging_meter>(ctx_, origin_.options().metrics_options);
+      } else {
+        meter_ = std::make_shared<metrics::noop_meter>();
+      }
+    }
+    meter_->start();
+    session_manager_->set_tracer(tracer_);
+    session_manager_->set_dispatch_timeout(origin_.options().dispatch_timeout);
+    // at this point we will infinitely try to connect
+    if (origin_.options().enable_dns_srv) {
+      do_background_dns_srv_open();
+    } else {
+      do_background_open();
+    }
+    background_open_started_ = true;
+    return handler({});
+  }
+#endif
+
   void open_bucket(const std::string& bucket_name,
                    utils::movable_function<void(std::error_code)>&& handler)
   {
@@ -283,7 +477,7 @@ public:
     }
     std::shared_ptr<bucket> b{};
     {
-      std::scoped_lock lock(buckets_mutex_);
+      const std::scoped_lock lock(buckets_mutex_);
       auto ptr = buckets_.find(bucket_name);
       if (ptr == buckets_.end()) {
         std::vector<protocol::hello_feature> known_features;
@@ -291,7 +485,9 @@ public:
         auto origin = origin_;
         if (session_ && session_->has_config()) {
           known_features = session_->supported_features();
-          origin = { origin_, session_->config().value() };
+          if (const auto config = session_->config(); config.has_value()) {
+            origin = { origin_, config.value() };
+          }
         }
 
         b = std::make_shared<bucket>(
@@ -307,7 +503,7 @@ public:
     b->bootstrap([self = shared_from_this(), bucket_name, handler = std::move(handler)](
                    std::error_code ec, const topology::configuration& config) mutable {
       if (ec) {
-        std::scoped_lock lock(self->buckets_mutex_);
+        const std::scoped_lock lock(self->buckets_mutex_);
         self->buckets_.erase(bucket_name);
       } else if (self->session_ && !self->session_->supports_gcccp()) {
         self->session_manager_->set_configuration(config, self->origin_.options());
@@ -324,7 +520,7 @@ public:
     }
     std::shared_ptr<bucket> b{};
     {
-      std::scoped_lock lock(buckets_mutex_);
+      const std::scoped_lock lock(buckets_mutex_);
 
       if (auto ptr = buckets_.find(bucket_name); ptr != buckets_.end()) {
         b = std::move(ptr->second);
@@ -337,7 +533,7 @@ public:
     return handler({});
   }
 
-  std::pair<std::error_code, couchbase::core::origin> origin() const
+  auto origin() const -> std::pair<std::error_code, couchbase::core::origin>
   {
     if (stopped_) {
       return { errc::network::cluster_closed, {} };
@@ -423,11 +619,8 @@ public:
         }
         return self->with_bucket_configuration(
           bucket_name,
-          [self = std::move(self),
-           cap,
-           request = std::move(request),
-           handler = std::forward<Handler>(handler)](std::error_code ec,
-                                                     topology::configuration config) mutable {
+          [self, cap, request = std::move(request), handler = std::forward<Handler>(handler)](
+            std::error_code ec, const topology::configuration& config) mutable {
             if (ec) {
               handler(request.make_response({ ec }, {}));
               return;
@@ -441,9 +634,9 @@ public:
       });
   }
 
-  std::shared_ptr<bucket> find_bucket_by_name(const std::string& name)
+  auto find_bucket_by_name(const std::string& name) -> std::shared_ptr<bucket>
   {
-    std::scoped_lock lock(buckets_mutex_);
+    const std::scoped_lock lock(buckets_mutex_);
 
     auto bucket = buckets_.find(name);
     if (bucket == buckets_.end()) {
@@ -456,13 +649,13 @@ public:
   {
     std::vector<std::shared_ptr<bucket>> buckets{};
     {
-      std::scoped_lock lock(buckets_mutex_);
+      const std::scoped_lock lock(buckets_mutex_);
       buckets.reserve(buckets_.size());
       for (const auto& [name, bucket] : buckets_) {
         buckets.push_back(bucket);
       }
     }
-    for (auto bucket : buckets) {
+    for (const auto& bucket : buckets) {
       handler(bucket);
     }
   }
@@ -481,7 +674,7 @@ public:
     bool has_capella_host = false;
     {
       bool has_non_capella_host = false;
-      static std::string suffix = "cloud.couchbase.com";
+      static const std::string suffix = "cloud.couchbase.com";
       for (const auto& node : origin_.get_hostnames()) {
         if (auto pos = node.find(suffix);
             pos != std::string::npos && pos + suffix.size() == node.size()) {
@@ -580,6 +773,8 @@ public:
                          id_,
                          origin_.options().trust_certificate,
                          ec.message());
+            // TODO(CXXCBC-549): clang-tidy-19 reports potential memory leak here
+            // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
             return close([ec, handler = std::move(handler)]() mutable {
               return handler(ec);
             });
@@ -595,6 +790,8 @@ public:
                        id_,
                        origin_.certificate_path(),
                        ec.message());
+          // TODO(CXXCBC-549): clang-tidy-19 reports potential memory leak here
+          // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
           return close([ec, handler = std::move(handler)]() mutable {
             return handler(ec);
           });
@@ -604,6 +801,8 @@ public:
         if (ec) {
           CB_LOG_ERROR(
             "[{}]: unable to load private key \"{}\": {}", id_, origin_.key_path(), ec.message());
+          // TODO(CXXCBC-549): clang-tidy-19 reports potential memory leak here
+          // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
           return close([ec, handler = std::move(handler)]() mutable {
             return handler(ec);
           });
@@ -645,6 +844,8 @@ public:
         });
       }
       if (ec) {
+        // TODO(CXXCBC-549): clang-tidy-19 reports potential memory leak here
+        // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
         return self->close([ec, handler = std::move(handler)]() mutable {
           handler(ec);
         });
@@ -653,6 +854,172 @@ public:
     });
   }
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  void do_background_open()
+  {
+    // TODO(JC): retries on more failures?  Right now only retry if load_verify_file() fails...
+
+    // Disables TLS v1.2 which should be okay cloud/columnar default.
+    configure_tls_options(true);
+    if (origin_.options().security_options.trust_only_capella) {
+      std::error_code ec{};
+      CB_LOG_DEBUG(R"([{}]: use Capella CA for TLS verify)", id_);
+      tls_.add_certificate_authority(
+        asio::const_buffer(couchbase::core::default_ca::capellaCaCert,
+                           strlen(couchbase::core::default_ca::capellaCaCert)),
+        ec);
+      if (ec) {
+        CB_LOG_WARNING("[{}]: unable to load Capella CAs: {}", id_, ec.message());
+        // we don't consider this fatal and try to continue without it
+      }
+    } else if (origin_.options().security_options.trust_only_pem_file ||
+               origin_.options().security_options.trust_only_pem_string) {
+      if (origin_.options().trust_certificate.empty() /* No CA certificate (or other SDK-specific
+                                                         trust source) is specified */
+          && origin_.options()
+               .trust_certificate_value.empty() /* and certificate value has not been specified */
+          && origin_.options().tls_verify !=
+               tls_verify_mode::none /* The user did not disable all TLS verification */) {
+        CB_LOG_WARNING("[{}] When TLS is enabled, the cluster options must specify certificate(s) "
+                       "to trust or ensure that they are "
+                       "available in system CA store.",
+                       id_);
+      }
+      std::error_code ec{};
+      // load only the explicit certificate
+      // system and default capella certificates are not loaded
+      if (!origin_.options().trust_certificate_value.empty()) {
+        CB_LOG_DEBUG(R"([{}]: use TLS certificate passed through via options object)", id_);
+        tls_.add_certificate_authority(
+          asio::const_buffer(origin_.options().trust_certificate_value.data(),
+                             origin_.options().trust_certificate_value.size()),
+          ec);
+        if (ec) {
+          CB_LOG_WARNING(
+            "[{}]: unable to load CA passed via options object: {}", id_, ec.message());
+        }
+      }
+      if (!origin_.options().trust_certificate.empty()) {
+        CB_LOG_DEBUG(
+          R"([{}]: use TLS verify file: "{}")", id_, origin_.options().trust_certificate);
+        tls_.load_verify_file(origin_.options().trust_certificate, ec);
+        if (ec) {
+          CB_LOG_ERROR("[{}]: unable to load verify file \"{}\": {}",
+                       id_,
+                       origin_.options().trust_certificate,
+                       ec.message());
+          auto backoff = std::chrono::milliseconds(500);
+          CB_LOG_DEBUG(
+            "[{}] waiting for {}ms before retrying TLS verify file.", id_, backoff.count());
+          backoff_then_retry(backoff, [self = shared_from_this()]() {
+            self->do_background_open();
+          });
+        }
+      }
+    } else if (origin_.options().security_options.trust_only_platform) {
+      // TODO(CXXCBC-548): security_options updates (use Mozilla certs?)
+      CB_LOG_DEBUG(R"([{}]: use default CA for TLS verify)", id_);
+      std::error_code ec{};
+      // load system certificates
+      tls_.set_default_verify_paths(ec);
+      if (ec) {
+        CB_LOG_WARNING(R"([{}]: failed to load system CAs: {})", id_, ec.message());
+      }
+    } else if (!origin_.options().security_options.trust_only_certificates.empty()) {
+      std::error_code ec{};
+      CB_LOG_DEBUG("[{}]: loading {} user provided CA certificates.",
+                   id_,
+                   origin_.options().security_options.trust_only_certificates.size());
+      for (const auto& cert : origin_.options().security_options.trust_only_certificates) {
+        tls_.add_certificate_authority(asio::const_buffer(cert.data(), cert.size()), ec);
+        if (ec) {
+          CB_LOG_WARNING("[{}]: unable to load CA: {}", id_, ec.message());
+        }
+      }
+    }
+    // TODO(CXXCBC-548): security_options updates (support cipher suites)
+    // if (!origin_.options().security_options.cipher_suites.empty()) {
+    // }
+    config_tracker_ = std::make_shared<couchbase::core::io::cluster_config_tracker>(
+      id_, origin_, ctx_, tls_, dns_srv_tracker_);
+    config_tracker_->register_bootstrap_notification_subscriber(session_manager_);
+    create_cluster_sessions();
+  }
+
+  void backoff_then_retry(std::chrono::milliseconds backoff,
+                          utils::movable_function<void()> callback)
+  {
+    retry_backoff_.expires_after(backoff);
+    retry_backoff_.async_wait(
+      [self = shared_from_this(), cb = std::move(callback)](std::error_code ec) {
+        if (ec == asio::error::operation_aborted || self->stopped_) {
+          return;
+        }
+        if (ec) {
+          CB_LOG_WARNING("[{}] Retry callback received error ec={}.", self->id_, ec.message());
+        }
+        cb();
+      });
+  }
+
+  void do_background_dns_srv_open()
+  {
+    std::string hostname;
+    std::string port;
+    std::tie(hostname, port) = origin_.next_address();
+    dns_srv_tracker_ = std::make_shared<impl::dns_srv_tracker>(
+      ctx_, hostname, origin_.options().dns_config, origin_.options().enable_tls);
+    return asio::post(asio::bind_executor(
+      ctx_, [self = shared_from_this(), hostname = std::move(hostname)]() mutable {
+        return self->dns_srv_tracker_->get_srv_nodes(
+          [self, hostname = std::move(hostname)](origin::node_list nodes,
+                                                 std::error_code ec) mutable {
+            if (ec) {
+              auto backoff = std::chrono::milliseconds(500);
+              self->session_manager_->notify_bootstrap_error({ ec, ec.message(), hostname, {} });
+              CB_LOG_DEBUG(
+                "[{}] waiting for {}ms before retrying DNS query.", self->id_, backoff.count());
+              self->backoff_then_retry(backoff, [self]() {
+                self->do_background_dns_srv_open();
+              });
+              return;
+            }
+            if (!nodes.empty()) {
+              self->origin_.set_nodes(std::move(nodes));
+              CB_LOG_INFO(
+                "[{}] Replace list of bootstrap nodes with addresses from DNS SRV of \"{}\": [{}]",
+                self->id_,
+                hostname,
+                utils::join_strings(self->origin_.get_nodes(), ", "));
+            }
+            return self->do_background_open();
+          });
+      }));
+  }
+
+  void create_cluster_sessions()
+  {
+    config_tracker_->create_sessions(
+      [self = shared_from_this()](std::error_code ec,
+                                  const topology::configuration& cfg,
+                                  const cluster_options& options) mutable {
+        if (ec) {
+          auto backoff = std::chrono::milliseconds(500);
+          CB_LOG_DEBUG("[{}] Waiting for {}ms before retrying to create cluster sessions.",
+                       self->id_,
+                       backoff.count());
+          self->backoff_then_retry(backoff, [self]() {
+            self->create_cluster_sessions();
+          });
+        } else {
+          self->session_manager_->set_configuration(cfg, options);
+          self->config_tracker_->on_configuration_update(self->session_manager_);
+          self->config_tracker_->register_state_listener();
+        }
+      });
+  }
+#endif
+
   void with_bucket_configuration(
     const std::string& bucket_name,
     utils::movable_function<void(std::error_code, topology::configuration)>&& handler)
@@ -672,9 +1039,8 @@ public:
 
         if (auto bucket = self->find_bucket_by_name(bucket_name); bucket != nullptr) {
           return bucket->with_configuration(std::move(handler));
-        } else {
-          return handler(errc::common::bucket_not_found, {});
         }
+        return handler(errc::common::bucket_not_found, {});
       });
   }
 
@@ -771,6 +1137,14 @@ public:
           self->session_->stop(retry_reason::do_not_retry);
           self->session_.reset();
         }
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+        if (self->config_tracker_) {
+          self->config_tracker_->close();
+          self->config_tracker_->unregister_bootstrap_notification_subscriber(
+            self->session_manager_);
+        }
+        self->retry_backoff_.cancel();
+#endif
         self->for_each_bucket([](auto bucket) {
           bucket->close();
         });
@@ -823,7 +1197,7 @@ public:
       return errc::common::invalid_argument;
     }
     if (auto bucket = find_bucket_by_name(bucket_name); bucket != nullptr) {
-      return bucket->direct_re_queue(std::move(req), is_retry);
+      return bucket->direct_re_queue(req, is_retry);
     }
 
     open_bucket(bucket_name,
@@ -837,6 +1211,15 @@ public:
     return {};
   }
 
+  auto http_session_manager()
+    -> std::pair<std::error_code, std::shared_ptr<io::http_session_manager>>
+  {
+    if (stopped_) {
+      return { errc::network::cluster_closed, {} };
+    }
+    return { {}, session_manager_ };
+  }
+
 private:
   std::string id_{ uuid::to_string(uuid::random()) };
   asio::io_context& ctx_;
@@ -851,6 +1234,11 @@ private:
   std::shared_ptr<couchbase::tracing::request_tracer> tracer_{ nullptr };
   std::shared_ptr<couchbase::metrics::meter> meter_{ nullptr };
   std::atomic_bool stopped_{ false };
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  std::shared_ptr<couchbase::core::io::cluster_config_tracker> config_tracker_{};
+  asio::steady_timer retry_backoff_;
+  std::atomic_bool background_open_started_{ false };
+#endif
 };
 
 cluster::cluster(asio::io_context& ctx)
@@ -906,6 +1294,20 @@ cluster::open(couchbase::core::origin origin,
   }
 }
 
+void
+cluster::open_in_background(
+  [[maybe_unused]] const couchbase::core::origin& origin,
+  [[maybe_unused]] utils::movable_function<void(std::error_code)>&& handler) const
+{
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  if (impl_) {
+    impl_->open_in_background(origin, std::move(handler));
+  }
+#else
+  CB_LOG_ERROR("Background open only available for Columnar builds.");
+#endif
+}
+
 void
 cluster::diagnostics(std::optional<std::string> report_id,
                      utils::movable_function<void(diag::diagnostics_result)>&& handler) const
@@ -926,7 +1328,7 @@ cluster::ping(std::optional<std::string> report_id,
     impl_->ping(std::move(report_id),
                 std::move(bucket_name),
                 std::move(services),
-                std::move(timeout),
+                timeout,
                 std::move(handler));
   }
 }
@@ -950,8 +1352,8 @@ cluster::close_bucket(const std::string& bucket_name,
   }
 }
 
-std::pair<std::error_code, couchbase::core::origin>
-cluster::origin() const
+auto
+cluster::origin() const -> std::pair<std::error_code, couchbase::core::origin>
 {
   if (impl_) {
     return impl_->origin();
@@ -1918,6 +2320,13 @@ cluster::execute(impl::lookup_in_replica_request request,
   return impl_->execute(std::move(request), std::move(handler));
 }
 
+auto
+cluster::http_session_manager() const
+  -> std::pair<std::error_code, std::shared_ptr<io::http_session_manager>>
+{
+  return impl_->http_session_manager();
+}
+
 auto
 cluster::to_string() const -> std::string
 {