couchbase 4.2.1 → 4.2.2

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

@@ -0,0 +1,116 @@
+/* -*- 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/common_options.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+class drop_query_index_options : public common_options<drop_query_index_options>
+{
+  public:
+    /**
+     * Set flag to ignore error if the index already exists
+     *
+     * The default is to not ignore the error.
+     *
+     * @param ignore_if_exists  if true, we don't return an error if the index already exists
+     * @return reference to this object, for use in chaining.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto ignore_if_not_exists(bool ignore_if_not_exists) -> drop_query_index_options&
+    {
+        ignore_if_not_exists_ = ignore_if_not_exists;
+        return self();
+    }
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<drop_query_index_options>::built {
+        bool ignore_if_not_exists{};
+    };
+
+    /**
+     * Validates options and returns them as an immutable value.
+     *
+     * @return consistent options as an immutable value
+     *
+     * @exception std::system_error with code errc::common::invalid_argument if the options are not valid
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options(), ignore_if_not_exists_ };
+    }
+
+  private:
+    bool ignore_if_not_exists_{ false };
+};
+
+/**
+ * The signature for the handler of the @ref query_index_manager#get_all_indexes() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+
+using drop_query_index_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_drop_query_index(std::shared_ptr<couchbase::core::cluster> core,
+                          std::string bucket_name,
+                          std::string index_name,
+                          couchbase::drop_query_index_options::built options,
+                          query_context query_ctx,
+                          std::string collection_name,
+                          drop_query_index_handler&& handler);
+void
+initiate_drop_query_index(std::shared_ptr<couchbase::core::cluster> core,
+                          std::string bucket_name,
+                          std::string index_name,
+                          couchbase::drop_query_index_options::built options,
+                          drop_query_index_handler&& handler);
+
+#endif
+} // namespace impl
+} // namespace core
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/fmt/cas.hxx

@@ -32,6 +32,6 @@ struct fmt::formatter<couchbase::cas> {
     template<typename FormatContext>
     auto format(const couchbase::cas& cas, FormatContext& ctx) const
     {
-        return format_to(ctx.out(), "{:x}", cas.value());
+        return format_to(ctx.out(), "{:016x}", cas.value());
     }
 };

package/deps/couchbase-cxx-client/couchbase/fmt/query_scan_consistency.hxx

@@ -0,0 +1,46 @@
+/* -*- 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/query_scan_consistency.hxx>
+
+#include <fmt/core.h>
+
+template<>
+struct fmt::formatter<couchbase::query_scan_consistency> {
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(couchbase::query_scan_consistency mode, FormatContext& ctx) const
+    {
+        string_view name = "unknown";
+        switch (mode) {
+            case couchbase::query_scan_consistency::not_bounded:
+                name = "not_bounded";
+                break;
+            case couchbase::query_scan_consistency::request_plus:
+                name = "request_plus";
+                break;
+        }
+        return format_to(ctx.out(), "{}", name);
+    }
+};

package/deps/couchbase-cxx-client/couchbase/fmt/query_status.hxx

@@ -0,0 +1,70 @@
+/* -*- 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/query_status.hxx>
+
+#include <fmt/core.h>
+
+template<>
+struct fmt::formatter<couchbase::query_status> {
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(couchbase::query_status status, FormatContext& ctx) const
+    {
+        string_view name = "unknown";
+        switch (status) {
+            case couchbase::query_status::running:
+                name = "running";
+                break;
+            case couchbase::query_status::success:
+                name = "success";
+                break;
+            case couchbase::query_status::errors:
+                name = "errors";
+                break;
+            case couchbase::query_status::completed:
+                name = "completed";
+                break;
+            case couchbase::query_status::stopped:
+                name = "stopped";
+                break;
+            case couchbase::query_status::timeout:
+                name = "timeout";
+                break;
+            case couchbase::query_status::closed:
+                name = "closed";
+                break;
+            case couchbase::query_status::fatal:
+                name = "fatal";
+                break;
+            case couchbase::query_status::aborted:
+                name = "aborted";
+                break;
+            case couchbase::query_status::unknown:
+                name = "unknown";
+                break;
+        }
+        return format_to(ctx.out(), "{}", name);
+    }
+};

package/deps/couchbase-cxx-client/couchbase/fmt/tls_verify_mode.hxx

@@ -0,0 +1,46 @@
+/* -*- 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/tls_verify_mode.hxx>
+
+#include <fmt/core.h>
+
+template<>
+struct fmt::formatter<couchbase::tls_verify_mode> {
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(couchbase::tls_verify_mode mode, FormatContext& ctx) const
+    {
+        string_view name = "unknown";
+        switch (mode) {
+            case couchbase::tls_verify_mode::none:
+                name = "none";
+                break;
+            case couchbase::tls_verify_mode::peer:
+                name = "peer";
+                break;
+        }
+        return format_to(ctx.out(), "{}", name);
+    }
+};

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

@@ -0,0 +1,100 @@
+/* -*- 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/common_options.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/management/query_index.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+class get_all_query_indexes_options : public common_options<get_all_query_indexes_options>
+{
+  public:
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<get_all_query_indexes_options>::built {
+    };
+
+    /**
+     * Validates options and returns them as an immutable value.
+     *
+     * @return consistent options as an immutable value
+     *
+     * @exception std::system_error with code errc::common::invalid_argument if the options are not valid
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+
+  private:
+};
+
+/**
+ * The signature for the handler of the @ref query_index_manager#get_all_indexes() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+
+using get_all_indexes_handler = std::function<void(couchbase::manager_error_context, std::vector<couchbase::management::query::index>)>;
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace core
+{
+class cluster;
+class query_context;
+namespace impl
+{
+
+/**
+ * @since 1.0.0
+ * @internal
+ */
+void
+initiate_get_all_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
+                               std::string bucket_name,
+                               couchbase::get_all_query_indexes_options::built options,
+                               get_all_indexes_handler&& handler);
+
+void
+initiate_get_all_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
+                               std::string bucket_name,
+                               couchbase::get_all_query_indexes_options::built options,
+                               query_context query_ctx,
+                               std::string collection_name,
+                               get_all_indexes_handler&& handler);
+
+#endif
+} // namespace impl
+} // namespace core
+} // namespace couchbase

package/deps/couchbase-cxx-client/{core → couchbase}/management/query_index.hxx

@@ -21,7 +21,7 @@
 #include <string>
 #include <vector>
 
-namespace couchbase::core::management::query
+namespace couchbase::management::query
 {
 struct index {
     bool is_primary{ false };
@@ -36,4 +36,4 @@ struct index {
     std::optional<std::string> collection_name{};
 };
 
-} // namespace couchbase::core::management::query
+} // namespace couchbase::management::query

package/deps/couchbase-cxx-client/couchbase/metrics/meter.hxx

@@ -46,6 +46,22 @@ class meter
     meter& operator=(meter&& other) = default;
     virtual ~meter() = default;
 
+    /**
+     * SDK invokes this method when cluster is ready to emit metrics. Override it as NO-OP if no action is necessary.
+     */
+    virtual void start()
+    {
+        /* do nothing */
+    }
+
+    /**
+     * SDK invokes this method when cluster is closed. Override it as NO-OP if no action is necessary.
+     */
+    virtual void stop()
+    {
+        /* do nothing */
+    }
+
     virtual std::shared_ptr<value_recorder> get_value_recorder(const std::string& name, const std::map<std::string, std::string>& tags) = 0;
 };
 

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

@@ -18,6 +18,12 @@
 #pragma once
 
 #include <couchbase/build_query_index_options.hxx>
+#include <couchbase/create_primary_query_index_options.hxx>
+#include <couchbase/create_query_index_options.hxx>
+#include <couchbase/drop_primary_query_index_options.hxx>
+#include <couchbase/drop_query_index_options.hxx>
+#include <couchbase/get_all_query_indexes_options.hxx>
+#include <couchbase/watch_query_indexes_options.hxx>
 
 #include <future>
 #include <memory>
@@ -42,22 +48,158 @@ class cluster;
 class query_index_manager
 {
   public:
+    /**
+     * Get all indexes within a bucket.
+     *
+     *
+     * @param bucket_name specifies the bucket in which we look for the indexes
+     * @param options optional parameters
+     * @param handler the handler that implements @ref get_all_query_indexes_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void get_all_indexes(std::string bucket_name, const get_all_query_indexes_options& options, get_all_indexes_handler&& handler) const
+    {
+        return core::impl::initiate_get_all_query_indexes(
+          core_, std::move(bucket_name), options.build(), std::forward<get_all_indexes_handler>(handler));
+    }
+    [[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;
+    }
+    /**
+     * Create an index on a bucket.
+     *
+     * @param bucket_name specifies the bucket in which to create the index
+     * @param index_name name of the index
+     * @param fields the fields to create the index over
+     * @param options optional parameters
+     * @param handler the handler that implements @ref create_query_index_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void create_index(std::string bucket_name,
+                      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));
+    }
+
+    [[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;
+    }
+
+    /**
+     * Create a primary index on a bucket.
+     *
+     * @param bucket_name specifies the bucket in which to create the index
+     * @param options optional parameters
+     * @param handler the handler that implements @ref create_query_index_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    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));
+    }
+
+    [[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;
+    }
+    /**
+     * Drop primary index on a bucket.
+     *
+     * @param bucket_name name of the bucket in which to drop the primary index
+     * @param options optional parameters
+     * @param handler the handler that implements @ref drop_query_index_handler
+     *
+     * @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));
+    }
+
+    [[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;
+    }
+
+    /**
+     *
+     * @param bucket_name name of the bucket in which to drop the index
+     * @param index_name name of the index to drop
+     * @param options optional parameters
+     * @param handler handler that implements @ref drop_query_index_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    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));
+    }
+
+    [[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;
+    }
     /**
      * Builds all currently deferred indexes.
      *
-     * By default, this method will build the indexes on the bucket. If the indexes should be built on a collection, both
-     * {@link build_query_index_options#scope_name} and {@link build_query_index_options#collection_name} must be set.
+     * By default, this method will build the indexes on the bucket.
      *
-     * @tparam Handler
      * @param bucket_name name of the bucket
      * @param options the custom options
      * @param handler the handler that implements @ref build_deferred_query_indexes_handler
+     *
+     * @since 1.0.0
+     * @committed
      */
-    template<typename Handler>
-    void build_deferred_indexes(std::string bucket_name, const build_query_index_options& options, Handler&& handler) const
+    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), std::move(options.build()), std::forward<Handler>(handler));
+          core_, std::move(bucket_name), options.build(), std::forward<build_deferred_query_indexes_handler>(handler));
     }
 
     [[nodiscard]] auto build_deferred_indexes(std::string bucket_name, const build_query_index_options& options) const
@@ -69,6 +211,36 @@ class query_index_manager
         return future;
     }
 
+    /**
+     * Polls the state of a set of indexes, until they all are online.
+     *
+     * @param bucket_name name of the bucket in which to look for the indexes
+     * @param index_names names of the indexes to watch
+     * @param options optional parameters
+     * @param handler handler that implements @ref watch_query_indexes_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    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));
+    }
+
+    [[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;
+    }
+
   private:
     friend class cluster;