couchbase 4.2.0 → 4.2.2

package/deps/couchbase-cxx-client/core/platform/terminate_handler.cc

@@ -49,9 +49,9 @@ log_handled_exception()
             throw;
         }
     } catch (const std::exception& e) {
-        LOG_CRITICAL("Caught unhandled std::exception-derived exception. what(): {}", e.what());
+        CB_LOG_CRITICAL("Caught unhandled std::exception-derived exception. what(): {}", e.what());
     } catch (...) {
-        LOG_CRITICAL_RAW("Caught unknown/unhandled exception.");
+        CB_LOG_CRITICAL_RAW("Caught unknown/unhandled exception.");
     }
 #endif
 }
@@ -64,14 +64,14 @@ log_backtrace()
 
     char buffer[8192];
     if (print_backtrace_to_buffer("    ", buffer, sizeof(buffer))) {
-        LOG_CRITICAL("Call stack:\n{}", buffer);
+        CB_LOG_CRITICAL("Call stack:\n{}", buffer);
     } else {
         // Exceeded buffer space - print directly to stderr FD (requires no
         // buffering, but has the disadvantage that we don't get it in the log).
         fprintf(stderr, format_str, "");
         print_backtrace_to_file(stderr);
         fflush(stderr);
-        LOG_CRITICAL_RAW("Call stack exceeds 8k, rendered to STDERR");
+        CB_LOG_CRITICAL_RAW("Call stack exceeds 8k, rendered to STDERR");
     }
 }
 
@@ -82,7 +82,7 @@ backtrace_terminate_handler()
 {
     static bool meta_reported = false;
     if (!meta_reported) {
-        LOG_CRITICAL(R"(*** Fatal error encountered during exception handling ({}) ***)", meta::sdk_build_info_short());
+        CB_LOG_CRITICAL(R"(*** Fatal error encountered during exception handling ({}) ***)", meta::sdk_build_info_short());
         meta_reported = true;
     }
     log_handled_exception();

package/deps/couchbase-cxx-client/core/platform/uuid.cc

@@ -21,16 +21,14 @@
 
 #include <iomanip>
 #include <random>
-#include <sstream>
 
 void
 couchbase::core::uuid::random(couchbase::core::uuid::uuid_t& uuid)
 {
-    std::random_device rd;
-    std::mt19937 gen(rd());
+    static thread_local std::mt19937_64 gen{ std::random_device()() };
     std::uniform_int_distribution<std::uint64_t> dis;
 
-    // The uuid is 16 bytes, which is the same as two 64 bit integers
+    // The uuid is 16 bytes, which is the same as two 64-bit integers
     auto* ptr = reinterpret_cast<std::uint64_t*>(uuid.data());
     ptr[0] = dis(gen);
     ptr[1] = dis(gen);
@@ -57,8 +55,8 @@ couchbase::core::uuid::from_string(std::string_view str)
                                     " (expected: 36)");
     }
 
-    size_t jj = 0;
-    for (size_t ii = 0; ii < 36; ii += 2) {
+    std::size_t jj = 0;
+    for (std::size_t ii = 0; ii < 36; ii += 2) {
         switch (ii) {
             case 8:
             case 13:
@@ -76,23 +74,29 @@ couchbase::core::uuid::from_string(std::string_view str)
     return ret;
 }
 
+inline char
+to_char(std::uint8_t c)
+{
+    if (c <= 9) {
+        return static_cast<char>('0' + c);
+    }
+    return static_cast<char>('a' + (c - 10));
+}
+
 std::string
 couchbase::core::uuid::to_string(const couchbase::core::uuid::uuid_t& uuid)
 {
-    std::stringstream ss;
-    ss << std::hex << std::setfill('0');
-    int ii = 0;
-    for (const auto& c : uuid) {
-        ss << std::setw(2) << static_cast<std::uint32_t>(c);
-        switch (++ii) {
-            case 4:
-            case 6:
-            case 8:
-            case 10:
-                ss << '-';
-            default:;
+    std::string ret(36, '-');
+    std::size_t i = 0;
+
+    for (const auto& byte : uuid) {
+        ret[i] = to_char(static_cast<std::uint8_t>(byte >> 4U) & 0x0fU);
+        ++i;
+        ret[i] = to_char(byte & 0x0fU);
+        ++i;
+        if (i == 6 || i == 11 || i == 16 || i == 21) {
+            ++i;
         }
     }
-
-    return ss.str();
+    return ret;
 }

package/deps/couchbase-cxx-client/core/protocol/client_opcode.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.
@@ -224,7 +224,13 @@ enum class client_opcode : std::uint8_t {
     subdoc_multi_mutation = 0xd1,
 
     get_cluster_config = 0xb5,
+
     get_error_map = 0xfe,
+
+    range_scan_create = 0xda,
+    range_scan_continue = 0xdb,
+    range_scan_cancel = 0xdc,
+
     invalid = 0xff,
 };
 
@@ -324,6 +330,9 @@ is_valid_client_opcode(std::uint8_t code)
         case client_opcode::get_keys:
         case client_opcode::set_collections_manifest:
         case client_opcode::get_scope_id:
+        case client_opcode::range_scan_create:
+        case client_opcode::range_scan_continue:
+        case client_opcode::range_scan_cancel:
             return true;
     }
     return false;

package/deps/couchbase-cxx-client/core/protocol/client_opcode_fmt.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.
@@ -244,6 +244,15 @@ struct fmt::formatter<couchbase::core::protocol::client_opcode> {
             case couchbase::core::protocol::client_opcode::get_scope_id:
                 name = "get_scope_id (0xbc)";
                 break;
+            case couchbase::core::protocol::client_opcode::range_scan_create:
+                name = "range_scan_create (0xda)";
+                break;
+            case couchbase::core::protocol::client_opcode::range_scan_continue:
+                name = "range_scan_continue (0xdb)";
+                break;
+            case couchbase::core::protocol::client_opcode::range_scan_cancel:
+                name = "range_scan_cancel (0xdc)";
+                break;
         }
         return format_to(ctx.out(), "{}", name);
     }

package/deps/couchbase-cxx-client/core/protocol/client_request.hxx

@@ -61,7 +61,7 @@ class client_request
 
     void opaque(std::uint32_t val)
     {
-        opaque_ = val;
+        opaque_ = utils::byte_swap(val);
     }
 
     void datatype(protocol::datatype val)
@@ -76,7 +76,7 @@ class client_request
 
     [[nodiscard]] std::uint32_t opaque() const
     {
-        return opaque_;
+        return utils::byte_swap(opaque_);
     }
 
     void opcode(client_opcode val)
@@ -110,8 +110,7 @@ class client_request
   private:
     [[nodiscard]] std::vector<std::byte> generate_payload(bool try_to_compress)
     {
-        std::vector<std::byte> payload;
-        payload.resize(header_size + body_.size(), std::byte{ 0 });
+        std::vector<std::byte> payload(header_size + body_.size());
         payload[0] = static_cast<std::byte>(magic_);
         payload[1] = static_cast<std::byte>(opcode_);
 

package/deps/couchbase-cxx-client/core/protocol/cmd_get_cluster_config.cxx

@@ -76,7 +76,7 @@ get_cluster_config_response_body::parse(key_value_status_code status,
         try {
             config_ = parse_config(config_text, info.endpoint_address, info.endpoint_port);
         } catch (const tao::pegtl::parse_error& e) {
-            LOG_DEBUG("unable to parse cluster configuration as JSON: {}, {}", e.message(), config_text);
+            CB_LOG_DEBUG("unable to parse cluster configuration as JSON: {}, {}", e.message(), config_text);
         }
         return true;
     }

package/deps/couchbase-cxx-client/core/protocol/cmd_get_collections_manifest.cxx

@@ -42,7 +42,7 @@ get_collections_manifest_response_body::parse(key_value_status_code status,
         try {
             manifest_ = utils::json::parse(manifest_text).as<topology::collections_manifest>();
         } catch (const tao::pegtl::parse_error& e) {
-            LOG_DEBUG("unable to parse collections manifest as JSON: {}, {}", e.message(), manifest_text);
+            CB_LOG_DEBUG("unable to parse collections manifest as JSON: {}, {}", e.message(), manifest_text);
         }
         return true;
     }

package/deps/couchbase-cxx-client/core/protocol/cmd_get_error_map.cxx

@@ -44,7 +44,7 @@ get_error_map_response_body::parse(key_value_status_code status,
         try {
             errmap_ = utils::json::parse(error_map_text).as<error_map>();
         } catch (const tao::pegtl::parse_error& e) {
-            LOG_DEBUG("unable to parse error map as JSON: {}, {}", e.message(), error_map_text);
+            CB_LOG_DEBUG("unable to parse error map as JSON: {}, {}", e.message(), error_map_text);
         }
         return true;
     }

package/deps/couchbase-cxx-client/core/protocol/cmd_hello.hxx

@@ -59,7 +59,6 @@ class hello_request_body
     std::vector<std::byte> key_;
     std::vector<hello_feature> features_{
         hello_feature::tcp_nodelay,
-        hello_feature::mutation_seqno,
         hello_feature::xattr,
         hello_feature::xerror,
         hello_feature::select_bucket,
@@ -93,6 +92,11 @@ class hello_request_body
         features_.emplace_back(hello_feature::snappy);
     }
 
+    void enable_mutation_tokens()
+    {
+        features_.emplace_back(hello_feature::mutation_seqno);
+    }
+
     [[nodiscard]] const std::vector<hello_feature>& features() const
     {
         return features_;

package/deps/couchbase-cxx-client/core/protocol/hello_feature.hxx

@@ -150,12 +150,17 @@ enum class hello_feature : std::uint16_t {
      * Does the server support using the virtual $document attributes in macro expansion ("${document.CAS}" etc)
      */
     subdoc_document_macro_support = 0x18,
+
+    // indicates support for the replacing body with xattr feature.
+    replace_body_with_xattr = 0x19,
+
+    resource_units = 0x1a,
 };
 
 constexpr bool
 is_valid_hello_feature(std::uint16_t code)
 {
-    switch (hello_feature(code)) {
+    switch (static_cast<hello_feature>(code)) {
         case hello_feature::tls:
         case hello_feature::tcp_nodelay:
         case hello_feature::mutation_seqno:
@@ -178,6 +183,8 @@ is_valid_hello_feature(std::uint16_t code)
         case hello_feature::tracing:
         case hello_feature::subdoc_create_as_deleted:
         case hello_feature::subdoc_document_macro_support:
+        case hello_feature::replace_body_with_xattr:
+        case hello_feature::resource_units:
             return true;
     }
     return false;

package/deps/couchbase-cxx-client/core/protocol/hello_feature_fmt.hxx

@@ -100,6 +100,12 @@ struct fmt::formatter<couchbase::core::protocol::hello_feature> {
             case couchbase::core::protocol::hello_feature::subdoc_document_macro_support:
                 name = "subdoc_document_macro_support";
                 break;
+            case couchbase::core::protocol::hello_feature::replace_body_with_xattr:
+                name = "replace_body_with_xattr";
+                break;
+            case couchbase::core::protocol::hello_feature::resource_units:
+                name = "resource_units";
+                break;
         }
         return format_to(ctx.out(), "{}", name);
     }

package/deps/couchbase-cxx-client/core/protocol/status.cxx

@@ -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.
@@ -40,6 +40,8 @@ map_status_code(protocol::client_opcode opcode, std::uint16_t status)
         case key_value_status_code::subdoc_multi_path_failure:
         case key_value_status_code::subdoc_success_deleted:
         case key_value_status_code::subdoc_multi_path_failure_deleted:
+        case key_value_status_code::range_scan_complete:
+        case key_value_status_code::range_scan_more:
             return {};
 
         case key_value_status_code::not_found:
@@ -185,6 +187,14 @@ map_status_code(protocol::client_opcode opcode, std::uint16_t status)
         case key_value_status_code::dcp_stream_id_invalid:
         case key_value_status_code::dcp_stream_not_found:
         case key_value_status_code::opaque_no_match:
+
+        case key_value_status_code::range_scan_cancelled:
+            return errc::key_value::range_scan_cancelled;
+
+        case key_value_status_code::range_scan_vb_uuid_not_equal:
+            return errc::key_value::range_scan_vb_uuid_not_equal;
+
+        case key_value_status_code::unknown:
             break;
     }
     return errc::network::protocol_error;

package/deps/couchbase-cxx-client/core/protocol/status.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.
@@ -98,7 +98,13 @@ is_valid_status(std::uint16_t code)
         case key_value_status_code::subdoc_xattr_unknown_vattr_macro:
         case key_value_status_code::subdoc_can_only_revive_deleted_documents:
         case key_value_status_code::subdoc_deleted_document_cannot_have_value:
+        case key_value_status_code::range_scan_cancelled:
+        case key_value_status_code::range_scan_more:
+        case key_value_status_code::range_scan_complete:
+        case key_value_status_code::range_scan_vb_uuid_not_equal:
             return true;
+        case key_value_status_code::unknown:
+            return false;
     }
     return false;
 }

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

@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   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 <fmt/format.h>
+#include <optional>
+#include <string>
+
+namespace couchbase::core
+{
+
+class query_context
+{
+  public:
+    query_context() = default;
+    query_context(std::string namespace_id, std::string bucket_name, std::string scope_name)
+      : namespace_id_(namespace_id)
+      , bucket_name_(bucket_name)
+      , scope_name_(scope_name)
+    {
+    }
+
+    query_context(std::string bucket_name, std::string scope_name)
+      : bucket_name_(bucket_name)
+      , scope_name_(scope_name)
+    {
+    }
+
+    bool has_value() const
+    {
+        return bucket_name_.has_value() && scope_name_.has_value();
+    }
+
+    std::string value() const
+    {
+        if (has_value()) {
+            return fmt::format("{}:`{}`.`{}`", namespace_id_, bucket_name_.value(), scope_name_.value());
+        }
+        return {};
+    }
+    std::string bucket_name() const
+    {
+        if (has_value()) {
+            return bucket_name_.value();
+        }
+        return "";
+    }
+    std::string scope_name() const
+    {
+        if (has_value()) {
+            return scope_name_.value();
+        }
+        return "";
+    }
+    std::string namespace_id() const
+    {
+        return namespace_id_;
+    }
+
+  private:
+    std::string namespace_id_{ "default" };
+    std::optional<std::string> bucket_name_;
+    std::optional<std::string> scope_name_;
+};
+} // namespace couchbase::core

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

@@ -0,0 +1,57 @@
+/* -*- 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.
+ */
+
+#include "range_scan_options.hxx"
+
+#include "core/utils/binary.hxx"
+
+namespace couchbase::core
+{
+range_scan::range_scan(scan_term start, scan_term end)
+  : start_{ std::move(start) }
+  , end_{ std::move(end) }
+{
+}
+
+range_scan::range_scan(std::string_view start, std::string_view end)
+  : start_{ utils::to_binary(start) }
+  , end_{ utils::to_binary(end) }
+{
+}
+
+range_scan::range_scan(std::string_view start, bool exclusive_start, std::string_view end, bool exclusive_end)
+  : start_{ utils::to_binary(start), exclusive_start }
+  , end_{ utils::to_binary(end), exclusive_end }
+{
+}
+
+range_scan::range_scan(std::vector<std::byte> start, std::vector<std::byte> end)
+  : start_{ std::move(start) }
+  , end_{ std::move(end) }
+{
+}
+
+range_scan::range_scan(std::vector<std::byte> start, bool exclusive_start, std::vector<std::byte> end, bool exclusive_end)
+  : start_{ std::move(start), exclusive_start }
+  , end_{ std::move(end), exclusive_end }
+{
+}
+
+auto
+range_scan_item_body::expiry_time() const -> std::chrono::system_clock::time_point
+{
+    return std::chrono::system_clock::time_point(std::chrono::seconds{ expiry });
+}
+} // namespace couchbase::core

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

@@ -0,0 +1,139 @@
+/* -*- 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 "couchbase/cas.hxx"
+#include "couchbase/retry_strategy.hxx"
+#include "utils/movable_function.hxx"
+
+#include <cinttypes>
+#include <memory>
+#include <optional>
+#include <system_error>
+#include <variant>
+#include <vector>
+
+namespace couchbase::core
+{
+struct scan_term {
+    static constexpr std::byte minimum_marker{ 0x00 };
+    static constexpr std::byte maximum_marker{ 0xff };
+
+    std::vector<std::byte> id;
+    bool exclusive{ false };
+};
+
+struct range_scan {
+    range_scan() = default;
+    range_scan(scan_term start, scan_term end);
+    range_scan(std::string_view start, std::string_view end);
+    range_scan(std::string_view start, bool exclusive_start, std::string_view end, bool exclusive_end);
+    range_scan(std::vector<std::byte> start, std::vector<std::byte> end);
+    range_scan(std::vector<std::byte> start, bool exclusive_start, std::vector<std::byte> end, bool exclusive_end);
+
+    scan_term start_{ { scan_term::minimum_marker } };
+    scan_term end_{ { scan_term::maximum_marker } };
+};
+
+struct sampling_scan {
+    std::size_t limit{};
+    std::optional<std::uint32_t> seed{};
+};
+
+struct range_snapshot_requirements {
+    std::uint64_t vbucket_uuid{};
+    std::uint64_t sequence_number{};
+    bool sequence_number_exists{ false };
+};
+
+struct range_scan_create_options {
+    std::string scope_name{};
+    std::string collection_name{};
+    std::variant<std::monostate, range_scan, sampling_scan> scan_type{};
+    std::chrono::milliseconds timeout{};
+    std::uint32_t collection_id{ 0 };
+    std::optional<range_snapshot_requirements> snapshot_requirements{};
+    bool ids_only{ false };
+    std::shared_ptr<couchbase::retry_strategy> retry_strategy{ nullptr };
+
+    struct {
+        std::string user{};
+    } internal{};
+};
+
+struct range_scan_create_result {
+    std::vector<std::byte> scan_uuid;
+    bool ids_only;
+};
+
+using range_scan_create_callback = utils::movable_function<void(range_scan_create_result, std::error_code)>;
+
+struct range_scan_continue_options {
+    static constexpr std::uint32_t default_batch_item_limit{ 50 };
+    static constexpr std::uint32_t default_batch_byte_limit{ 15000 };
+    static constexpr std::chrono::milliseconds default_batch_time_limit{ 0 };
+
+    std::uint32_t batch_item_limit{ default_batch_item_limit };
+    std::uint32_t batch_byte_limit{ default_batch_byte_limit };
+    std::chrono::milliseconds batch_time_limit{ default_batch_time_limit };
+    std::shared_ptr<couchbase::retry_strategy> retry_strategy{ nullptr };
+
+    bool ids_only{ false }; // support servers before MB-54267. TODO: remove after server GA
+    struct {
+        std::string user{};
+    } internal{};
+};
+
+struct range_scan_continue_result {
+    bool more;
+    bool complete;
+    bool ids_only;
+};
+
+using range_scan_continue_callback = utils::movable_function<void(range_scan_continue_result, std::error_code)>;
+
+struct range_scan_cancel_options {
+    std::chrono::milliseconds timeout;
+    std::shared_ptr<couchbase::retry_strategy> retry_strategy{ nullptr };
+
+    struct {
+        std::string user{};
+    } internal{};
+};
+
+struct range_scan_item_body {
+    std::uint32_t flags{};
+    std::uint32_t expiry{};
+    couchbase::cas cas{};
+    std::uint64_t sequence_number{};
+    std::byte datatype{};
+    std::vector<std::byte> value{};
+
+    [[nodiscard]] auto expiry_time() const -> std::chrono::system_clock::time_point;
+};
+
+struct range_scan_item {
+    std::vector<std::byte> key{};
+    std::optional<range_scan_item_body> body{};
+};
+
+using range_scan_item_callback = utils::movable_function<void(range_scan_item item)>;
+
+struct range_scan_cancel_result {
+};
+
+using range_scan_cancel_callback = utils::movable_function<void(range_scan_cancel_result, std::error_code)>;
+} // namespace couchbase::core