couchbase 4.2.11 → 4.3.0

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

@@ -17,6 +17,7 @@
 #include "staged_mutation.hxx"
 
 #include "attempt_context_impl.hxx"
+#include "attempt_context_testing_hooks.hxx"
 #include "core/cluster.hxx"
 
 #include "internal/transaction_fields.hxx"
@@ -357,98 +358,94 @@ staged_mutation_queue::rollback(attempt_context_impl* ctx)
 void
 staged_mutation_queue::rollback_insert(attempt_context_impl* ctx,
                                        const staged_mutation& item,
-                                       async_exp_delay delay,
+                                       async_exp_delay& delay,
                                        utils::movable_function<void(std::exception_ptr)> callback)
 {
     CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rolling back staged insert for {} with cas {}", item.doc().id(), item.doc().cas().value());
 
     asio::post(asio::bind_executor(ctx->cluster_ref().io_context(), [this, callback = std::move(callback), ctx, &item, delay]() mutable {
-        try {
-            auto ec = ctx->error_if_expired_and_not_in_overtime(STAGE_DELETE_INSERTED, item.doc().id().key());
-            if (ec) {
-                throw client_error(*ec, "expired in rollback and not in overtime mode");
-            }
-            ec = ctx->hooks_.before_rollback_delete_inserted(ctx, item.doc().id().key());
-            if (ec) {
-                throw client_error(*ec, "before_rollback_delete_insert hook threw error");
+        auto handler = [this, callback = std::move(callback), ctx, &item, delay](const std::optional<client_error>& e) mutable {
+            if (e) {
+                return handle_rollback_insert_error(e.value(), ctx, item, delay, std::move(callback));
             }
-            core::operations::mutate_in_request req{ item.doc().id() };
-            req.specs =
-              couchbase::mutate_in_specs{
-                  couchbase::mutate_in_specs::remove(TRANSACTION_INTERFACE_PREFIX_ONLY).xattr(),
-              }
-                .specs();
-            req.access_deleted = true;
-            req.cas = item.doc().cas();
-            wrap_durable_request(req, ctx->overall().config());
-            return ctx->cluster_ref().execute(
-              req, [this, callback = std::move(callback), ctx, &item, delay](const core::operations::mutate_in_response& resp) mutable {
-                  CB_ATTEMPT_CTX_LOG_TRACE(ctx, "mutate_in for {} with cas {}", item.doc().id(), item.doc().cas().value());
-
-                  auto res = result::create_from_subdoc_response(resp);
-                  try {
-                      validate_rollback_insert_result(ctx, res, item);
-                  } catch (const client_error& e) {
-                      handle_rollback_insert_error(e, ctx, item, delay, std::move(callback));
-                      return;
-                  }
-                  callback({});
-              });
-        } catch (const client_error& e) {
-            handle_rollback_insert_error(e, ctx, item, delay, std::move(callback));
-            return;
+            return callback({});
+        };
+
+        auto ec = ctx->error_if_expired_and_not_in_overtime(STAGE_DELETE_INSERTED, item.doc().id().key());
+        if (ec) {
+            return handler(client_error(*ec, "expired in rollback and not in overtime mode"));
         }
+
+        return ctx->hooks_.before_rollback_delete_inserted(
+          ctx, item.doc().id().key(), [handler = std::move(handler), ctx, &item, delay](std::optional<error_class> ec) mutable {
+              if (ec) {
+                  return handler(client_error(*ec, "before_rollback_delete_insert hook threw error"));
+              }
+              core::operations::mutate_in_request req{ item.doc().id() };
+              req.specs =
+                couchbase::mutate_in_specs{
+                    couchbase::mutate_in_specs::remove(TRANSACTION_INTERFACE_PREFIX_ONLY).xattr(),
+                }
+                  .specs();
+              req.access_deleted = true;
+              req.cas = item.doc().cas();
+              wrap_durable_request(req, ctx->overall().config());
+              return ctx->cluster_ref().execute(
+                req, [handler = std::move(handler), ctx, &item, delay](const core::operations::mutate_in_response& resp) mutable {
+                    CB_ATTEMPT_CTX_LOG_TRACE(ctx, "mutate_in for {} with cas {}", item.doc().id(), item.doc().cas().value());
+
+                    auto res = result::create_from_subdoc_response(resp);
+                    return validate_rollback_insert_result(ctx, res, item, std::move(handler));
+                });
+          });
     }));
 }
 
 void
 staged_mutation_queue::rollback_remove_or_replace(attempt_context_impl* ctx,
                                                   const staged_mutation& item,
-                                                  async_exp_delay delay,
+                                                  async_exp_delay& delay,
                                                   utils::movable_function<void(std::exception_ptr)> callback)
 {
     CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rolling back staged remove/replace for {} with cas {}", item.doc().id(), item.doc().cas().value());
 
     asio::post(asio::bind_executor(ctx->cluster_ref().io_context(), [this, callback = std::move(callback), ctx, &item, delay]() mutable {
-        try {
-            auto ec = ctx->error_if_expired_and_not_in_overtime(STAGE_ROLLBACK_DOC, item.doc().id().key());
-            if (ec) {
-                throw client_error(*ec, "expired in rollback_remove_or_replace and not in expiry overtime");
+        auto handler = [this, callback = std::move(callback), ctx, &item, delay](const std::optional<client_error>& e) mutable {
+            if (e) {
+                return handle_rollback_remove_or_replace_error(e.value(), ctx, item, delay, std::move(callback));
             }
-            ec = ctx->hooks_.before_doc_rolled_back(ctx, item.doc().id().key());
-            if (ec) {
-                throw client_error(*ec, "before_doc_rolled_back hook threw error");
-            }
-            core::operations::mutate_in_request req{ item.doc().id() };
-            req.specs =
-              couchbase::mutate_in_specs{
-                  couchbase::mutate_in_specs::remove(TRANSACTION_INTERFACE_PREFIX_ONLY).xattr(),
-              }
-                .specs();
-            req.cas = item.doc().cas();
-            wrap_durable_request(req, ctx->overall().config());
-            return ctx->cluster_ref().execute(
-              req, [this, callback = std::move(callback), ctx, &item, delay](const core::operations::mutate_in_response& resp) mutable {
-                  auto res = result::create_from_subdoc_response(resp);
-                  try {
-                      validate_rollback_remove_or_replace_result(ctx, res, item);
-                  } catch (const client_error& e) {
-                      handle_rollback_remove_or_replace_error(e, ctx, item, delay, std::move(callback));
-                      return;
-                  }
-                  callback({});
-              });
-        } catch (const client_error& e) {
-            handle_rollback_remove_or_replace_error(e, ctx, item, delay, std::move(callback));
-            return;
+            return callback({});
+        };
+        auto ec = ctx->error_if_expired_and_not_in_overtime(STAGE_ROLLBACK_DOC, item.doc().id().key());
+        if (ec) {
+            return handler(client_error(*ec, "expired in rollback_remove_or_replace and not in expiry overtime"));
         }
+        ctx->hooks_.before_doc_rolled_back(
+          ctx, item.doc().id().key(), [handler = std::move(handler), ctx, &item, delay](std::optional<error_class> ec) mutable {
+              if (ec) {
+                  return handler(client_error(*ec, "before_doc_rolled_back hook threw error"));
+              }
+              core::operations::mutate_in_request req{ item.doc().id() };
+              req.specs =
+                couchbase::mutate_in_specs{
+                    couchbase::mutate_in_specs::remove(TRANSACTION_INTERFACE_PREFIX_ONLY).xattr(),
+                }
+                  .specs();
+              req.cas = item.doc().cas();
+              wrap_durable_request(req, ctx->overall().config());
+              return ctx->cluster_ref().execute(
+                req, [handler = std::move(handler), ctx, &item, delay](const core::operations::mutate_in_response& resp) mutable {
+                    auto res = result::create_from_subdoc_response(resp);
+                    return validate_rollback_remove_or_replace_result(ctx, res, item, std::move(handler));
+                });
+          });
     }));
 }
 
 void
 staged_mutation_queue::commit_doc(attempt_context_impl* ctx,
                                   staged_mutation& item,
-                                  async_constant_delay delay,
+                                  async_constant_delay& delay,
                                   utils::movable_function<void(std::exception_ptr)> callback,
                                   bool ambiguity_resolution_mode,
                                   bool cas_zero_mode)
@@ -459,158 +456,204 @@ staged_mutation_queue::commit_doc(attempt_context_impl* ctx,
     asio::post(asio::bind_executor(
       ctx->cluster_ref().io_context(),
       [this, callback = std::move(callback), ctx, &item, delay, cas_zero_mode, ambiguity_resolution_mode]() mutable {
-          try {
-              ctx->check_expiry_during_commit_or_rollback(STAGE_COMMIT_DOC, std::optional<const std::string>(item.doc().id().key()));
-              auto ec = ctx->hooks_.before_doc_committed(ctx, item.doc().id().key());
-              if (ec) {
-                  throw client_error(*ec, "before_doc_committed hook threw error");
-              }
+          ctx->check_expiry_during_commit_or_rollback(STAGE_COMMIT_DOC, std::optional<const std::string>(item.doc().id().key()));
 
-              // move staged content into doc
-              CB_ATTEMPT_CTX_LOG_TRACE(
-                ctx, "commit doc id {}, content {}, cas {}", item.doc().id(), to_string(item.content()), item.doc().cas().value());
-
-              if (item.type() == staged_mutation_type::INSERT && !cas_zero_mode) {
-                  core::operations::insert_request req{ item.doc().id(), item.content() };
-                  req.flags = couchbase::codec::codec_flags::json_common_flags;
-                  wrap_durable_request(req, ctx->overall().config());
-                  return ctx->cluster_ref().execute(
-                    req,
-                    [this, callback = std::move(callback), ctx, &item, delay, ambiguity_resolution_mode, cas_zero_mode](
-                      const core::operations::insert_response& resp) mutable {
-                        auto res = result::create_from_mutation_response(resp);
-                        try {
-                            validate_commit_doc_result(ctx, res, item);
-                        } catch (const client_error& e) {
-                            handle_commit_doc_error(e, ctx, item, delay, ambiguity_resolution_mode, cas_zero_mode, std::move(callback));
-                            return;
-                        }
-                        // Commit successful
-                        callback({});
-                    });
-              } else {
-                  core::operations::mutate_in_request req{ item.doc().id() };
-                  req.specs =
-                    couchbase::mutate_in_specs{
-                        couchbase::mutate_in_specs::remove(TRANSACTION_INTERFACE_PREFIX_ONLY).xattr(),
-                        // subdoc::opcode::set_doc used in replace w/ empty path
-                        couchbase::mutate_in_specs::replace_raw("", item.content()),
-                    }
-                      .specs();
-                  req.store_semantics = couchbase::store_semantics::replace;
-                  req.cas = couchbase::cas(cas_zero_mode ? 0 : item.doc().cas().value());
-                  wrap_durable_request(req, ctx->overall().config());
-                  return ctx->cluster_ref().execute(
-                    req,
-                    [this, callback = std::move(callback), ctx, &item, delay, ambiguity_resolution_mode, cas_zero_mode](
-                      const core::operations::mutate_in_response resp) mutable {
-                        auto res = result::create_from_subdoc_response(resp);
-                        try {
-                            validate_commit_doc_result(ctx, res, item);
-                        } catch (const client_error& e) {
-                            handle_commit_doc_error(e, ctx, item, delay, ambiguity_resolution_mode, cas_zero_mode, std::move(callback));
-                            return;
-                        }
-                        // Commit successful
-                        callback({});
-                    });
+          auto handler = [this, callback = std::move(callback), ctx, &item, delay](
+                           const std::optional<client_error>& e, bool ambiguity_resolution_mode, bool cas_zero_mode) mutable {
+              if (e) {
+                  return handle_commit_doc_error(
+                    e.value(), ctx, item, delay, ambiguity_resolution_mode, cas_zero_mode, std::move(callback));
               }
-          } catch (const client_error& e) {
-              handle_commit_doc_error(e, ctx, item, delay, ambiguity_resolution_mode, cas_zero_mode, std::move(callback));
-          }
+              callback({});
+          };
+
+          ctx->hooks_.before_doc_committed(
+            ctx,
+            item.doc().id().key(),
+            [handler = std::move(handler), ctx, &item, delay, ambiguity_resolution_mode, cas_zero_mode](
+              std::optional<error_class> ec) mutable {
+                if (ec) {
+                    return handler(client_error(*ec, "before_doc_committed hook threw error"), ambiguity_resolution_mode, cas_zero_mode);
+                }
+                // move staged content into doc
+                CB_ATTEMPT_CTX_LOG_TRACE(
+                  ctx, "commit doc id {}, content {}, cas {}", item.doc().id(), to_string(item.content()), item.doc().cas().value());
+
+                if (item.type() == staged_mutation_type::INSERT && !cas_zero_mode) {
+                    core::operations::insert_request req{ item.doc().id(), item.content() };
+                    req.flags = couchbase::codec::codec_flags::json_common_flags;
+                    wrap_durable_request(req, ctx->overall().config());
+                    return ctx->cluster_ref().execute(
+                      req,
+                      [handler = std::move(handler), ctx, &item, delay, ambiguity_resolution_mode, cas_zero_mode](
+                        const core::operations::insert_response& resp) mutable {
+                          auto res = result::create_from_mutation_response(resp);
+                          return validate_commit_doc_result(
+                            ctx, res, item, [ambiguity_resolution_mode, cas_zero_mode, handler = std::move(handler)](auto e) mutable {
+                                if (e) {
+                                    return handler(e, ambiguity_resolution_mode, cas_zero_mode);
+                                }
+                                // Commit successful
+                                return handler({}, {}, {});
+                            });
+                      });
+                } else {
+                    core::operations::mutate_in_request req{ item.doc().id() };
+                    req.specs =
+                      couchbase::mutate_in_specs{
+                          couchbase::mutate_in_specs::remove(TRANSACTION_INTERFACE_PREFIX_ONLY).xattr(),
+                          // subdoc::opcode::set_doc used in replace w/ empty path
+                          couchbase::mutate_in_specs::replace_raw("", item.content()),
+                      }
+                        .specs();
+                    req.store_semantics = couchbase::store_semantics::replace;
+                    req.cas = couchbase::cas(cas_zero_mode ? 0 : item.doc().cas().value());
+                    wrap_durable_request(req, ctx->overall().config());
+                    return ctx->cluster_ref().execute(
+                      req,
+                      [handler = std::move(handler), ctx, &item, delay, ambiguity_resolution_mode, cas_zero_mode](
+                        const core::operations::mutate_in_response resp) mutable {
+                          auto res = result::create_from_subdoc_response(resp);
+                          return validate_commit_doc_result(
+                            ctx, res, item, [ambiguity_resolution_mode, cas_zero_mode, handler = std::move(handler)](auto e) mutable {
+                                if (e) {
+                                    return handler(e, ambiguity_resolution_mode, cas_zero_mode);
+                                }
+                                // Commit successful
+                                return handler({}, {}, {});
+                            });
+                      });
+                }
+            });
       }));
 }
 
 void
 staged_mutation_queue::remove_doc(attempt_context_impl* ctx,
                                   const staged_mutation& item,
-                                  async_constant_delay delay,
+                                  async_constant_delay& delay,
                                   utils::movable_function<void(std::exception_ptr)> callback)
 {
     CB_ATTEMPT_CTX_LOG_TRACE(ctx, "remove doc {}", item.doc().id());
 
     asio::post(asio::bind_executor(ctx->cluster_ref().io_context(), [this, callback = std::move(callback), ctx, &item, delay]() mutable {
-        try {
-            ctx->check_expiry_during_commit_or_rollback(STAGE_REMOVE_DOC, std::optional<const std::string>(item.doc().id().key()));
-            auto ec = ctx->hooks_.before_doc_removed(ctx, item.doc().id().key());
-            if (ec) {
-                throw client_error(*ec, "before_doc_removed hook threw error");
+        auto handler = [this, ctx, &item, delay, callback = std::move(callback)](const std::optional<client_error>& e) mutable {
+            if (e) {
+                return handle_remove_doc_error(e.value(), ctx, item, delay, std::move(callback));
             }
-            core::operations::remove_request req{ item.doc().id() };
-            wrap_durable_request(req, ctx->overall().config());
-            return ctx->cluster_ref().execute(
-              req, [this, callback = std::move(callback), ctx, &item, delay](core::operations::remove_response resp) mutable {
-                  auto res = result::create_from_mutation_response(resp);
-                  try {
-                      validate_remove_doc_result(ctx, res, item);
-                  } catch (const client_error& e) {
-                      handle_remove_doc_error(e, ctx, item, delay, std::move(callback));
-                      return;
-                  }
-                  callback({});
-              });
-        } catch (const client_error& e) {
-            handle_remove_doc_error(e, ctx, item, delay, std::move(callback));
-        }
+            return callback({});
+        };
+
+        ctx->check_expiry_during_commit_or_rollback(STAGE_REMOVE_DOC, std::optional<const std::string>(item.doc().id().key()));
+        return ctx->hooks_.before_doc_removed(
+          ctx, item.doc().id().key(), [ctx, &item, delay, handler = std::move(handler)](auto ec) mutable {
+              if (ec) {
+                  return handler(client_error(*ec, "before_doc_removed hook threw error"));
+              }
+              core::operations::remove_request req{ item.doc().id() };
+              wrap_durable_request(req, ctx->overall().config());
+              return ctx->cluster_ref().execute(
+                req, [handler = std::move(handler), ctx, &item, delay](core::operations::remove_response resp) mutable {
+                    auto res = result::create_from_mutation_response(resp);
+                    return validate_remove_doc_result(ctx, res, item, std::move(handler));
+                });
+          });
     }));
 }
 
 void
-staged_mutation_queue::validate_commit_doc_result(attempt_context_impl* ctx, result& res, staged_mutation& item)
+staged_mutation_queue::validate_commit_doc_result(attempt_context_impl* ctx,
+                                                  result& res,
+                                                  staged_mutation& item,
+                                                  client_error_handler&& handler)
 {
-    validate_operation_result(res);
+    try {
+        validate_operation_result(res);
+    } catch (const client_error& e) {
+        return handler(e);
+    }
     CB_ATTEMPT_CTX_LOG_TRACE(ctx, "commit doc result {}", res);
     // TODO: mutation tokens
-    auto ec = ctx->hooks_.after_doc_committed_before_saving_cas(ctx, item.doc().id().key());
-    if (ec) {
-        throw client_error(*ec, "after_doc_committed_before_saving_cas threw error");
-    }
-    item.doc().cas(res.cas);
-    ec = ctx->hooks_.after_doc_committed(ctx, item.doc().id().key());
-    if (ec) {
-        throw client_error(*ec, "after_doc_committed threw error");
-    }
+    ctx->hooks_.after_doc_committed_before_saving_cas(
+      ctx, item.doc().id().key(), [ctx, res, item, handler = std::move(handler)](auto ec) mutable {
+          if (ec) {
+              return handler(client_error(*ec, "after_doc_committed_before_saving_cas threw error"));
+          }
+          item.doc().cas(res.cas);
+          return ctx->hooks_.after_doc_committed(ctx, item.doc().id().key(), [res, item, handler = std::move(handler)](auto ec) mutable {
+              if (ec) {
+                  return handler(client_error(*ec, "after_doc_committed threw error"));
+              }
+              return handler({});
+          });
+      });
 }
 
 void
-staged_mutation_queue::validate_remove_doc_result(attempt_context_impl* ctx, result& res, const staged_mutation& item)
+staged_mutation_queue::validate_remove_doc_result(attempt_context_impl* ctx,
+                                                  result& res,
+                                                  const staged_mutation& item,
+                                                  client_error_handler&& handler)
 {
-    validate_operation_result(res);
-    CB_ATTEMPT_CTX_LOG_TRACE(ctx, "remove doc result {}", res);
-    auto ec = ctx->hooks_.after_doc_removed_pre_retry(ctx, item.doc().id().key());
-    CB_ATTEMPT_CTX_LOG_TRACE(ctx, "got hook ec");
-    if (ec) {
-        throw client_error(*ec, "after_doc_removed_pre_retry threw error");
+    try {
+        validate_operation_result(res);
+    } catch (const client_error& e) {
+        return handler(e);
     }
+    CB_ATTEMPT_CTX_LOG_TRACE(ctx, "remove doc result {}", res);
+    return ctx->hooks_.after_doc_removed_pre_retry(ctx, item.doc().id().key(), [handler = std::move(handler)](auto ec) {
+        if (ec) {
+            return handler(client_error(*ec, "after_doc_removed_pre_retry threw error"));
+        }
+        return handler({});
+    });
 }
 
 void
-staged_mutation_queue::validate_rollback_insert_result(attempt_context_impl* ctx, result& res, const staged_mutation& item)
+staged_mutation_queue::validate_rollback_insert_result(attempt_context_impl* ctx,
+                                                       result& res,
+                                                       const staged_mutation& item,
+                                                       client_error_handler&& handler)
 {
-    validate_operation_result(res);
-    CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rollback insert result {}", res);
-    auto ec = ctx->hooks_.after_rollback_delete_inserted(ctx, item.doc().id().key());
-    if (ec) {
-        throw client_error(*ec, "after_rollback_delete_insert hook threw error");
+    try {
+        validate_operation_result(res);
+    } catch (const client_error& e) {
+        return handler(e);
     }
+    CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rollback insert result {}", res);
+    return ctx->hooks_.after_rollback_delete_inserted(ctx, item.doc().id().key(), [handler = std::move(handler)](auto ec) {
+        if (ec) {
+            return handler(client_error(*ec, "after_rollback_delete_insert hook threw error"));
+        }
+        return handler({});
+    });
 }
 
 void
-staged_mutation_queue::validate_rollback_remove_or_replace_result(attempt_context_impl* ctx, result& res, const staged_mutation& item)
+staged_mutation_queue::validate_rollback_remove_or_replace_result(attempt_context_impl* ctx,
+                                                                  result& res,
+                                                                  const staged_mutation& item,
+                                                                  client_error_handler&& handler)
 {
-    validate_operation_result(res);
-    CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rollback remove or replace result {}", res);
-    auto ec = ctx->hooks_.after_rollback_replace_or_remove(ctx, item.doc().id().key());
-    if (ec) {
-        throw client_error(*ec, "after_rollback_replace_or_remove hook threw error");
+    try {
+        validate_operation_result(res);
+    } catch (const client_error& e) {
+        return handler(e);
     }
+    CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rollback remove or replace result {}", res);
+    return ctx->hooks_.after_rollback_replace_or_remove(ctx, item.doc().id().key(), [handler = std::move(handler)](auto ec) {
+        if (ec) {
+            return handler(client_error(*ec, "after_rollback_replace_or_remove hook threw error"));
+        }
+        return handler({});
+    });
 }
 
 void
 staged_mutation_queue::handle_commit_doc_error(const client_error& e,
                                                attempt_context_impl* ctx,
                                                staged_mutation& item,
-                                               async_constant_delay delay,
+                                               async_constant_delay& delay,
                                                bool ambiguity_resolution_mode,
                                                bool cas_zero_mode,
                                                utils::movable_function<void(std::exception_ptr)> callback)
@@ -656,7 +699,7 @@ void
 staged_mutation_queue::handle_remove_doc_error(const client_error& e,
                                                attempt_context_impl* ctx,
                                                const staged_mutation& item,
-                                               async_constant_delay delay,
+                                               async_constant_delay& delay,
                                                utils::movable_function<void(std::exception_ptr)> callback)
 {
     auto ec = e.ec();
@@ -690,7 +733,7 @@ void
 staged_mutation_queue::handle_rollback_insert_error(const client_error& e,
                                                     attempt_context_impl* ctx,
                                                     const staged_mutation& item,
-                                                    async_exp_delay delay,
+                                                    async_exp_delay& delay,
                                                     utils::movable_function<void(std::exception_ptr)> callback)
 {
     auto ec = e.ec();
@@ -736,7 +779,7 @@ void
 staged_mutation_queue::handle_rollback_remove_or_replace_error(const client_error& e,
                                                                attempt_context_impl* ctx,
                                                                const staged_mutation& item,
-                                                               async_exp_delay delay,
+                                                               async_exp_delay& delay,
                                                                utils::movable_function<void(std::exception_ptr)> callback)
 {
     auto ec = e.ec();

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

@@ -129,51 +129,62 @@ class staged_mutation_queue
     std::mutex mutex_;
     std::vector<staged_mutation> queue_;
 
-    static void validate_rollback_remove_or_replace_result(attempt_context_impl* ctx, result& res, const staged_mutation& item);
-    static void validate_rollback_insert_result(attempt_context_impl* ctx, result& res, const staged_mutation& item);
-    static void validate_commit_doc_result(attempt_context_impl* ctx, result& res, staged_mutation& item);
-    static void validate_remove_doc_result(attempt_context_impl* ctx, result& res, const staged_mutation& item);
+    using client_error_handler = utils::movable_function<void(const std::optional<client_error>&)>;
+
+    static void validate_rollback_remove_or_replace_result(attempt_context_impl* ctx,
+                                                           result& res,
+                                                           const staged_mutation& item,
+                                                           client_error_handler&& handler);
+    static void validate_rollback_insert_result(attempt_context_impl* ctx,
+                                                result& res,
+                                                const staged_mutation& item,
+                                                client_error_handler&& handler);
+    static void validate_commit_doc_result(attempt_context_impl* ctx, result& res, staged_mutation& item, client_error_handler&& handler);
+    static void validate_remove_doc_result(attempt_context_impl* ctx,
+                                           result& res,
+                                           const staged_mutation& item,
+                                           client_error_handler&& handler);
 
     void handle_commit_doc_error(const client_error& e,
                                  attempt_context_impl* ctx,
                                  staged_mutation& item,
-                                 async_constant_delay delay,
+                                 async_constant_delay& delay,
                                  bool ambiguity_resolution_mode,
                                  bool cas_zero_mode,
                                  utils::movable_function<void(std::exception_ptr)> callback);
     void handle_remove_doc_error(const client_error& e,
                                  attempt_context_impl* ctx,
                                  const staged_mutation& item,
-                                 async_constant_delay delay,
+                                 async_constant_delay& delay,
                                  utils::movable_function<void(std::exception_ptr)> callback);
     void handle_rollback_insert_error(const client_error& e,
                                       attempt_context_impl* ctx,
                                       const staged_mutation& item,
-                                      async_exp_delay delay,
+                                      async_exp_delay& delay,
                                       utils::movable_function<void(std::exception_ptr)> callback);
     void handle_rollback_remove_or_replace_error(const client_error& e,
                                                  attempt_context_impl* ctx,
                                                  const staged_mutation& item,
-                                                 async_exp_delay delay,
+                                                 async_exp_delay& delay,
                                                  utils::movable_function<void(std::exception_ptr)> callback);
 
     void commit_doc(attempt_context_impl* ctx,
                     staged_mutation& item,
-                    async_constant_delay delay,
+                    async_constant_delay& delay,
                     utils::movable_function<void(std::exception_ptr)> callback,
                     bool ambiguity_resolution_mode = false,
                     bool cas_zero_mode = false);
     void remove_doc(attempt_context_impl* ctx,
                     const staged_mutation& item,
-                    async_constant_delay delay,
+                    async_constant_delay& delay,
                     utils::movable_function<void(std::exception_ptr)> callback);
     void rollback_insert(attempt_context_impl* ctx,
                          const staged_mutation& item,
-                         async_exp_delay delay,
+                         async_exp_delay& delay,
                          utils::movable_function<void(std::exception_ptr)> callback);
     void rollback_remove_or_replace(attempt_context_impl* ctx,
                                     const staged_mutation& item,
-                                    async_exp_delay delay,
+                                    async_exp_delay& delay,
                                     utils::movable_function<void(std::exception_ptr)> callback);
 
   public: