couchbase 3.4.2 → 3.4.4

data/ext/couchbase/core/cluster_options.hxx

@@ -25,6 +25,7 @@
 #include "core/transactions/cleanup_testing_hooks.hxx"
 #include "service_type.hxx"
 #include "timeout_defaults.hxx"
+#include "tls_verify_mode.hxx"
 
 #include <couchbase/best_effort_retry_strategy.hxx>
 #include <couchbase/metrics/meter.hxx>
@@ -32,16 +33,10 @@
 #include <couchbase/transactions/transactions_config.hxx>
 
 #include <chrono>
-#include <list>
 #include <string>
 
 namespace couchbase::core
 {
-enum class tls_verify_mode {
-    none,
-    peer,
-};
-
 struct cluster_options {
     std::chrono::milliseconds bootstrap_timeout = timeout_defaults::bootstrap_timeout;
     std::chrono::milliseconds resolve_timeout = timeout_defaults::resolve_timeout;
@@ -55,7 +50,10 @@ struct cluster_options {
     std::chrono::milliseconds management_timeout = timeout_defaults::management_timeout;
 
     bool enable_tls{ false };
+    bool tls_disable_deprecated_protocols{ true };
+    bool tls_disable_v1_2{ false };
     std::string trust_certificate{};
+    std::string trust_certificate_value{};
     bool enable_mutation_tokens{ true };
     bool enable_tcp_keep_alive{ true };
     io::ip_protocol use_ip_protocol{ io::ip_protocol::any };
@@ -86,6 +84,9 @@ struct cluster_options {
     couchbase::transactions::transactions_config::built transactions{};
 
     [[nodiscard]] std::chrono::milliseconds default_timeout_for(service_type type) const;
+
+    bool dump_configuration{ false };
+    bool disable_mozilla_ca_certificates{ false };
     void apply_profile(std::string profile_name);
 };
 

data/ext/couchbase/core/cluster_options_fwd.hxx

@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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
+
+namespace couchbase
+{
+namespace core
+{
+struct cluster_options;
+} // namespace core
+} // namespace couchbase

data/ext/couchbase/core/config_profile.hxx

@@ -16,13 +16,7 @@
  */
 #pragma once
 
-#include "cluster_options.hxx"
-#include <chrono>
-#include <fmt/core.h>
-#include <map>
-#include <mutex>
-#include <stdexcept>
-#include <string>
+#include "cluster_options_fwd.hxx"
 
 namespace couchbase::core
 {
@@ -32,51 +26,4 @@ class config_profile
     virtual ~config_profile() = default;
     virtual void apply(cluster_options&) = 0;
 };
-
-class development_profile : public config_profile
-{
-  public:
-    void apply(couchbase::core::cluster_options& opts) override;
-};
-
-// this class just registers the known profiles defined above, and allows access to them.
-class config_profiles
-{
-  private:
-    std::map<std::string, std::shared_ptr<couchbase::core::config_profile>> profiles_;
-    std::mutex mut_;
-
-  public:
-    config_profiles() noexcept
-    {
-        // add all known profiles (above) to the map
-        register_profile<development_profile>("wan_development");
-    }
-
-    void apply(const std::string& profile_name, couchbase::core::cluster_options& opts)
-    {
-        std::lock_guard<std::mutex> lock(mut_);
-        auto it = profiles_.find(profile_name);
-        if (it != profiles_.end()) {
-            it->second->apply(opts);
-        } else {
-            throw std::invalid_argument(fmt::format("unknown profile '{}'", profile_name));
-        }
-    }
-
-    template<typename T, typename... Args>
-    void register_profile(const std::string& name, Args... args)
-    {
-        // This will just add it, doesn't look to see if it is overwriting an existing profile.
-        // TODO: perhaps add a template Args param?
-        // TODO: should we make this thread-safe?   Easy enough here, but we'd need to make the
-        //   singleton thread-safe too.
-        std::lock_guard<std::mutex> lock(mut_);
-        profiles_.emplace(std::make_pair(name, std::make_shared<T>(args...)));
-    }
-};
-
-config_profiles&
-known_profiles();
-
 } // namespace couchbase::core

data/ext/couchbase/core/config_profiles.cxx

@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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 "config_profiles.hxx"
+
+#include "cluster_options.hxx"
+
+#include <fmt/core.h>
+
+#include <chrono>
+#include <stdexcept>
+
+namespace couchbase::core
+{
+class development_profile : public config_profile
+{
+  public:
+    void apply(couchbase::core::cluster_options& opts) override
+    {
+        opts.key_value_timeout = std::chrono::seconds(20);
+        opts.key_value_durable_timeout = std::chrono::seconds(20);
+        opts.connect_timeout = std::chrono::seconds(20);
+        opts.view_timeout = std::chrono::minutes(2);
+        opts.query_timeout = std::chrono::minutes(2);
+        opts.analytics_timeout = std::chrono::minutes(2);
+        opts.search_timeout = std::chrono::minutes(2);
+        opts.management_timeout = std::chrono::minutes(2);
+
+        // C++SDK specific
+        opts.dns_config = couchbase::core::io::dns::dns_config{
+            opts.dns_config.nameserver(),
+            opts.dns_config.port(),
+            std::chrono::seconds(20), // timeout to make DNS-SRV query
+        };
+        opts.resolve_timeout = std::chrono::seconds(20);  // timeout to resolve hostnames
+        opts.bootstrap_timeout = std::chrono::minutes(2); // overall timeout to bootstrap
+    }
+};
+
+config_profiles::config_profiles() noexcept
+{
+    // add all known profiles (above) to the map
+    register_profile<development_profile>("wan_development");
+}
+
+void
+config_profiles::apply(const std::string& profile_name, couchbase::core::cluster_options& opts)
+{
+    std::lock_guard<std::mutex> lock(mut_);
+    auto it = profiles_.find(profile_name);
+    if (it != profiles_.end()) {
+        it->second->apply(opts);
+    } else {
+        throw std::invalid_argument(fmt::format("unknown profile '{}'", profile_name));
+    }
+}
+
+config_profiles&
+known_profiles()
+{
+    static config_profiles profiles{};
+    return profiles;
+}
+
+} // namespace couchbase::core

data/ext/couchbase/core/config_profiles.hxx

@@ -0,0 +1,56 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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 "cluster_options_fwd.hxx"
+#include "config_profile.hxx"
+
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+
+namespace couchbase::core
+{
+// this class just registers the known profiles defined above, and allows access to them.
+class config_profiles
+{
+  private:
+    std::map<std::string, std::shared_ptr<config_profile>, std::less<>> profiles_;
+    mutable std::mutex mut_;
+
+  public:
+    config_profiles() noexcept;
+
+    void apply(const std::string& profile_name, couchbase::core::cluster_options& opts);
+
+    template<typename T, typename... Args>
+    void register_profile(const std::string& name, Args... args)
+    {
+        // This will just add it, doesn't look to see if it is overwriting an existing profile.
+        // TODO: perhaps add a template Args param?
+        // TODO: should we make this thread-safe?   Easy enough here, but we'd need to make the
+        //   singleton thread-safe too.
+        const std::scoped_lock lock(mut_);
+        profiles_.emplace(std::make_pair(name, std::make_shared<T>(args...)));
+    }
+};
+
+config_profiles&
+known_profiles();
+
+} // namespace couchbase::core

data/ext/couchbase/core/crud_component.cxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   Copyright 2020-2023 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -39,6 +39,8 @@
 
 #include <tl/expected.hpp>
 
+#include <random>
+
 namespace couchbase::core
 {
 static std::pair<std::vector<std::byte>, std::error_code>
@@ -53,17 +55,40 @@ serialize_range_scan_create_options(const range_scan_create_options& options)
         body["collection"] = fmt::format("{:x}", options.collection_id);
     }
 
-    if (std::holds_alternative<range_scan>(options.scan_type)) {
-        const auto& range = std::get<range_scan>(options.scan_type);
+    if (std::holds_alternative<range_scan>(options.scan_type) || std::holds_alternative<prefix_scan>(options.scan_type)) {
+        const auto& range = (std::holds_alternative<range_scan>(options.scan_type))
+                              ? std::get<range_scan>(options.scan_type)
+                              : std::get<prefix_scan>(options.scan_type).to_range_scan();
+
+        const auto& from = range.from.value_or(scan_term{ "" });
+        const auto& to = range.to.value_or(scan_term{ "\xf4\x8f\xfb\xfb" });
+
         body["range"] = {
-            { range.start_.exclusive ? "excl_start" : "start", base64::encode(range.start_.id) },
-            { range.end_.exclusive ? "excl_end" : "end", base64::encode(range.end_.id) },
+            { from.exclusive ? "excl_start" : "start", base64::encode(from.term) },
+            { to.exclusive ? "excl_end" : "end", base64::encode(to.term) },
         };
     } else if (std::holds_alternative<sampling_scan>(options.scan_type)) {
         const auto& sampling = std::get<sampling_scan>(options.scan_type);
+
+        // The limit in sampling scan is required to be greater than 0
+        if (sampling.limit <= 0) {
+            return { {}, errc::common::invalid_argument };
+        }
+
+        std::uint64_t seed{};
+        if (sampling.seed.has_value()) {
+            seed = sampling.seed.value();
+        } else {
+            // Generate random uint64 as seed
+            std::random_device rd;
+            std::mt19937_64 gen(rd());
+            std::uniform_int_distribution<std::uint64_t> dis;
+            seed = dis(gen);
+        }
+
         body["sampling"] = {
             { "samples", sampling.limit },
-            { "seed", sampling.seed.value_or(0) },
+            { "seed", seed },
         };
     } else {
         return { {}, errc::common::invalid_argument };
@@ -75,7 +100,7 @@ serialize_range_scan_create_options(const range_scan_create_options& options)
             { "vb_uuid", std::to_string(snapshot.vbucket_uuid) },
             { "seqno", snapshot.sequence_number },
             { "timeout_ms",
-              (options.timeout == std::chrono::milliseconds::zero()) ? timeout_defaults::range_scan_timeout.count()
+              (options.timeout == std::chrono::milliseconds::zero()) ? timeout_defaults::key_value_scan_timeout.count()
                                                                      : options.timeout.count() },
         };
         if (snapshot.sequence_number_exists) {
@@ -98,7 +123,7 @@ parse_range_scan_keys(gsl::span<std::byte> data, range_scan_item_callback&& item
         if (remaining.size() < key_length) {
             return errc::network::protocol_error;
         }
-        item_callback(range_scan_item{ { remaining.begin(), remaining.begin() + static_cast<std::ptrdiff_t>(key_length) } });
+        item_callback(range_scan_item{ { reinterpret_cast<const char*>(remaining.data()), key_length } });
         if (remaining.size() == key_length) {
             return {};
         }
@@ -130,13 +155,13 @@ parse_range_scan_documents(gsl::span<std::byte> data, range_scan_item_callback&&
         body.datatype = data[24];
         data = gsl::make_span(data.data() + header_offset, data.size() - header_offset);
 
-        std::vector<std::byte> key{};
+        std::string key{};
         {
             auto [key_length, remaining] = utils::decode_unsigned_leb128<std::size_t>(data, core::utils::leb_128_no_throw{});
             if (remaining.size() < key_length) {
                 return errc::network::protocol_error;
             }
-            key = { remaining.begin(), remaining.begin() + static_cast<std::ptrdiff_t>(key_length) };
+            key = { reinterpret_cast<const char*>(remaining.data()), key_length };
             data = gsl::make_span(remaining.data() + key_length, remaining.size() - key_length);
         }
 
@@ -242,19 +267,10 @@ class crud_component_impl
               if (error) {
                   return cb({}, error);
               }
-              bool ids_only;
-              switch (response->extras_.size()) {
-                  case 4:
-                      ids_only = mcbp::big_endian::read_uint32(response->extras_, 0) == 0;
-                      break;
-
-                  case 0:
-                      ids_only = options.ids_only; // support servers before MB-54267. TODO: remove after server GA
-                      break;
-
-                  default:
-                      return cb({}, errc::network::protocol_error);
+              if (response->extras_.size() != 4) {
+                  return cb({}, errc::network::protocol_error);
               }
+              bool ids_only = mcbp::big_endian::read_uint32(response->extras_, 0) == 0;
 
               if (auto ec = parse_range_scan_data(response->value_, std::move(item_cb), ids_only); ec) {
                   return cb({}, ec);
@@ -276,6 +292,19 @@ class crud_component_impl
 
         req->persistent_ = true;
         req->vbucket_ = vbucket_id;
+
+        if (options.timeout != std::chrono::milliseconds::zero()) {
+            auto timer = std::make_shared<asio::steady_timer>(io_);
+            timer->expires_after(options.timeout);
+            timer->async_wait([req](auto error) {
+                if (error == asio::error::operation_aborted) {
+                    return;
+                }
+                req->cancel(couchbase::errc::common::unambiguous_timeout);
+            });
+            req->set_deadline(timer);
+        }
+
         mcbp::buffer_writer buf{ scan_uuid.size() + sizeof(std::uint32_t) * 3 };
         buf.write(scan_uuid);
         buf.write_uint32(options.batch_item_limit);

data/ext/couchbase/core/error_context/key_value.cxx

@@ -24,7 +24,7 @@ key_value_error_context
 make_key_value_error_context(std::error_code ec, const document_id& id)
 {
     return {
-        ec, {}, {}, 0, {}, id.key(), id.bucket(), id.scope(), id.collection(), 0, {}, {}, {}, {},
+        {}, ec, {}, {}, 0, {}, id.key(), id.bucket(), id.scope(), id.collection(), 0, {}, {}, {}, {},
     };
 }
 
@@ -36,6 +36,7 @@ make_subdocument_error_context(const key_value_error_context& ctx,
                                bool deleted)
 {
     return {
+        ctx.operation_id(),
         ec,
         ctx.last_dispatched_to(),
         ctx.last_dispatched_from(),

data/ext/couchbase/core/error_context/key_value.hxx

@@ -43,23 +43,21 @@ make_key_value_error_context(std::error_code ec, std::uint16_t status_code, cons
     const auto& scope = command->request.id.scope();
     const auto& bucket = command->request.id.bucket();
     std::uint32_t opaque = (ec && response.opaque() == 0) ? command->request.opaque : response.opaque();
-    auto status = response.status();
-    auto retry_attempts = command->request.retries.retry_attempts();
-    auto retry_reasons = command->request.retries.retry_reasons();
-    std::optional<std::string> last_dispatched_from{};
-    std::optional<std::string> last_dispatched_to{};
+    std::optional<key_value_status_code> status{};
     std::optional<key_value_error_map_info> error_map_info{};
-    if (command->session_) {
-        last_dispatched_from = command->session_->local_address();
-        last_dispatched_to = command->session_->remote_address();
-        if (status_code) {
+    if (status_code != 0xffffU) {
+        status = response.status();
+        if (command->session_ && status_code > 0) {
             error_map_info = command->session_->decode_error_code(status_code);
         }
     }
+    auto retry_attempts = command->request.retries.retry_attempts();
+    auto retry_reasons = command->request.retries.retry_reasons();
 
-    return { ec,
-             std::move(last_dispatched_from),
-             std::move(last_dispatched_to),
+    return { command->id_,
+             ec,
+             command->last_dispatched_to_,
+             command->last_dispatched_from_,
              retry_attempts,
              std::move(retry_reasons),
              key,

data/ext/couchbase/core/error_context/search.hxx

@@ -32,7 +32,7 @@ struct search {
     std::error_code ec{};
     std::string client_context_id{};
     std::string index_name{};
-    std::optional<std::string> query{};
+    std::string query{};
     std::optional<std::string> parameters{};
 
     std::string method{};

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

@@ -17,6 +17,7 @@
 
 #include <couchbase/cluster.hxx>
 #include <couchbase/error_codes.hxx>
+#include <couchbase/scope.hxx>
 
 #include "core/cluster.hxx"
 #include "core/operations/document_analytics.hxx"

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

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

@@ -0,0 +1,62 @@
+/* -*- 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/boolean_query.hxx>
+
+#include <couchbase/error_codes.hxx>
+
+namespace couchbase
+{
+auto
+boolean_query::encode() const -> encoded_search_query
+{
+    if (!must_ && !should_ && !must_not_) {
+        return { errc::common::invalid_argument };
+    }
+
+    encoded_search_query built;
+    built.query = tao::json::empty_object;
+    if (boost_) {
+        built.query["boost"] = boost_.value();
+    }
+    if (must_) {
+        auto encoded = must_->encode();
+        if (encoded.ec) {
+            return { encoded.ec };
+        }
+        built.query["must"] = encoded.query;
+    }
+    if (must_not_) {
+        auto encoded = must_not_->encode();
+        if (encoded.ec) {
+            return { encoded.ec };
+        }
+        built.query["must_not"] = encoded.query;
+    }
+    if (should_) {
+        auto encoded = should_->encode();
+        if (encoded.ec) {
+            return { encoded.ec };
+        }
+        built.query["should"] = encoded.query;
+    }
+
+    return built;
+}
+} // namespace couchbase