couchbase 3.5.1 → 3.5.3

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);
+  }
+};