couchbase 4.3.1 → 4.4.0

package/deps/couchbase-cxx-client/core/mcbp/codec.hxx

@@ -35,18 +35,20 @@ namespace couchbase::core::mcbp
 
 class codec
 {
-  public:
-    explicit codec(std::set<protocol::hello_feature> enabled_features);
-
-    auto encode_packet(const packet& packet) -> tl::expected<std::vector<std::byte>, std::error_code>;
-    auto decode_packet(gsl::span<std::byte> input) -> std::tuple<packet, std::size_t, std::error_code>;
-    auto decode_packet(gsl::span<std::byte> header, gsl::span<std::byte> body) -> std::tuple<packet, std::size_t, std::error_code>;
-    void enable_feature(protocol::hello_feature feature);
-    [[nodiscard]] auto is_feature_enabled(protocol::hello_feature feature) const -> bool;
-
-  private:
-    std::set<protocol::hello_feature> enabled_features_{};
-    bool collections_enabled_{ false };
+public:
+  explicit codec(std::set<protocol::hello_feature> enabled_features);
+
+  auto encode_packet(const packet& packet) -> tl::expected<std::vector<std::byte>, std::error_code>;
+  auto decode_packet(gsl::span<std::byte> input)
+    -> std::tuple<packet, std::size_t, std::error_code>;
+  auto decode_packet(gsl::span<std::byte> header,
+                     gsl::span<std::byte> body) -> std::tuple<packet, std::size_t, std::error_code>;
+  void enable_feature(protocol::hello_feature feature);
+  [[nodiscard]] auto is_feature_enabled(protocol::hello_feature feature) const -> bool;
+
+private:
+  std::set<protocol::hello_feature> enabled_features_{};
+  bool collections_enabled_{ false };
 };
 
 } // namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/mcbp/command_code.cxx

@@ -22,56 +22,56 @@ namespace couchbase::core::mcbp
 auto
 is_idempotent(protocol::client_opcode opcode) -> bool
 {
-    switch (opcode) {
-        case protocol::client_opcode::get:
-        case protocol::client_opcode::noop:
-        case protocol::client_opcode::get_replica:
-        case protocol::client_opcode::observe_seqno:
-        case protocol::client_opcode::observe:
-        case protocol::client_opcode::get_meta:
-        case protocol::client_opcode::stat:
-        case protocol::client_opcode::get_cluster_config:
-        case protocol::client_opcode::get_random_key:
-        case protocol::client_opcode::get_collections_manifest:
-        case protocol::client_opcode::get_collection_id:
-        case protocol::client_opcode::subdoc_multi_lookup:
-            return true;
-        default:
-            break;
-    }
-    return false;
+  switch (opcode) {
+    case protocol::client_opcode::get:
+    case protocol::client_opcode::noop:
+    case protocol::client_opcode::get_replica:
+    case protocol::client_opcode::observe_seqno:
+    case protocol::client_opcode::observe:
+    case protocol::client_opcode::get_meta:
+    case protocol::client_opcode::stat:
+    case protocol::client_opcode::get_cluster_config:
+    case protocol::client_opcode::get_random_key:
+    case protocol::client_opcode::get_collections_manifest:
+    case protocol::client_opcode::get_collection_id:
+    case protocol::client_opcode::subdoc_multi_lookup:
+      return true;
+    default:
+      break;
+  }
+  return false;
 }
 
-bool
-supports_collection_id(protocol::client_opcode command)
+auto
+supports_collection_id(protocol::client_opcode command) -> bool
 {
-    switch (command) {
-        case protocol::client_opcode::get:
-        case protocol::client_opcode::upsert:
-        case protocol::client_opcode::insert:
-        case protocol::client_opcode::replace:
-        case protocol::client_opcode::remove:
-        case protocol::client_opcode::increment:
-        case protocol::client_opcode::decrement:
-        case protocol::client_opcode::append:
-        case protocol::client_opcode::prepend:
-        case protocol::client_opcode::touch:
-        case protocol::client_opcode::get_and_touch:
-        case protocol::client_opcode::dcp_mutation:
-        case protocol::client_opcode::dcp_deletion:
-        case protocol::client_opcode::dcp_expiration:
-        case protocol::client_opcode::get_replica:
-        case protocol::client_opcode::get_and_lock:
-        case protocol::client_opcode::unlock:
-        case protocol::client_opcode::get_meta:
-        case protocol::client_opcode::upsert_with_meta:
-        case protocol::client_opcode::remove_with_meta:
-        case protocol::client_opcode::subdoc_multi_lookup:
-        case protocol::client_opcode::subdoc_multi_mutation:
-            return true;
-        default:
-            break;
-    }
-    return false;
+  switch (command) {
+    case protocol::client_opcode::get:
+    case protocol::client_opcode::upsert:
+    case protocol::client_opcode::insert:
+    case protocol::client_opcode::replace:
+    case protocol::client_opcode::remove:
+    case protocol::client_opcode::increment:
+    case protocol::client_opcode::decrement:
+    case protocol::client_opcode::append:
+    case protocol::client_opcode::prepend:
+    case protocol::client_opcode::touch:
+    case protocol::client_opcode::get_and_touch:
+    case protocol::client_opcode::dcp_mutation:
+    case protocol::client_opcode::dcp_deletion:
+    case protocol::client_opcode::dcp_expiration:
+    case protocol::client_opcode::get_replica:
+    case protocol::client_opcode::get_and_lock:
+    case protocol::client_opcode::unlock:
+    case protocol::client_opcode::get_meta:
+    case protocol::client_opcode::upsert_with_meta:
+    case protocol::client_opcode::remove_with_meta:
+    case protocol::client_opcode::subdoc_multi_lookup:
+    case protocol::client_opcode::subdoc_multi_mutation:
+      return true;
+    default:
+      break;
+  }
+  return false;
 }
 } // namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/mcbp/completion_token.hxx

@@ -26,44 +26,44 @@
 namespace couchbase::core::mcbp
 {
 struct completion_token {
-    std::shared_ptr<pending_operation> operation{};
-    std::error_code ec{};
+  std::shared_ptr<pending_operation> operation{};
+  std::error_code ec{};
 
-    template<std::size_t index>
-    auto&& get() &
-    {
-        return get_impl<index>(*this);
-    }
+  template<std::size_t index>
+  auto get() & -> auto&&
+  {
+    return get_impl<index>(*this);
+  }
 
-    template<std::size_t index>
-    auto&& get() &&
-    {
-        return get_impl<index>(*this);
-    }
+  template<std::size_t index>
+  auto get() && -> auto&&
+  {
+    return get_impl<index>(*this);
+  }
 
-    template<std::size_t index>
-    auto&& get() const&
-    {
-        return get_impl<index>(*this);
-    }
+  template<std::size_t index>
+  auto get() const& -> auto&&
+  {
+    return get_impl<index>(*this);
+  }
 
-    template<std::size_t index>
-    auto&& get() const&&
-    {
-        return get_impl<index>(*this);
-    }
+  template<std::size_t index>
+  auto get() const&& -> auto&&
+  {
+    return get_impl<index>(*this);
+  }
 
-  private:
-    template<std::size_t index, typename T>
-    auto&& get_impl(T&& t)
-    {
-        static_assert(index < 2, "index out of bounds for completion_token");
-        if constexpr (index == 0) {
-            return std::forward<T>(t).name;
-        }
-        if constexpr (index == 1) {
-            return std::forward<T>(t).age;
-        }
+private:
+  template<std::size_t index, typename T>
+  auto get_impl(T&& t) -> auto&&
+  {
+    static_assert(index < 2, "index out of bounds for completion_token");
+    if constexpr (index == 0) {
+      return std::forward<T>(t).name;
+    }
+    if constexpr (index == 1) {
+      return std::forward<T>(t).age;
     }
+  }
 };
 } // namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/mcbp/datatype.hxx

@@ -32,9 +32,9 @@ static constexpr datatype datatype_compressed{ 0x02 };
 // indicates the inclusion of xattr data in the value payload.
 static constexpr datatype datatype_xattrs{ 0x04 };
 
-static constexpr bool
-has_json_datatype(std::byte flags)
+static constexpr auto
+has_json_datatype(std::byte flags) -> bool
 {
-    return (flags & datatype_json) == datatype_json;
+  return (flags & datatype_json) == datatype_json;
 }
 } // namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/mcbp/durability_level.hxx

@@ -22,14 +22,15 @@
 namespace couchbase::core::mcbp
 {
 enum class durability_level : std::uint8_t {
-    // specifies that a change must be replicated to (held in memory) a majority of the nodes for the bucket.
-    majority = 0x01,
+  // specifies that a change must be replicated to (held in memory) a majority of the nodes for the
+  // bucket.
+  majority = 0x01,
 
-    // specifies that a change must be replicated to (held in memory) a majority of the nodes for the bucket and additionally persisted to
-    // disk on the active node.
-    majority_and_persist_to_active = 0x02,
+  // specifies that a change must be replicated to (held in memory) a majority of the nodes for the
+  // bucket and additionally persisted to disk on the active node.
+  majority_and_persist_to_active = 0x02,
 
-    // specifies that a change must be persisted to (written to disk) a majority for the bucket.
-    persist_to_majority = 0x03,
+  // specifies that a change must be persisted to (written to disk) a majority for the bucket.
+  persist_to_majority = 0x03,
 };
 } // namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/mcbp/durability_level_frame.hxx

@@ -21,8 +21,9 @@
 
 namespace couchbase::core::mcbp
 {
-// durability_level_frame allows you to specify a durability level for an operation through the frame extras.
+// durability_level_frame allows you to specify a durability level for an operation through the
+// frame extras.
 struct durability_level_frame {
-    durability_level level;
+  durability_level level;
 };
 } // namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/mcbp/durability_timeout_frame.hxx

@@ -21,9 +21,10 @@
 
 namespace couchbase::core::mcbp
 {
-// durability_timeout_frame allows you to specify a specific timeout for durability operations to timeout.  Note that this frame is actually
-// an extension of durability_level_frame and requires that frame to also be used in order to function.
+// durability_timeout_frame allows you to specify a specific timeout for durability operations to
+// timeout.  Note that this frame is actually an extension of durability_level_frame and requires
+// that frame to also be used in order to function.
 struct durability_timeout_frame {
-    std::chrono::milliseconds timeout;
+  std::chrono::milliseconds timeout;
 };
 } // namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/mcbp/open_tracing_frame.hxx

@@ -22,8 +22,9 @@
 
 namespace couchbase::core::mcbp
 {
-// open_tracing_frame allows open tracing context information to be included along with a command which is being performed.
+// open_tracing_frame allows open tracing context information to be included along with a command
+// which is being performed.
 struct open_tracing_frame {
-    std::vector<std::byte> trace_context;
+  std::vector<std::byte> trace_context;
 };
 } // namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/mcbp/operation_consumer.cxx

@@ -30,18 +30,18 @@ operation_consumer::operation_consumer(std::shared_ptr<operation_queue> parent)
 auto
 operation_consumer::queue() -> std::shared_ptr<operation_queue>
 {
-    return parent_;
+  return parent_;
 }
 
 void
 operation_consumer::close()
 {
-    parent_->close_consumer(shared_from_this());
+  parent_->close_consumer(shared_from_this());
 }
 
 auto
 operation_consumer::pop() -> std::shared_ptr<queue_request>
 {
-    return parent_->pop(shared_from_this());
+  return parent_->pop(shared_from_this());
 }
 } // namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/mcbp/operation_consumer.hxx

@@ -26,17 +26,17 @@ class queue_request;
 
 class operation_consumer : public std::enable_shared_from_this<operation_consumer>
 {
-  public:
-    explicit operation_consumer(std::shared_ptr<operation_queue> parent);
+public:
+  explicit operation_consumer(std::shared_ptr<operation_queue> parent);
 
-    [[nodiscard]] auto queue() -> std::shared_ptr<operation_queue>;
-    [[nodiscard]] auto pop() -> std::shared_ptr<queue_request>;
-    void close();
+  [[nodiscard]] auto queue() -> std::shared_ptr<operation_queue>;
+  [[nodiscard]] auto pop() -> std::shared_ptr<queue_request>;
+  void close();
 
-  private:
-    std::shared_ptr<operation_queue> parent_;
-    bool is_closed_{ false };
+private:
+  std::shared_ptr<operation_queue> parent_;
+  bool is_closed_{ false };
 
-    friend operation_queue;
+  friend operation_queue;
 };
 } // namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/mcbp/operation_queue.cxx

@@ -33,127 +33,133 @@ namespace couchbase::core::mcbp
 auto
 operation_queue::debug_string() const -> std::string
 {
-    std::scoped_lock lock(mutex_);
-    std::vector<char> out;
-    fmt::format_to(std::back_insert_iterator(out), "num_items: {}, is_open: {}", items_.size(), is_open_);
-    return { out.begin(), out.end() };
+  std::scoped_lock lock(mutex_);
+  std::vector<char> out;
+  fmt::format_to(
+    std::back_insert_iterator(out), "num_items: {}, is_open: {}", items_.size(), is_open_);
+  return { out.begin(), out.end() };
 }
 
 auto
 operation_queue::consumer() -> std::shared_ptr<operation_consumer>
 {
-    return std::make_shared<operation_consumer>(shared_from_this());
+  return std::make_shared<operation_consumer>(shared_from_this());
 }
 
 void
 operation_queue::close_consumer(std::shared_ptr<operation_consumer> consumer)
 {
-    std::scoped_lock lock(mutex_);
-    consumer->close();
-    signal_.notify_all();
+  std::scoped_lock lock(mutex_);
+  consumer->close();
+  signal_.notify_all();
 }
 
 void
 operation_queue::close()
 {
-    std::scoped_lock lock(mutex_);
-    is_open_ = false;
-    signal_.notify_all();
+  std::scoped_lock lock(mutex_);
+  is_open_ = false;
+  signal_.notify_all();
 }
 
 auto
-operation_queue::push(std::shared_ptr<queue_request> request, std::size_t max_items) -> std::error_code
+operation_queue::push(std::shared_ptr<queue_request> request,
+                      std::size_t max_items) -> std::error_code
 {
-    std::scoped_lock lock(mutex_);
+  std::scoped_lock lock(mutex_);
 
-    if (!is_open_) {
-        return errc::network::operation_queue_closed;
-    }
+  if (!is_open_) {
+    return errc::network::operation_queue_closed;
+  }
 
-    if (max_items > 0 && items_.size() >= max_items) {
-        return errc::network::operation_queue_full;
-    }
+  if (max_items > 0 && items_.size() >= max_items) {
+    return errc::network::operation_queue_full;
+  }
 
-    if (operation_queue * no_queue{ nullptr }; !request->queued_with_.compare_exchange_strong(no_queue, this)) {
-        return errc::network::request_already_queued;
-    }
+  if (operation_queue * no_queue{ nullptr };
+      !request->queued_with_.compare_exchange_strong(no_queue, this)) {
+    return errc::network::request_already_queued;
+  }
 
-    if (request->is_cancelled()) {
-        request->queued_with_.exchange(nullptr);
-        return errc::network::request_cancelled;
-    }
+  if (request->is_cancelled()) {
+    request->queued_with_.exchange(nullptr);
+    return errc::network::request_cancelled;
+  }
 
-    items_.emplace_back(std::move(request));
-    signal_.notify_all();
+  items_.emplace_back(std::move(request));
+  signal_.notify_all();
 
-    return {};
+  return {};
 }
 
 auto
 operation_queue::remove(std::shared_ptr<queue_request> request) -> bool
 {
-    std::scoped_lock lock(mutex_);
+  std::scoped_lock lock(mutex_);
 
-    if (!is_open_) {
-        return false;
-    }
+  if (!is_open_) {
+    return false;
+  }
 
-    if (operation_queue * this_queue{ nullptr }; !request->queued_with_.compare_exchange_strong(this_queue, nullptr)) {
-        return false;
-    }
+  if (operation_queue * this_queue{ nullptr };
+      !request->queued_with_.compare_exchange_strong(this_queue, nullptr)) {
+    return false;
+  }
 
-    if (auto item = std::find(items_.begin(), items_.end(), request); item != items_.end()) {
-        items_.erase(item);
-        return true;
-    }
+  if (auto item = std::find(items_.begin(), items_.end(), request); item != items_.end()) {
+    items_.erase(item);
+    return true;
+  }
 
-    return false;
+  return false;
 }
 
 auto
 operation_queue::pop(std::shared_ptr<operation_consumer> consumer) -> std::shared_ptr<queue_request>
 {
-    std::unique_lock lock(mutex_);
+  std::unique_lock lock(mutex_);
 
-    signal_.wait(lock, [this, consumer]() { return is_open_ && !consumer->is_closed_ && items_.empty(); });
+  signal_.wait(lock, [this, consumer]() {
+    return is_open_ && !consumer->is_closed_ && items_.empty();
+  });
 
-    if (!is_open_ || consumer->is_closed_) {
-        return nullptr;
-    }
+  if (!is_open_ || consumer->is_closed_) {
+    return nullptr;
+  }
 
-    auto request = items_.front();
-    items_.pop_front();
-    request->queued_with_.exchange(nullptr);
-    return request;
+  auto request = items_.front();
+  items_.pop_front();
+  request->queued_with_.exchange(nullptr);
+  return request;
 }
 
 void
 operation_queue::drain(operation_queue::drain_callback callback)
 {
-    for (const auto& request : items_to_drain()) {
-        callback(request);
-    }
+  for (const auto& request : items_to_drain()) {
+    callback(request);
+  }
 }
 
 auto
 operation_queue::items_to_drain() -> std::list<std::shared_ptr<queue_request>>
 {
-    std::scoped_lock lock(mutex_);
-
-    if (is_open_) {
-        CB_LOG_ERROR("attempted to drain open MCBP operation queue, ignoring");
-        return {};
-    }
-
-    if (items_.empty()) {
-        return {};
-    }
-
-    std::list<std::shared_ptr<queue_request>> local_items;
-    std::swap(local_items, items_);
-    for (const auto& request : local_items) {
-        request->queued_with_.exchange(nullptr);
-    }
-    return local_items;
+  std::scoped_lock lock(mutex_);
+
+  if (is_open_) {
+    CB_LOG_ERROR("attempted to drain open MCBP operation queue, ignoring");
+    return {};
+  }
+
+  if (items_.empty()) {
+    return {};
+  }
+
+  std::list<std::shared_ptr<queue_request>> local_items;
+  std::swap(local_items, items_);
+  for (const auto& request : local_items) {
+    request->queued_with_.exchange(nullptr);
+  }
+  return local_items;
 }
 } // namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/mcbp/operation_queue.hxx

@@ -31,27 +31,28 @@ class operation_consumer;
 
 class operation_queue : public std::enable_shared_from_this<operation_queue>
 {
-  public:
-    using drain_callback = std::function<void(std::shared_ptr<queue_request> request)>;
+public:
+  using drain_callback = std::function<void(std::shared_ptr<queue_request> request)>;
 
-    [[nodiscard]] auto push(std::shared_ptr<queue_request> request, std::size_t max_items) -> std::error_code;
-    auto remove(std::shared_ptr<queue_request> request) -> bool;
-    void drain(drain_callback callback);
+  [[nodiscard]] auto push(std::shared_ptr<queue_request> request,
+                          std::size_t max_items) -> std::error_code;
+  auto remove(std::shared_ptr<queue_request> request) -> bool;
+  void drain(drain_callback callback);
 
-    [[nodiscard]] auto consumer() -> std::shared_ptr<operation_consumer>;
-    void close();
-    [[nodiscard]] auto debug_string() const -> std::string;
+  [[nodiscard]] auto consumer() -> std::shared_ptr<operation_consumer>;
+  void close();
+  [[nodiscard]] auto debug_string() const -> std::string;
 
-  private:
-    void close_consumer(std::shared_ptr<operation_consumer> consumer);
-    auto pop(std::shared_ptr<operation_consumer> consumer) -> std::shared_ptr<queue_request>;
-    auto items_to_drain() -> std::list<std::shared_ptr<queue_request>>;
+private:
+  void close_consumer(std::shared_ptr<operation_consumer> consumer);
+  auto pop(std::shared_ptr<operation_consumer> consumer) -> std::shared_ptr<queue_request>;
+  auto items_to_drain() -> std::list<std::shared_ptr<queue_request>>;
 
-    std::list<std::shared_ptr<queue_request>> items_{};
-    mutable std::mutex mutex_{};
-    std::condition_variable signal_{};
-    bool is_open_{ true };
+  std::list<std::shared_ptr<queue_request>> items_{};
+  mutable std::mutex mutex_{};
+  std::condition_variable signal_{};
+  bool is_open_{ true };
 
-    friend operation_consumer;
+  friend operation_consumer;
 };
 } // namespace couchbase::core::mcbp