couchbase 3.1.1 → 3.2.0

data/ext/couchbase/protocol/client_response.hxx

@@ -33,6 +33,34 @@
 namespace couchbase::protocol
 {
 
+double
+parse_server_duration_us(const io::mcbp_message& msg)
+{
+    if (msg.header.magic != static_cast<std::uint8_t>(magic::alt_client_response)) {
+        return 0;
+    }
+    std::uint8_t framing_extras_size = static_cast<std::uint8_t>(msg.header.keylen & 0xfU);
+    if (framing_extras_size == 0) {
+        return 0;
+    }
+    std::size_t offset = 0;
+    while (offset < framing_extras_size) {
+        std::uint8_t frame_size = static_cast<std::uint8_t>(msg.body[offset] & 0xfU);
+        std::uint8_t frame_id = static_cast<std::uint8_t>((static_cast<std::uint32_t>(msg.body[offset]) >> 4U) & 0xfU);
+        offset++;
+        if (frame_id == static_cast<std::uint8_t>(response_frame_info_id::server_duration)) {
+            if (frame_size == 2 && framing_extras_size - offset >= frame_size) {
+                std::uint16_t encoded_duration{};
+                std::memcpy(&encoded_duration, msg.body.data() + offset, sizeof(encoded_duration));
+                encoded_duration = ntohs(encoded_duration);
+                return std::pow(encoded_duration, 1.74) / 2;
+            }
+        }
+        offset += frame_size;
+    }
+    return 0;
+}
+
 template<typename Body>
 class client_response
 {
@@ -55,7 +83,7 @@ class client_response
 
   public:
     client_response() = default;
-    explicit client_response(io::mcbp_message& msg)
+    explicit client_response(io::mcbp_message&& msg)
     {
         header_ = msg.header_data();
         data_ = std::move(msg.body);
@@ -108,15 +136,15 @@ class client_response
         Expects(header_[0] == static_cast<std::uint8_t>(magic::alt_client_response) ||
                 header_[0] == static_cast<std::uint8_t>(magic::client_response));
         Expects(header_[1] == static_cast<std::uint8_t>(Body::opcode));
-        magic_ = static_cast<magic>(header_[0]);
-        opcode_ = static_cast<client_opcode>(header_[1]);
+        magic_ = magic(header_[0]);
+        opcode_ = client_opcode(header_[1]);
         data_type_ = header_[5];
 
         uint16_t status = 0;
         memcpy(&status, header_.data() + 6, sizeof(status));
         status = ntohs(status);
         Expects(protocol::is_valid_status(status));
-        status_ = static_cast<protocol::status>(status);
+        status_ = protocol::status(status);
 
         extras_size_ = header_[4];
         if (magic_ == magic::alt_client_response) {
@@ -143,7 +171,7 @@ class client_response
         return error_;
     }
 
-    [[nodiscard]] std::string error_message()
+    [[nodiscard]] std::string error_message() const
     {
         if (error_) {
             return fmt::format(R"(magic={}, opcode={}, status={}, error={})", magic_, opcode_, status_, *error_);
@@ -161,12 +189,10 @@ class client_response
                 auto& err_obj = error["error"];
                 if (err_obj.is_object()) {
                     enhanced_error_info err{};
-                    auto& ref = err_obj["ref"];
-                    if (ref.is_string()) {
+                    if (auto& ref = err_obj["ref"]; ref.is_string()) {
                         err.reference = ref.get_string();
                     }
-                    auto& ctx = err_obj["context"];
-                    if (ctx.is_string()) {
+                    if (auto& ctx = err_obj["context"]; ctx.is_string()) {
                         err.context = ctx.get_string();
                     }
                     error_.emplace(err);
@@ -185,13 +211,12 @@ class client_response
             std::uint8_t frame_size = data_[offset] & 0xfU;
             std::uint8_t frame_id = (static_cast<std::uint32_t>(data_[offset]) >> 4U) & 0xfU;
             offset++;
-            if (frame_id == static_cast<std::uint8_t>(response_frame_info_id::server_duration)) {
-                if (frame_size == 2 && framing_extras_size_ - offset >= frame_size) {
-                    std::uint16_t encoded_duration{};
-                    std::memcpy(&encoded_duration, data_.data() + offset, sizeof(encoded_duration));
-                    encoded_duration = ntohs(encoded_duration);
-                    info_.server_duration_us = std::pow(encoded_duration, 1.74) / 2;
-                }
+            if (frame_id == static_cast<std::uint8_t>(response_frame_info_id::server_duration) && frame_size == 2 &&
+                framing_extras_size_ - offset >= frame_size) {
+                std::uint16_t encoded_duration{};
+                std::memcpy(&encoded_duration, data_.data() + offset, sizeof(encoded_duration));
+                encoded_duration = ntohs(encoded_duration);
+                info_.server_duration_us = std::pow(encoded_duration, 1.74) / 2;
             }
             offset += frame_size;
         }

data/ext/couchbase/protocol/cmd_append.hxx

@@ -18,13 +18,13 @@
 #pragma once
 
 #include <document_id.hxx>
-#include <protocol/status.hxx>
+#include <mutation_token.hxx>
 #include <protocol/client_opcode.hxx>
+#include <protocol/cmd_info.hxx>
+#include <protocol/durability_level.hxx>
 #include <protocol/frame_info_id.hxx>
+#include <protocol/status.hxx>
 #include <protocol/unsigned_leb128.h>
-#include <protocol/durability_level.hxx>
-#include <protocol/cmd_info.hxx>
-#include <mutation_token.hxx>
 #include <utils/byteswap.hxx>
 
 namespace couchbase::protocol
@@ -36,10 +36,10 @@ class append_response_body
     static const inline client_opcode opcode = client_opcode::append;
 
   private:
-    mutation_token token_;
+    mutation_token token_{};
 
   public:
-    mutation_token& token()
+    [[nodiscard]] const mutation_token& token() const
     {
         return token_;
     }
@@ -47,10 +47,10 @@ class append_response_body
     bool parse(protocol::status status,
                const header_buffer& header,
                std::uint8_t framing_extras_size,
-               std::uint16_t,
+               std::uint16_t /* key_size */,
                std::uint8_t extras_size,
                const std::vector<uint8_t>& body,
-               const cmd_info&)
+               const cmd_info& /* info */)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         if (status == protocol::status::success) {
@@ -81,6 +81,8 @@ class append_request_body
     std::vector<std::uint8_t> content_{};
     std::vector<std::uint8_t> framing_extras_{};
 
+    static inline std::vector<std::uint8_t> empty;
+
   public:
     void id(const document_id& id)
     {
@@ -110,33 +112,32 @@ class append_request_body
         }
     }
 
-    void content(const std::string& content)
+    void content(const std::string_view& content)
     {
         content_ = { content.begin(), content.end() };
     }
 
-    const std::string& key()
+    [[nodiscard]] const std::string& key() const
     {
         return key_;
     }
 
-    const std::vector<std::uint8_t>& framing_extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
     {
         return framing_extras_;
     }
 
-    const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const std::vector<std::uint8_t>& value() const
     {
         return content_;
     }
 
-    std::size_t size()
+    [[nodiscard]] std::size_t size() const
     {
         return framing_extras_.size() + key_.size() + content_.size();
     }

data/ext/couchbase/protocol/cmd_cluster_map_change_notification.hxx

@@ -19,8 +19,8 @@
 
 #include <gsl/gsl_assert>
 
-#include <protocol/server_opcode.hxx>
 #include <protocol/cmd_info.hxx>
+#include <protocol/server_opcode.hxx>
 
 #include <configuration.hxx>
 
@@ -38,12 +38,12 @@ class cluster_map_change_notification_request_body
     std::optional<configuration> config_;
 
   public:
-    [[nodiscard]] uint32_t protocol_revision()
+    [[nodiscard]] uint32_t protocol_revision() const
     {
         return protocol_revision_;
     }
 
-    [[nodiscard]] const std::string& bucket()
+    [[nodiscard]] const std::string& bucket() const
     {
         return bucket_;
     }
@@ -53,7 +53,7 @@ class cluster_map_change_notification_request_body
         return config_;
     }
 
-    bool parse(const header_buffer& header, const std::vector<uint8_t>& body, const cmd_info&)
+    bool parse(const header_buffer& header, const std::vector<uint8_t>& body, const cmd_info& /* info */)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         using offset_type = std::vector<uint8_t>::difference_type;

data/ext/couchbase/protocol/cmd_decrement.hxx

@@ -31,16 +31,16 @@ class decrement_response_body
     static const inline client_opcode opcode = client_opcode::decrement;
 
   private:
-    mutation_token token_;
-    std::uint64_t content_;
+    mutation_token token_{};
+    std::uint64_t content_{};
 
   public:
-    std::uint64_t content()
+    [[nodiscard]] std::uint64_t content() const
     {
         return content_;
     }
 
-    mutation_token& token()
+    [[nodiscard]] const mutation_token& token() const
     {
         return token_;
     }
@@ -51,7 +51,7 @@ class decrement_response_body
                std::uint16_t key_size,
                std::uint8_t extras_size,
                const std::vector<uint8_t>& body,
-               const cmd_info&)
+               const cmd_info& /* info */)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         if (status == protocol::status::success) {
@@ -142,17 +142,17 @@ class decrement_request_body
         framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 0U);
     }
 
-    const std::string& key()
+    [[nodiscard]] const std::string& key() const
     {
         return key_;
     }
 
-    const std::vector<std::uint8_t>& framing_extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
     {
         return framing_extras_;
     }
 
-    const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& extras()
     {
         if (extras_.empty()) {
             fill_extras();
@@ -160,10 +160,9 @@ class decrement_request_body
         return extras_;
     }
 
-    const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const std::vector<std::uint8_t>& value() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
     [[nodiscard]] std::size_t size()

data/ext/couchbase/protocol/cmd_exists.hxx

@@ -37,22 +37,22 @@ class exists_response_body
     std::uint64_t cas_;
 
   public:
-    [[nodiscard]] std::uint16_t partition_id()
+    [[nodiscard]] std::uint16_t partition_id() const
     {
         return partition_id_;
     }
 
-    [[nodiscard]] std::uint64_t cas()
+    [[nodiscard]] std::uint64_t cas() const
     {
         return cas_;
     }
 
-    [[nodiscard]] const std::string& key()
+    [[nodiscard]] const std::string& key() const
     {
         return key_;
     }
 
-    [[nodiscard]] std::uint8_t status()
+    [[nodiscard]] std::uint8_t status() const
     {
         return status_;
     }
@@ -115,26 +115,23 @@ class exists_request_body
         }
     }
 
-    const std::string& key()
+    [[nodiscard]] const std::string& key() const
     {
         /* for observe key goes in the body */
-        static std::string empty;
-        return empty;
+        return empty_string;
     }
 
-    const std::vector<std::uint8_t>& framing_extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const std::vector<std::uint8_t>& value()
     {
         if (value_.empty()) {
             fill_body();
@@ -142,7 +139,7 @@ class exists_request_body
         return value_;
     }
 
-    std::size_t size()
+    [[nodiscard]] std::size_t size()
     {
         if (value_.empty()) {
             fill_body();

data/ext/couchbase/protocol/cmd_get.hxx

@@ -35,12 +35,12 @@ class get_response_body
     std::string value_;
 
   public:
-    std::string& value()
+    [[nodiscard]] const std::string& value() const
     {
         return value_;
     }
 
-    std::uint32_t flags()
+    [[nodiscard]] std::uint32_t flags() const
     {
         return flags_;
     }
@@ -51,7 +51,7 @@ class get_response_body
                std::uint16_t key_size,
                std::uint8_t extras_size,
                const std::vector<uint8_t>& body,
-               const cmd_info&)
+               const cmd_info& /* info */)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         if (status == protocol::status::success) {
@@ -90,30 +90,27 @@ class get_request_body
         }
     }
 
-    const std::string& key()
+    [[nodiscard]] const std::string& key() const
     {
         return key_;
     }
 
-    const std::vector<std::uint8_t>& framing_extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const std::vector<std::uint8_t>& value() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    std::size_t size()
+    [[nodiscard]] std::size_t size() const
     {
         return key_.size();
     }

data/ext/couchbase/protocol/cmd_get_and_lock.hxx

@@ -35,12 +35,12 @@ class get_and_lock_response_body
     std::string value_;
 
   public:
-    std::string& value()
+    [[nodiscard]] const std::string& value() const
     {
         return value_;
     }
 
-    std::uint32_t flags()
+    [[nodiscard]] std::uint32_t flags() const
     {
         return flags_;
     }
@@ -51,7 +51,7 @@ class get_and_lock_response_body
                std::uint16_t key_size,
                std::uint8_t extras_size,
                const std::vector<uint8_t>& body,
-               const cmd_info&)
+               const cmd_info& /* info */)
     {
         Expects(header[1] == static_cast<uint8_t>(opcode));
         if (status == protocol::status::success) {
@@ -97,18 +97,17 @@ class get_and_lock_request_body
         lock_time_ = seconds;
     }
 
-    const std::string& key()
+    [[nodiscard]] const std::string& key() const
     {
         return key_;
     }
 
-    const std::vector<std::uint8_t>& framing_extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const std::vector<std::uint8_t>& extras()
     {
         if (extras_.empty()) {
             fill_extras();
@@ -116,13 +115,12 @@ class get_and_lock_request_body
         return extras_;
     }
 
-    const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const std::vector<std::uint8_t>& value() const
     {
-        static std::vector<std::uint8_t> empty;
-        return empty;
+        return empty_buffer;
     }
 
-    std::size_t size()
+    [[nodiscard]] std::size_t size()
     {
         if (extras_.empty()) {
             fill_extras();