couchbase 4.4.6 → 4.5.1

package/deps/couchbase-cxx-client/core/timeout_defaults.hxx

@@ -42,4 +42,8 @@ constexpr std::chrono::milliseconds config_poll_interval{ 2'500 };
 constexpr std::chrono::milliseconds config_poll_floor{ 50 };
 constexpr std::chrono::milliseconds config_idle_redial_timeout{ 5 * 60'000 };
 constexpr std::chrono::milliseconds idle_http_connection_timeout{ 1'000 };
+
+constexpr std::chrono::milliseconds app_telemetry_ping_interval{ 30'000 };
+constexpr std::chrono::milliseconds app_telemetry_ping_timeout{ 2'000 };
+constexpr std::chrono::milliseconds app_telemetry_backoff_interval{ std::chrono::hours{ 1 } };
 } // namespace couchbase::core::timeout_defaults

package/deps/couchbase-cxx-client/core/topology/configuration.cxx

@@ -29,9 +29,8 @@
 namespace couchbase::core::topology
 {
 auto
-configuration::node::port_or(service_type type,
-                             bool is_tls,
-                             std::uint16_t default_value) const -> std::uint16_t
+configuration::node::port_or(service_type type, bool is_tls, std::uint16_t default_value) const
+  -> std::uint16_t
 {
   if (is_tls) {
     switch (type) {
@@ -90,7 +89,7 @@ configuration::node::hostname_for(const std::string& network) const -> const std
   }
   const auto& address = alt.find(network);
   if (address == alt.end()) {
-    CB_LOG_WARNING(R"(requested network "{}" is not found, fallback to "default" host)", network);
+    CB_LOG_DEBUG(R"(requested network "{}" is not found, fallback to "default" host)", network);
     return hostname;
   }
   return address->second.hostname;
@@ -107,10 +106,9 @@ configuration::node::port_or(const std::string& network,
   }
   const auto& address = alt.find(network);
   if (address == alt.end()) {
-    CB_LOG_WARNING(
-      R"(requested network "{}" is not found, fallback to "default" port of {} service)",
-      network,
-      type);
+    CB_LOG_DEBUG(R"(requested network "{}" is not found, fallback to "default" port of {} service)",
+                 network,
+                 type);
     return port_or(type, is_tls, default_value);
   }
   if (is_tls) {
@@ -163,9 +161,8 @@ configuration::node::port_or(const std::string& network,
 }
 
 auto
-configuration::node::endpoint(const std::string& network,
-                              service_type type,
-                              bool is_tls) const -> std::optional<std::string>
+configuration::node::endpoint(const std::string& network, service_type type, bool is_tls) const
+  -> std::optional<std::string>
 {
   auto p = port_or(type, is_tls, 0);
   if (p == 0) {
@@ -234,8 +231,8 @@ configuration::index_for_this_node() const -> std::size_t
 }
 
 auto
-configuration::server_by_vbucket(std::uint16_t vbucket,
-                                 std::size_t index) const -> std::optional<std::size_t>
+configuration::server_by_vbucket(std::uint16_t vbucket, std::size_t index) const
+  -> std::optional<std::size_t>
 {
   if (!vbmap.has_value() || vbucket >= vbmap->size()) {
     return {};

package/deps/couchbase-cxx-client/core/topology/configuration.hxx

@@ -61,6 +61,8 @@ struct configuration {
     port_map services_tls{};
     std::map<std::string, alternate_address> alt{};
     std::string server_group{};
+    std::optional<std::string> app_telemetry_path{};
+    std::string node_uuid{};
 
     auto operator!=(const node& other) const -> bool
     {
@@ -69,9 +71,8 @@ struct configuration {
              services_tls.key_value != other.services_tls.key_value;
     }
 
-    [[nodiscard]] auto port_or(service_type type,
-                               bool is_tls,
-                               std::uint16_t default_value) const -> std::uint16_t;
+    [[nodiscard]] auto port_or(service_type type, bool is_tls, std::uint16_t default_value) const
+      -> std::uint16_t;
 
     [[nodiscard]] auto port_or(const std::string& network,
                                service_type type,
@@ -80,9 +81,8 @@ struct configuration {
 
     [[nodiscard]] auto hostname_for(const std::string& network) const -> const std::string&;
 
-    [[nodiscard]] auto endpoint(const std::string& network,
-                                service_type type,
-                                bool is_tls) const -> std::optional<std::string>;
+    [[nodiscard]] auto endpoint(const std::string& network, service_type type, bool is_tls) const
+      -> std::optional<std::string>;
   };
 
   [[nodiscard]] auto select_network(const std::string& bootstrap_hostname) const -> std::string;
@@ -128,13 +128,13 @@ struct configuration {
                               const std::string& hostname,
                               const std::string& port) const -> bool;
 
-  auto map_key(const std::string& key,
-               std::size_t index) const -> std::pair<std::uint16_t, std::optional<std::size_t>>;
-  auto map_key(const std::vector<std::byte>& key,
-               std::size_t index) const -> std::pair<std::uint16_t, std::optional<std::size_t>>;
+  auto map_key(const std::string& key, std::size_t index) const
+    -> std::pair<std::uint16_t, std::optional<std::size_t>>;
+  auto map_key(const std::vector<std::byte>& key, std::size_t index) const
+    -> std::pair<std::uint16_t, std::optional<std::size_t>>;
 
-  auto server_by_vbucket(std::uint16_t vbucket,
-                         std::size_t index) const -> std::optional<std::size_t>;
+  auto server_by_vbucket(std::uint16_t vbucket, std::size_t index) const
+    -> std::optional<std::size_t>;
 };
 
 using endpoint = std::pair<std::string, std::string>;
@@ -145,7 +145,6 @@ make_blank_configuration(const std::string& hostname,
                          std::uint16_t tls_port) -> configuration;
 
 auto
-make_blank_configuration(const std::vector<endpoint>& endpoints,
-                         bool use_tls,
-                         bool force = false) -> configuration;
+make_blank_configuration(const std::vector<endpoint>& endpoints, bool use_tls, bool force = false)
+  -> configuration;
 } // namespace couchbase::core::topology

package/deps/couchbase-cxx-client/core/topology/configuration_json.hxx

@@ -61,6 +61,12 @@ struct traits<couchbase::core::topology::configuration> {
         if (const auto& group = o.find("serverGroup"); group != o.end()) {
           n.server_group = group->second.get_string();
         }
+        if (const auto& path = o.find("appTelemetryPath"); path != o.end()) {
+          n.app_telemetry_path = path->second.get_string();
+        }
+        if (const auto& uuid = o.find("nodeUUID"); uuid != o.end()) {
+          n.node_uuid = uuid->second.get_string();
+        }
         const auto& s = o.at("services");
         n.services_plain.key_value = s.template optional<std::uint16_t>("kv");
         n.services_plain.management = s.template optional<std::uint16_t>("mgmt");

package/deps/couchbase-cxx-client/core/transactions/async_attempt_context.hxx

@@ -15,11 +15,14 @@
  */
 #pragma once
 
-#include "core/error_context/subdocument_error_context.hxx"
 #include "core/operations/document_query.hxx"
-#include "exceptions.hxx"
+#include "transaction_get_multi_mode.hxx"
+#include "transaction_get_multi_replicas_from_preferred_server_group_mode.hxx"
+#include "transaction_get_multi_replicas_from_preferred_server_group_result.hxx"
+#include "transaction_get_multi_result.hxx"
 #include "transaction_get_result.hxx"
 
+// FIXME(SA): remove public API from the core
 #include <couchbase/transactions/transaction_query_options.hxx>
 
 #include <optional>
@@ -42,6 +45,11 @@ public:
   using QueryCallback =
     std::function<void(std::exception_ptr, std::optional<core::operations::query_response>)>;
 
+  async_attempt_context() = default;
+  async_attempt_context(async_attempt_context&&) = default;
+  async_attempt_context(const async_attempt_context&) noexcept = default;
+  auto operator=(async_attempt_context&&) -> async_attempt_context& = default;
+  auto operator=(const async_attempt_context&) noexcept -> async_attempt_context& = default;
   virtual ~async_attempt_context() = default;
 
   /**
@@ -78,6 +86,18 @@ public:
     const core::document_id& id,
     std::function<void(std::exception_ptr, std::optional<transaction_get_result>)>&& cb) = 0;
 
+  virtual void get_multi(
+    const std::vector<core::document_id>& ids,
+    transaction_get_multi_mode mode,
+    std::function<void(std::exception_ptr, std::optional<transaction_get_multi_result>)>&& cb) = 0;
+
+  virtual void get_multi_replicas_from_preferred_server_group(
+    const std::vector<core::document_id>& ids,
+    transaction_get_multi_replicas_from_preferred_server_group_mode mode,
+    std::function<void(
+      std::exception_ptr,
+      std::optional<transaction_get_multi_replicas_from_preferred_server_group_result>)>&& cb) = 0;
+
   /**
    * Mutates the specified document with new content, using the document's last
    * TransactionDocument#cas().

package/deps/couchbase-cxx-client/core/transactions/attempt_context.hxx

@@ -15,10 +15,14 @@
  */
 #pragma once
 
+#include "core/operations/document_query.hxx"
+#include "transaction_get_multi_mode.hxx"
+#include "transaction_get_multi_replicas_from_preferred_server_group_mode.hxx"
+#include "transaction_get_multi_replicas_from_preferred_server_group_result.hxx"
+#include "transaction_get_multi_result.hxx"
 #include "transaction_get_result.hxx"
 
-#include "internal/exceptions_internal.hxx"
-
+// TODO(SA): remove public API from core interfaces
 #include <couchbase/transactions/transaction_query_options.hxx>
 
 #include <optional>
@@ -37,7 +41,13 @@ namespace couchbase::core::transactions
 class attempt_context
 {
 public:
+  attempt_context() = default;
+  attempt_context(attempt_context&&) noexcept = default;
+  attempt_context(const attempt_context&) = default;
+  auto operator=(attempt_context&&) noexcept -> attempt_context& = default;
+  auto operator=(const attempt_context&) -> attempt_context& = default;
   virtual ~attempt_context() = default;
+
   /**
    * Gets a document from the specified Couchbase collection matching the
    * specified id.
@@ -80,6 +90,14 @@ public:
   virtual auto get_replica_from_preferred_server_group(const core::document_id& id)
     -> std::optional<transaction_get_result> = 0;
 
+  virtual auto get_multi(const std::vector<core::document_id>& ids, transaction_get_multi_mode mode)
+    -> transaction_get_multi_result = 0;
+
+  virtual auto get_multi_replicas_from_preferred_server_group(
+    const std::vector<core::document_id>& ids,
+    transaction_get_multi_replicas_from_preferred_server_group_mode mode)
+    -> transaction_get_multi_replicas_from_preferred_server_group_result = 0;
+
   /**
    * Mutates the specified document with new content, using the document's last
    * TransactionDocument#cas().
@@ -101,8 +119,8 @@ public:
    * @throws transaction_operation_failed which either should not be caught by
    * the lambda, or rethrown if it is caught.
    */
-  virtual auto replace(const transaction_get_result& document,
-                       codec::encoded_value content) -> transaction_get_result = 0;
+  virtual auto replace(const transaction_get_result& document, codec::encoded_value content)
+    -> transaction_get_result = 0;
 
   /**
    * Inserts a new document into the specified Couchbase collection.
@@ -124,8 +142,8 @@ public:
    * @throws transaction_operation_failed which either should not be caught by
    * the lambda, or rethrown if it is caught.
    */
-  virtual auto insert(const core::document_id& id,
-                      codec::encoded_value content) -> transaction_get_result = 0;
+  virtual auto insert(const core::document_id& id, codec::encoded_value content)
+    -> transaction_get_result = 0;
 
   /**
    * Removes the specified document, using the document's last
@@ -157,7 +175,7 @@ public:
              const couchbase::transactions::transaction_query_options& opts,
              std::optional<std::string> query_context = {}) -> core::operations::query_response
   {
-    return do_core_query(statement, opts, query_context);
+    return do_core_query(statement, opts, std::move(query_context));
   };
 
   /**