couchbase 3.4.2 → 3.4.4

data/ext/couchbase/core/range_scan_orchestrator.hxx

@@ -18,6 +18,7 @@
 #include "range_scan_options.hxx"
 #include "range_scan_orchestrator_options.hxx"
 #include "scan_result.hxx"
+#include "topology/configuration.hxx"
 
 #include <tl/expected.hpp>
 
@@ -34,15 +35,25 @@ namespace couchbase::core
 class agent;
 class range_scan_orchestrator_impl;
 
+class scan_stream_manager
+{
+  public:
+    virtual ~scan_stream_manager() = default;
+    virtual void stream_start_failed(std::int16_t node_id, bool fatal) = 0;
+    virtual void stream_start_failed_awaiting_retry(std::int16_t node_id, std::uint16_t vbucket_id) = 0;
+    virtual void stream_continue_failed(std::int16_t node_id, bool fatal) = 0;
+    virtual void stream_completed(std::int16_t node_id) = 0;
+};
+
 class range_scan_orchestrator
 {
   public:
     range_scan_orchestrator(asio::io_context& io,
                             agent kv_provider,
-                            std::size_t num_vbuckets,
+                            topology::configuration::vbucket_map vbucket_map,
                             std::string scope_name,
                             std::string collection_name,
-                            std::variant<std::monostate, range_scan, sampling_scan> scan_type,
+                            std::variant<std::monostate, range_scan, prefix_scan, sampling_scan> scan_type,
                             range_scan_orchestrator_options options);
 
     auto scan() -> tl::expected<scan_result, std::error_code>;

data/ext/couchbase/core/range_scan_orchestrator_options.hxx

@@ -16,6 +16,7 @@
 #pragma once
 
 #include "scan_options.hxx"
+#include "timeout_defaults.hxx"
 
 #include <couchbase/mutation_token.hxx>
 #include <couchbase/retry_strategy.hxx>
@@ -40,15 +41,16 @@ namespace couchbase::core
 {
 
 struct range_scan_orchestrator_options {
+    static constexpr std::uint16_t default_concurrency{ 1 };
+
     bool ids_only{ false };
     std::optional<mutation_state> consistent_with{};
-    scan_sort sort{ scan_sort::none };
     std::uint32_t batch_item_limit{ range_scan_continue_options::default_batch_item_limit };
     std::uint32_t batch_byte_limit{ range_scan_continue_options::default_batch_byte_limit };
-    std::chrono::milliseconds batch_time_limit{ range_scan_continue_options::default_batch_time_limit };
+    std::uint16_t concurrency{ default_concurrency };
 
     std::shared_ptr<couchbase::retry_strategy> retry_strategy{ nullptr };
-    std::chrono::milliseconds timeout{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_scan_timeout };
     std::shared_ptr<couchbase::tracing::request_span> parent_span{};
 };
 } // namespace couchbase::core

data/ext/couchbase/core/scan_options.hxx

@@ -38,26 +38,7 @@ class request_span;
 
 namespace couchbase::core
 {
-
-enum class scan_sort {
-    none,
-    ascending,
-};
-
 struct mutation_state {
     std::vector<couchbase::mutation_token> tokens;
 };
-
-struct scan_options {
-    bool ids_only{ false };
-    std::optional<mutation_state> consistent_with{};
-    scan_sort sort{ scan_sort::none };
-    std::uint32_t batch_item_limit{ range_scan_continue_options::default_batch_item_limit };
-    std::uint32_t batch_byte_limit{ range_scan_continue_options::default_batch_byte_limit };
-    std::chrono::milliseconds batch_time_limit{ range_scan_continue_options::default_batch_time_limit };
-
-    std::shared_ptr<couchbase::retry_strategy> retry_strategy{ nullptr };
-    std::chrono::milliseconds timeout{};
-    std::shared_ptr<couchbase::tracing::request_span> parent_span{};
-};
 } // namespace couchbase::core

data/ext/couchbase/core/scan_result.cxx

@@ -32,10 +32,7 @@ class scan_result_impl
 
     [[nodiscard]] auto next() const -> tl::expected<range_scan_item, std::error_code>
     {
-        if (auto item = iterator_->next().get(); item) {
-            return item.value();
-        }
-        return tl::unexpected{ errc::key_value::range_scan_completed };
+        return iterator_->next().get();
     }
 
     void next(utils::movable_function<void(range_scan_item, std::error_code)> callback) const
@@ -43,6 +40,16 @@ class scan_result_impl
         return iterator_->next(std::move(callback));
     }
 
+    void cancel()
+    {
+        return iterator_->cancel();
+    }
+
+    [[nodiscard]] auto is_cancelled() -> bool
+    {
+        return iterator_->is_cancelled();
+    }
+
   private:
     std::shared_ptr<range_scan_item_iterator> iterator_;
 };
@@ -65,7 +72,14 @@ scan_result::next(utils::movable_function<void(range_scan_item, std::error_code)
 }
 
 void
-scan_result::cancel() const
+scan_result::cancel()
+{
+    return impl_->cancel();
+}
+
+auto
+scan_result::is_cancelled() -> bool
 {
+    return impl_->is_cancelled();
 }
 } // namespace couchbase::core

data/ext/couchbase/core/scan_result.hxx

@@ -41,8 +41,10 @@ class range_scan_item_iterator
 {
   public:
     virtual ~range_scan_item_iterator() = default;
-    virtual auto next() -> std::future<std::optional<range_scan_item>> = 0;
+    virtual auto next() -> std::future<tl::expected<range_scan_item, std::error_code>> = 0;
     virtual void next(utils::movable_function<void(range_scan_item, std::error_code)> callback) = 0;
+    virtual void cancel() = 0;
+    virtual bool is_cancelled() = 0;
 };
 
 class scan_result
@@ -51,7 +53,8 @@ class scan_result
     explicit scan_result(std::shared_ptr<range_scan_item_iterator> iterator);
     [[nodiscard]] auto next() const -> tl::expected<range_scan_item, std::error_code>;
     void next(utils::movable_function<void(range_scan_item, std::error_code)> callback) const;
-    void cancel() const;
+    void cancel();
+    [[nodiscard]] auto is_cancelled() -> bool;
 
   private:
     std::shared_ptr<scan_result_impl> impl_{};

data/ext/couchbase/core/timeout_defaults.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   Copyright 2020-2023 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -27,6 +27,7 @@ constexpr std::chrono::milliseconds resolve_timeout{ 2'000 };
 constexpr std::chrono::milliseconds connect_timeout{ 2'000 };
 constexpr std::chrono::milliseconds key_value_timeout{ 2'500 };
 constexpr std::chrono::milliseconds key_value_durable_timeout{ 10'000 };
+constexpr std::chrono::milliseconds key_value_scan_timeout{ 75'000 };
 constexpr std::chrono::milliseconds view_timeout{ 75'000 };
 constexpr std::chrono::milliseconds query_timeout{ 75'000 };
 constexpr std::chrono::milliseconds analytics_timeout{ 75'000 };
@@ -34,8 +35,6 @@ constexpr std::chrono::milliseconds search_timeout{ 75'000 };
 constexpr std::chrono::milliseconds management_timeout{ 75'000 };
 constexpr std::chrono::milliseconds eventing_timeout{ 75'000 };
 
-constexpr std::chrono::milliseconds range_scan_timeout{ 75'000 };
-
 constexpr std::chrono::milliseconds dns_srv_timeout{ 500 };
 constexpr std::chrono::milliseconds tcp_keep_alive_interval{ 60'000 };
 constexpr std::chrono::milliseconds config_poll_interval{ 2'500 };

data/ext/couchbase/core/tls_verify_mode.hxx

@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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.
+ */
+
+#pragma once
+
+namespace couchbase::core
+{
+enum class tls_verify_mode {
+    none,
+    peer,
+};
+} // namespace couchbase::core

data/ext/couchbase/core/topology/capabilities.hxx

@@ -31,6 +31,8 @@ enum class bucket_capability {
     collections,
     durable_write,
     tombstoned_user_xattrs,
+    range_scan,
+    replica_read,
 };
 
 enum class cluster_capability {
@@ -39,5 +41,6 @@ enum class cluster_capability {
     n1ql_javascript_functions,
     n1ql_inline_functions,
     n1ql_enhanced_prepared_statements,
+    n1ql_read_from_replica,
 };
 } // namespace couchbase::core

data/ext/couchbase/core/topology/capabilities_fmt.hxx

@@ -67,6 +67,12 @@ struct fmt::formatter<couchbase::core::bucket_capability> {
             case couchbase::core::bucket_capability::tombstoned_user_xattrs:
                 name = "tombstoned_user_xattrs";
                 break;
+            case couchbase::core::bucket_capability::range_scan:
+                name = "range_scan";
+                break;
+            case couchbase::core::bucket_capability::replica_read:
+                name = "replica_read";
+                break;
         }
         return format_to(ctx.out(), "{}", name);
     }
@@ -100,6 +106,8 @@ struct fmt::formatter<couchbase::core::cluster_capability> {
             case couchbase::core::cluster_capability::n1ql_enhanced_prepared_statements:
                 name = "n1ql_enhanced_prepared_statements";
                 break;
+            case couchbase::core::cluster_capability::n1ql_read_from_replica:
+                name = "n1ql_read_from_replica";
         }
         return format_to(ctx.out(), "{}", name);
     }

data/ext/couchbase/core/topology/collections_manifest_fmt.hxx

@@ -47,6 +47,6 @@ struct fmt::formatter<couchbase::core::topology::collections_manifest> {
                          couchbase::core::uuid::to_string(manifest.id),
                          manifest.uid,
                          collections.size(),
-                         utils::join_strings(collections, ", "));
+                         couchbase::core::utils::join_strings(collections, ", "));
     }
 };

data/ext/couchbase/core/topology/configuration.cxx

@@ -20,6 +20,8 @@
 #include "core/logger/logger.hxx"
 #include "core/service_type_fmt.hxx"
 
+#include <gsl/narrow>
+
 #include <algorithm>
 #include <stdexcept>
 
@@ -162,9 +164,20 @@ configuration::node::endpoint(const std::string& network, service_type type, boo
 }
 
 bool
-configuration::has_node_with_hostname(const std::string& hostname) const
+configuration::has_node(const std::string& network, service_type type, bool is_tls, const std::string& hostname, const std::string& port)
+  const
 {
-    return std::any_of(nodes.begin(), nodes.end(), [&hostname](const auto& n) { return n.hostname == hostname; });
+    std::uint16_t port_number{ 0 };
+    try {
+        port_number = gsl::narrow_cast<std::uint16_t>(std::stoul(port, nullptr, 10));
+    } catch (const std::invalid_argument&) {
+        return false;
+    } catch (const std::out_of_range&) {
+        return false;
+    }
+    return std::any_of(nodes.begin(), nodes.end(), [&](const auto& n) {
+        return n.hostname_for(network) == hostname && n.port_or(network, type, is_tls, 0) == port_number;
+    });
 }
 
 std::string

data/ext/couchbase/core/topology/configuration.hxx

@@ -112,6 +112,16 @@ struct configuration {
         return cluster_capabilities.find(cluster_capability::n1ql_enhanced_prepared_statements) != cluster_capabilities.end();
     }
 
+    [[nodiscard]] bool supports_read_from_replica() const
+    {
+        return cluster_capabilities.find(cluster_capability::n1ql_read_from_replica) != cluster_capabilities.end();
+    }
+
+    [[nodiscard]] bool supports_range_scan() const
+    {
+        return bucket_capabilities.find(bucket_capability::range_scan) != bucket_capabilities.end();
+    }
+
     [[nodiscard]] bool ephemeral() const
     {
         // Use bucket capabilities to identify if couchapi is missing (then its ephemeral). If its null then
@@ -119,8 +129,17 @@ struct configuration {
         return bucket_capabilities.count(couchbase::core::bucket_capability::couchapi) == 0;
     }
 
+    [[nodiscard]] bool supports_subdoc_read_replica() const
+    {
+        return bucket_capabilities.find(bucket_capability::replica_read) != bucket_capabilities.end();
+    }
+
     [[nodiscard]] std::size_t index_for_this_node() const;
-    [[nodiscard]] bool has_node_with_hostname(const std::string& hostname) const;
+    [[nodiscard]] bool has_node(const std::string& network,
+                                service_type type,
+                                bool is_tls,
+                                const std::string& hostname,
+                                const std::string& port) const;
 
     template<typename Key>
     std::pair<std::uint16_t, std::optional<std::size_t>> map_key(const Key& key, std::size_t index)

data/ext/couchbase/core/topology/configuration_json.hxx

@@ -52,7 +52,6 @@ struct traits<couchbase::core::topology::configuration> {
                 }
                 if (const auto& hostname = o.find("hostname"); hostname != o.end()) {
                     n.hostname = hostname->second.get_string();
-                    n.hostname = n.hostname.substr(0, n.hostname.rfind(':'));
                 }
                 const auto& s = o.at("services");
                 n.services_plain.key_value = s.template optional<std::uint16_t>("kv");
@@ -233,6 +232,10 @@ struct traits<couchbase::core::topology::configuration> {
                     result.bucket_capabilities.insert(couchbase::core::bucket_capability::nodes_ext);
                 } else if (name == "xattr") {
                     result.bucket_capabilities.insert(couchbase::core::bucket_capability::xattr);
+                } else if (name == "rangeScan") {
+                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::range_scan);
+                } else if (name == "subdoc.ReplicaRead") {
+                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::replica_read);
                 }
             }
         }
@@ -249,6 +252,8 @@ struct traits<couchbase::core::topology::configuration> {
                         result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_inline_functions);
                     } else if (name == "enhancedPreparedStatements") {
                         result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_enhanced_prepared_statements);
+                    } else if (name == "readFromReplica") {
+                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_read_from_replica);
                     }
                 }
             }

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

@@ -0,0 +1,93 @@
+/*
+ *     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 "attempt_context_testing_hooks.hxx"
+
+namespace couchbase::core::transactions
+{
+namespace
+{
+inline std::optional<error_class>
+noop_1(attempt_context*)
+{
+    return {};
+}
+
+inline std::optional<error_class>
+noop_2(attempt_context*, const std::string&)
+{
+    return {};
+}
+
+inline std::optional<const std::string>
+noop_3(attempt_context*)
+{
+    return {};
+}
+
+inline bool
+noop_4(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 }
+{
+}
+} // namespace couchbase::core::transactions

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