couchbase 3.3.0 → 3.4.0

data/ext/couchbase/couchbase/cluster_options.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   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.
@@ -17,62 +17,326 @@
 
 #pragma once
 
-#include <couchbase/io/ip_protocol.hxx>
-#include <couchbase/metrics/logging_meter_options.hxx>
-#include <couchbase/service_type.hxx>
-#include <couchbase/timeout_defaults.hxx>
-#include <couchbase/tracing/threshold_logging_options.hxx>
+#include <couchbase/behavior_options.hxx>
+#include <couchbase/certificate_authenticator.hxx>
+#include <couchbase/compression_options.hxx>
+#include <couchbase/configuration_profiles_registry.hxx>
+#include <couchbase/dns_options.hxx>
+#include <couchbase/metrics_options.hxx>
+#include <couchbase/network_options.hxx>
+#include <couchbase/password_authenticator.hxx>
+#include <couchbase/security_options.hxx>
+#include <couchbase/timeout_options.hxx>
+#include <couchbase/tracing_options.hxx>
+#include <couchbase/transactions/transactions_config.hxx>
 
-#include <chrono>
+#include <functional>
+#include <stdexcept>
 #include <string>
+#include <system_error>
+#include <vector>
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace asio
+{
+class io_context;
+} // namespace asio
+#endif
 
 namespace couchbase
 {
-enum class tls_verify_mode {
-    none,
-    peer,
-};
+class cluster_options
+{
+  public:
+    /**
+     *
+     * @param username
+     * @param password
+     *
+     * @since 1.0.0
+     * @comitted
+     */
+    cluster_options(std::string username, std::string password)
+      : username_{ std::move(username) }
+      , password_{ std::move(password) }
+    {
+    }
+
+    /**
+     *
+     * @param authenticator
+     *
+     * @since 1.0.0
+     * @comitted
+     */
+    explicit cluster_options(password_authenticator authenticator)
+      : username_{ std::move(authenticator.username_) }
+      , password_{ std::move(authenticator.password_) }
+    {
+        if (authenticator.ldap_compatible_) {
+            sasl_mechanisms_ = { { "PLAIN" } };
+        }
+    }
+
+    /**
+     *
+     * @param authenticator
+     *
+     * @since 1.0.0
+     * @comitted
+     */
+    explicit cluster_options(certificate_authenticator authenticator)
+      : certificate_path_{ std::move(authenticator.certificate_path_) }
+      , key_path_{ std::move(authenticator.key_path_) }
+    {
+    }
+
+    /**
+     * Apply settings profile by name.
+     *
+     * At the moment the only one profile is defined: "wan_development".
+     *
+     * @param profile_name  name of the registered profile
+     *
+     * @see configuration_profile_registry
+     * @see wan_development_configuration_profile
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    void apply_profile(const std::string& profile_name)
+    {
+        configuration_profiles_registry::apply_profile(profile_name, *this);
+    }
+
+    /**
+     * Returns compression options.
+     *
+     * @return compression options
+     *
+     * @since 1.0.0
+     * @comitted
+     */
+    [[nodiscard]] auto compression() -> compression_options&
+    {
+        return compression_;
+    }
+
+    /**
+     * Returns various timeout options.
+     *
+     * @return timeout options
+     *
+     * @since 1.0.0
+     * @comitted
+     */
+    [[nodiscard]] auto timeouts() -> timeout_options&
+    {
+        return timeouts_;
+    }
+
+    /**
+     * Returns options for DNS-SRV bootstrap.
+     *
+     * @return DNS options
+     *
+     * @since 1.0.0
+     * @comitted
+     */
+    [[nodiscard]] auto dns() -> dns_options&
+    {
+        return dns_;
+    }
+
+    /**
+     * Returns security options (including TLS)
+     *
+     * @return security options
+     *
+     * @since 1.0.0
+     * @comitted
+     */
+    [[nodiscard]] auto security() -> security_options&
+    {
+        return security_;
+    }
+
+    /**
+     * Returns network options
+     *
+     * @return network options
+     *
+     * @since 1.0.0
+     * @comitted
+     */
+    [[nodiscard]] auto network() -> network_options&
+    {
+        return network_;
+    }
+
+    /**
+     * Returns metrics and observability options
+     *
+     * @return metrics options
+     *
+     * @since 1.0.0
+     * @comitted
+     */
+    [[nodiscard]] auto metrics() -> metrics_options&
+    {
+        return metrics_;
+    }
+
+    /**
+     * Returns tracing options
+     *
+     * @return tracing options
+     *
+     * @since 1.0.0
+     * @comitted
+     */
+    [[nodiscard]] auto tracing() -> tracing_options&
+    {
+        return tracing_;
+    }
+
+    /**
+     * Returns misc options that affects cluster behavior.
+     *
+     * @return misc options.
+     *
+     * @since 1.0.0
+     * @volatile
+     */
+    [[nodiscard]] auto behavior() -> behavior_options&
+    {
+        return behavior_;
+    }
 
-struct cluster_options {
-    std::chrono::milliseconds bootstrap_timeout = timeout_defaults::bootstrap_timeout;
-    std::chrono::milliseconds resolve_timeout = timeout_defaults::resolve_timeout;
-    std::chrono::milliseconds connect_timeout = timeout_defaults::connect_timeout;
-    std::chrono::milliseconds key_value_timeout = timeout_defaults::key_value_timeout;
-    std::chrono::milliseconds key_value_durable_timeout = timeout_defaults::key_value_durable_timeout;
-    std::chrono::milliseconds view_timeout = timeout_defaults::view_timeout;
-    std::chrono::milliseconds query_timeout = timeout_defaults::query_timeout;
-    std::chrono::milliseconds analytics_timeout = timeout_defaults::analytics_timeout;
-    std::chrono::milliseconds search_timeout = timeout_defaults::search_timeout;
-    std::chrono::milliseconds management_timeout = timeout_defaults::management_timeout;
-    std::chrono::milliseconds dns_srv_timeout = timeout_defaults::dns_srv_timeout;
-
-    bool enable_tls{ false };
-    std::string trust_certificate{};
-    bool enable_mutation_tokens{ true };
-    bool enable_tcp_keep_alive{ true };
-    io::ip_protocol use_ip_protocol{ io::ip_protocol::any };
-    bool enable_dns_srv{ true };
-    bool show_queries{ false };
-    bool enable_unordered_execution{ true };
-    bool enable_clustermap_notification{ true };
-    bool enable_compression{ true };
-    bool enable_tracing{ true };
-    bool enable_metrics{ true };
-    std::string network{ "auto" };
-    tracing::threshold_logging_options tracing_options{};
-    metrics::logging_meter_options metrics_options{};
-    tls_verify_mode tls_verify{ tls_verify_mode::peer };
-
-    std::chrono::milliseconds tcp_keep_alive_interval = timeout_defaults::tcp_keep_alive_interval;
-    std::chrono::milliseconds config_poll_interval = timeout_defaults::config_poll_interval;
-    std::chrono::milliseconds config_poll_floor = timeout_defaults::config_poll_floor;
-    std::chrono::milliseconds config_idle_redial_timeout = timeout_defaults::config_idle_redial_timeout;
-
-    std::size_t max_http_connections{ 0 };
-    std::chrono::milliseconds idle_http_connection_timeout = timeout_defaults::idle_http_connection_timeout;
-    std::string user_agent_extra{};
-
-    [[nodiscard]] std::chrono::milliseconds default_timeout_for(service_type type) const;
+    /**
+     * Returns the transactions options which effect the transactions behavior.
+     *
+     * @return  transactions configuration.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto transactions() -> transactions::transactions_config&
+    {
+        return transactions_;
+    }
+
+    /**
+     * Override default retry strategy
+     *
+     * @return cluster options object for chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto default_retry_strategy(std::shared_ptr<retry_strategy> strategy) -> cluster_options&
+    {
+        if (strategy == nullptr) {
+            throw std::invalid_argument("retry strategy cannot be null");
+        }
+        default_retry_strategy_ = std::move(strategy);
+        return *this;
+    }
+
+    struct built {
+        std::string username;
+        std::string password;
+        std::string certificate_path;
+        std::string key_path;
+        std::optional<std::vector<std::string>> allowed_sasl_mechanisms;
+        compression_options::built compression;
+        timeout_options::built timeouts;
+        dns_options::built dns;
+        security_options::built security;
+        network_options::built network;
+        metrics_options::built metrics;
+        tracing_options::built tracing;
+        behavior_options::built behavior;
+        transactions::transactions_config::built transactions;
+        std::shared_ptr<retry_strategy> default_retry_strategy;
+    };
+
+    [[nodiscard]] auto build() const -> built
+    {
+        return {
+            username_,
+            password_,
+            certificate_path_,
+            key_path_,
+            sasl_mechanisms_,
+            compression_.build(),
+            timeouts_.build(),
+            dns_.build(),
+            security_.build(),
+            network_.build(),
+            metrics_.build(),
+            tracing_.build(),
+            behavior_.build(),
+            transactions_.build(),
+            default_retry_strategy_,
+        };
+    }
+
+  private:
+    std::string username_{};
+    std::string password_{};
+    std::string certificate_path_{};
+    std::string key_path_{};
+    std::optional<std::vector<std::string>> sasl_mechanisms_{};
+
+    compression_options compression_{};
+    timeout_options timeouts_{};
+    dns_options dns_{};
+    security_options security_{};
+    network_options network_{};
+    metrics_options metrics_{};
+    tracing_options tracing_{};
+    behavior_options behavior_{};
+    transactions::transactions_config transactions_{};
+    std::shared_ptr<retry_strategy> default_retry_strategy_{ nullptr };
 };
 
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+class cluster;
+#endif
+
+/**
+ * The signature for the handler of the @ref cluster::connect()
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using cluster_connect_handler = std::function<void(cluster, std::error_code)>;
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace core
+{
+class cluster;
+}
+
+namespace core::impl
+{
+
+/**
+ * @since 1.0.0
+ * @internal
+ */
+void
+initiate_cluster_connect(asio::io_context& io,
+                         const std::string& connection_string,
+                         const couchbase::cluster_options& options,
+                         cluster_connect_handler&& handler);
+/**
+ * @since 1.0.0
+ * @internal
+ */
+void
+initiate_cluster_close(std::shared_ptr<couchbase::core::cluster> core);
+#endif
+} // namespace core::impl
 } // namespace couchbase

data/ext/couchbase/couchbase/codec/binary_noop_serializer.hxx

@@ -0,0 +1,47 @@
+/* -*- 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 <couchbase/codec/encoded_value.hxx>
+#include <couchbase/codec/serializer_traits.hxx>
+
+namespace couchbase::codec
+{
+class binary_noop_serializer
+{
+  public:
+    using document_type = binary;
+
+    static auto serialize(binary document) -> binary
+    {
+        return document;
+    }
+
+    template<typename Document>
+    static auto deserialize(binary data) -> binary
+    {
+        return data;
+    }
+};
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+template<>
+struct is_serializer<binary_noop_serializer> : public std::true_type {
+};
+#endif
+} // namespace couchbase::codec

data/ext/couchbase/couchbase/codec/codec_flags.hxx

@@ -0,0 +1,145 @@
+/* -*- 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 <cinttypes>
+#include <vector>
+
+namespace couchbase::codec::codec_flags
+{
+
+/**
+ * 32bit flag is composed of:
+ *  - 3 compression bits
+ *  - 1 bit reserved for future use
+ *  - 4 format flags bits. those 8 upper bits make up the common flags
+ *  - 8 bits reserved for future use
+ *  - 16 bits for legacy flags
+ *
+ * This mask allows to compare a 32 bits flags with the 4 common flag format bits
+ * ("00001111 00000000 00000000 00000000").
+ *
+ * @see #extract_common_flags()
+ * @see #has_common_flags()
+ * @see #has_compression_flags()
+ */
+constexpr std::uint32_t common_format_mask = 0x0F000000;
+
+enum class common_flags : std::uint32_t {
+    reserved = 0x00,
+    client_specific = 0x01, // called PRIVATE in RFC and other SDKs
+    json = 0x02,
+    binary = 0x03,
+    string = 0x04
+};
+
+/**
+ * Takes a enum representation of common flags and moves them to the common flags MSBs.
+ *
+ * @param flags the flags to shift.
+ * @return an integer having the common flags set.
+ */
+constexpr std::uint32_t
+create_common_flags(common_flags flags)
+{
+    return static_cast<std::uint32_t>(flags) << 24U;
+}
+
+/**
+ * Returns only the common flags from the full flags.
+ *
+ * @note it returns common_flags::reserved for unknown flags structure.
+ *
+ * @param flags the flags to check.
+ * @return only the common flags simple representation (8 bits).
+ */
+constexpr common_flags
+extract_common_flags(std::uint32_t flags)
+{
+    switch (auto value = static_cast<common_flags>(flags >> 24U)) {
+        case common_flags::client_specific:
+        case common_flags::json:
+        case common_flags::binary:
+        case common_flags::string:
+            return value;
+        default:
+            break;
+    }
+    return common_flags::reserved;
+}
+
+/**
+ * Checks whether the upper 8 bits are set, indicating common flags presence.
+ *
+ * It does this by shifting bits to the right until only the most significant
+ * bits are remaining and then checks if one of them is set.
+ *
+ * @param flags the flags to check.
+ * @return true if set, false otherwise.
+ */
+constexpr bool
+has_common_flags(std::uint32_t flags)
+{
+    return extract_common_flags(flags) != common_flags::reserved;
+}
+
+/**
+ * Checks that flags has common flags bits set and that they correspond to expected common flags format.
+ *
+ * @param flags the 32 bits flags to check
+ * @param expected_common_flag the expected common flags format bits
+ * @return true if common flags bits are set and correspond to expected_common_flag format
+ */
+constexpr bool
+has_common_flags(std::uint32_t flags, std::uint32_t expected_common_flag)
+{
+    return has_common_flags(flags) && (flags & common_format_mask) == expected_common_flag;
+}
+
+/**
+ * Checks that flags has common flags bits set and that they correspond to expected common flags value.
+ *
+ * @param flags the 32 bits flags to check
+ * @param expected_common_flag the expected common flags enum value
+ * @return true if common flags bits are set and correspond to expected_common_flag format
+ */
+constexpr bool
+has_common_flags(std::uint32_t flags, common_flags expected_common_flag)
+{
+    return has_common_flags(flags) && (flags & common_format_mask) == create_common_flags(expected_common_flag);
+}
+
+/**
+ * Checks whether the upper 3 bits are set, indicating compression presence.
+ *
+ * It does this by shifting bits to the right until only the most significant bits are remaining and then checks if one of them is set.
+ *
+ * @param flags the flags to check.
+ * @return true if compression set, false otherwise.
+ */
+constexpr bool
+has_compression_flags(std::uint32_t flags)
+{
+    return (flags >> 29U) > 0;
+}
+
+constexpr std::uint32_t private_common_flags = create_common_flags(common_flags::client_specific);
+constexpr std::uint32_t json_common_flags = create_common_flags(common_flags::json);
+constexpr std::uint32_t binary_common_flags = create_common_flags(common_flags::binary);
+constexpr std::uint32_t string_common_flags = create_common_flags(common_flags::string);
+} // namespace couchbase::codec::codec_flags

data/ext/couchbase/couchbase/codec/default_json_transcoder.hxx

@@ -0,0 +1,36 @@
+/* -*- 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 <couchbase/codec/json_transcoder.hxx>
+#include <couchbase/codec/tao_json_serializer.hxx>
+#include <couchbase/codec/transcoder_traits.hxx>
+
+namespace couchbase
+{
+namespace codec
+{
+using default_json_transcoder = json_transcoder<tao_json_serializer>;
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+template<>
+struct is_transcoder<default_json_transcoder> : public std::true_type {
+};
+#endif
+} // namespace codec
+} // namespace couchbase

data/ext/couchbase/couchbase/codec/encoded_value.hxx

@@ -0,0 +1,31 @@
+/* -*- 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 <cinttypes>
+#include <vector>
+
+namespace couchbase::codec
+{
+using binary = std::vector<std::byte>;
+
+struct encoded_value {
+    binary data;
+    std::uint32_t flags;
+};
+} // namespace couchbase::codec

data/ext/couchbase/couchbase/codec/json_transcoder.hxx

@@ -0,0 +1,49 @@
+/* -*- 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 <couchbase/codec/codec_flags.hxx>
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/error_codes.hxx>
+
+#include <string>
+
+namespace couchbase::codec
+{
+template<typename Serializer>
+class json_transcoder
+{
+  public:
+    template<typename Document>
+    static auto encode(Document document) -> encoded_value
+    {
+        return { Serializer::serialize(document), codec_flags::json_common_flags };
+    }
+
+    template<typename Document>
+    static auto decode(const encoded_value& encoded) -> Document
+    {
+        if (encoded.flags != 0 && !codec_flags::has_common_flags(encoded.flags, codec_flags::json_common_flags)) {
+            throw std::system_error(errc::common::decoding_failure,
+                                    "json_transcoder excepts document to have JSON common flags, flags=" + std::to_string(encoded.flags));
+        }
+
+        return Serializer::template deserialize<Document>(encoded.data);
+    }
+};
+} // namespace couchbase::codec