couchbase 3.5.2 → 3.5.4

data/ext/couchbase/core/transactions/transaction_context.cxx

@@ -17,13 +17,17 @@
 #include "attempt_context_impl.hxx"
 #include "uid_generator.hxx"
 
+#include "core/transactions.hxx"
 #include "exceptions_fmt.hxx"
 #include "internal/logging.hxx"
+#include "internal/transaction_attempt.hxx"
 #include "internal/transaction_context.hxx"
+#include "internal/transactions_cleanup.hxx"
 #include "internal/utils.hxx"
 
 #include <asio/post.hpp>
 #include <asio/steady_timer.hpp>
+#include <utility>
 
 namespace couchbase::core::transactions
 {
@@ -67,11 +71,13 @@ transaction_context::transaction_context(transactions& txns,
   }
 }
 
+transaction_context::~transaction_context() = default;
+
 void
 transaction_context::add_attempt()
 {
-  transaction_attempt attempt{};
-  std::lock_guard<std::mutex> lock(mutex_);
+  const transaction_attempt attempt{};
+  const std::lock_guard<std::mutex> lock(mutex_);
   attempts_.push_back(attempt);
 }
 
@@ -94,7 +100,7 @@ transaction_context::has_expired_client_side() -> bool
     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_.timeout;
+  const bool is_expired = expired_nanos > config_.timeout;
   if (is_expired) {
     CB_ATTEMPT_CTX_LOG_INFO(
       current_attempt_context_,
@@ -112,7 +118,7 @@ transaction_context::has_expired_client_side() -> bool
 }
 
 void
-transaction_context::after_delay(std::chrono::milliseconds delay, std::function<void()> fn)
+transaction_context::after_delay(std::chrono::milliseconds delay, const std::function<void()>& fn)
 {
   auto timer = std::make_shared<asio::steady_timer>(this->transactions_.cluster_ref().io_context());
   timer->expires_after(delay);
@@ -207,7 +213,8 @@ transaction_context::query(const std::string& statement,
                            async_attempt_context::QueryCallback&& cb)
 {
   if (current_attempt_context_) {
-    return current_attempt_context_->query(statement, opts, query_context, std::move(cb));
+    return current_attempt_context_->query(
+      statement, opts, std::move(query_context), std::move(cb));
   }
   throw(transaction_operation_failed(FAIL_OTHER, "no current attempt context"));
 }
@@ -247,7 +254,7 @@ transaction_context::existing_error(bool previous_op_failed)
 }
 
 void
-transaction_context::handle_error(std::exception_ptr err, txn_complete_callback&& callback)
+transaction_context::handle_error(const std::exception_ptr& err, txn_complete_callback&& callback)
 {
   try {
     try {
@@ -344,9 +351,9 @@ transaction_context::finalize(txn_complete_callback&& cb)
     if (current_attempt_context_->is_done()) {
       return cb(std::nullopt, get_transaction_result());
     }
-    commit([self = shared_from_this(), cb = std::move(cb)](std::exception_ptr err) mutable {
+    commit([self = shared_from_this(), cb = std::move(cb)](const std::exception_ptr& err) mutable {
       if (err) {
-        return self->handle_error(std::move(err), std::move(cb));
+        return self->handle_error(err, std::move(cb));
       }
       cb(std::nullopt, self->get_transaction_result());
     });
@@ -354,4 +361,107 @@ transaction_context::finalize(txn_complete_callback&& cb)
     return handle_error(std::current_exception(), std::move(cb));
   }
 }
+
+void
+transaction_context::current_attempt_state(attempt_state s)
+{
+  const std::lock_guard<std::mutex> lock(mutex_);
+  if (attempts_.empty()) {
+    throw std::runtime_error("transaction_context has no attempts yet");
+  }
+  attempts_.back().state = s;
+}
+
+auto
+transaction_context::cluster_ref() const -> const core::cluster&
+{
+  return transactions_.cluster_ref();
+}
+
+auto
+transaction_context::config() const -> const couchbase::transactions::transactions_config::built&
+{
+  return config_;
+}
+
+auto
+transaction_context::cleanup() -> transactions_cleanup&
+{
+  return cleanup_;
+}
+
+auto
+transaction_context::start_time_client() const -> std::chrono::time_point<std::chrono::steady_clock>
+{
+  return start_time_client_;
+}
+
+auto
+transaction_context::atr_id() const -> const std::string&
+{
+  return atr_id_;
+}
+
+void
+transaction_context::atr_id(const std::string& id)
+{
+  atr_id_ = id;
+}
+
+auto
+transaction_context::atr_collection() const -> const std::string&
+{
+  return atr_collection_;
+}
+
+void
+transaction_context::atr_collection(const std::string& coll)
+{
+  atr_collection_ = coll;
+}
+
+auto
+transaction_context::get_transaction_result() const -> ::couchbase::transactions::transaction_result
+{
+  return couchbase::transactions::transaction_result{
+    transaction_id(), current_attempt().state == attempt_state::COMPLETED
+  };
+}
+
+void
+transaction_context::new_attempt_context()
+{
+  auto barrier = std::make_shared<std::promise<void>>();
+  auto f = barrier->get_future();
+  new_attempt_context([barrier](const std::exception_ptr& err) {
+    if (err) {
+      return barrier->set_exception(err);
+    }
+    return barrier->set_value();
+  });
+  f.get();
+}
+
+auto
+transaction_context::current_attempt() const -> const transaction_attempt&
+{
+  const std::lock_guard<std::mutex> lock(mutex_);
+  if (attempts_.empty()) {
+    throw std::runtime_error("transaction context has no attempts yet");
+  }
+  return attempts_.back();
+}
+
+auto
+transaction_context::num_attempts() const -> std::size_t
+{
+  const std::lock_guard<std::mutex> lock(mutex_);
+  return attempts_.size();
+}
+
+auto
+transaction_context::transaction_id() const -> const std::string&
+{
+  return transaction_id_;
+}
 } // namespace couchbase::core::transactions

data/ext/couchbase/core/transactions/transaction_get_result.cxx

@@ -15,9 +15,13 @@
  */
 
 #include "transaction_get_result.hxx"
-#include "couchbase/codec/codec_flags.hxx"
+
 #include "result.hxx"
 
+#include "core/operations.hxx"
+
+#include <couchbase/codec/codec_flags.hxx>
+
 namespace couchbase::core::transactions
 {
 namespace

data/ext/couchbase/core/transactions/transaction_get_result.hxx

@@ -15,16 +15,17 @@
  */
 
 #pragma once
+
 #include "core/document_id.hxx"
-#include "core/operations.hxx"
+#include "core/operations_fwd.hxx"
 #include "core/utils/json.hxx"
-#include "couchbase/codec/encoded_value.hxx"
 #include "document_metadata.hxx"
 #include "transaction_links.hxx"
+
+#include <couchbase/codec/encoded_value.hxx>
 #include <couchbase/fmt/cas.hxx>
 #include <couchbase/transactions/transaction_get_result.hxx>
 
-#include <ostream>
 #include <utility>
 
 namespace couchbase::core::transactions
@@ -57,6 +58,8 @@ public:
   /** @internal */
   transaction_get_result(const transaction_get_result& doc) = default;
   transaction_get_result(transaction_get_result&& doc) noexcept = default;
+  auto operator=(const transaction_get_result&) -> transaction_get_result& = delete;
+  auto operator=(transaction_get_result&&) -> transaction_get_result& = default;
 
   /*
   transaction_get_result(const transaction_op_error_context& ctx)
@@ -82,7 +85,7 @@ public:
     : cas_(res.cas())
     , document_id_(res.bucket(), res.scope(), res.collection(), res.id())
     , links_(res.base_->links())
-    , content_(std::move(res.content()))
+    , content_(res.content())
     , metadata_(res.base_->metadata_)
   {
   }
@@ -111,20 +114,9 @@ public:
     }
   }
 
-  auto operator=(const transaction_get_result& o) -> transaction_get_result&
-  {
-    if (this != &o) {
-      document_id_ = o.document_id_;
-      content_ = o.content_;
-      cas_ = o.cas_;
-      links_ = o.links_;
-    }
-    return *this;
-  }
-
   /** @internal */
-  static transaction_get_result create_from(const transaction_get_result& document,
-                                            codec::encoded_value content);
+  static auto create_from(const transaction_get_result& document,
+                          codec::encoded_value content) -> transaction_get_result;
 
   /** @internal */
   static auto create_from(const core::operations::lookup_in_response& resp)

data/ext/couchbase/core/transactions/transaction_keyspace.cxx

@@ -45,7 +45,7 @@ transaction_keyspace::transaction_keyspace(const std::string& bucket_name)
 }
 
 auto
-transaction_keyspace::valid() -> bool
+transaction_keyspace::valid() const -> bool
 {
   return !bucket.empty() && !scope.empty() && !collection.empty();
 }

data/ext/couchbase/core/transactions/transaction_links.cxx

@@ -16,9 +16,12 @@
 
 #include "transaction_links.hxx"
 
+#include <utility>
+
+namespace couchbase::core::transactions
+{
 auto
-couchbase::core::transactions::operator<<(std::ostream& os,
-                                          const transaction_links& links) -> std::ostream&
+operator<<(std::ostream& os, const transaction_links& links) -> std::ostream&
 {
   os << "transaction_links{atr: " << links.atr_id_.value_or("none")
      << ", atr_bkt: " << links.atr_bucket_name_.value_or("none")
@@ -29,3 +32,85 @@ couchbase::core::transactions::operator<<(std::ostream& os,
      << ", crc32_of_staging:" << links.crc32_of_staging_.value_or("none") << "}";
   return os;
 }
+
+void
+transaction_links::append_to_json(tao::json::value& obj) const
+{
+  if (staged_attempt_id_) {
+    obj["txnMeta"]["atmpt"] = staged_attempt_id_.value();
+  }
+  if (staged_transaction_id_) {
+    obj["txnMeta"]["txn"] = staged_transaction_id_.value();
+  }
+  if (staged_operation_id_) {
+    obj["txnMeta"]["txn"] = staged_operation_id_.value();
+  }
+  if (atr_id_) {
+    obj["txnMeta"]["atr"]["key"] = atr_id_.value();
+  }
+  if (atr_bucket_name_) {
+    obj["txnMeta"]["atr"]["bkt"] = atr_bucket_name_.value();
+  }
+  if (atr_scope_name_) {
+    obj["txnMeta"]["atr"]["scp"] = atr_scope_name_.value();
+  }
+  if (atr_collection_name_) {
+    obj["txnMeta"]["atr"]["coll"] = atr_collection_name_.value();
+  }
+}
+
+transaction_links::transaction_links(const tao::json::value& json)
+{
+  if (const auto* meta = json.find("txnMeta"); meta != nullptr && meta->is_object()) {
+    for (const auto& [key, value] : meta->get_object()) {
+      if (key == "atmpt") {
+        staged_attempt_id_ = value.get_string();
+      }
+      if (key == "txn") {
+        staged_transaction_id_ = value.get_string();
+      }
+      if (key == "atr" && value.is_object()) {
+        atr_id_ = value.at("key").get_string();
+        atr_bucket_name_ = value.at("bkt").get_string();
+        atr_scope_name_ = value.at("scp").get_string();
+        atr_collection_name_ = value.at("coll").get_string();
+      }
+    }
+  }
+}
+
+transaction_links::transaction_links(std::optional<std::string> atr_id,
+                                     std::optional<std::string> atr_bucket_name,
+                                     std::optional<std::string> atr_scope_name,
+                                     std::optional<std::string> atr_collection_name,
+                                     std::optional<std::string> staged_transaction_id,
+                                     std::optional<std::string> staged_attempt_id,
+                                     std::optional<std::string> staged_operation_id,
+                                     std::optional<codec::encoded_value> staged_content_json,
+                                     std::optional<codec::encoded_value> staged_content_binary,
+                                     std::optional<std::string> cas_pre_txn,
+                                     std::optional<std::string> revid_pre_txn,
+                                     std::optional<std::uint32_t> exptime_pre_txn,
+                                     std::optional<std::string> crc32_of_staging,
+                                     std::optional<std::string> op,
+                                     std::optional<tao::json::value> forward_compat,
+                                     bool is_deleted)
+  : atr_id_(std::move(atr_id))
+  , atr_bucket_name_(std::move(atr_bucket_name))
+  , atr_scope_name_(std::move(atr_scope_name))
+  , atr_collection_name_(std::move(atr_collection_name))
+  , staged_transaction_id_(std::move(staged_transaction_id))
+  , staged_attempt_id_(std::move(staged_attempt_id))
+  , staged_operation_id_(std::move(staged_operation_id))
+  , staged_content_json_(std::move(staged_content_json))
+  , staged_content_binary_(std::move(staged_content_binary))
+  , cas_pre_txn_(std::move(cas_pre_txn))
+  , revid_pre_txn_(std::move(revid_pre_txn))
+  , exptime_pre_txn_(exptime_pre_txn)
+  , crc32_of_staging_(std::move(crc32_of_staging))
+  , op_(std::move(op))
+  , forward_compat_(std::move(forward_compat))
+  , is_deleted_(is_deleted)
+{
+}
+} // namespace couchbase::core::transactions

data/ext/couchbase/core/transactions/transaction_links.hxx

@@ -68,74 +68,15 @@ public:
                     std::optional<std::string> crc32_of_staging,
                     std::optional<std::string> op,
                     std::optional<tao::json::value> forward_compat,
-                    bool is_deleted)
-    : atr_id_(std::move(atr_id))
-    , atr_bucket_name_(std::move(atr_bucket_name))
-    , atr_scope_name_(std::move(atr_scope_name))
-    , atr_collection_name_(std::move(atr_collection_name))
-    , staged_transaction_id_(std::move(staged_transaction_id))
-    , staged_attempt_id_(std::move(staged_attempt_id))
-    , staged_operation_id_(std::move(staged_operation_id))
-    , staged_content_json_(std::move(staged_content_json))
-    , staged_content_binary_(std::move(staged_content_binary))
-    , cas_pre_txn_(std::move(cas_pre_txn))
-    , revid_pre_txn_(std::move(revid_pre_txn))
-    , exptime_pre_txn_(exptime_pre_txn)
-    , crc32_of_staging_(std::move(crc32_of_staging))
-    , op_(std::move(op))
-    , forward_compat_(forward_compat)
-    , is_deleted_(is_deleted)
-  {
-  }
+                    bool is_deleted);
 
   /** @brief create links from query result
    *
    * @param json the returned row object from a txn query response.
    */
-  explicit transaction_links(const tao::json::value& json)
-  {
-    if (const auto* meta = json.find("txnMeta"); meta != nullptr && meta->is_object()) {
-      for (const auto& [key, value] : meta->get_object()) {
-        if (key == "atmpt") {
-          staged_attempt_id_ = value.get_string();
-        }
-        if (key == "txn") {
-          staged_transaction_id_ = value.get_string();
-        }
-        if (key == "atr" && value.is_object()) {
-          atr_id_ = value.at("key").get_string();
-          atr_bucket_name_ = value.at("bkt").get_string();
-          atr_scope_name_ = value.at("scp").get_string();
-          atr_collection_name_ = value.at("coll").get_string();
-        }
-      }
-    }
-  }
+  explicit transaction_links(const tao::json::value& json);
 
-  void append_to_json(tao::json::value& obj) const
-  {
-    if (staged_attempt_id_) {
-      obj["txnMeta"]["atmpt"] = staged_attempt_id_.value();
-    }
-    if (staged_transaction_id_) {
-      obj["txnMeta"]["txn"] = staged_transaction_id_.value();
-    }
-    if (staged_operation_id_) {
-      obj["txnMeta"]["txn"] = staged_operation_id_.value();
-    }
-    if (atr_id_) {
-      obj["txnMeta"]["atr"]["key"] = atr_id_.value();
-    }
-    if (atr_bucket_name_) {
-      obj["txnMeta"]["atr"]["bkt"] = atr_bucket_name_.value();
-    }
-    if (atr_scope_name_) {
-      obj["txnMeta"]["atr"]["scp"] = atr_scope_name_.value();
-    }
-    if (atr_collection_name_) {
-      obj["txnMeta"]["atr"]["coll"] = atr_collection_name_.value();
-    }
-  }
+  void append_to_json(tao::json::value& obj) const;
 
   /**
    * Note this doesn't guarantee an active transaction, as it may have expired
@@ -226,17 +167,17 @@ public:
     return staged_content_json_ || staged_content_binary_;
   }
 
-  [[nodiscard]] codec::encoded_value staged_content_json_or_binary() const
+  [[nodiscard]] auto staged_content_json_or_binary() const -> codec::encoded_value
   {
     return staged_content_json_.value_or(staged_content_binary_.value_or(codec::encoded_value{}));
   }
 
-  [[nodiscard]] codec::encoded_value staged_content_json() const
+  [[nodiscard]] auto staged_content_json() const -> codec::encoded_value
   {
     return staged_content_json_.value_or(codec::encoded_value{});
   }
 
-  [[nodiscard]] codec::encoded_value staged_content_binary() const
+  [[nodiscard]] auto staged_content_binary() const -> codec::encoded_value
   {
     return staged_content_binary_.value_or(codec::encoded_value{});
   }

data/ext/couchbase/core/transactions/transaction_options.cxx

@@ -19,6 +19,7 @@
 
 #include <core/transactions/attempt_context_testing_hooks.hxx>
 #include <core/transactions/cleanup_testing_hooks.hxx>
+#include <utility>
 
 namespace couchbase::transactions
 {
@@ -44,8 +45,8 @@ transaction_options::test_factories(
   std::shared_ptr<core::transactions::attempt_context_testing_hooks> hooks,
   std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks) -> transaction_options&
 {
-  attempt_context_hooks_ = hooks;
-  cleanup_hooks_ = cleanup_hooks;
+  attempt_context_hooks_ = std::move(hooks);
+  cleanup_hooks_ = std::move(cleanup_hooks);
   return *this;
 }
 

data/ext/couchbase/core/transactions/transactions.cxx

@@ -30,6 +30,7 @@
 #include <couchbase/error.hxx>
 
 #include <system_error>
+#include <utility>
 
 namespace couchbase::core::transactions
 {
@@ -40,9 +41,9 @@ transactions::transactions(core::cluster cluster,
 }
 
 transactions::transactions(core::cluster cluster,
-                           const couchbase::transactions::transactions_config::built& config)
+                           couchbase::transactions::transactions_config::built config)
   : cluster_(std::move(cluster))
-  , config_(config)
+  , config_(std::move(config))
   , cleanup_(new transactions_cleanup(cluster_, config_))
 {
 }
@@ -98,7 +99,7 @@ transactions::create(core::cluster cluster,
 {
   auto barrier =
     std::make_shared<std::promise<std::pair<std::error_code, std::shared_ptr<transactions>>>>();
-  create(std::move(cluster), config, [barrier](auto ec, auto txns) mutable {
+  create(std::move(cluster), config, [barrier](auto ec, const auto& txns) mutable {
     barrier->set_value({ ec, txns });
   });
   return barrier->get_future();
@@ -117,6 +118,8 @@ auto
 wrap_run(transactions& txns,
          const couchbase::transactions::transaction_options& config,
          std::size_t max_attempts,
+         // TODO(CXXCBC-549)
+         // NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward)
          Handler&& fn) -> ::couchbase::transactions::transaction_result
 {
   auto overall = transaction_context::create(txns, config);
@@ -168,8 +171,8 @@ wrap_public_api_run(transactions& txns,
                     std::size_t max_attempts,
                     Handler&& fn) -> ::couchbase::transactions::transaction_result
 {
-  return wrap_run(txns, config, max_attempts, [fn = std::forward<Handler>(fn)](auto ctx) {
-    couchbase::error err = fn(ctx);
+  return wrap_run(txns, config, max_attempts, [fn = std::forward<Handler>(fn)](const auto& ctx) {
+    const couchbase::error err = fn(ctx);
     if (err && err.ec() != errc::transaction_op::transaction_op_failed) {
       if (err.ec().category() == core::impl::transaction_op_category()) {
         throw op_exception(err);
@@ -182,7 +185,7 @@ wrap_public_api_run(transactions& txns,
 auto
 transactions::run(logic&& code) -> ::couchbase::transactions::transaction_result
 {
-  couchbase::transactions::transaction_options config;
+  const couchbase::transactions::transaction_options config;
   return wrap_run(*this, config, max_attempts_, std::move(code));
 }
 
@@ -214,7 +217,7 @@ transactions::run(const couchbase::transactions::transaction_options& config,
 {
   std::thread([this, config, code = std::move(code), cb = std::move(cb)]() {
     try {
-      auto result = wrap_run(*this, config, max_attempts_, std::move(code));
+      auto result = wrap_run(*this, config, max_attempts_, code);
       return cb({}, result);
     } catch (const transaction_exception& e) {
       return cb(e, std::nullopt);
@@ -228,7 +231,7 @@ transactions::run(couchbase::transactions::async_txn_logic&& code,
 {
   std::thread([this, config, code = std::move(code), cb = std::move(cb)]() {
     try {
-      auto result = wrap_public_api_run(*this, config, max_attempts_, std::move(code));
+      auto result = wrap_public_api_run(*this, config, max_attempts_, code);
       return cb({}, result);
     } catch (const transaction_exception& e) {
       auto [ctx, res] = e.get_transaction_result();
@@ -240,7 +243,7 @@ transactions::run(couchbase::transactions::async_txn_logic&& code,
 void
 transactions::run(async_logic&& code, txn_complete_callback&& cb)
 {
-  couchbase::transactions::transaction_options config;
+  const couchbase::transactions::transaction_options config;
   return run(config, std::move(code), std::move(cb));
 }