couchbase 3.4.3 → 3.4.5

data/ext/couchbase/couchbase/management/collection_spec.hxx

@@ -0,0 +1,29 @@
+/* -*- 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::management::bucket
+{
+struct collection_spec {
+    std::string name;
+    std::string scope_name;
+    std::uint32_t max_expiry{};
+    std::optional<bool> history{};
+};
+
+} // namespace couchbase::management::bucket

data/ext/couchbase/couchbase/management/scope_spec.hxx

@@ -0,0 +1,29 @@
+/* -*- 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 <couchbase/management/collection_spec.hxx>
+
+namespace couchbase::management::bucket
+{
+struct scope_spec {
+    std::string name;
+    std::vector<collection_spec> collections;
+};
+
+} // namespace couchbase::management::bucket

data/ext/couchbase/couchbase/manager_error_context.hxx

@@ -17,14 +17,20 @@
 
 #pragma once
 
+#include "core/impl/internal_manager_error_context.hxx"
 #include <couchbase/error_context.hxx>
 
 #include <cstdint>
+#include <memory>
 #include <optional>
 #include <string>
 
 namespace couchbase
 {
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+class internal_manager_error_context;
+#endif
+
 /**
  * The error context returned with manager operations.
  *
@@ -40,40 +46,25 @@ class manager_error_context : public error_context
      * @since 1.0.0
      * @committed
      */
-    manager_error_context() = default;
+    manager_error_context();
+    explicit manager_error_context(internal_manager_error_context ctx);
+    manager_error_context(manager_error_context&& other);
+    manager_error_context& operator=(manager_error_context&& other);
+    manager_error_context(const manager_error_context& other) = delete;
+    manager_error_context& operator=(const manager_error_context& other) = delete;
+    ~manager_error_context() override;
 
-    /**
-     * Creates and initializes error context with given parameters.
-     *
-     * @param ec
-     * @param last_dispatched_to
-     * @param last_dispatched_from
-     * @param retry_attempts
-     * @param retry_reasons
-     * @param client_context_id
-     * @param http_status
-     * @param content
-     * @param path
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    manager_error_context(std::error_code ec,
-                          std::optional<std::string> last_dispatched_to,
-                          std::optional<std::string> last_dispatched_from,
-                          std::size_t retry_attempts,
-                          std::set<retry_reason> retry_reasons,
-                          std::string client_context_id,
-                          std::uint32_t http_status,
-                          std::string content,
-                          std::string path)
-      : error_context{ ec, std::move(last_dispatched_to), std::move(last_dispatched_from), retry_attempts, std::move(retry_reasons) }
-      , client_context_id_{ std::move(client_context_id) }
-      , http_status_{ http_status }
-      , content_{ std::move(content) }
-      , path_{ std::move(path) }
-    {
-    }
+    [[nodiscard]] auto ec() const -> std::error_code override;
+
+    [[nodiscard]] auto last_dispatched_to() const -> const std::optional<std::string>& override;
+
+    [[nodiscard]] auto last_dispatched_from() const -> const std::optional<std::string>& override;
+
+    [[nodiscard]] auto retry_attempts() const -> std::size_t override;
+
+    [[nodiscard]] auto retry_reasons() const -> const std::set<retry_reason>& override;
+
+    [[nodiscard]] auto retried_because_of(retry_reason reason) const -> bool override;
 
     /**
      * Returns request path.
@@ -83,10 +74,7 @@ class manager_error_context : public error_context
      * @since 1.0.0
      * @uncommitted
      */
-    [[nodiscard]] auto path() const -> const std::string&
-    {
-        return path_;
-    }
+    [[nodiscard]] auto path() const -> const std::string&;
 
     /**
      * Returns response body.
@@ -96,10 +84,7 @@ class manager_error_context : public error_context
      * @since 1.0.0
      * @committed
      */
-    [[nodiscard]] auto content() const -> const std::string&
-    {
-        return content_;
-    }
+    [[nodiscard]] auto content() const -> const std::string&;
 
     /**
      * Returns the unique
@@ -109,10 +94,7 @@ class manager_error_context : public error_context
      * @since 1.0.0
      * @uncommitted
      */
-    [[nodiscard]] auto client_context_id() const -> const std::string&
-    {
-        return client_context_id_;
-    }
+    [[nodiscard]] auto client_context_id() const -> const std::string&;
 
     /**
      * Returns HTTP status of response
@@ -122,15 +104,9 @@ class manager_error_context : public error_context
      * @since 1.0.0
      * @committed
      */
-    [[nodiscard]] auto http_status() const -> std::uint32_t
-    {
-        return http_status_;
-    }
+    [[nodiscard]] auto http_status() const -> std::uint32_t;
 
   private:
-    std::string client_context_id_{};
-    std::uint32_t http_status_{};
-    std::string content_{};
-    std::string path_{};
+    std::unique_ptr<internal_manager_error_context> internal_;
 };
 } // namespace couchbase

data/ext/couchbase/couchbase/mutate_in_options.hxx

@@ -225,8 +225,8 @@ initiate_mutate_in_operation(std::shared_ptr<couchbase::core::cluster> core,
                              std::string collection_name,
                              std::string document_key,
                              const std::vector<couchbase::core::impl::subdoc::command>& specs,
-                             mutate_in_options::built options,
-                             mutate_in_handler&& handler);
+                             couchbase::mutate_in_options::built options,
+                             couchbase::mutate_in_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

data/ext/couchbase/couchbase/query_error_context.hxx

@@ -57,7 +57,7 @@ class query_error_context : public error_context
                         std::string http_body,
                         std::string hostname,
                         std::uint16_t port)
-      : error_context{ ec, std::move(last_dispatched_to), std::move(last_dispatched_from), retry_attempts, std::move(retry_reasons) }
+      : error_context{ {}, ec, std::move(last_dispatched_to), std::move(last_dispatched_from), retry_attempts, std::move(retry_reasons) }
       , first_error_code_{ first_error_code }
       , first_error_message_{ std::move(first_error_message) }
       , client_context_id_{ std::move(client_context_id) }
@@ -127,6 +127,8 @@ class query_error_context : public error_context
         return port_;
     }
 
+    [[nodiscard]] auto to_json() const -> std::string;
+
   private:
     std::uint64_t first_error_code_{};
     std::string first_error_message_{};

data/ext/couchbase/couchbase/query_index_manager.hxx

@@ -61,19 +61,11 @@ class query_index_manager
      */
     void get_all_indexes(std::string bucket_name,
                          const get_all_query_indexes_options& options,
-                         get_all_query_indexes_handler&& handler) const
-    {
-        return core::impl::initiate_get_all_query_indexes(
-          core_, std::move(bucket_name), options.build(), std::forward<get_all_query_indexes_handler>(handler));
-    }
+                         get_all_query_indexes_handler&& handler) const;
+
     [[nodiscard]] auto get_all_indexes(std::string bucket_name, const get_all_query_indexes_options& options) const
-      -> std::future<std::pair<manager_error_context, std::vector<couchbase::management::query::index>>>
-    {
-        auto barrier = std::make_shared<std::promise<std::pair<manager_error_context, std::vector<couchbase::management::query::index>>>>();
-        auto future = barrier->get_future();
-        get_all_indexes(std::move(bucket_name), options, [barrier](auto ctx, auto resp) { barrier->set_value({ ctx, resp }); });
-        return future;
-    }
+      -> std::future<std::pair<manager_error_context, std::vector<couchbase::management::query::index>>>;
+
     /**
      * Create an index on a bucket.
      *
@@ -90,23 +82,12 @@ class query_index_manager
                       std::string index_name,
                       std::vector<std::string> fields,
                       const create_query_index_options& options,
-                      create_query_index_handler&& handler) const
-    {
-        core::impl::initiate_create_query_index(
-          core_, std::move(bucket_name), std::move(index_name), std::move(fields), options.build(), std::move(handler));
-    }
+                      create_query_index_handler&& handler) const;
 
     [[nodiscard]] auto create_index(std::string bucket_name,
                                     std::string index_name,
                                     std::vector<std::string> fields,
-                                    const create_query_index_options& options) const -> std::future<manager_error_context>
-    {
-        auto barrier = std::make_shared<std::promise<manager_error_context>>();
-        auto future = barrier->get_future();
-        create_index(
-          std::move(bucket_name), std::move(index_name), std::move(fields), options, [barrier](auto ctx) { barrier->set_value(ctx); });
-        return future;
-    }
+                                    const create_query_index_options& options) const -> std::future<manager_error_context>;
 
     /**
      * Create a primary index on a bucket.
@@ -120,19 +101,10 @@ class query_index_manager
      */
     void create_primary_index(std::string bucket_name,
                               const create_primary_query_index_options& options,
-                              create_query_index_handler&& handler)
-    {
-        return core::impl::initiate_create_primary_query_index(core_, std::move(bucket_name), options.build(), std::move(handler));
-    }
+                              create_query_index_handler&& handler);
 
     [[nodiscard]] auto create_primary_index(std::string bucket_name, const create_primary_query_index_options& options)
-      -> std::future<manager_error_context>
-    {
-        auto barrier = std::make_shared<std::promise<manager_error_context>>();
-        auto future = barrier->get_future();
-        create_primary_index(std::move(bucket_name), options, [barrier](auto ctx) { barrier->set_value(ctx); });
-        return future;
-    }
+      -> std::future<manager_error_context>;
     /**
      * Drop primary index on a bucket.
      *
@@ -143,19 +115,10 @@ class query_index_manager
      * @since 1.0.0
      * @committed
      */
-    void drop_primary_index(std::string bucket_name, const drop_primary_query_index_options& options, drop_query_index_handler&& handler)
-    {
-        return core::impl::initiate_drop_primary_query_index(core_, std::move(bucket_name), options.build(), std::move(handler));
-    }
+    void drop_primary_index(std::string bucket_name, const drop_primary_query_index_options& options, drop_query_index_handler&& handler);
 
     [[nodiscard]] auto drop_primary_index(std::string bucket_name, const drop_primary_query_index_options& options)
-      -> std::future<manager_error_context>
-    {
-        auto barrier = std::make_shared<std::promise<manager_error_context>>();
-        auto future = barrier->get_future();
-        drop_primary_index(std::move(bucket_name), options, [barrier](auto ctx) { barrier->set_value(ctx); });
-        return future;
-    }
+      -> std::future<manager_error_context>;
 
     /**
      *
@@ -170,20 +133,10 @@ class query_index_manager
     void drop_index(std::string bucket_name,
                     std::string index_name,
                     const drop_query_index_options& options,
-                    drop_query_index_handler&& handler)
-    {
-        return core::impl::initiate_drop_query_index(
-          core_, std::move(bucket_name), std::move(index_name), options.build(), std::move(handler));
-    }
+                    drop_query_index_handler&& handler);
 
     [[nodiscard]] auto drop_index(std::string bucket_name, std::string index_name, const drop_query_index_options& options)
-      -> std::future<manager_error_context>
-    {
-        auto barrier = std::make_shared<std::promise<manager_error_context>>();
-        auto future = barrier->get_future();
-        drop_index(std::move(bucket_name), std::move(index_name), options, [barrier](auto ctx) { barrier->set_value(ctx); });
-        return future;
-    }
+      -> std::future<manager_error_context>;
     /**
      * Builds all currently deferred indexes.
      *
@@ -198,20 +151,10 @@ class query_index_manager
      */
     void build_deferred_indexes(std::string bucket_name,
                                 const build_query_index_options& options,
-                                build_deferred_query_indexes_handler&& handler) const
-    {
-        return core::impl::initiate_build_deferred_indexes(
-          core_, std::move(bucket_name), options.build(), std::forward<build_deferred_query_indexes_handler>(handler));
-    }
+                                build_deferred_query_indexes_handler&& handler) const;
 
     [[nodiscard]] auto build_deferred_indexes(std::string bucket_name, const build_query_index_options& options) const
-      -> std::future<manager_error_context>
-    {
-        auto barrier = std::make_shared<std::promise<manager_error_context>>();
-        auto future = barrier->get_future();
-        build_deferred_indexes(std::move(bucket_name), options, [barrier](auto ctx) { barrier->set_value(std::move(ctx)); });
-        return future;
-    }
+      -> std::future<manager_error_context>;
 
     /**
      * Polls the state of a set of indexes, until they all are online.
@@ -227,21 +170,11 @@ class query_index_manager
     void watch_indexes(std::string bucket_name,
                        std::vector<std::string> index_names,
                        const watch_query_indexes_options& options,
-                       watch_query_indexes_handler&& handler)
-    {
-        return core::impl::initiate_watch_query_indexes(
-          core_, std::move(bucket_name), std::move(index_names), options.build(), std::move(handler));
-    }
+                       watch_query_indexes_handler&& handler);
 
     [[nodiscard]] auto watch_indexes(std::string bucket_name,
                                      std::vector<std::string> index_names,
-                                     const watch_query_indexes_options& options)
-    {
-        auto barrier = std::make_shared<std::promise<manager_error_context>>();
-        auto future = barrier->get_future();
-        watch_indexes(std::move(bucket_name), std::move(index_names), options, [barrier](auto ctx) { barrier->set_value(ctx); });
-        return future;
-    }
+                                     const watch_query_indexes_options& options) -> std::future<manager_error_context>;
 
   private:
     friend class cluster;

data/ext/couchbase/couchbase/query_options.hxx

@@ -51,6 +51,7 @@ struct query_options : public common_options<query_options> {
         const bool readonly;
         const bool flex_index;
         const bool preserve_expiry;
+        std::optional<bool> use_replica;
         std::optional<std::uint64_t> max_parallelism;
         std::optional<std::uint64_t> scan_cap;
         std::optional<std::chrono::milliseconds> scan_wait;
@@ -84,6 +85,7 @@ struct query_options : public common_options<query_options> {
             readonly_,
             flex_index_,
             preserve_expiry_,
+            use_replica_,
             max_parallelism_,
             scan_cap_,
             scan_wait_,
@@ -225,6 +227,21 @@ struct query_options : public common_options<query_options> {
         return self();
     }
 
+    /**
+     * Specifies that the query engine should use replica nodes for KV fetches if the active node is down.
+     *
+     * @param use_replica whether replica nodes should be used if the active node is down. If not provided, the server default will be used.
+     * @return the options builder for chaining purposes.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto use_replica(bool use_replica) -> query_options&
+    {
+        use_replica_ = use_replica;
+        return self();
+    }
+
     /**
      * Allows overriding the default maximum parallelism for the query execution on the server side.
      *
@@ -529,6 +546,7 @@ struct query_options : public common_options<query_options> {
     bool readonly_{ false };
     bool flex_index_{ false };
     bool preserve_expiry_{ false };
+    std::optional<bool> use_replica_{};
     std::optional<std::uint64_t> max_parallelism_{};
     std::optional<std::uint64_t> scan_cap_{};
     std::optional<std::uint64_t> pipeline_batch_{};

data/ext/couchbase/couchbase/remove_options.hxx

@@ -115,8 +115,8 @@ initiate_remove_operation(std::shared_ptr<couchbase::core::cluster> core,
                           std::string scope_name,
                           std::string collection_name,
                           std::string document_key,
-                          remove_options::built options,
-                          remove_handler&& handler);
+                          couchbase::remove_options::built options,
+                          couchbase::remove_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

data/ext/couchbase/couchbase/replace_options.hxx

@@ -175,9 +175,9 @@ initiate_replace_operation(std::shared_ptr<couchbase::core::cluster> core,
                            std::string scope_name,
                            std::string collection_name,
                            std::string document_key,
-                           codec::encoded_value encoded,
-                           replace_options::built options,
-                           replace_handler&& handler);
+                           couchbase::codec::encoded_value encoded,
+                           couchbase::replace_options::built options,
+                           couchbase::replace_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

data/ext/couchbase/couchbase/security_options.hxx

@@ -45,11 +45,20 @@ class security_options
         return *this;
     }
 
+    auto trust_certificate_value(std::string certificate_value) -> security_options&
+    {
+        trust_certificate_value_ = certificate_value;
+        return *this;
+    }
+
     struct built {
         bool enabled;
         tls_verify_mode tls_verify;
         std::optional<std::string> trust_certificate;
+        std::optional<std::string> trust_certificate_value;
         bool disable_mozilla_ca_certificates;
+        bool disable_deprecated_protocols;
+        bool disable_tls_v1_2;
     };
 
     [[nodiscard]] auto build() const -> built
@@ -58,7 +67,10 @@ class security_options
             enabled_,
             tls_verify_,
             trust_certificate_,
+            trust_certificate_value_,
             disable_mozilla_ca_certificates_,
+            disable_deprecated_protocols,
+            disable_tls_v1_2,
         };
     }
 
@@ -66,6 +78,9 @@ class security_options
     bool enabled_{ true };
     tls_verify_mode tls_verify_{ tls_verify_mode::peer };
     std::optional<std::string> trust_certificate_{};
+    std::optional<std::string> trust_certificate_value_{};
     bool disable_mozilla_ca_certificates_{ false };
+    bool disable_deprecated_protocols{ true };
+    bool disable_tls_v1_2{ false };
 };
 } // namespace couchbase

data/ext/couchbase/couchbase/subdocument_error_context.hxx

@@ -62,7 +62,8 @@ class subdocument_error_context : public key_value_error_context
      * @since 1.0.0
      * @internal
      */
-    subdocument_error_context(std::error_code ec,
+    subdocument_error_context(std::string operation_id,
+                              std::error_code ec,
                               std::optional<std::string> last_dispatched_to,
                               std::optional<std::string> last_dispatched_from,
                               std::size_t retry_attempts,
@@ -79,7 +80,8 @@ class subdocument_error_context : public key_value_error_context
                               std::optional<std::string> first_error_path,
                               std::optional<std::uint64_t> first_error_index,
                               bool deleted)
-      : key_value_error_context{ ec,
+      : key_value_error_context{ std::move(operation_id),
+                                 ec,
                                  std::move(last_dispatched_to),
                                  std::move(last_dispatched_from),
                                  retry_attempts,

data/ext/couchbase/couchbase/touch_options.hxx

@@ -86,8 +86,8 @@ initiate_touch_operation(std::shared_ptr<couchbase::core::cluster> core,
                          std::string collection_name,
                          std::string document_key,
                          std::uint32_t expiry,
-                         touch_options::built options,
-                         touch_handler&& handler);
+                         couchbase::touch_options::built options,
+                         couchbase::touch_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

data/ext/couchbase/couchbase/unlock_options.hxx

@@ -89,8 +89,8 @@ initiate_unlock_operation(std::shared_ptr<couchbase::core::cluster> core,
                           std::string collection_name,
                           std::string document_key,
                           couchbase::cas cas,
-                          unlock_options::built options,
-                          unlock_handler&& handler);
+                          couchbase::unlock_options::built options,
+                          couchbase::unlock_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core

data/ext/couchbase/couchbase/update_bucket_options.hxx

@@ -0,0 +1,41 @@
+/* -*- 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 <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+struct update_bucket_options : public common_options<update_bucket_options> {
+  public:
+    struct built : public common_options<update_bucket_options>::built {
+    };
+
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+
+  private:
+};
+
+using update_bucket_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

data/ext/couchbase/couchbase/update_collection_options.hxx

@@ -0,0 +1,44 @@
+/* -*- 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 <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+struct update_collection_options : public common_options<update_collection_options> {
+  public:
+    struct built : public common_options<update_collection_options>::built {
+    };
+
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+};
+
+struct update_collection_settings {
+    std::optional<std::uint32_t> max_expiry{};
+    std::optional<bool> history{};
+};
+
+using update_collection_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

data/ext/couchbase/couchbase/upsert_options.hxx

@@ -149,9 +149,9 @@ initiate_upsert_operation(std::shared_ptr<couchbase::core::cluster> core,
                           std::string scope_name,
                           std::string collection_name,
                           std::string document_key,
-                          codec::encoded_value encoded,
-                          upsert_options::built options,
-                          upsert_handler&& handler);
+                          couchbase::codec::encoded_value encoded,
+                          couchbase::upsert_options::built options,
+                          couchbase::upsert_handler&& handler);
 #endif
 } // namespace impl
 } // namespace core