couchbase 3.8.1 → 3.9.0

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,
@@ -289,7 +292,11 @@ private:
           err.cause(TRANSACTION_ALREADY_COMMITTED);
           break;
         default:
-          err.cause(UNKNOWN);
+          // Ops are only blocked once commit or rollback has begun (wait_and_block_ops), but the
+          // attempt state is published later -- and the empty-commit fast path never reaches
+          // COMMITTED at all. So a racing op can land here with the state still PENDING: report it
+          // as a concurrent operation rather than an opaque unknown cause.
+          err.cause(CONCURRENT_OPERATIONS_DETECTED_ON_SAME_DOCUMENT);
       }
       op_completed_with_error_no_cache(std::forward<Handler>(cb), std::make_exception_ptr(err));
     } catch (const transaction_operation_failed& e) {
@@ -457,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;
 
@@ -479,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>
@@ -509,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>,
@@ -536,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