couchbase 4.2.0 → 4.2.2

package/deps/couchbase-cxx-client/core/durability_options.hxx

@@ -0,0 +1,110 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ * Copyright 2022-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 "resource_units.hxx"
+#include "utils/movable_function.hxx"
+
+#include <couchbase/cas.hxx>
+
+#include <chrono>
+#include <string>
+#include <system_error>
+#include <vector>
+
+namespace couchbase
+{
+class retry_strategy;
+namespace tracing
+{
+class request_span;
+} // namespace tracing
+} // namespace couchbase
+
+namespace couchbase::core
+{
+enum class key_state {
+    not_persisted = 0x00,
+    persisted = 0x01,
+    not_found = 0x80,
+    deleted = 0x81,
+};
+
+class observe_options
+{
+  public:
+    std::vector<std::byte> key{};
+    std::uint32_t replica_index{};
+    std::string collection_name{};
+    std::string scope_name{};
+    std::uint32_t collection_id{};
+
+    std::shared_ptr<couchbase::retry_strategy> retry_strategy{};
+    std::chrono::milliseconds timeout{};
+    std::shared_ptr<couchbase::tracing::request_span> parent_span{};
+
+    struct {
+        std::string user{};
+    } internal{};
+};
+
+class observe_result
+{
+  public:
+    key_state state{};
+    couchbase::cas cas{};
+
+    struct {
+        std::optional<resource_unit_result> resource_units{};
+    } internal{};
+};
+
+using observe_callback = utils::movable_function<void(observe_result result, std::error_code ec)>;
+
+class observe_seqno_options
+{
+  public:
+    std::uint16_t vbucket_id{};
+    std::uint64_t vbucket_uuid{};
+    std::uint32_t replica_index{};
+
+    std::shared_ptr<couchbase::retry_strategy> retry_strategy{};
+    std::chrono::milliseconds timeout{};
+    std::shared_ptr<couchbase::tracing::request_span> parent_span{};
+
+    struct {
+        std::string user{};
+    } internal{};
+};
+
+class observe_seqno_result
+{
+  public:
+    bool did_failover{};
+    std::uint16_t vbucket_id{};
+    std::uint64_t vbucket_uuid{};
+    std::uint64_t persist_sequence_number{};
+    std::uint64_t current_sequence_number{};
+    std::uint64_t old_vbucket_uuid{};
+    std::uint64_t last_sequence_number{};
+
+    struct {
+        std::optional<resource_unit_result> resource_units{};
+    } internal{};
+};
+
+using observe_seqno_callback = utils::movable_function<void(observe_seqno_result result, std::error_code ec)>;
+} // namespace couchbase::core

package/deps/couchbase-cxx-client/core/error_context/analytics.hxx

@@ -44,7 +44,7 @@ struct analytics {
 
     std::optional<std::string> last_dispatched_to{};
     std::optional<std::string> last_dispatched_from{};
-    int retry_attempts{ 0 };
+    std::size_t retry_attempts{ 0 };
     std::set<retry_reason> retry_reasons{};
 };
 

package/deps/couchbase-cxx-client/core/error_context/http.hxx

@@ -40,7 +40,7 @@ struct http {
 
     std::optional<std::string> last_dispatched_to{};
     std::optional<std::string> last_dispatched_from{};
-    int retry_attempts{ 0 };
+    std::size_t retry_attempts{ 0 };
     std::set<retry_reason> retry_reasons{};
 };
 

package/deps/couchbase-cxx-client/core/error_context/key_value.hxx

@@ -44,8 +44,8 @@ make_key_value_error_context(std::error_code ec, std::uint16_t status_code, cons
     const auto& bucket = command->request.id.bucket();
     std::uint32_t opaque = (ec && response.opaque() == 0) ? command->request.opaque : response.opaque();
     auto status = response.status();
-    auto retry_attempts = command->request.retries.retry_attempts;
-    auto retry_reasons = command->request.retries.reasons;
+    auto retry_attempts = command->request.retries.retry_attempts();
+    auto retry_reasons = command->request.retries.retry_reasons();
     std::optional<std::string> last_dispatched_from{};
     std::optional<std::string> last_dispatched_to{};
     std::optional<key_value_error_map_info> error_map_info{};

package/deps/couchbase-cxx-client/core/error_context/query.hxx

@@ -44,7 +44,7 @@ struct query {
 
     std::optional<std::string> last_dispatched_to{};
     std::optional<std::string> last_dispatched_from{};
-    int retry_attempts{ 0 };
+    std::size_t retry_attempts{ 0 };
     std::set<retry_reason> retry_reasons{};
 };
 

package/deps/couchbase-cxx-client/core/error_context/search.hxx

@@ -43,7 +43,7 @@ struct search {
 
     std::optional<std::string> last_dispatched_to{};
     std::optional<std::string> last_dispatched_from{};
-    int retry_attempts{ 0 };
+    std::size_t retry_attempts{ 0 };
     std::set<retry_reason> retry_reasons{};
 };
 

package/deps/couchbase-cxx-client/core/error_context/view.hxx

@@ -44,7 +44,7 @@ struct view {
 
     std::optional<std::string> last_dispatched_to{};
     std::optional<std::string> last_dispatched_from{};
-    int retry_attempts{ 0 };
+    std::size_t retry_attempts{ 0 };
     std::set<retry_reason> retry_reasons{};
 };
 

package/deps/couchbase-cxx-client/core/free_form_http_request.cxx

@@ -0,0 +1,81 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ * Copyright 2022-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 "free_form_http_request.hxx"
+
+namespace couchbase::core
+{
+class http_response_impl
+{
+  public:
+    auto endpoint() -> std::string
+    {
+        return {};
+    }
+
+    auto status_code() -> std::uint32_t
+    {
+        return {};
+    }
+
+    auto content_length() -> std::size_t
+    {
+        return {};
+    }
+
+    auto body() -> std::vector<std::byte>
+    {
+        return {};
+    }
+
+    auto close() -> std::error_code
+    {
+        return {};
+    }
+};
+
+http_response::http_response()
+  : impl_{ std::make_shared<http_response_impl>() }
+{
+}
+
+auto
+http_response::endpoint() -> std::string
+{
+    return impl_->endpoint();
+}
+auto
+http_response::status_code() -> std::uint32_t
+{
+    return impl_->status_code();
+}
+auto
+http_response::content_length() -> std::size_t
+{
+    return impl_->content_length();
+}
+
+auto
+http_response::body() -> std::vector<std::byte>
+{
+    return impl_->body();
+}
+
+auto
+http_response::close() -> std::error_code
+{
+    return impl_->close();
+}
+} // namespace couchbase::core

package/deps/couchbase-cxx-client/core/free_form_http_request.hxx

@@ -0,0 +1,90 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ * Copyright 2022-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 "utils/movable_function.hxx"
+
+#include <chrono>
+#include <cinttypes>
+#include <map>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <vector>
+
+namespace couchbase
+{
+class retry_strategy;
+namespace tracing
+{
+class request_span;
+} // namespace tracing
+} // namespace couchbase
+
+namespace couchbase::core
+{
+enum class http_service_type {
+    management,
+    capi,
+    n1ql,
+    search,
+    analytics,
+};
+
+class http_request
+{
+  public:
+    http_service_type service;
+    std::string method{};
+    std::string endpoint{};
+    std::string path{};
+    std::string username{};
+    std::string password{};
+    std::vector<std::byte> body{};
+    std::map<std::string, std::string> headers{};
+    std::string content_type{};
+    bool is_idempotent{};
+    std::string unique_id{};
+    std::shared_ptr<couchbase::retry_strategy> retry_strategy{};
+    std::chrono::milliseconds timeout{};
+    std::shared_ptr<couchbase::tracing::request_span> parent_span{};
+
+    struct {
+        std::string user{};
+    } internal{};
+};
+
+class http_response_impl;
+
+class http_response
+{
+  public:
+    http_response();
+
+    auto endpoint() -> std::string;
+    auto status_code() -> std::uint32_t;
+    auto content_length() -> std::size_t;
+
+    auto body() -> std::vector<std::byte>;
+    auto close() -> std::error_code;
+
+  private:
+    std::shared_ptr<http_response_impl> impl_;
+};
+
+using free_form_http_request_callback = utils::movable_function<void(http_response response, std::error_code ec)>;
+
+} // namespace couchbase::core

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

@@ -50,6 +50,7 @@ initiate_append_operation(std::shared_ptr<couchbase::core::cluster> core,
             {},
             options.durability_level,
             options.timeout,
+            { options.retry_strategy },
           },
           [handler = std::move(handler)](operations::append_response&& resp) mutable {
               if (resp.ctx.ec()) {
@@ -59,7 +60,9 @@ initiate_append_operation(std::shared_ptr<couchbase::core::cluster> core,
           });
     }
 
-    operations::append_request request{ id, std::move(data), {}, {}, durability_level::none, options.timeout };
+    operations::append_request request{
+        id, std::move(data), {}, {}, durability_level::none, options.timeout, { options.retry_strategy },
+    };
     return core->execute(
       std::move(request), [core, id = std::move(id), options, handler = std::move(handler)](operations::append_response&& resp) mutable {
           if (resp.ctx.ec()) {

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

@@ -0,0 +1,109 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2022-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 <couchbase/best_effort_retry_strategy.hxx>
+
+#include <fmt/core.h>
+
+#include <cmath>
+
+namespace couchbase
+{
+auto
+controlled_backoff(std::size_t retry_attempts) -> std::chrono::milliseconds
+{
+    switch (retry_attempts) {
+        case 0:
+            return std::chrono::milliseconds(1);
+
+        case 1:
+            return std::chrono::milliseconds(10);
+
+        case 2:
+            return std::chrono::milliseconds(50);
+
+        case 3:
+            return std::chrono::milliseconds(100);
+
+        case 4:
+            return std::chrono::milliseconds(500);
+
+        default:
+            break;
+    }
+    return std::chrono::milliseconds(1'000);
+}
+
+auto
+exponential_backoff(std::chrono::milliseconds min_backoff, std::chrono::milliseconds max_backoff, double backoff_factor)
+  -> backoff_calculator
+{
+    double min = 1;   // 1 millisecond
+    double max = 500; // 500 milliseconds
+    double factor = 2;
+
+    if (min_backoff > std::chrono::milliseconds::zero()) {
+        min = static_cast<double>(min_backoff.count());
+    }
+    if (max_backoff > std::chrono::milliseconds::zero()) {
+        max = static_cast<double>(max_backoff.count());
+    }
+    if (backoff_factor > 0) {
+        factor = backoff_factor;
+    }
+
+    return [min, max, factor](std::size_t retry_attempts) {
+        double backoff = min * std::pow(factor, static_cast<double>(retry_attempts));
+        if (backoff > max) {
+            backoff = max;
+        }
+        if (backoff < min) {
+            backoff = min;
+        }
+        return std::chrono::milliseconds(static_cast<std::uint64_t>(backoff));
+    };
+}
+
+best_effort_retry_strategy::best_effort_retry_strategy(backoff_calculator calculator)
+  : backoff_calculator_{ std::move(calculator) }
+{
+}
+
+auto
+best_effort_retry_strategy::retry_after(const retry_request& request, retry_reason reason) -> retry_action
+{
+    if (request.idempotent() || allows_non_idempotent_retry(reason)) {
+        return retry_action{ backoff_calculator_(request.retry_attempts()) };
+    }
+    return retry_action::do_not_retry();
+}
+
+auto
+best_effort_retry_strategy::to_string() const -> std::string
+{
+    return fmt::format(R"(#<best_effort_retry_strategy:{} backoff_calculator=#<{}:{}>>)",
+                       static_cast<const void*>(this),
+                       typeid(backoff_calculator_).name(),
+                       typeid(backoff_calculator_).hash_code());
+}
+
+auto
+make_best_effort_retry_strategy(backoff_calculator calculator) -> std::shared_ptr<best_effort_retry_strategy>
+{
+    return std::make_shared<best_effort_retry_strategy>(std::move(calculator));
+}
+} // namespace couchbase

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

@@ -19,6 +19,7 @@
 
 #include "core/config_listener.hxx"
 
+#include <memory>
 #include <string>
 #include <system_error>
 #include <vector>

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

@@ -39,22 +39,24 @@ build_context(Response& resp)
              std::move(resp.ctx.http_body),
              std::move(resp.ctx.path) };
 }
-
 void
 initiate_build_deferred_indexes(std::shared_ptr<couchbase::core::cluster> core,
                                 std::string bucket_name,
                                 build_query_index_options::built options,
+                                query_context query_ctx,
+                                std::string collection_name,
                                 build_deferred_query_indexes_handler&& handler)
 {
     core->execute(
       operations::management::query_index_get_all_deferred_request{
         bucket_name,
-        options.scope_name.value_or(""),
-        options.collection_name.value_or(""),
+        "",
+        collection_name,
+        query_ctx,
         {},
         options.timeout,
       },
-      [core, bucket_name, options = std::move(options), handler = std::move(handler)](
+      [core, bucket_name, collection_name, options = std::move(options), query_ctx, handler = std::move(handler)](
         operations::management::query_index_get_all_deferred_response resp1) mutable {
           auto list_resp = std::move(resp1);
           if (list_resp.ctx.ec) {
@@ -66,8 +68,9 @@ initiate_build_deferred_indexes(std::shared_ptr<couchbase::core::cluster> core,
           core->execute(
             operations::management::query_index_build_request{
               std::move(bucket_name),
-              options.scope_name.value_or(""),
-              options.collection_name.value_or(""),
+              "",
+              collection_name,
+              query_ctx,
               std::move(list_resp.index_names),
               {},
               options.timeout,
@@ -78,4 +81,12 @@ initiate_build_deferred_indexes(std::shared_ptr<couchbase::core::cluster> core,
             });
       });
 }
+void
+initiate_build_deferred_indexes(std::shared_ptr<couchbase::core::cluster> core,
+                                std::string bucket_name,
+                                build_query_index_options::built options,
+                                build_deferred_query_indexes_handler&& handler)
+{
+    return initiate_build_deferred_indexes(core, std::move(bucket_name), options, {}, "", std::move(handler));
+}
 } // namespace couchbase::core::impl

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

@@ -30,11 +30,22 @@ cluster::transactions() -> std::shared_ptr<couchbase::transactions::transactions
     // TODO: add mutex for thread safety.
     if (!transactions_) {
         // TODO: fill in the cluster config, add an optional transactions_config, use it here.
-        transactions_ = std::make_shared<couchbase::core::transactions::transactions>(core_, couchbase::transactions::transaction_config());
+        transactions_ = std::make_shared<couchbase::core::transactions::transactions>(core_, core_->origin().second.options().transactions);
     }
     return transactions_;
 }
 
+auto
+cluster::close() -> void
+{
+    if (transactions_) {
+        // blocks until cleanup is finished
+        transactions_->close();
+    }
+    transactions_.reset();
+    return core::impl::initiate_cluster_close(core_);
+}
+
 namespace core::impl
 {
 
@@ -51,6 +62,10 @@ options_to_origin(const std::string& connection_string, const couchbase::cluster
     auth.allowed_sasl_mechanisms = std::move(opts.allowed_sasl_mechanisms);
 
     core::cluster_options user_options;
+
+    if (opts.default_retry_strategy != nullptr) {
+        user_options.default_retry_strategy_ = std::move(opts.default_retry_strategy);
+    }
     user_options.bootstrap_timeout = opts.timeouts.bootstrap_timeout;
     user_options.resolve_timeout = opts.timeouts.resolve_timeout;
     user_options.connect_timeout = opts.timeouts.connect_timeout;
@@ -134,7 +149,7 @@ options_to_origin(const std::string& connection_string, const couchbase::cluster
         user_options.tracing_options.management_threshold = opts.tracing.management_threshold;
         user_options.tracing_options.eventing_threshold = opts.tracing.eventing_threshold;
     }
-
+    user_options.transactions = opts.transactions;
     // connection string might override some user options
     return { auth, couchbase::core::utils::parse_connection_string(connection_string, user_options) };
 }
@@ -151,7 +166,10 @@ initiate_cluster_connect(asio::io_service& io,
         if (ec) {
             return handler({}, ec);
         }
-        handler(couchbase::cluster(core), {});
+        auto c = couchbase::cluster(core);
+        // create txns as we want to start cleanup immediately if configured with metadata_collection
+        [[maybe_unused]] std::shared_ptr<couchbase::transactions::transactions> t = c.transactions();
+        handler(std::move(c), {});
     });
 }
 

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

@@ -0,0 +1,93 @@
+/* -*- 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.
+ */
+
+#include <core/query_context.hxx>
+#include <couchbase/collection_query_index_manager.hxx>
+
+namespace couchbase
+{
+
+void
+collection_query_index_manager::get_all_indexes(const get_all_query_indexes_options& options, get_all_indexes_handler&& handler) const
+{
+    return core::impl::initiate_get_all_query_indexes(core_,
+                                                      "",
+                                                      options.build(),
+                                                      core::query_context(bucket_name_, scope_name_),
+                                                      collection_name_,
+                                                      std::forward<get_all_indexes_handler>(handler));
+}
+
+void
+collection_query_index_manager::create_index(std::string index_name,
+                                             std::vector<std::string> fields,
+                                             const create_query_index_options& options,
+                                             create_query_index_handler&& handler) const
+{
+    return core::impl::initiate_create_query_index(core_,
+                                                   "",
+                                                   std::move(index_name),
+                                                   std::move(fields),
+                                                   options.build(),
+                                                   { bucket_name_, scope_name_ },
+                                                   collection_name_,
+                                                   std::forward<create_query_index_handler>(handler));
+}
+
+void
+collection_query_index_manager::create_primary_index(const create_primary_query_index_options& options,
+                                                     create_query_index_handler&& handler) const
+{
+    return core::impl::initiate_create_primary_query_index(
+      core_, "", options.build(), { bucket_name_, scope_name_ }, collection_name_, std::move(handler));
+}
+
+void
+collection_query_index_manager::drop_primary_index(const drop_primary_query_index_options& options,
+                                                   drop_query_index_handler&& handler) const
+{
+    return core::impl::initiate_drop_primary_query_index(
+      core_, "", options.build(), { bucket_name_, scope_name_ }, collection_name_, std::move(handler));
+}
+void
+collection_query_index_manager::drop_index(std::string index_name,
+                                           const drop_query_index_options& options,
+                                           drop_query_index_handler&& handler) const
+{
+    return core::impl::initiate_drop_query_index(
+      core_, "", std::move(index_name), options.build(), { bucket_name_, scope_name_ }, collection_name_, std::move(handler));
+}
+void
+collection_query_index_manager::build_deferred_indexes(const build_query_index_options& options,
+                                                       build_deferred_query_indexes_handler&& handler) const
+{
+    return core::impl::initiate_build_deferred_indexes(core_,
+                                                       "",
+                                                       options.build(),
+                                                       { bucket_name_, scope_name_ },
+                                                       collection_name_,
+                                                       std::forward<build_deferred_query_indexes_handler>(handler));
+}
+void
+collection_query_index_manager::watch_indexes(std::vector<std::string> index_names,
+                                              const watch_query_indexes_options& options,
+                                              watch_query_indexes_handler&& handler) const
+{
+    return core::impl::initiate_watch_query_indexes(
+      core_, "", std::move(index_names), options.build(), { bucket_name_, scope_name_ }, collection_name_, std::move(handler));
+}
+} // namespace couchbase