couchbase 4.1.1 → 4.1.2

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_unlock.cxx

@@ -24,25 +24,21 @@
 namespace couchbase::protocol
 {
 bool
-unlock_response_body::parse(protocol::status,
+unlock_response_body::parse(protocol::status /* status */,
                             const header_buffer& header,
-                            std::uint8_t,
-                            std::uint16_t,
-                            std::uint8_t,
-                            const std::vector<uint8_t>&,
-                            const cmd_info&)
+                            std::uint8_t /* framing_extras_size */,
+                            std::uint16_t /* key_size */,
+                            std::uint8_t /* extras_size */,
+                            const std::vector<std::byte>& /* body */,
+                            const cmd_info& /* info */)
 {
-    Expects(header[1] == static_cast<uint8_t>(opcode));
+    Expects(header[1] == static_cast<std::byte>(opcode));
     return false;
 }
 
 void
 unlock_request_body::id(const document_id& id)
 {
-    key_ = id.key();
-    if (id.is_collection_resolved()) {
-        utils::unsigned_leb128<uint32_t> encoded(id.collection_uid());
-        key_.insert(0, encoded.get());
-    }
+    key_ = make_protocol_key(id);
 }
 } // namespace couchbase::protocol

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_unlock.hxx

@@ -36,7 +36,7 @@ class unlock_response_body
                std::uint8_t framing_extras_size,
                std::uint16_t key_size,
                std::uint8_t extras_size,
-               const std::vector<uint8_t>& body,
+               const std::vector<std::byte>& body,
                const cmd_info& info);
 };
 
@@ -47,27 +47,27 @@ class unlock_request_body
     static const inline client_opcode opcode = client_opcode::unlock;
 
   private:
-    std::string key_;
+    std::vector<std::byte> key_;
 
   public:
     void id(const document_id& id);
 
-    [[nodiscard]] const std::string& key() const
+    [[nodiscard]] const auto& key() const
     {
         return key_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return empty_buffer;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
+    [[nodiscard]] const auto& extras() const
     {
         return empty_buffer;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return empty_buffer;
     }

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_upsert.cxx

@@ -17,7 +17,7 @@
 
 #include <couchbase/protocol/cmd_upsert.hxx>
 
-#include <couchbase/protocol/frame_info_id.hxx>
+#include <couchbase/protocol/frame_info_utils.hxx>
 #include <couchbase/utils/byteswap.hxx>
 #include <couchbase/utils/unsigned_leb128.hxx>
 
@@ -32,10 +32,10 @@ upsert_response_body::parse(protocol::status status,
                             std::uint8_t framing_extras_size,
                             std::uint16_t /* key_size */,
                             std::uint8_t extras_size,
-                            const std::vector<uint8_t>& body,
+                            const std::vector<std::byte>& body,
                             const cmd_info& /* info */)
 {
-    Expects(header[1] == static_cast<uint8_t>(opcode));
+    Expects(header[1] == static_cast<std::byte>(opcode));
     if (status == protocol::status::success) {
         std::vector<uint8_t>::difference_type offset = framing_extras_size;
         if (extras_size == 16) {
@@ -53,11 +53,7 @@ upsert_response_body::parse(protocol::status status,
 void
 upsert_request_body::id(const document_id& id)
 {
-    key_ = id.key();
-    if (id.is_collection_resolved()) {
-        utils::unsigned_leb128<uint32_t> encoded(id.collection_uid());
-        key_.insert(0, encoded.get());
-    }
+    key_ = make_protocol_key(id);
 }
 
 void
@@ -66,28 +62,14 @@ upsert_request_body::durability(protocol::durability_level level, std::optional<
     if (level == protocol::durability_level::none) {
         return;
     }
-    auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::durability_requirement);
-    auto extras_size = framing_extras_.size();
-    if (timeout) {
-        framing_extras_.resize(extras_size + 4);
-        framing_extras_[extras_size + 0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
-        framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
-        uint16_t val = utils::byte_swap(*timeout);
-        memcpy(framing_extras_.data() + extras_size + 2, &val, sizeof(val));
-    } else {
-        framing_extras_.resize(extras_size + 2);
-        framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
-        framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
-    }
+
+    add_durability_frame_info(framing_extras_, level, timeout);
 }
 
 void
 upsert_request_body::preserve_expiry()
 {
-    auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::preserve_ttl);
-    auto extras_size = framing_extras_.size();
-    framing_extras_.resize(extras_size + 1);
-    framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 0U);
+    add_preserve_expiry_frame_info(framing_extras_);
 }
 
 void

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_upsert.hxx

@@ -47,7 +47,7 @@ class upsert_response_body
                std::uint8_t framing_extras_size,
                std::uint16_t key_size,
                std::uint8_t extras_size,
-               const std::vector<uint8_t>& body,
+               const std::vector<std::byte>& body,
                const cmd_info& info);
 };
 
@@ -58,12 +58,12 @@ class upsert_request_body
     static const inline client_opcode opcode = client_opcode::upsert;
 
   private:
-    std::string key_{};
-    std::vector<std::uint8_t> extras_{};
-    std::vector<std::uint8_t> content_{};
+    std::vector<std::byte> key_{};
+    std::vector<std::byte> extras_{};
+    std::vector<std::byte> content_{};
     std::uint32_t flags_{};
     std::uint32_t expiry_{};
-    std::vector<std::uint8_t> framing_extras_{};
+    std::vector<std::byte> framing_extras_{};
 
   public:
     void id(const document_id& id);
@@ -72,7 +72,7 @@ class upsert_request_body
 
     void preserve_expiry();
 
-    void content(const std::string_view& content)
+    void content(const std::vector<std::byte>& content)
     {
         content_ = { content.begin(), content.end() };
     }
@@ -87,17 +87,17 @@ class upsert_request_body
         expiry_ = value;
     }
 
-    [[nodiscard]] const std::string& key() const
+    [[nodiscard]] const auto& key() const
     {
         return key_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return framing_extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const auto& extras()
     {
         if (extras_.empty()) {
             fill_extras();
@@ -105,7 +105,7 @@ class upsert_request_body
         return extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return content_;
     }

package/deps/couchbase-cxx-client/couchbase/protocol/datatype.hxx

@@ -19,7 +19,7 @@
 
 namespace couchbase::protocol
 {
-enum class datatype : uint8_t {
+enum class datatype : std::uint8_t {
     raw = 0x00,
     json = 0x01,
     snappy = 0x02,
@@ -28,9 +28,9 @@ enum class datatype : uint8_t {
 };
 
 constexpr bool
-is_valid_datatype(uint8_t code)
+is_valid_datatype(std::uint8_t code)
 {
-    switch (datatype(code)) {
+    switch (static_cast<datatype>(code)) {
         case datatype::raw:
         case datatype::json:
         case datatype::snappy:
@@ -41,8 +41,8 @@ is_valid_datatype(uint8_t code)
 }
 
 constexpr bool
-has_json_datatype(uint8_t code)
+has_json_datatype(std::uint8_t code)
 {
-    return (code & uint8_t(datatype::json)) != 0;
+    return (code & static_cast<std::uint8_t>(datatype::json)) != 0;
 }
 } // namespace couchbase::protocol

package/deps/couchbase-cxx-client/couchbase/protocol/frame_info_utils.cxx

@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   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 <couchbase/protocol/frame_info_utils.hxx>
+
+#include <couchbase/protocol/frame_info_id.hxx>
+#include <couchbase/utils/byteswap.hxx>
+
+#include <cstddef>
+#include <cstring>
+
+namespace couchbase::protocol
+{
+
+void
+add_durability_frame_info(std::vector<std::byte>& framing_extras, protocol::durability_level level, std::optional<std::uint16_t> timeout)
+{
+    const auto frame_id = static_cast<std::byte>(protocol::request_frame_info_id::durability_requirement);
+    const auto extras_old_size = framing_extras.size();
+    if (timeout) {
+        const std::byte frame_size{ 3 };
+        framing_extras.resize(+1 + static_cast<std::size_t>(frame_size));
+        framing_extras[extras_old_size + 0] = (frame_id << 4U) | frame_size;
+        framing_extras[extras_old_size + 1] = static_cast<std::byte>(level);
+        std::uint16_t val = utils::byte_swap(*timeout);
+        memcpy(framing_extras.data() + extras_old_size + 2, &val, sizeof(val));
+    } else {
+        const std::byte frame_size{ 3 };
+        framing_extras.resize(framing_extras.size() + 1 + static_cast<std::size_t>(frame_size));
+        framing_extras[extras_old_size + 0] = (frame_id << 4U) | frame_size;
+        framing_extras[extras_old_size + 1] = static_cast<std::byte>(level);
+    }
+}
+
+void
+add_preserve_expiry_frame_info(std::vector<std::byte>& framing_extras)
+{
+    const auto frame_id = static_cast<std::byte>(protocol::request_frame_info_id::preserve_ttl);
+    const std::byte frame_size{ 0 };
+    const auto extras_old_size = framing_extras.size();
+
+    framing_extras.resize(extras_old_size + 1);
+    framing_extras[extras_old_size + 0] = (frame_id << 4U) | frame_size;
+}
+} // namespace couchbase::protocol

package/deps/couchbase-cxx-client/couchbase/protocol/frame_info_utils.hxx

@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   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/protocol/durability_level.hxx>
+
+#include <cinttypes>
+#include <optional>
+#include <vector>
+
+namespace couchbase::protocol
+{
+
+/**
+ * Encodes durability level with optional timeout and appends result to @c framing_extras.
+ *
+ * @param framing_extras output storage for extras
+ * @param level durability level
+ * @param timeout durability timeout
+ *
+ * @since 1.1.0
+ * @internal
+ */
+void
+add_durability_frame_info(std::vector<std::byte>& framing_extras, protocol::durability_level level, std::optional<std::uint16_t> timeout);
+
+/**
+ * Appends "preserve expiry" frame to @c framing_extras.
+ *
+ * @param framing_extras output storage for extras
+ *
+ * @since 1.1.0
+ * @internal
+ */
+void
+add_preserve_expiry_frame_info(std::vector<std::byte>& framing_extras);
+} // namespace couchbase::protocol

package/deps/couchbase-cxx-client/couchbase/protocol/server_request.hxx

@@ -38,8 +38,8 @@ class server_request
     Body body_;
     server_opcode opcode_{ server_opcode::invalid };
     header_buffer header_;
-    uint8_t data_type_;
-    std::vector<std::uint8_t> data_;
+    std::uint8_t data_type_;
+    std::vector<std::byte> data_;
     std::size_t body_size_;
     std::uint32_t opaque_;
     std::uint64_t cas_;
@@ -93,10 +93,10 @@ class server_request
 
     void verify_header()
     {
-        Expects(header_[0] == static_cast<std::uint8_t>(magic_));
-        Expects(header_[1] == static_cast<std::uint8_t>(Body::opcode));
-        opcode_ = server_opcode(header_[1]);
-        data_type_ = header_[5];
+        Expects(header_[0] == static_cast<std::byte>(magic_));
+        Expects(header_[1] == static_cast<std::byte>(Body::opcode));
+        opcode_ = static_cast<server_opcode>(header_[1]);
+        data_type_ = std::to_integer<std::uint8_t>(header_[5]);
 
         uint32_t field = 0;
         memcpy(&field, header_.data() + 8, sizeof(field));
@@ -113,7 +113,7 @@ class server_request
         body_.parse(header_, data_, info_);
     }
 
-    [[nodiscard]] std::vector<std::uint8_t>& data()
+    [[nodiscard]] std::vector<std::byte>& data()
     {
         return data_;
     }

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

@@ -32,6 +32,7 @@ constexpr std::chrono::milliseconds query_timeout{ 75'000 };
 constexpr std::chrono::milliseconds analytics_timeout{ 75'000 };
 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 dns_srv_timeout{ 500 };
 constexpr std::chrono::milliseconds tcp_keep_alive_interval{ 60'000 };

package/deps/couchbase-cxx-client/couchbase/topology/collections_manifest.hxx

@@ -27,6 +27,7 @@ struct collections_manifest {
     struct collection {
         std::uint64_t uid;
         std::string name;
+        std::uint32_t max_expiry{ 0 };
     };
 
     struct scope {

package/deps/couchbase-cxx-client/couchbase/topology/collections_manifest_json.hxx

@@ -40,6 +40,9 @@ struct traits<couchbase::topology::collections_manifest> {
                 couchbase::topology::collections_manifest::collection collection;
                 collection.uid = std::stoull(c.at("uid").get_string(), nullptr, 16);
                 collection.name = c.at("name").get_string();
+                if (const auto* max_ttl = c.find("maxTTL"); max_ttl != nullptr) {
+                    collection.max_expiry = max_ttl->template as<std::uint32_t>();
+                }
                 scope.collections.emplace_back(collection);
             }
             result.scopes.emplace_back(scope);

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

@@ -173,7 +173,7 @@ class concurrent_fixed_queue
 
     concurrent_fixed_queue(const concurrent_fixed_queue& other) = delete;
 
-    concurrent_fixed_queue(concurrent_fixed_queue&& other)
+    concurrent_fixed_queue(concurrent_fixed_queue&& other) noexcept
     {
         std::unique_lock<std::mutex> lock(other.mutex_);
         std::swap(data_, other.data_);

package/deps/couchbase-cxx-client/couchbase/utils/CMakeLists.txt

@@ -3,6 +3,7 @@ add_library(
   connection_string.cxx
   url_codec.cxx
   json.cxx
+  binary.cxx
   duration_parser.cxx
   json_streaming_lexer.cxx)
 set_target_properties(couchbase_utils PROPERTIES POSITION_INDEPENDENT_CODE ON)

package/deps/couchbase-cxx-client/couchbase/utils/{byteswap.cxx → binary.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.
@@ -15,31 +15,13 @@
  *   limitations under the License.
  */
 
-#include <couchbase/utils/byteswap.hxx>
+#include <couchbase/utils/binary.hxx>
 
 namespace couchbase::utils
 {
-constexpr std::uint64_t
-byte_swap(std::uint64_t val)
+binary
+to_binary(std::string_view value) noexcept
 {
-    std::uint64_t ret = 0U;
-    for (std::size_t i = 0; i < sizeof(std::uint64_t); ++i) {
-        ret <<= 8U;
-        ret |= val & 0xffU;
-        val >>= 8U;
-    }
-    return ret;
-}
-
-constexpr std::uint32_t
-byte_swap_32(std::uint32_t val)
-{
-    std::uint64_t ret = 0U;
-    for (std::size_t i = 0; i < sizeof(std::uint64_t); ++i) {
-        ret <<= 8U;
-        ret |= val & 0xffU;
-        val >>= 8U;
-    }
-    return ret;
+    return to_binary(value.data(), value.size());
 }
 } // namespace couchbase::utils

package/deps/couchbase-cxx-client/couchbase/utils/binary.hxx

@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   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 <algorithm>
+#include <cstddef>
+#include <iterator>
+#include <string_view>
+#include <vector>
+
+namespace couchbase::utils
+{
+using binary = std::vector<std::byte>;
+
+template<typename T>
+[[nodiscard]] binary
+to_binary(const T* data, const std::size_t size) noexcept
+{
+    static_assert(sizeof(T) == 1);
+    binary copy;
+    copy.reserve(size);
+    std::transform(data, data + size, std::back_insert_iterator(copy), [](auto e) { return static_cast<std::byte>(e); });
+    return copy;
+}
+
+[[nodiscard]] binary
+to_binary(std::string_view value) noexcept;
+
+template<typename InputIterator, typename OutputIterator>
+OutputIterator
+to_binary(InputIterator first, InputIterator last, OutputIterator result) noexcept
+{
+    return std::transform(first, last, result, [](auto e) { return static_cast<std::byte>(e); });
+}
+
+template<typename Container, typename OutputIterator>
+OutputIterator
+to_binary(Container container, OutputIterator result) noexcept
+{
+    return to_binary(std::begin(container), std::end(container), result);
+}
+} // namespace couchbase::utils

package/deps/couchbase-cxx-client/couchbase/utils/byteswap.hxx

@@ -24,8 +24,8 @@ namespace couchbase::utils
 static constexpr std::uint16_t
 byte_swap(std::uint16_t value)
 {
-    auto hi = std::uint16_t(value << 8U);
-    auto lo = std::uint16_t(value >> 8U);
+    auto hi = static_cast<std::uint16_t>(value << 8U);
+    auto lo = static_cast<std::uint16_t>(value >> 8U);
     return hi | lo;
 }
 
@@ -42,8 +42,8 @@ byte_swap(std::uint32_t value)
 static constexpr std::uint64_t
 byte_swap(std::uint64_t value)
 {
-    std::uint64_t hi = byte_swap(std::uint32_t(value));
-    std::uint32_t lo = byte_swap(std::uint32_t(value >> 32));
+    std::uint64_t hi = byte_swap(static_cast<std::uint32_t>(value));
+    std::uint32_t lo = byte_swap(static_cast<std::uint32_t>(value >> 32));
     return (hi << 32) | lo;
 }
 } // namespace couchbase::utils