couchbase 3.5.2 → 3.5.3

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

@@ -54,12 +54,12 @@ parse_mutation_cas(const std::string& cas) -> std::uint64_t
 
   std::uint64_t val = stoull(cas, nullptr, 16);
   /* byteswap */
-  std::size_t ii;
+  std::size_t ii = 0;
   std::uint64_t ret = 0;
   for (ii = 0; ii < sizeof(std::uint64_t); ii++) {
-    ret <<= 8ull;
-    ret |= val & 0xffull;
-    val >>= 8ull;
+    ret <<= 8ULL;
+    ret |= val & 0xffULL;
+    val >>= 8ULL;
   }
   return ret / 1000000;
 }
@@ -94,7 +94,7 @@ map_to_atr(const operations::lookup_in_response& resp) -> active_transaction_rec
       if (const auto* compat = val.find(ATR_FIELD_FORWARD_COMPAT); compat != nullptr) {
         forward_compat = *compat;
       }
-      std::optional<std::uint32_t> expires_after_msec =
+      const std::optional<std::uint32_t> expires_after_msec =
         std::max(val.optional<std::int32_t>(ATR_FIELD_EXPIRES_AFTER_MSECS).value_or(0), 0);
       entries.emplace_back(
         resp.ctx.bucket(),
@@ -117,10 +117,9 @@ map_to_atr(const operations::lookup_in_response& resp) -> active_transaction_rec
         val.optional<std::string>(ATR_FIELD_DURABILITY_LEVEL));
     }
   }
-  return active_transaction_record(
-    { resp.ctx.bucket(), resp.ctx.scope(), resp.ctx.collection(), resp.ctx.id() },
-    resp.cas.value(),
-    std::move(entries));
+  return { { resp.ctx.bucket(), resp.ctx.scope(), resp.ctx.collection(), resp.ctx.id() },
+           resp.cas.value(),
+           std::move(entries) };
 }
 
 auto
@@ -151,28 +150,28 @@ active_transaction_record::get_atr(
       lookup_in_specs::get(subdoc::lookup_in_macro::vbucket).xattr(),
     }
       .specs();
-  cluster.execute(req,
-                  [atr_id, cb = std::move(cb)](core::operations::lookup_in_response resp) mutable {
-                    try {
-                      if (resp.ctx.ec() == couchbase::errc::key_value::document_not_found) {
-                        // that's ok, just return an empty one.
-                        return cb({}, {});
-                      }
-                      if (!resp.ctx.ec()) {
-                        // success
-                        return cb(resp.ctx.ec(), map_to_atr(resp));
-                      }
-                      // otherwise, raise an error.
-                      cb(resp.ctx.ec(), {});
-                    } catch (const std::exception&) {
-                      // ok - we have a corrupt ATR.  The question is:  what should we return
-                      // for an error? Turns out, we don't much care in the code what this error
-                      // is.  Since we cannot parse the atr, but there wasn't an error, lets
-                      // select this one for now.
-                      // TODO: consider a different mechanism - not an error_code.  Or, perhaps
-                      // we need txn-specific error codes?
-                      cb(couchbase::errc::key_value::path_invalid, std::nullopt);
-                    }
-                  });
+  cluster.execute(
+    req, [atr_id, cb = std::move(cb)](const core::operations::lookup_in_response& resp) mutable {
+      try {
+        if (resp.ctx.ec() == couchbase::errc::key_value::document_not_found) {
+          // that's ok, just return an empty one.
+          return cb({}, {});
+        }
+        if (!resp.ctx.ec()) {
+          // success
+          return cb(resp.ctx.ec(), map_to_atr(resp));
+        }
+        // otherwise, raise an error.
+        cb(resp.ctx.ec(), {});
+      } catch (const std::exception&) {
+        // ok - we have a corrupt ATR.  The question is:  what should we return
+        // for an error? Turns out, we don't much care in the code what this error
+        // is.  Since we cannot parse the atr, but there wasn't an error, lets
+        // select this one for now.
+        // TODO(SA): consider a different mechanism - not an error_code.  Or, perhaps
+        // we need txn-specific error codes?
+        cb(couchbase::errc::key_value::path_invalid, std::nullopt);
+      }
+    });
 }
 } // namespace couchbase::core::transactions

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

@@ -16,12 +16,12 @@
 #pragma once
 
 #include "core/error_context/subdocument_error_context.hxx"
-#include "couchbase/cluster.hxx"
-#include "couchbase/transactions/transaction_query_options.hxx"
+#include "core/operations/document_query.hxx"
 #include "exceptions.hxx"
 #include "transaction_get_result.hxx"
 
-#include "core/operations/document_query.hxx"
+#include <couchbase/transactions/transaction_query_options.hxx>
+
 #include <future>
 #include <optional>
 #include <string>

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

@@ -20,18 +20,21 @@
 #include "durability_level.hxx"
 #include "forward_compat.hxx"
 
+#include "core/operations.hxx"
 #include "core/transactions.hxx"
 #include "internal/atr_cleanup_entry.hxx"
 #include "internal/doc_record_fmt.hxx"
 #include "internal/exceptions_internal.hxx"
 #include "internal/exceptions_internal_fmt.hxx"
 #include "internal/logging.hxx"
+#include "internal/transaction_context.hxx"
 #include "internal/transactions_cleanup.hxx"
 #include "internal/utils.hxx"
 #include "result.hxx"
 #include "result_fmt.hxx"
 
 #include <optional>
+#include <utility>
 
 namespace couchbase::core::transactions
 {
@@ -46,11 +49,11 @@ compare_atr_entries::operator()(atr_cleanup_entry& lhs, atr_cleanup_entry& rhs)
 // wait a bit after an attempt is expired before cleaning it.
 const uint32_t atr_cleanup_entry::safety_margin_ms_ = 1500;
 
-atr_cleanup_entry::atr_cleanup_entry(const core::document_id& atr_id,
-                                     const std::string& attempt_id,
+atr_cleanup_entry::atr_cleanup_entry(core::document_id atr_id,
+                                     std::string attempt_id,
                                      const transactions_cleanup& cleanup)
-  : atr_id_(atr_id)
-  , attempt_id_(attempt_id)
+  : atr_id_(std::move(atr_id))
+  , attempt_id_(std::move(attempt_id))
   , check_if_expired_(false)
   , cleanup_(&cleanup)
   , atr_entry_(nullptr)
@@ -58,11 +61,10 @@ atr_cleanup_entry::atr_cleanup_entry(const core::document_id& atr_id,
 }
 
 atr_cleanup_entry::atr_cleanup_entry(const atr_entry& entry,
-                                     const core::document_id& atr_id,
+                                     core::document_id atr_id,
                                      const transactions_cleanup& cleanup,
                                      bool check_if_expired)
-  //  : atr_id_(atr_id.bucket(), atr_id.scope(), atr_id.collection(), atr_id.key())
-  : atr_id_(atr_id)
+  : atr_id_(std::move(atr_id))
   , attempt_id_(entry.attempt_id())
   , check_if_expired_(check_if_expired)
   , cleanup_(&cleanup)
@@ -70,7 +72,7 @@ atr_cleanup_entry::atr_cleanup_entry(const atr_entry& entry,
 {
 }
 
-atr_cleanup_entry::atr_cleanup_entry(std::shared_ptr<attempt_context> ctx)
+atr_cleanup_entry::atr_cleanup_entry(const std::shared_ptr<attempt_context>& ctx)
   : min_start_time_(std::chrono::steady_clock::now())
   , check_if_expired_(false)
   , atr_entry_(nullptr)
@@ -78,12 +80,17 @@ atr_cleanup_entry::atr_cleanup_entry(std::shared_ptr<attempt_context> ctx)
   // NOTE: we create these entries externally, in fit_performer tests, hence the
   // use of attempt_context rather than attempt_context_impl
   auto ctx_impl = std::dynamic_pointer_cast<attempt_context_impl>(ctx);
-  atr_id_ = { ctx_impl->atr_id_.value().bucket(),
-              ctx_impl->atr_id_.value().scope(),
-              ctx_impl->atr_id_.value().collection(),
-              ctx_impl->atr_id_.value().key() };
+  Expects(ctx_impl != nullptr);
+  if (auto atr_id = ctx_impl->atr_id_; atr_id.has_value()) {
+    atr_id_ = {
+      atr_id->bucket(),
+      atr_id->scope(),
+      atr_id->collection(),
+      atr_id->key(),
+    };
+  }
   attempt_id_ = ctx_impl->id();
-  cleanup_ = &ctx_impl->overall_->cleanup();
+  cleanup_ = &ctx_impl->overall()->cleanup();
 }
 
 void
@@ -91,7 +98,7 @@ atr_cleanup_entry::clean(transactions_cleanup_attempt* result)
 {
   CB_ATTEMPT_CLEANUP_LOG_TRACE("cleaning {}", *this);
   // get atr entry if needed
-  atr_entry entry;
+  const atr_entry entry;
   if (nullptr == atr_entry_) {
     auto atr = active_transaction_record::get_atr(cleanup_->cluster_ref(), atr_id_);
     if (atr) {
@@ -102,14 +109,12 @@ atr_cleanup_entry::clean(transactions_cleanup_attempt* result)
       if (it != atr->entries().end()) {
         atr_entry_ = &(*it);
         return check_atr_and_cleanup(result);
-      } else {
-        CB_ATTEMPT_CLEANUP_LOG_TRACE("could not find attempt {}, nothing to clean", attempt_id_);
-        return;
       }
-    } else {
-      CB_ATTEMPT_CLEANUP_LOG_TRACE("could not find atr {}, nothing to clean", atr_id_);
+      CB_ATTEMPT_CLEANUP_LOG_TRACE("could not find attempt {}, nothing to clean", attempt_id_);
       return;
     }
+    CB_ATTEMPT_CLEANUP_LOG_TRACE("could not find atr {}, nothing to clean", atr_id_);
+    return;
   }
   check_atr_and_cleanup(result);
 }
@@ -127,7 +132,7 @@ atr_cleanup_entry::check_atr_and_cleanup(transactions_cleanup_attempt* result)
     CB_ATTEMPT_CLEANUP_LOG_TRACE("not expired, nothing to clean");
     return;
   }
-  if (result) {
+  if (result != nullptr) {
     result->state(atr_entry_->state());
   }
   auto err =
@@ -149,7 +154,6 @@ atr_cleanup_entry::check_atr_and_cleanup(transactions_cleanup_attempt* result)
   if (ec) {
     throw client_error(*ec, "on_cleanup_completed hook threw error");
   }
-  return;
 }
 
 void
@@ -175,7 +179,7 @@ atr_cleanup_entry::cleanup_docs(durability_level dl)
 }
 
 void
-atr_cleanup_entry::do_per_doc(std::vector<doc_record> docs,
+atr_cleanup_entry::do_per_doc(const std::vector<doc_record>& docs,
                               bool require_crc_to_match,
                               const std::function<void(transaction_get_result&, bool)>& call)
 {
@@ -227,19 +231,21 @@ atr_cleanup_entry::do_per_doc(std::vector<doc_record> docs,
         continue;
       }
       if (require_crc_to_match) {
-        if (!doc.metadata()->crc32() || !doc.links().crc32_of_staging() ||
-            doc.links().crc32_of_staging() != doc.metadata()->crc32()) {
-          CB_ATTEMPT_CLEANUP_LOG_TRACE(
-            "document {} crc32 {} doesn't match staged value {}, skipping",
-            dr.id(),
-            doc.metadata()->crc32().value_or("<none>"),
-            doc.links().crc32_of_staging().value_or("<none>"));
-          continue;
+        if (const auto& metadata = doc.metadata(); metadata.has_value()) {
+          if (!metadata->crc32() || !doc.links().crc32_of_staging() ||
+              doc.links().crc32_of_staging() != metadata->crc32()) {
+            CB_ATTEMPT_CLEANUP_LOG_TRACE(
+              "document {} crc32 {} doesn't match staged value {}, skipping",
+              dr.id(),
+              metadata->crc32().value_or("<none>"),
+              doc.links().crc32_of_staging().value_or("<none>"));
+            continue;
+          }
         }
       }
       call(doc, res.deleted);
     } catch (const client_error& e) {
-      error_class ec = e.ec();
+      const error_class ec = e.ec();
       switch (ec) {
         case FAIL_DOC_NOT_FOUND:
           CB_ATTEMPT_CLEANUP_LOG_ERROR("document {} not found - ignoring ", dr);
@@ -270,10 +276,11 @@ atr_cleanup_entry::commit_docs(std::optional<std::vector<doc_record>> docs, dura
           req.flags = content.flags;
           auto barrier = std::make_shared<std::promise<result>>();
           auto f = barrier->get_future();
-          cleanup_->cluster_ref().execute(
-            wrap_durable_request(req, dl), [barrier](core::operations::insert_response resp) {
-              barrier->set_value(result::create_from_mutation_response(resp));
-            });
+          cleanup_->cluster_ref().execute(wrap_durable_request(req, dl),
+                                          [barrier](const core::operations::insert_response& resp) {
+                                            barrier->set_value(
+                                              result::create_from_mutation_response(resp));
+                                          });
           wrap_operation_future(f);
         } else {
           core::operations::mutate_in_request req{ doc.id() };
@@ -290,7 +297,7 @@ atr_cleanup_entry::commit_docs(std::optional<std::vector<doc_record>> docs, dura
           auto barrier = std::make_shared<std::promise<result>>();
           auto f = barrier->get_future();
           cleanup_->cluster_ref().execute(
-            req, [barrier](core::operations::mutate_in_response resp) {
+            req, [barrier](const core::operations::mutate_in_response& resp) {
               barrier->set_value(result::create_from_subdoc_response(resp));
             });
           wrap_operation_future(f);
@@ -328,9 +335,10 @@ atr_cleanup_entry::remove_docs(std::optional<std::vector<doc_record>> docs, dura
         wrap_durable_request(req, dl);
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        cleanup_->cluster_ref().execute(req, [barrier](core::operations::mutate_in_response resp) {
-          barrier->set_value(result::create_from_subdoc_response(resp));
-        });
+        cleanup_->cluster_ref().execute(
+          req, [barrier](const core::operations::mutate_in_response& resp) {
+            barrier->set_value(result::create_from_subdoc_response(resp));
+          });
         wrap_operation_future(f);
       } else {
         core::operations::remove_request req{ doc.id() };
@@ -338,9 +346,10 @@ atr_cleanup_entry::remove_docs(std::optional<std::vector<doc_record>> docs, dura
         wrap_durable_request(req, dl);
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        cleanup_->cluster_ref().execute(req, [barrier](core::operations::remove_response resp) {
-          barrier->set_value(result::create_from_mutation_response(resp));
-        });
+        cleanup_->cluster_ref().execute(
+          req, [barrier](const core::operations::remove_response& resp) {
+            barrier->set_value(result::create_from_mutation_response(resp));
+          });
         wrap_operation_future(f);
       }
       CB_ATTEMPT_CLEANUP_LOG_TRACE("remove_docs removed doc {}", doc.id());
@@ -367,9 +376,10 @@ atr_cleanup_entry::remove_docs_staged_for_removal(std::optional<std::vector<doc_
         wrap_durable_request(req, dl);
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        cleanup_->cluster_ref().execute(req, [barrier](core::operations::remove_response resp) {
-          barrier->set_value(result::create_from_mutation_response(resp));
-        });
+        cleanup_->cluster_ref().execute(
+          req, [barrier](const core::operations::remove_response& resp) {
+            barrier->set_value(result::create_from_mutation_response(resp));
+          });
         wrap_operation_future(f);
         CB_ATTEMPT_CLEANUP_LOG_TRACE("remove_docs_staged_for_removal removed doc {}", doc.id());
       } else {
@@ -405,9 +415,10 @@ atr_cleanup_entry::remove_txn_links(std::optional<std::vector<doc_record>> docs,
       wrap_durable_request(req, dl);
       auto barrier = std::make_shared<std::promise<result>>();
       auto f = barrier->get_future();
-      cleanup_->cluster_ref().execute(req, [barrier](core::operations::mutate_in_response resp) {
-        barrier->set_value(result::create_from_subdoc_response(resp));
-      });
+      cleanup_->cluster_ref().execute(
+        req, [barrier](const core::operations::mutate_in_response& resp) {
+          barrier->set_value(result::create_from_subdoc_response(resp));
+        });
       wrap_operation_future(f);
       CB_ATTEMPT_CLEANUP_LOG_TRACE("remove_txn_links removed links for doc {}", doc.id());
     });
@@ -437,9 +448,10 @@ atr_cleanup_entry::cleanup_entry(durability_level dl)
     wrap_durable_request(req, dl);
     auto barrier = std::make_shared<std::promise<result>>();
     auto f = barrier->get_future();
-    cleanup_->cluster_ref().execute(req, [barrier](core::operations::mutate_in_response resp) {
-      barrier->set_value(result::create_from_subdoc_response(resp));
-    });
+    cleanup_->cluster_ref().execute(req,
+                                    [barrier](const core::operations::mutate_in_response& resp) {
+                                      barrier->set_value(result::create_from_subdoc_response(resp));
+                                    });
     wrap_operation_future(f);
     CB_ATTEMPT_CLEANUP_LOG_TRACE("successfully removed attempt {}", attempt_id_);
   } catch (const client_error& e) {
@@ -467,9 +479,9 @@ atr_cleanup_entry::ready() const -> bool
 auto
 atr_cleanup_queue::pop(bool check_time) -> std::optional<atr_cleanup_entry>
 {
-  std::unique_lock<std::mutex> lock(mutex_);
+  const std::unique_lock<std::mutex> lock(mutex_);
   if (!queue_.empty()) {
-    if (!check_time || (check_time && queue_.top().ready())) {
+    if (!check_time || queue_.top().ready()) {
       // copy it
       atr_cleanup_entry top = queue_.top();
       // pop it
@@ -483,14 +495,14 @@ atr_cleanup_queue::pop(bool check_time) -> std::optional<atr_cleanup_entry>
 auto
 atr_cleanup_queue::size() const -> std::size_t
 {
-  std::unique_lock<std::mutex> lock(mutex_);
+  const std::unique_lock<std::mutex> lock(mutex_);
   return queue_.size();
 }
 
 void
-atr_cleanup_queue::push(std::shared_ptr<attempt_context> ctx)
+atr_cleanup_queue::push(const std::shared_ptr<attempt_context>& ctx)
 {
-  std::unique_lock<std::mutex> lock(mutex_);
+  const std::unique_lock<std::mutex> lock(mutex_);
   queue_.emplace(ctx);
 }
 } // namespace couchbase::core::transactions

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

@@ -24,7 +24,8 @@
 
 namespace couchbase::core::transactions
 {
-
+// TODO(CXXCBC-549)
+// NOLINTNEXTLINE(cert-err58-cpp)
 const std::vector<std::string> ATR_IDS({
   "_txn:atr-0-#14",     "_txn:atr-1-#10b6",    "_txn:atr-2-#cc8",    "_txn:atr-3-#f08",
   "_txn:atr-4-#c7",     "_txn:atr-5-#11a",     "_txn:atr-6-#a",      "_txn:atr-7-#2c4",
@@ -303,7 +304,7 @@ auto
 atr_ids::vbucket_for_key(const std::string& key) -> std::size_t
 {
   static const int num_vbuckets = 1024;
-  std::uint32_t digest = core::utils::hash_crc32(key.data(), key.size());
+  const std::uint32_t digest = core::utils::hash_crc32(key.data(), key.size());
   return static_cast<std::size_t>(digest % num_vbuckets);
 }