couchbase 4.2.8 → 4.2.10

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

@@ -0,0 +1,139 @@
+/* -*- 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 "core/impl/encoded_search_query.hxx"
+
+#include <couchbase/search_request.hxx>
+
+namespace couchbase
+{
+class search_request_impl
+{
+  public:
+    explicit search_request_impl(std::optional<encoded_search_query> search_query,
+                                 std::optional<encoded_search_query> vector_search,
+                                 std::optional<vector_search_options::built> options)
+      : search_query_(std::move(search_query))
+      , vector_search_(std::move(vector_search))
+      , vector_search_options_(std::move(options))
+    {
+    }
+
+    static search_request_impl create(const search_query& query)
+    {
+        auto encoded = query.encode();
+        if (encoded.ec) {
+            throw std::system_error(encoded.ec, "unable to encode the search_query");
+        }
+        return search_request_impl(encoded, {}, {});
+    }
+
+    static search_request_impl create(const vector_search& search)
+    {
+        auto encoded = search.encode();
+        if (encoded.ec) {
+            throw std::system_error(encoded.ec, "unable to encode the vector_search");
+        }
+        return search_request_impl({}, encoded, search.options());
+    }
+
+    void search_query(const couchbase::search_query& query)
+    {
+        search_query_ = query.encode();
+        if (search_query_.value().ec) {
+            throw std::system_error(search_query_.value().ec, "unable to encode the search_query");
+        }
+    }
+
+    void vector_search(const couchbase::vector_search& search)
+    {
+        vector_search_ = search.encode();
+        if (vector_search_.value().ec) {
+            throw std::system_error(vector_search_.value().ec, "unable to encode the vector_search");
+        }
+        vector_search_options_ = search.options();
+    }
+
+    [[nodiscard]] std::optional<encoded_search_query> search_query() const
+    {
+        return search_query_;
+    }
+
+    [[nodiscard]] std::optional<encoded_search_query> vector_search() const
+    {
+        return vector_search_;
+    }
+
+    [[nodiscard]] std::optional<vector_search_options::built> vector_options() const
+    {
+        return vector_search_options_;
+    }
+
+  private:
+    std::optional<encoded_search_query> search_query_;
+    std::optional<encoded_search_query> vector_search_;
+    std::optional<vector_search_options::built> vector_search_options_;
+};
+
+search_request::search_request(const couchbase::search_query& query)
+  : impl_{ std::make_shared<search_request_impl>(search_request_impl::create(query)) }
+{
+}
+
+search_request::search_request(const couchbase::vector_search& search)
+  : impl_{ std::make_shared<search_request_impl>(search_request_impl::create(search)) }
+{
+}
+
+auto
+search_request::search_query(const couchbase::search_query& search_query) -> search_request&
+{
+    if (impl_->search_query().has_value()) {
+        throw std::invalid_argument("There can only be one search_query in a search request");
+    }
+    impl_->search_query(search_query);
+    return *this;
+}
+
+auto
+search_request::vector_search(const couchbase::vector_search& vector_search) -> search_request&
+{
+    if (impl_->vector_search().has_value()) {
+        throw std::invalid_argument("There can only be one vector_search in a search request");
+    }
+    impl_->vector_search(vector_search);
+    return *this;
+}
+
+[[nodiscard]] std::optional<encoded_search_query>
+search_request::search_query() const
+{
+    return impl_->search_query();
+}
+
+[[nodiscard]] std::optional<encoded_search_query>
+search_request::vector_search() const
+{
+    return impl_->vector_search();
+}
+
+[[nodiscard]] std::optional<couchbase::vector_search_options::built>
+search_request::vector_options()
+{
+    return impl_->vector_options();
+}
+} // namespace couchbase

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

@@ -26,6 +26,18 @@ search_row_location::search_row_location(internal_search_row_location internal)
 {
 }
 
+search_row_location::search_row_location()
+  : internal_{ nullptr }
+{
+}
+
+search_row_location::~search_row_location() = default;
+
+search_row_location::search_row_location(search_row_location&&) noexcept = default;
+
+search_row_location&
+search_row_location::operator=(couchbase::search_row_location&&) noexcept = default;
+
 auto
 search_row_location::field() const -> const std::string&
 {

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

@@ -0,0 +1,87 @@
+/* -*- 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 "encoded_search_sort.hxx"
+
+#include <couchbase/search_sort_geo_distance.hxx>
+
+namespace couchbase
+{
+auto
+search_sort_geo_distance::descending(bool desc) -> search_sort_geo_distance&
+{
+    descending_ = desc;
+    return *this;
+}
+
+auto
+search_sort_geo_distance::unit(couchbase::search_geo_distance_units unit) -> search_sort_geo_distance&
+{
+    unit_ = unit;
+    return *this;
+}
+
+auto
+search_sort_geo_distance::encode() const -> encoded_search_sort
+{
+    encoded_search_sort built;
+    built.sort = {
+        { "by", "geo_distance" },
+        { "field", field_ },
+    };
+    built.sort["location"] = {
+        { "lat", location_.latitude },
+        { "lon", location_.longitude },
+    };
+    if (const auto& desc = descending_; desc.has_value()) {
+        built.sort["desc"] = desc.value();
+    }
+
+    if (const auto& unit = unit_; unit.has_value()) {
+        switch (unit.value()) {
+            case search_geo_distance_units::meters:
+                built.sort["unit"] = "meters";
+                break;
+            case search_geo_distance_units::miles:
+                built.sort["unit"] = "miles";
+                break;
+            case search_geo_distance_units::centimeters:
+                built.sort["unit"] = "centimeters";
+                break;
+            case search_geo_distance_units::millimeters:
+                built.sort["unit"] = "millimeters";
+                break;
+            case search_geo_distance_units::nautical_miles:
+                built.sort["unit"] = "nauticalmiles";
+                break;
+            case search_geo_distance_units::kilometers:
+                built.sort["unit"] = "kilometers";
+                break;
+            case search_geo_distance_units::feet:
+                built.sort["unit"] = "feet";
+                break;
+            case search_geo_distance_units::yards:
+                built.sort["unit"] = "yards";
+                break;
+            case search_geo_distance_units::inch:
+                built.sort["unit"] = "inch";
+                break;
+        }
+    }
+    return built;
+}
+} // namespace couchbase

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

@@ -0,0 +1,42 @@
+/* -*- 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 "encoded_search_query.hxx"
+
+#include <couchbase/vector_query.hxx>
+
+namespace couchbase
+{
+auto
+vector_query::encode() const -> encoded_search_query
+{
+    encoded_search_query built;
+    built.query = tao::json::empty_object;
+    if (boost_) {
+        built.query["boost"] = boost_.value();
+    }
+    built.query["field"] = vector_field_name_;
+
+    tao::json::value vector_values = tao::json::empty_array;
+    for (const auto value : vector_query_) {
+        vector_values.push_back(value);
+    }
+    built.query["vector"] = vector_values;
+    built.query["k"] = num_candidates_;
+    return built;
+}
+} // namespace couchbase

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

@@ -0,0 +1,40 @@
+/* -*- 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 "encoded_search_query.hxx"
+
+#include <couchbase/vector_search.hxx>
+
+namespace couchbase
+{
+auto
+vector_search::encode() const -> encoded_search_query
+{
+    encoded_search_query built;
+
+    built.query = tao::json::empty_array;
+
+    for (const auto& query : vector_queries_) {
+        auto encoded = query.encode();
+        if (encoded.ec) {
+            return { encoded.ec };
+        }
+        built.query.push_back(encoded.query);
+    }
+    return built;
+}
+} // namespace couchbase

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

@@ -34,32 +34,30 @@ struct with_legacy_durability : public mutation_request {
     template<typename Core, typename Handler>
     void execute(Core core, Handler handler)
     {
-        using mutation_response = typename mutation_request::response_type;
-        core->template execute<mutation_request>(*this,
-                                                 [core,
-                                                  id = mutation_request::id,
-                                                  timeout = mutation_request::timeout,
-                                                  persist_to = persist_to,
-                                                  replicate_to = replicate_to,
-                                                  handler = std::forward<Handler>(handler)](mutation_response&& resp) mutable {
-                                                     if (resp.ctx.ec()) {
-                                                         return handler(std::move(resp));
-                                                     }
+        core.execute(*static_cast<mutation_request*>(this),
+                     [core,
+                      id = mutation_request::id,
+                      timeout = mutation_request::timeout,
+                      persist_to_ = persist_to,
+                      replicate_to_ = replicate_to,
+                      handler = std::forward<Handler>(handler)](auto&& resp) mutable {
+                         if (resp.ctx.ec()) {
+                             return handler(std::move(resp));
+                         }
 
-                                                     initiate_observe_poll(
-                                                       core,
-                                                       id,
-                                                       resp.token,
-                                                       timeout,
-                                                       persist_to,
-                                                       replicate_to,
-                                                       [resp = std::move(resp), handler = std::move(handler)](std::error_code ec) mutable {
-                                                           if (ec) {
-                                                               resp.ctx.override_ec(ec);
-                                                           }
-                                                           return handler(std::move(resp));
-                                                       });
-                                                 });
+                         initiate_observe_poll(core,
+                                               id,
+                                               resp.token,
+                                               timeout,
+                                               persist_to_,
+                                               replicate_to_,
+                                               [resp = std::move(resp), handler = std::move(handler)](std::error_code ec) mutable {
+                                                   if (ec) {
+                                                       resp.ctx.override_ec(ec);
+                                                   }
+                                                   return handler(std::move(resp));
+                                               });
+                     });
     }
 };
 } // namespace couchbase::core::impl

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

@@ -33,7 +33,10 @@
 
 #include <asio/ip/address.hpp>
 
+#include <filesystem>
+#include <fstream>
 #include <mutex>
+#include <utility>
 
 namespace couchbase::core::io::dns
 {
@@ -158,4 +161,29 @@ dns_config::system_config()
 
     return instance;
 }
+
+dns_config::dns_config(std::string nameserver, std::uint16_t port, std::chrono::milliseconds timeout)
+  : nameserver_{ std::move(nameserver) }
+  , port_{ port }
+  , timeout_{ timeout }
+{
+}
+
+std::uint16_t
+dns_config::port() const
+{
+    return port_;
+}
+
+const std::string&
+dns_config::nameserver() const
+{
+    return nameserver_;
+}
+
+std::chrono::milliseconds
+dns_config::timeout() const
+{
+    return timeout_;
+}
 } // namespace couchbase::core::io::dns

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

@@ -20,8 +20,6 @@
 #include "core/timeout_defaults.hxx"
 
 #include <cstdint>
-#include <filesystem>
-#include <fstream>
 #include <string>
 
 namespace couchbase::core::io::dns
@@ -32,31 +30,14 @@ class dns_config
     static constexpr auto default_nameserver = "8.8.8.8";
     static constexpr std::uint16_t default_port = 53;
 
-    dns_config() = default;
-
-    dns_config(const std::string& nameserver, std::uint16_t port, std::chrono::milliseconds timeout = timeout_defaults::dns_srv_timeout)
-      : nameserver_{ nameserver }
-      , port_{ port }
-      , timeout_{ timeout }
-    {
-    }
-
-    [[nodiscard]] std::uint16_t port() const
-    {
-        return port_;
-    }
-
-    [[nodiscard]] const std::string& nameserver() const
-    {
-        return nameserver_;
-    }
+    static const dns_config& system_config();
 
-    [[nodiscard]] std::chrono::milliseconds timeout() const
-    {
-        return timeout_;
-    }
+    dns_config() = default;
+    dns_config(std::string nameserver, std::uint16_t port, std::chrono::milliseconds timeout = timeout_defaults::dns_srv_timeout);
 
-    static const dns_config& system_config();
+    [[nodiscard]] std::uint16_t port() const;
+    [[nodiscard]] const std::string& nameserver() const;
+    [[nodiscard]] std::chrono::milliseconds timeout() const;
 
   private:
     std::string nameserver_{ default_nameserver };

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

@@ -370,11 +370,12 @@ class http_session : public std::enable_shared_from_this<http_session>
             return;
         }
         if (ec) {
-            CB_LOG_ERROR("{} error on resolve: {}", info_.log_prefix(), ec.message());
+            CB_LOG_ERROR("{} error on resolve \"{}:{}\": {}", info_.log_prefix(), hostname_, service_, ec.message());
             return;
         }
         last_active_ = std::chrono::steady_clock::now();
         endpoints_ = endpoints;
+        CB_LOG_TRACE("{} resolved \"{}:{}\" to {} endpoint(s)", info_.log_prefix(), hostname_, service_, endpoints_.size());
         do_connect(endpoints_.begin());
         deadline_timer_.async_wait(std::bind(&http_session::check_deadline, shared_from_this(), std::placeholders::_1));
     }
@@ -385,15 +386,17 @@ class http_session : public std::enable_shared_from_this<http_session>
             return;
         }
         if (it != endpoints_.end()) {
-            CB_LOG_DEBUG("{} connecting to {}:{}, timeout={}ms",
+            CB_LOG_DEBUG("{} connecting to {}:{} (\"{}:{}\"), timeout={}ms",
                          info_.log_prefix(),
                          it->endpoint().address().to_string(),
                          it->endpoint().port(),
+                         hostname_,
+                         service_,
                          http_ctx_.options.connect_timeout.count());
             deadline_timer_.expires_after(http_ctx_.options.connect_timeout);
             stream_->async_connect(it->endpoint(), std::bind(&http_session::on_connect, shared_from_this(), std::placeholders::_1, it));
         } else {
-            CB_LOG_ERROR("{} no more endpoints left to connect", info_.log_prefix());
+            CB_LOG_ERROR("{} no more endpoints left to connect, \"{}:{}\" is not reachable", info_.log_prefix(), hostname_, service_);
             stop();
         }
     }

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

@@ -29,6 +29,8 @@
 
 #include <gsl/narrow>
 
+#include <chrono>
+#include <optional>
 #include <random>
 
 namespace couchbase::core::io
@@ -104,6 +106,7 @@ class http_session_manager
 
     template<typename Collector>
     void ping(std::set<service_type> services,
+              std::optional<std::chrono::milliseconds> timeout,
               std::shared_ptr<Collector> collector,
               const couchbase::core::cluster_credentials& credentials)
     {
@@ -153,6 +156,7 @@ class http_session_manager
                     }
                     operations::http_noop_request request{};
                     request.type = type;
+                    request.timeout = timeout;
                     auto cmd = std::make_shared<operations::http_command<operations::http_noop_request>>(
                       ctx_, request, tracer_, meter_, options_.default_timeout_for(request.type));
                     cmd->start([start = std::chrono::steady_clock::now(),
@@ -163,7 +167,11 @@ class http_session_manager
                         diag::ping_state state = diag::ping_state::ok;
                         std::optional<std::string> error{};
                         if (ec) {
-                            state = diag::ping_state::error;
+                            if (ec == errc::common::unambiguous_timeout || ec == errc::common::ambiguous_timeout) {
+                                state = diag::ping_state::timeout;
+                            } else {
+                                state = diag::ping_state::error;
+                            }
                             error.emplace(fmt::format("code={}, message={}, http_code={}", ec.value(), ec.message(), msg.status_code));
                         }
                         handler->report(diag::endpoint_ping_info{

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

@@ -269,7 +269,7 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
                                                                                                  : errc::common::ambiguous_timeout));
               }
               if (ec == errc::common::request_canceled) {
-                  if (reason == retry_reason::do_not_retry) {
+                  if (!self->request.retries.idempotent() && !allows_non_idempotent_retry(reason)) {
                       if (self->span_->uses_tags())
                           self->span_->add_tag(tracing::attributes::orphan, "canceled");
                       return self->invoke_handler(ec);

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

@@ -46,9 +46,10 @@ struct binary_header {
 };
 
 struct mcbp_message {
-    binary_header header;
-    std::vector<std::byte> body;
+    binary_header header{};
+    std::vector<std::byte> body{};
 
+    mcbp_message() = default;
     mcbp_message(const mcbp_message& other) = delete;
     mcbp_message& operator=(const mcbp_message& other) = delete;
     mcbp_message(mcbp_message&& other) = default;