couchbase 4.2.8 → 4.2.10

package/deps/couchbase-cxx-client/cmake/CompilerWarnings.cmake

@@ -67,9 +67,13 @@ function(set_project_warnings project_name)
       -Wuseless-cast # warn if you perform a cast to the same type
       -Wdeprecated-declarations # warn if [[deprecated]] elements being used
   )
-  set(CLANG_WARNINGS ${COMMON_WARNINGS} -Wshadow # warn the user if a variable declaration shadows one from a parent
-                                                 # context
-  )
+
+  set(CLANG_WARNINGS ${COMMON_WARNINGS})
+  if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS_EQUAL "17.0.0")
+    set(CLANG_WARNINGS ${CLANG_WARNINGS} -Wshadow # warn the user if a variable declaration shadows one from a parent
+                                                  # context
+    )
+  endif()
 
   if(MSVC)
     set(PROJECT_WARNINGS ${MSVC_WARNINGS})

package/deps/couchbase-cxx-client/cmake/OpenSSL.cmake

@@ -54,6 +54,7 @@ elseif(COUCHBASE_CXX_CLIENT_STATIC_BORINGSSL)
       )
     endif()
   endif()
+  declare_system_library(ssl)
   add_library(OpenSSL::SSL ALIAS ssl)
   add_library(OpenSSL::Crypto ALIAS ssl)
 else()

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

@@ -30,7 +30,7 @@ class retry_strategy;
 namespace couchbase::core
 {
 struct agent_config {
-    core_sdk_shim shim{}; // TODO: remove once refactoring will be finished.
+    core_sdk_shim shim; // TODO: remove once refactoring will be finished.
 
     std::string bucket_name{};
     std::string user_agent{};

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

@@ -215,5 +215,4 @@ agent_group::diagnostics(diagnostics_options options) -> tl::expected<diagnostic
 {
     return impl_->diagnostics(options);
 }
-
 } // namespace couchbase::core

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

@@ -36,6 +36,11 @@ namespace asio
 class io_context;
 } // namespace asio
 
+namespace couchbase
+{
+class cluster;
+} // namespace couchbase
+
 namespace couchbase::core
 {
 class agent_group_impl;
@@ -76,4 +81,8 @@ class agent_group
   private:
     std::shared_ptr<agent_group_impl> impl_;
 };
+
+// FIXME: temporary solution for the core API migration. FIT performer needs to access core for KV range APIs
+auto
+make_agent_group(couchbase::cluster public_api_cluster) -> agent_group;
 } // namespace couchbase::core

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

@@ -32,7 +32,7 @@ class retry_strategy;
 namespace couchbase::core
 {
 struct agent_group_config {
-    core_sdk_shim shim{}; // TODO: remove once refactoring will be finished.
+    core_sdk_shim shim; // TODO: remove once refactoring will be finished.
 
     std::string user_agent{};
     std::shared_ptr<retry_strategy> default_retry_strategy{ make_best_effort_retry_strategy() };

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

@@ -20,6 +20,7 @@
 #include "collection_id_cache_entry.hxx"
 #include "core/mcbp/big_endian.hxx"
 #include "core/mcbp/codec.hxx"
+#include "couchbase/bucket.hxx"
 #include "dispatcher.hxx"
 #include "impl/bootstrap_state_listener.hxx"
 #include "mcbp/operation_queue.hxx"
@@ -27,6 +28,7 @@
 #include "mcbp/queue_response.hxx"
 #include "origin.hxx"
 #include "ping_collector.hxx"
+#include "protocol/cmd_get_cluster_config.hxx"
 #include "retry_orchestrator.hxx"
 
 #include <couchbase/metrics/meter.hxx>
@@ -66,6 +68,10 @@ class bucket_impl
       , codec_{ { known_features_.begin(), known_features_.end() } }
       , ctx_{ ctx }
       , tls_{ tls }
+      , heartbeat_timer_(ctx_)
+      , heartbeat_interval_{ origin_.options().config_poll_floor > origin_.options().config_poll_interval
+                               ? origin_.options().config_poll_floor
+                               : origin_.options().config_poll_interval }
     {
     }
 
@@ -91,12 +97,12 @@ class bucket_impl
             return req->try_callback(resp, req->idempotent() ? errc::common::unambiguous_timeout : errc::common::ambiguous_timeout);
         }
         if (ec == errc::common::request_canceled) {
-            if (reason == retry_reason::do_not_retry) {
+            if (!req->idempotent() && !allows_non_idempotent_retry(reason)) {
                 // TODO: fix tracing
                 // self->span_->add_tag(tracing::attributes::orphan, "canceled");
                 return req->try_callback(resp, ec);
             }
-            backoff_and_retry(req, retry_reason::node_not_available);
+            backoff_and_retry(req, reason == retry_reason::do_not_retry ? retry_reason::node_not_available : reason);
             return;
         }
         key_value_status_code status{ key_value_status_code::unknown };
@@ -196,7 +202,7 @@ class bucket_impl
 
         auto session = route_request(req);
         if (!session || !session->has_config()) {
-            return defer_command([self = shared_from_this(), req]() { self->direct_dispatch(std::move(req)); });
+            return defer_command([self = shared_from_this(), req]() { self->direct_dispatch(req); });
         }
         if (session->is_stopped()) {
             if (backoff_and_retry(req, retry_reason::node_not_available)) {
@@ -420,6 +426,7 @@ class bucket_impl
                 }
                 self->update_config(cfg);
                 self->drain_deferred_queue();
+                self->fetch_config({});
             }
             asio::post(asio::bind_executor(self->ctx_, [h = std::move(h), ec, cfg = std::move(cfg)]() mutable { h(ec, cfg); }));
         });
@@ -475,12 +482,52 @@ class bucket_impl
         }
     }
 
+    void fetch_config(std::error_code ec)
+    {
+        if (ec == asio::error::operation_aborted || closed_) {
+            return;
+        }
+        if (heartbeat_timer_.expiry() > std::chrono::steady_clock::now()) {
+            return;
+        }
+
+        std::optional<io::mcbp_session> session{};
+        {
+            std::scoped_lock lock(sessions_mutex_);
+
+            std::size_t start = heartbeat_next_index_.fetch_add(1);
+            std::size_t i = start;
+            do {
+                auto ptr = sessions_.find(i % sessions_.size());
+                if (ptr != sessions_.end() && ptr->second.supports_gcccp()) {
+                    session = ptr->second;
+                }
+                i = heartbeat_next_index_.fetch_add(1);
+            } while (start % sessions_.size() != i % sessions_.size());
+        }
+        if (session) {
+            protocol::client_request<protocol::get_cluster_config_request_body> req;
+            req.opaque(session->next_opaque());
+            session->write_and_flush(req.data());
+        } else {
+            CB_LOG_WARNING(R"({} unable to find session with GCCCP support, retry in {})", log_prefix_, heartbeat_interval_);
+        }
+        heartbeat_timer_.expires_after(heartbeat_interval_);
+        return heartbeat_timer_.async_wait([self = shared_from_this()](std::error_code e) {
+            if (e == asio::error::operation_aborted) {
+                return;
+            }
+            self->fetch_config(e);
+        });
+    }
+
     void close()
     {
-        if (closed_) {
+        if (bool expected_state{ false }; !closed_.compare_exchange_strong(expected_state, true)) {
             return;
         }
-        closed_ = true;
+
+        heartbeat_timer_.cancel();
 
         drain_deferred_queue();
 
@@ -532,6 +579,7 @@ class bucket_impl
     {
         std::vector<topology::configuration::node> added{};
         std::vector<topology::configuration::node> removed{};
+        bool sequence_changed = false;
         {
             std::scoped_lock lock(config_mutex_);
             if (!config_) {
@@ -553,9 +601,21 @@ class bucket_impl
             if (config_) {
                 diff_nodes(config_->nodes, config.nodes, added);
                 diff_nodes(config.nodes, config_->nodes, removed);
+                if (added.empty() && removed.empty() && config.nodes.size() == config_->nodes.size()) {
+                    for (std::size_t i = 0; i < config.nodes.size(); ++i) {
+                        if (config.nodes[i] != config_->nodes[i]) {
+                            sequence_changed = true;
+                            break;
+                        }
+                    }
+                } else {
+                    sequence_changed = true;
+                }
             } else {
+                sequence_changed = true;
                 added = config.nodes;
             }
+            config_.reset();
             config_ = config;
             configured_ = true;
 
@@ -566,7 +626,7 @@ class bucket_impl
                 }
             }
         }
-        if (!added.empty() || !removed.empty()) {
+        if (!added.empty() || !removed.empty() || sequence_changed) {
             std::scoped_lock lock(sessions_mutex_);
             std::map<size_t, io::mcbp_session> new_sessions{};
 
@@ -715,7 +775,7 @@ class bucket_impl
         }
     }
 
-    void ping(std::shared_ptr<diag::ping_collector> collector)
+    void ping(std::shared_ptr<diag::ping_collector> collector, std::optional<std::chrono::milliseconds> timeout)
     {
         std::map<size_t, io::mcbp_session> sessions;
         {
@@ -723,7 +783,7 @@ class bucket_impl
             sessions = sessions_;
         }
         for (const auto& [index, session] : sessions) {
-            session.ping(collector->build_reporter());
+            session.ping(collector->build_reporter(), timeout);
         }
     }
 
@@ -759,6 +819,10 @@ class bucket_impl
     asio::io_context& ctx_;
     asio::ssl::context& tls_;
 
+    asio::steady_timer heartbeat_timer_;
+    std::chrono::milliseconds heartbeat_interval_;
+    std::atomic_size_t heartbeat_next_index_{ 0 };
+
     std::atomic_bool closed_{ false };
     std::atomic_bool configured_{ false };
 
@@ -811,9 +875,9 @@ bucket::export_diag_info(diag::diagnostics_result& res) const
 }
 
 void
-bucket::ping(std::shared_ptr<diag::ping_collector> collector)
+bucket::ping(std::shared_ptr<diag::ping_collector> collector, std::optional<std::chrono::milliseconds> timeout)
 {
-    return impl_->ping(std::move(collector));
+    return impl_->ping(std::move(collector), std::move(timeout));
 }
 
 void

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

@@ -26,6 +26,8 @@
 #include <asio/post.hpp>
 #include <asio/ssl.hpp>
 
+#include <chrono>
+#include <optional>
 #include <utility>
 #include <vector>
 
@@ -149,7 +151,7 @@ class bucket
         }
         cmd->last_dispatched_from_ = session->local_address();
         cmd->last_dispatched_to_ = session->bootstrap_address();
-        CB_LOG_TRACE(R"([{}] send operation id="{}", key="{}", partition={}, index={}, address="{}", rev={})",
+        CB_LOG_TRACE(R"({} send operation id="{}", key="{}", partition={}, index={}, address="{}", rev={})",
                      session->log_prefix(),
                      cmd->id_,
                      cmd->request.id,
@@ -182,7 +184,7 @@ class bucket
     void on_configuration_update(std::shared_ptr<config_listener> handler);
     void close();
     void export_diag_info(diag::diagnostics_result& res) const;
-    void ping(std::shared_ptr<diag::ping_collector> collector);
+    void ping(std::shared_ptr<diag::ping_collector> collector, std::optional<std::chrono::milliseconds> timeout);
     void defer_command(utils::movable_function<void()> command);
 
     [[nodiscard]] auto name() const -> const std::string&;