couchbase 4.2.0 → 4.2.1

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

@@ -0,0 +1,39 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ * Copyright 2022-Present 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
+ *
+ *     https://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
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace couchbase::core
+{
+struct dns_srv_record {
+    std::string protocol{};
+    std::string scheme{};
+    std::string hostname{};
+
+    [[nodiscard]] auto to_string() const -> std::string;
+};
+
+struct seed_config {
+    std::vector<std::string> mcbp_addresses{};
+    std::vector<std::string> http_addresses{};
+    std::optional<dns_srv_record> srv_record{};
+
+    [[nodiscard]] auto to_string() const -> std::string;
+};
+} // namespace couchbase::core

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

@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ * Copyright 2022-Present 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
+
+#include "utils/movable_function.hxx"
+
+#include <chrono>
+#include <map>
+#include <string>
+#include <system_error>
+
+namespace couchbase
+{
+class retry_strategy;
+namespace tracing
+{
+class request_span;
+} // namespace tracing
+} // namespace couchbase
+
+namespace couchbase::core
+{
+class stats_options
+{
+  public:
+    std::string key{};
+    std::shared_ptr<couchbase::retry_strategy> retry_strategy{};
+    std::chrono::milliseconds timeout{};
+    std::shared_ptr<couchbase::tracing::request_span> parent_span{};
+
+    struct {
+        std::string user{};
+    } internal{};
+};
+
+struct single_server_stats {
+    std::error_code error{};
+    std::map<std::string, std::string> stats{};
+};
+
+class stats_result
+{
+  public:
+    std::map<std::string, single_server_stats> servers{};
+};
+
+using stats_callback = utils::movable_function<void(stats_result result, std::error_code ec)>;
+} // namespace couchbase::core

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

@@ -0,0 +1,124 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ * Copyright 2022-Present 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
+
+#include "protocol/client_opcode.hxx"
+#include "resource_units.hxx"
+#include "utils/movable_function.hxx"
+
+#include <couchbase/cas.hxx>
+#include <couchbase/durability_level.hxx>
+#include <couchbase/mutation_token.hxx>
+
+#include <chrono>
+#include <optional>
+#include <string>
+#include <system_error>
+#include <vector>
+
+namespace couchbase
+{
+class retry_strategy;
+namespace tracing
+{
+class request_span;
+} // namespace tracing
+} // namespace couchbase
+
+namespace couchbase::core
+{
+struct subdoc_operation {
+    protocol::subdoc_opcode opcode{};
+    std::uint8_t flags{};
+    std::string path{};
+    std::vector<std::byte> value{};
+};
+
+struct subdoc_result {
+    std::error_code error{};
+    std::vector<std::byte> value{};
+};
+
+class lookup_in_options
+{
+  public:
+    std::vector<std::byte> key{};
+    std::uint8_t flags{};
+    std::vector<subdoc_operation> operations{};
+    std::string collection_name{};
+    std::string scope_name{};
+    std::uint32_t collection_id{};
+
+    std::shared_ptr<couchbase::retry_strategy> retry_strategy{};
+    std::chrono::milliseconds timeout{};
+    std::shared_ptr<couchbase::tracing::request_span> parent_span{};
+
+    struct {
+        std::string user{};
+    } internal{};
+};
+
+class lookup_in_result
+{
+  public:
+    std::vector<subdoc_result> results{};
+    couchbase::cas cas{};
+
+    struct {
+        bool is_deleted{};
+        std::optional<resource_unit_result> resource_units{};
+    } internal{};
+};
+
+using lookup_in_callback = utils::movable_function<void(lookup_in_result result, std::error_code ec)>;
+
+class mutate_in_options
+{
+  public:
+    std::vector<std::byte> key{};
+    std::uint8_t flags{};
+    couchbase::cas cas{};
+    std::uint32_t expiry{};
+    std::vector<subdoc_operation> operations{};
+    std::string collection_name{};
+    std::string scope_name{};
+    std::uint32_t collection_id{};
+    couchbase::durability_level durability_level{};
+    std::chrono::milliseconds durability_level_timeout{};
+
+    std::shared_ptr<couchbase::retry_strategy> retry_strategy{};
+    std::chrono::milliseconds timeout{};
+    std::shared_ptr<couchbase::tracing::request_span> parent_span{};
+
+    struct {
+        std::string user{};
+    } internal{};
+};
+
+class mutate_in_result
+{
+  public:
+    std::vector<subdoc_result> results{};
+    couchbase::cas cas{};
+    mutation_token token{};
+
+    struct {
+        std::optional<resource_unit_result> resource_units{};
+    } internal{};
+};
+
+using mutate_in_callback = utils::movable_function<void(mutate_in_result result, std::error_code ec)>;
+} // namespace couchbase::core

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

@@ -34,10 +34,12 @@ 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 };
-constexpr std::chrono::milliseconds config_poll_floor{ 50'000 };
+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{ 4'500 };
 } // namespace couchbase::core::timeout_defaults

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

@@ -85,7 +85,7 @@ configuration::node::hostname_for(const std::string& network) const
     }
     const auto& address = alt.find(network);
     if (address == alt.end()) {
-        LOG_WARNING(R"(requested network "{}" is not found, fallback to "default" host)", network);
+        CB_LOG_WARNING(R"(requested network "{}" is not found, fallback to "default" host)", network);
         return hostname;
     }
     return address->second.hostname;
@@ -99,7 +99,7 @@ configuration::node::port_or(const std::string& network, service_type type, bool
     }
     const auto& address = alt.find(network);
     if (address == alt.end()) {
-        LOG_WARNING(R"(requested network "{}" is not found, fallback to "default" port of {} service)", network, type);
+        CB_LOG_WARNING(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) {
@@ -205,15 +205,16 @@ configuration::index_for_this_node() const
     throw std::runtime_error("no nodes marked as this_node");
 }
 
-std::pair<std::uint16_t, std::int16_t>
-configuration::map_key(const std::string& key, std::size_t index)
+std::optional<std::size_t>
+configuration::server_by_vbucket(std::uint16_t vbucket, std::size_t index)
 {
-    if (!vbmap.has_value()) {
-        return { 0, -1 };
+    if (!vbmap.has_value() || vbucket >= vbmap->size()) {
+        return {};
+    }
+    if (auto server_index = vbmap->at(vbucket)[index]; server_index >= 0) {
+        return static_cast<std::size_t>(server_index);
     }
-    std::uint32_t crc = utils::hash_crc32(key.data(), key.size());
-    auto vbucket = std::uint16_t(crc % vbmap->size());
-    return { vbucket, vbmap->at(vbucket)[index] };
+    return {};
 }
 
 configuration

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

@@ -122,7 +122,18 @@ struct configuration {
     [[nodiscard]] std::size_t index_for_this_node() const;
     [[nodiscard]] bool has_node_with_hostname(const std::string& hostname) const;
 
-    std::pair<std::uint16_t, std::int16_t> map_key(const std::string& key, std::size_t index);
+    template<typename Key>
+    std::pair<std::uint16_t, std::optional<std::size_t>> map_key(const Key& key, std::size_t index)
+    {
+        if (!vbmap.has_value()) {
+            return { 0, {} };
+        }
+        std::uint32_t crc = utils::hash_crc32(key.data(), key.size());
+        auto vbucket = static_cast<std::uint16_t>(crc % vbmap->size());
+        return { vbucket, server_by_vbucket(vbucket, index) };
+    }
+
+    std::optional<std::size_t> server_by_vbucket(std::uint16_t vbucket, std::size_t index);
 };
 
 configuration

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

@@ -78,7 +78,7 @@ struct traits<couchbase::core::error_map> {
                 } else if (attr_val == "rate-limit") {
                     attributes.insert(couchbase::key_value_error_map_attribute::rate_limit);
                 } else {
-                    LOG_WARNING(R"(skipping unknown attribute "{}" in error map for code={} and name="{}")", attr_val, code, name);
+                    CB_LOG_WARNING(R"(skipping unknown attribute "{}" in error map for code={} and name="{}")", attr_val, code, name);
                 }
             }
             result.errors.emplace(code, couchbase::key_value_error_map_info{ code, name, description, attributes });

package/deps/couchbase-cxx-client/core/tracing/constants.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-Present Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -60,6 +60,9 @@ constexpr auto mcbp_prepend = "cb.prepend";
 constexpr auto mcbp_increment = "cb.increment";
 constexpr auto mcbp_decrement = "cb.decrement";
 constexpr auto mcbp_observe = "cb.observe";
+constexpr auto mcbp_range_scan_create = "cb.range_scan_create";
+constexpr auto mcbp_range_scan_continue = "cb.range_scan_continue";
+constexpr auto mcbp_range_scan_cancel = "cb.range_scan_cancel";
 /* multi-command operations */
 constexpr auto mcbp_get_all_replicas = "cb.get_all_replicas";
 constexpr auto mcbp_get_any_replica = "cb.get_any_replica";
@@ -211,6 +214,15 @@ span_name_for_mcbp_command(protocol::client_opcode opcode)
         case protocol::client_opcode::observe:
             return operation::mcbp_exists;
 
+        case protocol::client_opcode::range_scan_create:
+            return operation::mcbp_range_scan_create;
+
+        case protocol::client_opcode::range_scan_continue:
+            return operation::mcbp_range_scan_continue;
+
+        case protocol::client_opcode::range_scan_cancel:
+            return operation::mcbp_range_scan_cancel;
+
         case protocol::client_opcode::noop:
         case protocol::client_opcode::version:
         case protocol::client_opcode::stat:

package/deps/couchbase-cxx-client/core/tracing/threshold_logging_tracer.cxx

@@ -348,7 +348,7 @@ class threshold_logging_tracer_impl
             queue.pop();
         }
         report["top"] = entries;
-        LOG_WARNING("Orphan responses observed: {}", utils::json::generate(report));
+        CB_LOG_WARNING("Orphan responses observed: {}", utils::json::generate(report));
     }
 
     void log_threshold_report()
@@ -373,7 +373,7 @@ class threshold_logging_tracer_impl
                 queue.pop();
             }
             report["top"] = entries;
-            LOG_WARNING("Operations over threshold: {}", utils::json::generate(report));
+            CB_LOG_WARNING("Operations over threshold: {}", utils::json::generate(report));
         }
     }
 

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

@@ -17,7 +17,7 @@
 
 #include "core/cluster.hxx"
 
-#include "couchbase/transactions/transaction_config.hxx"
+#include "couchbase/transactions/transactions_config.hxx"
 #include "exceptions.hxx"
 #include "internal/atr_entry.hxx"
 #include "internal/doc_record.hxx"
@@ -35,7 +35,7 @@ namespace couchbase::core::transactions
 class active_transaction_record
 {
   public:
-    // TODO: we should get the kv_timeout and put it in the request (pass in the transaction_config)
+    // TODO: we should get the kv_timeout and put it in the request (pass in the transactions_config)
     template<typename Callback>
     static void get_atr(std::shared_ptr<core::cluster> cluster, const core::document_id& atr_id, Callback&& cb)
     {

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

@@ -17,12 +17,11 @@
 
 #include "couchbase/cluster.hxx"
 #include "couchbase/subdocument_error_context.hxx"
+#include "couchbase/transactions/transaction_query_options.hxx"
 #include "exceptions.hxx"
 #include "transaction_get_result.hxx"
-#include "transaction_query_options.hxx"
 
 #include "core/operations/document_query.hxx"
-#include "core/utils/movable_function.hxx"
 #include <future>
 #include <optional>
 #include <string>
@@ -39,8 +38,8 @@ class transaction_operation_failed;
 class async_attempt_context
 {
   public:
-    using Callback = utils::movable_function<void(std::exception_ptr, std::optional<transaction_get_result>)>;
-    using VoidCallback = utils::movable_function<void(std::exception_ptr)>;
+    using Callback = std::function<void(std::exception_ptr, std::optional<transaction_get_result>)>;
+    using VoidCallback = std::function<void(std::exception_ptr)>;
     using QueryCallback = std::function<void(std::exception_ptr, std::optional<core::operations::query_response>)>;
     virtual ~async_attempt_context() = default;
     /**
@@ -121,7 +120,9 @@ class async_attempt_context
      * @param options options to apply to the query.
      * @param cb callback which is called when the query completes.
      */
-    virtual void query(const std::string& statement, const transaction_query_options& options, QueryCallback&& cb) = 0;
+    virtual void query(const std::string& statement,
+                       const couchbase::transactions::transaction_query_options& options,
+                       QueryCallback&& cb) = 0;
 
     /**
      * Performs a Query, within the current transaction.
@@ -131,7 +132,7 @@ class async_attempt_context
      */
     void query(const std::string& statement, QueryCallback&& cb)
     {
-        transaction_query_options opts;
+        couchbase::transactions::transaction_query_options opts;
         return query(statement, opts, std::move(cb));
     }
 

package/deps/couchbase-cxx-client/core/transactions/atr_cleanup_entry.cxx

@@ -114,7 +114,7 @@ atr_cleanup_entry::check_atr_and_cleanup(std::shared_ptr<spdlog::logger> logger,
 {
     // ExtStoreDurability: this is the first point where we're guaranteed to have the ATR entry
     auto durability_level_raw = atr_entry_->durability_level();
-    auto durability_level = cleanup_->config().durability_level();
+    auto durability_level = cleanup_->config().level;
     if (durability_level_raw.has_value()) {
         durability_level = store_string_to_durability_level(durability_level_raw.value());
     }
@@ -134,12 +134,12 @@ atr_cleanup_entry::check_atr_and_cleanup(std::shared_ptr<spdlog::logger> logger,
         throw *err;
     }
     cleanup_docs(logger, durability_level);
-    auto ec = cleanup_->config().cleanup_hooks().on_cleanup_docs_completed();
+    auto ec = cleanup_->config().cleanup_hooks->on_cleanup_docs_completed();
     if (ec) {
         throw client_error(*ec, "on_cleanup_docs_completed hook threw error");
     }
     cleanup_entry(logger, durability_level);
-    ec = cleanup_->config().cleanup_hooks().on_cleanup_completed();
+    ec = cleanup_->config().cleanup_hooks->on_cleanup_completed();
     if (ec) {
         throw client_error(*ec, "on_cleanup_completed hook threw error");
     }
@@ -250,7 +250,7 @@ atr_cleanup_entry::commit_docs(std::shared_ptr<spdlog::logger> logger, std::opti
         do_per_doc(logger, *docs, true, [&](std::shared_ptr<spdlog::logger> log, transaction_get_result& doc, bool) {
             if (doc.links().has_staged_content()) {
                 auto content = doc.links().staged_content();
-                auto ec = cleanup_->config().cleanup_hooks().before_commit_doc(doc.id().key());
+                auto ec = cleanup_->config().cleanup_hooks->before_commit_doc(doc.id().key());
                 if (ec) {
                     throw client_error(*ec, "before_commit_doc hook threw error");
                 }
@@ -293,7 +293,7 @@ atr_cleanup_entry::remove_docs(std::shared_ptr<spdlog::logger> logger, std::opti
 {
     if (docs) {
         do_per_doc(logger, *docs, true, [&](std::shared_ptr<spdlog::logger> log, transaction_get_result& doc, bool is_deleted) {
-            auto ec = cleanup_->config().cleanup_hooks().before_remove_doc(doc.id().key());
+            auto ec = cleanup_->config().cleanup_hooks->before_remove_doc(doc.id().key());
             if (ec) {
                 throw client_error(*ec, "before_remove_doc hook threw error");
             }
@@ -337,7 +337,7 @@ atr_cleanup_entry::remove_docs_staged_for_removal(std::shared_ptr<spdlog::logger
     if (docs) {
         do_per_doc(logger, *docs, true, [&](std::shared_ptr<spdlog::logger> log, transaction_get_result& doc, bool) {
             if (doc.links().is_document_being_removed()) {
-                auto ec = cleanup_->config().cleanup_hooks().before_remove_doc_staged_for_removal(doc.id().key());
+                auto ec = cleanup_->config().cleanup_hooks->before_remove_doc_staged_for_removal(doc.id().key());
                 if (ec) {
                     throw client_error(*ec, "before_remove_doc_staged_for_removal hook threw error");
                 }
@@ -367,7 +367,7 @@ atr_cleanup_entry::remove_txn_links(std::shared_ptr<spdlog::logger> logger,
 {
     if (docs) {
         do_per_doc(logger, *docs, false, [&](std::shared_ptr<spdlog::logger> log, transaction_get_result& doc, bool) {
-            auto ec = cleanup_->config().cleanup_hooks().before_remove_links(doc.id().key());
+            auto ec = cleanup_->config().cleanup_hooks->before_remove_links(doc.id().key());
             if (ec) {
                 throw client_error(*ec, "before_remove_links hook threw error");
             }
@@ -394,7 +394,7 @@ void
 atr_cleanup_entry::cleanup_entry(std::shared_ptr<spdlog::logger> logger, durability_level dl)
 {
     try {
-        auto ec = cleanup_->config().cleanup_hooks().before_atr_remove();
+        auto ec = cleanup_->config().cleanup_hooks->before_atr_remove();
         if (ec) {
             throw client_error(*ec, "before_atr_remove hook threw error");
         }

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

@@ -16,7 +16,7 @@
 #pragma once
 
 #include "transaction_get_result.hxx"
-#include "transaction_query_options.hxx"
+#include <couchbase/transactions/transaction_query_options.hxx>
 
 #include <optional>
 #include <string>
@@ -136,7 +136,10 @@ class attempt_context
      * @param options options to apply to the query.
      * @returns result of the query.
      */
-    virtual core::operations::query_response query(const std::string& statement, const transaction_query_options& options) = 0;
+    core::operations::query_response query(const std::string& statement, const couchbase::transactions::transaction_query_options& opts)
+    {
+        return do_core_query(statement, opts);
+    };
     /**
      * Performs a Query, within the current transaction.
      *
@@ -145,7 +148,7 @@ class attempt_context
      */
     core::operations::query_response query(const std::string& statement)
     {
-        transaction_query_options opts;
+        couchbase::transactions::transaction_query_options opts;
         return query(statement, opts);
     }
 
@@ -179,6 +182,9 @@ class attempt_context
 
     /** @internal */
     virtual transaction_get_result replace_raw(const transaction_get_result& document, const std::vector<std::byte>& content) = 0;
+
+    virtual core::operations::query_response do_core_query(const std::string&,
+                                                           const couchbase::transactions::transaction_query_options& opts) = 0;
 };
 
 } // namespace couchbase::core::transactions