couchbase 4.2.9 → 4.2.10

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->fetch_config({});
             }
             asio::post(asio::bind_executor(self->ctx_, [h = std::move(h), ec, cfg = std::move(cfg)]() mutable { h(ec, cfg); }));
         });
@@ -476,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();
 
@@ -773,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 };
 

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,

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

@@ -333,6 +333,38 @@ 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;
+                    }
+                    auto bucket_caps = config.bucket_capabilities;
+                    if (bucket_caps.find(cap) == bucket_caps.end()) {
+                        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 +1106,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 +1116,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/diagnostics.cxx

@@ -0,0 +1,294 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "diagnostics.hxx"
+
+#include "core/diagnostics.hxx"
+#include "core/service_type.hxx"
+
+#include <couchbase/codec/tao_json_serializer.hxx>
+#include <couchbase/diagnostics_result.hxx>
+#include <couchbase/endpoint_ping_report.hxx>
+#include <couchbase/ping_result.hxx>
+#include <couchbase/service_type.hxx>
+
+#include <cstdint>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+namespace couchbase
+{
+namespace
+{
+std::string
+service_type_as_string(service_type service_type)
+{
+    switch (service_type) {
+        case service_type::key_value:
+            return "kv";
+        case service_type::query:
+            return "query";
+        case service_type::analytics:
+            return "analytics";
+        case service_type::search:
+            return "search";
+        case service_type::view:
+            return "views";
+        case service_type::management:
+            return "mgmt";
+        case service_type::eventing:
+            return "eventing";
+    }
+    return "";
+}
+
+std::string
+ping_state_as_string(ping_state state)
+{
+    switch (state) {
+        case ping_state::ok:
+            return "ok";
+        case ping_state::timeout:
+            return "timeout";
+        case ping_state::error:
+            return "error";
+    }
+    return "";
+}
+
+std::string
+endpoint_state_as_string(endpoint_state state)
+{
+    switch (state) {
+        case endpoint_state::connected:
+            return "connected";
+        case endpoint_state::connecting:
+            return "connecting";
+        case endpoint_state::disconnected:
+            return "disconnected";
+        case endpoint_state::disconnecting:
+            return "disconnecting";
+    }
+    return "";
+}
+
+codec::tao_json_serializer::document_type
+endpoint_ping_report_as_json(const endpoint_ping_report& report)
+{
+    codec::tao_json_serializer::document_type res{
+        { "id", report.id() },       { "latency_us", report.latency().count() },        { "remote", report.remote() },
+        { "local", report.local() }, { "state", ping_state_as_string(report.state()) },
+    };
+    if (report.error()) {
+        res["error"] = report.error().value();
+    }
+    if (report.endpoint_namespace()) {
+        res["namespace"] = report.endpoint_namespace().value();
+    }
+    return res;
+}
+
+codec::tao_json_serializer::document_type
+endpoint_diagnostics_as_json(const endpoint_diagnostics& report)
+{
+    codec::tao_json_serializer::document_type res{
+        { "id", report.id() },
+        { "local", report.local() },
+        { "remote", report.remote() },
+        { "state", endpoint_state_as_string(report.state()) },
+    };
+    if (report.last_activity()) {
+        res["last_activity_us"] = report.last_activity().value().count();
+    }
+    if (report.endpoint_namespace()) {
+        res["namespace"] = report.endpoint_namespace().value();
+    }
+    if (report.details()) {
+        res["details"] = report.details();
+    }
+    return res;
+}
+} // namespace
+
+auto
+ping_result::as_json() const -> codec::tao_json_serializer::document_type
+{
+    codec::tao_json_serializer::document_type endpoints{};
+    for (const auto& [service_type, reports] : endpoints_) {
+        std::vector<codec::tao_json_serializer::document_type> json_reports{};
+        for (const auto& report : reports) {
+            json_reports.emplace_back(endpoint_ping_report_as_json(report));
+        }
+        endpoints[service_type_as_string(service_type)] = json_reports;
+    }
+    return {
+        { "version", version_ },
+        { "id", id_ },
+        { "sdk", sdk_ },
+        { "services", endpoints },
+    };
+}
+
+auto
+diagnostics_result::as_json() const -> codec::tao_json_serializer::document_type
+{
+    codec::tao_json_serializer::document_type endpoints{};
+    for (const auto& [service_type, reports] : endpoints_) {
+        std::vector<codec::tao_json_serializer::document_type> json_reports{};
+        for (const auto& report : reports) {
+            json_reports.emplace_back(endpoint_diagnostics_as_json(report));
+        }
+        endpoints[service_type_as_string(service_type)] = json_reports;
+    }
+    return {
+        { "id", id_ },
+        { "sdk", sdk_ },
+        { "version", version_ },
+        { "services", endpoints },
+    };
+}
+} // namespace couchbase
+
+namespace couchbase::core::impl
+{
+namespace
+{
+couchbase::service_type
+to_public_service_type(core::service_type service_type)
+{
+    switch (service_type) {
+        case core::service_type::key_value:
+            return couchbase::service_type::key_value;
+        case core::service_type::query:
+            return couchbase::service_type::query;
+        case core::service_type::analytics:
+            return couchbase::service_type::analytics;
+        case core::service_type::search:
+            return couchbase::service_type::search;
+        case core::service_type::view:
+            return couchbase::service_type::view;
+        case core::service_type::management:
+            return couchbase::service_type::management;
+        case core::service_type::eventing:
+            return couchbase::service_type::eventing;
+    }
+    return {};
+}
+
+couchbase::ping_state
+to_public_ping_state(core::diag::ping_state ping_state)
+{
+    switch (ping_state) {
+        case core::diag::ping_state::timeout:
+            return couchbase::ping_state::timeout;
+        case core::diag::ping_state::error:
+            return couchbase::ping_state::error;
+        case core::diag::ping_state::ok:
+            return couchbase::ping_state::ok;
+    }
+    return {};
+}
+
+couchbase::endpoint_state
+to_public_endpoint_state(core::diag::endpoint_state endpoint_state)
+{
+    switch (endpoint_state) {
+        case core::diag::endpoint_state::connected:
+            return couchbase::endpoint_state::connected;
+        case diag::endpoint_state::disconnected:
+            return couchbase::endpoint_state::disconnected;
+        case diag::endpoint_state::connecting:
+            return couchbase::endpoint_state::connecting;
+        case diag::endpoint_state::disconnecting:
+            return couchbase::endpoint_state::disconnecting;
+    }
+    return {};
+}
+} // namespace
+
+std::set<core::service_type>
+to_core_service_types(const std::set<couchbase::service_type>& service_types)
+{
+    std::set<core::service_type> res{};
+    for (auto s : service_types) {
+        switch (s) {
+            case couchbase::service_type::key_value:
+                res.emplace(core::service_type::key_value);
+                break;
+            case couchbase::service_type::query:
+                res.emplace(core::service_type::query);
+                break;
+            case couchbase::service_type::analytics:
+                res.emplace(core::service_type::analytics);
+                break;
+            case couchbase::service_type::search:
+                res.emplace(core::service_type::search);
+                break;
+            case couchbase::service_type::view:
+                res.emplace(core::service_type::view);
+                break;
+            case couchbase::service_type::management:
+                res.emplace(core::service_type::management);
+                break;
+            case couchbase::service_type::eventing:
+                res.emplace(core::service_type::eventing);
+                break;
+        }
+    }
+    return res;
+}
+
+couchbase::ping_result
+build_result(const core::diag::ping_result& result)
+{
+    std::map<couchbase::service_type, std::vector<couchbase::endpoint_ping_report>> endpoints{};
+    for (const auto& [core_service_type, core_endpoints] : result.services) {
+        auto service_type = to_public_service_type(core_service_type);
+        endpoints[service_type] = std::vector<couchbase::endpoint_ping_report>{};
+        for (const auto& info : core_endpoints) {
+            endpoints[service_type].emplace_back(
+              service_type, info.id, info.local, info.remote, to_public_ping_state(info.state), info.error, info.bucket, info.latency);
+        }
+    }
+
+    return { result.id, static_cast<std::uint16_t>(result.version), result.sdk, endpoints };
+}
+
+couchbase::diagnostics_result
+build_result(const core::diag::diagnostics_result& result)
+{
+    std::map<couchbase::service_type, std::vector<couchbase::endpoint_diagnostics>> endpoints{};
+    for (const auto& [core_service_type, core_endpoints] : result.services) {
+        auto service_type = to_public_service_type(core_service_type);
+        endpoints[service_type] = std::vector<couchbase::endpoint_diagnostics>{};
+        for (const auto& info : core_endpoints) {
+            endpoints[service_type].emplace_back(service_type,
+                                                 info.id,
+                                                 info.last_activity,
+                                                 info.local,
+                                                 info.remote,
+                                                 info.bucket,
+                                                 to_public_endpoint_state(info.state),
+                                                 info.details);
+        }
+    }
+
+    return { result.id, static_cast<std::uint16_t>(result.version), result.sdk, endpoints };
+}
+} // namespace couchbase::core::impl

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

@@ -0,0 +1,39 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <couchbase/diagnostics_result.hxx>
+#include <couchbase/ping_result.hxx>
+#include <couchbase/service_type.hxx>
+
+#include "core/diagnostics.hxx"
+#include "core/service_type.hxx"
+
+#include <set>
+
+namespace couchbase::core::impl
+{
+std::set<core::service_type>
+to_core_service_types(const std::set<couchbase::service_type>& service_types);
+
+couchbase::ping_result
+build_result(const core::diag::ping_result& result);
+
+couchbase::diagnostics_result
+build_result(const core::diag::diagnostics_result& result);
+} // namespace couchbase::core::impl