couchbase 3.5.1 → 3.5.2

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

@@ -16,12 +16,15 @@
 
 #pragma once
 
-#include "core/error_context/query.hxx"
 #include "error_class.hxx"
 
+#include <couchbase/error.hxx>
 #include <couchbase/error_codes.hxx>
 #include <couchbase/transactions/transaction_result.hxx>
 
+#include "core/error_context/transaction_error_context.hxx"
+#include "core/error_context/transaction_op_error_context.hxx"
+
 #include <stdexcept>
 #include <utility>
 
@@ -31,182 +34,210 @@ namespace couchbase::core::transactions
  */
 class transaction_context;
 
-enum class failure_type { FAIL, EXPIRY, COMMIT_AMBIGUOUS };
+enum class failure_type {
+  FAIL,
+  EXPIRY,
+  COMMIT_AMBIGUOUS
+};
 
 enum external_exception {
-    UNKNOWN = 0,
-    ACTIVE_TRANSACTION_RECORD_ENTRY_NOT_FOUND,
-    ACTIVE_TRANSACTION_RECORD_FULL,
-    ACTIVE_TRANSACTION_RECORD_NOT_FOUND,
-    DOCUMENT_ALREADY_IN_TRANSACTION,
-    DOCUMENT_EXISTS_EXCEPTION,
-    DOCUMENT_NOT_FOUND_EXCEPTION,
-    NOT_SET,
-    FEATURE_NOT_AVAILABLE_EXCEPTION,
-    TRANSACTION_ABORTED_EXTERNALLY,
-    PREVIOUS_OPERATION_FAILED,
-    FORWARD_COMPATIBILITY_FAILURE,
-    PARSING_FAILURE,
-    ILLEGAL_STATE_EXCEPTION,
-    COUCHBASE_EXCEPTION,
-    SERVICE_NOT_AVAILABLE_EXCEPTION,
-    REQUEST_CANCELED_EXCEPTION,
-    CONCURRENT_OPERATIONS_DETECTED_ON_SAME_DOCUMENT,
-    COMMIT_NOT_PERMITTED,
-    ROLLBACK_NOT_PERMITTED,
-    TRANSACTION_ALREADY_ABORTED,
-    TRANSACTION_ALREADY_COMMITTED,
+  UNKNOWN = 0,
+  ACTIVE_TRANSACTION_RECORD_ENTRY_NOT_FOUND,
+  ACTIVE_TRANSACTION_RECORD_FULL,
+  ACTIVE_TRANSACTION_RECORD_NOT_FOUND,
+  DOCUMENT_ALREADY_IN_TRANSACTION,
+  DOCUMENT_EXISTS_EXCEPTION,
+  DOCUMENT_NOT_FOUND_EXCEPTION,
+  NOT_SET,
+  FEATURE_NOT_AVAILABLE_EXCEPTION,
+  TRANSACTION_ABORTED_EXTERNALLY,
+  PREVIOUS_OPERATION_FAILED,
+  FORWARD_COMPATIBILITY_FAILURE,
+  PARSING_FAILURE,
+  ILLEGAL_STATE_EXCEPTION,
+  COUCHBASE_EXCEPTION,
+  SERVICE_NOT_AVAILABLE_EXCEPTION,
+  REQUEST_CANCELED_EXCEPTION,
+  CONCURRENT_OPERATIONS_DETECTED_ON_SAME_DOCUMENT,
+  COMMIT_NOT_PERMITTED,
+  ROLLBACK_NOT_PERMITTED,
+  TRANSACTION_ALREADY_ABORTED,
+  TRANSACTION_ALREADY_COMMITTED,
 };
 
-couchbase::errc::transaction_op
-transaction_op_errc_from_external_exception(external_exception e);
+auto
+transaction_op_errc_from_external_exception(external_exception e)
+  -> couchbase::errc::transaction_op;
+
+auto
+external_exception_from_transaction_op_errc(couchbase::errc::transaction_op ec)
+  -> external_exception;
 
-couchbase::core::transactions::error_class
-error_class_from_external_exception(external_exception e);
+auto
+error_class_from_external_exception(external_exception e)
+  -> couchbase::core::transactions::error_class;
 
 /**
- * @brief Base class for all exceptions expected to be raised from a transaction.
+ * @brief Base class for all exceptions expected to be raised from a
+ * transaction.
  *
- * Subclasses of this are the only exceptions that are raised out of the transaction lambda.
+ * Subclasses of this are the only exceptions that are raised out of the
+ * transaction lambda.
  */
 class transaction_exception : public std::runtime_error
 {
-  private:
-    couchbase::transactions::transaction_result result_;
-    external_exception cause_;
-    failure_type type_;
-    std::string txn_id_;
-
-  public:
-    /**
-     * @brief Construct from underlying exception.
-     *
-     * @param cause Underlying cause for this exception.
-     * @param context The internal state of the transaction at the time of the exception.
-     */
-    explicit transaction_exception(const std::runtime_error& cause, const transaction_context& context, failure_type type);
-
-    /**
-     * @brief Internal state of transaction at time of exception
-     *
-     * @returns Internal state of transaction.
-     */
-    std::pair<couchbase::transaction_error_context, couchbase::transactions::transaction_result> get_transaction_result() const
-    {
-        return { error_context(), { result_.transaction_id, result_.unstaging_complete } };
-    }
-
-    /**
-     * @brief The cause of the exception
-     *
-     * @returns The underlying cause for this exception.
-     */
-    external_exception cause() const
-    {
-        return cause_;
-    }
-    /**
-     * @brief The type of the exception - see @ref failure_type
-     * @return The failure type.
-     */
-    failure_type type() const
-    {
-        return type_;
-    }
-
-    [[nodiscard]] transaction_error_context error_context() const
-    {
-        std::error_code ec{};
-        switch (type_) {
-            case failure_type::FAIL:
-                ec = errc::transaction::failed;
-                break;
-            case failure_type::EXPIRY:
-                ec = errc::transaction::expired;
-                break;
-            case failure_type::COMMIT_AMBIGUOUS:
-                ec = errc::transaction::ambiguous;
-                break;
-        }
-        return { ec, transaction_op_errc_from_external_exception(cause_) };
+private:
+  couchbase::transactions::transaction_result result_;
+  external_exception cause_;
+  failure_type type_;
+  std::string txn_id_;
+
+public:
+  /**
+   * @brief Construct from underlying exception.
+   *
+   * @param cause Underlying cause for this exception.
+   * @param context The internal state of the transaction at the time of the
+   * exception.
+   */
+  explicit transaction_exception(const std::runtime_error& cause,
+                                 const transaction_context& context,
+                                 failure_type type);
+
+  /**
+   * @brief Internal state of transaction at time of exception
+   *
+   * @returns Internal state of transaction.
+   */
+  [[nodiscard]] auto get_transaction_result() const
+    -> std::pair<couchbase::core::transaction_error_context,
+                 couchbase::transactions::transaction_result>
+  {
+    return { error_context(), { result_.transaction_id, result_.unstaging_complete } };
+  }
+
+  /**
+   * @brief The cause of the exception
+   *
+   * @returns The underlying cause for this exception.
+   */
+  [[nodiscard]] auto cause() const -> external_exception
+  {
+    return cause_;
+  }
+  /**
+   * @brief The type of the exception - see @ref failure_type
+   * @return The failure type.
+   */
+  [[nodiscard]] auto type() const -> failure_type
+  {
+    return type_;
+  }
+
+  [[nodiscard]] auto error_context() const -> transaction_error_context
+  {
+    std::error_code ec{};
+    switch (type_) {
+      case failure_type::FAIL:
+        ec = errc::transaction::failed;
+        break;
+      case failure_type::EXPIRY:
+        ec = errc::transaction::expired;
+        break;
+      case failure_type::COMMIT_AMBIGUOUS:
+        ec = errc::transaction::ambiguous;
+        break;
     }
+    return { ec, transaction_op_errc_from_external_exception(cause_) };
+  }
 };
 class op_exception : public std::runtime_error
 {
-  private:
-    external_exception cause_;
-    transaction_op_error_context ctx_;
-
-  public:
-    explicit op_exception(transaction_op_error_context ctx, external_exception cause = COUCHBASE_EXCEPTION)
-      : std::runtime_error(ctx.ec().message())
-      , cause_(cause)
-      , ctx_(std::move(ctx))
-    {
-    }
-
-    [[nodiscard]] external_exception cause() const
-    {
-        return cause_;
-    }
-
-    [[nodiscard]] const transaction_op_error_context& ctx() const
-    {
-        return ctx_;
-    }
+private:
+  external_exception cause_;
+  transaction_op_error_context ctx_;
+
+public:
+  explicit op_exception(transaction_op_error_context ctx,
+                        external_exception cause = COUCHBASE_EXCEPTION)
+    : std::runtime_error(ctx.ec().message())
+    , cause_(cause)
+    , ctx_(std::move(ctx))
+  {
+  }
+
+  /**
+   * For converting from Public API error (for errors propagated from lambda)
+   */
+  explicit op_exception(couchbase::error err)
+    : std::runtime_error(err.ec().message())
+    , cause_{ external_exception_from_transaction_op_errc(errc::transaction_op(err.ec().value())) }
+    , ctx_{ err.ec() }
+  {
+  }
+
+  [[nodiscard]] auto cause() const -> external_exception
+  {
+    return cause_;
+  }
+
+  [[nodiscard]] auto ctx() const -> const transaction_op_error_context&
+  {
+    return ctx_;
+  }
 };
 
 class document_not_found : public op_exception
 {
-  public:
-    explicit document_not_found(transaction_op_error_context ctx)
-      : op_exception(std::move(ctx), DOCUMENT_NOT_FOUND_EXCEPTION)
-    {
-    }
+public:
+  explicit document_not_found(transaction_op_error_context ctx)
+    : op_exception(std::move(ctx), DOCUMENT_NOT_FOUND_EXCEPTION)
+  {
+  }
 };
 
 class document_exists : public op_exception
 {
-  public:
-    explicit document_exists(transaction_op_error_context ctx)
-      : op_exception(std::move(ctx), DOCUMENT_EXISTS_EXCEPTION)
-    {
-    }
+public:
+  explicit document_exists(transaction_op_error_context ctx)
+    : op_exception(std::move(ctx), DOCUMENT_EXISTS_EXCEPTION)
+  {
+  }
 };
 
 class query_attempt_not_found : public op_exception
 {
-  public:
-    query_attempt_not_found(transaction_op_error_context ctx)
-      : op_exception(std::move(ctx))
-    {
-    }
+public:
+  query_attempt_not_found(transaction_op_error_context ctx)
+    : op_exception(std::move(ctx))
+  {
+  }
 };
 
 class query_cas_mismatch : public op_exception
 {
-  public:
-    query_cas_mismatch(transaction_op_error_context ctx)
-      : op_exception(std::move(ctx))
-    {
-    }
+public:
+  query_cas_mismatch(transaction_op_error_context ctx)
+    : op_exception(std::move(ctx))
+  {
+  }
 };
 
 class query_attempt_expired : public op_exception
 {
-  public:
-    query_attempt_expired(transaction_op_error_context ctx)
-      : op_exception(std::move(ctx))
-    {
-    }
+public:
+  query_attempt_expired(transaction_op_error_context ctx)
+    : op_exception(std::move(ctx))
+  {
+  }
 };
 
 class query_parsing_failure : public op_exception
 {
-  public:
-    query_parsing_failure(transaction_op_error_context ctx)
-      : op_exception(std::move(ctx), PARSING_FAILURE)
-    {
-    }
+public:
+  query_parsing_failure(transaction_op_error_context ctx)
+    : op_exception(std::move(ctx), PARSING_FAILURE)
+  {
+  }
 };
 } // namespace couchbase::core::transactions

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

@@ -0,0 +1,105 @@
+/*
+ *     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 "exceptions.hxx"
+
+#include <fmt/core.h>
+
+template<>
+struct fmt::formatter<couchbase::core::transactions::external_exception> {
+  template<typename ParseContext>
+  constexpr auto parse(ParseContext& ctx)
+  {
+    return ctx.begin();
+  }
+
+  template<typename FormatContext>
+  auto format(couchbase::core::transactions::external_exception ec, FormatContext& ctx) const
+  {
+    string_view name = "<UNKNOWN EXTERNAL EXCEPTION>";
+    switch (ec) {
+      case couchbase::core::transactions::UNKNOWN:
+        name = "UNKNOWN";
+        break;
+      case couchbase::core::transactions::ACTIVE_TRANSACTION_RECORD_ENTRY_NOT_FOUND:
+        name = "ACTIVE_TRANSACTION_RECORD_ENTRY_NOT_FOUND";
+        break;
+      case couchbase::core::transactions::ACTIVE_TRANSACTION_RECORD_FULL:
+        name = "ACTIVE_TRANSACTION_RECORD_FULL";
+        break;
+      case couchbase::core::transactions::ACTIVE_TRANSACTION_RECORD_NOT_FOUND:
+        name = "ACTIVE_TRANSACTION_RECORD_NOT_FOUND";
+        break;
+      case couchbase::core::transactions::DOCUMENT_ALREADY_IN_TRANSACTION:
+        name = "DOCUMENT_ALREADY_IN_TRANSACTION";
+        break;
+      case couchbase::core::transactions::DOCUMENT_EXISTS_EXCEPTION:
+        name = "DOCUMENT_EXISTS_EXCEPTION";
+        break;
+      case couchbase::core::transactions::DOCUMENT_NOT_FOUND_EXCEPTION:
+        name = "DOCUMENT_NOT_FOUND_EXCEPTION";
+        break;
+      case couchbase::core::transactions::NOT_SET:
+        name = "NOT_SET";
+        break;
+      case couchbase::core::transactions::FEATURE_NOT_AVAILABLE_EXCEPTION:
+        name = "FEATURE_NOT_AVAILABLE_EXCEPTION";
+        break;
+      case couchbase::core::transactions::TRANSACTION_ABORTED_EXTERNALLY:
+        name = "TRANSACTION_ABORTED_EXTERNALLY";
+        break;
+      case couchbase::core::transactions::PREVIOUS_OPERATION_FAILED:
+        name = "PREVIOUS_OPERATION_FAILED";
+        break;
+      case couchbase::core::transactions::FORWARD_COMPATIBILITY_FAILURE:
+        name = "FORWARD_COMPATIBILITY_FAILURE";
+        break;
+      case couchbase::core::transactions::PARSING_FAILURE:
+        name = "PARSING_FAILURE";
+        break;
+      case couchbase::core::transactions::ILLEGAL_STATE_EXCEPTION:
+        name = "ILLEGAL_STATE_EXCEPTION";
+        break;
+      case couchbase::core::transactions::COUCHBASE_EXCEPTION:
+        name = "COUCHBASE_EXCEPTION";
+        break;
+      case couchbase::core::transactions::SERVICE_NOT_AVAILABLE_EXCEPTION:
+        name = "SERVICE_NOT_AVAILABLE_EXCEPTION";
+        break;
+      case couchbase::core::transactions::REQUEST_CANCELED_EXCEPTION:
+        name = "REQUEST_CANCELED_EXCEPTION";
+        break;
+      case couchbase::core::transactions::CONCURRENT_OPERATIONS_DETECTED_ON_SAME_DOCUMENT:
+        name = "CONCURRENT_OPERATIONS_DETECTED_ON_SAME_DOCUMENT";
+        break;
+      case couchbase::core::transactions::COMMIT_NOT_PERMITTED:
+        name = "COMMIT_NOT_PERMITTED";
+        break;
+      case couchbase::core::transactions::ROLLBACK_NOT_PERMITTED:
+        name = "ROLLBACK_NOT_PERMITTED";
+        break;
+      case couchbase::core::transactions::TRANSACTION_ALREADY_ABORTED:
+        name = "TRANSACTION_ALREADY_ABORTED";
+        break;
+      case couchbase::core::transactions::TRANSACTION_ALREADY_COMMITTED:
+        name = "TRANSACTION_ALREADY_COMMITTED";
+        break;
+    }
+    return format_to(ctx.out(), "{}", name);
+  }
+};

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

@@ -0,0 +1,220 @@
+/*
+ *     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 "forward_compat.hxx"
+
+#include "internal/exceptions_internal.hxx"
+#include "internal/logging.hxx"
+
+#include "core/utils/split_string.hxx"
+
+#include <chrono>
+#include <thread>
+#include <vector>
+
+namespace couchbase::core::transactions
+{
+struct forward_compat_behavior_full {
+  forward_compat_behavior behavior;
+  std::optional<std::chrono::milliseconds> retry_delay;
+
+  forward_compat_behavior_full(forward_compat_behavior b,
+                               std::optional<std::chrono::milliseconds> r)
+    : behavior(b)
+    , retry_delay(r)
+  {
+  }
+
+  forward_compat_behavior_full(const tao::json::value& j)
+  {
+    std::string b = j.at("b").get_string();
+    behavior = create_forward_compat_behavior(b);
+    if (const auto* ra = j.find("ra"); ra != nullptr) {
+      retry_delay = std::chrono::milliseconds(ra->get_unsigned());
+    }
+  }
+
+  template<typename OStream>
+  friend OStream& operator<<(OStream& os, const forward_compat_behavior_full& b)
+  {
+    os << "forward_compat_behavior_full:{";
+    os << "behavior: " << forward_compat_behavior_name(b.behavior);
+    if (b.retry_delay) {
+      os << ", retry_delay: " << b.retry_delay->count() << " ms";
+    }
+    os << "}";
+  }
+};
+
+struct forward_compat_requirement {
+  forward_compat_behavior_full behavior;
+
+  forward_compat_requirement(forward_compat_behavior_full b)
+    : behavior(b)
+  {
+  }
+
+  virtual forward_compat_behavior_full check(forward_compat_supported supported) = 0;
+  virtual ~forward_compat_requirement() = default;
+};
+
+struct forward_compat_protocol_requirement : public forward_compat_requirement {
+  uint32_t min_protocol_major;
+  uint32_t min_protocol_minor;
+
+  forward_compat_protocol_requirement(forward_compat_behavior_full b,
+                                      uint32_t min_major,
+                                      uint32_t min_minor)
+    : forward_compat_requirement(b)
+    , min_protocol_major(min_major)
+    , min_protocol_minor(min_minor)
+  {
+  }
+
+  virtual forward_compat_behavior_full check(forward_compat_supported supported)
+  {
+    if ((min_protocol_major > supported.protocol_major) ||
+        (min_protocol_minor > supported.protocol_minor)) {
+      return behavior;
+    }
+    return { forward_compat_behavior::CONTINUE, std::nullopt };
+  }
+};
+
+struct forward_compat_extension_requirement : public forward_compat_requirement {
+  std::string extension_id;
+
+  forward_compat_extension_requirement(forward_compat_behavior_full b, const std::string ext)
+    : forward_compat_requirement(b)
+    , extension_id(ext)
+  {
+  }
+
+  virtual forward_compat_behavior_full check(forward_compat_supported supported)
+  {
+    auto it = std::find(supported.extensions.begin(), supported.extensions.end(), extension_id);
+    if (it == supported.extensions.end()) {
+      return behavior;
+    }
+    return { forward_compat_behavior::CONTINUE, std::nullopt };
+  }
+};
+
+forward_compat_stage
+create_forward_compat_stage(const std::string& str)
+{
+  if (str == "WW_R") {
+    return forward_compat_stage::WWC_READING_ATR;
+  }
+  if (str == "WW_RP") {
+    return forward_compat_stage::WWC_REPLACING;
+  }
+  if (str == "WW_RM") {
+    return forward_compat_stage::WWC_REMOVING;
+  }
+  if (str == "WW_I") {
+    return forward_compat_stage::WWC_INSERTING;
+  }
+  if (str == "WW_IG") {
+    return forward_compat_stage::WWC_INSERTING_GET;
+  }
+  if (str == "G") {
+    return forward_compat_stage::GETS;
+  }
+  if (str == "G_A") {
+    return forward_compat_stage::GETS_READING_ATR;
+  }
+  if (str == "CL_E") {
+    return forward_compat_stage::CLEANUP_ENTRY;
+  }
+  throw std::runtime_error("Unknown forward compatibility stage");
+}
+
+class forward_compat
+{
+public:
+  forward_compat(tao::json::value& json)
+    : json_(json)
+  {
+    CB_TXN_LOG_TRACE("creating forward_compat from {}", core::utils::json::generate(json_));
+    // parse it into the map
+    for (const auto& [key, value] : json_.get_object()) {
+      auto stage = create_forward_compat_stage(key);
+      // the value is an array of forward_compat_behavior_full objects
+      for (const auto& item : value.get_array()) {
+        forward_compat_behavior_full behavior(item);
+        if (const auto* b = item.find("b"); b != nullptr) {
+          if (const auto* e = item.find("e")) {
+            std::string ext = e->get_string();
+            compat_map_[stage].push_back(new forward_compat_extension_requirement(behavior, ext));
+          } else if (const auto* p = item.find("p")) {
+            std::string proto_string = p->get_string();
+            auto proto = core::utils::split_string(proto_string, '.');
+            compat_map_[stage].push_back(new forward_compat_protocol_requirement(
+              behavior,
+              static_cast<std::uint32_t>(std::stoi(proto[0])),
+              static_cast<std::uint32_t>(std::stoi(proto[1]))));
+          }
+        }
+      }
+    }
+  }
+
+  std::optional<transaction_operation_failed> check_internal(forward_compat_stage stage,
+                                                             forward_compat_supported supported)
+  {
+    if (auto it = compat_map_.find(stage); it != compat_map_.end()) {
+      transaction_operation_failed ex(FAIL_OTHER, "Forward Compatibililty failure");
+      ex.cause(FORWARD_COMPATIBILITY_FAILURE);
+      for (const auto& b : it->second) {
+        auto behavior = b->check(supported);
+        switch (behavior.behavior) {
+          case forward_compat_behavior::FAIL_FAST_TXN:
+            CB_TXN_LOG_TRACE("forward compatiblity FAIL_FAST_TXN");
+            return ex;
+          case forward_compat_behavior::RETRY_TXN:
+            CB_TXN_LOG_TRACE("forward compatibility RETRY_TXN");
+            if (behavior.retry_delay) {
+              CB_TXN_LOG_TRACE("delay {}ms before retrying", behavior.retry_delay->count());
+              std::this_thread::sleep_for(*behavior.retry_delay);
+            }
+            return ex.retry();
+          case forward_compat_behavior::CONTINUE:
+          default:
+            break;
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+private:
+  std::map<forward_compat_stage, std::list<forward_compat_requirement*>> compat_map_;
+  tao::json::value json_;
+};
+
+std::optional<transaction_operation_failed>
+check_forward_compat(forward_compat_stage stage, std::optional<tao::json::value> json)
+{
+  if (json) {
+    forward_compat_supported supported;
+    forward_compat fc(json.value());
+    return fc.check_internal(stage, supported);
+  }
+  return std::nullopt;
+}
+
+} // namespace couchbase::core::transactions