couchbase 4.3.1 → 4.4.0

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

@@ -37,31 +37,36 @@ class range_scan_orchestrator_impl;
 
 class scan_stream_manager
 {
-  public:
-    virtual ~scan_stream_manager() = default;
-    virtual void stream_start_failed_awaiting_retry(std::int16_t node_id, std::uint16_t vbucket_id) = 0;
-    virtual void stream_received_item(range_scan_item item) = 0;
-    virtual void stream_failed(std::int16_t node_id, std::uint16_t vbucket_id, std::error_code ec, bool fatal) = 0;
-    virtual void stream_completed(std::int16_t node_id, std::uint16_t vbucket_id) = 0;
+public:
+  virtual ~scan_stream_manager() = default;
+  virtual void stream_start_failed_awaiting_retry(std::int16_t node_id,
+                                                  std::uint16_t vbucket_id) = 0;
+  virtual void stream_received_item(range_scan_item item) = 0;
+  virtual void stream_failed(std::int16_t node_id,
+                             std::uint16_t vbucket_id,
+                             std::error_code ec,
+                             bool fatal) = 0;
+  virtual void stream_completed(std::int16_t node_id, std::uint16_t vbucket_id) = 0;
 };
 
 using scan_callback = utils::movable_function<void(std::error_code, scan_result result)>;
 
 class range_scan_orchestrator
 {
-  public:
-    range_scan_orchestrator(asio::io_context& io,
-                            agent kv_provider,
-                            topology::configuration::vbucket_map vbucket_map,
-                            std::string scope_name,
-                            std::string collection_name,
-                            std::variant<std::monostate, range_scan, prefix_scan, sampling_scan> scan_type,
-                            range_scan_orchestrator_options options);
+public:
+  range_scan_orchestrator(
+    asio::io_context& io,
+    agent kv_provider,
+    topology::configuration::vbucket_map vbucket_map,
+    std::string scope_name,
+    std::string collection_name,
+    std::variant<std::monostate, range_scan, prefix_scan, sampling_scan> scan_type,
+    range_scan_orchestrator_options options);
 
-    auto scan() -> tl::expected<scan_result, std::error_code>;
-    void scan(scan_callback&& cb);
+  auto scan() -> tl::expected<scan_result, std::error_code>;
+  void scan(scan_callback&& cb);
 
-  private:
-    std::shared_ptr<range_scan_orchestrator_impl> impl_;
+private:
+  std::shared_ptr<range_scan_orchestrator_impl> impl_;
 };
 } // namespace couchbase::core

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

@@ -40,20 +40,20 @@ class request_span;
 namespace couchbase::core
 {
 struct mutation_state {
-    std::vector<couchbase::mutation_token> tokens;
+  std::vector<couchbase::mutation_token> tokens;
 };
 
 struct range_scan_orchestrator_options {
-    static constexpr std::uint16_t default_concurrency{ 1 };
+  static constexpr std::uint16_t default_concurrency{ 1 };
 
-    bool ids_only{ false };
-    std::optional<mutation_state> consistent_with{};
-    std::uint32_t batch_item_limit{ range_scan_continue_options::default_batch_item_limit };
-    std::uint32_t batch_byte_limit{ range_scan_continue_options::default_batch_byte_limit };
-    std::uint16_t concurrency{ default_concurrency };
+  bool ids_only{ false };
+  std::optional<mutation_state> consistent_with{};
+  std::uint32_t batch_item_limit{ range_scan_continue_options::default_batch_item_limit };
+  std::uint32_t batch_byte_limit{ range_scan_continue_options::default_batch_byte_limit };
+  std::uint16_t concurrency{ default_concurrency };
 
-    std::shared_ptr<couchbase::retry_strategy> retry_strategy{ make_best_effort_retry_strategy() };
-    std::chrono::milliseconds timeout{ timeout_defaults::key_value_scan_timeout };
-    std::shared_ptr<couchbase::tracing::request_span> parent_span{};
+  std::shared_ptr<couchbase::retry_strategy> retry_strategy{ make_best_effort_retry_strategy() };
+  std::chrono::milliseconds timeout{ timeout_defaults::key_value_scan_timeout };
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{};
 };
 } // namespace couchbase::core

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

@@ -20,7 +20,7 @@
 namespace couchbase
 {
 struct resource_unit_result {
-    std::uint16_t read_units{};
-    std::uint16_t write_units{};
+  std::uint16_t read_units{};
+  std::uint16_t write_units{};
 };
 } // namespace couchbase

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <couchbase/key_value_error_map_info.hxx>
+#include "core/error_context/key_value_error_map_info.hxx"
 #include <couchbase/retry_reason.hxx>
 
 #include <memory>
@@ -37,13 +37,13 @@ class queue_request;
 
 class response_handler
 {
-  public:
-    virtual ~response_handler() = default;
-    virtual void handle_response(std::shared_ptr<mcbp::queue_request> request,
-                                 std::error_code error,
-                                 retry_reason reason,
-                                 io::mcbp_message msg,
-                                 std::optional<key_value_error_map_info> error_info) = 0;
+public:
+  virtual ~response_handler() = default;
+  virtual void handle_response(std::shared_ptr<mcbp::queue_request> request,
+                               std::error_code error,
+                               retry_reason reason,
+                               io::mcbp_message msg,
+                               std::optional<key_value_error_map_info> error_info) = 0;
 };
 
 } // namespace couchbase::core

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

@@ -26,27 +26,35 @@
 namespace couchbase::core
 {
 auto
-retry_orchestrator::should_retry(std::shared_ptr<mcbp::queue_request> request, retry_reason reason) -> retry_action
+retry_orchestrator::should_retry(std::shared_ptr<mcbp::queue_request> request,
+                                 retry_reason reason) -> retry_action
 {
-    if (always_retry(reason)) {
-        auto duration = controlled_backoff(request->retry_attempts());
-        CB_LOG_DEBUG("will retry request. backoff={}, operation_id={}, reason={}", duration, request->identifier(), reason);
-        request->record_retry_attempt(reason);
-        return retry_action{ duration };
-    }
+  if (always_retry(reason)) {
+    auto duration = controlled_backoff(request->retry_attempts());
+    CB_LOG_DEBUG("will retry request. backoff={}, operation_id={}, reason={}",
+                 duration,
+                 request->identifier(),
+                 reason);
+    request->record_retry_attempt(reason);
+    return retry_action{ duration };
+  }
 
-    auto strategy = request->retry_strategy();
-    if (strategy == nullptr) {
-        return retry_action::do_not_retry();
-    }
+  auto strategy = request->retry_strategy();
+  if (strategy == nullptr) {
+    return retry_action::do_not_retry();
+  }
 
-    auto action = strategy->retry_after(*request, reason);
-    if (!action.need_to_retry()) {
-        CB_LOG_DEBUG("will not retry request. operation_id={}, reason={}", request->identifier(), reason);
-        return retry_action::do_not_retry();
-    }
-    CB_LOG_DEBUG("will retry request. backoff={}, operation_id={}, reason={}", action.duration(), request->identifier(), reason);
-    request->record_retry_attempt(reason);
-    return action;
+  auto action = strategy->retry_after(*request, reason);
+  if (!action.need_to_retry()) {
+    CB_LOG_DEBUG(
+      "will not retry request. operation_id={}, reason={}", request->identifier(), reason);
+    return retry_action::do_not_retry();
+  }
+  CB_LOG_DEBUG("will retry request. backoff={}, operation_id={}, reason={}",
+               action.duration(),
+               request->identifier(),
+               reason);
+  request->record_retry_attempt(reason);
+  return action;
 }
 } // namespace couchbase::core

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

@@ -29,7 +29,8 @@ class queue_request;
 
 class retry_orchestrator
 {
-  public:
-    [[nodiscard]] static auto should_retry(std::shared_ptr<mcbp::queue_request> request, retry_reason reason) -> retry_action;
+public:
+  [[nodiscard]] static auto should_retry(std::shared_ptr<mcbp::queue_request> request,
+                                         retry_reason reason) -> retry_action;
 };
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/sasl/client.cc

@@ -25,26 +25,30 @@
 namespace couchbase::core::sasl
 {
 
-ClientContext::ClientContext(GetUsernameCallback user_cb, GetPasswordCallback password_cb, const std::vector<std::string>& mechanisms)
+ClientContext::ClientContext(GetUsernameCallback user_cb,
+                             GetPasswordCallback password_cb,
+                             const std::vector<std::string>& mechanisms)
 {
-    switch (select_mechanism(mechanisms)) {
-        case Mechanism::SCRAM_SHA512:
-            backend = std::make_unique<mechanism::scram::Sha512ClientBackend>(user_cb, password_cb, *this);
-            break;
-        case Mechanism::SCRAM_SHA256:
-            backend = std::make_unique<mechanism::scram::Sha256ClientBackend>(user_cb, password_cb, *this);
-            break;
-        case Mechanism::SCRAM_SHA1:
-            backend = std::make_unique<mechanism::scram::Sha1ClientBackend>(user_cb, password_cb, *this);
-            break;
-        case Mechanism::PLAIN:
-            backend = std::make_unique<mechanism::plain::ClientBackend>(user_cb, password_cb, *this);
-    }
+  switch (select_mechanism(mechanisms)) {
+    case Mechanism::SCRAM_SHA512:
+      backend =
+        std::make_unique<mechanism::scram::Sha512ClientBackend>(user_cb, password_cb, *this);
+      break;
+    case Mechanism::SCRAM_SHA256:
+      backend =
+        std::make_unique<mechanism::scram::Sha256ClientBackend>(user_cb, password_cb, *this);
+      break;
+    case Mechanism::SCRAM_SHA1:
+      backend = std::make_unique<mechanism::scram::Sha1ClientBackend>(user_cb, password_cb, *this);
+      break;
+    case Mechanism::PLAIN:
+      backend = std::make_unique<mechanism::plain::ClientBackend>(user_cb, password_cb, *this);
+  }
 
-    if (!backend) {
-        throw unknown_mechanism("cb::sasl::client::ClientContext(): Failed to create "
-                                "mechanism");
-    }
+  if (!backend) {
+    throw unknown_mechanism("cb::sasl::client::ClientContext(): Failed to create "
+                            "mechanism");
+  }
 }
 
 } // namespace couchbase::core::sasl

package/deps/couchbase-cxx-client/core/sasl/client.h

@@ -48,22 +48,24 @@ using GetPasswordCallback = std::function<std::string()>;
  */
 class MechanismBackend
 {
-  public:
-    explicit MechanismBackend(GetUsernameCallback user_cb, GetPasswordCallback password_cb, ClientContext& ctx)
-      : usernameCallback(std::move(user_cb))
-      , passwordCallback(std::move(password_cb))
-      , context(ctx)
-    {
-    }
-    virtual ~MechanismBackend() = default;
-    virtual std::pair<error, std::string_view> start() = 0;
-    virtual std::pair<error, std::string_view> step(std::string_view input) = 0;
-    [[nodiscard]] virtual std::string_view get_name() const = 0;
+public:
+  explicit MechanismBackend(GetUsernameCallback user_cb,
+                            GetPasswordCallback password_cb,
+                            ClientContext& ctx)
+    : usernameCallback(std::move(user_cb))
+    , passwordCallback(std::move(password_cb))
+    , context(ctx)
+  {
+  }
+  virtual ~MechanismBackend() = default;
+  virtual std::pair<error, std::string_view> start() = 0;
+  virtual std::pair<error, std::string_view> step(std::string_view input) = 0;
+  [[nodiscard]] virtual std::string_view get_name() const = 0;
 
-  protected:
-    const GetUsernameCallback usernameCallback;
-    const GetPasswordCallback passwordCallback;
-    ClientContext& context;
+protected:
+  const GetUsernameCallback usernameCallback;
+  const GetPasswordCallback passwordCallback;
+  ClientContext& context;
 };
 
 /**
@@ -71,57 +73,59 @@ class MechanismBackend
  */
 class ClientContext : public Context
 {
-  public:
-    /**
-     * Create a new instance of the ClientContext
-     *
-     * @param user_cb The callback method to fetch the username to
-     *                use in the authentication
-     * @param password_cb The callback method to fetch the password to
-     *                use in the authentication
-     * @param mechanisms The list of available mechanisms provided by
-     *                   the server. The client will pick the most
-     *                   secure method available
-     * @throws couchbase::core::sasl::no_such_mechanism if none of the mechanisms
-     *                   specified in the list of available mechanisms
-     *                   is supported
-     */
-    ClientContext(GetUsernameCallback user_cb, GetPasswordCallback password_cb, const std::vector<std::string>& mechanisms);
+public:
+  /**
+   * Create a new instance of the ClientContext
+   *
+   * @param user_cb The callback method to fetch the username to
+   *                use in the authentication
+   * @param password_cb The callback method to fetch the password to
+   *                use in the authentication
+   * @param mechanisms The list of available mechanisms provided by
+   *                   the server. The client will pick the most
+   *                   secure method available
+   * @throws couchbase::core::sasl::no_such_mechanism if none of the mechanisms
+   *                   specified in the list of available mechanisms
+   *                   is supported
+   */
+  ClientContext(GetUsernameCallback user_cb,
+                GetPasswordCallback password_cb,
+                const std::vector<std::string>& mechanisms);
 
-    /**
-     * Get the name of the mechanism in use by this backend.
-     *
-     * @return The name of the chosen authentication method
-     */
-    [[nodiscard]] std::string_view get_name() const
-    {
-        return backend->get_name();
-    }
+  /**
+   * Get the name of the mechanism in use by this backend.
+   *
+   * @return The name of the chosen authentication method
+   */
+  [[nodiscard]] std::string_view get_name() const
+  {
+    return backend->get_name();
+  }
 
-    /**
-     * Start the authentication
-     *
-     * @return The challenge to send to the server
-     */
-    std::pair<error, std::string_view> start()
-    {
-        return backend->start();
-    }
+  /**
+   * Start the authentication
+   *
+   * @return The challenge to send to the server
+   */
+  std::pair<error, std::string_view> start()
+  {
+    return backend->start();
+  }
 
-    /**
-     * Process the response received from the server and generate
-     * another challenge to send to the server.
-     *
-     * @param input The response from the server
-     * @return The challenge to send to the server
-     */
-    std::pair<error, std::string_view> step(std::string_view input)
-    {
-        return backend->step(input);
-    }
+  /**
+   * Process the response received from the server and generate
+   * another challenge to send to the server.
+   *
+   * @param input The response from the server
+   * @return The challenge to send to the server
+   */
+  std::pair<error, std::string_view> step(std::string_view input)
+  {
+    return backend->step(input);
+  }
 
-  private:
-    std::unique_ptr<MechanismBackend> backend;
+private:
+  std::unique_ptr<MechanismBackend> backend;
 };
 
 } // namespace couchbase::core::sasl

package/deps/couchbase-cxx-client/core/sasl/context.cc

@@ -25,10 +25,10 @@ namespace couchbase::core::sasl
 const std::string&
 Context::get_uuid()
 {
-    if (uuid.empty()) {
-        uuid = uuid::to_string(uuid::random());
-    }
+  if (uuid.empty()) {
+    uuid = uuid::to_string(uuid::random());
+  }
 
-    return uuid;
+  return uuid;
 }
 } // namespace couchbase::core::sasl

package/deps/couchbase-cxx-client/core/sasl/context.h

@@ -28,25 +28,25 @@ namespace couchbase::core::sasl
  */
 class Context
 {
-  public:
-    virtual ~Context() = default;
-
-    /**
-     * Get the UUID used for errors by this connection. If none
-     * is created a new one is generated.
-     */
-    [[nodiscard]] const std::string& get_uuid();
-
-    /**
-     * Do this context contain a UUID?
-     */
-    [[nodiscard]] bool contains_uuid() const
-    {
-        return !uuid.empty();
-    }
-
-  private:
-    std::string uuid;
+public:
+  virtual ~Context() = default;
+
+  /**
+   * Get the UUID used for errors by this connection. If none
+   * is created a new one is generated.
+   */
+  [[nodiscard]] const std::string& get_uuid();
+
+  /**
+   * Do this context contain a UUID?
+   */
+  [[nodiscard]] bool contains_uuid() const
+  {
+    return !uuid.empty();
+  }
+
+private:
+  std::string uuid;
 };
 
 } // namespace couchbase::core::sasl

package/deps/couchbase-cxx-client/core/sasl/error.h

@@ -23,6 +23,17 @@ namespace couchbase::core::sasl
 /**
  * The error values used in CBSASL
  */
-enum class error { OK, CONTINUE, FAIL, BAD_PARAM, NO_MEM, NO_MECH, NO_USER, PASSWORD_ERROR, NO_RBAC_PROFILE, AUTH_PROVIDER_DIED };
+enum class error {
+  OK,
+  CONTINUE,
+  FAIL,
+  BAD_PARAM,
+  NO_MEM,
+  NO_MECH,
+  NO_USER,
+  PASSWORD_ERROR,
+  NO_RBAC_PROFILE,
+  AUTH_PROVIDER_DIED
+};
 
 } // namespace couchbase::core::sasl

package/deps/couchbase-cxx-client/core/sasl/error_fmt.h

@@ -23,48 +23,48 @@
 
 template<>
 struct fmt::formatter<couchbase::core::sasl::error> {
-    template<typename ParseContext>
-    constexpr auto parse(ParseContext& ctx)
-    {
-        return ctx.begin();
-    }
+  template<typename ParseContext>
+  constexpr auto parse(ParseContext& ctx)
+  {
+    return ctx.begin();
+  }
 
-    template<typename FormatContext>
-    auto format(couchbase::core::sasl::error err, FormatContext& ctx) const
-    {
-        string_view name = "unknown";
-        switch (err) {
-            case couchbase::core::sasl::error::OK:
-                name = "ok";
-                break;
-            case couchbase::core::sasl::error::CONTINUE:
-                name = "continue";
-                break;
-            case couchbase::core::sasl::error::FAIL:
-                name = "fail";
-                break;
-            case couchbase::core::sasl::error::BAD_PARAM:
-                name = "bad_param";
-                break;
-            case couchbase::core::sasl::error::NO_MEM:
-                name = "no_mem";
-                break;
-            case couchbase::core::sasl::error::NO_MECH:
-                name = "no_mech";
-                break;
-            case couchbase::core::sasl::error::NO_USER:
-                name = "no_user";
-                break;
-            case couchbase::core::sasl::error::PASSWORD_ERROR:
-                name = "password_error";
-                break;
-            case couchbase::core::sasl::error::NO_RBAC_PROFILE:
-                name = "no_rbac_profile";
-                break;
-            case couchbase::core::sasl::error::AUTH_PROVIDER_DIED:
-                name = "auth_provider_died";
-                break;
-        }
-        return format_to(ctx.out(), "{}", name);
+  template<typename FormatContext>
+  auto format(couchbase::core::sasl::error err, FormatContext& ctx) const
+  {
+    string_view name = "unknown";
+    switch (err) {
+      case couchbase::core::sasl::error::OK:
+        name = "ok";
+        break;
+      case couchbase::core::sasl::error::CONTINUE:
+        name = "continue";
+        break;
+      case couchbase::core::sasl::error::FAIL:
+        name = "fail";
+        break;
+      case couchbase::core::sasl::error::BAD_PARAM:
+        name = "bad_param";
+        break;
+      case couchbase::core::sasl::error::NO_MEM:
+        name = "no_mem";
+        break;
+      case couchbase::core::sasl::error::NO_MECH:
+        name = "no_mech";
+        break;
+      case couchbase::core::sasl::error::NO_USER:
+        name = "no_user";
+        break;
+      case couchbase::core::sasl::error::PASSWORD_ERROR:
+        name = "password_error";
+        break;
+      case couchbase::core::sasl::error::NO_RBAC_PROFILE:
+        name = "no_rbac_profile";
+        break;
+      case couchbase::core::sasl::error::AUTH_PROVIDER_DIED:
+        name = "auth_provider_died";
+        break;
     }
+    return format_to(ctx.out(), "{}", name);
+  }
 };

package/deps/couchbase-cxx-client/core/sasl/mechanism.cc

@@ -27,19 +27,22 @@ namespace couchbase::core::sasl
 Mechanism
 select_mechanism(const std::vector<std::string>& available_mechanisms)
 {
-    // Search what we've got backends for
-    const std::vector<std::pair<std::string, Mechanism>> mechs = { { std::string{ "SCRAM-SHA512" }, Mechanism::SCRAM_SHA512 },
-                                                                   { std::string{ "SCRAM-SHA256" }, Mechanism::SCRAM_SHA256 },
-                                                                   { std::string{ "SCRAM-SHA1" }, Mechanism::SCRAM_SHA1 },
-                                                                   { std::string{ "PLAIN" }, Mechanism::PLAIN } };
+  // Search what we've got backends for
+  const std::vector<std::pair<std::string, Mechanism>> mechs = {
+    { std::string{ "SCRAM-SHA512" }, Mechanism::SCRAM_SHA512 },
+    { std::string{ "SCRAM-SHA256" }, Mechanism::SCRAM_SHA256 },
+    { std::string{ "SCRAM-SHA1" }, Mechanism::SCRAM_SHA1 },
+    { std::string{ "PLAIN" }, Mechanism::PLAIN }
+  };
 
-    for (const auto& [name, code] : mechs) {
-        if (std::find(available_mechanisms.begin(), available_mechanisms.end(), name) != available_mechanisms.end()) {
-            return code;
-        }
+  for (const auto& [name, code] : mechs) {
+    if (std::find(available_mechanisms.begin(), available_mechanisms.end(), name) !=
+        available_mechanisms.end()) {
+      return code;
     }
+  }
 
-    throw unknown_mechanism("unknown mechanism"); // TODO: avoid this exception
+  throw unknown_mechanism("unknown mechanism"); // TODO: avoid this exception
 }
 
 } // namespace couchbase::core::sasl

package/deps/couchbase-cxx-client/core/sasl/mechanism.h

@@ -26,12 +26,17 @@
 namespace couchbase::core::sasl
 {
 
-enum class Mechanism { SCRAM_SHA512, SCRAM_SHA256, SCRAM_SHA1, PLAIN };
+enum class Mechanism {
+  SCRAM_SHA512,
+  SCRAM_SHA256,
+  SCRAM_SHA1,
+  PLAIN
+};
 
 class unknown_mechanism : public std::invalid_argument
 {
-  public:
-    using std::invalid_argument::invalid_argument;
+public:
+  using std::invalid_argument::invalid_argument;
 };
 
 /**

package/deps/couchbase-cxx-client/core/sasl/plain/plain.cc

@@ -24,16 +24,16 @@ namespace couchbase::core::sasl::mechanism::plain
 std::pair<error, std::string_view>
 ClientBackend::start()
 {
-    auto usernm = usernameCallback();
-    auto passwd = passwordCallback();
+  auto usernm = usernameCallback();
+  auto passwd = passwordCallback();
 
-    buffer.reserve(usernm.size() + passwd.size() + 2);
-    buffer.push_back(0);
-    std::copy(usernm.begin(), usernm.end(), std::back_insert_iterator(buffer));
-    buffer.push_back(0);
-    std::copy(passwd.begin(), passwd.end(), std::back_insert_iterator(buffer));
+  buffer.reserve(usernm.size() + passwd.size() + 2);
+  buffer.push_back(0);
+  std::copy(usernm.begin(), usernm.end(), std::back_insert_iterator(buffer));
+  buffer.push_back(0);
+  std::copy(passwd.begin(), passwd.end(), std::back_insert_iterator(buffer));
 
-    return { error::OK, { buffer.data(), buffer.size() } };
+  return { error::OK, { buffer.data(), buffer.size() } };
 }
 
 } // namespace couchbase::core::sasl::mechanism::plain