couchbase 3.0.0.alpha.5 → 3.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8161b1f71ed9c5bf76741005dc12a1d2dde2c0583d4bf160cf5553285b061ee5
-  data.tar.gz: 964cfd24dc5e5b92dabc5e9e527ad864e5b7115c53302d6c279315a04c7a3b5e
+  metadata.gz: 1e71b3d69cab6a09f02460f5b983a908c256a76e12dd68f57fab9173c6a50d0e
+  data.tar.gz: b58766149d745a869828fe7f2f04f56182560de48a3365b95b253313f7f428c4
 SHA512:
-  metadata.gz: a812521c76a7a8aaa4ef364d344f507bb750e54214aa33ca4dbcb0ed88ec5cf1330545ffe9a22543f89b5ee82bf264aa8c152d5140d374534b62715152280112
-  data.tar.gz: 9d113e948491fdf943c38d50718e11222c30413a17bff1b7fb32775e2872ee0255cea4f9f4fea44cd2e0cf7d1e75f37939f1396a6472953a9410c6bb40566ec9
+  metadata.gz: 12b4ab101a664897933c2ca98841c1d7cd27c6b5a15653eb2b48e59eba69f76f431ce25b316eba392ad8f104cdcde0fa44b38004a341e316141d821a7256c852
+  data.tar.gz: 4a1723022980425bc7b0a907d5487ae72c654d29709f1137a32349a98eab7e11f23d75a95414df60a35097e9eae4cd9ec2414d184877b95c06f62cb97825770a

data/Gemfile

@@ -17,8 +17,17 @@ git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 gemspec
 
+gem "rake"
+
 group :development do
-  gem "byebug"
-  gem "rake"
-#  gem "sorbet"
+  gem "yard"
+  platforms :mri do
+    gem "byebug"
+  end
+end
+
+group :test do
+  gem "minitest"
+  gem "minitest-reporters"
+  gem "simplecov-cobertura"
 end

data/README.md

@@ -4,7 +4,7 @@ This repository contains the third generation of the official Couchbase SDK for
 
 ## Support and Feedback
 
-If you find an issue, please file it in [our JIRA issue tracker](http://couchbase.com/issues/browse/RCBC).
+If you find an issue, please file it in [our JIRA issue tracker](https://couchbase.com/issues/browse/RCBC).
 Also you are always welcome on [our forum](https://forums.couchbase.com/c/ruby-sdk).
 
 Please attach version information to ticket/post. To obtain this information use the following command:
@@ -13,10 +13,12 @@ Please attach version information to ticket/post. To obtain this information use
 
 ## Installation
 
+The library tested with the MRI 2.5, 2.6 and 2.7. Supported platforms are Linux and MacOS.
+
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "couchbase", "3.0.0.alpha.5"
+gem "couchbase", "3.0.0.beta.1"
 ```
 
 And then execute:

data/Rakefile

@@ -33,7 +33,7 @@ task :doc do
   input_dir = File.join(__dir__, "lib")
   output_dir = File.join(__dir__, "doc", "couchbase-ruby-client-#{Couchbase::VERSION[:sdk]}")
   rm_rf output_dir
-  sh "yard doc --output-dir #{output_dir} #{input_dir} - README.md"
+  sh "yard doc --hide-api private --output-dir #{output_dir} #{input_dir} --main README.md"
   puts "#{File.realpath(output_dir)}/index.html"
 end
 

data/couchbase.gemspec

@@ -26,13 +26,23 @@ Gem::Specification.new do |spec|
   spec.homepage = "https://www.couchbase.com"
   spec.license = "Apache-2.0"
 
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/couchbase/couchbase-ruby-client"
-  spec.metadata["changelog_uri"] = "#{spec.metadata["source_code_uri"]}/releases"
-  spec.metadata["github_repo"] = "ssh://github.com/couchbase/couchbase-ruby-client"
+  spec.metadata = {
+      "homepage_uri" => "https://docs.couchbase.com/ruby-sdk/3.0/hello-world/start-using-sdk.html",
+      "bug_tracker_uri" => "https://couchbase.com/issues/browse/RCBC",
+      "mailing_list_uri" => "https://forums.couchbase.com/c/ruby-sdk",
+      "source_code_uri" => "https://github.com/couchbasse/couchbase-ruby-client/tree/#{spec.version}",
+      "changelog_uri" => "https://github.com/couchbase/couchbase-ruby-client/releases/tag/#{spec.version}",
+      "documentation_uri" => "https://docs.couchbase.com/sdk-api/couchbase-ruby-client-#{spec.version}/index.html",
+      "github_repo" => "ssh://github.com/couchbase/couchbase-ruby-client",
+  }
 
   spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
     exclude_paths = %w[
+        .idea
+        .github
+        .gitignore
+        .gitmodules
+        bin
         test
         spec
         features
@@ -57,17 +67,12 @@ Gem::Specification.new do |spec|
         ext/third_party/spdlog/tests
     ]
     `git ls-files --recurse-submodules -z`
-      .split("\x0")
-      .reject { |f| f.match(%r{^(#{Regexp.union(exclude_paths)})/}) }
+        .split("\x0")
+        .reject { |f| f.match(%r{^(#{Regexp.union(exclude_paths)})}) }
   end
   spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
   spec.extensions = ["ext/extconf.rb"]
-  spec.rdoc_options.append('--exclude', 'ext/')
-
-  spec.add_development_dependency "bundler", "~> 2.1"
-  spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "minitest", "~> 5.14"
-  spec.add_development_dependency "minitest-reporters", "~> 1.4"
+  spec.rdoc_options << "--exclude" << "ext/"
 end

data/ext/.idea/misc.xml

@@ -1,4 +1,16 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
+  <component name="CidrRootsConfiguration">
+    <sourceRoots>
+      <file path="$PROJECT_DIR$/couchbase" />
+    </sourceRoots>
+    <libraryRoots>
+      <file path="$PROJECT_DIR$/third_party" />
+    </libraryRoots>
+    <excludeRoots>
+      <file path="$PROJECT_DIR$/cmake-build-debug" />
+      <file path="$PROJECT_DIR$/cmake-build-debug-system-gcc" />
+    </excludeRoots>
+  </component>
 </project>

data/ext/CMakeLists.txt

@@ -29,7 +29,7 @@ if(MSVC)
     target_compile_options(project_warnings INTERFACE /W4 /WX "/permissive-")
 else()
     option(ONLY_COVERAGE "Build only tests necessary for coverage" FALSE)
-    option(LIBCPP "Build with libc++" FALSE)
+    option(STATIC_STDLIB "Statically link C++ standard library" FALSE)
     option(ENABLE_COVERAGE "Enable coverage reporting for gcc/clang" FALSE)
     option(ENABLE_FUZZERS "Enable fuzz testing tools" FALSE)
 
@@ -52,6 +52,11 @@ else()
         target_link_libraries(project_options INTERFACE -fsanitize=thread)
     endif()
 
+    if(STATIC_STDLIB)
+        target_compile_options(project_options INTERFACE -static-libgcc -static-libstdc++)
+        target_link_options(project_options INTERFACE -static-libgcc -static-libstdc++)
+    endif()
+
     target_compile_options(
         project_warnings
         INTERFACE -Wall
@@ -87,6 +92,9 @@ else()
     endif()
 endif()
 
+# Read more at https://wiki.wireshark.org/TLS
+option(TLS_KEY_LOG_FILE "Path to file to write per-session secrets (Useful for Wireshark SSL/TLS dissection)")
+
 include(FindOpenSSL)
 message(STATUS "OPENSSL_VERSION: ${OPENSSL_VERSION}")
 message(STATUS "OPENSSL_INCLUDEDIRS: ${OPENSSL_INCLUDE_DIR}")
@@ -129,6 +137,7 @@ endif()
 
 string(TIMESTAMP BACKEND_BUILD_TIMESTAMP "%Y-%m-%d %H:%M:%S" UTC)
 configure_file(${PROJECT_SOURCE_DIR}/build_version.hxx.in ${PROJECT_BINARY_DIR}/generated/build_version.hxx @ONLY)
+configure_file(${PROJECT_SOURCE_DIR}/build_config.hxx.in ${PROJECT_BINARY_DIR}/generated/build_config.hxx @ONLY)
 add_library(couchbase SHARED couchbase/couchbase.cxx)
 target_include_directories(couchbase PRIVATE ${PROJECT_BINARY_DIR}/generated)
 target_link_libraries(

data/ext/build_config.hxx.in

@@ -0,0 +1,20 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#cmakedefine TLS_KEY_LOG_FILE "@TLS_KEY_LOG_FILE@"

data/ext/build_version.hxx.in

@@ -22,5 +22,5 @@
 #define BACKEND_C_COMPILER "@CMAKE_C_COMPILER_ID@ @CMAKE_C_COMPILER_VERSION@"
 #define BACKEND_SYSTEM "@CMAKE_SYSTEM@"
 #define BACKEND_SYSTEM_PROCESSOR "@CMAKE_SYSTEM_PROCESSOR@"
-#define BACKEND_GIT_REVISION "96d4d0b033b3d0ab2c198d755fa0180a54e9211f"
+#define BACKEND_GIT_REVISION "f01d0c237750cc67ee75325ed160bc0da1d2bf7a"
 

data/ext/couchbase/bucket.hxx

@@ -18,19 +18,29 @@
 #pragma once
 
 #include <utility>
+#include <queue>
 
-#include <configuration_monitor.hxx>
 #include <operations.hxx>
+#include <origin.hxx>
 
 namespace couchbase
 {
-class bucket
+class bucket : public std::enable_shared_from_this<bucket>
 {
   public:
-    explicit bucket(asio::io_context& ctx, std::string name, configuration config)
-      : ctx_(ctx)
+    explicit bucket(const std::string& client_id,
+                    asio::io_context& ctx,
+                    asio::ssl::context& tls,
+                    std::string name,
+                    couchbase::origin origin,
+                    const std::vector<protocol::hello_feature>& known_features)
+
+      : client_id_(client_id)
+      , ctx_(ctx)
+      , tls_(tls)
       , name_(std::move(name))
-      , config_(std::move(config))
+      , origin_(std::move(origin))
+      , known_features_(known_features)
     {
     }
 
@@ -44,21 +54,55 @@ class bucket
         return name_;
     }
 
-    void set_node(size_t index, std::shared_ptr<io::mcbp_session> session)
+    template<typename Handler>
+    void bootstrap(Handler&& handler)
     {
-        if (closed_) {
-            return;
+        std::shared_ptr<io::mcbp_session> new_session;
+        if (origin_.options().enable_tls) {
+            new_session = std::make_shared<io::mcbp_session>(client_id_, ctx_, tls_, origin_, name_, known_features_);
+        } else {
+            new_session = std::make_shared<io::mcbp_session>(client_id_, ctx_, origin_, name_, known_features_);
         }
-
-        sessions_.emplace(index, std::move(session));
-    }
-
-    void remove_node(size_t index)
-    {
-        if (closed_) {
-            return;
-        }
-        sessions_.erase(index);
+        new_session->bootstrap([self = shared_from_this(), new_session, h = std::forward<Handler>(handler)](
+                                 std::error_code ec, const configuration& cfg) mutable {
+            if (!ec) {
+                self->config_ = cfg;
+                size_t this_index = new_session->index();
+                self->sessions_.emplace(this_index, std::move(new_session));
+                if (cfg.nodes.size() > 1) {
+                    for (const auto& n : cfg.nodes) {
+                        if (n.index != this_index) {
+                            couchbase::origin origin(
+                              self->origin_.get_username(),
+                              self->origin_.get_password(),
+                              n.hostname_for(self->origin_.options().network),
+                              n.port_or(self->origin_.options().network, service_type::kv, self->origin_.options().enable_tls, 0),
+                              self->origin_.options());
+                            std::shared_ptr<io::mcbp_session> s;
+                            if (self->origin_.options().enable_tls) {
+                                s = std::make_shared<io::mcbp_session>(
+                                  self->client_id_, self->ctx_, self->tls_, origin, self->name_, self->known_features_);
+                            } else {
+                                s = std::make_shared<io::mcbp_session>(
+                                  self->client_id_, self->ctx_, origin, self->name_, self->known_features_);
+                            }
+                            s->bootstrap([host = n.hostname, bucket = self->name_](std::error_code err, const configuration& /*config*/) {
+                                // TODO: retry, we know that auth is correct
+                                if (err) {
+                                    spdlog::warn("unable to bootstrap node {} ({}): {}", host, bucket, err.message());
+                                }
+                            });
+                            self->sessions_.emplace(n.index, std::move(s));
+                        }
+                    }
+                }
+                while (!self->deferred_commands_.empty()) {
+                    self->deferred_commands_.front()();
+                    self->deferred_commands_.pop();
+                }
+            }
+            h(ec, cfg);
+        });
     }
 
     template<typename Request, typename Handler>
@@ -67,11 +111,16 @@ class bucket
         if (closed_) {
             return;
         }
-        size_t index = 0;
-        std::tie(request.partition, index) = config_.map_key(request.id.key);
-        auto session = sessions_.at(index);
-        auto cmd = std::make_shared<operations::command<Request>>(ctx_, std::move(request));
-        cmd->send_to(session, std::forward<Handler>(handler));
+        auto cmd = std::make_shared<operations::mcbp_command<Request>>(ctx_, request);
+        cmd->start([cmd, handler = std::forward<Handler>(handler)](std::error_code ec, std::optional<io::mcbp_message> msg) mutable {
+            using encoded_response_type = typename Request::encoded_response_type;
+            handler(make_response(ec, cmd->request, msg ? encoded_response_type(*msg) : encoded_response_type{}));
+        });
+        if (config_) {
+            map_and_send(cmd);
+        } else {
+            deferred_commands_.emplace([self = shared_from_this(), cmd]() { self->map_and_send(cmd); });
+        }
     }
 
     void close()
@@ -85,10 +134,27 @@ class bucket
         }
     }
 
+    template<typename Request>
+    void map_and_send(std::shared_ptr<operations::mcbp_command<Request>> cmd)
+    {
+        size_t index = 0;
+        std::tie(cmd->request.partition, index) = config_->map_key(cmd->request.id.key);
+        auto session = sessions_.at(index);
+        cmd->send_to(session);
+    }
+
   private:
+    std::string client_id_;
     asio::io_context& ctx_;
+    asio::ssl::context& tls_;
     std::string name_;
-    configuration config_;
+    origin origin_;
+
+    std::optional<configuration> config_{};
+    std::vector<protocol::hello_feature> known_features_;
+
+    std::queue<std::function<void()>> deferred_commands_{};
+
     bool closed_{ false };
     std::map<size_t, std::shared_ptr<io::mcbp_session>> sessions_{};
 };

data/ext/couchbase/cluster.hxx

@@ -19,36 +19,21 @@
 
 #include <utility>
 #include <thread>
+#include <fstream>
+
+#include <asio/ssl.hpp>
 
 #include <io/mcbp_session.hxx>
 #include <io/http_session_manager.hxx>
+#include <io/http_command.hxx>
+#include <io/dns_client.hxx>
+#include <origin.hxx>
 #include <bucket.hxx>
 #include <operations.hxx>
 #include <operations/document_query.hxx>
 
 namespace couchbase
 {
-struct origin {
-    std::string username;
-    std::string password;
-    std::string hostname;
-
-    [[nodiscard]] const std::string& get_username() const
-    {
-        return username;
-    }
-
-    [[nodiscard]] const std::string& get_password() const
-    {
-        return password;
-    }
-
-    [[nodiscard]] std::pair<std::string, std::string> get_address() const
-    {
-        return { hostname, "11210" };
-    }
-};
-
 class cluster
 {
   public:
@@ -56,88 +41,53 @@ class cluster
       : id_(uuid::to_string(uuid::random()))
       , ctx_(ctx)
       , work_(asio::make_work_guard(ctx_))
-      , session_(std::make_shared<io::mcbp_session>(id_, ctx_))
-      , session_manager_(std::make_shared<io::http_session_manager>(id_, ctx_))
+      , tls_(asio::ssl::context::tls_client)
+      , session_manager_(std::make_shared<io::http_session_manager>(id_, ctx_, tls_))
+      , dns_config_(io::dns::dns_config::get())
+      , dns_client_(ctx_)
     {
     }
 
-    ~cluster()
-    {
-        work_.reset();
-    }
-
     template<typename Handler>
     void open(const couchbase::origin& origin, Handler&& handler)
     {
-        auto address = origin.get_address();
         origin_ = origin;
-        session_->bootstrap(address.first,
-                            address.second,
-                            origin.get_username(),
-                            origin.get_password(),
-                            [this, handler = std::forward<Handler>(handler)](std::error_code ec, configuration config) mutable {
-                                session_manager_->set_configuration(config);
-                                handler(ec);
-                            });
+        if (origin_.options().enable_dns_srv) {
+            return do_dns_srv(std::forward<Handler>(handler));
+        }
+        do_open(std::forward<Handler>(handler));
     }
 
     template<typename Handler>
     void close(Handler&& handler)
     {
         asio::post(asio::bind_executor(ctx_, [this, handler = std::forward<Handler>(handler)]() {
-            session_->stop();
+            if (session_) {
+                session_->stop();
+            }
             for (auto& bucket : buckets_) {
                 bucket.second->close();
             }
             handler();
+            work_.reset();
         }));
     }
 
     template<typename Handler>
     void open_bucket(const std::string& bucket_name, Handler&& handler)
     {
-        if (!session_->has_config()) {
-            return handler(std::make_error_code(error::common_errc::invalid_argument));
+        std::vector<protocol::hello_feature> known_features;
+        if (session_ && session_->has_config()) {
+            known_features = session_->supported_features();
         }
-        configuration config = session_->config();
-        auto known_features = session_->supported_features();
-        auto& node = config.nodes.front();
-        auto new_session = std::make_shared<io::mcbp_session>(id_, ctx_, bucket_name, known_features);
-        new_session->bootstrap(node.hostname,
-                               std::to_string(*node.services_plain.key_value),
-                               origin_.get_username(),
-                               origin_.get_password(),
-                               [this, name = bucket_name, new_session, known_features, h = std::forward<Handler>(handler)](
-                                 std::error_code ec, configuration cfg) mutable {
-                                   if (!ec) {
-                                       if (!session_->supports_gcccp()) {
-                                           session_manager_->set_configuration(cfg);
-                                       }
-                                       auto b = std::make_shared<bucket>(ctx_, name, cfg);
-                                       size_t this_index = new_session->index();
-                                       b->set_node(this_index, new_session);
-                                       if (cfg.nodes.size() > 1) {
-                                           for (const auto& n : cfg.nodes) {
-                                               if (n.index != this_index) {
-                                                   auto s = std::make_shared<io::mcbp_session>(id_, ctx_, name, known_features);
-                                                   b->set_node(n.index, s);
-                                                   s->bootstrap(n.hostname,
-                                                                std::to_string(*n.services_plain.key_value),
-                                                                origin_.get_username(),
-                                                                origin_.get_password(),
-                                                                [s, i = n.index, b](std::error_code err, configuration /*config*/) {
-                                                                    if (err) {
-                                                                        spdlog::warn("unable to bootstrap node: {}", err.message());
-                                                                        b->remove_node(i);
-                                                                    }
-                                                                });
-                                               }
-                                           }
-                                       }
-                                       buckets_.emplace(name, std::move(b));
-                                   }
-                                   h(ec);
-                               });
+        auto b = std::make_shared<bucket>(id_, ctx_, tls_, bucket_name, origin_, known_features);
+        b->bootstrap([this, handler = std::forward<Handler>(handler)](std::error_code ec, const configuration& config) mutable {
+            if (!ec && !session_->supports_gcccp()) {
+                session_manager_->set_configuration(config, origin_.options());
+            }
+            handler(ec);
+        });
+        buckets_.emplace(bucket_name, b);
     }
 
     template<class Request, class Handler>
@@ -153,11 +103,11 @@ class cluster
     template<class Request, class Handler>
     void execute_http(Request request, Handler&& handler)
     {
-        auto session = session_manager_->check_out(Request::type, origin_.username, origin_.password);
+        auto session = session_manager_->check_out(Request::type, origin_.get_username(), origin_.get_password());
         if (!session) {
             return handler(operations::make_response(std::make_error_code(error::common_errc::service_not_available), request, {}));
         }
-        auto cmd = std::make_shared<operations::command<Request>>(ctx_, std::move(request));
+        auto cmd = std::make_shared<operations::http_command<Request>>(ctx_, request);
         cmd->send_to(session, [this, session, handler = std::forward<Handler>(handler)](typename Request::response_type resp) mutable {
             handler(std::move(resp));
             session_manager_->check_in(Request::type, session);
@@ -165,12 +115,103 @@ class cluster
     }
 
   private:
+    template<typename Handler>
+    void do_dns_srv(Handler&& handler)
+    {
+        std::string hostname;
+        std::string service;
+        std::tie(hostname, service) = origin_.next_address();
+        service = origin_.options().enable_tls ? "_couchbases" : "_couchbase";
+        dns_client_.query_srv(
+          hostname,
+          service,
+          [hostname, this, handler = std::forward<Handler>(handler)](couchbase::io::dns::dns_client::dns_srv_response resp) mutable {
+              if (resp.ec) {
+                  spdlog::warn("failed to fetch DNS SRV records for \"{}\" ({}), assuming that cluster is listening this address",
+                               hostname,
+                               resp.ec.message());
+              } else if (resp.targets.empty()) {
+                  spdlog::warn("DNS SRV query returned 0 records for \"{}\", assuming that cluster is listening this address", hostname);
+              } else {
+                  origin::node_list nodes;
+                  nodes.reserve(resp.targets.size());
+                  for (const auto& address : resp.targets) {
+                      origin::node_entry node;
+                      node.first = address.hostname;
+                      node.second = std::to_string(address.port);
+                      nodes.emplace_back(node);
+                  }
+                  origin_.set_nodes(nodes);
+                  spdlog::info("replace list of bootstrap nodes with addresses from DNS SRV of \"{}\": [{}]",
+                               hostname,
+                               fmt::join(origin_.get_nodes(), ", "));
+              }
+              return do_open(std::forward<Handler>(handler));
+          });
+    }
+
+    template<typename Handler>
+    void do_open(Handler&& handler)
+    {
+        if (origin_.options().enable_tls) {
+            tls_.set_options(asio::ssl::context::default_workarounds | asio::ssl::context::no_sslv2 | asio::ssl::context::no_sslv3);
+            if (!origin_.options().trust_certificate.empty()) {
+                std::error_code ec{};
+                tls_.use_certificate_chain_file(origin_.options().trust_certificate, ec);
+                if (ec) {
+                    spdlog::error("unable to load certificate chain \"{}\": {}", origin_.options().trust_certificate, ec.message());
+                    return handler(ec);
+                }
+            }
+#ifdef TLS_KEY_LOG_FILE
+            SSL_CTX_set_keylog_callback(tls_.native_handle(), [](const SSL* /* ssl */, const char* line) {
+                std::ofstream keylog(TLS_KEY_LOG_FILE, std::ios::out | std::ios::app | std::ios::binary);
+                keylog << std::string_view(line) << std::endl;
+            });
+            spdlog::critical("TLS_KEY_LOG_FILE was set to \"{}\" during build, all TLS keys will be logged for network analysis "
+                             "(https://wiki.wireshark.org/TLS). DO NOT USE THIS BUILD IN PRODUCTION",
+                             TLS_KEY_LOG_FILE);
+#endif
+            session_ = std::make_shared<io::mcbp_session>(id_, ctx_, tls_, origin_);
+        } else {
+            session_ = std::make_shared<io::mcbp_session>(id_, ctx_, origin_);
+        }
+        session_->bootstrap([this, handler = std::forward<Handler>(handler)](std::error_code ec, const configuration& config) mutable {
+            if (!ec) {
+                if (origin_.options().network == "auto") {
+                    origin_.options().network = config.select_network(session_->bootstrap_hostname());
+                    spdlog::info(R"({} detected network is "{}")", session_->log_prefix(), origin_.options().network);
+                }
+                if (origin_.options().network != "default") {
+                    origin::node_list nodes;
+                    nodes.reserve(config.nodes.size());
+                    for (const auto& address : config.nodes) {
+                        origin::node_entry node;
+                        node.first = address.hostname_for(origin_.options().network);
+                        node.second =
+                          std::to_string(address.port_or(origin_.options().network, service_type::kv, origin_.options().enable_tls, 0));
+                        nodes.emplace_back(node);
+                    }
+                    origin_.set_nodes(nodes);
+                    spdlog::info("replace list of bootstrap nodes with addresses of alternative network \"{}\": [{}]",
+                                 origin_.options().network,
+                                 fmt::join(origin_.get_nodes(), ","));
+                }
+                session_manager_->set_configuration(config, origin_.options());
+            }
+            handler(ec);
+        });
+    }
+
     std::string id_;
     asio::io_context& ctx_;
     asio::executor_work_guard<asio::io_context::executor_type> work_;
-    std::shared_ptr<io::mcbp_session> session_;
+    asio::ssl::context tls_;
     std::shared_ptr<io::http_session_manager> session_manager_;
-    std::map<std::string, std::shared_ptr<bucket>> buckets_;
-    origin origin_;
+    io::dns::dns_config& dns_config_;
+    couchbase::io::dns::dns_client dns_client_;
+    std::shared_ptr<io::mcbp_session> session_{};
+    std::map<std::string, std::shared_ptr<bucket>> buckets_{};
+    couchbase::origin origin_{};
 };
 } // namespace couchbase