couchbase 4.2.0 → 4.2.1

package/deps/couchbase-cxx-client/core/transactions/internal/utils.hxx

@@ -15,8 +15,10 @@
  */
 #pragma once
 
+#include <couchbase/transactions/transaction_query_result.hxx>
+#include <couchbase/transactions/transactions_config.hxx>
+
 #include "core/transactions/result.hxx"
-#include "couchbase/transactions/transaction_config.hxx"
 #include "exceptions_internal.hxx"
 
 #include <chrono>
@@ -54,26 +56,26 @@ operator<<(OStream& os, const core::document_id& id)
 
 template<typename T>
 T&
-wrap_request(T&& req, const couchbase::transactions::transaction_config& config)
+wrap_request(T&& req, const couchbase::transactions::transactions_config::built& config)
 {
-    if (config.kv_timeout()) {
-        req.timeout = config.kv_timeout().value();
+    if (config.kv_timeout) {
+        req.timeout = config.kv_timeout.value();
     }
     return req;
 }
 
 template<typename T>
 T&
-wrap_durable_request(T&& req, const couchbase::transactions::transaction_config& config)
+wrap_durable_request(T&& req, const couchbase::transactions::transactions_config::built& config)
 {
     wrap_request(req, config);
-    req.durability_level = config.durability_level();
+    req.durability_level = config.level;
     return req;
 }
 
 template<typename T>
 T&
-wrap_durable_request(T&& req, const couchbase::transactions::transaction_config& config, durability_level level)
+wrap_durable_request(T&& req, const couchbase::transactions::transactions_config::built& config, durability_level level)
 {
     wrap_request(req, config);
     req.durability_level = level;
@@ -300,4 +302,10 @@ struct constant_delay {
 
 std::list<std::string>
 get_and_open_buckets(std::shared_ptr<core::cluster> c);
-} // namespace couchbase::core::transactions
+
+core::document_id
+atr_id_from_bucket_and_key(const couchbase::transactions::transactions_config::built& cfg,
+                           const std::string& bucket,
+                           const std::string& key);
+
+} // namespace couchbase::core::transactions

package/deps/couchbase-cxx-client/core/transactions/staged_mutation.cxx

@@ -69,7 +69,7 @@ staged_mutation_queue::extract_to(const std::string& prefix, core::operations::m
                 break;
         }
     }
-    req.specs =
+    auto specs =
       couchbase::mutate_in_specs{
           couchbase::mutate_in_specs::upsert_raw(prefix + ATR_FIELD_DOCS_INSERTED, core::utils::json::generate_binary(inserts))
             .xattr()
@@ -82,6 +82,7 @@ staged_mutation_queue::extract_to(const std::string& prefix, core::operations::m
             .create_path(),
       }
         .specs();
+    req.specs.insert(req.specs.end(), specs.begin(), specs.end());
 }
 
 void
@@ -152,6 +153,7 @@ staged_mutation_queue::iterate(std::function<void(staged_mutation&)> op)
 void
 staged_mutation_queue::commit(attempt_context_impl& ctx)
 {
+    ctx.trace("staged mutations committing...");
     std::lock_guard<std::mutex> lock(mutex_);
     for (auto& item : queue_) {
         switch (item.type()) {
@@ -313,6 +315,7 @@ staged_mutation_queue::commit_doc(attempt_context_impl& ctx, staged_mutation& it
             result res;
             if (item.type() == staged_mutation_type::INSERT && !cas_zero_mode) {
                 core::operations::insert_request req{ item.doc().id(), item.doc().content() };
+                req.flags = couchbase::codec::codec_flags::json_common_flags;
                 wrap_durable_request(req, ctx.overall_.config());
                 auto barrier = std::make_shared<std::promise<result>>();
                 auto f = barrier->get_future();

package/deps/couchbase-cxx-client/core/transactions/transaction_context.cxx

@@ -25,15 +25,20 @@
 
 namespace couchbase::core::transactions
 {
-transaction_context::transaction_context(transactions& txns, const couchbase::transactions::per_transaction_config& config)
+transaction_context::transaction_context(transactions& txns, const couchbase::transactions::transaction_options& config)
   : transaction_id_(uid_generator::next())
   , start_time_client_(std::chrono::steady_clock::now())
   , transactions_(txns)
   , config_(config.apply(txns.config()))
   , deferred_elapsed_(0)
   , cleanup_(txns.cleanup())
-  , delay_(new exp_delay(std::chrono::milliseconds(1), std::chrono::milliseconds(100), 2 * config_.expiration_time()))
+  , delay_(new exp_delay(std::chrono::milliseconds(1), std::chrono::milliseconds(100), 2 * config_.expiration_time))
 {
+    // add metadata_collection to cleanup, if present
+    if (config_.metadata_collection) {
+        transactions_.cleanup().add_collection(
+          { config_.metadata_collection->bucket, config_.metadata_collection->scope, config_.metadata_collection->collection });
+    }
 }
 
 void
@@ -48,7 +53,7 @@ transaction_context::remaining() const
 {
     const auto& now = std::chrono::steady_clock::now();
     auto expired_nanos = std::chrono::duration_cast<std::chrono::nanoseconds>(now - start_time_client_) + deferred_elapsed_;
-    return config_.expiration_time() - expired_nanos;
+    return config_.expiration_time - expired_nanos;
 }
 
 [[nodiscard]] bool
@@ -58,7 +63,7 @@ transaction_context::has_expired_client_side()
     const auto& now = std::chrono::steady_clock::now();
     auto expired_nanos = std::chrono::duration_cast<std::chrono::nanoseconds>(now - start_time_client_) + deferred_elapsed_;
     auto expired_millis = std::chrono::duration_cast<std::chrono::milliseconds>(expired_nanos);
-    bool is_expired = expired_nanos > config_.expiration_time();
+    bool is_expired = expired_nanos > config_.expiration_time;
     if (is_expired) {
         txn_log->info("has expired client side (now={}ns, start={}ns, deferred_elapsed={}ns, expired={}ns ({}ms), config={}ms)",
                       now.time_since_epoch().count(),
@@ -66,7 +71,7 @@ transaction_context::has_expired_client_side()
                       deferred_elapsed_.count(),
                       expired_nanos.count(),
                       expired_millis.count(),
-                      std::chrono::duration_cast<std::chrono::milliseconds>(config_.expiration_time()).count());
+                      std::chrono::duration_cast<std::chrono::milliseconds>(config_.expiration_time).count());
     }
     return is_expired;
 }
@@ -75,8 +80,11 @@ void
 transaction_context::retry_delay()
 {
     // when we retry an operation, we typically call that function recursively.  So, we need to
-    // limit total number of times we do it.  Later we can be more sophisticated, perhaps.
-    auto delay = config_.expiration_time() / 100; // the 100 is arbitrary
+    // limit total number of times we do it.  CXXCBC-263 will address this, and no longer make the
+    // recursive calls that lead to hacks like this. No way to know how many calls will blow up the
+    // stack, so using 50 in hopes that makes jenkins happy till we do this better.
+    constexpr auto arbitrary_factor = 50;
+    auto delay = config_.expiration_time / arbitrary_factor;
     txn_log->trace("about to sleep for {} ms", std::chrono::duration_cast<std::chrono::milliseconds>(delay).count());
     std::this_thread::sleep_for(delay);
 }
@@ -150,7 +158,9 @@ transaction_context::remove(const transaction_get_result& doc, async_attempt_con
 }
 
 void
-transaction_context::query(const std::string& statement, const transaction_query_options& opts, async_attempt_context::QueryCallback&& cb)
+transaction_context::query(const std::string& statement,
+                           const couchbase::transactions::transaction_query_options& opts,
+                           async_attempt_context::QueryCallback&& cb)
 {
     if (current_attempt_context_) {
         return current_attempt_context_->query(statement, opts, std::move(cb));
@@ -191,7 +201,7 @@ transaction_context::handle_error(std::exception_ptr err, txn_complete_callback&
     try {
         try {
             std::rethrow_exception(err);
-        } catch (const query_exception& e) {
+        } catch (const op_exception& e) {
             // turn this into a transaction_operation_failed
             throw transaction_operation_failed(FAIL_OTHER, e.what()).cause(e.cause());
         }

package/deps/couchbase-cxx-client/core/transactions/transaction_options.cxx

@@ -0,0 +1,38 @@
+/*
+ *     Copyright 2022 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/transactions/attempt_context_testing_hooks.hxx>
+#include <core/transactions/cleanup_testing_hooks.hxx>
+#include <couchbase/transactions/transaction_options.hxx>
+
+namespace couchbase::transactions
+{
+transactions_config::built
+transaction_options::apply(const transactions_config::built& conf) const
+{
+    auto query_config = conf.query_config;
+    if (scan_consistency_) {
+        query_config.scan_consistency = *scan_consistency_;
+    }
+    return { durability_.value_or(conf.level),
+             expiration_time_.value_or(conf.expiration_time),
+             kv_timeout_ ? kv_timeout_ : conf.kv_timeout,
+             attempt_context_hooks_ ? attempt_context_hooks_ : conf.attempt_context_hooks,
+             cleanup_hooks_ ? cleanup_hooks_ : conf.cleanup_hooks,
+             metadata_collection_ ? metadata_collection_ : conf.metadata_collection,
+             query_config,
+             conf.cleanup_config };
+}
+} // namespace couchbase::transactions

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

@@ -27,8 +27,12 @@
 
 namespace couchbase::core::transactions
 {
+transactions::transactions(std::shared_ptr<core::cluster> cluster, const couchbase::transactions::transactions_config& config)
+  : transactions(cluster, config.build())
+{
+}
 
-transactions::transactions(std::shared_ptr<core::cluster> cluster, const couchbase::transactions::transaction_config& config)
+transactions::transactions(std::shared_ptr<core::cluster> cluster, const couchbase::transactions::transactions_config::built& config)
   : cluster_(cluster)
   , config_(config)
   , cleanup_(new transactions_cleanup(cluster_, config_))
@@ -40,11 +44,11 @@ transactions::transactions(std::shared_ptr<core::cluster> cluster, const couchba
     // on the cluster (that we have permissions to open) in the cleanup.   However, that is happening asynchronously
     // so there's a chance we will fail to have opened the custom metadata collection bucket before trying to make a
     // transaction.   We have to open this one _now_.
-    if (config_.custom_metadata_collection()) {
+    if (config_.metadata_collection) {
         auto barrier = std::make_shared<std::promise<std::error_code>>();
         auto f = barrier->get_future();
         std::atomic<bool> callback_called{ false };
-        cluster_->open_bucket(config_.custom_metadata_collection()->bucket, [&callback_called, barrier](std::error_code ec) {
+        cluster_->open_bucket(config_.metadata_collection->bucket, [&callback_called, barrier](std::error_code ec) {
             if (callback_called.load()) {
                 return;
             }
@@ -53,8 +57,8 @@ transactions::transactions(std::shared_ptr<core::cluster> cluster, const couchba
         });
         auto err = f.get();
         if (err) {
-            auto err_msg = fmt::format("error opening custom_metadata_collection bucket '{}' specified in the config!",
-                                       config_.custom_metadata_collection()->bucket);
+            auto err_msg =
+              fmt::format("error opening metadata_collection bucket '{}' specified in the config!", config_.metadata_collection->bucket);
             txn_log->error(err_msg);
             throw std::runtime_error(err_msg);
         }
@@ -65,7 +69,7 @@ transactions::~transactions() = default;
 
 template<typename Handler>
 ::couchbase::transactions::transaction_result
-wrap_run(transactions& txns, const couchbase::transactions::per_transaction_config& config, std::size_t max_attempts, Handler&& fn)
+wrap_run(transactions& txns, const couchbase::transactions::transaction_options& config, std::size_t max_attempts, Handler&& fn)
 {
     transaction_context overall(txns, config);
     std::size_t attempts{ 0 };
@@ -114,18 +118,18 @@ wrap_run(transactions& txns, const couchbase::transactions::per_transaction_conf
 ::couchbase::transactions::transaction_result
 transactions::run(logic&& code)
 {
-    couchbase::transactions::per_transaction_config config;
+    couchbase::transactions::transaction_options config;
     return wrap_run(*this, config, max_attempts_, std::move(code));
 }
 
 ::couchbase::transactions::transaction_result
-transactions::run(const couchbase::transactions::per_transaction_config& config, logic&& code)
+transactions::run(const couchbase::transactions::transaction_options& config, logic&& code)
 {
     return wrap_run(*this, config, max_attempts_, std::move(code));
 }
 
 couchbase::transactions::transaction_result
-transactions::run(couchbase::transactions::txn_logic&& code, const couchbase::transactions::per_transaction_config& config)
+transactions::run(couchbase::transactions::txn_logic&& code, const couchbase::transactions::transaction_options& config)
 {
     try {
         return wrap_run(*this, config, max_attempts_, std::move(code));
@@ -136,7 +140,7 @@ transactions::run(couchbase::transactions::txn_logic&& code, const couchbase::tr
 }
 
 void
-transactions::run(const couchbase::transactions::per_transaction_config& config, async_logic&& code, txn_complete_callback&& cb)
+transactions::run(const couchbase::transactions::transaction_options& config, async_logic&& code, txn_complete_callback&& cb)
 {
     std::thread([this, config, code = std::move(code), cb = std::move(cb)]() {
         try {
@@ -150,7 +154,7 @@ transactions::run(const couchbase::transactions::per_transaction_config& config,
 void
 transactions::run(couchbase::transactions::async_txn_logic&& code,
                   couchbase::transactions::async_txn_complete_logic&& cb,
-                  const couchbase::transactions::per_transaction_config& config)
+                  const couchbase::transactions::transaction_options& config)
 {
     std::thread([this, config, code = std::move(code), cb = std::move(cb)]() {
         try {
@@ -165,7 +169,7 @@ transactions::run(couchbase::transactions::async_txn_logic&& code,
 void
 transactions::run(async_logic&& code, txn_complete_callback&& cb)
 {
-    couchbase::transactions::per_transaction_config config;
+    couchbase::transactions::transaction_options config;
     return run(config, std::move(code), std::move(cb));
 }