couchbase 4.2.9 → 4.2.11-rc.1

package/deps/couchbase-cxx-client/CMakeLists.txt

@@ -121,6 +121,7 @@ set(couchbase_cxx_client_FILES
     core/impl/date_range_facet.cxx
     core/impl/date_range_facet_result.cxx
     core/impl/date_range_query.cxx
+    core/impl/diagnostics.cxx
     core/impl/disjunction_query.cxx
     core/impl/dns_srv_tracker.cxx
     core/impl/doc_id_query.cxx
@@ -173,6 +174,7 @@ set(couchbase_cxx_client_FILES
     core/impl/search_index_manager.cxx
     core/impl/search_meta_data.cxx
     core/impl/search_result.cxx
+    core/impl/search_request.cxx
     core/impl/search_row.cxx
     core/impl/search_row_location.cxx
     core/impl/search_row_locations.cxx
@@ -205,6 +207,8 @@ set(couchbase_cxx_client_FILES
     core/impl/transaction_error_category.cxx
     core/impl/transaction_get_result.cxx
     core/impl/transaction_op_error_category.cxx
+    core/impl/vector_query.cxx
+    core/impl/vector_search.cxx
     core/impl/view_error_category.cxx
     core/impl/wildcard_query.cxx
     core/io/dns_client.cxx

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/bucket.cxx

@@ -28,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>
@@ -67,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 }
     {
     }
 
@@ -421,6 +426,7 @@ class bucket_impl
                 }
                 self->update_config(cfg);
                 self->drain_deferred_queue();
+                self->poll_config({});
             }
             asio::post(asio::bind_executor(self->ctx_, [h = std::move(h), ec, cfg = std::move(cfg)]() mutable { h(ec, cfg); }));
         });
@@ -476,12 +482,61 @@ class bucket_impl
         }
     }
 
-    void close()
+    void fetch_config()
     {
         if (closed_) {
             return;
         }
-        closed_ = true;
+        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_);
+        }
+    }
+
+    void poll_config(std::error_code ec)
+    {
+        if (ec == asio::error::operation_aborted || closed_) {
+            return;
+        }
+        if (heartbeat_timer_.expiry() > std::chrono::steady_clock::now()) {
+            return;
+        }
+
+        fetch_config();
+
+        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->poll_config(e);
+        });
+    }
+
+    void close()
+    {
+        if (bool expected_state{ false }; !closed_.compare_exchange_strong(expected_state, true)) {
+            return;
+        }
+
+        heartbeat_timer_.cancel();
 
         drain_deferred_queue();
 
@@ -773,6 +828,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 };
 
@@ -830,6 +889,12 @@ bucket::ping(std::shared_ptr<diag::ping_collector> collector, std::optional<std:
     return impl_->ping(std::move(collector), std::move(timeout));
 }
 
+void
+bucket::fetch_config()
+{
+    return impl_->fetch_config();
+}
+
 void
 bucket::update_config(topology::configuration config)
 {

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

@@ -151,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,
@@ -177,6 +177,7 @@ class bucket
         });
     }
 
+    void fetch_config();
     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);

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

@@ -114,6 +114,26 @@ class ping_collector_impl
     }
 };
 
+template<typename Request>
+constexpr bool
+is_feature_supported(const Request& /* request */, const configuration_capabilities& /* capabilities */)
+{
+    return true;
+}
+
+constexpr bool
+is_feature_supported(const operations::search_request& request, const configuration_capabilities& capabilities)
+{
+    if (request.scope_name && !capabilities.supports_scoped_search_indexes()) {
+        return false;
+    }
+    if (request.vector_search && !capabilities.supports_vector_search()) {
+        return false;
+    }
+
+    return true;
+}
+
 class cluster_impl : public std::enable_shared_from_this<cluster_impl>
 {
   public:
@@ -238,10 +258,14 @@ class cluster_impl : public std::enable_shared_from_this<cluster_impl>
             auto ptr = buckets_.find(bucket_name);
             if (ptr == buckets_.end()) {
                 std::vector<protocol::hello_feature> known_features;
+
+                auto origin = origin_;
                 if (session_ && session_->has_config()) {
                     known_features = session_->supported_features();
+                    origin = { origin_, session_->config().value() };
                 }
-                b = std::make_shared<bucket>(id_, ctx_, tls_, tracer_, meter_, bucket_name, origin_, known_features, dns_srv_tracker_);
+
+                b = std::make_shared<bucket>(id_, ctx_, tls_, tracer_, meter_, bucket_name, origin, known_features, dns_srv_tracker_);
                 buckets_.try_emplace(bucket_name, b);
             }
         }
@@ -326,6 +350,9 @@ class cluster_impl : public std::enable_shared_from_this<cluster_impl>
         if (stopped_) {
             return handler(request.make_response({ errc::network::cluster_closed }, response_type{}));
         }
+        if (!is_feature_supported(request, session_manager_->configuration_capabilities())) {
+            return handler(request.make_response({ errc::common::feature_not_available }, response_type{}));
+        }
         if constexpr (operations::is_compound_operation_v<Request>) {
             return request.execute(shared_from_this(), std::forward<Handler>(handler));
         } else {
@@ -333,6 +360,37 @@ class cluster_impl : public std::enable_shared_from_this<cluster_impl>
         }
     }
 
+    template<class Request,
+             class Handler,
+             typename std::enable_if_t<std::is_same_v<typename Request::encoded_request_type, io::http_request>, int> = 0>
+    void execute_with_bucket_capability_check(Request request, bucket_capability cap, Handler&& handler)
+    {
+        auto bucket_name = request.bucket_name;
+        return open_bucket(
+          bucket_name,
+          [self = shared_from_this(), bucket_name, cap, request = std::move(request), handler = std::forward<Handler>(handler)](
+            std::error_code ec) mutable {
+              if (ec) {
+                  handler(request.make_response({ ec }, {}));
+                  return;
+              }
+              return self->with_bucket_configuration(
+                bucket_name,
+                [self = std::move(self), cap, request = std::move(request), handler = std::forward<Handler>(handler)](
+                  std::error_code ec, topology::configuration config) mutable {
+                    if (ec) {
+                        handler(request.make_response({ ec }, {}));
+                        return;
+                    }
+                    if (!config.capabilities.has_bucket_capability(cap)) {
+                        handler(request.make_response({ errc::common::feature_not_available }, {}));
+                        return;
+                    }
+                    return self->execute(std::move(request), std::forward<Handler>(handler));
+                });
+          });
+    }
+
     std::shared_ptr<bucket> find_bucket_by_name(const std::string& name)
     {
         std::scoped_lock lock(buckets_mutex_);
@@ -1074,6 +1132,9 @@ void
 cluster::execute(operations::management::collection_create_request request,
                  utils::movable_function<void(operations::management::collection_create_response)>&& handler) const
 {
+    if (request.history.has_value()) {
+        return impl_->execute_with_bucket_capability_check(std::move(request), bucket_capability::non_deduped_history, std::move(handler));
+    }
     return impl_->execute(std::move(request), std::move(handler));
 }
 
@@ -1081,6 +1142,9 @@ void
 cluster::execute(operations::management::collection_update_request request,
                  utils::movable_function<void(operations::management::collection_update_response)>&& handler) const
 {
+    if (request.history.has_value()) {
+        return impl_->execute_with_bucket_capability_check(std::move(request), bucket_capability::non_deduped_history, std::move(handler));
+    }
     return impl_->execute(std::move(request), std::move(handler));
 }
 

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

@@ -16,6 +16,7 @@
  */
 
 #include "core/cluster.hxx"
+#include "diagnostics.hxx"
 
 #include <couchbase/bucket.hxx>
 
@@ -42,6 +43,15 @@ class bucket_impl : public std::enable_shared_from_this<bucket_impl>
         return core_;
     }
 
+    void ping(const ping_options::built& options, ping_handler&& handler) const
+    {
+        return core_.ping(options.report_id,
+                          name_,
+                          core::impl::to_core_service_types(options.service_types),
+                          options.timeout,
+                          [handler = std::move(handler)](auto resp) mutable { return handler(core::impl::build_result(resp)); });
+    }
+
   private:
     core::cluster core_;
     std::string name_;
@@ -70,6 +80,20 @@ bucket::scope(std::string_view scope_name) const -> couchbase::scope
     return { impl_->core(), impl_->name(), scope_name };
 }
 
+void
+bucket::ping(const couchbase::ping_options& options, couchbase::ping_handler&& handler) const
+{
+    return impl_->ping(options.build(), std::move(handler));
+}
+
+auto
+bucket::ping(const couchbase::ping_options& options) const -> std::future<ping_result>
+{
+    auto barrier = std::make_shared<std::promise<ping_result>>();
+    ping(options, [barrier](auto result) mutable { barrier->set_value(std::move(result)); });
+    return barrier->get_future();
+}
+
 auto
 bucket::collections() const -> collection_manager
 {

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

@@ -21,6 +21,7 @@
 #include "core/agent_group.hxx"
 #include "core/transactions.hxx"
 #include "core/utils/connection_string.hxx"
+#include "diagnostics.hxx"
 #include "internal_search_error_context.hxx"
 #include "internal_search_meta_data.hxx"
 #include "internal_search_result.hxx"
@@ -186,6 +187,33 @@ class cluster_impl : public std::enable_shared_from_this<cluster_impl>
                              });
     }
 
+    void ping(const ping_options::built& options, ping_handler&& handler) const
+    {
+        return core_.ping(options.report_id,
+                          {},
+                          core::impl::to_core_service_types(options.service_types),
+                          options.timeout,
+                          [handler = std::move(handler)](auto resp) mutable { return handler(core::impl::build_result(resp)); });
+    };
+
+    void diagnostics(const diagnostics_options::built& options, diagnostics_handler&& handler) const
+    {
+        return core_.diagnostics(options.report_id,
+                                 [handler = std::move(handler)](auto resp) mutable { return handler(core::impl::build_result(resp)); });
+    }
+
+    void search(std::string index_name,
+                couchbase::search_request request,
+                const search_options::built& options,
+                search_handler&& handler) const
+    {
+        return core_.execute(core::impl::build_search_request(std::move(index_name), std::move(request), options, {}, {}),
+                             [handler = std::move(handler)](auto resp) mutable {
+                                 return handler(search_error_context{ internal_search_error_context{ resp } },
+                                                search_result{ internal_search_result{ resp } });
+                             });
+    }
+
     void close(core::utils::movable_function<void()> handler)
     {
         if (transactions_) {
@@ -283,6 +311,51 @@ cluster::search_query(std::string index_name, const class search_query& query, c
     return barrier->get_future();
 }
 
+void
+cluster::ping(const couchbase::ping_options& options, couchbase::ping_handler&& handler) const
+{
+    return impl_->ping(options.build(), std::move(handler));
+}
+
+auto
+cluster::ping(const couchbase::ping_options& options) const -> std::future<ping_result>
+{
+    auto barrier = std::make_shared<std::promise<ping_result>>();
+    ping(options, [barrier](auto result) mutable { barrier->set_value(std::move(result)); });
+    return barrier->get_future();
+}
+
+void
+cluster::diagnostics(const couchbase::diagnostics_options& options, couchbase::diagnostics_handler&& handler) const
+{
+    return impl_->diagnostics(options.build(), std::move(handler));
+}
+
+auto
+cluster::diagnostics(const couchbase::diagnostics_options& options) const -> std::future<diagnostics_result>
+{
+    auto barrier = std::make_shared<std::promise<diagnostics_result>>();
+    diagnostics(options, [barrier](auto result) mutable { barrier->set_value(std::move(result)); });
+    return barrier->get_future();
+}
+
+void
+cluster::search(std::string index_name, search_request request, const search_options& options, search_handler&& handler) const
+{
+    return impl_->search(std::move(index_name), std::move(request), options.build(), std::move(handler));
+}
+
+auto
+cluster::search(std::string index_name, search_request request, const search_options& options) const
+  -> std::future<std::pair<search_error_context, search_result>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<search_error_context, search_result>>>();
+    search(std::move(index_name), std::move(request), options, [barrier](auto ctx, auto result) mutable {
+        barrier->set_value(std::make_pair(std::move(ctx), std::move(result)));
+    });
+    return barrier->get_future();
+}
+
 auto
 cluster::connect(asio::io_context& io, const std::string& connection_string, const cluster_options& options)
   -> std::future<std::pair<cluster, std::error_code>>

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

@@ -479,7 +479,7 @@ class collection_impl : public std::enable_shared_from_this<collection_impl>
           bucket_name_,
           [core = core_, r = std::move(request), h = std::move(handler)](std::error_code ec,
                                                                          const core::topology::configuration& config) mutable {
-              if (!config.supports_subdoc_read_replica()) {
+              if (!config.capabilities.supports_subdoc_read_replica()) {
                   ec = errc::common::feature_not_available;
               }
 
@@ -601,7 +601,7 @@ class collection_impl : public std::enable_shared_from_this<collection_impl>
           bucket_name_,
           [core = core_, r = std::move(request), h = std::move(handler)](std::error_code ec,
                                                                          const core::topology::configuration& config) mutable {
-              if (!config.supports_subdoc_read_replica()) {
+              if (!config.capabilities.supports_subdoc_read_replica()) {
                   ec = errc::common::feature_not_available;
               }
               if (r->specs().size() > 16) {