couchbase 3.5.2 → 3.5.3

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

@@ -16,12 +16,6 @@
 
 #pragma once
 
-#include <couchbase/transactions/async_attempt_context.hxx>
-#include <couchbase/transactions/attempt_context.hxx>
-#include <couchbase/transactions/transaction_query_options.hxx>
-
-#include "attempt_context_testing_hooks.hxx"
-#include "couchbase/codec/encoded_value.hxx"
 #include "error_list.hxx"
 #include "waitable_op_list.hxx"
 
@@ -30,9 +24,13 @@
 #include "attempt_state.hxx"
 #include "internal/atr_cleanup_entry.hxx"
 #include "internal/exceptions_internal.hxx"
-#include "internal/transaction_context.hxx"
 #include "transaction_get_result.hxx"
 
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/transactions/async_attempt_context.hxx>
+#include <couchbase/transactions/attempt_context.hxx>
+#include <couchbase/transactions/transaction_query_options.hxx>
+
 #include <cstdint>
 #include <memory>
 #include <mutex>
@@ -43,6 +41,8 @@
 namespace couchbase::core
 {
 class cluster;
+class transaction_context;
+
 namespace impl
 {
 auto
@@ -65,6 +65,7 @@ class transactions;
 enum class forward_compat_stage;
 class staged_mutation_queue;
 class staged_mutation;
+struct attempt_context_testing_hooks;
 
 class attempt_context_impl
   : public attempt_context
@@ -74,7 +75,7 @@ class attempt_context_impl
   , public std::enable_shared_from_this<attempt_context_impl>
 {
 private:
-  std::shared_ptr<transaction_context> overall_;
+  std::weak_ptr<transaction_context> overall_;
   std::optional<core::document_id> atr_id_;
   bool is_done_{ false };
   std::unique_ptr<staged_mutation_queue> staged_mutations_;
@@ -141,23 +142,23 @@ private:
   void commit_with_query(VoidCallback&& cb);
   void rollback_with_query(VoidCallback&& cb);
 
-  void query_begin_work(std::optional<std::string> query_context, VoidCallback&& cb);
+  void query_begin_work(const std::optional<std::string>& query_context, VoidCallback&& cb);
 
   void do_query(const std::string& statement,
                 const couchbase::transactions::transaction_query_options& opts,
-                std::optional<std::string> query_context,
+                const std::optional<std::string>& query_context,
                 QueryCallback&& cb);
-  auto handle_query_error(const core::operations::query_response& resp) -> std::exception_ptr;
+  auto handle_query_error(const core::operations::query_response& resp) const -> std::exception_ptr;
   void wrap_query(const std::string& statement,
                   const couchbase::transactions::transaction_query_options& opts,
                   std::vector<core::json_string> params,
                   const tao::json::value& txdata,
                   const std::string& hook_point,
                   bool check_expiry,
-                  std::optional<std::string> query_context,
+                  const std::optional<std::string>& query_context,
                   std::function<void(std::exception_ptr, core::operations::query_response)>&& cb);
 
-  void handle_err_from_callback(std::exception_ptr e);
+  void handle_err_from_callback(const std::exception_ptr& e);
 
   template<typename Cb, typename T>
   void op_completed_with_callback(Cb&& cb, std::optional<T> t)
@@ -183,14 +184,16 @@ private:
     }
   }
 
-  template<typename ErrorHandler, typename ExceptionType>
+  template<typename ErrorHandler,
+           typename ExceptionType,
+           typename std::enable_if_t<!std::is_same_v<ExceptionType, std::exception_ptr>, int> = 0>
   void op_completed_with_error(ErrorHandler&& cb, ExceptionType&& err)
   {
     return op_completed_with_error(std::forward<ErrorHandler>(cb),
                                    std::make_exception_ptr(std::forward<ExceptionType>(err)));
   }
 
-  void op_completed_with_error(VoidCallback cb, std::exception_ptr err);
+  void op_completed_with_error(const VoidCallback& cb, const std::exception_ptr& err);
 
   template<typename Ret>
   void op_completed_with_error(std::function<void(std::exception_ptr, std::optional<Ret>)> cb,
@@ -222,7 +225,7 @@ private:
 
   template<typename Ret>
   void op_completed_with_error_no_cache(
-    std::function<void(std::exception_ptr, std::optional<Ret>)>&& cb,
+    std::function<void(std::exception_ptr, std::optional<Ret>)> cb,
     std::exception_ptr err)
   {
     try {
@@ -232,17 +235,17 @@ private:
     }
   }
 
-  void op_completed_with_error_no_cache(VoidCallback&& cb, std::exception_ptr err)
+  void op_completed_with_error_no_cache(VoidCallback cb, std::exception_ptr err)
   {
     try {
-      cb(std::move(err));
+      cb(err);
     } catch (...) {
       // just eat it.
     }
   }
 
   template<typename Handler>
-  void cache_error_async(Handler cb, std::function<void()> func)
+  void cache_error_async(Handler&& cb, std::function<void()> func)
   {
     try {
       op_list_.increment_ops();
@@ -268,27 +271,27 @@ private:
         default:
           err.cause(UNKNOWN);
       }
-      op_completed_with_error_no_cache(std::move(cb), std::make_exception_ptr(err));
+      op_completed_with_error_no_cache(std::forward<Handler>(cb), std::make_exception_ptr(err));
     } catch (const transaction_operation_failed& e) {
       // thrown only from call_func when previous error exists, so eat it,
       // unless it has PREVIOUS_OP_FAILED or FEATURE_NOT_AVAILABLE_EXCEPTION
       // cause
       if (e.cause() == PREVIOUS_OPERATION_FAILED || e.cause() == FEATURE_NOT_AVAILABLE_EXCEPTION) {
-        op_completed_with_error(std::move(cb), e);
+        op_completed_with_error(cb, e);
       }
     } catch (const op_exception& e) {
-      op_completed_with_error(std::move(cb), e);
+      op_completed_with_error(cb, e);
     } catch (const std::exception& e) {
-      op_completed_with_error(std::move(cb), transaction_operation_failed(FAIL_OTHER, e.what()));
+      op_completed_with_error(cb, transaction_operation_failed(FAIL_OTHER, e.what()));
     }
   }
 
   [[nodiscard]] auto cluster_ref() const -> const core::cluster&;
 
-  explicit attempt_context_impl(std::shared_ptr<transaction_context> transaction_ctx);
+  explicit attempt_context_impl(const std::shared_ptr<transaction_context>& transaction_ctx);
 
 public:
-  static auto create(std::shared_ptr<transaction_context> transaction_ctx)
+  static auto create(const std::shared_ptr<transaction_context>& transaction_ctx)
     -> std::shared_ptr<attempt_context_impl>;
 
   ~attempt_context_impl() override;
@@ -359,55 +362,25 @@ public:
 
   void existing_error(bool prev_op_failed = true);
 
-  [[nodiscard]] auto is_done() const -> bool
-  {
-    return is_done_;
-  }
+  [[nodiscard]] auto is_done() const -> bool;
 
-  [[nodiscard]] auto overall() -> std::shared_ptr<transaction_context>
-  {
-    return overall_;
-  }
+  [[nodiscard]] auto overall() const -> std::shared_ptr<transaction_context>;
 
-  [[nodiscard]] auto transaction_id() const -> const std::string&
-  {
-    return overall_->transaction_id();
-  }
+  [[nodiscard]] auto transaction_id() const -> const std::string&;
 
-  [[nodiscard]] auto id() const -> const std::string&
-  {
-    return overall_->current_attempt().id;
-  }
+  [[nodiscard]] auto id() const -> const std::string&;
 
-  [[nodiscard]] auto state() -> attempt_state
-  {
-    return overall_->current_attempt().state;
-  }
+  [[nodiscard]] auto state() const -> attempt_state;
 
-  void state(attempt_state s)
-  {
-    overall_->current_attempt_state(s);
-  }
+  void state(attempt_state s) const;
 
-  [[nodiscard]] auto atr_id() const -> const std::string&
-  {
-    return overall_->atr_id();
-  }
+  [[nodiscard]] auto atr_id() const -> const std::string&;
 
-  void atr_id(const std::string& atr_id)
-  {
-    overall_->atr_id(atr_id);
-  }
+  void atr_id(const std::string& atr_id) const;
 
-  [[nodiscard]] auto atr_collection() const -> const std::string&
-  {
-    return overall_->atr_collection();
-  }
+  [[nodiscard]] auto atr_collection() const -> const std::string&;
 
-  void atr_collection_name(const std::string& coll)
-  {
-    overall_->atr_collection(coll);
-  }
+  void atr_collection_name(const std::string& coll) const;
 
   auto has_expired_client_side(std::string place, std::optional<const std::string> doc_id) -> bool;
 

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

@@ -21,6 +21,8 @@ namespace couchbase::core::transactions
 {
 namespace
 {
+// TODO(CXXCBC-549)
+// NOLINTBEGIN(performance-unnecessary-value-param)
 inline void
 noop1(std::shared_ptr<attempt_context> /* ctx */,
       utils::movable_function<void(std::optional<error_class>)>&& handler)
@@ -49,6 +51,7 @@ noop4(std::shared_ptr<attempt_context> /* ctx */,
 {
   return false;
 }
+// NOLINTEND(performance-unnecessary-value-param)
 } // namespace
 
 attempt_context_testing_hooks::attempt_context_testing_hooks()

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

@@ -21,6 +21,6 @@ namespace couchbase::core::transactions
 auto
 to_string(const std::vector<std::byte>& input) -> std::string
 {
-  return std::string(reinterpret_cast<const char*>(input.data()), input.size());
+  return { reinterpret_cast<const char*>(input.data()), input.size() };
 }
 } // namespace couchbase::core::transactions

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

@@ -21,7 +21,8 @@ namespace couchbase::core::transactions
 namespace
 {
 inline void
-noop1(const std::string&, utils::movable_function<void(std::optional<error_class>)>&& handler)
+noop1(const std::string& /*unused*/,
+      utils::movable_function<void(std::optional<error_class>)>&& handler)
 {
   return handler({});
 }

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

@@ -98,9 +98,9 @@ public:
   }
 
 private:
-  const std::optional<std::string> cas_;
-  const std::optional<std::string> revid_;
-  const std::optional<std::uint32_t> exptime_;
-  const std::optional<std::string> crc32_;
+  std::optional<std::string> cas_;
+  std::optional<std::string> revid_;
+  std::optional<std::uint32_t> exptime_;
+  std::optional<std::string> crc32_;
 };
 } // namespace couchbase::core::transactions

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

@@ -50,7 +50,7 @@ error_class_from_external_exception(external_exception e)
 auto
 error_class_from_result(const result& res) -> error_class
 {
-  subdoc_result::status_type subdoc_status = res.subdoc_status();
+  const subdoc_result::status_type subdoc_status = res.subdoc_status();
   assert(res.ec ||
          (!res.ignore_subdoc_errors && subdoc_status != subdoc_result::status_type::success));
   if (res.ec || res.ignore_subdoc_errors) {
@@ -83,17 +83,16 @@ error_class_from_result(const result& res) -> error_class
       return FAIL_PATH_ALREADY_EXISTS;
     }
     return FAIL_OTHER;
-  } else {
-    // TODO this section is likely redundant from TXNCXX-230, but leaving it here to be compatible
-    // with older C++ clients.  It can be removed later.
-    if (subdoc_status == subdoc_result::status_type::subdoc_path_not_found) {
-      return FAIL_PATH_NOT_FOUND;
-    } else if (subdoc_status == subdoc_result::status_type::subdoc_path_exists) {
-      return FAIL_PATH_ALREADY_EXISTS;
-    } else {
-      return FAIL_OTHER;
-    }
   }
+  // TODO(TXNCXX-230): this section is likely redundant, but leaving it here to be compatible with
+  // older C++ clients.  It can be removed later.
+  if (subdoc_status == subdoc_result::status_type::subdoc_path_not_found) {
+    return FAIL_PATH_NOT_FOUND;
+  }
+  if (subdoc_status == subdoc_result::status_type::subdoc_path_exists) {
+    return FAIL_PATH_ALREADY_EXISTS;
+  }
+  return FAIL_OTHER;
 }
 
 transaction_exception::transaction_exception(const std::runtime_error& cause,
@@ -105,7 +104,7 @@ transaction_exception::transaction_exception(const std::runtime_error& cause,
   , type_(type)
   , txn_id_(context.transaction_id())
 {
-  auto txn_op = dynamic_cast<const transaction_operation_failed*>(&cause);
+  const auto* txn_op = dynamic_cast<const transaction_operation_failed*>(&cause);
   if (nullptr != txn_op) {
     cause_ = txn_op->cause();
   }

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

@@ -23,6 +23,7 @@
 
 #include <chrono>
 #include <thread>
+#include <utility>
 #include <vector>
 
 namespace couchbase::core::transactions
@@ -38,9 +39,9 @@ struct forward_compat_behavior_full {
   {
   }
 
-  forward_compat_behavior_full(const tao::json::value& j)
+  explicit forward_compat_behavior_full(const tao::json::value& j)
   {
-    std::string b = j.at("b").get_string();
+    const std::string b = j.at("b").get_string();
     behavior = create_forward_compat_behavior(b);
     if (const auto* ra = j.find("ra"); ra != nullptr) {
       retry_delay = std::chrono::milliseconds(ra->get_unsigned());
@@ -48,7 +49,7 @@ struct forward_compat_behavior_full {
   }
 
   template<typename OStream>
-  friend OStream& operator<<(OStream& os, const forward_compat_behavior_full& b)
+  friend auto operator<<(OStream& os, const forward_compat_behavior_full& b) -> OStream&
   {
     os << "forward_compat_behavior_full:{";
     os << "behavior: " << forward_compat_behavior_name(b.behavior);
@@ -56,35 +57,43 @@ struct forward_compat_behavior_full {
       os << ", retry_delay: " << b.retry_delay->count() << " ms";
     }
     os << "}";
+    return os;
   }
 };
 
 struct forward_compat_requirement {
   forward_compat_behavior_full behavior;
 
-  forward_compat_requirement(forward_compat_behavior_full b)
+  explicit forward_compat_requirement(forward_compat_behavior_full b)
     : behavior(b)
   {
   }
 
-  virtual forward_compat_behavior_full check(forward_compat_supported supported) = 0;
+  forward_compat_requirement(const forward_compat_requirement&) = default;
+  forward_compat_requirement(forward_compat_requirement&&) = default;
+  auto operator=(const forward_compat_requirement&) -> forward_compat_requirement& = default;
+  auto operator=(forward_compat_requirement&&) -> forward_compat_requirement& = default;
+
+  [[nodiscard]] virtual auto check(const forward_compat_supported& supported) const
+    -> forward_compat_behavior_full = 0;
   virtual ~forward_compat_requirement() = default;
 };
 
 struct forward_compat_protocol_requirement : public forward_compat_requirement {
-  uint32_t min_protocol_major;
-  uint32_t min_protocol_minor;
+  std::uint64_t min_protocol_major;
+  std::uint64_t min_protocol_minor;
 
   forward_compat_protocol_requirement(forward_compat_behavior_full b,
-                                      uint32_t min_major,
-                                      uint32_t min_minor)
+                                      unsigned long min_major,
+                                      unsigned long min_minor)
     : forward_compat_requirement(b)
     , min_protocol_major(min_major)
     , min_protocol_minor(min_minor)
   {
   }
 
-  virtual forward_compat_behavior_full check(forward_compat_supported supported)
+  [[nodiscard]] auto check(const forward_compat_supported& supported) const
+    -> forward_compat_behavior_full override
   {
     if ((min_protocol_major > supported.protocol_major) ||
         (min_protocol_minor > supported.protocol_minor)) {
@@ -97,13 +106,14 @@ struct forward_compat_protocol_requirement : public forward_compat_requirement {
 struct forward_compat_extension_requirement : public forward_compat_requirement {
   std::string extension_id;
 
-  forward_compat_extension_requirement(forward_compat_behavior_full b, const std::string ext)
+  forward_compat_extension_requirement(forward_compat_behavior_full b, std::string ext)
     : forward_compat_requirement(b)
-    , extension_id(ext)
+    , extension_id(std::move(ext))
   {
   }
 
-  virtual forward_compat_behavior_full check(forward_compat_supported supported)
+  [[nodiscard]] auto check(const forward_compat_supported& supported) const
+    -> forward_compat_behavior_full override
   {
     auto it = std::find(supported.extensions.begin(), supported.extensions.end(), extension_id);
     if (it == supported.extensions.end()) {
@@ -113,8 +123,8 @@ struct forward_compat_extension_requirement : public forward_compat_requirement
   }
 };
 
-forward_compat_stage
-create_forward_compat_stage(const std::string& str)
+auto
+create_forward_compat_stage(const std::string& str) -> forward_compat_stage
 {
   if (str == "WW_R") {
     return forward_compat_stage::WWC_READING_ATR;
@@ -146,7 +156,7 @@ create_forward_compat_stage(const std::string& str)
 class forward_compat
 {
 public:
-  forward_compat(tao::json::value& json)
+  explicit forward_compat(tao::json::value& json)
     : json_(json)
   {
     CB_TXN_LOG_TRACE("creating forward_compat from {}", core::utils::json::generate(json_));
@@ -155,26 +165,25 @@ public:
       auto stage = create_forward_compat_stage(key);
       // the value is an array of forward_compat_behavior_full objects
       for (const auto& item : value.get_array()) {
-        forward_compat_behavior_full behavior(item);
+        const forward_compat_behavior_full behavior(item);
         if (const auto* b = item.find("b"); b != nullptr) {
           if (const auto* e = item.find("e")) {
-            std::string ext = e->get_string();
-            compat_map_[stage].push_back(new forward_compat_extension_requirement(behavior, ext));
+            const std::string ext = e->get_string();
+            compat_map_[stage].push_back(
+              std::make_unique<forward_compat_extension_requirement>(behavior, ext));
           } else if (const auto* p = item.find("p")) {
-            std::string proto_string = p->get_string();
+            const std::string proto_string = p->get_string();
             auto proto = core::utils::split_string(proto_string, '.');
-            compat_map_[stage].push_back(new forward_compat_protocol_requirement(
-              behavior,
-              static_cast<std::uint32_t>(std::stoi(proto[0])),
-              static_cast<std::uint32_t>(std::stoi(proto[1]))));
+            compat_map_[stage].push_back(std::make_unique<forward_compat_protocol_requirement>(
+              behavior, std::stoul(proto[0]), std::stoul(proto[1])));
           }
         }
       }
     }
   }
 
-  std::optional<transaction_operation_failed> check_internal(forward_compat_stage stage,
-                                                             forward_compat_supported supported)
+  auto check_internal(forward_compat_stage stage, const forward_compat_supported& supported)
+    -> std::optional<transaction_operation_failed>
   {
     if (auto it = compat_map_.find(stage); it != compat_map_.end()) {
       transaction_operation_failed ex(FAIL_OTHER, "Forward Compatibililty failure");
@@ -202,15 +211,17 @@ public:
   }
 
 private:
-  std::map<forward_compat_stage, std::list<forward_compat_requirement*>> compat_map_;
+  std::map<forward_compat_stage, std::list<std::unique_ptr<forward_compat_requirement>>>
+    compat_map_;
   tao::json::value json_;
 };
 
-std::optional<transaction_operation_failed>
+auto
 check_forward_compat(forward_compat_stage stage, std::optional<tao::json::value> json)
+  -> std::optional<transaction_operation_failed>
 {
   if (json) {
-    forward_compat_supported supported;
+    const forward_compat_supported supported;
     forward_compat fc(json.value());
     return fc.check_internal(stage, supported);
   }

data/ext/couchbase/core/transactions/internal/atr_cleanup_entry.hxx

@@ -76,39 +76,39 @@ private:
   void remove_docs_staged_for_removal(std::optional<std::vector<doc_record>> docs,
                                       durability_level dl);
   void remove_txn_links(std::optional<std::vector<doc_record>> docs, durability_level dl);
-  void do_per_doc(std::vector<doc_record> docs,
+  void do_per_doc(const std::vector<doc_record>& docs,
                   bool require_crc_to_match,
                   const std::function<void(transaction_get_result&, bool)>& call);
 
 public:
-  explicit atr_cleanup_entry(std::shared_ptr<attempt_context> ctx);
+  explicit atr_cleanup_entry(const std::shared_ptr<attempt_context>& ctx);
   explicit atr_cleanup_entry(const atr_entry& entry,
-                             const core::document_id& atr_coll,
+                             core::document_id atr_id,
                              const transactions_cleanup& cleanup,
                              bool check_if_expired = true);
 
-  explicit atr_cleanup_entry(const core::document_id& atr_id,
-                             const std::string& attempt_id,
+  explicit atr_cleanup_entry(core::document_id atr_id,
+                             std::string attempt_id,
                              const transactions_cleanup& cleanup);
 
   void clean(transactions_cleanup_attempt* result = nullptr);
-  bool ready() const;
-  couchbase::core::document_id atr_id() const
+  [[nodiscard]] auto ready() const -> bool;
+  [[nodiscard]] auto atr_id() const -> couchbase::core::document_id
   {
     return atr_id_;
   }
 
-  std::string attempt_id() const
+  [[nodiscard]] auto attempt_id() const -> std::string
   {
     return attempt_id_;
   }
 
-  bool check_if_expired() const
+  [[nodiscard]] auto check_if_expired() const -> bool
   {
     return check_if_expired_;
   }
 
-  std::chrono::time_point<std::chrono::steady_clock> min_start_time() const
+  [[nodiscard]] auto min_start_time() const -> std::chrono::time_point<std::chrono::steady_clock>
   {
     return min_start_time_;
   };
@@ -127,6 +127,7 @@ public:
     os << "}";
     return os;
   }
+
   void min_start_time(std::chrono::time_point<std::chrono::steady_clock> new_time)
   {
     min_start_time_ = new_time;
@@ -144,7 +145,7 @@ private:
 public:
   // pop, but only if the front entry's min_start_time_ is before now
   std::optional<atr_cleanup_entry> pop(bool check_time = true);
-  void push(std::shared_ptr<attempt_context> ctx);
+  void push(const std::shared_ptr<attempt_context>& ctx);
   std::size_t size() const;
 };
 

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

@@ -20,13 +20,13 @@
 
 namespace couchbase::core::transactions
 {
-doc_record
-doc_record::create_from(const tao::json::value& obj)
+auto
+doc_record::create_from(const tao::json::value& obj) -> doc_record
 {
-  std::string bucket_name = obj.at(ATR_FIELD_PER_DOC_BUCKET).get_string();
-  std::string scope_name = obj.at(ATR_FIELD_PER_DOC_SCOPE).get_string();
-  std::string collection_name = obj.at(ATR_FIELD_PER_DOC_COLLECTION).get_string();
-  std::string id = obj.at(ATR_FIELD_PER_DOC_ID).get_string();
-  return doc_record(bucket_name, scope_name, collection_name, id);
+  const std::string bucket_name = obj.at(ATR_FIELD_PER_DOC_BUCKET).get_string();
+  const std::string scope_name = obj.at(ATR_FIELD_PER_DOC_SCOPE).get_string();
+  const std::string collection_name = obj.at(ATR_FIELD_PER_DOC_COLLECTION).get_string();
+  const std::string id = obj.at(ATR_FIELD_PER_DOC_ID).get_string();
+  return { bucket_name, scope_name, collection_name, id };
 }
 } // namespace couchbase::core::transactions