couchbase 4.2.11 → 4.3.0

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

@@ -15,79 +15,80 @@
  */
 
 #include "attempt_context_testing_hooks.hxx"
+#include "core/utils/movable_function.hxx"
 
 namespace couchbase::core::transactions
 {
 namespace
 {
-inline std::optional<error_class>
-noop_1(attempt_context*)
+inline void
+noop1(attempt_context*, utils::movable_function<void(std::optional<error_class>)>&& handler)
 {
-    return {};
+    return handler({});
 }
 
-inline std::optional<error_class>
-noop_2(attempt_context*, const std::string&)
+inline void
+noop2(attempt_context*, const std::string&, utils::movable_function<void(std::optional<error_class>)>&& handler)
 {
-    return {};
+    return handler({});
 }
 
 inline std::optional<const std::string>
-noop_3(attempt_context*)
+noop3(attempt_context*)
 {
     return {};
 }
 
 inline bool
-noop_4(attempt_context*, const std::string&, std::optional<const std::string>)
+noop4(attempt_context*, const std::string&, std::optional<const std::string>)
 {
     return false;
 }
 } // namespace
 
 attempt_context_testing_hooks::attempt_context_testing_hooks()
-  : before_atr_commit{ noop_1 }
-  , before_atr_commit_ambiguity_resolution{ noop_1 }
-  , after_atr_commit{ noop_1 }
-  , before_doc_committed{ noop_2 }
-  , before_removing_doc_during_staged_insert{ noop_2 }
-  , before_rollback_delete_inserted{ noop_2 }
-  , after_doc_committed_before_saving_cas{ noop_2 }
-  , after_doc_committed{ noop_2 }
-  , before_staged_insert{ noop_2 }
-  , before_staged_remove{ noop_2 }
-  , before_staged_replace{ noop_2 }
-  , before_doc_removed{ noop_2 }
-  , before_doc_rolled_back{ noop_2 }
-  , after_doc_removed_pre_retry{ noop_2 }
-  , after_doc_removed_post_retry{ noop_2 }
-  , after_get_complete{ noop_2 }
-  , after_staged_replace_complete_before_cas_saved{ noop_2 }
-  , after_staged_replace_complete{ noop_2 }
-  , after_staged_remove_complete{ noop_2 }
-  , after_staged_insert_complete{ noop_2 }
-  , after_rollback_replace_or_remove{ noop_2 }
-  , after_rollback_delete_inserted{ noop_2 }
-  , before_check_atr_entry_for_blocking_doc{ noop_2 }
-  , before_doc_get{ noop_2 }
-  , before_get_doc_in_exists_during_staged_insert{ noop_2 }
-  , before_query{ noop_2 }
-  , after_query{ noop_2 }
-  , before_remove_staged_insert{ noop_2 }
-  , after_remove_staged_insert{ noop_2 }
-  , after_docs_committed{ noop_1 }
-  , after_docs_removed{ noop_1 }
-  , after_atr_pending{ noop_1 }
-  , before_atr_pending{ noop_1 }
-  , before_atr_complete{ noop_1 }
-  , before_atr_rolled_back{ noop_1 }
-  , after_atr_complete{ noop_1 }
-  , before_get_atr_for_abort{ noop_1 }
-  , before_atr_aborted{ noop_1 }
-  , after_atr_aborted{ noop_1 }
-  , after_atr_rolled_back{ noop_1 }
-  , random_atr_id_for_vbucket{ noop_3 }
-  , has_expired_client_side{ noop_4 }
+  : before_atr_commit{ noop1 }
+  , before_atr_commit_ambiguity_resolution{ noop1 }
+  , after_atr_commit{ noop1 }
+  , before_doc_committed{ noop2 }
+  , before_removing_doc_during_staged_insert{ noop2 }
+  , before_rollback_delete_inserted{ noop2 }
+  , after_doc_committed_before_saving_cas{ noop2 }
+  , after_doc_committed{ noop2 }
+  , before_staged_insert{ noop2 }
+  , before_staged_remove{ noop2 }
+  , before_staged_replace{ noop2 }
+  , before_doc_removed{ noop2 }
+  , before_doc_rolled_back{ noop2 }
+  , after_doc_removed_pre_retry{ noop2 }
+  , after_doc_removed_post_retry{ noop2 }
+  , after_get_complete{ noop2 }
+  , after_staged_replace_complete_before_cas_saved{ noop2 }
+  , after_staged_replace_complete{ noop2 }
+  , after_staged_remove_complete{ noop2 }
+  , after_staged_insert_complete{ noop2 }
+  , after_rollback_replace_or_remove{ noop2 }
+  , after_rollback_delete_inserted{ noop2 }
+  , before_check_atr_entry_for_blocking_doc{ noop2 }
+  , before_doc_get{ noop2 }
+  , before_get_doc_in_exists_during_staged_insert{ noop2 }
+  , before_query{ noop2 }
+  , after_query{ noop2 }
+  , before_remove_staged_insert{ noop2 }
+  , after_remove_staged_insert{ noop2 }
+  , after_docs_committed{ noop1 }
+  , after_docs_removed{ noop1 }
+  , after_atr_pending{ noop1 }
+  , before_atr_pending{ noop1 }
+  , before_atr_complete{ noop1 }
+  , before_atr_rolled_back{ noop1 }
+  , after_atr_complete{ noop1 }
+  , before_get_atr_for_abort{ noop1 }
+  , before_atr_aborted{ noop1 }
+  , after_atr_aborted{ noop1 }
+  , after_atr_rolled_back{ noop1 }
+  , random_atr_id_for_vbucket{ noop3 }
+  , has_expired_client_side{ noop4 }
 {
 }
 } // namespace couchbase::core::transactions

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

@@ -16,6 +16,7 @@
 #pragma once
 
 #include "core/transactions/error_class.hxx"
+#include "core/utils/movable_function.hxx"
 
 #include <functional>
 #include <optional>
@@ -25,8 +26,9 @@ namespace couchbase::core::transactions
 {
 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&)>;
+using error_func1 = std::function<void(attempt_context*, core::utils::movable_function<void(std::optional<error_class>)>&&)>;
+using error_func2 =
+  std::function<void(attempt_context*, const std::string&, core::utils::movable_function<void(std::optional<error_class>)>&&)>;
 
 static const std::string STAGE_ROLLBACK = "rollback";
 static const std::string STAGE_GET = "get";

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

@@ -20,16 +20,16 @@ namespace couchbase::core::transactions
 {
 namespace
 {
-inline std::optional<couchbase::core::transactions::error_class>
-noop1(const std::string&)
+inline void
+noop1(const std::string&, utils::movable_function<void(std::optional<error_class>)>&& handler)
 {
-    return {};
+    return handler({});
 }
 
-inline std::optional<couchbase::core::transactions::error_class>
-noop2()
+inline void
+noop2(utils::movable_function<void(std::optional<error_class>)>&& handler)
 {
-    return {};
+    return handler({});
 }
 } // namespace
 

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

@@ -16,6 +16,7 @@
 #pragma once
 
 #include "core/transactions/error_class.hxx"
+#include "core/utils/movable_function.hxx"
 
 #include <functional>
 #include <optional>
@@ -23,8 +24,8 @@
 
 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)>;
+using error_func3 = std::function<void(const std::string&, core::utils::movable_function<void(std::optional<error_class>)>&&)>;
+using error_func4 = std::function<void(core::utils::movable_function<void(std::optional<error_class>)>&&)>;
 
 /**
  * Hooks purely for testing purposes.  If you're an end-user looking at these for any reason, then please contact us first

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

@@ -127,6 +127,8 @@ class transactions_cleanup
     const atr_cleanup_stats force_cleanup_atr(const core::document_id& atr_id, std::vector<transactions_cleanup_attempt>& results);
     const client_record_details get_active_clients(const couchbase::transactions::transaction_keyspace& keyspace, const std::string& uuid);
     void remove_client_record_from_all_buckets(const std::string& uuid);
+    void start();
+    void stop();
     void close();
 
   private:

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

@@ -26,6 +26,7 @@
 #include <functional>
 #include <future>
 #include <limits>
+#include <optional>
 #include <random>
 #include <string>
 #include <thread>
@@ -79,6 +80,9 @@ validate_operation_result(result& res, bool ignore_subdoc_errors = true);
 result
 wrap_operation_future(std::future<result>& fut, bool ignore_subdoc_errors = true);
 
+std::optional<error_class>
+wait_for_hook(std::function<void(utils::movable_function<void(std::optional<error_class>)>)> hook);
+
 inline void
 wrap_collection_call(result& res, std::function<void(result&)> call);
 
@@ -326,7 +330,7 @@ struct async_exp_delay {
 
     void operator()(utils::movable_function<void(std::exception_ptr)> callback) const
     {
-        if (retries >= max_retries) {
+        if (retries++ >= max_retries) {
             callback(std::make_exception_ptr(retry_operation_retries_exhausted("retries exhausted")));
             return;
         }