couchbase 4.2.11-rc.1 → 4.3.0

package/deps/couchbase-cxx-client/core/io/mcbp_session.cxx

@@ -210,6 +210,7 @@ class mcbp_session_impl
         std::shared_ptr<mcbp_session_impl> session_;
         sasl::ClientContext sasl_;
         std::atomic_bool stopped_{ false };
+        std::string last_error_message_;
 
       public:
         ~bootstrap_handler()
@@ -234,6 +235,16 @@ class mcbp_session_impl
             return { "SCRAM-SHA512", "SCRAM-SHA256", "SCRAM-SHA1" };
         }
 
+        std::string last_error_message() &&
+        {
+            return std::move(last_error_message_);
+        }
+
+        [[nodiscard]] const std::string& last_error_message() const&
+        {
+            return last_error_message_;
+        }
+
         explicit bootstrap_handler(std::shared_ptr<mcbp_session_impl> session)
           : session_(std::move(session))
           , sasl_([origin = session_->origin_]() { return origin.username(); },
@@ -322,21 +333,21 @@ class mcbp_session_impl
                         case key_value_status_code::rate_limited_max_connections:
                         case key_value_status_code::rate_limited_network_egress:
                         case key_value_status_code::rate_limited_network_ingress:
-                            CB_LOG_DEBUG(
-                              "{} unable to bootstrap MCBP session (bucket={}, opcode={}, status={}), the user has reached rate limit",
-                              session_->log_prefix_,
+                            last_error_message_ = fmt::format(
+                              "unable to bootstrap MCBP session (bucket={}, opcode={}, status={}), the user has reached rate limit",
                               session_->bucket_name_.value_or(""),
                               protocol::client_opcode(msg.header.opcode),
                               status);
+                            CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
                             return complete(errc::common::rate_limited);
 
                         case key_value_status_code::scope_size_limit_exceeded:
-                            CB_LOG_DEBUG(
-                              "{} unable to bootstrap MCBP session (bucket={}, opcode={}, status={}), the user has reached quota limit",
-                              session_->log_prefix_,
+                            last_error_message_ = fmt::format(
+                              "unable to bootstrap MCBP session (bucket={}, opcode={}, status={}), the user has reached quota limit",
                               session_->bucket_name_.value_or(""),
                               protocol::client_opcode(msg.header.opcode),
                               status);
+                            CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
                             return complete(errc::common::quota_limited);
 
                         default:
@@ -356,20 +367,18 @@ class mcbp_session_impl
                                     return auth_success();
                                 }
                             } else {
-                                CB_LOG_WARNING("{} unexpected message status during bootstrap: {} (opaque={})",
-                                               session_->log_prefix_,
-                                               resp.error_message(),
-                                               resp.opaque());
+                                last_error_message_ = fmt::format(
+                                  "unexpected message status during bootstrap: {} (opaque={})", resp.error_message(), resp.opaque());
+                                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::network::handshake_failure);
                             }
                         } break;
                         case protocol::client_opcode::sasl_list_mechs: {
                             protocol::client_response<protocol::sasl_list_mechs_response_body> resp(std::move(msg));
                             if (resp.status() != key_value_status_code::success) {
-                                CB_LOG_WARNING("{} unexpected message status during bootstrap: {} (opaque={})",
-                                               session_->log_prefix_,
-                                               resp.error_message(),
-                                               resp.opaque());
+                                last_error_message_ = fmt::format(
+                                  "unexpected message status during bootstrap: {} (opaque={})", resp.error_message(), resp.opaque());
+                                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::common::authentication_failure);
                             }
                         } break;
@@ -390,17 +399,17 @@ class mcbp_session_impl
                                     req.body().sasl_data(sasl_payload);
                                     session_->write_and_flush(req.data());
                                 } else {
-                                    CB_LOG_ERROR("{} unable to authenticate: (sasl_code={}, opaque={})",
-                                                 session_->log_prefix_,
-                                                 sasl_code,
-                                                 resp.opaque());
+                                    last_error_message_ =
+                                      fmt::format("unable to authenticate: (sasl_code={}, opaque={})", sasl_code, resp.opaque());
+                                    CB_LOG_ERROR("{} {}", session_->log_prefix_, last_error_message_);
                                     return complete(errc::common::authentication_failure);
                                 }
                             } else {
-                                CB_LOG_WARNING("{} unexpected message status during bootstrap: {} (opaque={})",
-                                               session_->log_prefix_,
-                                               resp.error_message(),
-                                               resp.opaque());
+                                last_error_message_ = fmt::format("{} unexpected message status during bootstrap: {} (opaque={})",
+                                                                  session_->log_prefix_,
+                                                                  resp.error_message(),
+                                                                  resp.opaque());
+                                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::common::authentication_failure);
                             }
                         } break;
@@ -409,6 +418,9 @@ class mcbp_session_impl
                             if (resp.status() == key_value_status_code::success) {
                                 return auth_success();
                             }
+                            last_error_message_ =
+                              fmt::format("unable to authenticate (opcode={}, status={}, opaque={})", opcode, resp.status(), resp.opaque());
+                            CB_LOG_ERROR("{} {}", session_->log_prefix_, last_error_message_);
                             return complete(errc::common::authentication_failure);
                         }
                         case protocol::client_opcode::get_error_map: {
@@ -416,11 +428,11 @@ class mcbp_session_impl
                             if (resp.status() == key_value_status_code::success) {
                                 session_->error_map_.emplace(resp.body().errmap());
                             } else {
-                                CB_LOG_WARNING("{} unexpected message status during bootstrap: {} (opaque={}, {:n})",
-                                               session_->log_prefix_,
-                                               resp.error_message(),
-                                               resp.opaque(),
-                                               spdlog::to_hex(resp.header()));
+                                last_error_message_ = fmt::format("unexpected message status during bootstrap: {} (opaque={}, {:n})",
+                                                                  resp.error_message(),
+                                                                  resp.opaque(),
+                                                                  spdlog::to_hex(resp.header()));
+                                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::network::protocol_error);
                             }
                         } break;
@@ -430,25 +442,25 @@ class mcbp_session_impl
                                 CB_LOG_DEBUG("{} selected bucket: {}", session_->log_prefix_, session_->bucket_name_.value_or(""));
                                 session_->bucket_selected_ = true;
                             } else if (resp.status() == key_value_status_code::not_found) {
-                                CB_LOG_DEBUG(
-                                  "{} kv_engine node does not have configuration propagated yet (opcode={}, status={}, opaque={})",
-                                  session_->log_prefix_,
-                                  opcode,
-                                  resp.status(),
-                                  resp.opaque());
+                                last_error_message_ =
+                                  fmt::format("kv_engine node does not have configuration propagated yet (opcode={}, status={}, opaque={})",
+                                              opcode,
+                                              resp.status(),
+                                              resp.opaque());
+                                CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::network::configuration_not_available);
                             } else if (resp.status() == key_value_status_code::no_access) {
-                                CB_LOG_DEBUG("{} unable to select bucket: {}, probably the bucket does not exist",
-                                             session_->log_prefix_,
-                                             session_->bucket_name_.value_or(""));
+                                last_error_message_ = fmt::format("unable to select bucket: {}, probably the bucket does not exist",
+                                                                  session_->bucket_name_.value_or(""));
+                                CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
                                 session_->bucket_selected_ = false;
                                 return complete(errc::common::bucket_not_found);
                             } else {
-                                CB_LOG_WARNING("{} unexpected message status during bootstrap: {} (opaque={}, {:n})",
-                                               session_->log_prefix_,
-                                               resp.error_message(),
-                                               resp.opaque(),
-                                               spdlog::to_hex(resp.header()));
+                                last_error_message_ = fmt::format("unexpected message status during bootstrap: {} (opaque={}, {:n})",
+                                                                  resp.error_message(),
+                                                                  resp.opaque(),
+                                                                  spdlog::to_hex(resp.header()));
+                                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::common::bucket_not_found);
                             }
                         } break;
@@ -470,12 +482,12 @@ class mcbp_session_impl
                                 session_->update_configuration(resp.body().config());
                                 complete({});
                             } else if (resp.status() == key_value_status_code::not_found) {
-                                CB_LOG_DEBUG(
-                                  "{} kv_engine node does not have configuration propagated yet (opcode={}, status={}, opaque={})",
-                                  session_->log_prefix_,
-                                  opcode,
-                                  resp.status(),
-                                  resp.opaque());
+                                last_error_message_ =
+                                  fmt::format("kv_engine node does not have configuration propagated yet (opcode={}, status={}, opaque={})",
+                                              opcode,
+                                              resp.status(),
+                                              resp.opaque());
+                                CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::network::configuration_not_available);
                             } else if (resp.status() == key_value_status_code::no_bucket && !session_->bucket_name_) {
                                 // bucket-less session, but the server wants bucket
@@ -486,16 +498,17 @@ class mcbp_session_impl
                                   session_->connection_endpoints_.remote_address, session_->connection_endpoints_.remote.port(), 0));
                                 complete({});
                             } else {
-                                CB_LOG_WARNING("{} unexpected message status during bootstrap: {} (opaque={}, {:n})",
-                                               session_->log_prefix_,
-                                               resp.error_message(),
-                                               resp.opaque(),
-                                               spdlog::to_hex(resp.header()));
+                                last_error_message_ = fmt::format("unexpected message status during bootstrap: {} (opaque={}, {:n})",
+                                                                  resp.error_message(),
+                                                                  resp.opaque(),
+                                                                  spdlog::to_hex(resp.header()));
+                                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::network::protocol_error);
                             }
                         } break;
                         default:
-                            CB_LOG_WARNING("{} unexpected message during bootstrap: {}", session_->log_prefix_, opcode);
+                            last_error_message_ = fmt::format("unexpected message during bootstrap: {}", opcode);
+                            CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
                             return complete(errc::network::protocol_error);
                     }
                     break;
@@ -796,6 +809,20 @@ class mcbp_session_impl
 
     void ping(std::shared_ptr<diag::ping_reporter> handler, std::optional<std::chrono::milliseconds> timeout)
     {
+        if (!bootstrapped_) {
+            handler->report({
+              service_type::key_value,
+              id_,
+              std::chrono::microseconds(0),
+              remote_address(),
+              local_address(),
+              diag::ping_state::error,
+              bucket_name_,
+              last_bootstrap_error_message_.has_value() ? last_bootstrap_error_message_.value()
+                                                        : "Bootstrap incomplete, cannot perform ping.",
+            });
+            return;
+        }
         protocol::client_request<protocol::mcbp_noop_request_body> req;
         req.opaque(next_opaque());
         write_and_subscribe(req.opaque(),
@@ -871,6 +898,9 @@ class mcbp_session_impl
             return;
         }
         bootstrapped_ = false;
+        if (bootstrap_handler_) {
+            last_bootstrap_error_message_ = std::move(bootstrap_handler_)->last_error_message();
+        }
         bootstrap_handler_ = nullptr;
         state_ = diag::endpoint_state::connecting;
         if (stream_->is_open()) {
@@ -920,6 +950,11 @@ class mcbp_session_impl
         return stopped_;
     }
 
+    [[nodiscard]] bool is_bootstrapped() const
+    {
+        return bootstrapped_;
+    }
+
     void on_stop(utils::movable_function<void()> handler)
     {
         on_stop_handler_ = std::move(handler);
@@ -1639,6 +1674,7 @@ class mcbp_session_impl
     std::optional<std::string> bucket_name_;
     mcbp_parser parser_;
     std::shared_ptr<bootstrap_handler> bootstrap_handler_{ nullptr };
+    std::optional<std::string> last_bootstrap_error_message_;
     std::shared_ptr<message_handler> handler_{ nullptr };
     utils::movable_function<void(std::error_code, const topology::configuration&)> bootstrap_callback_{};
     std::mutex command_handlers_mutex_{};
@@ -1739,6 +1775,12 @@ mcbp_session::is_stopped() const
     return impl_->is_stopped();
 }
 
+bool
+mcbp_session::is_bootstrapped() const
+{
+    return impl_->is_bootstrapped();
+}
+
 std::uint32_t
 mcbp_session::next_opaque()
 {

package/deps/couchbase-cxx-client/core/io/mcbp_session.hxx

@@ -97,6 +97,7 @@ class mcbp_session
     [[nodiscard]] const std::string& log_prefix() const;
     [[nodiscard]] bool cancel(std::uint32_t opaque, std::error_code ec, retry_reason reason);
     [[nodiscard]] bool is_stopped() const;
+    [[nodiscard]] bool is_bootstrapped() const;
     [[nodiscard]] std::uint32_t next_opaque();
     [[nodiscard]] std::optional<std::uint32_t> get_collection_uid(const std::string& collection_path);
     [[nodiscard]] mcbp_context context() const;

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

@@ -25,6 +25,7 @@
 
 #include <fmt/core.h>
 
+#include <algorithm>
 #include <memory>
 
 namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/meta/features.hxx

@@ -126,3 +126,8 @@
  * Transaction's transaction_operation_failed has a public getter for its final_error
  */
 #define COUCHBASE_CXX_CLIENT_TRANSACTIONS_CAN_FETCH_TO_RAISE 1
+
+/**
+ * Hooks in the transactions core are asynchronous (they have a callback parameter)
+ */
+#define COUCHBASE_CXX_CLIENT_TRANSACTIONS_CORE_ASYNC_HOOKS

package/deps/couchbase-cxx-client/core/operations/document_lookup_in_all_replicas.hxx

@@ -65,123 +65,134 @@ struct lookup_in_all_replicas_request {
     template<typename Core, typename Handler>
     void execute(Core core, Handler handler)
     {
-        core->with_bucket_configuration(
+        core->open_bucket(
           id.bucket(),
           [core, id = id, timeout = timeout, specs = specs, parent_span = parent_span, h = std::forward<Handler>(handler)](
-            std::error_code ec, const topology::configuration& config) mutable {
-              if (!config.capabilities.supports_subdoc_read_replica()) {
-                  ec = errc::common::feature_not_available;
-              }
-
+            std::error_code ec) mutable {
               if (ec) {
                   std::optional<std::string> first_error_path{};
                   std::optional<std::size_t> first_error_index{};
                   return h(response_type{
                     make_subdocument_error_context(make_key_value_error_context(ec, id), ec, first_error_path, first_error_index, false) });
               }
-              using handler_type = utils::movable_function<void(response_type)>;
+              core->with_bucket_configuration(
+                id.bucket(),
+                [core, id = id, timeout = timeout, specs = specs, parent_span = parent_span, h = std::forward<Handler>(h)](
+                  std::error_code ec, const topology::configuration& config) mutable {
+                    if (!config.capabilities.supports_subdoc_read_replica()) {
+                        ec = errc::common::feature_not_available;
+                    }
 
-              struct replica_context {
-                  replica_context(handler_type handler, std::uint32_t expected_responses)
-                    : handler_(std::move(handler))
-                    , expected_responses_(expected_responses)
-                  {
-                  }
+                    if (ec) {
+                        std::optional<std::string> first_error_path{};
+                        std::optional<std::size_t> first_error_index{};
+                        return h(response_type{ make_subdocument_error_context(
+                          make_key_value_error_context(ec, id), ec, first_error_path, first_error_index, false) });
+                    }
+                    using handler_type = utils::movable_function<void(response_type)>;
 
-                  handler_type handler_;
-                  std::uint32_t expected_responses_;
-                  bool done_{ false };
-                  std::mutex mutex_{};
-                  std::vector<lookup_in_all_replicas_response::entry> result_{};
-              };
-              auto ctx = std::make_shared<replica_context>(std::move(h), config.num_replicas.value_or(0U) + 1U);
+                    struct replica_context {
+                        replica_context(handler_type handler, std::uint32_t expected_responses)
+                          : handler_(std::move(handler))
+                          , expected_responses_(expected_responses)
+                        {
+                        }
 
-              for (std::size_t idx = 1U; idx <= config.num_replicas.value_or(0U); ++idx) {
-                  document_id replica_id{ id };
-                  replica_id.node_index(idx);
-                  core->execute(impl::lookup_in_replica_request{ std::move(replica_id), specs, timeout, parent_span },
-                                [ctx](impl::lookup_in_replica_response&& resp) {
-                                    handler_type local_handler{};
-                                    {
-                                        std::scoped_lock lock(ctx->mutex_);
-                                        if (ctx->done_) {
-                                            return;
-                                        }
-                                        --ctx->expected_responses_;
-                                        if (resp.ctx.ec()) {
-                                            if (ctx->expected_responses_ > 0) {
-                                                // just ignore the response
-                                                return;
-                                            }
-                                        } else {
-                                            lookup_in_all_replicas_response::entry top_entry{};
-                                            top_entry.cas = resp.cas;
-                                            top_entry.deleted = resp.deleted;
-                                            top_entry.is_replica = true;
-                                            for (auto& field : resp.fields) {
-                                                lookup_in_all_replicas_response::entry::lookup_in_entry lookup_in_entry{};
-                                                lookup_in_entry.path = field.path;
-                                                lookup_in_entry.value = field.value;
-                                                lookup_in_entry.status = field.status;
-                                                lookup_in_entry.ec = field.ec;
-                                                lookup_in_entry.exists = field.exists;
-                                                lookup_in_entry.original_index = field.original_index;
-                                                lookup_in_entry.opcode = field.opcode;
-                                                top_entry.fields.emplace_back(lookup_in_entry);
-                                            }
-                                            ctx->result_.emplace_back(lookup_in_all_replicas_response::entry{ top_entry });
-                                        }
-                                        if (ctx->expected_responses_ == 0) {
-                                            ctx->done_ = true;
-                                            std::swap(local_handler, ctx->handler_);
-                                        }
-                                    }
-                                    if (local_handler) {
-                                        return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
-                                    }
-                                });
-              }
+                        handler_type handler_;
+                        std::uint32_t expected_responses_;
+                        bool done_{ false };
+                        std::mutex mutex_{};
+                        std::vector<lookup_in_all_replicas_response::entry> result_{};
+                    };
+                    auto ctx = std::make_shared<replica_context>(std::move(h), config.num_replicas.value_or(0U) + 1U);
+
+                    for (std::size_t idx = 1U; idx <= config.num_replicas.value_or(0U); ++idx) {
+                        document_id replica_id{ id };
+                        replica_id.node_index(idx);
+                        core->execute(impl::lookup_in_replica_request{ std::move(replica_id), specs, timeout, parent_span },
+                                      [ctx](impl::lookup_in_replica_response&& resp) {
+                                          handler_type local_handler{};
+                                          {
+                                              std::scoped_lock lock(ctx->mutex_);
+                                              if (ctx->done_) {
+                                                  return;
+                                              }
+                                              --ctx->expected_responses_;
+                                              if (resp.ctx.ec()) {
+                                                  if (ctx->expected_responses_ > 0) {
+                                                      // just ignore the response
+                                                      return;
+                                                  }
+                                              } else {
+                                                  lookup_in_all_replicas_response::entry top_entry{};
+                                                  top_entry.cas = resp.cas;
+                                                  top_entry.deleted = resp.deleted;
+                                                  top_entry.is_replica = true;
+                                                  for (auto& field : resp.fields) {
+                                                      lookup_in_all_replicas_response::entry::lookup_in_entry lookup_in_entry{};
+                                                      lookup_in_entry.path = field.path;
+                                                      lookup_in_entry.value = field.value;
+                                                      lookup_in_entry.status = field.status;
+                                                      lookup_in_entry.ec = field.ec;
+                                                      lookup_in_entry.exists = field.exists;
+                                                      lookup_in_entry.original_index = field.original_index;
+                                                      lookup_in_entry.opcode = field.opcode;
+                                                      top_entry.fields.emplace_back(lookup_in_entry);
+                                                  }
+                                                  ctx->result_.emplace_back(lookup_in_all_replicas_response::entry{ top_entry });
+                                              }
+                                              if (ctx->expected_responses_ == 0) {
+                                                  ctx->done_ = true;
+                                                  std::swap(local_handler, ctx->handler_);
+                                              }
+                                          }
+                                          if (local_handler) {
+                                              return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
+                                          }
+                                      });
+                    }
 
-              core->execute(lookup_in_request{ document_id{ id }, {}, {}, false, specs, timeout }, [ctx](lookup_in_response&& resp) {
-                  handler_type local_handler{};
-                  {
-                      std::scoped_lock lock(ctx->mutex_);
-                      if (ctx->done_) {
-                          return;
-                      }
-                      --ctx->expected_responses_;
-                      if (resp.ctx.ec()) {
-                          if (ctx->expected_responses_ > 0) {
-                              // just ignore the response
-                              return;
-                          }
-                      } else {
-                          lookup_in_all_replicas_response::entry top_entry{};
-                          top_entry.cas = resp.cas;
-                          top_entry.deleted = resp.deleted;
-                          top_entry.is_replica = false;
-                          for (auto& field : resp.fields) {
-                              lookup_in_all_replicas_response::entry::lookup_in_entry lookup_in_entry{};
-                              lookup_in_entry.path = field.path;
-                              lookup_in_entry.value = field.value;
-                              lookup_in_entry.status = field.status;
-                              lookup_in_entry.ec = field.ec;
-                              lookup_in_entry.exists = field.exists;
-                              lookup_in_entry.original_index = field.original_index;
-                              lookup_in_entry.opcode = field.opcode;
-                              top_entry.fields.emplace_back(lookup_in_entry);
-                          }
-                          ctx->result_.emplace_back(lookup_in_all_replicas_response::entry{ top_entry });
-                      }
-                      if (ctx->expected_responses_ == 0) {
-                          ctx->done_ = true;
-                          std::swap(local_handler, ctx->handler_);
-                      }
-                  }
-                  if (local_handler) {
-                      return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
-                  }
-              });
+                    core->execute(lookup_in_request{ document_id{ id }, {}, {}, false, specs, timeout }, [ctx](lookup_in_response&& resp) {
+                        handler_type local_handler{};
+                        {
+                            std::scoped_lock lock(ctx->mutex_);
+                            if (ctx->done_) {
+                                return;
+                            }
+                            --ctx->expected_responses_;
+                            if (resp.ctx.ec()) {
+                                if (ctx->expected_responses_ > 0) {
+                                    // just ignore the response
+                                    return;
+                                }
+                            } else {
+                                lookup_in_all_replicas_response::entry top_entry{};
+                                top_entry.cas = resp.cas;
+                                top_entry.deleted = resp.deleted;
+                                top_entry.is_replica = false;
+                                for (auto& field : resp.fields) {
+                                    lookup_in_all_replicas_response::entry::lookup_in_entry lookup_in_entry{};
+                                    lookup_in_entry.path = field.path;
+                                    lookup_in_entry.value = field.value;
+                                    lookup_in_entry.status = field.status;
+                                    lookup_in_entry.ec = field.ec;
+                                    lookup_in_entry.exists = field.exists;
+                                    lookup_in_entry.original_index = field.original_index;
+                                    lookup_in_entry.opcode = field.opcode;
+                                    top_entry.fields.emplace_back(lookup_in_entry);
+                                }
+                                ctx->result_.emplace_back(lookup_in_all_replicas_response::entry{ top_entry });
+                            }
+                            if (ctx->expected_responses_ == 0) {
+                                ctx->done_ = true;
+                                std::swap(local_handler, ctx->handler_);
+                            }
+                        }
+                        if (local_handler) {
+                            return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
+                        }
+                    });
+                });
           });
     }
 };