couchbase 4.2.3 → 4.2.4

package/deps/couchbase-cxx-client/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)
@@ -379,7 +379,7 @@ class mcbp_session_impl
                     Expects(protocol::is_valid_server_request_opcode(msg.header.opcode));
                     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() };
+                            protocol::cmd_info info{ session_->bootstrap_hostname_, session_->bootstrap_port_number_ };
                             if (session_->origin_.options().dump_configuration) {
                                 std::string_view config_text{ reinterpret_cast<const char*>(msg.body.data()), msg.body.size() };
                                 CB_LOG_TRACE(
@@ -404,7 +404,7 @@ class mcbp_session_impl
                             CB_LOG_WARNING("{} unexpected server request: opcode={:x}, opaque={}{:a}{:a}",
                                            session_->log_prefix_,
                                            msg.header.opcode,
-                                           msg.header.opaque,
+                                           utils::byte_swap(msg.header.opaque),
                                            spdlog::to_hex(msg.header_data()),
                                            spdlog::to_hex(msg.body));
                     }
@@ -416,7 +416,7 @@ class mcbp_session_impl
                                    session_->log_prefix_,
                                    magic,
                                    msg.header.opcode,
-                                   msg.header.opaque,
+                                   utils::byte_swap(msg.header.opaque),
                                    spdlog::to_hex(msg.header_data()),
                                    spdlog::to_hex(msg.body));
                     break;
@@ -473,7 +473,7 @@ class mcbp_session_impl
                     Expects(protocol::is_valid_client_opcode(msg.header.opcode));
                     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() };
+                            protocol::cmd_info info{ session_->bootstrap_hostname_, session_->bootstrap_port_number_ };
                             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=\"{}:{}\"), {}",
@@ -781,13 +781,10 @@ class mcbp_session_impl
             return;
         }
         std::tie(bootstrap_hostname_, bootstrap_port_) = origin_.next_address();
-        log_prefix_ = fmt::format("[{}/{}/{}/{}] <{}:{}>",
-                                  client_id_,
-                                  id_,
-                                  stream_->log_prefix(),
-                                  bucket_name_.value_or("-"),
-                                  bootstrap_hostname_,
-                                  bootstrap_port_);
+        bootstrap_port_number_ = gsl::narrow_cast<std::uint16_t>(std::stoul(bootstrap_port_, nullptr, 10));
+        bootstrap_address_ = fmt::format("{}:{}", bootstrap_hostname_, bootstrap_port_);
+        log_prefix_ =
+          fmt::format("[{}/{}/{}/{}] <{}>", client_id_, id_, stream_->log_prefix(), bucket_name_.value_or("-"), bootstrap_address_);
         CB_LOG_DEBUG("{} attempt to establish MCBP connection", log_prefix_);
 
         async_resolve(origin_.options().use_ip_protocol,
@@ -807,7 +804,7 @@ class mcbp_session_impl
         return stopped_;
     }
 
-    void on_stop(utils::movable_function<void(retry_reason)> handler)
+    void on_stop(utils::movable_function<void()> handler)
     {
         on_stop_handler_ = std::move(handler);
     }
@@ -863,7 +860,7 @@ class mcbp_session_impl
         config_listeners_.clear();
         state_ = diag::endpoint_state::disconnected;
         if (auto on_stop = std::move(on_stop_handler_); on_stop) {
-            on_stop(reason);
+            on_stop();
         }
     }
 
@@ -874,7 +871,7 @@ class mcbp_session_impl
         }
         std::uint32_t opaque{ 0 };
         std::memcpy(&opaque, buf.data() + 12, sizeof(opaque));
-        CB_LOG_TRACE("{} MCBP send, opaque={}, {:n}", log_prefix_, opaque, spdlog::to_hex(buf.begin(), buf.begin() + 24));
+        CB_LOG_TRACE("{} MCBP send, opaque={}, {:n}", log_prefix_, utils::byte_swap(opaque), spdlog::to_hex(buf.begin(), buf.begin() + 24));
         std::scoped_lock lock(output_buffer_mutex_);
         output_buffer_.emplace_back(std::move(buf));
     }
@@ -1058,6 +1055,11 @@ class mcbp_session_impl
         return config_->index_for_this_node();
     }
 
+    [[nodiscard]] const std::string& bootstrap_address() const
+    {
+        return bootstrap_address_;
+    }
+
     [[nodiscard]] const std::string& bootstrap_hostname() const
     {
         return bootstrap_hostname_;
@@ -1068,6 +1070,11 @@ class mcbp_session_impl
         return bootstrap_port_;
     }
 
+    [[nodiscard]] std::uint16_t bootstrap_port_number() const
+    {
+        return bootstrap_port_number_;
+    }
+
     [[nodiscard]] std::uint32_t next_opaque()
     {
         return ++opaque_;
@@ -1161,15 +1168,15 @@ class mcbp_session_impl
                     CB_LOG_TRACE("{} configuration from not_my_vbucket response (size={}, endpoint=\"{}:{}\"), {}",
                                  log_prefix_,
                                  config_text.size(),
-                                 endpoint_address_,
-                                 endpoint_.port(),
+                                 bootstrap_hostname_,
+                                 bootstrap_port_number_,
                                  config_text);
                 }
-                auto config = protocol::parse_config(config_text, endpoint_address_, endpoint_.port());
+                auto config = protocol::parse_config(config_text, bootstrap_hostname_, bootstrap_port_number_);
                 CB_LOG_DEBUG("{} received not_my_vbucket status for {}, opaque={} with config rev={} in the payload",
                              log_prefix_,
                              protocol::client_opcode(msg.header.opcode),
-                             msg.header.opaque,
+                             utils::byte_swap(msg.header.opaque),
                              config.rev_str());
                 update_configuration(std::move(config));
             }
@@ -1204,6 +1211,12 @@ class mcbp_session_impl
             CB_LOG_DEBUG(R"({} server returned {} ({}), it must be transient condition, retrying)", log_prefix_, ec.value(), ec.message());
             return initiate_bootstrap();
         }
+        if (!origin_.exhausted() && ec == errc::common::authentication_failure) {
+            CB_LOG_DEBUG(
+              R"({} server returned authentication_failure, but the bootstrap list is not exhausted yet. It must be transient condition, retrying)",
+              log_prefix_);
+            return initiate_bootstrap();
+        }
 
         if (!bootstrapped_ && bootstrap_callback_) {
             bootstrap_deadline_.cancel();
@@ -1382,8 +1395,10 @@ class mcbp_session_impl
                           if (self->stopped_) {
                               return;
                           }
-                          CB_LOG_TRACE(
-                            "{} MCBP recv, opaque={}, {:n}", self->log_prefix_, msg.header.opaque, spdlog::to_hex(msg.header_data()));
+                          CB_LOG_TRACE("{} MCBP recv, opaque={}, {:n}",
+                                       self->log_prefix_,
+                                       utils::byte_swap(msg.header.opaque),
+                                       spdlog::to_hex(msg.header_data()));
                           if (self->bootstrapped_) {
                               self->handler_->handle(std::move(msg));
                           } else {
@@ -1462,7 +1477,7 @@ class mcbp_session_impl
     std::mutex command_handlers_mutex_{};
     std::map<std::uint32_t, command_handler> command_handlers_{};
     std::vector<std::shared_ptr<config_listener>> config_listeners_{};
-    utils::movable_function<void(retry_reason)> on_stop_handler_{};
+    utils::movable_function<void()> on_stop_handler_{};
 
     std::atomic_bool bootstrapped_{ false };
     std::atomic_bool stopped_{ false };
@@ -1482,6 +1497,8 @@ class mcbp_session_impl
     std::mutex writing_buffer_mutex_{};
     std::string bootstrap_hostname_{};
     std::string bootstrap_port_{};
+    std::string bootstrap_address_{};
+    std::uint16_t bootstrap_port_number_{};
     asio::ip::tcp::endpoint endpoint_{}; // connected endpoint
     std::string endpoint_address_{};     // cached string with endpoint address
     asio::ip::tcp::endpoint local_endpoint_{};
@@ -1582,22 +1599,16 @@ mcbp_session::supports_feature(protocol::hello_feature feature)
     return impl_->supports_feature(feature);
 }
 
-// const std::string&
-// mcbp_session::id() const
-// {
-//     return impl_->id();
-// }
-std::string
+const std::string&
 mcbp_session::id() const
 {
-    if (impl_) {
-        return fmt::format("{}, {}, {}, refcnt={}",
-                           reinterpret_cast<const void*>(this),
-                           reinterpret_cast<const void*>(impl_.get()),
-                           impl_->id(),
-                           impl_.use_count());
-    }
-    return fmt::format("{}, nullptr", reinterpret_cast<const void*>(this));
+    return impl_->id();
+}
+
+const std::string&
+mcbp_session::bootstrap_address() const
+{
+    return impl_->bootstrap_address();
 }
 
 std::string
@@ -1624,6 +1635,12 @@ mcbp_session::bootstrap_port() const
     return impl_->bootstrap_port();
 }
 
+std::uint16_t
+mcbp_session::bootstrap_port_number() const
+{
+    return impl_->bootstrap_port_number();
+}
+
 void
 mcbp_session::write_and_subscribe(std::uint32_t opaque, std::vector<std::byte>&& data, command_handler&& handler)
 {
@@ -1637,7 +1654,7 @@ mcbp_session::bootstrap(utils::movable_function<void(std::error_code, topology::
 }
 
 void
-mcbp_session::on_stop(utils::movable_function<void(retry_reason)> handler)
+mcbp_session::on_stop(utils::movable_function<void()> handler)
 {
     return impl_->on_stop(std::move(handler));
 }

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

@@ -101,17 +101,18 @@ class mcbp_session
     [[nodiscard]] mcbp_context context() const;
     [[nodiscard]] bool supports_feature(protocol::hello_feature feature);
     [[nodiscard]] std::vector<protocol::hello_feature> supported_features() const;
-    //[[nodiscard]] const std::string& id() const;
-    [[nodiscard]] std::string id() const;
+    [[nodiscard]] const std::string& id() const;
     [[nodiscard]] std::string remote_address() const;
     [[nodiscard]] std::string local_address() const;
+    [[nodiscard]] const std::string& bootstrap_address() const;
     [[nodiscard]] const std::string& bootstrap_hostname() const;
     [[nodiscard]] const std::string& bootstrap_port() const;
+    [[nodiscard]] std::uint16_t bootstrap_port_number() const;
     void write_and_subscribe(std::shared_ptr<mcbp::queue_request>, std::shared_ptr<response_handler> handler);
     void write_and_subscribe(std::uint32_t opaque, std::vector<std::byte>&& data, command_handler&& handler);
     void bootstrap(utils::movable_function<void(std::error_code, topology::configuration)>&& handler,
                    bool retry_on_bucket_not_found = false);
-    void on_stop(utils::movable_function<void(retry_reason)> handler);
+    void on_stop(utils::movable_function<void()> handler);
     void stop(retry_reason reason);
     [[nodiscard]] std::size_t index() const;
     [[nodiscard]] bool has_config() const;

package/deps/couchbase-cxx-client/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))
     {

package/deps/couchbase-cxx-client/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;

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

@@ -0,0 +1,39 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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 <array>
+#include <gsl/span>
+#include <string_view>
+
+namespace couchbase::core::default_ca
+{
+struct certificate {
+    std::string_view authority;
+    std::string_view body;
+};
+
+auto
+mozilla_ca_certs() -> gsl::span<const certificate>;
+
+auto
+mozilla_ca_certs_date() -> std::string_view;
+
+auto
+mozilla_ca_certs_sha256() -> std::string_view;
+} // namespace couchbase::core::default_ca

package/deps/couchbase-cxx-client/core/operations/document_search.cxx

@@ -32,9 +32,11 @@ search_request::encode_to(search_request::encoded_request_type& encoded, http_co
 {
     auto body = tao::json::value{
         { "query", utils::json::parse(query) },
-        { "explain", explain },
         { "ctl", { { "timeout", encoded.timeout.count() } } },
     };
+    if (explain) {
+        body["explain"] = *explain;
+    }
     if (limit) {
         body["size"] = *limit;
     }

package/deps/couchbase-cxx-client/core/operations/document_search.hxx

@@ -121,7 +121,7 @@ struct search_request {
 
     std::optional<std::uint32_t> limit{};
     std::optional<std::uint32_t> skip{};
-    bool explain{ false };
+    std::optional<bool> explain{ false };
     bool disable_scoring{ false };
     /**
      * UNCOMMITTED: If set to true, will include the vector of search_location in rows.

package/deps/couchbase-cxx-client/core/protocol/client_request.hxx

@@ -29,6 +29,8 @@
 #include <cstring>
 #include <gsl/util>
 
+#include <iostream>
+
 namespace couchbase::core::protocol
 {
 std::pair<bool, std::uint32_t>
@@ -110,10 +112,17 @@ class client_request
   private:
     [[nodiscard]] std::vector<std::byte> generate_payload(bool try_to_compress)
     {
-        std::vector<std::byte> payload(header_size + body_.size());
+        // SA: for some reason GCC 8.5.0 on CentOS 8 sees here null-pointer dereference
+#if defined(__GNUC__) && __GNUC__ == 8
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnull-dereference"
+#endif
+        std::vector<std::byte> payload(header_size + body_.size(), std::byte{});
         payload[0] = static_cast<std::byte>(magic_);
         payload[1] = static_cast<std::byte>(opcode_);
-
+#if defined(__GNUC__) && __GNUC__ == 8
+#pragma GCC diagnostic pop
+#endif
         const auto& framing_extras = body_.framing_extras();
 
         std::uint16_t key_size = gsl::narrow_cast<std::uint16_t>(body_.key().size());

package/deps/couchbase-cxx-client/core/protocol/client_response.hxx

@@ -148,6 +148,7 @@ class client_response
         data_.resize(body_size_);
 
         memcpy(&opaque_, header_.data() + 12, sizeof(opaque_));
+        opaque_ = utils::byte_swap(opaque_);
 
         memcpy(&cas_, header_.data() + 16, sizeof(cas_));
         cas_ = utils::byte_swap(cas_);