couchbase 3.4.1 → 3.4.3

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

@@ -28,33 +28,6 @@ class attempt_context;
 using error_func1 = std::function<std::optional<error_class>(attempt_context*)>;
 using error_func2 = std::function<std::optional<error_class>(attempt_context*, const std::string&)>;
 
-namespace
-{
-std::optional<error_class>
-noop_1(attempt_context*)
-{
-    return {};
-}
-
-std::optional<error_class>
-noop_2(attempt_context*, const std::string&)
-{
-    return {};
-}
-
-std::optional<const std::string>
-noop_3(attempt_context*)
-{
-    return {};
-}
-
-bool
-noop_4(attempt_context*, const std::string&, std::optional<const std::string>)
-{
-    return false;
-}
-} // namespace
-
 static const std::string STAGE_ROLLBACK = "rollback";
 static const std::string STAGE_GET = "get";
 static const std::string STAGE_INSERT = "insert";
@@ -91,55 +64,55 @@ static const std::string STAGE_QUERY_KV_INSERT = "queryKvInsert";
  * about your use-case: we are always open to adding good ideas into the transactions library.
  */
 struct attempt_context_testing_hooks {
-    error_func1 before_atr_commit = noop_1;
-    error_func1 before_atr_commit_ambiguity_resolution = noop_1;
-    error_func1 after_atr_commit = noop_1;
-    error_func2 before_doc_committed = noop_2;
-    error_func2 before_removing_doc_during_staged_insert = noop_2;
-    error_func2 before_rollback_delete_inserted = noop_2;
-    error_func2 after_doc_committed_before_saving_cas = noop_2;
-    error_func2 after_doc_committed = noop_2;
-    error_func2 before_staged_insert = noop_2;
-    error_func2 before_staged_remove = noop_2;
-    error_func2 before_staged_replace = noop_2;
-    error_func2 before_doc_removed = noop_2;
-    error_func2 before_doc_rolled_back = noop_2;
-    error_func2 after_doc_removed_pre_retry = noop_2;
-    error_func2 after_doc_removed_post_retry = noop_2;
-    error_func2 after_get_complete = noop_2;
-    error_func2 after_staged_replace_complete_before_cas_saved = noop_2;
-    error_func2 after_staged_replace_complete = noop_2;
-    error_func2 after_staged_remove_complete = noop_2;
-    error_func2 after_staged_insert_complete = noop_2;
-    error_func2 after_rollback_replace_or_remove = noop_2;
-    error_func2 after_rollback_delete_inserted = noop_2;
-    error_func2 before_check_atr_entry_for_blocking_doc = noop_2;
-    error_func2 before_doc_get = noop_2;
-    error_func2 before_get_doc_in_exists_during_staged_insert = noop_2;
-    error_func2 before_query = noop_2;
-    error_func2 after_query = noop_2;
-    error_func2 before_remove_staged_insert = noop_2;
-    error_func2 after_remove_staged_insert = noop_2;
-
-    error_func1 after_docs_committed = noop_1;
-    error_func1 after_docs_removed = noop_1;
-    error_func1 after_atr_pending = noop_1;
-    error_func1 before_atr_pending = noop_1;
-    error_func1 before_atr_complete = noop_1;
-    error_func1 before_atr_rolled_back = noop_1;
-    error_func1 after_atr_complete = noop_1;
-    error_func1 before_get_atr_for_abort = noop_1;
-    error_func1 before_atr_aborted = noop_1;
-    error_func1 after_atr_aborted = noop_1;
-    error_func1 after_atr_rolled_back = noop_1;
-
-    std::function<std::optional<const std::string>(attempt_context*)> random_atr_id_for_vbucket = noop_3;
-
-    std::function<bool(attempt_context*, const std::string&, std::optional<const std::string>)> has_expired_client_side = noop_4;
+    error_func1 before_atr_commit;
+    error_func1 before_atr_commit_ambiguity_resolution;
+    error_func1 after_atr_commit;
+    error_func2 before_doc_committed;
+    error_func2 before_removing_doc_during_staged_insert;
+    error_func2 before_rollback_delete_inserted;
+    error_func2 after_doc_committed_before_saving_cas;
+    error_func2 after_doc_committed;
+    error_func2 before_staged_insert;
+    error_func2 before_staged_remove;
+    error_func2 before_staged_replace;
+    error_func2 before_doc_removed;
+    error_func2 before_doc_rolled_back;
+    error_func2 after_doc_removed_pre_retry;
+    error_func2 after_doc_removed_post_retry;
+    error_func2 after_get_complete;
+    error_func2 after_staged_replace_complete_before_cas_saved;
+    error_func2 after_staged_replace_complete;
+    error_func2 after_staged_remove_complete;
+    error_func2 after_staged_insert_complete;
+    error_func2 after_rollback_replace_or_remove;
+    error_func2 after_rollback_delete_inserted;
+    error_func2 before_check_atr_entry_for_blocking_doc;
+    error_func2 before_doc_get;
+    error_func2 before_get_doc_in_exists_during_staged_insert;
+    error_func2 before_query;
+    error_func2 after_query;
+    error_func2 before_remove_staged_insert;
+    error_func2 after_remove_staged_insert;
+
+    error_func1 after_docs_committed;
+    error_func1 after_docs_removed;
+    error_func1 after_atr_pending;
+    error_func1 before_atr_pending;
+    error_func1 before_atr_complete;
+    error_func1 before_atr_rolled_back;
+    error_func1 after_atr_complete;
+    error_func1 before_get_atr_for_abort;
+    error_func1 before_atr_aborted;
+    error_func1 after_atr_aborted;
+    error_func1 after_atr_rolled_back;
+
+    std::function<std::optional<const std::string>(attempt_context*)> random_atr_id_for_vbucket;
+
+    std::function<bool(attempt_context*, const std::string&, std::optional<const std::string>)> has_expired_client_side;
+
+    attempt_context_testing_hooks();
 
     // needed for unique_ptr<attempt_context_testing_hooks> in transaction_config, with a forward declaration.
-    ~attempt_context_testing_hooks()
-    {
-    }
+    ~attempt_context_testing_hooks() = default;
 };
 } // namespace couchbase::core::transactions

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

@@ -0,0 +1,52 @@
+/*
+ *     Copyright 2021-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 "cleanup_testing_hooks.hxx"
+
+namespace couchbase::core::transactions
+{
+namespace
+{
+inline std::optional<couchbase::core::transactions::error_class>
+noop1(const std::string&)
+{
+    return {};
+}
+
+inline std::optional<couchbase::core::transactions::error_class>
+noop2()
+{
+    return {};
+}
+} // namespace
+
+cleanup_testing_hooks::cleanup_testing_hooks()
+  : before_commit_doc{ noop1 }
+  , before_doc_get{ noop1 }
+  , before_remove_doc_staged_for_removal{ noop1 }
+  , before_remove_doc{ noop1 }
+  , before_atr_get{ noop1 }
+  , before_remove_links{ noop1 }
+  , before_atr_remove{ noop2 }
+  , on_cleanup_docs_completed{ noop2 }
+  , on_cleanup_completed{ noop2 }
+  , client_record_before_create{ noop1 }
+  , client_record_before_get{ noop1 }
+  , client_record_before_update{ noop1 }
+  , client_record_before_remove_client{ noop1 }
+{
+}
+} // namespace couchbase::core::transactions

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

@@ -18,52 +18,38 @@
 #include "core/transactions/error_class.hxx"
 
 #include <functional>
+#include <optional>
 #include <string>
 
 namespace couchbase::core::transactions
 {
 using error_func3 = std::function<std::optional<error_class>(const std::string&)>;
 using error_func4 = std::function<std::optional<error_class>(void)>;
-namespace
-{
-std::optional<couchbase::core::transactions::error_class>
-noop1(const std::string&)
-{
-    return {};
-}
-std::optional<couchbase::core::transactions::error_class>
-noop2()
-{
-    return {};
-}
-
-} // namespace
 
 /**
  * Hooks purely for testing purposes.  If you're an end-user looking at these for any reason, then please contact us first
  * about your use-case: we are always open to adding good ideas into the transactions library.
  */
 struct cleanup_testing_hooks {
-    error_func3 before_commit_doc = noop1;
-    error_func3 before_doc_get = noop1;
-    error_func3 before_remove_doc_staged_for_removal = noop1;
-    error_func3 before_remove_doc = noop1;
-    error_func3 before_atr_get = noop1;
-    error_func3 before_remove_links = noop1;
+    error_func3 before_commit_doc;
+    error_func3 before_doc_get;
+    error_func3 before_remove_doc_staged_for_removal;
+    error_func3 before_remove_doc;
+    error_func3 before_atr_get;
+    error_func3 before_remove_links;
 
-    error_func4 before_atr_remove = noop2;
+    error_func4 before_atr_remove;
 
-    error_func4 on_cleanup_docs_completed = noop2;
-    error_func4 on_cleanup_completed = noop2;
+    error_func4 on_cleanup_docs_completed;
+    error_func4 on_cleanup_completed;
 
-    error_func3 client_record_before_create = noop1;
-    error_func3 client_record_before_get = noop1;
-    error_func3 client_record_before_update = noop1;
-    error_func3 client_record_before_remove_client = noop1;
+    error_func3 client_record_before_create;
+    error_func3 client_record_before_get;
+    error_func3 client_record_before_update;
+    error_func3 client_record_before_remove_client;
 
+    cleanup_testing_hooks();
     // needed for unique_ptr<cleanup_testing_hooks> in transaction_config, with a forward declaration.
-    ~cleanup_testing_hooks()
-    {
-    }
+    ~cleanup_testing_hooks() = default;
 };
-} // namespace couchbase::core::transactions
+} // namespace couchbase::core::transactions

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

@@ -16,11 +16,14 @@
 
 #pragma once
 
-#include <core/error_context/query.hxx>
+#include "core/error_context/query.hxx"
+#include "error_class.hxx"
+
 #include <couchbase/error_codes.hxx>
 #include <couchbase/transactions/transaction_result.hxx>
-#include <optional>
+
 #include <stdexcept>
+#include <utility>
 
 namespace couchbase::core::transactions
 {
@@ -135,7 +138,7 @@ class op_exception : public std::runtime_error
     transaction_op_error_context ctx_;
 
   public:
-    op_exception(transaction_op_error_context ctx, external_exception cause = COUCHBASE_EXCEPTION)
+    explicit op_exception(transaction_op_error_context ctx, external_exception cause = COUCHBASE_EXCEPTION)
       : std::runtime_error(ctx.ec().message())
       , cause_(cause)
       , ctx_(std::move(ctx))
@@ -157,7 +160,7 @@ class document_not_found : public op_exception
 {
   public:
     explicit document_not_found(transaction_op_error_context ctx)
-      : op_exception(ctx, DOCUMENT_NOT_FOUND_EXCEPTION)
+      : op_exception(std::move(ctx), DOCUMENT_NOT_FOUND_EXCEPTION)
     {
     }
 };
@@ -166,7 +169,7 @@ class document_exists : public op_exception
 {
   public:
     explicit document_exists(transaction_op_error_context ctx)
-      : op_exception(ctx, DOCUMENT_EXISTS_EXCEPTION)
+      : op_exception(std::move(ctx), DOCUMENT_EXISTS_EXCEPTION)
     {
     }
 };
@@ -175,7 +178,7 @@ class query_attempt_not_found : public op_exception
 {
   public:
     query_attempt_not_found(transaction_op_error_context ctx)
-      : op_exception(ctx)
+      : op_exception(std::move(ctx))
     {
     }
 };
@@ -184,7 +187,7 @@ class query_cas_mismatch : public op_exception
 {
   public:
     query_cas_mismatch(transaction_op_error_context ctx)
-      : op_exception(ctx)
+      : op_exception(std::move(ctx))
     {
     }
 };
@@ -193,7 +196,7 @@ class query_attempt_expired : public op_exception
 {
   public:
     query_attempt_expired(transaction_op_error_context ctx)
-      : op_exception(ctx)
+      : op_exception(std::move(ctx))
     {
     }
 };
@@ -202,7 +205,7 @@ class query_parsing_failure : public op_exception
 {
   public:
     query_parsing_failure(transaction_op_error_context ctx)
-      : op_exception(ctx, PARSING_FAILURE)
+      : op_exception(std::move(ctx), PARSING_FAILURE)
     {
     }
 };

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

@@ -49,30 +49,29 @@ class transaction_context
 
     [[nodiscard]] std::size_t num_attempts() const
     {
+        std::lock_guard<std::mutex> lock(mutex_);
         return attempts_.size();
     }
-    [[nodiscard]] const std::vector<transaction_attempt>& attempts() const
-    {
-        return attempts_;
-    }
-    [[nodiscard]] std::vector<transaction_attempt>& attempts()
-    {
-        return const_cast<std::vector<transaction_attempt>&>(const_cast<const transaction_context*>(this)->attempts());
-    }
     [[nodiscard]] const transaction_attempt& current_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();
     }
-    [[nodiscard]] transaction_attempt& current_attempt()
-    {
-        return const_cast<transaction_attempt&>(const_cast<const transaction_context*>(this)->current_attempt());
-    }
 
     void add_attempt();
 
+    void current_attempt_state(attempt_state s)
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        if (attempts_.empty()) {
+            throw std::runtime_error("transaction_context has no attempts yet");
+        }
+        attempts_.back().state = s;
+    }
+
     [[nodiscard]] std::shared_ptr<core::cluster> cluster_ref()
     {
         return transactions_.cluster_ref();
@@ -191,6 +190,7 @@ class transaction_context
     std::string atr_collection_;
     transactions_cleanup& cleanup_;
     std::shared_ptr<attempt_context_impl> current_attempt_context_;
+    mutable std::mutex mutex_;
 
     std::unique_ptr<exp_delay> delay_;
 };

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

@@ -145,6 +145,12 @@ class transactions_cleanup
 
     void attempts_loop();
 
+    bool is_running()
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        return running_;
+    }
+
     template<class R, class P>
     bool interruptable_wait(std::chrono::duration<R, P> time);
 
@@ -153,7 +159,7 @@ class transactions_cleanup
     void create_client_record(const couchbase::transactions::transaction_keyspace& keyspace);
     const atr_cleanup_stats handle_atr_cleanup(const core::document_id& atr_id,
                                                std::vector<transactions_cleanup_attempt>* result = nullptr);
-    std::atomic<bool> running_{ false };
+    bool running_{ false };
 };
 } // namespace transactions
 } // namespace couchbase::core

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

@@ -45,6 +45,7 @@ void
 transaction_context::add_attempt()
 {
     transaction_attempt attempt{};
+    std::lock_guard<std::mutex> lock(mutex_);
     attempts_.push_back(attempt);
 }