couchbase 3.4.2 → 3.4.3

data/ext/couchbase/core/impl/search_sort_field.cxx

@@ -0,0 +1,104 @@
+/* -*- 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_field.hxx>
+
+namespace couchbase
+{
+auto
+search_sort_field::descending(bool desc) -> search_sort_field&
+{
+    descending_ = desc;
+    return *this;
+}
+
+auto
+search_sort_field::type(search_sort_field_type value) -> search_sort_field&
+{
+    type_ = value;
+    return *this;
+}
+
+auto
+search_sort_field::mode(search_sort_field_mode value) -> search_sort_field&
+{
+    mode_ = value;
+    return *this;
+}
+
+auto
+search_sort_field::missing(search_sort_field_missing value) -> search_sort_field&
+{
+    missing_ = value;
+    return *this;
+}
+
+auto
+search_sort_field::encode() const -> encoded_search_sort
+{
+    encoded_search_sort built;
+    built.sort = {
+        { "by", "field" },
+        { "field", field_ },
+    };
+    if (const auto& desc = descending_; desc.has_value()) {
+        built.sort["desc"] = desc.value();
+    }
+    if (const auto& type = type_; type.has_value()) {
+        switch (type.value()) {
+            case search_sort_field_type::automatic:
+                built.sort["type"] = "auto";
+                break;
+            case search_sort_field_type::string:
+                built.sort["type"] = "string";
+                break;
+            case search_sort_field_type::number:
+                built.sort["type"] = "number";
+                break;
+            case search_sort_field_type::date:
+                built.sort["type"] = "date";
+                break;
+        }
+    }
+    if (const auto& mode = mode_; mode.has_value()) {
+        switch (mode.value()) {
+            case search_sort_field_mode::server_default:
+                built.sort["mode"] = "default";
+                break;
+            case search_sort_field_mode::min:
+                built.sort["mode"] = "min";
+                break;
+            case search_sort_field_mode::max:
+                built.sort["mode"] = "max";
+                break;
+        }
+    }
+    if (const auto& missing = missing_; missing.has_value()) {
+        switch (missing.value()) {
+            case search_sort_field_missing::last:
+                built.sort["missing"] = "last";
+                break;
+            case search_sort_field_missing::first:
+                built.sort["missing"] = "first";
+                break;
+        }
+    }
+    return built;
+}
+} // namespace couchbase

data/ext/couchbase/core/impl/search_sort_id.cxx

@@ -0,0 +1,43 @@
+/* -*- 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_id.hxx>
+
+namespace couchbase
+{
+auto
+search_sort_id::descending(bool desc) -> search_sort_id&
+{
+    descending_ = desc;
+    return *this;
+}
+
+auto
+search_sort_id::encode() const -> encoded_search_sort
+{
+    encoded_search_sort built;
+    built.sort = {
+        { "by", "id" },
+    };
+    if (const auto& desc = descending_; desc.has_value()) {
+        built.sort["desc"] = desc.value();
+    }
+    return built;
+}
+} // namespace couchbase

data/ext/couchbase/core/impl/search_sort_score.cxx

@@ -0,0 +1,43 @@
+/* -*- 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_score.hxx>
+
+namespace couchbase
+{
+auto
+search_sort_score::descending(bool desc) -> search_sort_score&
+{
+    descending_ = desc;
+    return *this;
+}
+
+auto
+search_sort_score::encode() const -> encoded_search_sort
+{
+    encoded_search_sort built;
+    built.sort = {
+        { "by", "score" },
+    };
+    if (const auto& desc = descending_; desc.has_value()) {
+        built.sort["desc"] = desc.value();
+    }
+    return built;
+}
+} // namespace couchbase

data/ext/couchbase/core/impl/term_facet.cxx

@@ -0,0 +1,36 @@
+/* -*- 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_facet.hxx"
+
+#include <couchbase/term_facet.hxx>
+
+namespace couchbase
+{
+auto
+term_facet::encode() const -> encoded_search_facet
+{
+    encoded_search_facet built;
+    built.facet = {
+        { "field", field_ },
+    };
+    if (size_) {
+        built.facet["size"] = size_.value();
+    }
+    return built;
+}
+} // namespace couchbase

data/ext/couchbase/core/impl/term_facet_result.cxx

@@ -0,0 +1,64 @@
+/* -*- 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 "internal_term_facet_result.hxx"
+
+#include <couchbase/term_facet_result.hxx>
+
+namespace couchbase
+{
+term_facet_result::term_facet_result(internal_term_facet_result internal)
+  : internal_{ std::make_unique<internal_term_facet_result>(std::move(internal)) }
+{
+}
+
+auto
+term_facet_result::name() const -> const std::string&
+{
+    return internal_->name();
+}
+
+auto
+term_facet_result::field() const -> const std::string&
+{
+    return internal_->field();
+}
+
+auto
+term_facet_result::total() const -> std::uint64_t
+{
+    return internal_->total();
+}
+
+auto
+term_facet_result::missing() const -> std::uint64_t
+{
+    return internal_->missing();
+}
+
+auto
+term_facet_result::other() const -> std::uint64_t
+{
+    return internal_->other();
+}
+
+auto
+term_facet_result::terms() const -> const std::vector<search_term_range>&
+{
+    return internal_->terms();
+}
+} // namespace couchbase

data/ext/couchbase/core/impl/term_query.cxx

@@ -0,0 +1,56 @@
+/* -*- 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/term_query.hxx>
+
+namespace couchbase
+{
+auto
+term_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["term"] = term_;
+    if (field_) {
+        built.query["field"] = field_.value();
+    }
+    if (fuzziness_) {
+        built.query["fuzziness"] = fuzziness_.value();
+    }
+    if (prefix_length_) {
+        built.query["prefix_length"] = prefix_length_.value();
+    }
+    if (operator_) {
+        switch (operator_.value()) {
+            case match_operator::logical_or:
+                built.query["operator"] = "or";
+                break;
+            case match_operator::logical_and:
+                built.query["operator"] = "and";
+                break;
+        }
+    }
+
+    return built;
+}
+} // namespace couchbase

data/ext/couchbase/core/impl/term_range_query.cxx

@@ -0,0 +1,57 @@
+/* -*- 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/term_range_query.hxx>
+
+#include <couchbase/error_codes.hxx>
+
+namespace couchbase
+{
+auto
+term_range_query::encode() const -> encoded_search_query
+{
+    if ((!min_ || min_->empty()) && (!max_ || max_->empty())) {
+        return { errc::common::invalid_argument };
+    }
+
+    encoded_search_query built;
+    built.query = tao::json::empty_object;
+    if (boost_) {
+        built.query["boost"] = boost_.value();
+    }
+    if (field_) {
+        built.query["field"] = field_.value();
+    }
+
+    if (min_) {
+        built.query["min"] = min_.value();
+        if (inclusive_min_.has_value()) {
+            built.query["inclusive_min"] = inclusive_min_.value();
+        }
+    }
+    if (max_) {
+        built.query["max"] = max_.value();
+        if (inclusive_max_.has_value()) {
+            built.query["inclusive_max"] = inclusive_max_.value();
+        }
+    }
+
+    return built;
+}
+} // namespace couchbase

data/ext/couchbase/core/impl/wildcard_query.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/wildcard_query.hxx>
+
+namespace couchbase
+{
+auto
+wildcard_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["wildcard"] = wildcard_;
+    if (field_) {
+        built.query["field"] = field_.value();
+    }
+
+    return built;
+}
+} // namespace couchbase

data/ext/couchbase/core/io/http_context.hxx

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include "core/cluster_options.hxx"
+#include "core/cluster_options_fwd.hxx"
 #include "core/topology/configuration.hxx"
 #include "query_cache.hxx"
 

data/ext/couchbase/core/io/http_session.hxx

@@ -216,11 +216,21 @@ class http_session : public std::enable_shared_from_this<http_session>
         return id_;
     }
 
+    [[nodiscard]] service_type type() const
+    {
+        return type_;
+    }
+
     [[nodiscard]] const std::string& hostname() const
     {
         return hostname_;
     }
 
+    [[nodiscard]] const std::string& port() const
+    {
+        return service_;
+    }
+
     [[nodiscard]] const asio::ip::tcp::endpoint& endpoint()
     {
         std::scoped_lock lock(info_mutex_);

data/ext/couchbase/core/io/http_session_manager.hxx

@@ -61,8 +61,9 @@ class http_session_manager
         std::scoped_lock config_lock(config_mutex_, sessions_mutex_);
         config_ = std::move(config);
         for (auto& [type, sessions] : idle_sessions_) {
-            sessions.remove_if(
-              [&cfg = config_](const auto& session) { return session && !cfg.has_node_with_hostname(session->hostname()); });
+            sessions.remove_if([&opts = options_, &cfg = config_](const auto& session) {
+                return session && !cfg.has_node(opts.network, session->type(), opts.enable_tls, session->hostname(), session->port());
+            });
         }
     }
 
@@ -224,7 +225,8 @@ class http_session_manager
     {
         {
             std::scoped_lock lock(config_mutex_);
-            if (!session->keep_alive() || !config_.has_node_with_hostname(session->hostname())) {
+            if (!session->keep_alive() ||
+                !config_.has_node(options_.network, session->type(), options_.enable_tls, session->hostname(), session->port())) {
                 return asio::post(session->get_executor(), [session]() { session->stop(); });
             }
         }

data/ext/couchbase/core/io/mcbp_session.cxx

@@ -72,7 +72,7 @@ class collection_cache
         if (auto ptr = cid_map_.find(path); ptr != cid_map_.end()) {
             return ptr->second;
         }
-        return {};
+        return std::nullopt;
     }
 
     void update(const std::string& path, std::uint32_t id)
@@ -380,6 +380,16 @@ class mcbp_session_impl
                     switch (static_cast<protocol::server_opcode>(msg.header.opcode)) {
                         case protocol::server_opcode::cluster_map_change_notification: {
                             protocol::cmd_info info{ session_->endpoint_address_, session_->endpoint_.port() };
+                            if (session_->origin_.options().dump_configuration) {
+                                std::string_view config_text{ reinterpret_cast<const char*>(msg.body.data()), msg.body.size() };
+                                CB_LOG_TRACE(
+                                  "{} configuration from cluster_map_change_notification request (size={}, endpoint=\"{}:{}\"), {}",
+                                  session_->log_prefix_,
+                                  config_text.size(),
+                                  info.endpoint_address,
+                                  info.endpoint_port,
+                                  config_text);
+                            }
                             protocol::server_request<protocol::cluster_map_change_notification_request_body> req(std::move(msg), info);
                             std::optional<topology::configuration> config = req.body().config();
                             if (session_ && config.has_value()) {
@@ -464,6 +474,15 @@ class mcbp_session_impl
                     switch (auto opcode = static_cast<protocol::client_opcode>(msg.header.opcode)) {
                         case protocol::client_opcode::get_cluster_config: {
                             protocol::cmd_info info{ session_->endpoint_address_, session_->endpoint_.port() };
+                            if (session_->origin_.options().dump_configuration) {
+                                std::string_view config_text{ reinterpret_cast<const char*>(msg.body.data()), msg.body.size() };
+                                CB_LOG_TRACE("{} configuration from get_cluster_config response (size={}, endpoint=\"{}:{}\"), {}",
+                                             session_->log_prefix_,
+                                             config_text.size(),
+                                             info.endpoint_address,
+                                             info.endpoint_port,
+                                             config_text);
+                            }
                             protocol::client_response<protocol::get_cluster_config_response_body> resp(std::move(msg), info);
                             if (resp.status() == key_value_status_code::success) {
                                 if (session_) {
@@ -1138,6 +1157,14 @@ class mcbp_session_impl
             if (utils::byte_swap(msg.header.bodylen) - offset > 0) {
                 std::string_view config_text{ reinterpret_cast<const char*>(msg.body.data()) + offset,
                                               msg.body.size() - static_cast<std::size_t>(offset) };
+                if (origin_.options().dump_configuration) {
+                    CB_LOG_TRACE("{} configuration from not_my_vbucket response (size={}, endpoint=\"{}:{}\"), {}",
+                                 log_prefix_,
+                                 config_text.size(),
+                                 endpoint_address_,
+                                 endpoint_.port(),
+                                 config_text);
+                }
                 auto config = protocol::parse_config(config_text, endpoint_address_, endpoint_.port());
                 CB_LOG_DEBUG("{} received not_my_vbucket status for {}, opaque={} with config rev={} in the payload",
                              log_prefix_,

data/ext/couchbase/core/io/retry_orchestrator.hxx

@@ -55,13 +55,14 @@ retry_with_duration(std::shared_ptr<Manager> manager,
                     std::chrono::milliseconds duration)
 {
     command->request.retries.record_retry_attempt(reason);
-    CB_LOG_TRACE(R"({} retrying operation {} (duration={}ms, id="{}", reason={}, attempts={}))",
+    CB_LOG_TRACE(R"({} retrying operation {} (duration={}ms, id="{}", reason={}, attempts={}, last_dispatched_to=\"{}\"))",
                  manager->log_prefix(),
                  decltype(command->request)::encoded_request_type::body_type::opcode,
                  duration.count(),
                  command->id_,
                  reason,
-                 command->request.retries.retry_attempts());
+                 command->request.retries.retry_attempts(),
+                 command->session_ ? command->session_->remote_address() : "");
     manager->schedule_for_retry(command, duration);
 }
 

data/ext/couchbase/core/json_string.hxx

@@ -37,6 +37,11 @@ struct json_string {
         return *this;
     }
 
+    json_string(const std::vector<std::byte>& value)
+      : value_(value)
+    {
+    }
+
     json_string(std::vector<std::byte>&& value)
       : value_(std::move(value))
     {

data/ext/couchbase/core/meta/version.cxx

@@ -17,10 +17,12 @@
 
 #include "version.hxx"
 
+#include "core/mozilla_ca_bundle.hxx"
 #include "core/transactions/forward_compat.hxx"
 #include "core/utils/join_strings.hxx"
 #include "core/utils/json.hxx"
 
+#include <couchbase/build_config.hxx>
 #include <couchbase/build_info.hxx>
 #include <couchbase/build_version.hxx>
 
@@ -76,7 +78,7 @@ sdk_build_info()
     info["link_libraries"] = COUCHBASE_CXX_CLIENT_LINK_LIBRARIES;
     info["link_options"] = COUCHBASE_CXX_CLIENT_LINK_OPTIONS;
     info["static_stdlib"] =
-#if defined(STATIC_STDLIB)
+#if defined(COUCHBASE_CXX_CLIENT_STATIC_STDLIB)
       "true"
 #else
       "false"
@@ -84,7 +86,7 @@ sdk_build_info()
       ;
     info["post_linked_openssl"] = COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL;
     info["static_openssl"] =
-#if defined(STATIC_OPENSSL)
+#if defined(COUCHBASE_CXX_CLIENT_STATIC_OPENSSL)
       "true"
 #else
       "false"
@@ -112,8 +114,19 @@ sdk_build_info()
         }
     }
 #endif
+
+#if defined(COUCHBASE_CXX_CLIENT_EMBED_MOZILLA_CA_BUNDLE)
+    info["mozilla_ca_bundle_embedded"] = "true";
+    info["mozilla_ca_bundle_sha256"] = COUCHBASE_CXX_CLIENT_MOZILLA_CA_BUNDLE_SHA256;
+    info["mozilla_ca_bundle_date"] = COUCHBASE_CXX_CLIENT_MOZILLA_CA_BUNDLE_DATE;
+#else
+    info["mozilla_ca_bundle_embedded"] = "false";
+#endif
+    info["mozilla_ca_bundle_size"] = std::to_string(default_ca::mozilla_ca_certs().size());
     info["openssl_default_cert_dir"] = X509_get_default_cert_dir();
     info["openssl_default_cert_file"] = X509_get_default_cert_file();
+    info["openssl_default_cert_dir_env"] = X509_get_default_cert_dir_env();
+    info["openssl_default_cert_file_env"] = X509_get_default_cert_file_env();
     info["openssl_ssl_interface_include_directories"] = OPENSSL_SSL_INTERFACE_INCLUDE_DIRECTORIES;
     info["openssl_ssl_interface_link_libraries"] = OPENSSL_SSL_INTERFACE_LINK_LIBRARIES;
     info["openssl_ssl_imported_location"] = OPENSSL_SSL_IMPORTED_LOCATION;
@@ -138,9 +151,10 @@ sdk_build_info_json()
 {
     tao::json::value info;
     for (const auto& [name, value] : sdk_build_info()) {
-        if (name == "version_major" || name == "version_minor" || name == "version_patch" || name == "version_build") {
+        if (name == "version_major" || name == "version_minor" || name == "version_patch" || name == "version_build" ||
+            name == "mozilla_ca_bundle_size") {
             info[name] = std::stoi(value);
-        } else if (name == "snapshot" || name == "static_stdlib" || name == "static_openssl") {
+        } else if (name == "snapshot" || name == "static_stdlib" || name == "static_openssl" || name == "mozilla_ca_bundle_embedded") {
             info[name] = value == "true";
         } else {
             info[name] = value;