couchbase 4.2.5 → 4.2.6-dev.1

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

@@ -136,37 +136,4 @@ class create_query_index_options : public common_options<create_query_index_opti
  */
 
 using create_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_create_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                            std::string bucket_name,
-                            std::string index_name,
-                            std::vector<std::string> fields,
-                            couchbase::create_query_index_options::built options,
-                            create_query_index_handler&& handler);
-void
-initiate_create_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                            std::string bucket_name,
-                            std::string index_name,
-                            std::vector<std::string> fields,
-                            couchbase::create_query_index_options::built options,
-                            query_context query_ctx,
-                            std::string collection_name,
-                            create_query_index_handler&& handler);
-
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/drop_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 drop_bucket_options : public common_options<drop_bucket_options> {
+  public:
+    struct built : public common_options<drop_bucket_options>::built {
+    };
+
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+
+  private:
+};
+
+using drop_bucket_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

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

@@ -96,34 +96,4 @@ class drop_primary_query_index_options : public common_options<drop_primary_quer
  */
 
 using drop_primary_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_primary_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                                  std::string bucket_name,
-                                  couchbase::drop_primary_query_index_options::built options,
-                                  query_context query_ctx,
-                                  std::string collection_name,
-                                  drop_primary_query_index_handler&& handler);
-
-void
-initiate_drop_primary_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                                  std::string bucket_name,
-                                  couchbase::drop_primary_query_index_options::built options,
-                                  drop_primary_query_index_handler&& handler);
-
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

@@ -82,35 +82,4 @@ class drop_query_index_options : public common_options<drop_query_index_options>
  */
 
 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/error_codes.hxx

@@ -599,8 +599,7 @@ enum class key_value {
     // KV Code: 0xd6
     cannot_revive_living_document = 131,
 
-    range_scan_cancelled = 132,
-    range_scan_vb_uuid_not_equal = 133,
+    mutation_token_outdated = 133,
     range_scan_completed = 134,
 };
 

package/deps/couchbase-cxx-client/couchbase/flush_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 flush_bucket_options : public common_options<flush_bucket_options> {
+  public:
+    struct built : public common_options<flush_bucket_options>::built {
+    };
+
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+
+  private:
+};
+
+using flush_bucket_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/get_all_buckets_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 <couchbase/management/bucket_settings.hxx>
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+struct get_all_buckets_options : public common_options<get_all_buckets_options> {
+  public:
+    struct built : public common_options<get_all_buckets_options>::built {
+    };
+
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+
+  private:
+};
+
+using get_all_buckets_handler =
+  std::function<void(couchbase::manager_error_context, std::vector<couchbase::management::cluster::bucket_settings>)>;
+} // namespace couchbase

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

@@ -68,34 +68,4 @@ class get_all_query_indexes_options : public common_options<get_all_query_indexe
 
 using get_all_query_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_query_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_query_indexes_handler&& handler);
-
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

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

package/deps/couchbase-cxx-client/couchbase/management/bucket_settings.hxx

@@ -0,0 +1,116 @@
+/* -*- 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/durability_level.hxx>
+
+#include <map>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace couchbase::management::cluster
+{
+enum class bucket_type { unknown, couchbase, memcached, ephemeral };
+enum class bucket_compression { unknown, off, active, passive };
+enum class bucket_eviction_policy {
+    unknown,
+
+    /**
+     * During ejection, everything (including key, metadata, and value) will be ejected.
+     *
+     * Full Ejection reduces the memory overhead requirement, at the cost of performance.
+     *
+     * This value is only valid for buckets of type COUCHBASE.
+     */
+    full,
+
+    /**
+     * During ejection, only the value will be ejected (key and metadata will remain in memory).
+     *
+     * Value Ejection needs more system memory, but provides better performance than Full Ejection.
+     *
+     * This value is only valid for buckets of type COUCHBASE.
+     */
+    value_only,
+
+    /**
+     * Couchbase Server keeps all data until explicitly deleted, but will reject
+     * any new data if you reach the quota (dedicated memory) you set for your bucket.
+     *
+     * This value is only valid for buckets of type EPHEMERAL.
+     */
+    no_eviction,
+
+    /**
+     * When the memory quota is reached, Couchbase Server ejects data that has not been used recently.
+     *
+     * This value is only valid for buckets of type EPHEMERAL.
+     */
+    not_recently_used,
+};
+enum class bucket_conflict_resolution {
+    unknown,
+    /**
+     * Use timestamp conflict resolution.
+     *
+     * Timestamp-based conflict resolution (often referred to as Last Write Wins, or LWW) uses the document
+     * timestamp (stored in the CAS) to resolve conflicts. The timestamps associated with the most recent
+     * updates of source and target documents are compared. The document whose update has the more recent
+     * timestamp prevails.
+     */
+    timestamp,
+
+    /**
+     * Use sequence number conflict resolution
+     *
+     * Conflicts can be resolved by referring to documents' sequence numbers. Sequence numbers are maintained
+     * per document, and are incremented on every document-update. The sequence numbers of source and
+     * target documents are compared; and the document with the higher sequence number prevails.
+     */
+    sequence_number,
+
+    /**
+     * VOLATILE: This API is subject to change at any time.
+     *
+     * In Couchbase Server 7.1, this feature is only available in "developer-preview" mode. See the UI XDCR settings.
+     */
+    custom,
+};
+enum class bucket_storage_backend { unknown, couchstore, magma };
+
+struct bucket_settings {
+
+    std::string name;
+    cluster::bucket_type bucket_type{ cluster::bucket_type::unknown };
+    std::uint64_t ram_quota_mb{ 100 };
+    std::uint32_t max_expiry{ 0 };
+    bucket_compression compression_mode{ bucket_compression::unknown };
+    std::optional<couchbase::durability_level> minimum_durability_level{};
+    std::uint32_t num_replicas{ 1 };
+    bool replica_indexes{ false };
+    bool flush_enabled{ false };
+    bucket_eviction_policy eviction_policy{ bucket_eviction_policy::unknown };
+    bucket_conflict_resolution conflict_resolution_type{ bucket_conflict_resolution::unknown };
+
+    /**
+     * UNCOMMITTED: This API may change in the future
+     */
+    bucket_storage_backend storage_backend{ bucket_storage_backend::unknown };
+};
+} // namespace couchbase::management::cluster

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