couchbase 3.8.2 → 3.9.0

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

@@ -201,11 +201,14 @@ attempt_context_impl::check_and_handle_blocking_transactions(
       if (err) {
         return cb(err);
       }
-      return check_atr_entry_for_blocking_document(doc,
-                                                   exp_delay(std::chrono::milliseconds(50),
-                                                             std::chrono::milliseconds(500),
-                                                             std::chrono::seconds(1)),
-                                                   std::move(cb));
+      return check_atr_entry_for_blocking_document(
+        doc,
+        std::make_shared<async_timed_exp_delay>(
+          std::make_shared<asio::steady_timer>(cluster_ref().io_context()),
+          std::chrono::milliseconds(50),
+          std::chrono::milliseconds(500),
+          std::chrono::seconds(1)),
+        std::move(cb));
     }
     CB_ATTEMPT_CTX_LOG_DEBUG(this,
                              "doc \"{}\" is in another transaction {}, but doesn't have enough "
@@ -919,7 +922,7 @@ attempt_context_impl::replace(const transaction_get_result& document,
             CB_ATTEMPT_CTX_LOG_TRACE(
               self, "replacing {} with {}", document, utils::to_string(content.data));
             self->check_if_done(cb);
-            staged_mutation* existing_sm = self->staged_mutations_->find_any(document.id());
+            const staged_mutation* existing_sm = self->staged_mutations_->find_any(document.id());
             if (existing_sm != nullptr && existing_sm->type() == staged_mutation_type::REMOVE) {
               CB_ATTEMPT_CTX_LOG_DEBUG(
                 self, "found existing REMOVE of {} while replacing", document);
@@ -972,9 +975,7 @@ attempt_context_impl::replace(const transaction_get_result& document,
                       self->create_staged_insert(document.id(),
                                                  std::move(content),
                                                  document.cas().value(),
-                                                 exp_delay(std::chrono::milliseconds(5),
-                                                           std::chrono::milliseconds(300),
-                                                           self->overall()->config().timeout),
+                                                 self->staged_insert_delay(),
                                                  op_id,
                                                  std::move(cb));
                       return;
@@ -1312,7 +1313,7 @@ attempt_context_impl::insert(const core::document_id& id,
           try {
             self->check_if_done(cb);
             auto op_id = uid_generator::next();
-            staged_mutation* existing_sm = self->staged_mutations_->find_any(id);
+            const staged_mutation* existing_sm = self->staged_mutations_->find_any(id);
             if ((existing_sm != nullptr) &&
                 (existing_sm->type() == staged_mutation_type::INSERT ||
                  existing_sm->type() == staged_mutation_type::REPLACE)) {
@@ -1345,14 +1346,8 @@ attempt_context_impl::insert(const core::document_id& id,
                                                      std::move(cb));
                 }
                 const std::uint64_t cas = 0;
-                self->create_staged_insert(id,
-                                           std::move(content),
-                                           cas,
-                                           exp_delay(std::chrono::milliseconds(5),
-                                                     std::chrono::milliseconds(300),
-                                                     self->overall()->config().timeout),
-                                           op_id,
-                                           std::move(cb));
+                self->create_staged_insert(
+                  id, std::move(content), cas, self->staged_insert_delay(), op_id, std::move(cb));
               });
           } catch (const std::exception& e) {
             return self->op_completed_with_error(
@@ -1401,19 +1396,24 @@ attempt_context_impl::select_atr_if_needed_unlocked(
     CB_ATTEMPT_CTX_LOG_ERROR(this, "unexpected error \"{}\" during select atr if needed", e.what());
   }
 }
-template<typename Handler, typename Delay>
+template<typename Handler>
 void
-attempt_context_impl::check_atr_entry_for_blocking_document(const transaction_get_result& doc,
-                                                            Delay delay,
-                                                            Handler&& cb)
+attempt_context_impl::check_atr_entry_for_blocking_document(
+  const transaction_get_result& doc,
+  std::shared_ptr<async_timed_exp_delay> delay,
+  Handler&& cb)
 {
-  try {
-    delay();
-    return hooks_.before_check_atr_entry_for_blocking_doc(
-      shared_from_this(),
+  (*delay)([self = shared_from_this(), doc, delay, cb = std::forward<Handler>(cb)](
+             const std::exception_ptr& delay_err) mutable {
+    if (delay_err) {
+      return cb(transaction_operation_failed(FAIL_WRITE_WRITE_CONFLICT,
+                                             "document is in another transaction")
+                  .retry());
+    }
+    return self->hooks_.before_check_atr_entry_for_blocking_doc(
+      self,
       doc.id().key(),
-      [self = shared_from_this(), delay = std::move(delay), cb = std::forward<Handler>(cb), doc](
-        auto ec) mutable {
+      [self, delay = std::move(delay), cb = std::move(cb), doc](auto ec) mutable {
         if (ec) {
           return cb(transaction_operation_failed(FAIL_WRITE_WRITE_CONFLICT,
                                                  "document is in another transaction")
@@ -1453,7 +1453,8 @@ attempt_context_impl::check_atr_entry_for_blocking_document(const transaction_ge
                                                "existing atr entry found in state {}, retrying",
                                                attempt_state_name(it->state()));
                   }
-                  return self->check_atr_entry_for_blocking_document(doc, delay, std::move(cb));
+                  return self->check_atr_entry_for_blocking_document(
+                    doc, std::move(delay), std::move(cb));
                 }
               }
               CB_ATTEMPT_CTX_LOG_DEBUG(self, "no blocking atr entry");
@@ -1465,11 +1466,7 @@ attempt_context_impl::check_atr_entry_for_blocking_document(const transaction_ge
                         .retry());
           });
       });
-  } catch (const retry_operation_timeout&) {
-    return cb(
-      transaction_operation_failed(FAIL_WRITE_WRITE_CONFLICT, "document is in another transaction")
-        .retry());
-  }
+  });
 }
 void
 attempt_context_impl::remove(const transaction_get_result& document, VoidCallback&& cb)
@@ -1993,11 +1990,11 @@ dump_request(const core::operations::query_request& req) -> std::string
   std::string raw = "{";
   for (const auto& x : req.raw) {
     raw += x.first;
-    raw += ":";
+    raw += ':';
     raw += x.second.str();
-    raw += ",";
+    raw += ',';
   }
-  raw += "}";
+  raw += '}';
   std::string params;
   for (const auto& x : req.positional_parameters) {
     params.append(x.str());
@@ -2049,6 +2046,7 @@ attempt_context_impl::wrap_query(
 
   if (check_expiry) {
     if (has_expired_client_side(hook_point, std::nullopt)) {
+      query_check_expired_ = true;
       auto err = std::make_exception_ptr(
         transaction_operation_failed(FAIL_EXPIRY,
                                      fmt::format("{} expired in stage {}", statement, hook_point))
@@ -3241,10 +3239,10 @@ attempt_context_impl::set_atr_pending_locked(
           // This bounds the value to [0-timeout].  It should always be in this
           // range, this is just to protect against the application clock
           // changing.
-          const long remaining_bounded_nanos =
+          const auto remaining_bounded_nanos =
             std::max(std::min(remaining.count(), self->overall()->config().timeout.count()),
                      static_cast<std::chrono::nanoseconds::rep>(0));
-          const long remaining_bounded_msecs = remaining_bounded_nanos / 1'000'000;
+          const auto remaining_bounded_msecs = remaining_bounded_nanos / 1'000'000;
 
           core::operations::mutate_in_request req{ self->atr_id_.value() };
 
@@ -3403,6 +3401,7 @@ attempt_context_impl::do_get(const core::document_id& id,
         return self->get_doc(
           id,
           allow_replica,
+          std::nullopt,
           [self,
            id,
            allow_replica,
@@ -3578,6 +3577,7 @@ execute_lookup(attempt_context_impl* ctx, LookupInRequest& req, Callback&& cb)
 void
 attempt_context_impl::get_doc(const core::document_id& id,
                               bool allow_replica,
+                              std::optional<std::chrono::milliseconds> timeout,
                               std::function<void(std::optional<error_class>,
                                                  std::optional<external_exception>,
                                                  std::optional<std::string>,
@@ -3601,27 +3601,21 @@ attempt_context_impl::get_doc(const core::document_id& id,
 
   try {
     if (allow_replica) {
-      cluster_ref().with_bucket_configuration(
-        id.bucket(),
-        [this, id, specs, cb = std::move(cb)](
-          std::error_code ec, const std::shared_ptr<topology::configuration>& config) {
-          if (ec) {
-            cb(FAIL_OTHER,
-               std::nullopt,
-               "failed to check whether access_deleted is supported: " + ec.message(),
-               std::nullopt);
-            return;
-          }
-          core::operations::lookup_in_any_replica_request req{ id };
-          req.read_preference = couchbase::read_preference::selected_server_group_or_all_available;
-          req.specs = specs;
-          req.access_deleted = config->capabilities.supports_subdoc_access_deleted();
-          execute_lookup(this, req, cb);
-        });
+      // Per the transactions spec ("Fetching an individual document") and MB-63241, a replica read
+      // must not be combined with the accessDeleted flag; the reference SDKs omit it on the replica
+      // path. We therefore always read replicas without accessDeleted (so tombstones are not
+      // visible there) and need no bucket-config capability probe.
+      core::operations::lookup_in_any_replica_request req{ id };
+      req.read_preference = couchbase::read_preference::selected_server_group_or_all_available;
+      req.specs = specs;
+      req.access_deleted = false;
+      req.timeout = timeout;
+      execute_lookup(this, req, cb);
     } else {
       core::operations::lookup_in_request req{ id };
       req.access_deleted = true;
       req.specs = specs;
+      req.timeout = timeout;
       execute_lookup(this, req, cb);
     }
   } catch (const std::exception& e) {
@@ -3658,8 +3652,8 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
         transaction_operation_failed(ec, "transient error in insert").retry());
     case FAIL_AMBIGUOUS:
       CB_ATTEMPT_CTX_LOG_DEBUG(this, "FAIL_AMBIGUOUS in create_staged_insert, retrying");
-      delay();
-      return create_staged_insert(id, content, cas, delay, op_id, std::forward<Handler>(cb));
+      return retry_create_staged_insert(
+        id, content, cas, std::forward<Delay>(delay), op_id, std::forward<Handler>(cb));
     case FAIL_OTHER:
       return op_completed_with_error(
         std::forward<Handler>(cb),
@@ -3720,6 +3714,7 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
           return self->get_doc(
             id,
             false,
+            std::nullopt,
             [self, id, content, op_id, cb = std::forward<Handler>(cb), error_handler, delay](
               std::optional<error_class> ec3,
               std::optional<external_exception> /* cause */,
@@ -3747,8 +3742,7 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
                                              "create staged insert found existing deleted doc, "
                                              "retrying with cas {}",
                                              doc->cas().value());
-                    delay();
-                    return self->create_staged_insert(
+                    return self->retry_create_staged_insert(
                       id, content, doc->cas().value(), delay, op_id, std::forward<Handler>(cb));
                   }
                   if (!doc->links().is_document_in_transaction()) {
@@ -3800,9 +3794,8 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
                                                "doc ok to overwrite, retrying create_staged_insert "
                                                "with cas {}",
                                                doc->cas().value());
-                      delay();
-                      return self->create_staged_insert(
-                        id, content, doc->cas().value(), delay, op_id, std::forward<Handler>(cb));
+                      return self->retry_create_staged_insert(
+                        id, content, doc->cas().value(), delay, op_id, std::move(cb));
                     });
                 } else {
                   // no doc now, just retry entire txn
@@ -3828,6 +3821,58 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
   }
 }
 
+auto
+attempt_context_impl::staged_insert_delay() const -> std::shared_ptr<async_timed_exp_delay>
+{
+  auto delay = std::make_shared<async_timed_exp_delay>(
+    std::make_shared<asio::steady_timer>(cluster_ref().io_context()),
+    std::chrono::milliseconds(5),
+    std::chrono::milliseconds(300),
+    overall()->config().timeout);
+  // The transaction expiry bounds the retries; a retry limit would fail a long transaction early.
+  delay->max_retries = std::numeric_limits<std::size_t>::max();
+  return delay;
+}
+
+template<typename Handler, typename Delay>
+void
+attempt_context_impl::retry_create_staged_insert(const core::document_id& id,
+                                                 const codec::encoded_value& content,
+                                                 std::uint64_t cas,
+                                                 Delay&& delay,
+                                                 const std::string& op_id,
+                                                 Handler&& cb)
+{
+  auto shared_delay = delay;
+  (*shared_delay)([self = shared_from_this(),
+                   id,
+                   content = content,
+                   cas,
+                   delay = std::forward<Delay>(delay),
+                   op_id,
+                   cb = std::forward<Handler>(cb)](const std::exception_ptr& delay_err) mutable {
+    if (delay_err) {
+      try {
+        std::rethrow_exception(delay_err);
+      } catch (const retry_operation_timeout&) {
+        return self->create_staged_insert_error_handler(id,
+                                                        content,
+                                                        cas,
+                                                        delay,
+                                                        op_id,
+                                                        std::move(cb),
+                                                        FAIL_EXPIRY,
+                                                        UNKNOWN,
+                                                        "create_staged_insert retries timed out");
+      } catch (const std::exception& e) {
+        return self->op_completed_with_error(std::move(cb),
+                                             transaction_operation_failed(FAIL_OTHER, e.what()));
+      }
+    }
+    return self->create_staged_insert(id, std::move(content), cas, delay, op_id, std::move(cb));
+  });
+}
+
 template<typename Handler, typename Delay>
 void
 attempt_context_impl::create_staged_insert(const core::document_id& id,

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

@@ -74,6 +74,7 @@ class transactions;
 enum class forward_compat_stage : std::uint8_t;
 class staged_mutation_queue;
 class staged_mutation;
+struct async_timed_exp_delay;
 struct attempt_context_testing_hooks;
 
 class attempt_context_impl
@@ -100,6 +101,8 @@ private:
   friend class atr_cleanup_entry;
   // transaction_context needs access to the two functions below
   friend class transaction_context;
+  // get_multi fetches raw documents (body + metadata, no MAV/ATR resolution) via get_doc
+  friend class get_multi_operation;
 
   void insert(const core::document_id& id,
               codec::encoded_value content,
@@ -461,6 +464,9 @@ public:
 
 private:
   std::atomic<bool> expiry_overtime_mode_{ false };
+  // Set when the client-side expiry check of a query statement fires. Any later failed
+  // auto-rollback in this attempt raises EXPIRED instead of FAILED.
+  std::atomic<bool> query_check_expired_{ false };
 
   auto check_expiry_pre_commit(std::string stage, std::optional<const std::string> doc_id) -> bool;
 
@@ -483,9 +489,9 @@ private:
     forward_compat_stage stage,
     std::function<void(std::optional<transaction_operation_failed>)>&& cb);
 
-  template<typename Handler, typename Delay>
+  template<typename Handler>
   void check_atr_entry_for_blocking_document(const transaction_get_result& doc,
-                                             Delay delay,
+                                             std::shared_ptr<async_timed_exp_delay> delay,
                                              Handler&& cb);
 
   template<typename Handler>
@@ -513,6 +519,7 @@ private:
 
   void get_doc(const core::document_id& id,
                bool allow_replica,
+               std::optional<std::chrono::milliseconds> timeout,
                std::function<void(std::optional<error_class>,
                                   std::optional<external_exception>,
                                   std::optional<std::string>,
@@ -540,6 +547,16 @@ private:
                              const std::optional<document_metadata>& document_metadata,
                              Handler&& cb);
 
+  [[nodiscard]] auto staged_insert_delay() const -> std::shared_ptr<async_timed_exp_delay>;
+
+  template<typename Handler, typename Delay>
+  void retry_create_staged_insert(const core::document_id& id,
+                                  const codec::encoded_value& content,
+                                  std::uint64_t cas,
+                                  Delay&& delay,
+                                  const std::string& op_id,
+                                  Handler&& cb);
+
   template<typename Handler, typename Delay>
   void create_staged_insert_error_handler(const core::document_id& id,
                                           const codec::encoded_value& content,

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

@@ -39,7 +39,7 @@ public:
   }
   void push_back(const transaction_operation_failed& ex)
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::scoped_lock<std::mutex> lock(mutex_);
     list_.push_back(ex);
     size_ = list_.size();
   }
@@ -47,7 +47,7 @@ public:
   {
     assert(size_.load() > 0);
     // merge the errors, throw a composite
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::scoped_lock<std::mutex> lock(mutex_);
     transaction_operation_failed::merge_errors(list_, cause);
   }
 };

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

@@ -0,0 +1,160 @@
+/*
+ *     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.
+ */
+
+#pragma once
+
+#include "core/document_id.hxx"
+#include "error_class.hxx"
+#include "exceptions.hxx"
+#include "get_multi_transaction_id.hxx"
+#include "internal/doc_record.hxx"
+
+#include <algorithm>
+#include <chrono>
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+// Pure decision helpers for the get_multi orchestrator, factored out of get_multi_orchestrator.cxx
+// so the branching that the ExtGetMulti spec specifies can be unit-tested without a cluster. Each
+// function operates on plain data and is free of I/O or orchestrator state.
+namespace couchbase::core::transactions
+{
+enum class get_multi_fetch_outcome : std::uint8_t {
+  document_absent,
+  retry_after_backoff,
+  bound_exceeded,
+  fail_expired,
+  fail_without_rollback,
+  fail_with_rollback,
+};
+
+enum class bound_exceeded_action : std::uint8_t {
+  preserve_prior_value,
+  fail_retryable,
+};
+
+/**
+ * Decides what a bound-exceeded fetch does with its slot. A document already fetched in an earlier
+ * round is kept for the best-effort snapshot the spec's BoundExceeded return allows. But when no
+ * value is held for the document -- e.g. reset_and_retry() cleared every slot and the re-fetch hit
+ * a transient with the (fixed, already-elapsed) bound -- leaving the slot blank would misreport the
+ * document as not-found: a transient is never a document-not-found. The spec's "Global signal
+ * handling" instead raises a retryable error when a document is unresolved at the bound, so the
+ * enclosing transaction retries rather than returning a wrong absent result.
+ */
+[[nodiscard]] inline auto
+get_multi_bound_exceeded_action(bool has_prior_value) -> bound_exceeded_action
+{
+  return has_prior_value ? bound_exceeded_action::preserve_prior_value
+                         : bound_exceeded_action::fail_retryable;
+}
+
+/**
+ * Maps a failed individual get_multi fetch to the action required by the ExtGetMulti spec's
+ * "Fetching an individual document / Error handling" section, adapted to this SDK's error model.
+ *
+ * The spec branches on a distinct TimeoutException, which this SDK does not have: a read timeout
+ * classifies as FAIL_TRANSIENT (unambiguous_timeout) or FAIL_AMBIGUOUS (ambiguous_timeout), the
+ * same classes as a genuine transient failure. Rather than guess which occurred, a transient class
+ * is disambiguated by whether the operation's read-skew bound has elapsed: before the bound it is a
+ * transient error to retry (spec FAIL_TRANSIENT: exponential backoff from 1ms), once the bound has
+ * elapsed the SDK stops resolving and returns the best-effort snapshot (spec BoundExceeded).
+ * A FAIL_EXPIRY is surfaced as fail_expired so the caller can mark the operation expired (raising
+ * TRANSACTION_EXPIRED) rather than a generic failure.
+ */
+[[nodiscard]] inline auto
+classify_get_multi_fetch_error(std::optional<error_class> ec,
+                               std::optional<external_exception> cause,
+                               bool read_skew_bound_exceeded) -> get_multi_fetch_outcome
+{
+  if (!ec.has_value()) {
+    return get_multi_fetch_outcome::document_absent;
+  }
+  if (cause == DOCUMENT_UNRETRIEVABLE_EXCEPTION || cause == DOCUMENT_NOT_FOUND_EXCEPTION ||
+      ec == FAIL_DOC_NOT_FOUND) {
+    return get_multi_fetch_outcome::document_absent;
+  }
+  if (ec == FAIL_TRANSIENT || ec == FAIL_AMBIGUOUS) {
+    return read_skew_bound_exceeded ? get_multi_fetch_outcome::bound_exceeded
+                                    : get_multi_fetch_outcome::retry_after_backoff;
+  }
+  if (ec == FAIL_EXPIRY) {
+    return get_multi_fetch_outcome::fail_expired;
+  }
+  if (ec == FAIL_HARD) {
+    return get_multi_fetch_outcome::fail_without_rollback;
+  }
+  return get_multi_fetch_outcome::fail_with_rollback;
+}
+
+/**
+ * Per-document read timeout: the smaller of the time left before the operation's read-skew bound
+ * and the SDK's key-value read timeout (spec "Fetching an individual document": use an operation
+ * timeout of min(remaining deadline, 2.5s)). Floored at 1ms so an already-elapsed bound still
+ * issues a bounded read that fails fast rather than passing a zero or negative timeout.
+ */
+[[nodiscard]] inline auto
+get_multi_fetch_timeout(std::chrono::steady_clock::duration remaining,
+                        std::chrono::milliseconds key_value_timeout) -> std::chrono::milliseconds
+{
+  const auto remaining_ms = std::chrono::duration_cast<std::chrono::milliseconds>(remaining);
+  if (remaining_ms < std::chrono::milliseconds{ 1 }) {
+    return std::chrono::milliseconds{ 1 };
+  }
+  return std::min(remaining_ms, key_value_timeout);
+}
+
+/**
+ * True when a fetched document is a read-skew victim (spec "Read skew resolution", T1 COMMITTED): a
+ * document we fetched that is NOT part of T1 -- it carries no transactional metadata, or belongs to
+ * a different attempt -- yet which T1's ATR entry records as mutated (inserted/replaced/removed).
+ * Such a document was read before T1 committed and must be re-fetched for a consistent snapshot.
+ */
+[[nodiscard]] inline auto
+contains_mutation(const std::optional<std::vector<doc_record>>& mutated_ids,
+                  const core::document_id& id) -> bool
+{
+  if (!mutated_ids) {
+    return false;
+  }
+  return std::any_of(mutated_ids->begin(), mutated_ids->end(), [&id](const auto& mutation) {
+    return mutation == id;
+  });
+}
+
+[[nodiscard]] inline auto
+is_read_skew_victim(bool doc_exists,
+                    const std::optional<transaction_id>& doc_transaction_id,
+                    const std::string& t1_attempt_id,
+                    const core::document_id& id,
+                    const std::optional<std::vector<doc_record>>& t1_inserted_ids,
+                    const std::optional<std::vector<doc_record>>& t1_replaced_ids,
+                    const std::optional<std::vector<doc_record>>& t1_removed_ids) -> bool
+{
+  if (!doc_exists) {
+    return false;
+  }
+  const bool fetched_as_part_of_t1 =
+    doc_transaction_id.has_value() && doc_transaction_id->attempt == t1_attempt_id;
+  if (fetched_as_part_of_t1) {
+    return false;
+  }
+  return contains_mutation(t1_inserted_ids, id) || contains_mutation(t1_replaced_ids, id) ||
+         contains_mutation(t1_removed_ids, id);
+}
+} // namespace couchbase::core::transactions