couchbase 4.2.5 → 4.2.6-dev

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

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

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

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

package/deps/couchbase-cxx-client/couchbase/watch_query_indexes_options.hxx

@@ -81,35 +81,4 @@ class watch_query_indexes_options : public common_options<watch_query_indexes_op
  */
 
 using watch_query_indexes_handler = std::function<void(couchbase::manager_error_context)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-class query_context;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_watch_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
-                             std::string bucket_name,
-                             std::vector<std::string> index_names,
-                             couchbase::watch_query_indexes_options::built options,
-                             query_context query_ctx,
-                             std::string collection_name,
-                             watch_query_indexes_handler&& handler);
-void
-initiate_watch_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
-                             std::string bucket_name,
-                             std::vector<std::string> index_names,
-                             couchbase::watch_query_indexes_options::built options,
-                             watch_query_indexes_handler&& handler);
-
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

package/deps/couchbase-cxx-client/docs/cbc-analytics.md

@@ -141,6 +141,7 @@ Execute one or more Analytics queries and print results to standard output.
 
 <dl>
 <dt>`--user-agent-extra=STRING`</dt><dd>Append extra string SDK identifiers. [default: `cbc`].</dd>
+<dt>`--network=STRING`</dt><dd>Network (a.k.a. Alternate Addresses) to use. [default: `auto`]</dd>
 <dt>`--show-queries`</dt><dd>Log queries on INFO level.</dd>
 <dt>`--enable-clustermap-notifications`</dt><dd>Allow server to send notifications when cluster configuration changes.</dd>
 <dt>`--disable-mutation-tokens`</dt><dd>Do not request Key/Value service to send mutation tokens.</dd>

package/deps/couchbase-cxx-client/docs/cbc-get.md

@@ -141,6 +141,7 @@ Retrieve one or more documents from the server and print them to standard output
 
 <dl>
 <dt>`--user-agent-extra=STRING`</dt><dd>Append extra string SDK identifiers. [default: `cbc`].</dd>
+<dt>`--network=STRING`</dt><dd>Network (a.k.a. Alternate Addresses) to use. [default: `auto`]</dd>
 <dt>`--show-queries`</dt><dd>Log queries on INFO level.</dd>
 <dt>`--enable-clustermap-notifications`</dt><dd>Allow server to send notifications when cluster configuration changes.</dd>
 <dt>`--disable-mutation-tokens`</dt><dd>Do not request Key/Value service to send mutation tokens.</dd>

package/deps/couchbase-cxx-client/docs/cbc-pillowfight.md

@@ -148,6 +148,7 @@ Run simple workload generator that sends GET/UPSERT requests with optional N1QL
 
 <dl>
 <dt>`--user-agent-extra=STRING`</dt><dd>Append extra string SDK identifiers. [default: `cbc`].</dd>
+<dt>`--network=STRING`</dt><dd>Network (a.k.a. Alternate Addresses) to use. [default: `auto`]</dd>
 <dt>`--show-queries`</dt><dd>Log queries on INFO level.</dd>
 <dt>`--enable-clustermap-notifications`</dt><dd>Allow server to send notifications when cluster configuration changes.</dd>
 <dt>`--disable-mutation-tokens`</dt><dd>Do not request Key/Value service to send mutation tokens.</dd>

package/deps/couchbase-cxx-client/docs/cbc-query.md

@@ -149,6 +149,7 @@ Execute one or more N1QL queries and print results to standard output.
 
 <dl>
 <dt>`--user-agent-extra=STRING`</dt><dd>Append extra string SDK identifiers. [default: `cbc`].</dd>
+<dt>`--network=STRING`</dt><dd>Network (a.k.a. Alternate Addresses) to use. [default: `auto`]</dd>
 <dt>`--show-queries`</dt><dd>Log queries on INFO level.</dd>
 <dt>`--enable-clustermap-notifications`</dt><dd>Allow server to send notifications when cluster configuration changes.</dd>
 <dt>`--disable-mutation-tokens`</dt><dd>Do not request Key/Value service to send mutation tokens.</dd>

package/deps/couchbase-cxx-client/docs/cbc.md

@@ -32,6 +32,16 @@ Retrieve document from the server. See [cbc-get](md_docs_2cbc-get) for more info
 <dd>
 Perform N1QL query. See [cbc-query](md_docs_2cbc-query) for more information.
 </dd>
+
+<dt>analytics</dt>
+<dd>
+Perform Analytics query. See [cbc-analytics](md_docs_2cbc-analytics) for more information.
+</dd>
+
+<dt>pillowfight</dt>
+<dd>
+Run simple workload generator. See [cbc-pillowfight](md_docs_2cbc-pillowfight) for more information.
+</dd>
 </dl>
 
 ### OPTIONS

package/deps/couchbase-cxx-client/test/CMakeLists.txt

@@ -26,6 +26,7 @@ unit_test(jsonsl)
 unit_test(config_profiles)
 unit_test(options)
 unit_test(search)
+unit_test(query)
 target_link_libraries(test_unit_jsonsl jsonsl)
 
 integration_benchmark(get)

package/deps/couchbase-cxx-client/test/test_integration_collections.cxx

@@ -113,6 +113,12 @@ TEST_CASE("integration: get and insert non default scope and collection", "[inte
         REQUIRE_SUCCESS(resp.ctx.ec());
         REQUIRE(resp.value == couchbase::core::utils::to_binary(key));
     }
+
+    {
+        couchbase::core::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+    }
 }
 
 TEST_CASE("integration: insert into dropped scope", "[integration]")

package/deps/couchbase-cxx-client/test/test_integration_crud.cxx

@@ -315,6 +315,11 @@ TEST_CASE("integration: lock/unlock without lock time", "[integration]")
 TEST_CASE("integration: touch with zero expiry resets expiry", "[integration]")
 {
     test::utils::integration_test_guard integration;
+
+    if (integration.ctx.deployment == test::utils::deployment_type::elixir) {
+        SKIP("Timeout is too strict for sanity test env");
+    }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("get_reset_expiry_key") };

package/deps/couchbase-cxx-client/test/test_integration_examples.cxx

@@ -132,6 +132,9 @@ row: {"airline":{"callsign":"MILE-AIR","country":"United States","iata":"Q5","ic
 TEST_CASE("example: start using", "[integration]")
 {
     test::utils::integration_test_guard integration;
+    if (integration.cluster_version().is_capella()) {
+        SKIP("Capella does not allow to use REST API to load sample buckets");
+    }
     if (!integration.cluster_version().supports_collections()) {
         SKIP("cluster does not support collections");
     }
@@ -438,8 +441,12 @@ row: {"airline":{"callsign":"MILE-AIR","country":"United States","iata":"Q5","ic
 TEST_CASE("example: search", "[integration]")
 {
     test::utils::integration_test_guard integration;
+
+    if (integration.cluster_version().is_capella()) {
+        SKIP("Capella does not allow to use REST API to load sample buckets");
+    }
     if (!integration.cluster_version().supports_collections()) {
-        return;
+        SKIP("cluster does not support collections");
     }
 
     const auto env = test::utils::test_context::load_from_environment();
@@ -452,3 +459,132 @@ TEST_CASE("example: search", "[integration]")
 
     REQUIRE(example_search::main(4, argv) == 0);
 }
+
+namespace example_buckets
+{
+//! [example-buckets]
+#include <couchbase/cluster.hxx>
+
+int
+main(int argc, const char* argv[])
+{
+    if (argc != 4) {
+        fmt::print("USAGE: ./example_buckets couchbase://127.0.0.1 Administrator password\n");
+        return 1;
+    }
+
+    std::string connection_string{ argv[1] }; // "couchbase://127.0.0.1"
+    std::string username{ argv[2] };          // "Administrator"
+    std::string password{ argv[3] };          // "password"
+    std::string bucket_name{ "travel-sample" };
+
+    // run IO context on separate thread
+    asio::io_context io;
+    auto guard = asio::make_work_guard(io);
+    std::thread io_thread([&io]() { io.run(); });
+
+    auto options = couchbase::cluster_options(username, password);
+    // customize through the 'options'.
+    // For example, optimize timeouts for WAN
+    options.apply_profile("wan_development");
+
+    auto [cluster, ec] = couchbase::cluster::connect(io, connection_string, options).get();
+    if (ec) {
+        fmt::print("unable to connect to the cluster: {}\n", ec.message());
+        return 1;
+    }
+    auto manager = cluster.buckets();
+
+    couchbase::management::cluster::bucket_settings bucket_settings{};
+    std::string test_bucket_name = "cxx_test_integration_examples_bucket";
+    bucket_settings.name = test_bucket_name;
+    bucket_settings.ram_quota_mb = 150;
+    bucket_settings.bucket_type = couchbase::management::cluster::bucket_type::couchbase;
+    bucket_settings.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::value_only;
+    bucket_settings.flush_enabled = true;
+    bucket_settings.replica_indexes = true;
+    bucket_settings.conflict_resolution_type = couchbase::management::cluster::bucket_conflict_resolution::sequence_number;
+    {
+        fmt::print("--- create bucket\n");
+        auto ctx = manager.create_bucket(bucket_settings).get();
+        if (ctx.ec()) {
+            if (ctx.ec() == couchbase::errc::common::invalid_argument) {
+                fmt::print("bucket already exists\n");
+            } else {
+                fmt::print("unable to create the bucket: {}\n", ctx.ec().message());
+                return 1;
+            }
+        } else {
+            fmt::print("--- bucket has been successfully created\n");
+        }
+    }
+    {
+        fmt::print("--- get bucket\n");
+        auto [ctx, bucket] = manager.get_bucket(bucket_name).get();
+        if (ctx.ec()) {
+            fmt::print("unable to get the bucket: {}\n", ctx.ec().message());
+            return 1;
+        }
+        fmt::print("name of fetched bucket: {}\n", bucket.name);
+    }
+    {
+        fmt::print("--- get all buckets\n");
+        auto [ctx, buckets] = manager.get_all_buckets().get();
+        if (ctx.ec()) {
+            fmt::print("unable to get all buckets: {}\n", ctx.ec().message());
+            return 1;
+        }
+        for (const auto& fetched_bucket : buckets) {
+            fmt::print("Bucket name: {}\n", fetched_bucket.name);
+        }
+    }
+    {
+        fmt::print("--- update bucket\n");
+        bucket_settings.ram_quota_mb = 150;
+        auto ctx = manager.update_bucket(bucket_settings).get();
+        if (ctx.ec()) {
+            fmt::print("unable to update the bucket: {}\n", ctx.ec().message());
+            return 1;
+        }
+        fmt::print("bucket has been updated\n");
+    }
+    {
+        fmt::print("--- drop bucket\n");
+        auto ctx = manager.drop_bucket(test_bucket_name).get();
+        if (ctx.ec()) {
+            fmt::print("unable to drop the bucket: {}\n", ctx.ec().message());
+            return 1;
+        }
+        fmt::print("bucket has been dropped\n");
+    }
+
+    // close cluster connection
+    cluster.close();
+    guard.reset();
+
+    io_thread.join();
+    return 0;
+}
+
+//! [example-buckets]
+} // namespace example_buckets
+
+TEST_CASE("example: bucket management", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+
+    if (integration.cluster_version().is_capella()) {
+        SKIP("Capella does not allow to use REST API to load sample buckets");
+    }
+
+    const auto env = test::utils::test_context::load_from_environment();
+
+    const char* argv[] = {
+        "example_buckets", // name of the "executable"
+        env.connection_string.c_str(),
+        env.username.c_str(),
+        env.password.c_str(),
+    };
+
+    REQUIRE(example_buckets::main(4, argv) == 0);
+}