couchbase 4.3.1 → 4.4.0

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

@@ -17,8 +17,8 @@
 
 #pragma once
 
-#include <couchbase/fmt/key_value_extended_error_info.hxx>
-#include <couchbase/fmt/key_value_status_code.hxx>
+#include "core/fmt/key_value_extended_error_info.hxx"
+#include "core/fmt/key_value_status_code.hxx"
 
 #include "client_opcode.hxx"
 #include "client_opcode_fmt.hxx"
@@ -43,170 +43,173 @@
 namespace couchbase::core::protocol
 {
 
-double
-parse_server_duration_us(const io::mcbp_message& msg);
+auto
+parse_server_duration_us(const io::mcbp_message& msg) -> double;
 
-bool
-parse_enhanced_error(std::string_view str, key_value_extended_error_info& info);
+auto
+parse_enhanced_error(std::string_view str, key_value_extended_error_info& info) -> bool;
 
 template<typename Body>
 class client_response
 {
-  private:
-    Body body_;
-    magic magic_{ magic::client_response };
-    client_opcode opcode_{ client_opcode::invalid };
-    header_buffer header_{};
-    std::uint8_t data_type_{ 0 };
-    std::vector<std::byte> data_{};
-    std::uint16_t key_size_{ 0 };
-    std::uint8_t framing_extras_size_{ 0 };
-    std::uint8_t extras_size_{ 0 };
-    std::size_t body_size_{ 0 };
-    key_value_status_code status_{};
-    std::optional<key_value_extended_error_info> error_;
-    std::uint32_t opaque_{};
-    std::uint64_t cas_{};
-    cmd_info info_{};
-
-  public:
-    client_response() = default;
-    explicit client_response(io::mcbp_message&& msg)
-      : client_response(std::move(msg), {})
-    {
+private:
+  Body body_;
+  magic magic_{ magic::client_response };
+  client_opcode opcode_{ client_opcode::invalid };
+  header_buffer header_{};
+  std::uint8_t data_type_{ 0 };
+  std::vector<std::byte> data_{};
+  std::uint16_t key_size_{ 0 };
+  std::uint8_t framing_extras_size_{ 0 };
+  std::uint8_t extras_size_{ 0 };
+  std::size_t body_size_{ 0 };
+  key_value_status_code status_{};
+  std::optional<key_value_extended_error_info> error_;
+  std::uint32_t opaque_{};
+  std::uint64_t cas_{};
+  cmd_info info_{};
+
+public:
+  client_response() = default;
+  explicit client_response(io::mcbp_message&& msg)
+    : client_response(std::move(msg), {})
+  {
+  }
+
+  client_response(io::mcbp_message&& msg, const cmd_info& info)
+    : header_(msg.header_data())
+    , data_(std::move(msg.body))
+    , info_(info)
+  {
+    verify_header();
+    parse_body();
+  }
+
+  [[nodiscard]] auto opcode() const -> client_opcode
+  {
+    return opcode_;
+  }
+
+  [[nodiscard]] auto status() const -> key_value_status_code
+  {
+    return status_;
+  }
+
+  [[nodiscard]] auto cas() const -> couchbase::cas
+  {
+    return couchbase::cas{ cas_ };
+  }
+
+  [[nodiscard]] auto opaque() const -> std::uint32_t
+  {
+    return opaque_;
+  }
+
+  auto body() -> Body&
+  {
+    return body_;
+  }
+
+  [[nodiscard]] auto body() const -> const Body&
+  {
+    return body_;
+  }
+
+  [[nodiscard]] auto header() -> header_buffer&
+  {
+    return header_;
+  }
+
+  void verify_header()
+  {
+    Expects(header_[0] == static_cast<std::byte>(magic::alt_client_response) ||
+            header_[0] == static_cast<std::byte>(magic::client_response));
+    Expects(header_[1] == static_cast<std::byte>(Body::opcode));
+    magic_ = static_cast<magic>(header_[0]);
+    opcode_ = static_cast<client_opcode>(header_[1]);
+    data_type_ = std::to_integer<std::uint8_t>(header_[5]);
+
+    std::uint16_t status = 0;
+    memcpy(&status, header_.data() + 6, sizeof(status));
+    status = utils::byte_swap(status);
+    status_ = static_cast<key_value_status_code>(status);
+
+    extras_size_ = std::to_integer<std::uint8_t>(header_[4]);
+    if (magic_ == magic::alt_client_response) {
+      framing_extras_size_ = std::to_integer<std::uint8_t>(header_[2]);
+      key_size_ = std::to_integer<std::uint8_t>(header_[3]);
+    } else {
+      memcpy(&key_size_, header_.data() + 2, sizeof(key_size_));
+      key_size_ = utils::byte_swap(key_size_);
     }
 
-    client_response(io::mcbp_message&& msg, const cmd_info& info)
-      : header_(msg.header_data())
-      , data_(std::move(msg.body))
-      , info_(info)
-    {
-        verify_header();
-        parse_body();
-    }
+    std::uint32_t field = 0;
+    memcpy(&field, header_.data() + 8, sizeof(field));
+    body_size_ = utils::byte_swap(field);
+    data_.resize(body_size_);
 
-    [[nodiscard]] client_opcode opcode() const
-    {
-        return opcode_;
-    }
+    memcpy(&opaque_, header_.data() + 12, sizeof(opaque_));
+    opaque_ = utils::byte_swap(opaque_);
 
-    [[nodiscard]] key_value_status_code status() const
-    {
-        return status_;
-    }
+    memcpy(&cas_, header_.data() + 16, sizeof(cas_));
+    cas_ = utils::byte_swap(cas_);
+  }
 
-    [[nodiscard]] couchbase::cas cas() const
-    {
-        return couchbase::cas{ cas_ };
-    }
+  [[nodiscard]] auto error_info() const -> std::optional<key_value_extended_error_info>
+  {
+    return error_;
+  }
 
-    [[nodiscard]] std::uint32_t opaque() const
-    {
-        return opaque_;
+  [[nodiscard]] auto error_message() const -> std::string
+  {
+    if (error_) {
+      return fmt::format(
+        R"(magic={}, opcode={}, status={}, error={})", magic_, opcode_, status_, *error_);
     }
-
-    Body& body()
-    {
-        return body_;
+    return fmt::format("magic={}, opcode={}, status={}", magic_, opcode_, status_);
+  }
+
+  void parse_body()
+  {
+    parse_framing_extras();
+    bool parsed =
+      body_.parse(status_, header_, framing_extras_size_, key_size_, extras_size_, data_, info_);
+    if (status_ != key_value_status_code::success && !parsed && has_json_datatype(data_type_)) {
+      key_value_extended_error_info err;
+      std::vector<std::uint8_t>::difference_type offset =
+        framing_extras_size_ + extras_size_ + key_size_;
+      std::string_view enhanced_error_text{ reinterpret_cast<const char*>(data_.data()) + offset,
+                                            data_.size() - static_cast<std::size_t>(offset) };
+      if (parse_enhanced_error(enhanced_error_text, err)) {
+        error_.emplace(err);
+      }
     }
+  }
 
-    [[nodiscard]] const Body& body() const
-    {
-        return body_;
+  void parse_framing_extras()
+  {
+    if (framing_extras_size_ == 0) {
+      return;
     }
-
-    [[nodiscard]] header_buffer& header()
-    {
-        return header_;
-    }
-
-    void verify_header()
-    {
-        Expects(header_[0] == static_cast<std::byte>(magic::alt_client_response) ||
-                header_[0] == static_cast<std::byte>(magic::client_response));
-        Expects(header_[1] == static_cast<std::byte>(Body::opcode));
-        magic_ = static_cast<magic>(header_[0]);
-        opcode_ = static_cast<client_opcode>(header_[1]);
-        data_type_ = std::to_integer<std::uint8_t>(header_[5]);
-
-        std::uint16_t status = 0;
-        memcpy(&status, header_.data() + 6, sizeof(status));
-        status = utils::byte_swap(status);
-        status_ = static_cast<key_value_status_code>(status);
-
-        extras_size_ = std::to_integer<std::uint8_t>(header_[4]);
-        if (magic_ == magic::alt_client_response) {
-            framing_extras_size_ = std::to_integer<std::uint8_t>(header_[2]);
-            key_size_ = std::to_integer<std::uint8_t>(header_[3]);
-        } else {
-            memcpy(&key_size_, header_.data() + 2, sizeof(key_size_));
-            key_size_ = utils::byte_swap(key_size_);
-        }
-
-        std::uint32_t field = 0;
-        memcpy(&field, header_.data() + 8, sizeof(field));
-        body_size_ = utils::byte_swap(field);
-        data_.resize(body_size_);
-
-        memcpy(&opaque_, header_.data() + 12, sizeof(opaque_));
-        opaque_ = utils::byte_swap(opaque_);
-
-        memcpy(&cas_, header_.data() + 16, sizeof(cas_));
-        cas_ = utils::byte_swap(cas_);
+    size_t offset = 0;
+    while (offset < framing_extras_size_) {
+      auto frame_size = std::to_integer<std::uint8_t>(data_[offset] & std::byte{ 0b1111 });
+      auto frame_id = std::to_integer<std::uint8_t>((data_[offset] >> 4U) & std::byte{ 0b1111 });
+      ++offset;
+      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 = utils::byte_swap(encoded_duration);
+        info_.server_duration_us = std::pow(encoded_duration, 1.74) / 2;
+      }
+      offset += frame_size;
     }
+  }
 
-    [[nodiscard]] std::optional<key_value_extended_error_info> error_info() const
-    {
-        return error_;
-    }
-
-    [[nodiscard]] std::string error_message() const
-    {
-        if (error_) {
-            return fmt::format(R"(magic={}, opcode={}, status={}, error={})", magic_, opcode_, status_, *error_);
-        }
-        return fmt::format("magic={}, opcode={}, status={}", magic_, opcode_, status_);
-    }
-
-    void parse_body()
-    {
-        parse_framing_extras();
-        bool parsed = body_.parse(status_, header_, framing_extras_size_, key_size_, extras_size_, data_, info_);
-        if (status_ != key_value_status_code::success && !parsed && has_json_datatype(data_type_)) {
-            key_value_extended_error_info err;
-            std::vector<std::uint8_t>::difference_type offset = framing_extras_size_ + extras_size_ + key_size_;
-            std::string_view enhanced_error_text{ reinterpret_cast<const char*>(data_.data()) + offset,
-                                                  data_.size() - static_cast<std::size_t>(offset) };
-            if (parse_enhanced_error(enhanced_error_text, err)) {
-                error_.emplace(err);
-            }
-        }
-    }
-
-    void parse_framing_extras()
-    {
-        if (framing_extras_size_ == 0) {
-            return;
-        }
-        size_t offset = 0;
-        while (offset < framing_extras_size_) {
-            auto frame_size = std::to_integer<std::uint8_t>(data_[offset] & std::byte{ 0b1111 });
-            auto frame_id = std::to_integer<std::uint8_t>((data_[offset] >> 4U) & std::byte{ 0b1111 });
-            ++offset;
-            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 = utils::byte_swap(encoded_duration);
-                info_.server_duration_us = std::pow(encoded_duration, 1.74) / 2;
-            }
-            offset += frame_size;
-        }
-    }
-
-    [[nodiscard]] std::vector<std::byte>& data()
-    {
-        return data_;
-    }
+  [[nodiscard]] auto data() -> std::vector<std::byte>&
+  {
+    return data_;
+  }
 };
 } // namespace couchbase::core::protocol

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

@@ -27,48 +27,49 @@
 namespace couchbase::core::protocol
 {
 
-bool
+auto
 protocol::append_response_body::parse(key_value_status_code status,
                                       const header_buffer& header,
                                       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 */)
+                                      const cmd_info& /* info */) -> bool
 {
-    Expects(header[1] == static_cast<std::byte>(opcode));
-    if (status == key_value_status_code::success) {
-        std::vector<std::uint8_t>::difference_type offset = framing_extras_size;
-        if (extras_size == 16) {
-            std::uint64_t partition_uuid{};
-            memcpy(&partition_uuid, body.data() + offset, sizeof(partition_uuid));
-            partition_uuid = utils::byte_swap(partition_uuid);
-            offset += 8;
+  Expects(header[1] == static_cast<std::byte>(opcode));
+  if (status == key_value_status_code::success) {
+    std::vector<std::uint8_t>::difference_type offset = framing_extras_size;
+    if (extras_size == 16) {
+      std::uint64_t partition_uuid{};
+      memcpy(&partition_uuid, body.data() + offset, sizeof(partition_uuid));
+      partition_uuid = utils::byte_swap(partition_uuid);
+      offset += 8;
 
-            std::uint64_t sequence_number{};
-            memcpy(&sequence_number, body.data() + offset, sizeof(sequence_number));
-            sequence_number = utils::byte_swap(sequence_number);
+      std::uint64_t sequence_number{};
+      memcpy(&sequence_number, body.data() + offset, sizeof(sequence_number));
+      sequence_number = utils::byte_swap(sequence_number);
 
-            token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
-            return true;
-        }
+      token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
+      return true;
     }
-    return false;
+  }
+  return false;
 }
 
 void
 protocol::append_request_body::id(const document_id& id)
 {
-    key_ = make_protocol_key(id);
+  key_ = make_protocol_key(id);
 }
 
 void
-protocol::append_request_body::durability(durability_level level, std::optional<std::uint16_t> timeout)
+protocol::append_request_body::durability(durability_level level,
+                                          std::optional<std::uint16_t> timeout)
 {
-    if (level == durability_level::none) {
-        return;
-    }
+  if (level == durability_level::none) {
+    return;
+  }
 
-    add_durability_frame_info(framing_extras_, level, timeout);
+  add_durability_frame_info(framing_extras_, level, timeout);
 }
 } // namespace couchbase::core::protocol

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

@@ -33,75 +33,75 @@ namespace couchbase::core::protocol
 
 class append_response_body
 {
-  public:
-    static const inline client_opcode opcode = client_opcode::append;
-
-  private:
-    mutation_token token_{};
-
-  public:
-    [[nodiscard]] const mutation_token& token() const
-    {
-        return token_;
-    }
-
-    bool parse(key_value_status_code status,
-               const header_buffer& header,
-               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);
+public:
+  static const inline client_opcode opcode = client_opcode::append;
+
+private:
+  mutation_token token_{};
+
+public:
+  [[nodiscard]] auto token() const -> const mutation_token&
+  {
+    return token_;
+  }
+
+  auto parse(key_value_status_code status,
+             const header_buffer& header,
+             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) -> bool;
 };
 
 class append_request_body
 {
-  public:
-    using response_body_type = append_response_body;
-    static const inline client_opcode opcode = client_opcode::append;
-
-  private:
-    std::vector<std::byte> key_{};
-    std::vector<std::byte> extras_{};
-    std::vector<std::byte> content_{};
-    std::vector<std::byte> framing_extras_{};
-
-    static inline std::vector<std::uint8_t> empty;
-
-  public:
-    void id(const document_id& id);
-
-    void durability(durability_level level, std::optional<std::uint16_t> timeout);
-
-    void content(const std::vector<std::byte>& content)
-    {
-        content_ = { content.begin(), content.end() };
-    }
-
-    [[nodiscard]] const auto& key() const
-    {
-        return key_;
-    }
-
-    [[nodiscard]] const auto& framing_extras() const
-    {
-        return framing_extras_;
-    }
-
-    [[nodiscard]] const auto& extras() const
-    {
-        return empty_buffer;
-    }
-
-    [[nodiscard]] const auto& value() const
-    {
-        return content_;
-    }
-
-    [[nodiscard]] std::size_t size() const
-    {
-        return framing_extras_.size() + key_.size() + content_.size();
-    }
+public:
+  using response_body_type = append_response_body;
+  static const inline client_opcode opcode = client_opcode::append;
+
+private:
+  std::vector<std::byte> key_{};
+  std::vector<std::byte> extras_{};
+  std::vector<std::byte> content_{};
+  std::vector<std::byte> framing_extras_{};
+
+  static inline std::vector<std::uint8_t> empty;
+
+public:
+  void id(const document_id& id);
+
+  void durability(durability_level level, std::optional<std::uint16_t> timeout);
+
+  void content(const std::vector<std::byte>& content)
+  {
+    content_ = { content.begin(), content.end() };
+  }
+
+  [[nodiscard]] auto key() const -> const auto&
+  {
+    return key_;
+  }
+
+  [[nodiscard]] auto framing_extras() const -> const auto&
+  {
+    return framing_extras_;
+  }
+
+  [[nodiscard]] auto extras() const -> const auto&
+  {
+    return empty_buffer;
+  }
+
+  [[nodiscard]] auto value() const -> const auto&
+  {
+    return content_;
+  }
+
+  [[nodiscard]] auto size() const -> std::size_t
+  {
+    return framing_extras_.size() + key_.size() + content_.size();
+  }
 };
 
 } // namespace couchbase::core::protocol

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

@@ -26,28 +26,32 @@
 
 namespace couchbase::core::protocol
 {
-bool
-cluster_map_change_notification_request_body::parse(const header_buffer& header, const std::vector<std::byte>& body, const cmd_info& info)
+auto
+cluster_map_change_notification_request_body::parse(const header_buffer& header,
+                                                    const std::vector<std::byte>& body,
+                                                    const cmd_info& info) -> bool
 {
-    Expects(header[1] == static_cast<std::byte>(opcode));
-    using offset_type = std::vector<std::byte>::difference_type;
+  Expects(header[1] == static_cast<std::byte>(opcode));
+  using offset_type = std::vector<std::byte>::difference_type;
 
-    auto ext_size = std::to_integer<std::uint8_t>(header[4]);
-    offset_type offset = ext_size;
-    if (ext_size == 4) {
-        memcpy(&protocol_revision_, body.data(), sizeof(protocol_revision_));
-        protocol_revision_ = utils::byte_swap(protocol_revision_);
-    }
-    std::uint16_t key_size = 0;
-    memcpy(&key_size, header.data() + 2, sizeof(key_size));
-    key_size = utils::byte_swap(key_size);
-    const auto* data_ptr = reinterpret_cast<const char*>(body.data());
-    bucket_.assign(data_ptr + offset, data_ptr + offset + key_size);
-    offset += key_size;
-    if (body.size() > static_cast<std::size_t>(offset)) {
-        std::string_view config_text{ data_ptr + offset, body.size() - static_cast<std::size_t>(offset) };
-        config_ = parse_config(config_text, info.endpoint_address, info.endpoint_port);
-    }
-    return true;
+  auto ext_size = std::to_integer<std::uint8_t>(header[4]);
+  offset_type offset = ext_size;
+  if (ext_size == 4) {
+    memcpy(&protocol_revision_, body.data(), sizeof(protocol_revision_));
+    protocol_revision_ = utils::byte_swap(protocol_revision_);
+  }
+  std::uint16_t key_size = 0;
+  memcpy(&key_size, header.data() + 2, sizeof(key_size));
+  key_size = utils::byte_swap(key_size);
+  const auto* data_ptr = reinterpret_cast<const char*>(body.data());
+  bucket_.assign(data_ptr + offset, data_ptr + offset + key_size);
+  offset += key_size;
+  if (body.size() > static_cast<std::size_t>(offset)) {
+    std::string_view config_text{ data_ptr + offset,
+                                  body.size() - static_cast<std::size_t>(offset) };
+    config_ = parse_config(config_text, info.endpoint_address, info.endpoint_port);
+    config_text_.emplace(config_text);
+  }
+  return true;
 }
 } // namespace couchbase::core::protocol

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

@@ -27,31 +27,39 @@ namespace couchbase::core::protocol
 
 class cluster_map_change_notification_request_body
 {
-  public:
-    static const inline server_opcode opcode = server_opcode::cluster_map_change_notification;
-
-  private:
-    std::uint32_t protocol_revision_{};
-    std::string bucket_{};
-    std::optional<topology::configuration> config_{};
-
-  public:
-    [[nodiscard]] std::uint32_t protocol_revision() const
-    {
-        return protocol_revision_;
-    }
-
-    [[nodiscard]] const std::string& bucket() const
-    {
-        return bucket_;
-    }
-
-    [[nodiscard]] std::optional<topology::configuration> config()
-    {
-        return config_;
-    }
-
-    bool parse(const header_buffer& header, const std::vector<std::byte>& body, const cmd_info& info);
+public:
+  static const inline server_opcode opcode = server_opcode::cluster_map_change_notification;
+
+private:
+  std::uint32_t protocol_revision_{};
+  std::string bucket_{};
+  std::optional<topology::configuration> config_{};
+  std::optional<std::string_view> config_text_;
+
+public:
+  [[nodiscard]] auto protocol_revision() const -> std::uint32_t
+  {
+    return protocol_revision_;
+  }
+
+  [[nodiscard]] auto bucket() const -> const std::string&
+  {
+    return bucket_;
+  }
+
+  [[nodiscard]] auto config() -> std::optional<topology::configuration>
+  {
+    return config_;
+  }
+
+  [[nodiscard]] auto config_text() const -> const std::optional<std::string_view>&
+  {
+    return config_text_;
+  }
+
+  auto parse(const header_buffer& header,
+             const std::vector<std::byte>& body,
+             const cmd_info& info) -> bool;
 };
 
 } // namespace couchbase::core::protocol