couchbase 4.4.4 → 4.4.6-dev.1

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

@@ -90,7 +90,7 @@
 #include <couchbase/unlock_options.hxx>
 #include <couchbase/upsert_options.hxx>
 
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <chrono>
 #include <cstdint>
@@ -884,13 +884,14 @@ public:
         return core_.with_bucket_configuration(
           bucket_name_,
           [this, handler = std::move(handler), orchestrator_opts, core_scan_type](
-            std::error_code ec, const core::topology::configuration& config) mutable {
+            std::error_code ec,
+            const std::shared_ptr<core::topology::configuration>& config) mutable {
             if (ec) {
               return handler(
                 error(ec, "An error occurred when attempting to fetch the bucket configuration."),
                 {});
             }
-            if (!config.capabilities.supports_range_scan()) {
+            if (!config->capabilities.supports_range_scan()) {
               return handler(error(errc::common::feature_not_available,
                                    "This bucket does not support range scan."),
                              {});
@@ -913,7 +914,7 @@ public:
                         bucket_name_)),
                 {});
             }
-            if (!config.vbmap.has_value() || config.vbmap->empty()) {
+            if (!config->vbmap.has_value() || config->vbmap->empty()) {
               CB_LOG_WARNING("Unable to get vbucket map for `{}` - cannot perform scan operation",
                              bucket_name_);
               return handler(error(errc::common::request_canceled,
@@ -923,7 +924,7 @@ public:
 
             auto orchestrator = core::range_scan_orchestrator(core_.io_context(),
                                                               agent.value(),
-                                                              config.vbmap.value(),
+                                                              config->vbmap.value(),
                                                               scope_name_,
                                                               name_,
                                                               core_scan_type,
@@ -993,8 +994,8 @@ collection::get(std::string document_id, const get_options& options, get_handler
 }
 
 auto
-collection::get(std::string document_id,
-                const get_options& options) const -> std::future<std::pair<error, get_result>>
+collection::get(std::string document_id, const get_options& options) const
+  -> std::future<std::pair<error, get_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, get_result>>>();
   auto future = barrier->get_future();
@@ -1296,9 +1297,8 @@ collection::unlock(std::string document_id,
 }
 
 auto
-collection::unlock(std::string document_id,
-                   couchbase::cas cas,
-                   const unlock_options& options) const -> std::future<error>
+collection::unlock(std::string document_id, couchbase::cas cas, const unlock_options& options) const
+  -> std::future<error>
 {
   auto barrier = std::make_shared<std::promise<error>>();
   auto future = barrier->get_future();
@@ -1409,8 +1409,9 @@ collection::scan(const couchbase::scan_type& scan_type,
 }
 
 auto
-collection::scan(const couchbase::scan_type& scan_type, const couchbase::scan_options& options)
-  const -> std::future<std::pair<error, scan_result>>
+collection::scan(const couchbase::scan_type& scan_type,
+                 const couchbase::scan_options& options) const
+  -> std::future<std::pair<error, scan_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, scan_result>>>();
   auto future = barrier->get_future();

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

@@ -17,8 +17,8 @@
 
 #include <couchbase/date_range.hxx>
 
-#include <fmt/chrono.h>
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/chrono.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <chrono>
 #include <ctime>

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

@@ -21,8 +21,8 @@
 
 #include <couchbase/error_codes.hxx>
 
-#include <fmt/chrono.h>
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/chrono.h>
+#include <spdlog/fmt/bundled/core.h>
 #include <tao/json/type.hpp>
 
 #include <chrono>

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

@@ -31,7 +31,7 @@
 #include <asio/bind_executor.hpp>
 #include <asio/io_context.hpp>
 #include <asio/post.hpp>
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <functional>
 #include <memory>

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

@@ -36,14 +36,16 @@
 #include "core/impl/internal_error_context.hxx"
 #include "core/transactions/exceptions.hxx"
 #include "core/transactions/internal/exceptions_internal.hxx"
-#include "core/transactions/internal/exceptions_internal_fmt.hxx"
 
 #include <couchbase/error.hxx>
 #include <couchbase/error_codes.hxx>
 #include <couchbase/error_context.hxx>
 
+#include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
+#include "core/transactions/internal/exceptions_internal_fmt.hxx"
+
 #include <memory>
 #include <optional>
 #include <string>

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

@@ -18,8 +18,8 @@
 #include <couchbase/error_codes.hxx>
 #include <couchbase/expiry.hxx>
 
-#include <fmt/chrono.h>
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/chrono.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <chrono>
 #include <cstdint>

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

@@ -20,8 +20,7 @@
 #include <couchbase/retry_reason.hxx>
 #include <couchbase/retry_request.hxx>
 
-#include <fmt/core.h>
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/format.h>
 
 #include <memory>
 #include <string>

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

@@ -15,14 +15,16 @@
  *   limitations under the License.
  */
 
-#include <couchbase/fmt/cas.hxx>
-#include <couchbase/fmt/retry_reason.hxx>
-
 #include "core/error_context/key_value_error_context.hxx"
+
+#include <spdlog/fmt/bundled/core.h>
+#include <tao/json/to_string.hpp>
+
 #include "core/fmt/key_value_error_map_attribute.hxx"
 #include "core/fmt/key_value_status_code.hxx"
 
-#include <tao/json/to_string.hpp>
+#include <couchbase/fmt/cas.hxx>
+#include <couchbase/fmt/retry_reason.hxx>
 
 namespace couchbase::core
 {

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

@@ -17,7 +17,7 @@
 
 #include <couchbase/numeric_range.hxx>
 
-#include <fmt/chrono.h>
+#include <spdlog/fmt/bundled/chrono.h>
 
 namespace couchbase
 {

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

@@ -96,24 +96,24 @@ number_of_replica_nodes_required(couchbase::replicate_to replicate_to) -> std::u
 }
 
 auto
-validate_replicas(const topology::configuration& config,
+validate_replicas(const std::shared_ptr<topology::configuration>& config,
                   couchbase::persist_to persist_to,
                   couchbase::replicate_to replicate_to) -> std::pair<std::error_code, std::uint32_t>
 {
-  if (config.node_locator != topology::configuration::node_locator_type::vbucket) {
+  if (config->node_locator != topology::configuration::node_locator_type::vbucket) {
     return { errc::common::feature_not_available, {} };
   }
 
   if (touches_replica(persist_to, replicate_to)) {
-    if (!config.num_replicas) {
+    auto number_of_replicas = config->num_replicas;
+    if (!number_of_replicas.has_value()) {
       return { errc::key_value::durability_impossible, {} };
     }
-    auto number_of_replicas = config.num_replicas.value();
     if (number_of_replica_nodes_required(persist_to) > number_of_replicas ||
         number_of_replica_nodes_required(replicate_to) > number_of_replicas) {
       return { errc::key_value::durability_impossible, {} };
     }
-    return { {}, number_of_replicas };
+    return { {}, number_of_replicas.value() };
   }
   return { {}, 0 };
 }
@@ -335,8 +335,8 @@ observe_poll(const cluster& core, std::shared_ptr<observe_context> ctx)
   const std::string bucket_name = ctx->bucket_name();
   core.with_bucket_configuration(
     bucket_name,
-    [core, ctx = std::move(ctx)](std::error_code ec,
-                                 const core::topology::configuration& config) mutable {
+    [core, ctx = std::move(ctx)](
+      std::error_code ec, const std::shared_ptr<core::topology::configuration>& config) mutable {
       if (ec) {
         return ctx->finish(ec);
       }

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

@@ -15,12 +15,13 @@
  *   limitations under the License.
  */
 
-#include <couchbase/fmt/retry_reason.hxx>
-
 #include "core/error_context/query_error_context.hxx"
 
+#include <spdlog/fmt/bundled/core.h>
 #include <tao/json/to_string.hpp>
 
+#include <couchbase/fmt/retry_reason.hxx>
+
 namespace couchbase::core
 {
 auto

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

@@ -25,7 +25,7 @@ namespace couchbase::core::impl
 
 auto
 effective_nodes(const document_id& id,
-                const topology::configuration& config,
+                const std::shared_ptr<topology::configuration>& config,
                 const read_preference& preference,
                 const std::string& preferred_server_group) -> std::vector<readable_node>
 {
@@ -37,12 +37,12 @@ effective_nodes(const document_id& id,
   std::vector<readable_node> available_nodes{};
   std::vector<readable_node> local_nodes{};
 
-  for (std::size_t idx = 0U; idx <= config.num_replicas.value_or(0U); ++idx) {
-    auto [vbid, server] = config.map_key(id.key(), idx);
-    if (server.has_value() && server.value() < config.nodes.size()) {
+  for (std::size_t idx = 0U; idx <= config->num_replicas.value_or(0U); ++idx) {
+    auto [vbid, server] = config->map_key(id.key(), idx);
+    if (server.has_value() && server.value() < config->nodes.size()) {
       const bool is_replica = idx != 0;
       available_nodes.emplace_back(readable_node{ is_replica, idx });
-      if (preferred_server_group == config.nodes[server.value()].server_group) {
+      if (preferred_server_group == config->nodes[server.value()].server_group) {
         local_nodes.emplace_back(readable_node{ is_replica, idx });
       }
     }

package/deps/couchbase-cxx-client/core/impl/replica_utils.hxx

@@ -23,6 +23,7 @@
 
 #include "couchbase/read_preference.hxx"
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -42,7 +43,7 @@ struct readable_node {
  */
 auto
 effective_nodes(const document_id& id,
-                const topology::configuration& config,
+                const std::shared_ptr<topology::configuration>& config,
                 const read_preference& preference,
                 const std::string& preferred_server_group) -> std::vector<readable_node>;
 } // namespace couchbase::core::impl

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

@@ -31,7 +31,7 @@
 #include <couchbase/collection.hxx>
 #include <couchbase/scope.hxx>
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <memory>
 #include <utility>
@@ -136,8 +136,8 @@ scope::query(std::string statement, const query_options& options, query_handler&
 }
 
 auto
-scope::query(std::string statement,
-             const query_options& options) const -> std::future<std::pair<error, query_result>>
+scope::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();
@@ -178,9 +178,8 @@ scope::search(std::string index_name,
 }
 
 auto
-scope::search(std::string index_name,
-              search_request request,
-              const search_options& options) const -> std::future<std::pair<error, search_result>>
+scope::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>>>();
   auto future = barrier->get_future();

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

@@ -29,7 +29,7 @@
 #include <couchbase/match_none_query.hxx>
 #include <utility>
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 namespace couchbase::core::impl
 {

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

@@ -29,7 +29,7 @@
 #include "mcbp_session.hxx"
 
 #include <asio/steady_timer.hpp>
-#include <fmt/chrono.h>
+#include <spdlog/fmt/bundled/chrono.h>
 
 namespace couchbase::core::io
 {

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

@@ -27,10 +27,8 @@
 #include <asio/ip/tcp.hpp>
 #include <asio/read.hpp>
 #include <asio/write.hpp>
-
-#include <fmt/chrono.h>
-
 #include <spdlog/fmt/bin_to_hex.h>
+#include <spdlog/fmt/bundled/chrono.h>
 
 #include <chrono>
 #include <memory>
@@ -98,6 +96,9 @@ public:
                         bytes_transferred1);
         if (ec1) {
           self->udp_deadline_.cancel();
+          if (ec1 == asio::error::operation_aborted) {
+            return;
+          }
           CB_LOG_DEBUG(
             "DNS UDP write operation has got error, retrying with TCP, address=\"{}:{}\", ec={}",
             self->address_.to_string(),
@@ -121,6 +122,9 @@ public:
 
             self->udp_deadline_.cancel();
             if (ec2) {
+              if (ec2 == asio::error::operation_aborted) {
+                return;
+              }
               CB_LOG_DEBUG(
                 "DNS UDP read operation has got error, retrying with TCP, address=\"{}:{}\", ec={}",
                 self->address_.to_string(),
@@ -151,11 +155,12 @@ public:
       if (ec == asio::error::operation_aborted) {
         return;
       }
+      self->udp_.cancel();
       CB_LOG_DEBUG("DNS UDP deadline has been reached, cancelling UDP operation and fall back to "
                    "TCP, address=\"{}:{}\"",
                    self->address_.to_string(),
                    self->port_);
-      self->udp_.cancel();
+      return self->retry_with_tcp();
     });
 
     deadline_.expires_after(total_timeout);
@@ -172,6 +177,7 @@ public:
       if (self->tcp_.is_open()) {
         self->tcp_.cancel();
       }
+      return self->handler_({ errc::common::unambiguous_timeout });
     });
   }
 
@@ -195,6 +201,9 @@ private:
     const asio::ip::tcp::endpoint endpoint(address_, port_);
     tcp_.async_connect(endpoint, [self = shared_from_this()](std::error_code ec1) mutable {
       if (ec1) {
+        if (ec1 == asio::error::operation_aborted) {
+          return;
+        }
         self->deadline_.cancel();
         CB_LOG_DEBUG("DNS TCP connection has been aborted, address=\"{}:{}\", ec={}",
                      self->address_.to_string(),
@@ -220,14 +229,14 @@ private:
                           ec2 ? ec2.message() : "ok",
                           bytes_transferred2);
           if (ec2) {
+            if (ec2 == asio::error::operation_aborted) {
+              return;
+            }
             CB_LOG_DEBUG("DNS TCP write operation has been aborted, address=\"{}:{}\", ec={}",
                          self->address_.to_string(),
                          self->port_,
                          ec2.message());
             self->deadline_.cancel();
-            if (ec2 == asio::error::operation_aborted) {
-              ec2 = errc::common::unambiguous_timeout;
-            }
             return self->handler_({ ec2 });
           }
           asio::async_read(
@@ -244,6 +253,9 @@ private:
                                reinterpret_cast<std::uint8_t*>(&self->recv_buf_size_) +
                                  bytes_transferred3));
               if (ec3) {
+                if (ec3 == asio::error::operation_aborted) {
+                  return;
+                }
                 CB_LOG_DEBUG(
                   "DNS TCP buf size read operation has been aborted, address=\"{}:{}\", ec={}",
                   self->address_.to_string(),
@@ -259,7 +271,6 @@ private:
                 self->tcp_,
                 asio::buffer(self->recv_buf_),
                 [self](std::error_code ec4, std::size_t bytes_transferred4) mutable {
-                  self->deadline_.cancel();
                   CB_LOG_PROTOCOL(
                     "[DNS, TCP, IN] host=\"{}\", port={}, rc={}, bytes_received={}{:a}",
                     self->address_.to_string(),
@@ -269,6 +280,10 @@ private:
                     spdlog::to_hex(self->recv_buf_.data(),
                                    self->recv_buf_.data() + bytes_transferred4));
 
+                  if (ec4 == asio::error::operation_aborted) {
+                    return;
+                  }
+                  self->deadline_.cancel();
                   if (ec4) {
                     CB_LOG_DEBUG(
                       "DNS TCP read operation has been aborted, address=\"{}:{}\", ec={}",

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

@@ -17,8 +17,8 @@
 
 #include "http_parser.hxx"
 
-#include <fmt/core.h>
 #include <llhttp.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <algorithm>
 

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

@@ -19,10 +19,14 @@
 
 #include "core/logger/logger.hxx"
 #include "core/meta/version.hxx"
+#include "core/platform/base64.h"
 #include "core/platform/uuid.h"
 #include "core/service_type_fmt.hxx"
 
 #include <couchbase/error_codes.hxx>
+
+#include <spdlog/fmt/bin_to_hex.h>
+
 #include <utility>
 
 namespace couchbase::core::io

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

@@ -20,7 +20,6 @@
 #include <couchbase/build_config.hxx>
 
 #include "core/diagnostics.hxx"
-#include "core/impl/bootstrap_error.hxx"
 #include "core/origin.hxx"
 #include "core/platform/base64.h"
 #include "core/utils/movable_function.hxx"
@@ -30,9 +29,12 @@
 #include "http_streaming_parser.hxx"
 #include "http_streaming_response.hxx"
 #include "streams.hxx"
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+#include "core/impl/bootstrap_error.hxx"
+#endif
 
 #include <asio.hpp>
-#include <spdlog/fmt/bin_to_hex.h>
+#include <spdlog/fmt/bundled/chrono.h>
 
 #include <memory>
 #include <optional>

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

@@ -36,7 +36,7 @@
 #include <couchbase/error_codes.hxx>
 
 #include <asio/steady_timer.hpp>
-#include <fmt/chrono.h>
+#include <spdlog/fmt/bundled/chrono.h>
 
 #include <functional>
 #include <utility>

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

@@ -15,8 +15,8 @@
 
 #include "key_value_config.hxx"
 
-#include <fmt/chrono.h>
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/chrono.h>
+#include <spdlog/fmt/bundled/core.h>
 
 namespace couchbase::core
 {

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

@@ -322,7 +322,7 @@ create_file_logger(const configuration& logger_settings) -> std::optional<std::s
   if (error) {
     return error;
   }
-  file_logger = std::move(logger);
+  update_file_logger(logger);
   return {};
 }
 

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

@@ -27,7 +27,7 @@
 
 #include "level.hxx"
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 #include <spdlog/fwd.h>
 
 #include <memory>

package/deps/couchbase-cxx-client/core/management/rbac_fmt.hxx

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

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

@@ -23,7 +23,7 @@
 
 #include <couchbase/error_codes.hxx>
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <algorithm>
 #include <iterator>

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

@@ -22,8 +22,8 @@
 
 #include "core/fmt/key_value_status_code.hxx"
 
-#include <fmt/core.h>
 #include <spdlog/fmt/bin_to_hex.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <iterator>
 

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

@@ -206,3 +206,8 @@
  * All options classes in the Public API expose the parent_span option.
  */
 #define COUCHBASE_CXX_CLIENT_PUBLIC_API_PARENT_SPAN 1
+
+/**
+ * core API like with_bucket_configuration() yields shared_ptr instead of configuration copy
+ */
+#define COUCHBASE_CXX_CLIENT_CORE_RETURNS_POINTER_TO_CONFIG 1

package/deps/couchbase-cxx-client/core/meta/version.cxx

@@ -27,12 +27,12 @@
 #include <couchbase/build_version.hxx>
 
 #include <asio/version.hpp>
-#include <fmt/core.h>
 #include <hdr/hdr_histogram_version.h>
 #include <llhttp.h>
 #include <openssl/crypto.h>
 #include <openssl/x509.h>
 #include <snappy-stubs-public.h>
+#include <spdlog/fmt/bundled/core.h>
 #include <spdlog/version.h>
 
 #include <regex>

package/deps/couchbase-cxx-client/core/operations/document_append.cxx

@@ -28,6 +28,7 @@ append_request::encode_to(protocol::client_request<protocol::append_request_body
 {
   encoded.opaque(opaque);
   encoded.partition(partition);
+  encoded.cas(cas);
   encoded.body().id(id);
   encoded.body().content(value);
   return {};

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

@@ -50,6 +50,7 @@ struct append_request {
   std::vector<std::byte> value;
   std::uint16_t partition{};
   std::uint32_t opaque{};
+  couchbase::cas cas{ 0 };
   couchbase::durability_level durability_level{ durability_level::none };
   std::optional<std::chrono::milliseconds> timeout{};
   io::retry_context<false> retries{};

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

@@ -26,7 +26,6 @@
 #include "core/utils/movable_function.hxx"
 #include "couchbase/error_codes.hxx"
 
-#include <functional>
 #include <memory>
 #include <mutex>
 
@@ -65,8 +64,8 @@ struct get_all_replicas_request {
        id = id,
        timeout = timeout,
        read_preference = read_preference,
-       h = std::forward<Handler>(handler)](std::error_code ec,
-                                           const topology::configuration& config) mutable {
+       h = std::forward<Handler>(handler)](
+        std::error_code ec, std::shared_ptr<topology::configuration> config) mutable {
         if (ec) {
           return h(response_type{ make_key_value_error_context(ec, id) });
         }
@@ -82,7 +81,7 @@ struct get_all_replicas_request {
             "Unable to retrieve replicas for \"{}\", server_group={}, number_of_replicas={}",
             id,
             origin.options().server_group,
-            config.num_replicas.value_or(0));
+            config->num_replicas.value_or(0));
           return h(response_type{
             make_key_value_error_context(errc::key_value::document_irretrievable, id) });
         }