couchbase 4.2.8-dev.1 → 4.2.9

package/deps/couchbase-cxx-client/core/impl/collection_manager.cxx

@@ -0,0 +1,306 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-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.
+ */
+
+#include "core/cluster.hxx"
+
+#include "core/operations/management/collection_create.hxx"
+#include "core/operations/management/collection_drop.hxx"
+#include "core/operations/management/collection_update.hxx"
+#include "core/operations/management/scope_create.hxx"
+#include "core/operations/management/scope_drop.hxx"
+#include "core/operations/management/scope_get_all.hxx"
+#include "internal_manager_error_context.hxx"
+
+#include <couchbase/collection_manager.hxx>
+
+#include <memory>
+
+namespace couchbase
+{
+namespace
+{
+template<typename Response>
+manager_error_context
+build_context(Response& resp)
+{
+    return manager_error_context(internal_manager_error_context{ resp.ctx.ec,
+                                                                 resp.ctx.last_dispatched_to,
+                                                                 resp.ctx.last_dispatched_from,
+                                                                 resp.ctx.retry_attempts,
+                                                                 std::move(resp.ctx.retry_reasons),
+                                                                 std::move(resp.ctx.client_context_id),
+                                                                 resp.ctx.http_status,
+                                                                 std::move(resp.ctx.http_body),
+                                                                 std::move(resp.ctx.path) });
+}
+
+management::bucket::collection_spec
+map_collection(std::string scope_name, const core::topology::collections_manifest::collection& collection)
+{
+    management::bucket::collection_spec spec{};
+    spec.name = collection.name;
+    spec.scope_name = std::move(scope_name);
+    spec.max_expiry = collection.max_expiry;
+    spec.history = collection.history;
+    return spec;
+}
+
+std::vector<couchbase::management::bucket::scope_spec>
+map_scope_specs(core::topology::collections_manifest& manifest)
+{
+    std::vector<couchbase::management::bucket::scope_spec> scope_specs{};
+    for (const auto& scope : manifest.scopes) {
+        couchbase::management::bucket::scope_spec converted_scope{};
+        converted_scope.name = scope.name;
+        for (const auto& collection : scope.collections) {
+            auto collection_spec = map_collection(scope.name, collection);
+            converted_scope.collections.emplace_back(collection_spec);
+        }
+        scope_specs.emplace_back(converted_scope);
+    }
+    return scope_specs;
+}
+} // namespace
+
+class collection_manager_impl
+{
+  public:
+    collection_manager_impl(core::cluster core, std::string_view bucket_name)
+      : core_{ std::move(core) }
+      , bucket_name_{ bucket_name }
+    {
+    }
+
+    void drop_collection(std::string scope_name,
+                         std::string collection_name,
+                         const couchbase::drop_collection_options::built& options,
+                         couchbase::drop_collection_handler&& handler) const
+    {
+        return core_.execute(
+          core::operations::management::collection_drop_request{
+            bucket_name_,
+            std::move(scope_name),
+            std::move(collection_name),
+            {},
+            options.timeout,
+          },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+    }
+
+    void update_collection(std::string scope_name,
+                           std::string collection_name,
+                           const couchbase::update_collection_settings& settings,
+                           const couchbase::update_collection_options::built& options,
+                           couchbase::update_collection_handler&& handler) const
+    {
+        return core_.execute(
+          core::operations::management::collection_update_request{
+            bucket_name_,
+            std::move(scope_name),
+            std::move(collection_name),
+            settings.max_expiry,
+            settings.history,
+            {},
+            options.timeout,
+          },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+    }
+
+    void create_collection(std::string scope_name,
+                           std::string collection_name,
+                           const couchbase::create_collection_settings& settings,
+                           const couchbase::create_collection_options::built& options,
+                           couchbase::update_collection_handler&& handler) const
+    {
+        return core_.execute(
+          core::operations::management::collection_create_request{
+            bucket_name_,
+            std::move(scope_name),
+            std::move(collection_name),
+            settings.max_expiry,
+            settings.history,
+            {},
+            options.timeout,
+          },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+    }
+
+    void get_all_scopes(const get_all_scopes_options::built& options, get_all_scopes_handler&& handler) const
+    {
+        return core_.execute(
+          core::operations::management::scope_get_all_request{
+            bucket_name_,
+            {},
+            options.timeout,
+          },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp), map_scope_specs(resp.manifest)); });
+    }
+
+    void create_scope(std::string scope_name,
+                      const couchbase::create_scope_options::built& options,
+                      couchbase::create_scope_handler&& handler) const
+    {
+        return core_.execute(
+          core::operations::management::scope_create_request{
+            bucket_name_,
+            std::move(scope_name),
+            {},
+            options.timeout,
+          },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+    }
+
+    void drop_scope(std::string scope_name,
+                    const couchbase::drop_scope_options::built& options,
+                    couchbase::drop_scope_handler&& handler) const
+    {
+        core_.execute(
+          core::operations::management::scope_drop_request{
+            bucket_name_,
+            std::move(scope_name),
+            {},
+            options.timeout,
+          },
+          [handler = std::move(handler)](auto resp) mutable { return handler(build_context(resp)); });
+    }
+
+  private:
+    core::cluster core_;
+    std::string bucket_name_;
+};
+
+collection_manager::collection_manager(core::cluster core, std::string_view bucket_name)
+  : impl_(std::make_shared<collection_manager_impl>(std::move(core), bucket_name))
+{
+}
+
+void
+collection_manager::drop_collection(std::string scope_name,
+                                    std::string collection_name,
+                                    const couchbase::drop_collection_options& options,
+                                    couchbase::drop_collection_handler&& handler) const
+{
+    return impl_->drop_collection(std::move(scope_name), std::move(collection_name), options.build(), std::move(handler));
+}
+
+auto
+collection_manager::drop_collection(std::string scope_name,
+                                    std::string collection_name,
+                                    const couchbase::drop_collection_options& options) const -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    drop_collection(
+      std::move(scope_name), std::move(collection_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+collection_manager::update_collection(std::string scope_name,
+                                      std::string collection_name,
+                                      const update_collection_settings& settings,
+                                      const update_collection_options& options,
+                                      update_collection_handler&& handler) const
+{
+    return impl_->update_collection(std::move(scope_name), std::move(collection_name), settings, options.build(), std::move(handler));
+}
+
+auto
+collection_manager::update_collection(std::string scope_name,
+                                      std::string collection_name,
+                                      const couchbase::update_collection_settings& settings,
+                                      const couchbase::update_collection_options& options) const -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    update_collection(std::move(scope_name), std::move(collection_name), settings, options, [barrier](auto ctx) mutable {
+        barrier->set_value(std::move(ctx));
+    });
+    return barrier->get_future();
+}
+
+void
+collection_manager::create_collection(std::string scope_name,
+                                      std::string collection_name,
+                                      const couchbase::create_collection_settings& settings,
+                                      const couchbase::create_collection_options& options,
+                                      couchbase::create_collection_handler&& handler) const
+{
+    return impl_->create_collection(std::move(scope_name), std::move(collection_name), settings, options.build(), std::move(handler));
+}
+
+auto
+collection_manager::create_collection(std::string scope_name,
+                                      std::string collection_name,
+                                      const couchbase::create_collection_settings& settings,
+                                      const couchbase::create_collection_options& options) const -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    create_collection(std::move(scope_name), std::move(collection_name), settings, options, [barrier](auto ctx) mutable {
+        barrier->set_value(std::move(ctx));
+    });
+    return barrier->get_future();
+}
+
+void
+collection_manager::get_all_scopes(const get_all_scopes_options& options, get_all_scopes_handler&& handler) const
+{
+    return impl_->get_all_scopes(options.build(), std::move(handler));
+}
+
+auto
+collection_manager::get_all_scopes(const couchbase::get_all_scopes_options& options) const
+  -> std::future<std::pair<manager_error_context, std::vector<management::bucket::scope_spec>>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<manager_error_context, std::vector<management::bucket::scope_spec>>>>();
+    get_all_scopes(options,
+                   [barrier](auto ctx, auto result) mutable { barrier->set_value(std::make_pair(std::move(ctx), std::move(result))); });
+    return barrier->get_future();
+}
+
+void
+collection_manager::create_scope(std::string scope_name,
+                                 const couchbase::create_scope_options& options,
+                                 couchbase::create_scope_handler&& handler) const
+{
+    return impl_->create_scope(std::move(scope_name), options.build(), std::move(handler));
+}
+
+auto
+collection_manager::create_scope(std::string scope_name, const couchbase::create_scope_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    create_scope(std::move(scope_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
+void
+collection_manager::drop_scope(std::string scope_name,
+                               const couchbase::drop_scope_options& options,
+                               couchbase::drop_scope_handler&& handler) const
+{
+    return impl_->drop_scope(std::move(scope_name), options.build(), std::move(handler));
+}
+
+auto
+collection_manager::drop_scope(std::string scope_name, const couchbase::drop_scope_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    drop_scope(std::move(scope_name), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+} // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/configuration_profiles_registry.cxx

@@ -57,7 +57,9 @@ configuration_profiles_registry::apply_profile(const std::string& name, couchbas
         }
     }
 
-    profile->apply(options);
+    if (profile) {
+        profile->apply(options);
+    }
 }
 
 auto

package/deps/couchbase-cxx-client/core/impl/dns_srv_tracker.cxx

@@ -20,6 +20,8 @@
 #include "core/logger/logger.hxx"
 #include "core/utils/join_strings.hxx"
 
+#include <couchbase/error_codes.hxx>
+
 #include <asio/bind_executor.hpp>
 #include <asio/io_context.hpp>
 #include <asio/post.hpp>

package/deps/couchbase-cxx-client/core/{operations/mcbp_noop.cxx → impl/doc_id_query.cxx}

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   Copyright 2023-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.
@@ -15,24 +15,28 @@
  *   limitations under the License.
  */
 
-#include "mcbp_noop.hxx"
+#include "encoded_search_query.hxx"
 
+#include <couchbase/doc_id_query.hxx>
 #include <couchbase/error_codes.hxx>
 
-namespace couchbase::core::operations
+#include <tao/json/contrib/traits.hpp>
+
+namespace couchbase
 {
-std::error_code
-mcbp_noop_request::encode_to(mcbp_noop_request::encoded_request_type& encoded, mcbp_context&& /* context */) const
+auto
+doc_id_query::encode() const -> encoded_search_query
 {
-    encoded.opaque(opaque);
-    encoded.partition(partition);
-    return {};
-}
+    if (ids_.empty()) {
+        return { errc::common::invalid_argument };
+    }
 
-mcbp_noop_response
-mcbp_noop_request::make_response(key_value_error_context&& ctx, const encoded_response_type& /* encoded */) const
-{
-    mcbp_noop_response response{ std::move(ctx) };
-    return response;
+    encoded_search_query built;
+    built.query = tao::json::value{ { "ids", ids_ } };
+
+    if (boost_.has_value()) {
+        built.query["boost"] = boost_.value();
+    }
+    return built;
 }
-} // namespace couchbase::core::operations
+} // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/key_value_error_category.cxx

@@ -80,10 +80,12 @@ struct key_value_error_category : std::error_category {
                 return "xattr_unknown_virtual_attribute (127)";
             case errc::key_value::xattr_cannot_modify_virtual_attribute:
                 return "xattr_cannot_modify_virtual_attribute (128)";
-            case errc::key_value::cannot_revive_living_document:
-                return "cannot_revive_living_document (131)";
             case errc::key_value::xattr_no_access:
                 return "xattr_no_access (130)";
+            case errc::key_value::document_not_locked:
+                return "document_not_locked (131)";
+            case errc::key_value::cannot_revive_living_document:
+                return "cannot_revive_living_document (132)";
             case errc::key_value::mutation_token_outdated:
                 return "mutation_token_outdated (133)";
             case errc::key_value::range_scan_completed:

package/deps/couchbase-cxx-client/core/impl/lookup_in_all_replicas.hxx

@@ -67,14 +67,4 @@ class lookup_in_all_replicas_request
 
 using movable_lookup_in_all_replicas_handler =
   utils::movable_function<void(couchbase::subdocument_error_context, lookup_in_all_replicas_result)>;
-
-void
-initiate_lookup_in_all_replicas_operation(std::shared_ptr<cluster> core,
-                                          const std::string& bucket_name,
-                                          const std::string& scope_name,
-                                          const std::string& collection_name,
-                                          std::string document_key,
-                                          const std::vector<subdoc::command>& specs,
-                                          std::optional<std::chrono::milliseconds> timeout,
-                                          movable_lookup_in_all_replicas_handler&& handler);
 } // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/lookup_in_any_replica.hxx

@@ -62,14 +62,4 @@ class lookup_in_any_replica_request
 };
 
 using movable_lookup_in_any_replica_handler = utils::movable_function<void(couchbase::subdocument_error_context, lookup_in_replica_result)>;
-
-void
-initiate_lookup_in_any_replica_operation(std::shared_ptr<cluster> core,
-                                         const std::string& bucket_name,
-                                         const std::string& scope_name,
-                                         const std::string& collection_name,
-                                         std::string document_key,
-                                         const std::vector<subdoc::command>& specs,
-                                         std::optional<std::chrono::milliseconds> timeout,
-                                         movable_lookup_in_any_replica_handler&& handler);
 } // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/observe_poll.cxx

@@ -20,12 +20,18 @@
 #include "core/cluster.hxx"
 #include "core/impl/observe_seqno.hxx"
 
+#include <couchbase/error_codes.hxx>
+
+#include <asio/steady_timer.hpp>
+
 #include <memory>
 #include <mutex>
 
 namespace couchbase::core::impl
 {
-static constexpr bool
+namespace
+{
+constexpr bool
 touches_replica(couchbase::persist_to persist_to, couchbase::replicate_to replicate_to)
 {
 
@@ -53,7 +59,7 @@ touches_replica(couchbase::persist_to persist_to, couchbase::replicate_to replic
     return false;
 }
 
-static constexpr std::uint32_t
+constexpr std::uint32_t
 number_of_replica_nodes_required(couchbase::persist_to persist_to)
 {
     switch (persist_to) {
@@ -72,7 +78,7 @@ number_of_replica_nodes_required(couchbase::persist_to persist_to)
     return 0U;
 }
 
-static constexpr std::uint32_t
+constexpr std::uint32_t
 number_of_replica_nodes_required(couchbase::replicate_to replicate_to)
 {
     switch (replicate_to) {
@@ -88,7 +94,7 @@ number_of_replica_nodes_required(couchbase::replicate_to replicate_to)
     return 0U;
 }
 
-static std::pair<std::error_code, std::uint32_t>
+std::pair<std::error_code, std::uint32_t>
 validate_replicas(const topology::configuration& config, couchbase::persist_to persist_to, couchbase::replicate_to replicate_to)
 {
     if (config.node_locator != topology::configuration::node_locator_type::vbucket) {
@@ -158,8 +164,8 @@ class observe_status
 };
 
 class observe_context;
-static void
-observe_poll(std::shared_ptr<couchbase::core::cluster> core, std::shared_ptr<observe_context> ctx);
+void
+observe_poll(cluster core, std::shared_ptr<observe_context> ctx);
 
 class observe_context : public std::enable_shared_from_this<observe_context>
 {
@@ -270,13 +276,13 @@ class observe_context : public std::enable_shared_from_this<observe_context>
         }
     }
 
-    void on_last_response(std::size_t expected_number_of_responses, std::function<void(std::error_code)> handler)
+    void on_last_response(std::size_t expected_number_of_responses, utils::movable_function<void(std::error_code)> handler)
     {
         expect_number_of_responses_ = expected_number_of_responses;
         on_last_response_ = std::move(handler);
     }
 
-    void execute(std::shared_ptr<couchbase::core::cluster> core)
+    void execute(cluster core)
     {
         auto requests = std::move(requests_);
         status_.reset();
@@ -287,8 +293,8 @@ class observe_context : public std::enable_shared_from_this<observe_context>
             observe_poll(std::move(core), std::move(ctx));
         });
         for (auto&& request : requests) {
-            core->execute(std::move(request),
-                          [ctx = shared_from_this()](observe_seqno_response&& response) { ctx->handle_response(std::move(response)); });
+            core.execute(std::move(request),
+                         [ctx = shared_from_this()](observe_seqno_response&& response) { ctx->handle_response(std::move(response)); });
         }
     }
 
@@ -304,16 +310,16 @@ class observe_context : public std::enable_shared_from_this<observe_context>
     std::atomic_size_t expect_number_of_responses_{};
     std::mutex handler_mutex_{};
     observe_handler handler_{};
-    std::function<void(std::error_code)> on_last_response_{};
+    utils::movable_function<void(std::error_code)> on_last_response_{};
     std::chrono::milliseconds poll_backoff_interval_{ 500 };
     std::chrono::milliseconds poll_deadline_interval_{ 5'000 };
 };
 
-static void
-observe_poll(std::shared_ptr<couchbase::core::cluster> core, std::shared_ptr<observe_context> ctx)
+void
+observe_poll(cluster core, std::shared_ptr<observe_context> ctx)
 {
-    std::string bucket_name = ctx->bucket_name();
-    core->with_bucket_configuration(
+    const std::string bucket_name = ctx->bucket_name();
+    core.with_bucket_configuration(
       bucket_name, [core, ctx = std::move(ctx)](std::error_code ec, const core::topology::configuration& config) mutable {
           if (ec) {
               return ctx->finish(ec);
@@ -337,9 +343,10 @@ observe_poll(std::shared_ptr<couchbase::core::cluster> core, std::shared_ptr<obs
           ctx->execute(core);
       });
 }
+} // namespace
 
 void
-initiate_observe_poll(std::shared_ptr<couchbase::core::cluster> core,
+initiate_observe_poll(cluster core,
                       document_id id,
                       mutation_token token,
                       std::optional<std::chrono::milliseconds> timeout,
@@ -348,7 +355,7 @@ initiate_observe_poll(std::shared_ptr<couchbase::core::cluster> core,
                       observe_handler&& handler)
 {
     auto ctx = std::make_shared<observe_context>(
-      core->io_context(), std::move(id), std::move(token), timeout, persist_to, replicate_to, std::move(handler));
+      core.io_context(), std::move(id), std::move(token), timeout, persist_to, replicate_to, std::move(handler));
     ctx->start();
     return observe_poll(std::move(core), std::move(ctx));
 }

package/deps/couchbase-cxx-client/core/impl/observe_poll.hxx

@@ -38,7 +38,7 @@ namespace impl
 using observe_handler = utils::movable_function<void(std::error_code)>;
 
 void
-initiate_observe_poll(std::shared_ptr<couchbase::core::cluster> core,
+initiate_observe_poll(cluster core,
                       document_id id,
                       mutation_token token,
                       std::optional<std::chrono::milliseconds> timeout,