couchbase 3.5.6 → 3.6.0

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

@@ -24,11 +24,20 @@
 #include "attempt_state.hxx"
 #include "internal/atr_cleanup_entry.hxx"
 #include "internal/exceptions_internal.hxx"
+#include "transaction_get_multi_mode.hxx"
 #include "transaction_get_result.hxx"
 
+// TODO(SA): do not mix public and core APIs in the single class
+#include <chrono>
 #include <couchbase/codec/encoded_value.hxx>
 #include <couchbase/transactions/async_attempt_context.hxx>
 #include <couchbase/transactions/attempt_context.hxx>
+#include <couchbase/transactions/transaction_get_multi_options.hxx>
+#include <couchbase/transactions/transaction_get_multi_replicas_from_preferred_server_group_options.hxx>
+#include <couchbase/transactions/transaction_get_multi_replicas_from_preferred_server_group_result.hxx>
+#include <couchbase/transactions/transaction_get_multi_replicas_from_preferred_server_group_spec.hxx>
+#include <couchbase/transactions/transaction_get_multi_result.hxx>
+#include <couchbase/transactions/transaction_get_multi_spec.hxx>
 #include <couchbase/transactions/transaction_query_options.hxx>
 
 #include <cstdint>
@@ -62,7 +71,7 @@ namespace transactions
  * insert and delete documents, as well as commit or rollback the transaction.
  */
 class transactions;
-enum class forward_compat_stage;
+enum class forward_compat_stage : std::uint8_t;
 class staged_mutation_queue;
 class staged_mutation;
 struct attempt_context_testing_hooks;
@@ -96,15 +105,15 @@ private:
               codec::encoded_value content,
               core::transactions::async_attempt_context::Callback&& cb) override;
 
-  auto insert(const core::document_id& id,
-              codec::encoded_value content) -> core::transactions::transaction_get_result override;
+  auto insert(const core::document_id& id, codec::encoded_value content)
+    -> core::transactions::transaction_get_result override;
 
   void replace(const transaction_get_result& document,
                codec::encoded_value content,
                core::transactions::async_attempt_context::Callback&& cb) override;
 
-  auto replace(const transaction_get_result& document,
-               codec::encoded_value content) -> transaction_get_result override;
+  auto replace(const transaction_get_result& document, codec::encoded_value content)
+    -> transaction_get_result override;
 
   auto insert_raw(const collection& coll, const std::string& id, codec::encoded_value content)
     -> std::pair<couchbase::error, couchbase::transactions::transaction_get_result> override;
@@ -159,12 +168,24 @@ private:
 
   void handle_err_from_callback(const std::exception_ptr& e);
 
+  template<typename Cb, typename E, typename T>
+  void op_completed_with_callback(Cb&& cb, E e, std::optional<T> t)
+  {
+    try {
+      op_list_.decrement_in_flight();
+      std::forward<Cb>(cb)(std::make_exception_ptr(std::forward<E>(e)), t);
+      op_list_.decrement_ops();
+    } catch (...) {
+      handle_err_from_callback(std::current_exception());
+    }
+  }
+
   template<typename Cb, typename T>
   void op_completed_with_callback(Cb&& cb, std::optional<T> t)
   {
     try {
       op_list_.decrement_in_flight();
-      cb({}, t);
+      std::forward<Cb>(cb)({}, t);
       op_list_.decrement_ops();
     } catch (...) {
       handle_err_from_callback(std::current_exception());
@@ -176,7 +197,7 @@ private:
   {
     try {
       op_list_.decrement_in_flight();
-      cb({});
+      std::forward<Cb>(cb)({});
       op_list_.decrement_ops();
     } catch (...) {
       handle_err_from_callback(std::current_exception());
@@ -237,7 +258,7 @@ private:
   void op_completed_with_error_no_cache(VoidCallback cb, std::exception_ptr err)
   {
     try {
-      cb(err);
+      cb(std::move(err));
     } catch (...) {
       // just eat it.
     }
@@ -285,11 +306,12 @@ private:
     }
   }
 
-  [[nodiscard]] auto cluster_ref() const -> const core::cluster&;
-
   explicit attempt_context_impl(const std::shared_ptr<transaction_context>& transaction_ctx);
 
 public:
+  [[nodiscard]] auto cluster_ref() const -> const core::cluster&;
+  [[nodiscard]] auto expiry_time() const -> std::chrono::steady_clock::time_point;
+
   static auto create(const std::shared_ptr<transaction_context>& transaction_ctx)
     -> std::shared_ptr<attempt_context_impl>;
 
@@ -327,6 +349,56 @@ public:
     const std::string& id,
     couchbase::transactions::async_result_handler&& handler) override;
 
+  auto get_multi(const std::vector<core::document_id>& ids, transaction_get_multi_mode mode)
+    -> transaction_get_multi_result override;
+  void get_multi(const std::vector<core::document_id>& ids,
+                 transaction_get_multi_mode mode,
+                 std::function<void(std::exception_ptr,
+                                    std::optional<transaction_get_multi_result>)>&& cb) override;
+  auto get_multi(const std::vector<couchbase::transactions::transaction_get_multi_spec>& specs,
+                 const couchbase::transactions::transaction_get_multi_options& options)
+    -> std::pair<error,
+                 std::optional<couchbase::transactions::transaction_get_multi_result>> override;
+  void get_multi(
+    const std::vector<couchbase::transactions::transaction_get_multi_spec>& specs,
+    const couchbase::transactions::transaction_get_multi_options& options,
+    std::function<void(error,
+                       std::optional<couchbase::transactions::transaction_get_multi_result>)>&& cb)
+    override;
+
+  auto get_multi_replicas_from_preferred_server_group(
+    const std::vector<core::document_id>& ids,
+    transaction_get_multi_replicas_from_preferred_server_group_mode mode)
+    -> transaction_get_multi_replicas_from_preferred_server_group_result override;
+  void get_multi_replicas_from_preferred_server_group(
+    const std::vector<core::document_id>& ids,
+    transaction_get_multi_replicas_from_preferred_server_group_mode mode,
+    std::function<
+      void(std::exception_ptr,
+           std::optional<transaction_get_multi_replicas_from_preferred_server_group_result>)>&& cb)
+    override;
+  auto get_multi_replicas_from_preferred_server_group(
+    const std::vector<
+      couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_spec>&
+      specs,
+    const couchbase::transactions::
+      transaction_get_multi_replicas_from_preferred_server_group_options& options)
+    -> std::pair<
+      error,
+      std::optional<couchbase::transactions::
+                      transaction_get_multi_replicas_from_preferred_server_group_result>> override;
+  void get_multi_replicas_from_preferred_server_group(
+    const std::vector<
+      couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_spec>&
+      specs,
+    const couchbase::transactions::
+      transaction_get_multi_replicas_from_preferred_server_group_options& options,
+    std::function<void(
+      error,
+      std::optional<couchbase::transactions::
+                      transaction_get_multi_replicas_from_preferred_server_group_result>)>&& cb)
+    override;
+
   void remove(const transaction_get_result& document) override;
   auto remove(const couchbase::transactions::transaction_get_result& doc)
     -> couchbase::error override;
@@ -438,6 +510,7 @@ private:
   void get_doc(const core::document_id& id,
                bool allow_replica,
                std::function<void(std::optional<error_class>,
+                                  std::optional<external_exception>,
                                   std::optional<std::string>,
                                   std::optional<transaction_get_result>)>&& cb);
 
@@ -455,9 +528,12 @@ private:
                             Handler&& cb);
 
   template<typename Handler>
-  void create_staged_replace(const transaction_get_result& document,
+  void create_staged_replace(const document_id& id,
                              codec::encoded_value content,
+                             std::uint32_t original_flags,
+                             const couchbase::cas& cas,
                              const std::string& op_id,
+                             const std::optional<document_metadata>& document_metadata,
                              Handler&& cb);
 
   template<typename Handler, typename Delay>
@@ -472,7 +548,10 @@ private:
                                           const std::string& message);
 
   void ensure_open_bucket(const std::string& bucket_name,
-                          std::function<void(std::error_code)>&& handler);
+                          std::function<void(std::error_code)>&& handler) const;
+
+  void supports_replace_body_with_xattr(const std::string& bucket_name,
+                                        std::function<void(std::error_code, bool)>&& handler) const;
 };
 
 } // namespace transactions

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

@@ -17,6 +17,7 @@
 #include "internal/transaction_context.hxx"
 
 #include "exceptions.hxx"
+#include "exceptions_fmt.hxx"
 
 namespace couchbase::core::transactions
 {
@@ -156,6 +157,8 @@ transaction_op_errc_from_external_exception(external_exception e) -> errc::trans
       return errc::transaction_op::transaction_already_aborted;
     case external_exception::TRANSACTION_ALREADY_COMMITTED:
       return errc::transaction_op::transaction_already_committed;
+    case external_exception::DOCUMENT_UNRETRIEVABLE_EXCEPTION:
+      return errc::transaction_op::document_unretrievable;
   }
   return errc::transaction_op::generic;
 }
@@ -204,6 +207,8 @@ external_exception_from_transaction_op_errc(errc::transaction_op ec) -> external
       return external_exception::TRANSACTION_ALREADY_ABORTED;
     case errc::transaction_op::transaction_already_committed:
       return external_exception::TRANSACTION_ALREADY_COMMITTED;
+    case errc::transaction_op::document_unretrievable:
+      return external_exception::DOCUMENT_UNRETRIEVABLE_EXCEPTION;
     default:
       return external_exception::UNKNOWN;
   }

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

@@ -63,6 +63,7 @@ enum external_exception {
   ROLLBACK_NOT_PERMITTED,
   TRANSACTION_ALREADY_ABORTED,
   TRANSACTION_ALREADY_COMMITTED,
+  DOCUMENT_UNRETRIEVABLE_EXCEPTION,
 };
 
 auto
@@ -151,6 +152,12 @@ public:
     return { ec, transaction_op_errc_from_external_exception(cause_) };
   }
 };
+
+/**
+ * op_exception represents errors raised from transactions operations that are _not_ wrapped in a
+ * transaction_operation_failed. They might be wrapped in a transaction_operation_failed eventually,
+ * or they might be raised directly from the lambda.
+ */
 class op_exception : public std::runtime_error
 {
 private:
@@ -166,6 +173,15 @@ public:
   {
   }
 
+  explicit op_exception(transaction_op_error_context ctx,
+                        const std::string& what,
+                        external_exception cause = COUCHBASE_EXCEPTION)
+    : std::runtime_error(what)
+    , cause_(cause)
+    , ctx_(std::move(ctx))
+  {
+  }
+
   /**
    * For converting from Public API error (for errors propagated from lambda)
    */
@@ -178,6 +194,10 @@ public:
 
   [[nodiscard]] auto cause() const -> external_exception
   {
+    // TODO(DC): This doesn't appear to be a 'cause' in the sense that we use it elsewhere, but more
+    // like the 'external_exception' equivalent of the error code inside the ctx. We should probably
+    // rename this or simplify this class. This is used to set the 'cause' field of
+    // transaction_operation_failed.
     return cause_;
   }
 

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

@@ -99,6 +99,9 @@ struct fmt::formatter<couchbase::core::transactions::external_exception> {
       case couchbase::core::transactions::TRANSACTION_ALREADY_COMMITTED:
         name = "TRANSACTION_ALREADY_COMMITTED";
         break;
+      case couchbase::core::transactions::DOCUMENT_UNRETRIEVABLE_EXCEPTION:
+        name = "DOCUMENT_UNRETRIEVABLE_EXCEPTION";
+        break;
     }
     return format_to(ctx.out(), "{}", name);
   }

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

@@ -127,19 +127,19 @@ auto
 create_forward_compat_stage(const std::string& str) -> forward_compat_stage
 {
   if (str == "WW_R") {
-    return forward_compat_stage::WWC_READING_ATR;
+    return forward_compat_stage::WRITE_WRITE_CONFLICT_READING_ATR;
   }
   if (str == "WW_RP") {
-    return forward_compat_stage::WWC_REPLACING;
+    return forward_compat_stage::WRITE_WRITE_CONFLICT_REPLACING;
   }
   if (str == "WW_RM") {
-    return forward_compat_stage::WWC_REMOVING;
+    return forward_compat_stage::WRITE_WRITE_CONFLICT_REMOVING;
   }
   if (str == "WW_I") {
-    return forward_compat_stage::WWC_INSERTING;
+    return forward_compat_stage::WRITE_WRITE_CONFLICT_INSERTING;
   }
   if (str == "WW_IG") {
-    return forward_compat_stage::WWC_INSERTING_GET;
+    return forward_compat_stage::WRITE_WRITE_CONFLICT_INSERTING_GET;
   }
   if (str == "G") {
     return forward_compat_stage::GETS;
@@ -150,7 +150,19 @@ create_forward_compat_stage(const std::string& str) -> forward_compat_stage
   if (str == "CL_E") {
     return forward_compat_stage::CLEANUP_ENTRY;
   }
-  throw std::runtime_error("Unknown forward compatibility stage");
+  if (str == "CM_C") {
+    return forward_compat_stage::CAS_MISMATCH_DURING_COMMIT;
+  }
+  if (str == "CM_R") {
+    return forward_compat_stage::CAS_MISMATCH_DURING_ROLLBACK;
+  }
+  if (str == "CM_S") {
+    return forward_compat_stage::CAS_MISMATCH_DURING_STAGING;
+  }
+  if (str == "GM_G") {
+    return forward_compat_stage::GET_MULTI_GET;
+  }
+  throw std::runtime_error(fmt::format("Unknown forward compatibility stage: {}", str));
 }
 
 class forward_compat
@@ -228,4 +240,57 @@ check_forward_compat(forward_compat_stage stage, std::optional<tao::json::value>
   return std::nullopt;
 }
 
+auto
+to_string(forward_compat_stage value) -> std::string
+{
+  switch (value) {
+    case forward_compat_stage::WRITE_WRITE_CONFLICT_READING_ATR:
+      return "WW_R";
+    case forward_compat_stage::WRITE_WRITE_CONFLICT_REPLACING:
+      return "WW_RP";
+    case forward_compat_stage::WRITE_WRITE_CONFLICT_REMOVING:
+      return "WW_RM";
+    case forward_compat_stage::WRITE_WRITE_CONFLICT_INSERTING:
+      return "WW_I";
+    case forward_compat_stage::WRITE_WRITE_CONFLICT_INSERTING_GET:
+      return "WW_IG";
+    case forward_compat_stage::GETS:
+      return "G";
+    case forward_compat_stage::GETS_READING_ATR:
+      return "G_A";
+    case forward_compat_stage::CLEANUP_ENTRY:
+      return "CL_E";
+    case forward_compat_stage::CAS_MISMATCH_DURING_COMMIT:
+      return "CM_C";
+    case forward_compat_stage::CAS_MISMATCH_DURING_ROLLBACK:
+      return "CM_R";
+    case forward_compat_stage::CAS_MISMATCH_DURING_STAGING:
+      return "CM_S";
+    case forward_compat_stage::GET_MULTI_GET:
+      return "GM_G";
+  };
+  throw std::runtime_error(
+    fmt::format("Unknown forward compatibility stage: {}", static_cast<std::uint8_t>(value)));
+}
+auto
+create_forward_compat_behavior(const std::string& str) -> forward_compat_behavior
+{
+  if (str == "r") {
+    return forward_compat_behavior::RETRY_TXN;
+  }
+  return forward_compat_behavior::FAIL_FAST_TXN;
+}
+auto
+forward_compat_behavior_name(forward_compat_behavior b) -> const char*
+{
+  switch (b) {
+    case forward_compat_behavior::CONTINUE:
+      return "CONTINUE";
+    case forward_compat_behavior::RETRY_TXN:
+      return "RETRY_TXN";
+    case forward_compat_behavior::FAIL_FAST_TXN:
+      return "FAIL_FAST_TRANSACTION";
+  }
+  return "unknown behavior";
+}
 } // namespace couchbase::core::transactions

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

@@ -16,91 +16,77 @@
 #pragma once
 
 #include "internal/exceptions_internal.hxx"
+
 #include <cstdint>
-#include <list>
 #include <optional>
-#include <stdexcept>
 #include <string>
+#include <vector>
 
 namespace couchbase::core::transactions
 {
-// TODO(SA): rename using long and human-readable names
-enum class forward_compat_stage {
-  WWC_READING_ATR,
-  WWC_REPLACING,
-  WWC_REMOVING,
-  WWC_INSERTING,
-  WWC_INSERTING_GET,
+enum class forward_compat_stage : std::uint8_t {
+  WRITE_WRITE_CONFLICT_READING_ATR,
+  WRITE_WRITE_CONFLICT_REPLACING,
+  WRITE_WRITE_CONFLICT_REMOVING,
+  WRITE_WRITE_CONFLICT_INSERTING,
+  WRITE_WRITE_CONFLICT_INSERTING_GET,
   GETS,
   GETS_READING_ATR,
-  CLEANUP_ENTRY
+  CLEANUP_ENTRY,
+  CAS_MISMATCH_DURING_COMMIT,
+  CAS_MISMATCH_DURING_ROLLBACK,
+  CAS_MISMATCH_DURING_STAGING,
+  GET_MULTI_GET,
 };
 
-inline auto
-to_string(forward_compat_stage value) -> const char*
-{
-  switch (value) {
-    case forward_compat_stage::WWC_READING_ATR:
-      return "WW_R";
-    case forward_compat_stage::WWC_REPLACING:
-      return "WW_RP";
-    case forward_compat_stage::WWC_REMOVING:
-      return "WW_RM";
-    case forward_compat_stage::WWC_INSERTING:
-      return "WW_I";
-    case forward_compat_stage::WWC_INSERTING_GET:
-      return "WW_IG";
-    case forward_compat_stage::GETS:
-      return "G";
-    case forward_compat_stage::GETS_READING_ATR:
-      return "G_A";
-    case forward_compat_stage::CLEANUP_ENTRY:
-      return "CL_E";
-  };
-  throw std::runtime_error("Unknown forward compatibility stage");
-}
+auto
+to_string(forward_compat_stage value) -> std::string;
 
-enum class forward_compat_behavior {
+enum class forward_compat_behavior : std::uint8_t {
   CONTINUE,
   RETRY_TXN,
   FAIL_FAST_TXN
 };
 
-inline auto
-create_forward_compat_behavior(const std::string& str) -> forward_compat_behavior
-{
-  if (str == "r") {
-    return forward_compat_behavior::RETRY_TXN;
-  }
-  return forward_compat_behavior::FAIL_FAST_TXN;
-}
+auto
+create_forward_compat_behavior(const std::string& str) -> forward_compat_behavior;
 
 // used only for logging
-inline auto
-forward_compat_behavior_name(forward_compat_behavior b) -> const char*
-{
-  switch (b) {
-    case forward_compat_behavior::CONTINUE:
-      return "CONTINUE";
-    case forward_compat_behavior::RETRY_TXN:
-      return "RETRY_TXN";
-    case forward_compat_behavior::FAIL_FAST_TXN:
-      return "FAIL_FAST_TRANSACTION";
-  }
-  return "unknown behavior";
-}
+auto
+forward_compat_behavior_name(forward_compat_behavior b) -> const char*;
 
 struct forward_compat_supported {
   std::uint32_t protocol_major = 2;
   std::uint32_t protocol_minor = 0;
   std::list<std::string> extensions{
-    "TI", "MO",     "BM", "QU", "SD", "BF3787", "BF3705", "BF3838", "RC", "UA",
-    "CO", "BF3791", "CM", "SI", "QC", "IX",     "TS",     "PU",     "BS", "RP",
+    "BF3705", // BF-CBD-3705
+    "BF3787", // BF-CBD-3787
+    "BF3791", // BF-CBD-3791
+    "BF3838", // BF-CBD-3838
+    "BM",     // ExtBinaryMetadata
+    "BS",     // ExtBinarySupport
+    "CM",     // ExtCustomMetadataCollection
+    "CO",     // ExtAllKVCombinations
+    "IX",     // ExtInsertExisting
+    "MO",     // ExtMemoryOptUnstaging
+    "PU",     // ExtParallelUnstaging
+    "QC",     // ExtQueryContext
+    "QU",     // ExtQuery
+    "RC",     // ExtRemoveCompleted
+    "RP",     // ExtReplicaFromPreferredGroup
+    "RX",     // ExtReplaceBodyWithXattr
+    "SD",     // ExtStoreDurability
+    "SI",     // ExtSDKIntegration
+    "TI",     // ExtTransactionId
+    "TS",     // ExtThreadSafety
+    "UA",     // ExtUnknownATRStates
+    "GM",     // ExtGetMulti
   };
 };
 
 class transaction_operation_failed;
 
-std::optional<transaction_operation_failed>
-check_forward_compat(forward_compat_stage stage, std::optional<tao::json::value> json);
+auto
+check_forward_compat(forward_compat_stage stage, std::optional<tao::json::value> json)
+  -> std::optional<transaction_operation_failed>;
 } // namespace couchbase::core::transactions