couchbase 3.4.3 → 3.4.4

data/ext/couchbase/core/range_scan_orchestrator.hxx

@@ -18,6 +18,7 @@
 #include "range_scan_options.hxx"
 #include "range_scan_orchestrator_options.hxx"
 #include "scan_result.hxx"
+#include "topology/configuration.hxx"
 
 #include <tl/expected.hpp>
 
@@ -34,15 +35,25 @@ namespace couchbase::core
 class agent;
 class range_scan_orchestrator_impl;
 
+class scan_stream_manager
+{
+  public:
+    virtual ~scan_stream_manager() = default;
+    virtual void stream_start_failed(std::int16_t node_id, bool fatal) = 0;
+    virtual void stream_start_failed_awaiting_retry(std::int16_t node_id, std::uint16_t vbucket_id) = 0;
+    virtual void stream_continue_failed(std::int16_t node_id, bool fatal) = 0;
+    virtual void stream_completed(std::int16_t node_id) = 0;
+};
+
 class range_scan_orchestrator
 {
   public:
     range_scan_orchestrator(asio::io_context& io,
                             agent kv_provider,
-                            std::size_t num_vbuckets,
+                            topology::configuration::vbucket_map vbucket_map,
                             std::string scope_name,
                             std::string collection_name,
-                            std::variant<std::monostate, range_scan, sampling_scan> scan_type,
+                            std::variant<std::monostate, range_scan, prefix_scan, sampling_scan> scan_type,
                             range_scan_orchestrator_options options);
 
     auto scan() -> tl::expected<scan_result, std::error_code>;

data/ext/couchbase/core/range_scan_orchestrator_options.hxx

@@ -16,6 +16,7 @@
 #pragma once
 
 #include "scan_options.hxx"
+#include "timeout_defaults.hxx"
 
 #include <couchbase/mutation_token.hxx>
 #include <couchbase/retry_strategy.hxx>
@@ -40,15 +41,16 @@ namespace couchbase::core
 {
 
 struct range_scan_orchestrator_options {
+    static constexpr std::uint16_t default_concurrency{ 1 };
+
     bool ids_only{ false };
     std::optional<mutation_state> consistent_with{};
-    scan_sort sort{ scan_sort::none };
     std::uint32_t batch_item_limit{ range_scan_continue_options::default_batch_item_limit };
     std::uint32_t batch_byte_limit{ range_scan_continue_options::default_batch_byte_limit };
-    std::chrono::milliseconds batch_time_limit{ range_scan_continue_options::default_batch_time_limit };
+    std::uint16_t concurrency{ default_concurrency };
 
     std::shared_ptr<couchbase::retry_strategy> retry_strategy{ nullptr };
-    std::chrono::milliseconds timeout{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_scan_timeout };
     std::shared_ptr<couchbase::tracing::request_span> parent_span{};
 };
 } // namespace couchbase::core

data/ext/couchbase/core/scan_options.hxx

@@ -38,26 +38,7 @@ class request_span;
 
 namespace couchbase::core
 {
-
-enum class scan_sort {
-    none,
-    ascending,
-};
-
 struct mutation_state {
     std::vector<couchbase::mutation_token> tokens;
 };
-
-struct scan_options {
-    bool ids_only{ false };
-    std::optional<mutation_state> consistent_with{};
-    scan_sort sort{ scan_sort::none };
-    std::uint32_t batch_item_limit{ range_scan_continue_options::default_batch_item_limit };
-    std::uint32_t batch_byte_limit{ range_scan_continue_options::default_batch_byte_limit };
-    std::chrono::milliseconds batch_time_limit{ range_scan_continue_options::default_batch_time_limit };
-
-    std::shared_ptr<couchbase::retry_strategy> retry_strategy{ nullptr };
-    std::chrono::milliseconds timeout{};
-    std::shared_ptr<couchbase::tracing::request_span> parent_span{};
-};
 } // namespace couchbase::core

data/ext/couchbase/core/scan_result.cxx

@@ -32,10 +32,7 @@ class scan_result_impl
 
     [[nodiscard]] auto next() const -> tl::expected<range_scan_item, std::error_code>
     {
-        if (auto item = iterator_->next().get(); item) {
-            return item.value();
-        }
-        return tl::unexpected{ errc::key_value::range_scan_completed };
+        return iterator_->next().get();
     }
 
     void next(utils::movable_function<void(range_scan_item, std::error_code)> callback) const
@@ -43,6 +40,16 @@ class scan_result_impl
         return iterator_->next(std::move(callback));
     }
 
+    void cancel()
+    {
+        return iterator_->cancel();
+    }
+
+    [[nodiscard]] auto is_cancelled() -> bool
+    {
+        return iterator_->is_cancelled();
+    }
+
   private:
     std::shared_ptr<range_scan_item_iterator> iterator_;
 };
@@ -65,7 +72,14 @@ scan_result::next(utils::movable_function<void(range_scan_item, std::error_code)
 }
 
 void
-scan_result::cancel() const
+scan_result::cancel()
+{
+    return impl_->cancel();
+}
+
+auto
+scan_result::is_cancelled() -> bool
 {
+    return impl_->is_cancelled();
 }
 } // namespace couchbase::core

data/ext/couchbase/core/scan_result.hxx

@@ -41,8 +41,10 @@ class range_scan_item_iterator
 {
   public:
     virtual ~range_scan_item_iterator() = default;
-    virtual auto next() -> std::future<std::optional<range_scan_item>> = 0;
+    virtual auto next() -> std::future<tl::expected<range_scan_item, std::error_code>> = 0;
     virtual void next(utils::movable_function<void(range_scan_item, std::error_code)> callback) = 0;
+    virtual void cancel() = 0;
+    virtual bool is_cancelled() = 0;
 };
 
 class scan_result
@@ -51,7 +53,8 @@ class scan_result
     explicit scan_result(std::shared_ptr<range_scan_item_iterator> iterator);
     [[nodiscard]] auto next() const -> tl::expected<range_scan_item, std::error_code>;
     void next(utils::movable_function<void(range_scan_item, std::error_code)> callback) const;
-    void cancel() const;
+    void cancel();
+    [[nodiscard]] auto is_cancelled() -> bool;
 
   private:
     std::shared_ptr<scan_result_impl> impl_{};

data/ext/couchbase/core/timeout_defaults.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   Copyright 2020-2023 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -27,6 +27,7 @@ constexpr std::chrono::milliseconds resolve_timeout{ 2'000 };
 constexpr std::chrono::milliseconds connect_timeout{ 2'000 };
 constexpr std::chrono::milliseconds key_value_timeout{ 2'500 };
 constexpr std::chrono::milliseconds key_value_durable_timeout{ 10'000 };
+constexpr std::chrono::milliseconds key_value_scan_timeout{ 75'000 };
 constexpr std::chrono::milliseconds view_timeout{ 75'000 };
 constexpr std::chrono::milliseconds query_timeout{ 75'000 };
 constexpr std::chrono::milliseconds analytics_timeout{ 75'000 };
@@ -34,8 +35,6 @@ constexpr std::chrono::milliseconds search_timeout{ 75'000 };
 constexpr std::chrono::milliseconds management_timeout{ 75'000 };
 constexpr std::chrono::milliseconds eventing_timeout{ 75'000 };
 
-constexpr std::chrono::milliseconds range_scan_timeout{ 75'000 };
-
 constexpr std::chrono::milliseconds dns_srv_timeout{ 500 };
 constexpr std::chrono::milliseconds tcp_keep_alive_interval{ 60'000 };
 constexpr std::chrono::milliseconds config_poll_interval{ 2'500 };

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

@@ -31,6 +31,8 @@ enum class bucket_capability {
     collections,
     durable_write,
     tombstoned_user_xattrs,
+    range_scan,
+    replica_read,
 };
 
 enum class cluster_capability {
@@ -39,5 +41,6 @@ enum class cluster_capability {
     n1ql_javascript_functions,
     n1ql_inline_functions,
     n1ql_enhanced_prepared_statements,
+    n1ql_read_from_replica,
 };
 } // namespace couchbase::core

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

@@ -67,6 +67,12 @@ struct fmt::formatter<couchbase::core::bucket_capability> {
             case couchbase::core::bucket_capability::tombstoned_user_xattrs:
                 name = "tombstoned_user_xattrs";
                 break;
+            case couchbase::core::bucket_capability::range_scan:
+                name = "range_scan";
+                break;
+            case couchbase::core::bucket_capability::replica_read:
+                name = "replica_read";
+                break;
         }
         return format_to(ctx.out(), "{}", name);
     }
@@ -100,6 +106,8 @@ struct fmt::formatter<couchbase::core::cluster_capability> {
             case couchbase::core::cluster_capability::n1ql_enhanced_prepared_statements:
                 name = "n1ql_enhanced_prepared_statements";
                 break;
+            case couchbase::core::cluster_capability::n1ql_read_from_replica:
+                name = "n1ql_read_from_replica";
         }
         return format_to(ctx.out(), "{}", name);
     }

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

@@ -47,6 +47,6 @@ struct fmt::formatter<couchbase::core::topology::collections_manifest> {
                          couchbase::core::uuid::to_string(manifest.id),
                          manifest.uid,
                          collections.size(),
-                         utils::join_strings(collections, ", "));
+                         couchbase::core::utils::join_strings(collections, ", "));
     }
 };

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

@@ -112,6 +112,16 @@ struct configuration {
         return cluster_capabilities.find(cluster_capability::n1ql_enhanced_prepared_statements) != cluster_capabilities.end();
     }
 
+    [[nodiscard]] bool supports_read_from_replica() const
+    {
+        return cluster_capabilities.find(cluster_capability::n1ql_read_from_replica) != cluster_capabilities.end();
+    }
+
+    [[nodiscard]] bool supports_range_scan() const
+    {
+        return bucket_capabilities.find(bucket_capability::range_scan) != bucket_capabilities.end();
+    }
+
     [[nodiscard]] bool ephemeral() const
     {
         // Use bucket capabilities to identify if couchapi is missing (then its ephemeral). If its null then
@@ -119,6 +129,11 @@ struct configuration {
         return bucket_capabilities.count(couchbase::core::bucket_capability::couchapi) == 0;
     }
 
+    [[nodiscard]] bool supports_subdoc_read_replica() const
+    {
+        return bucket_capabilities.find(bucket_capability::replica_read) != bucket_capabilities.end();
+    }
+
     [[nodiscard]] std::size_t index_for_this_node() const;
     [[nodiscard]] bool has_node(const std::string& network,
                                 service_type type,

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

@@ -52,7 +52,6 @@ struct traits<couchbase::core::topology::configuration> {
                 }
                 if (const auto& hostname = o.find("hostname"); hostname != o.end()) {
                     n.hostname = hostname->second.get_string();
-                    n.hostname = n.hostname.substr(0, n.hostname.rfind(':'));
                 }
                 const auto& s = o.at("services");
                 n.services_plain.key_value = s.template optional<std::uint16_t>("kv");
@@ -233,6 +232,10 @@ struct traits<couchbase::core::topology::configuration> {
                     result.bucket_capabilities.insert(couchbase::core::bucket_capability::nodes_ext);
                 } else if (name == "xattr") {
                     result.bucket_capabilities.insert(couchbase::core::bucket_capability::xattr);
+                } else if (name == "rangeScan") {
+                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::range_scan);
+                } else if (name == "subdoc.ReplicaRead") {
+                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::replica_read);
                 }
             }
         }
@@ -249,6 +252,8 @@ struct traits<couchbase::core::topology::configuration> {
                         result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_inline_functions);
                     } else if (name == "enhancedPreparedStatements") {
                         result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_enhanced_prepared_statements);
+                    } else if (name == "readFromReplica") {
+                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_read_from_replica);
                     }
                 }
             }

data/ext/couchbase/core/utils/connection_string.cxx

@@ -182,33 +182,39 @@ struct action<bucket_name> {
 } // namespace priv
 
 void
-parse_option(std::string& receiver, const std::string& /* name */, const std::string& value)
+parse_option(std::string& receiver, const std::string& /* name */, const std::string& value, std::vector<std::string>& /* warnings */)
 {
     receiver = string_codec::url_decode(value);
 }
 
 void
-parse_option(bool& receiver, const std::string& /* name */, const std::string& value)
+parse_option(bool& receiver, const std::string& name, const std::string& value, std::vector<std::string>& warnings)
 {
     if (value == "true" || value == "yes" || value == "on") {
         receiver = true;
     } else if (value == "false" || value == "no" || value == "off") {
         receiver = false;
+    } else {
+        warnings.push_back(fmt::format(
+          R"(unable to parse "{}" parameter in connection string (value "{}" cannot be interpreted as a boolean))", name, value));
     }
 }
 
 void
-parse_option(tls_verify_mode& receiver, const std::string& /* name */, const std::string& value)
+parse_option(tls_verify_mode& receiver, const std::string& name, const std::string& value, std::vector<std::string>& warnings)
 {
     if (value == "none") {
         receiver = tls_verify_mode::none;
     } else if (value == "peer") {
         receiver = tls_verify_mode::peer;
+    } else {
+        warnings.push_back(fmt::format(
+          R"(unable to parse "{}" parameter in connection string (value "{}" is not a valid TLS verification mode))", name, value));
     }
 }
 
 void
-parse_option(io::ip_protocol& receiver, const std::string& /* name */, const std::string& value)
+parse_option(io::ip_protocol& receiver, const std::string& name, const std::string& value, std::vector<std::string>& warnings)
 {
     if (value == "any") {
         receiver = io::ip_protocol::any;
@@ -216,23 +222,28 @@ parse_option(io::ip_protocol& receiver, const std::string& /* name */, const std
         receiver = io::ip_protocol::force_ipv4;
     } else if (value == "force_ipv6") {
         receiver = io::ip_protocol::force_ipv6;
+    } else {
+        warnings.push_back(fmt::format(
+          R"(unable to parse "{}" parameter in connection string (value "{}" is not a valid IP protocol preference))", name, value));
     }
 }
 
 void
-parse_option(std::size_t& receiver, const std::string& name, const std::string& value)
+parse_option(std::size_t& receiver, const std::string& name, const std::string& value, std::vector<std::string>& warnings)
 {
     try {
         receiver = std::stoull(value, nullptr, 10);
     } catch (const std::invalid_argument& ex1) {
-        CB_LOG_WARNING(R"(unable to parse "{}" parameter in connection string (value "{}" is not a number): {})", name, value, ex1.what());
+        warnings.push_back(
+          fmt::format(R"(unable to parse "{}" parameter in connection string (value "{}" is not a number): {})", name, value, ex1.what()));
     } catch (const std::out_of_range& ex2) {
-        CB_LOG_WARNING(R"(unable to parse "{}" parameter in connection string (value "{}" is out of range): {})", name, value, ex2.what());
+        warnings.push_back(
+          fmt::format(R"(unable to parse "{}" parameter in connection string (value "{}" is out of range): {})", name, value, ex2.what()));
     }
 }
 
 void
-parse_option(std::chrono::milliseconds& receiver, const std::string& name, const std::string& value)
+parse_option(std::chrono::milliseconds& receiver, const std::string& name, const std::string& value, std::vector<std::string>& warnings)
 {
     try {
         receiver = std::chrono::duration_cast<std::chrono::milliseconds>(parse_duration(value));
@@ -240,11 +251,11 @@ parse_option(std::chrono::milliseconds& receiver, const std::string& name, const
         try {
             receiver = std::chrono::milliseconds(std::stoull(value, nullptr, 10));
         } catch (const std::invalid_argument& ex1) {
-            CB_LOG_WARNING(
-              R"(unable to parse "{}" parameter in connection string (value "{}" is not a number): {})", name, value, ex1.what());
+            warnings.push_back(fmt::format(
+              R"(unable to parse "{}" parameter in connection string (value "{}" is not a number): {})", name, value, ex1.what()));
         } catch (const std::out_of_range& ex2) {
-            CB_LOG_WARNING(
-              R"(unable to parse "{}" parameter in connection string (value "{}" is out of range): {})", name, value, ex2.what());
+            warnings.push_back(fmt::format(
+              R"(unable to parse "{}" parameter in connection string (value "{}" is out of range): {})", name, value, ex2.what()));
         }
     }
 }
@@ -262,68 +273,68 @@ extract_options(connection_string& connstr)
              * Number of seconds the client should wait while attempting to connect to a node’s KV service via a socket.  Initial
              * connection, reconnecting, node added, etc.
              */
-            parse_option(connstr.options.connect_timeout, name, value);
+            parse_option(connstr.options.connect_timeout, name, value, connstr.warnings);
         } else if (name == "kv_timeout" || name == "key_value_timeout") {
             /**
              * Number of milliseconds to wait before timing out a KV operation by the client.
              */
-            parse_option(connstr.options.key_value_timeout, name, value);
+            parse_option(connstr.options.key_value_timeout, name, value, connstr.warnings);
         } else if (name == "kv_durable_timeout" || name == "key_value_durable_timeout") {
             /**
              * Number of milliseconds to wait before timing out a KV operation that is either using synchronous durability or
              * observe-based durability.
              */
-            parse_option(connstr.options.key_value_durable_timeout, name, value);
+            parse_option(connstr.options.key_value_durable_timeout, name, value, connstr.warnings);
         } else if (name == "view_timeout") {
             /**
              * Number of seconds to wait before timing out a View request  by the client..
              */
-            parse_option(connstr.options.view_timeout, name, value);
+            parse_option(connstr.options.view_timeout, name, value, connstr.warnings);
         } else if (name == "query_timeout") {
             /**
              * Number of seconds to wait before timing out a Query or N1QL request by the client.
              */
-            parse_option(connstr.options.query_timeout, name, value);
+            parse_option(connstr.options.query_timeout, name, value, connstr.warnings);
         } else if (name == "analytics_timeout") {
             /**
              * Number of seconds to wait before timing out an Analytics request by the client.
              */
-            parse_option(connstr.options.analytics_timeout, name, value);
+            parse_option(connstr.options.analytics_timeout, name, value, connstr.warnings);
         } else if (name == "search_timeout") {
             /**
              * Number of seconds to wait before timing out a Search request by the client.
              */
-            parse_option(connstr.options.search_timeout, name, value);
+            parse_option(connstr.options.search_timeout, name, value, connstr.warnings);
         } else if (name == "management_timeout") {
             /**
              * Number of seconds to wait before timing out a Management API request by the client.
              */
-            parse_option(connstr.options.management_timeout, name, value);
+            parse_option(connstr.options.management_timeout, name, value, connstr.warnings);
         } else if (name == "trust_certificate") {
-            parse_option(connstr.options.trust_certificate, name, value);
+            parse_option(connstr.options.trust_certificate, name, value, connstr.warnings);
         } else if (name == "enable_mutation_tokens") {
             /**
              * Request mutation tokens at connection negotiation time. Turning this off will save 16 bytes per operation response.
              */
-            parse_option(connstr.options.enable_mutation_tokens, name, value);
+            parse_option(connstr.options.enable_mutation_tokens, name, value, connstr.warnings);
         } else if (name == "enable_tcp_keep_alive") {
             /**
              * Gets or sets a value indicating whether enable TCP keep-alive.
              */
-            parse_option(connstr.options.enable_tcp_keep_alive, name, value);
+            parse_option(connstr.options.enable_tcp_keep_alive, name, value, connstr.warnings);
         } else if (name == "tcp_keep_alive_interval") {
             /**
              * Specifies the timeout, in milliseconds, with no activity until the first keep-alive packet is sent. This applies to all
              * services, but is advisory: if the underlying platform does not support this on all connections, it will be applied only
              * on those it can be.
              */
-            parse_option(connstr.options.tcp_keep_alive_interval, name, value);
+            parse_option(connstr.options.tcp_keep_alive_interval, name, value, connstr.warnings);
         } else if (name == "force_ipv4") {
             /**
              * Sets the SDK configuration to do IPv4 Name Resolution
              */
             bool force_ipv4 = false;
-            parse_option(force_ipv4, name, value);
+            parse_option(force_ipv4, name, value, connstr.warnings);
             if (force_ipv4) {
                 connstr.options.use_ip_protocol = io::ip_protocol::force_ipv4;
             }
@@ -331,40 +342,40 @@ extract_options(connection_string& connstr)
             /**
              * Controls preference of IP protocol for name resolution
              */
-            parse_option(connstr.options.use_ip_protocol, name, value);
+            parse_option(connstr.options.use_ip_protocol, name, value, connstr.warnings);
         } else if (name == "config_poll_interval") {
-            parse_option(connstr.options.config_poll_interval, name, value);
+            parse_option(connstr.options.config_poll_interval, name, value, connstr.warnings);
         } else if (name == "config_poll_floor") {
-            parse_option(connstr.options.config_poll_floor, name, value);
+            parse_option(connstr.options.config_poll_floor, name, value, connstr.warnings);
         } else if (name == "max_http_connections") {
             /**
              * The maximum number of HTTP connections allowed on a per-host and per-port basis.  0 indicates an unlimited number of
              * connections are permitted.
              */
-            parse_option(connstr.options.max_http_connections, name, value);
+            parse_option(connstr.options.max_http_connections, name, value, connstr.warnings);
         } else if (name == "idle_http_connection_timeout") {
             /**
              * The period of time an HTTP connection can be idle before it is forcefully disconnected.
              */
-            parse_option(connstr.options.idle_http_connection_timeout, name, value);
+            parse_option(connstr.options.idle_http_connection_timeout, name, value, connstr.warnings);
         } else if (name == "bootstrap_timeout") {
             /**
              * The period of time allocated to complete bootstrap
              */
-            parse_option(connstr.options.bootstrap_timeout, name, value);
+            parse_option(connstr.options.bootstrap_timeout, name, value, connstr.warnings);
         } else if (name == "resolve_timeout") {
             /**
              * The period of time to resolve DNS name of the node to IP address
              */
-            parse_option(connstr.options.resolve_timeout, name, value);
+            parse_option(connstr.options.resolve_timeout, name, value, connstr.warnings);
         } else if (name == "enable_dns_srv") {
             if (connstr.bootstrap_nodes.size() == 1) {
-                parse_option(connstr.options.enable_dns_srv, name, value);
+                parse_option(connstr.options.enable_dns_srv, name, value, connstr.warnings);
             } else {
-                CB_LOG_WARNING(
-                  R"(parameter "{}" require single entry in bootstrap nodes list of the connection string, ignoring (value "{}"))",
+                connstr.warnings.push_back(fmt::format(
+                  R"(parameter "{}" requires single entry in bootstrap nodes list of the connection string, ignoring (value "{}"))",
                   name,
-                  value);
+                  value));
             }
         } else if (name == "network") {
             connstr.options.network = value; /* current known values are "auto", "default" and "external" */
@@ -372,51 +383,55 @@ extract_options(connection_string& connstr)
             /**
              * Whether to display N1QL, Analytics, Search queries on info level (default false)
              */
-            parse_option(connstr.options.show_queries, name, value);
+            parse_option(connstr.options.show_queries, name, value, connstr.warnings);
         } else if (name == "enable_clustermap_notification") {
             /**
              * Allow the server to push configuration updates asynchronously.
              */
-            parse_option(connstr.options.enable_clustermap_notification, name, value);
+            parse_option(connstr.options.enable_clustermap_notification, name, value, connstr.warnings);
         } else if (name == "enable_unordered_execution") {
             /**
              * Allow the server to reorder commands
              */
-            parse_option(connstr.options.enable_unordered_execution, name, value);
+            parse_option(connstr.options.enable_unordered_execution, name, value, connstr.warnings);
         } else if (name == "enable_compression") {
             /**
              * Announce support of compression (snappy) to server
              */
-            parse_option(connstr.options.enable_compression, name, value);
+            parse_option(connstr.options.enable_compression, name, value, connstr.warnings);
         } else if (name == "enable_tracing") {
             /**
              * true - use threshold_logging_tracer
              * false - use noop_tracer
              */
-            parse_option(connstr.options.enable_tracing, name, value);
+            parse_option(connstr.options.enable_tracing, name, value, connstr.warnings);
         } else if (name == "enable_metrics") {
             /**
              * true - use logging_meter
              * false - use noop_meter
              */
-            parse_option(connstr.options.enable_metrics, name, value);
+            parse_option(connstr.options.enable_metrics, name, value, connstr.warnings);
         } else if (name == "tls_verify") {
-            parse_option(connstr.options.tls_verify, name, value);
+            parse_option(connstr.options.tls_verify, name, value, connstr.warnings);
         } else if (name == "disable_mozilla_ca_certificates") {
-            parse_option(connstr.options.disable_mozilla_ca_certificates, name, value);
+            parse_option(connstr.options.disable_mozilla_ca_certificates, name, value, connstr.warnings);
+        } else if (name == "tls_disable_deprecated_protocols") {
+            parse_option(connstr.options.tls_disable_deprecated_protocols, name, value, connstr.warnings);
+        } else if (name == "tls_disable_v1_2") {
+            parse_option(connstr.options.tls_disable_v1_2, name, value, connstr.warnings);
         } else if (name == "user_agent_extra") {
             /**
              * string, that will be appended to identification fields of the server protocols (key in HELO packet for MCBP, "user-agent"
              * header for HTTP)
              */
-            parse_option(connstr.options.user_agent_extra, name, value);
+            parse_option(connstr.options.user_agent_extra, name, value, connstr.warnings);
         } else if (name == "dump_configuration") {
             /**
              * Whether to dump every new configuration on TRACE level
              */
-            parse_option(connstr.options.dump_configuration, name, value);
+            parse_option(connstr.options.dump_configuration, name, value, connstr.warnings);
         } else {
-            CB_LOG_WARNING(R"(unknown parameter "{}" in connection string (value "{}"))", name, value);
+            connstr.warnings.push_back(fmt::format(R"(unknown parameter "{}" in connection string (value "{}"))", name, value));
         }
     }
 }

data/ext/couchbase/core/utils/connection_string.hxx

@@ -68,6 +68,7 @@ struct connection_string {
     bootstrap_mode default_mode{ connection_string::bootstrap_mode::gcccp };
     std::uint16_t default_port{ 11210 };
 
+    std::vector<std::string> warnings{};
     std::optional<std::string> error{};
 };
 

data/ext/couchbase/couchbase/analytics_error_context.hxx

@@ -57,7 +57,7 @@ class analytics_error_context : public error_context
                             std::string http_body,
                             std::string hostname,
                             std::uint16_t port)
-      : error_context{ ec, std::move(last_dispatched_to), std::move(last_dispatched_from), retry_attempts, std::move(retry_reasons) }
+      : error_context{ {}, ec, std::move(last_dispatched_to), std::move(last_dispatched_from), retry_attempts, std::move(retry_reasons) }
       , first_error_code_{ first_error_code }
       , first_error_message_{ std::move(first_error_message) }
       , client_context_id_{ std::move(client_context_id) }

data/ext/couchbase/couchbase/behavior_options.hxx

@@ -60,6 +60,21 @@ class behavior_options
         return *this;
     }
 
+    /**
+     * Selects network to use.
+     *
+     * @param name network name as it is exposed in the configuration.
+     * @return this object for chaining purposes.
+     *
+     * @see https://docs.couchbase.com/server/current/learn/clusters-and-availability/connectivity.html#alternate-addresses
+     * @see https://docs.couchbase.com/server/current/rest-api/rest-set-up-alternate-address.html
+     */
+    auto network(std::string name) -> behavior_options&
+    {
+        network_ = std::move(name);
+        return *this;
+    }
+
     struct built {
         std::string user_agent_extra;
         bool show_queries;
@@ -67,13 +82,14 @@ class behavior_options
         bool enable_mutation_tokens;
         bool enable_unordered_execution;
         bool dump_configuration;
+        std::string network;
     };
 
     [[nodiscard]] auto build() const -> built
     {
         return {
-            user_agent_extra_,           show_queries_,       enable_clustermap_notification_, enable_mutation_tokens_,
-            enable_unordered_execution_, dump_configuration_,
+            user_agent_extra_,   show_queries_, enable_clustermap_notification_, enable_mutation_tokens_, enable_unordered_execution_,
+            dump_configuration_, network_,
         };
     }
 
@@ -84,5 +100,6 @@ class behavior_options
     bool enable_mutation_tokens_{ true };
     bool enable_unordered_execution_{ true };
     bool dump_configuration_{ false };
+    std::string network_{ "auto" };
 };
 } // namespace couchbase