couchbase 4.2.8-dev.1 → 4.2.9

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

@@ -0,0 +1,260 @@
+/* -*- 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::core
+{
+namespace management::analytics
+{
+struct azure_blob_external_link;
+struct couchbase_remote_link;
+struct s3_external_link;
+} // namespace management::analytics
+
+namespace impl
+{
+struct get_replica_request;
+struct get_replica_response;
+struct lookup_in_replica_request;
+struct lookup_in_replica_response;
+struct observe_seqno_request;
+struct observe_seqno_response;
+template<typename mutation_request>
+struct with_legacy_durability;
+} // namespace impl
+
+namespace operations
+{
+struct analytics_request;
+struct analytics_response;
+struct append_request;
+struct append_response;
+struct decrement_request;
+struct decrement_response;
+struct exists_request;
+struct exists_response;
+struct get_request;
+struct get_response;
+struct get_all_replicas_request;
+struct get_all_replicas_response;
+struct get_and_lock_request;
+struct get_and_lock_response;
+struct get_and_touch_request;
+struct get_and_touch_response;
+struct get_any_replica_request;
+struct get_any_replica_response;
+struct get_projected_request;
+struct get_projected_response;
+struct increment_request;
+struct increment_response;
+struct insert_request;
+struct insert_response;
+struct lookup_in_request;
+struct lookup_in_response;
+struct lookup_in_any_replica_request;
+struct lookup_in_any_replica_response;
+struct lookup_in_all_replicas_request;
+struct lookup_in_all_replicas_response;
+struct mutate_in_request;
+struct mutate_in_response;
+struct prepend_request;
+struct prepend_response;
+struct query_request;
+struct query_response;
+struct remove_request;
+struct remove_response;
+struct replace_request;
+struct replace_response;
+struct search_request;
+struct search_response;
+struct touch_request;
+struct touch_response;
+struct unlock_request;
+struct unlock_response;
+struct upsert_request;
+struct upsert_response;
+struct document_view_request;
+struct document_view_response;
+struct http_noop_request;
+struct http_noop_response;
+
+using append_request_with_legacy_durability = impl::with_legacy_durability<append_request>;
+using decrement_request_with_legacy_durability = impl::with_legacy_durability<decrement_request>;
+using increment_request_with_legacy_durability = impl::with_legacy_durability<increment_request>;
+using insert_request_with_legacy_durability = impl::with_legacy_durability<insert_request>;
+using mutate_in_request_with_legacy_durability = impl::with_legacy_durability<mutate_in_request>;
+using prepend_request_with_legacy_durability = impl::with_legacy_durability<prepend_request>;
+using remove_request_with_legacy_durability = impl::with_legacy_durability<remove_request>;
+using replace_request_with_legacy_durability = impl::with_legacy_durability<replace_request>;
+using upsert_request_with_legacy_durability = impl::with_legacy_durability<upsert_request>;
+
+namespace management
+{
+struct analytics_dataset_create_request;
+struct analytics_dataset_create_response;
+struct analytics_dataset_drop_request;
+struct analytics_dataset_drop_response;
+struct analytics_dataset_get_all_request;
+struct analytics_dataset_get_all_response;
+struct analytics_dataverse_create_request;
+struct analytics_dataverse_create_response;
+struct analytics_dataverse_drop_request;
+struct analytics_dataverse_drop_response;
+struct analytics_get_pending_mutations_request;
+struct analytics_get_pending_mutations_response;
+struct analytics_index_create_request;
+struct analytics_index_create_response;
+struct analytics_index_drop_request;
+struct analytics_index_drop_response;
+struct analytics_index_get_all_request;
+struct analytics_index_get_all_response;
+struct analytics_link_connect_request;
+struct analytics_link_connect_response;
+template<typename analytics_link_type>
+struct analytics_link_create_request;
+struct analytics_link_create_response;
+struct analytics_link_disconnect_request;
+struct analytics_link_disconnect_response;
+struct analytics_link_drop_request;
+struct analytics_link_drop_response;
+struct analytics_link_get_all_request;
+struct analytics_link_get_all_response;
+template<typename analytics_link_type>
+struct analytics_link_replace_request;
+struct analytics_link_replace_response;
+struct bucket_create_request;
+struct bucket_create_response;
+struct bucket_drop_request;
+struct bucket_drop_response;
+struct bucket_flush_request;
+struct bucket_flush_response;
+struct bucket_get_request;
+struct bucket_get_response;
+struct bucket_get_all_request;
+struct bucket_get_all_response;
+struct bucket_update_request;
+struct bucket_update_response;
+struct cluster_developer_preview_enable_request;
+struct cluster_developer_preview_enable_response;
+struct collection_create_request;
+struct collection_create_response;
+struct collection_drop_request;
+struct collection_drop_response;
+struct collection_update_request;
+struct collection_update_response;
+struct collections_manifest_get_request;
+struct collections_manifest_get_response;
+struct scope_create_request;
+struct scope_create_response;
+struct scope_drop_request;
+struct scope_drop_response;
+struct scope_get_all_request;
+struct scope_get_all_response;
+struct eventing_deploy_function_request;
+struct eventing_deploy_function_response;
+struct eventing_drop_function_request;
+struct eventing_drop_function_response;
+struct eventing_get_all_functions_request;
+struct eventing_get_all_functions_response;
+struct eventing_get_function_request;
+struct eventing_get_function_response;
+struct eventing_get_status_request;
+struct eventing_get_status_response;
+struct eventing_pause_function_request;
+struct eventing_pause_function_response;
+struct eventing_resume_function_request;
+struct eventing_resume_function_response;
+struct eventing_undeploy_function_request;
+struct eventing_undeploy_function_response;
+struct eventing_upsert_function_request;
+struct eventing_upsert_function_response;
+struct view_index_drop_request;
+struct view_index_drop_response;
+struct view_index_get_request;
+struct view_index_get_response;
+struct view_index_get_all_request;
+struct view_index_get_all_response;
+struct view_index_upsert_request;
+struct view_index_upsert_response;
+struct change_password_request;
+struct change_password_response;
+struct group_drop_request;
+struct group_drop_response;
+struct group_get_request;
+struct group_get_response;
+struct group_get_all_request;
+struct group_get_all_response;
+struct group_upsert_request;
+struct group_upsert_response;
+struct role_get_all_request;
+struct role_get_all_response;
+struct user_drop_request;
+struct user_drop_response;
+struct user_get_request;
+struct user_get_response;
+struct user_get_all_request;
+struct user_get_all_response;
+struct user_upsert_request;
+struct user_upsert_response;
+struct search_get_stats_request;
+struct search_get_stats_response;
+struct search_index_analyze_document_request;
+struct search_index_analyze_document_response;
+struct search_index_control_ingest_request;
+struct search_index_control_ingest_response;
+struct search_index_control_plan_freeze_request;
+struct search_index_control_plan_freeze_response;
+struct search_index_control_query_request;
+struct search_index_control_query_response;
+struct search_index_drop_request;
+struct search_index_drop_response;
+struct search_index_get_request;
+struct search_index_get_response;
+struct search_index_get_all_request;
+struct search_index_get_all_response;
+struct search_index_get_documents_count_request;
+struct search_index_get_documents_count_response;
+struct search_index_get_stats_request;
+struct search_index_get_stats_response;
+struct search_index_upsert_request;
+struct search_index_upsert_response;
+struct query_index_build_request;
+struct query_index_build_response;
+struct query_index_build_deferred_request;
+struct query_index_build_deferred_response;
+struct query_index_create_request;
+struct query_index_create_response;
+struct query_index_drop_request;
+struct query_index_drop_response;
+struct query_index_get_all_request;
+struct query_index_get_all_response;
+struct query_index_get_all_deferred_request;
+struct query_index_get_all_deferred_response;
+
+struct bucket_describe_request;
+struct bucket_describe_response;
+struct cluster_describe_request;
+struct cluster_describe_response;
+struct freeform_request;
+struct freeform_response;
+struct search_index_stats_request;
+struct search_index_stats_response;
+} // namespace management
+} // namespace operations
+
+} // namespace couchbase::core

package/deps/couchbase-cxx-client/core/origin.cxx

@@ -17,8 +17,10 @@
 
 #include "origin.hxx"
 
+#include "core/utils/connection_string.hxx"
+
 #include <fmt/chrono.h>
-#include <fmt/format.h>
+#include <fmt/core.h>
 
 #include <tao/json.hpp>
 
@@ -166,7 +168,7 @@ struct traits<couchbase::transactions::transactions_config::built> {
     static void assign(tao::json::basic_value<Traits>& v, const couchbase::transactions::transactions_config::built& o)
     {
         v = {
-            { "expiration_time", o.expiration_time },
+            { "timeout", o.timeout },
             { "durability_level", o.level },
             {
               "query_config",
@@ -184,9 +186,6 @@ struct traits<couchbase::transactions::transactions_config::built> {
               },
             },
         };
-        if (const auto& p = o.kv_timeout; p.has_value()) {
-            v["key_value_timeout"] = p.value();
-        }
         if (const auto& p = o.metadata_collection; p.has_value()) {
             v["metadata_collection"] = {
                 { "bucket", p.value().bucket },
@@ -267,4 +266,146 @@ origin::to_json() const -> std::string
     }
     return tao::json::to_string(json);
 }
+
+bool
+cluster_credentials::uses_certificate() const
+{
+    return !certificate_path.empty();
+}
 } // namespace couchbase::core
+
+couchbase::core::origin::origin(const couchbase::core::origin& other)
+  : options_(other.options_)
+  , credentials_(other.credentials_)
+  , nodes_(other.nodes_)
+  , next_node_(nodes_.begin())
+{
+}
+couchbase::core::origin::origin(couchbase::core::cluster_credentials auth,
+                                const std::string& hostname,
+                                std::uint16_t port,
+                                couchbase::core::cluster_options options)
+  : options_(std::move(options))
+  , credentials_(std::move(auth))
+  , nodes_{ { hostname, std::to_string(port) } }
+  , next_node_(nodes_.begin())
+{
+}
+couchbase::core::origin::origin(couchbase::core::cluster_credentials auth,
+                                const std::string& hostname,
+                                const std::string& port,
+                                couchbase::core::cluster_options options)
+  : options_(std::move(options))
+  , credentials_(std::move(auth))
+  , nodes_{ { hostname, port } }
+  , next_node_(nodes_.begin())
+{
+}
+couchbase::core::origin::origin(couchbase::core::cluster_credentials auth, const couchbase::core::utils::connection_string& connstr)
+  : options_(connstr.options)
+  , credentials_(std::move(auth))
+{
+    nodes_.reserve(connstr.bootstrap_nodes.size());
+    for (const auto& node : connstr.bootstrap_nodes) {
+        nodes_.emplace_back(node.address, node.port > 0 ? std::to_string(node.port) : std::to_string(connstr.default_port));
+    }
+    next_node_ = nodes_.begin();
+}
+couchbase::core::origin&
+couchbase::core::origin::operator=(const couchbase::core::origin& other)
+{
+    if (this != &other) {
+        options_ = other.options_;
+        credentials_ = other.credentials_;
+        nodes_ = other.nodes_;
+        next_node_ = nodes_.begin();
+        exhausted_ = false;
+    }
+    return *this;
+}
+const std::string&
+couchbase::core::origin::username() const
+{
+    return credentials_.username;
+}
+const std::string&
+couchbase::core::origin::password() const
+{
+    return credentials_.password;
+}
+const std::string&
+couchbase::core::origin::certificate_path() const
+{
+    return credentials_.certificate_path;
+}
+const std::string&
+couchbase::core::origin::key_path() const
+{
+    return credentials_.key_path;
+}
+std::vector<std::string>
+couchbase::core::origin::get_hostnames() const
+{
+    std::vector<std::string> res;
+    res.reserve(nodes_.size());
+    for (const auto& [hostname, _] : nodes_) {
+        res.emplace_back(hostname);
+    }
+    return res;
+}
+std::vector<std::string>
+couchbase::core::origin::get_nodes() const
+{
+    std::vector<std::string> res;
+    res.reserve(nodes_.size());
+    for (const auto& [hostname, port] : nodes_) {
+        res.emplace_back(fmt::format("\"{}:{}\"", hostname, port));
+    }
+    return res;
+}
+void
+couchbase::core::origin::set_nodes(couchbase::core::origin::node_list nodes)
+{
+    nodes_ = std::move(nodes);
+    next_node_ = nodes_.begin();
+    exhausted_ = false;
+}
+std::pair<std::string, std::string>
+couchbase::core::origin::next_address()
+{
+    if (exhausted_) {
+        restart();
+    }
+
+    auto address = *next_node_;
+    if (++next_node_ == nodes_.end()) {
+        exhausted_ = true;
+    }
+    return address;
+}
+bool
+couchbase::core::origin::exhausted() const
+{
+    return exhausted_;
+}
+void
+couchbase::core::origin::restart()
+{
+    exhausted_ = false;
+    next_node_ = nodes_.begin();
+}
+const couchbase::core::cluster_options&
+couchbase::core::origin::options() const
+{
+    return options_;
+}
+couchbase::core::cluster_options&
+couchbase::core::origin::options()
+{
+    return options_;
+}
+const couchbase::core::cluster_credentials&
+couchbase::core::origin::credentials() const
+{
+    return credentials_;
+}

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

@@ -17,15 +17,19 @@
 
 #pragma once
 
-#include "core/utils/connection_string.hxx"
-
-#include <fmt/core.h>
+#include "cluster_options.hxx"
 
 #include <string>
 #include <utility>
+#include <vector>
 
 namespace couchbase::core
 {
+namespace utils
+{
+struct connection_string;
+} // namespace utils
+
 struct cluster_credentials {
     std::string username{};
     std::string password{};
@@ -33,10 +37,7 @@ struct cluster_credentials {
     std::string key_path{};
     std::optional<std::vector<std::string>> allowed_sasl_mechanisms{};
 
-    [[nodiscard]] bool uses_certificate() const
-    {
-        return !certificate_path.empty();
-    }
+    [[nodiscard]] bool uses_certificate() const;
 };
 
 struct origin {
@@ -44,146 +45,35 @@ struct origin {
     using node_list = std::vector<node_entry>;
 
     origin() = default;
-
     ~origin() = default;
 
     origin(origin&& other) = default;
+    origin(const origin& other);
+    origin(cluster_credentials auth, const std::string& hostname, std::uint16_t port, cluster_options options);
+    origin(cluster_credentials auth, const std::string& hostname, const std::string& port, cluster_options options);
+    origin(cluster_credentials auth, const utils::connection_string& connstr);
+    origin& operator=(origin&& other) = default;
+    origin& operator=(const origin& other);
 
-    origin(const origin& other)
-      : options_(other.options_)
-      , credentials_(other.credentials_)
-      , nodes_(other.nodes_)
-      , next_node_(nodes_.begin())
-    {
-    }
-
-    origin(cluster_credentials auth, const std::string& hostname, std::uint16_t port, cluster_options options)
-      : options_(std::move(options))
-      , credentials_(std::move(auth))
-      , nodes_{ { hostname, std::to_string(port) } }
-      , next_node_(nodes_.begin())
-    {
-    }
-
-    origin(cluster_credentials auth, const std::string& hostname, const std::string& port, cluster_options options)
-      : options_(std::move(options))
-      , credentials_(std::move(auth))
-      , nodes_{ { hostname, port } }
-      , next_node_(nodes_.begin())
-    {
-    }
-
-    origin(cluster_credentials auth, const utils::connection_string& connstr)
-      : options_(connstr.options)
-      , credentials_(std::move(auth))
-    {
-        nodes_.reserve(connstr.bootstrap_nodes.size());
-        for (const auto& node : connstr.bootstrap_nodes) {
-            nodes_.emplace_back(node.address, node.port > 0 ? std::to_string(node.port) : std::to_string(connstr.default_port));
-        }
-        next_node_ = nodes_.begin();
-    }
+    [[nodiscard]] const std::string& username() const;
+    [[nodiscard]] const std::string& password() const;
+    [[nodiscard]] const std::string& certificate_path() const;
+    [[nodiscard]] const std::string& key_path() const;
 
-    origin& operator=(origin&& other) = default;
+    [[nodiscard]] std::vector<std::string> get_hostnames() const;
+    [[nodiscard]] std::vector<std::string> get_nodes() const;
+
+    void set_nodes(node_list nodes);
+
+    [[nodiscard]] std::pair<std::string, std::string> next_address();
+
+    [[nodiscard]] bool exhausted() const;
 
-    origin& operator=(const origin& other)
-    {
-        if (this != &other) {
-            options_ = other.options_;
-            credentials_ = other.credentials_;
-            nodes_ = other.nodes_;
-            next_node_ = nodes_.begin();
-            exhausted_ = false;
-        }
-        return *this;
-    }
-
-    [[nodiscard]] const std::string& username() const
-    {
-        return credentials_.username;
-    }
-
-    [[nodiscard]] const std::string& password() const
-    {
-        return credentials_.password;
-    }
-
-    [[nodiscard]] const std::string& certificate_path() const
-    {
-        return credentials_.certificate_path;
-    }
-
-    [[nodiscard]] const std::string& key_path() const
-    {
-        return credentials_.key_path;
-    }
-
-    [[nodiscard]] std::vector<std::string> get_hostnames() const
-    {
-        std::vector<std::string> res;
-        res.reserve(nodes_.size());
-        for (const auto& [hostname, _] : nodes_) {
-            res.emplace_back(hostname);
-        }
-        return res;
-    }
-
-    [[nodiscard]] std::vector<std::string> get_nodes() const
-    {
-        std::vector<std::string> res;
-        res.reserve(nodes_.size());
-        for (const auto& [hostname, port] : nodes_) {
-            res.emplace_back(fmt::format("\"{}:{}\"", hostname, port));
-        }
-        return res;
-    }
-
-    void set_nodes(node_list nodes)
-    {
-        nodes_ = std::move(nodes);
-        next_node_ = nodes_.begin();
-        exhausted_ = false;
-    }
-
-    [[nodiscard]] std::pair<std::string, std::string> next_address()
-    {
-        if (exhausted_) {
-            restart();
-        }
-
-        auto address = *next_node_;
-        if (++next_node_ == nodes_.end()) {
-            exhausted_ = true;
-        }
-        return address;
-    }
-
-    [[nodiscard]] bool exhausted() const
-    {
-        return exhausted_;
-    }
-
-    void restart()
-    {
-        exhausted_ = false;
-        next_node_ = nodes_.begin();
-    }
-
-    [[nodiscard]] const couchbase::core::cluster_options& options() const
-    {
-        return options_;
-    }
-
-    [[nodiscard]] couchbase::core::cluster_options& options()
-    {
-        return options_;
-    }
-
-    [[nodiscard]] const couchbase::core::cluster_credentials& credentials() const
-    {
-        return credentials_;
-    }
+    void restart();
 
+    [[nodiscard]] const couchbase::core::cluster_options& options() const;
+    [[nodiscard]] couchbase::core::cluster_options& options();
+    [[nodiscard]] const couchbase::core::cluster_credentials& credentials() const;
     [[nodiscard]] auto to_json() const -> std::string;
 
   private:

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

@@ -31,9 +31,9 @@ class cluster_map_change_notification_request_body
     static const inline server_opcode opcode = server_opcode::cluster_map_change_notification;
 
   private:
-    std::uint32_t protocol_revision_;
-    std::string bucket_;
-    std::optional<topology::configuration> config_;
+    std::uint32_t protocol_revision_{};
+    std::string bucket_{};
+    std::optional<topology::configuration> config_{};
 
   public:
     [[nodiscard]] std::uint32_t protocol_revision() const

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

@@ -88,6 +88,11 @@ class hello_request_body
         features_.emplace_back(hello_feature::clustermap_change_notification);
     }
 
+    void enable_deduplicate_not_my_vbucket_clustermap()
+    {
+        features_.emplace_back(hello_feature::deduplicate_not_my_vbucket_clustermap);
+    }
+
     void enable_compression()
     {
         features_.emplace_back(hello_feature::snappy);

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

@@ -34,10 +34,10 @@ class observe_seqno_response_body
     static const inline client_opcode opcode = client_opcode::observe_seqno;
 
   private:
-    std::uint16_t partition_id_;
-    std::uint64_t partition_uuid_;
-    std::uint64_t last_persisted_sequence_number_;
-    std::uint64_t current_sequence_number_;
+    std::uint16_t partition_id_{};
+    std::uint64_t partition_uuid_{};
+    std::uint64_t last_persisted_sequence_number_{};
+    std::uint64_t current_sequence_number_{};
     std::optional<std::uint64_t> old_partition_uuid_{};
     std::optional<std::uint64_t> last_received_sequence_number_{};
 

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

@@ -160,6 +160,11 @@ enum class hello_feature : std::uint16_t {
      * Indicates support for subdoc lookup operations on replicas
      */
     subdoc_replica_read = 0x1c,
+
+    /**
+     * The server will not send configuration body to the connections, that already has seen it.
+     */
+    deduplicate_not_my_vbucket_clustermap = 0x1e,
 };
 
 constexpr bool
@@ -191,6 +196,7 @@ is_valid_hello_feature(std::uint16_t code)
         case hello_feature::replace_body_with_xattr:
         case hello_feature::resource_units:
         case hello_feature::subdoc_replica_read:
+        case hello_feature::deduplicate_not_my_vbucket_clustermap:
             return true;
     }
     return false;