couchbase 4.4.4 → 4.4.6-dev.1

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

@@ -52,8 +52,8 @@
 #include <asio/io_context.hpp>
 #include <asio/post.hpp>
 #include <asio/ssl/context.hpp>
-#include <fmt/format.h>
 #include <gsl/span>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <algorithm>
 #include <chrono>
@@ -225,8 +225,8 @@ public:
     return {};
   }
 
-  auto direct_re_queue(const std::shared_ptr<mcbp::queue_request>& req,
-                       bool is_retry) -> std::error_code
+  auto direct_re_queue(const std::shared_ptr<mcbp::queue_request>& req, bool is_retry)
+    -> std::error_code
   {
     auto handle_error = [is_retry, req](std::error_code ec) {
       // We only want to log an error on retries if the error isn't cancelled.
@@ -281,8 +281,8 @@ public:
     return {};
   }
 
-  auto backoff_and_retry(const std::shared_ptr<mcbp::queue_request>& request,
-                         retry_reason reason) -> bool
+  auto backoff_and_retry(const std::shared_ptr<mcbp::queue_request>& request, retry_reason reason)
+    -> bool
   {
     auto action = retry_orchestrator::should_retry(request, reason);
     auto retried = action.need_to_retry();
@@ -314,8 +314,8 @@ public:
     return {};
   }
 
-  [[nodiscard]] auto server_by_vbucket(std::uint16_t vbucket,
-                                       std::size_t node_index) -> std::optional<std::size_t>
+  [[nodiscard]] auto server_by_vbucket(std::uint16_t vbucket, std::size_t node_index)
+    -> std::optional<std::size_t>
   {
     const std::scoped_lock lock(config_mutex_);
     if (config_) {
@@ -356,7 +356,7 @@ public:
   void restart_sessions()
   {
     const std::scoped_lock lock(config_mutex_, sessions_mutex_);
-    if (!config_.has_value()) {
+    if (!config_) {
       return;
     }
 
@@ -512,37 +512,38 @@ public:
   }
 
   void with_configuration(
-    utils::movable_function<void(std::error_code, topology::configuration)>&& handler)
+    utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
+      handler)
   {
     if (closed_) {
-      return handler(errc::network::configuration_not_available, topology::configuration{});
+      return handler(errc::network::configuration_not_available, nullptr);
     }
     if (configured_) {
-      std::optional<topology::configuration> config{};
+      std::shared_ptr<topology::configuration> config{};
       {
         const std::scoped_lock config_lock(config_mutex_);
         config = config_;
       }
       if (config) {
-        return handler({}, config.value());
+        return handler({}, config);
       }
-      return handler(errc::network::configuration_not_available, topology::configuration{});
+      return handler(errc::network::configuration_not_available, nullptr);
     }
     const std::scoped_lock lock(deferred_commands_mutex_);
     deferred_commands_.emplace([self = shared_from_this(), handler = std::move(handler)]() mutable {
       if (self->closed_ || !self->configured_) {
-        return handler(errc::network::configuration_not_available, topology::configuration{});
+        return handler(errc::network::configuration_not_available, nullptr);
       }
 
-      std::optional<topology::configuration> config{};
+      std::shared_ptr<topology::configuration> config{};
       {
         const std::scoped_lock config_lock(self->config_mutex_);
         config = self->config_;
       }
       if (config) {
-        return handler({}, config.value());
+        return handler({}, std::move(config));
       }
-      return handler(errc::network::configuration_not_available, topology::configuration{});
+      return handler(errc::network::configuration_not_available, nullptr);
     });
   }
 
@@ -715,7 +716,7 @@ public:
                      config_->rev_str(),
                      config.rev_str());
         return;
-      } else if (config_ < config) {
+      } else if (*config_ < config) {
         CB_LOG_DEBUG("{} will update the configuration old={} -> new={}",
                      log_prefix_,
                      config_->rev_str(),
@@ -742,7 +743,7 @@ public:
         added = config.nodes;
       }
       config_.reset();
-      config_ = config;
+      config_ = std::make_shared<topology::configuration>(config);
       configured_ = true;
 
       {
@@ -964,7 +965,7 @@ private:
   std::atomic_bool closed_{ false };
   std::atomic_bool configured_{ false };
 
-  std::optional<topology::configuration> config_{};
+  std::shared_ptr<topology::configuration> config_{};
   mutable std::mutex config_mutex_{};
 
   std::vector<std::shared_ptr<config_listener>> config_listeners_{};
@@ -1081,7 +1082,8 @@ bucket::bootstrap(utils::movable_function<void(std::error_code, topology::config
 
 void
 bucket::with_configuration(
-  utils::movable_function<void(std::error_code, topology::configuration)>&& handler)
+  utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
+    handler)
 {
   return impl_->with_configuration(std::move(handler));
 }
@@ -1141,8 +1143,8 @@ bucket::direct_dispatch(std::shared_ptr<mcbp::queue_request> req) -> std::error_
 }
 
 auto
-bucket::direct_re_queue(const std::shared_ptr<mcbp::queue_request>& req,
-                        bool is_retry) -> std::error_code
+bucket::direct_re_queue(const std::shared_ptr<mcbp::queue_request>& req, bool is_retry)
+  -> std::error_code
 {
   return impl_->direct_re_queue(req, is_retry);
 }

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

@@ -189,7 +189,8 @@ public:
   void update_config(topology::configuration config) override;
   void bootstrap(utils::movable_function<void(std::error_code, topology::configuration)>&& handler);
   void with_configuration(
-    utils::movable_function<void(std::error_code, topology::configuration)>&& handler);
+    utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
+      handler);
 
   void on_configuration_update(std::shared_ptr<config_listener> handler);
   void close();

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

@@ -164,12 +164,10 @@
 #include <asio/executor_work_guard.hpp>
 #include <asio/post.hpp>
 #include <asio/ssl/verify_mode.hpp>
-#include <fmt/core.h>
 
 #include <atomic>
 #include <chrono>
 #include <cstring>
-#include <fmt/format.h>
 #include <map>
 #include <memory>
 #include <mutex>
@@ -580,12 +578,12 @@ public:
         return self->with_bucket_configuration(
           bucket_name,
           [self, cap, request = std::move(request), handler = std::forward<Handler>(handler)](
-            std::error_code ec, const topology::configuration& config) mutable {
+            std::error_code ec, const std::shared_ptr<topology::configuration>& config) mutable {
             if (ec) {
               handler(request.make_response({ ec }, {}));
               return;
             }
-            if (!config.capabilities.has_bucket_capability(cap)) {
+            if (!config->capabilities.has_bucket_capability(cap)) {
               handler(request.make_response({ errc::common::feature_not_available }, {}));
               return;
             }
@@ -982,10 +980,11 @@ public:
 
   void with_bucket_configuration(
     const std::string& bucket_name,
-    utils::movable_function<void(std::error_code, topology::configuration)>&& handler)
+    utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
+      handler)
   {
     if (stopped_) {
-      return handler(errc::network::cluster_closed, {});
+      return handler(errc::network::cluster_closed, nullptr);
     }
     if (auto bucket = find_bucket_by_name(bucket_name); bucket != nullptr) {
       return bucket->with_configuration(std::move(handler));
@@ -994,13 +993,13 @@ public:
       bucket_name,
       [self = shared_from_this(), bucket_name, handler = std::move(handler)](auto ec) mutable {
         if (ec) {
-          return handler(ec, {});
+          return handler(ec, nullptr);
         }
 
         if (auto bucket = self->find_bucket_by_name(bucket_name); bucket != nullptr) {
           return bucket->with_configuration(std::move(handler));
         }
-        return handler(errc::common::bucket_not_found, {});
+        return handler(errc::common::bucket_not_found, nullptr);
       });
   }
 
@@ -1328,7 +1327,8 @@ cluster::ping(std::optional<std::string> report_id,
 void
 cluster::with_bucket_configuration(
   const std::string& bucket_name,
-  utils::movable_function<void(std::error_code, topology::configuration)>&& handler) const
+  utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
+    handler) const
 {
   if (impl_) {
     impl_->with_bucket_configuration(bucket_name, std::move(handler));

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

@@ -77,7 +77,8 @@ public:
 
   void with_bucket_configuration(
     const std::string& bucket_name,
-    utils::movable_function<void(std::error_code, topology::configuration)>&& handler) const;
+    utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
+      handler) const;
 
   void execute(o::analytics_request request, mf<void(o::analytics_response)>&& handler) const;
   void execute(o::append_request request, mf<void(o::append_response)>&& handler) const;

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

@@ -15,7 +15,7 @@
 
 #include "cluster_agent_config.hxx"
 
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <string>
 

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

@@ -42,7 +42,7 @@
 #include <asio/error.hpp>
 #include <asio/io_context.hpp>
 #include <asio/steady_timer.hpp>
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 #include <tao/pegtl/parse_error.hpp>
 #include <tl/expected.hpp>

package/deps/couchbase-cxx-client/core/columnar/agent_config.cxx

@@ -17,8 +17,8 @@
 
 #include "agent_config.hxx"
 
-#include <fmt/chrono.h>
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/chrono.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <string>
 

package/deps/couchbase-cxx-client/core/columnar/error.hxx

@@ -18,7 +18,6 @@
 #pragma once
 
 #include <cstdint>
-#include <map>
 #include <memory>
 #include <string>
 #include <system_error>

package/deps/couchbase-cxx-client/core/columnar/query_component.cxx

@@ -33,9 +33,9 @@
 
 #include <asio/io_context.hpp>
 #include <asio/steady_timer.hpp>
-#include <fmt/chrono.h>
-#include <fmt/format.h>
 #include <gsl/util>
+#include <spdlog/fmt/bundled/chrono.h>
+#include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 #include <tl/expected.hpp>
 

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

@@ -20,7 +20,7 @@
 #include "cluster_options.hxx"
 #include "core/config_profile.hxx"
 
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <chrono>
 #include <mutex>

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

@@ -15,7 +15,7 @@
 
 #include "core_sdk_shim.hxx"
 
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <string>
 

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

@@ -39,11 +39,11 @@
 #include <asio/error.hpp>
 #include <asio/io_context.hpp>
 #include <asio/steady_timer.hpp>
-#include <fmt/format.h>
 #include <gsl/span>
 #include <gsl/span_ext>
 #include <gsl/util>
 #include <snappy.h>
+#include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 #include <tl/expected.hpp>
 

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

@@ -19,7 +19,7 @@
 
 #include "design_document_namespace.hxx"
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 template<>
 struct fmt::formatter<couchbase::core::design_document_namespace> {

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

@@ -19,7 +19,7 @@
 
 #include "diagnostics.hxx"
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 template<>
 struct fmt::formatter<couchbase::core::diag::cluster_state> {

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

@@ -20,7 +20,7 @@
 #include "core/utils/binary.hxx"
 #include "core/utils/unsigned_leb128.hxx"
 
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <algorithm>
 #include <cstddef>

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

@@ -19,7 +19,7 @@
 
 #include "document_id.hxx"
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 template<>
 struct fmt::formatter<couchbase::core::document_id> {

package/deps/couchbase-cxx-client/core/error_context/analytics_json.hxx

@@ -21,11 +21,13 @@
 #include "core/impl/retry_reason.hxx"
 
 #include <couchbase/error_codes.hxx>
-#include <couchbase/fmt/retry_reason.hxx>
 
+#include <spdlog/fmt/bundled/core.h>
 #include <tao/json/forward.hpp>
 #include <tao/json/value.hpp>
 
+#include <couchbase/fmt/retry_reason.hxx>
+
 namespace tao::json
 {
 template<>

package/deps/couchbase-cxx-client/core/error_context/key_value_json.hxx

@@ -22,7 +22,7 @@
 
 #include "key_value_error_context.hxx"
 
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/format.h>
 #include <tao/json/forward.hpp>
 
 namespace tao::json

package/deps/couchbase-cxx-client/core/error_context/query_public_json.hxx

@@ -21,7 +21,7 @@
 
 #include <couchbase/fmt/retry_reason.hxx>
 
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/format.h>
 #include <tao/json/forward.hpp>
 
 namespace tao::json

package/deps/couchbase-cxx-client/core/error_context/subdocument_json.hxx

@@ -21,7 +21,7 @@
 
 #include <couchbase/fmt/retry_reason.hxx>
 
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/format.h>
 #include <tao/json/forward.hpp>
 
 #include "key_value_json.hxx"

package/deps/couchbase-cxx-client/core/fmt/key_value_error_map_attribute.hxx

@@ -19,7 +19,7 @@
 
 #include "core/error_context/key_value_error_map_attribute.hxx"
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 template<>
 struct fmt::formatter<couchbase::core::key_value_error_map_attribute> {

package/deps/couchbase-cxx-client/core/fmt/key_value_extended_error_info.hxx

@@ -19,7 +19,7 @@
 
 #include "core/error_context/key_value_extended_error_info.hxx"
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 /**
  * Helper for fmtlib to format @ref couchbase::key_value_extended_error_info objects.

package/deps/couchbase-cxx-client/core/fmt/key_value_status_code.hxx

@@ -19,7 +19,7 @@
 
 #include "core/error_context/key_value_status_code.hxx"
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 /**
  * Helper for fmtlib to format @ref couchbase::core::key_value_status_code objects.

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

@@ -25,7 +25,7 @@
 #include <couchbase/build_config.hxx>
 
 #include <asio/error.hpp>
-#include <fmt/chrono.h>
+#include <spdlog/fmt/bundled/chrono.h>
 #include <tl/expected.hpp>
 
 #include <memory>
@@ -269,8 +269,8 @@ public:
   ~pending_buffered_http_operation() override = default;
   pending_buffered_http_operation(const pending_buffered_http_operation&) = delete;
   pending_buffered_http_operation(pending_buffered_http_operation&&) = delete;
-  auto operator=(const pending_buffered_http_operation&) -> pending_buffered_http_operation =
-                                                              delete;
+  auto operator=(const pending_buffered_http_operation&)
+    -> pending_buffered_http_operation = delete;
   auto operator=(pending_buffered_http_operation&&) -> pending_buffered_http_operation = delete;
 
   void start(buffered_free_form_http_request_callback&& callback)

package/deps/couchbase-cxx-client/core/impl/best_effort_retry_strategy.cxx

@@ -21,7 +21,7 @@
 #include <couchbase/retry_reason.hxx>
 #include <couchbase/retry_request.hxx>
 
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <algorithm>
 #include <chrono>

package/deps/couchbase-cxx-client/core/impl/binary_collection.cxx

@@ -96,6 +96,7 @@ public:
           std::move(data),
           {},
           {},
+          options.cas,
           options.durability_level,
           options.timeout,
           { options.retry_strategy },
@@ -114,6 +115,7 @@ public:
       std::move(data),
       {},
       {},
+      options.cas,
       durability_level::none,
       options.timeout,
       { options.retry_strategy },
@@ -165,6 +167,7 @@ public:
           std::move(data),
           {},
           {},
+          options.cas,
           options.durability_level,
           options.timeout,
           { options.retry_strategy },
@@ -183,6 +186,7 @@ public:
       std::move(data),
       {},
       {},
+      options.cas,
       durability_level::none,
       options.timeout,
       { options.retry_strategy },

package/deps/couchbase-cxx-client/core/impl/cluster.cxx

@@ -79,8 +79,8 @@ cluster::cluster(std::shared_ptr<cluster_impl> impl)
 namespace
 {
 auto
-options_to_origin(const std::string& connection_string,
-                  const couchbase::cluster_options& options) -> core::origin
+options_to_origin(const std::string& connection_string, const couchbase::cluster_options& options)
+  -> core::origin
 {
   auto opts = options.build();
 
@@ -215,12 +215,27 @@ fork_event_to_asio(fork_event event) -> asio::execution_context::fork_event
 class cluster_impl : public std::enable_shared_from_this<cluster_impl>
 {
 public:
-  cluster_impl() = default;
+  cluster_impl(std::string connection_string, cluster_options options)
+    : connection_string_{ std::move(connection_string) }
+    , options_{ std::move(options) }
+  {
+  }
+
   cluster_impl(const cluster_impl&) = delete;
   cluster_impl(cluster_impl&&) = delete;
   auto operator=(const cluster_impl&) = delete;
   auto operator=(cluster_impl&&) = delete;
 
+  [[nodiscard]] auto connection_string() const -> const std::string&
+  {
+    return connection_string_;
+  }
+
+  [[nodiscard]] auto options() const -> const cluster_options&
+  {
+    return options_;
+  }
+
   ~cluster_impl()
   {
     std::promise<void> barrier;
@@ -238,12 +253,10 @@ public:
     future.get();
   }
 
-  void open(const std::string& connection_string,
-            const cluster_options& options,
-            cluster_connect_handler&& handler)
+  void open(cluster_connect_handler&& handler)
   {
     core_.open(
-      options_to_origin(connection_string, options),
+      options_to_origin(connection_string_, options_),
       [impl = shared_from_this(), handler = std::move(handler)](std::error_code ec) mutable {
         if (ec) {
           return handler(ec, {});
@@ -350,7 +363,7 @@ public:
     }
     io_.notify_fork(fork_event_to_asio(event));
 
-    if (transactions_) {
+    if (event != fork_event::child && transactions_) {
       transactions_->notify_fork(event);
     }
   }
@@ -393,6 +406,8 @@ private:
     }
   }
 
+  std::string connection_string_;
+  cluster_options options_;
   asio::io_context io_{ ASIO_CONCURRENCY_HINT_SAFE };
   core::cluster core_{ io_ };
   std::shared_ptr<core::transactions::transactions> transactions_{ nullptr };
@@ -423,8 +438,8 @@ cluster::query(std::string statement, const query_options& options, query_handle
 }
 
 auto
-cluster::query(std::string statement,
-               const query_options& options) const -> std::future<std::pair<error, query_result>>
+cluster::query(std::string statement, const query_options& options) const
+  -> std::future<std::pair<error, query_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, query_result>>>();
   auto future = barrier->get_future();
@@ -500,9 +515,8 @@ cluster::search(std::string index_name,
 }
 
 auto
-cluster::search(std::string index_name,
-                search_request request,
-                const search_options& options) const -> std::future<std::pair<error, search_result>>
+cluster::search(std::string index_name, search_request request, const search_options& options) const
+  -> std::future<std::pair<error, search_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, search_result>>>();
   search(
@@ -513,8 +527,8 @@ cluster::search(std::string index_name,
 }
 
 auto
-cluster::connect(const std::string& connection_string,
-                 const cluster_options& options) -> std::future<std::pair<error, cluster>>
+cluster::connect(const std::string& connection_string, const cluster_options& options)
+  -> std::future<std::pair<error, cluster>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, cluster>>>();
   auto future = barrier->get_future();
@@ -535,8 +549,8 @@ cluster::connect(const std::string& connection_string,
     auto barrier = std::make_shared<std::promise<std::pair<error, cluster>>>();
     auto future = barrier->get_future();
     {
-      auto impl = std::make_shared<cluster_impl>();
-      impl->open(connection_string, options, [barrier](auto err, auto c) {
+      auto impl = std::make_shared<cluster_impl>(connection_string, options);
+      impl->open([barrier](auto err, auto c) {
         barrier->set_value({ std::move(err), std::move(c) });
       });
     }
@@ -552,7 +566,30 @@ cluster::notify_fork(fork_event event) -> void
   if (!impl_) {
     return;
   }
-  return impl_->notify_fork(event);
+  impl_->notify_fork(event);
+  if (event != fork_event::child) {
+    return;
+  }
+
+  auto new_impl = std::make_shared<cluster_impl>(impl_->connection_string(), impl_->options());
+  impl_.reset();
+
+  {
+    auto barrier = std::make_shared<std::promise<void>>();
+    auto future = barrier->get_future();
+
+    new_impl->open([this, barrier, new_impl](const auto& err, const auto& /* c */) {
+      if (err.ec()) {
+        // TODO(SA): we should fall to background reconnect loop similar to Columnar build
+        CB_LOG_ERROR("Unable to reconnect instance after fork: {}", err.ec().message());
+        return;
+      }
+      impl_ = new_impl;
+      barrier->set_value();
+    });
+
+    future.get();
+  }
 }
 
 void