couchbase 4.2.0 → 4.2.2

package/deps/couchbase-cxx-client/core/transactions/attempt_context_impl.hxx

@@ -16,8 +16,10 @@
 
 #pragma once
 
+#include <core/cluster.hxx>
 #include <couchbase/transactions/async_attempt_context.hxx>
 #include <couchbase/transactions/attempt_context.hxx>
+#include <couchbase/transactions/transaction_query_options.hxx>
 
 #include "attempt_context_testing_hooks.hxx"
 #include "error_list.hxx"
@@ -38,6 +40,18 @@
 #include <thread>
 #include <utility>
 
+// implemented in core::impl::query, to take advantage of the statics over there
+namespace couchbase::core::impl
+{
+
+couchbase::transactions::transaction_query_result
+build_transaction_query_result(operations::query_response resp, std::error_code ec = {});
+
+core::operations::query_request
+build_transaction_query_request(couchbase::query_options::built opts);
+
+} // namespace couchbase::core::impl
+
 namespace couchbase::core::transactions
 {
 /**
@@ -64,6 +78,7 @@ class attempt_context_impl
     error_list errors_;
     std::mutex mutex_;
     waitable_op_list op_list_;
+    std::string query_context_;
 
     // commit needs to access the hooks
     friend class staged_mutation_queue;
@@ -72,21 +87,21 @@ class attempt_context_impl
     // transaction_context needs access to the two functions below
     friend class transaction_context;
 
-    couchbase::transactions::transaction_get_result_ptr insert_raw(std::shared_ptr<couchbase::collection> coll,
+    couchbase::transactions::transaction_get_result_ptr insert_raw(const couchbase::collection& coll,
                                                                    const std::string& id,
                                                                    std::vector<std::byte> content) override
     {
         return wrap_call_for_public_api([this, coll, &id, &content]() -> transaction_get_result {
-            return insert_raw({ coll->bucket_name(), coll->scope_name(), coll->name(), id }, content);
+            return insert_raw({ coll.bucket_name(), coll.scope_name(), coll.name(), id }, content);
         });
     }
     transaction_get_result insert_raw(const core::document_id& id, const std::vector<std::byte>& content) override;
-    void insert_raw(std::shared_ptr<collection> coll,
+    void insert_raw(const collection& coll,
                     std::string id,
                     std::vector<std::byte> content,
                     couchbase::transactions::async_result_handler&& handler) override
     {
-        insert_raw({ coll->bucket_name(), coll->scope_name(), coll->name(), std::move(id) },
+        insert_raw({ coll.bucket_name(), coll.scope_name(), coll.name(), std::move(id) },
                    content,
                    [this, handler = std::move(handler)](std::exception_ptr err, std::optional<transaction_get_result> res) mutable {
                        wrap_callback_for_async_public_api(err, res, std::move(handler));
@@ -123,43 +138,49 @@ class attempt_context_impl
     void commit_with_query(VoidCallback&& cb);
     void rollback_with_query(VoidCallback&& cb);
 
-    void query_begin_work(utils::movable_function<void(std::exception_ptr)>&& cb);
+    void query_begin_work(std::optional<std::string> query_context, std::function<void(std::exception_ptr)>&& cb);
 
-    void do_query(const std::string& statement, const transaction_query_options& opts, QueryCallback&& cb);
+    void do_query(const std::string& statement,
+                  const couchbase::transactions::transaction_query_options& opts,
+                  std::optional<std::string> query_context,
+                  QueryCallback&& cb);
     std::exception_ptr handle_query_error(const core::operations::query_response& resp);
     void wrap_query(const std::string& statement,
-                    const transaction_query_options& opts,
+                    const couchbase::transactions::transaction_query_options& opts,
                     const std::vector<core::json_string>& params,
                     const tao::json::value& txdata,
                     const std::string& hook_point,
                     bool check_expiry,
-                    utils::movable_function<void(std::exception_ptr, core::operations::query_response)>&& cb);
+                    std::optional<std::string> query_context,
+                    std::function<void(std::exception_ptr, core::operations::query_response)>&& cb);
 
     void handle_err_from_callback(std::exception_ptr e)
     {
         try {
             throw e;
         } catch (const transaction_operation_failed& ex) {
-            txn_log->error("op callback called a txn operation that threw exception {}", ex.what());
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "op callback called a txn operation that threw exception {}", ex.what());
             op_list_.decrement_ops();
             // presumably that op called op_completed_with_error already, so
             // don't do anything here but swallow it.
         } catch (const async_operation_conflict& op_ex) {
             // the count isn't changed when this is thrown, so just swallow it and log
-            txn_log->error("op callback called a txn operation that threw exception {}", op_ex.what());
-        } catch (const query_exception& query_ex) {
-            txn_log->warn("op callback called a txn operation that threw (and didn't handle) a query_exception {}", query_ex.what());
-            errors_.push_back(transaction_operation_failed(FAIL_OTHER, query_ex.what()).cause(query_ex.cause()));
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "op callback called a txn operation that threw exception {}", op_ex.what());
+        } catch (const op_exception& op_ex) {
+            CB_ATTEMPT_CTX_LOG_WARNING(
+              this, "op callback called a txn operation that threw (and didn't handle) a op_exception {}", op_ex.what());
+            errors_.push_back(
+              transaction_operation_failed(error_class_from_external_exception(op_ex.cause()), op_ex.what()).cause(op_ex.cause()));
             op_list_.decrement_ops();
         } catch (const std::exception& std_ex) {
             // if the callback throws something which wasn't handled
             // we just want to handle as a rollback
-            txn_log->error("op callback threw exception {}", std_ex.what());
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "op callback threw exception {}", std_ex.what());
             errors_.push_back(transaction_operation_failed(FAIL_OTHER, std_ex.what()));
             op_list_.decrement_ops();
         } catch (...) {
             // could be something really arbitrary, still...
-            txn_log->error("op callback threw unexpected exception");
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "op callback threw unexpected exception");
             errors_.push_back(transaction_operation_failed(FAIL_OTHER, "unexpected error"));
             op_list_.decrement_ops();
         }
@@ -270,7 +291,7 @@ class attempt_context_impl
     }
 
     template<typename Handler>
-    void cache_error_async(Handler&& cb, std::function<void()> func)
+    void cache_error_async(Handler cb, std::function<void()> func)
     {
         try {
             op_list_.increment_ops();
@@ -278,7 +299,7 @@ class attempt_context_impl
             return func();
         } catch (const async_operation_conflict& e) {
             // can't do anything here but log and eat it.
-            error("Attempted to perform txn operation after commit/rollback started: {}", e.what());
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "Attempted to perform txn operation after commit/rollback started: {}", e.what());
             // you cannot call op_completed_with_error, as it tries to decrement
             // the op count, however it didn't successfully increment it, so...
             op_completed_with_error_no_cache(std::move(cb), std::current_exception());
@@ -288,35 +309,13 @@ class attempt_context_impl
             if (e.cause() == PREVIOUS_OPERATION_FAILED) {
                 op_completed_with_error(std::move(cb), e);
             }
+        } catch (const op_exception& e) {
+            op_completed_with_error(std::move(cb), e);
         } catch (const std::exception& e) {
             op_completed_with_error(std::move(cb), transaction_operation_failed(FAIL_OTHER, e.what()));
         }
     }
 
-    template<typename... Args>
-    void trace(const std::string& fmt, Args... args)
-    {
-        txn_log->trace(attempt_format_string + fmt, this->transaction_id(), this->id(), args...);
-    }
-
-    template<typename... Args>
-    void debug(const std::string& fmt, Args... args)
-    {
-        txn_log->debug(attempt_format_string + fmt, this->transaction_id(), this->id(), args...);
-    }
-
-    template<typename... Args>
-    void info(const std::string& fmt, Args... args)
-    {
-        txn_log->info(attempt_format_string + fmt, this->transaction_id(), this->id(), args...);
-    }
-
-    template<typename... Args>
-    void error(const std::string& fmt, Args... args)
-    {
-        txn_log->error(attempt_format_string + fmt, this->transaction_id(), this->id(), args...);
-    }
-
     std::shared_ptr<core::cluster> cluster_ref();
 
   public:
@@ -324,19 +323,19 @@ class attempt_context_impl
     ~attempt_context_impl() override;
 
     transaction_get_result get(const core::document_id& id) override;
-    couchbase::transactions::transaction_get_result_ptr get(std::shared_ptr<couchbase::collection> coll, const std::string& id) override
+    couchbase::transactions::transaction_get_result_ptr get(const couchbase::collection& coll, const std::string& id) override
     {
         return wrap_call_for_public_api([this, coll, id]() mutable -> transaction_get_result {
-            auto ret = get_optional({ coll->bucket_name(), coll->scope_name(), coll->name(), id });
+            auto ret = get_optional({ coll.bucket_name(), coll.scope_name(), coll.name(), id });
             if (ret) {
                 return *ret;
             }
             return { transaction_op_error_context{ errc::transaction_op::document_not_found_exception } };
         });
     }
-    void get(std::shared_ptr<couchbase::collection> coll, std::string id, couchbase::transactions::async_result_handler&& handler) override
+    void get(const couchbase::collection& coll, std::string id, couchbase::transactions::async_result_handler&& handler) override
     {
-        get_optional({ coll->bucket_name(), coll->scope_name(), coll->name(), std::move(id) },
+        get_optional({ coll.bucket_name(), coll.scope_name(), coll.name(), std::move(id) },
                      [this, handler = std::move(handler)](std::exception_ptr err, std::optional<transaction_get_result> res) mutable {
                          if (!res) {
                              return handler(std::make_shared<transaction_get_result>(
@@ -363,8 +362,46 @@ class attempt_context_impl
         });
     };
 
-    core::operations::query_response query(const std::string& statement, const transaction_query_options& options) override;
-    void query(const std::string& statement, const transaction_query_options& options, QueryCallback&& cb) override;
+    core::operations::query_response do_core_query(const std::string& statement,
+                                                   const couchbase::transactions::transaction_query_options& options,
+                                                   std::optional<std::string> query_context) override;
+
+    couchbase::transactions::transaction_query_result_ptr do_public_query(const std::string& statement,
+                                                                          const couchbase::transactions::transaction_query_options& opts,
+                                                                          std::optional<std::string> query_context) override;
+
+    void query(const std::string& statement,
+               const couchbase::transactions::transaction_query_options& options,
+               std::optional<std::string> query_context,
+               QueryCallback&& cb) override;
+
+    void query(std::string statement,
+               couchbase::transactions::transaction_query_options opts,
+               std::optional<std::string> query_context,
+               couchbase::transactions::async_query_handler&& handler) override
+    {
+        query(
+          statement,
+          opts,
+          query_context,
+          [handler = std::move(handler)](std::exception_ptr err, std::optional<core::operations::query_response> resp) {
+              if (err) {
+                  try {
+                      std::rethrow_exception(err);
+                  } catch (const transaction_operation_failed& e) {
+                      return handler(std::make_shared<couchbase::transactions::transaction_query_result>(e.get_error_ctx()));
+                  } catch (const op_exception& ex) {
+                      return handler(std::make_shared<couchbase::transactions::transaction_query_result>(ex.ctx()));
+                  } catch (...) {
+                      // just in case...
+                      return handler(std::make_shared<couchbase::transactions::transaction_query_result>(
+                        transaction_op_error_context(couchbase::errc::transaction_op::unknown)));
+                  }
+              }
+              handler(
+                std::make_shared<couchbase::transactions::transaction_query_result>(core::impl::build_transaction_query_result(*resp)));
+          });
+    }
 
     void commit() override;
     void commit(VoidCallback&& cb) override;
@@ -458,15 +495,13 @@ class attempt_context_impl
 
     void atr_rollback_complete();
 
-    void select_atr_if_needed_unlocked(const core::document_id id,
-                                       utils::movable_function<void(std::optional<transaction_operation_failed>)>&& cb);
+    void select_atr_if_needed_unlocked(const core::document_id id, std::function<void(std::optional<transaction_operation_failed>)>&& cb);
 
     template<typename Handler>
     void do_get(const core::document_id& id, const std::optional<std::string> resolving_missing_atr_entry, Handler&& cb);
 
-    void get_doc(
-      const core::document_id& id,
-      utils::movable_function<void(std::optional<error_class>, std::optional<std::string>, std::optional<transaction_get_result>)>&& cb);
+    void get_doc(const core::document_id& id,
+                 std::function<void(std::optional<error_class>, std::optional<std::string>, std::optional<transaction_get_result>)>&& cb);
 
     core::operations::mutate_in_request create_staging_request(const core::document_id& in,
                                                                const transaction_get_result* document,
@@ -498,6 +533,8 @@ class attempt_context_impl
             return std::make_shared<transaction_get_result>(handler());
         } catch (const transaction_operation_failed& e) {
             return std::make_shared<transaction_get_result>(e.get_error_ctx());
+        } catch (const op_exception& ex) {
+            return std::make_shared<transaction_get_result>(ex.ctx());
         } catch (...) {
             // the handler should catch everything else, but just in case...
             return std::make_shared<transaction_get_result>(transaction_op_error_context(errc::transaction_op::unknown));
@@ -527,6 +564,8 @@ class attempt_context_impl
         if (err) {
             try {
                 std::rethrow_exception(err);
+            } catch (const op_exception& e) {
+                return cb(std::make_shared<transaction_get_result>(e.ctx()));
             } catch (const transaction_operation_failed& e) {
                 return cb(std::make_shared<transaction_get_result>(e.get_error_ctx()));
             } catch (...) {
@@ -549,5 +588,11 @@ class attempt_context_impl
         }
         return cb({});
     }
+
+    void ensure_open_bucket(std::string bucket_name, std::function<void(std::error_code)>&& handler)
+    {
+        cluster_ref()->open_bucket(bucket_name, [handler = std::move(handler)](std::error_code ec) { handler(ec); });
+    }
 };
+
 } // namespace couchbase::core::transactions

package/deps/couchbase-cxx-client/core/transactions/attempt_context_testing_hooks.hxx

@@ -15,7 +15,7 @@
  */
 #pragma once
 
-#include "internal/exceptions_internal.hxx"
+#include "core/transactions/error_class.hxx"
 
 #include <functional>
 #include <optional>
@@ -136,5 +136,10 @@ struct attempt_context_testing_hooks {
     std::function<std::optional<const std::string>(attempt_context*)> random_atr_id_for_vbucket = noop_3;
 
     std::function<bool(attempt_context*, const std::string&, std::optional<const std::string>)> has_expired_client_side = noop_4;
+
+    // needed for unique_ptr<attempt_context_testing_hooks> in transaction_config, with a forward declaration.
+    ~attempt_context_testing_hooks()
+    {
+    }
 };
 } // namespace couchbase::core::transactions

package/deps/couchbase-cxx-client/core/transactions/cleanup_testing_hooks.hxx

@@ -15,6 +15,8 @@
  */
 #pragma once
 
+#include "core/transactions/error_class.hxx"
+
 #include <functional>
 #include <string>
 
@@ -24,12 +26,12 @@ using error_func3 = std::function<std::optional<error_class>(const std::string&)
 using error_func4 = std::function<std::optional<error_class>(void)>;
 namespace
 {
-std::optional<error_class>
+std::optional<couchbase::core::transactions::error_class>
 noop1(const std::string&)
 {
     return {};
 }
-std::optional<error_class>
+std::optional<couchbase::core::transactions::error_class>
 noop2()
 {
     return {};
@@ -58,5 +60,10 @@ struct cleanup_testing_hooks {
     error_func3 client_record_before_get = noop1;
     error_func3 client_record_before_update = noop1;
     error_func3 client_record_before_remove_client = noop1;
+
+    // needed for unique_ptr<cleanup_testing_hooks> in transaction_config, with a forward declaration.
+    ~cleanup_testing_hooks()
+    {
+    }
 };
 } // namespace couchbase::core::transactions

package/deps/couchbase-cxx-client/core/transactions/durability_level.hxx

@@ -46,7 +46,7 @@ durability_level_to_string_for_query(durability_level level)
         case durability_level::majority:
             return "majority";
         case durability_level::majority_and_persist_to_active:
-            return "majorityAndPersistToActive";
+            return "majorityAndPersistActive";
         case durability_level::persist_to_majority:
             return "persistToMajority";
     }

package/deps/couchbase-cxx-client/core/transactions/error_class.hxx

@@ -0,0 +1,35 @@
+/*
+ *     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
+
+namespace couchbase::core::transactions
+{
+enum error_class {
+    FAIL_HARD = 0,
+    FAIL_OTHER,
+    FAIL_TRANSIENT,
+    FAIL_AMBIGUOUS,
+    FAIL_DOC_ALREADY_EXISTS,
+    FAIL_DOC_NOT_FOUND,
+    FAIL_PATH_NOT_FOUND,
+    FAIL_CAS_MISMATCH,
+    FAIL_WRITE_WRITE_CONFLICT,
+    FAIL_ATR_FULL,
+    FAIL_PATH_ALREADY_EXISTS,
+    FAIL_EXPIRY
+};
+} // namespace couchbase::core::transactions

package/deps/couchbase-cxx-client/core/transactions/exceptions.cxx

@@ -33,6 +33,19 @@ external_exception_from_error_class(error_class ec)
     }
 }
 
+couchbase::core::transactions::error_class
+error_class_from_external_exception(external_exception e)
+{
+    switch (e) {
+        case DOCUMENT_NOT_FOUND_EXCEPTION:
+            return FAIL_DOC_NOT_FOUND;
+        case DOCUMENT_EXISTS_EXCEPTION:
+            return FAIL_DOC_ALREADY_EXISTS;
+        default:
+            return FAIL_OTHER;
+    }
+}
+
 error_class
 error_class_from_result(const result& res)
 {

package/deps/couchbase-cxx-client/core/transactions/exceptions.hxx

@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <core/error_context/query.hxx>
 #include <couchbase/error_codes.hxx>
 #include <couchbase/transactions/transaction_result.hxx>
 #include <optional>
@@ -57,6 +58,9 @@ enum external_exception {
 couchbase::errc::transaction_op
 transaction_op_errc_from_external_exception(external_exception e);
 
+couchbase::core::transactions::error_class
+error_class_from_external_exception(external_exception e);
+
 /**
  * @brief Base class for all exceptions expected to be raised from a transaction.
  *
@@ -124,74 +128,81 @@ class transaction_exception : public std::runtime_error
         return { ec, transaction_op_errc_from_external_exception(cause_) };
     }
 };
-
-class query_exception : public std::runtime_error
+class op_exception : public std::runtime_error
 {
+  private:
+    external_exception cause_;
+    transaction_op_error_context ctx_;
+
   public:
-    query_exception(const std::string& what, external_exception cause = COUCHBASE_EXCEPTION)
-      : std::runtime_error(what)
+    op_exception(transaction_op_error_context ctx, external_exception cause = COUCHBASE_EXCEPTION)
+      : std::runtime_error(ctx.ec().message())
       , cause_(cause)
+      , ctx_(std::move(ctx))
     {
     }
-    external_exception cause() const
+
+    [[nodiscard]] external_exception cause() const
     {
         return cause_;
     }
 
-  private:
-    external_exception cause_;
+    [[nodiscard]] const transaction_op_error_context& ctx() const
+    {
+        return ctx_;
+    }
 };
 
-class query_document_not_found : public query_exception
+class document_not_found : public op_exception
 {
   public:
-    explicit query_document_not_found(const std::string& what)
-      : query_exception(what, DOCUMENT_NOT_FOUND_EXCEPTION)
+    explicit document_not_found(transaction_op_error_context ctx)
+      : op_exception(ctx, DOCUMENT_NOT_FOUND_EXCEPTION)
     {
     }
 };
 
-class query_document_exists : public query_exception
+class document_exists : public op_exception
 {
   public:
-    explicit query_document_exists(const std::string& what)
-      : query_exception(what, DOCUMENT_EXISTS_EXCEPTION)
+    explicit document_exists(transaction_op_error_context ctx)
+      : op_exception(ctx, DOCUMENT_EXISTS_EXCEPTION)
     {
     }
 };
 
-class query_attempt_not_found : public query_exception
+class query_attempt_not_found : public op_exception
 {
   public:
-    query_attempt_not_found(const std::string& what)
-      : query_exception(what)
+    query_attempt_not_found(transaction_op_error_context ctx)
+      : op_exception(ctx)
     {
     }
 };
 
-class query_cas_mismatch : public query_exception
+class query_cas_mismatch : public op_exception
 {
   public:
-    query_cas_mismatch(const std::string& what)
-      : query_exception(what)
+    query_cas_mismatch(transaction_op_error_context ctx)
+      : op_exception(ctx)
     {
     }
 };
 
-class query_attempt_expired : public query_exception
+class query_attempt_expired : public op_exception
 {
   public:
-    query_attempt_expired(const std::string& what)
-      : query_exception(what)
+    query_attempt_expired(transaction_op_error_context ctx)
+      : op_exception(ctx)
     {
     }
 };
 
-class query_parsing_failure : public query_exception
+class query_parsing_failure : public op_exception
 {
   public:
-    query_parsing_failure(const std::string& what)
-      : query_exception(what, PARSING_FAILURE)
+    query_parsing_failure(transaction_op_error_context ctx)
+      : op_exception(ctx, PARSING_FAILURE)
     {
     }
 };

package/deps/couchbase-cxx-client/core/transactions/forward_compat.hxx

@@ -122,7 +122,8 @@ struct forward_compat_behavior_full {
 struct forward_compat_supported {
     uint32_t protocol_major = 2;
     uint32_t protocol_minor = 0;
-    std::list<std::string> extensions{ "TI", "MO", "BM", "QU", "SD", "BF3787", "BF3705", "BF3838", "RC", "UA", "CO", "BF3791", "CM" };
+    std::list<std::string> extensions{ "TI", "MO", "BM", "QU",     "SD", "BF3787", "BF3705", "BF3838",
+                                       "RC", "UA", "CO", "BF3791", "CM", "SI",     "QC",     "IX" };
 };
 
 struct forward_compat_requirement {
@@ -191,12 +192,12 @@ class forward_compat
                 auto behavior = b->check(supported);
                 switch (behavior.behavior) {
                     case forward_compat_behavior::FAIL_FAST_TXN:
-                        txn_log->trace("forward compatiblity FAIL_FAST_TXN");
+                        CB_TXN_LOG_TRACE("forward compatiblity FAIL_FAST_TXN");
                         return ex;
                     case forward_compat_behavior::RETRY_TXN:
-                        txn_log->trace("forward compatibility RETRY_TXN");
+                        CB_TXN_LOG_TRACE("forward compatibility RETRY_TXN");
                         if (behavior.retry_delay) {
-                            txn_log->trace("delay {}ms before retrying", behavior.retry_delay->count());
+                            CB_TXN_LOG_TRACE("delay {}ms before retrying", behavior.retry_delay->count());
                             std::this_thread::sleep_for(*behavior.retry_delay);
                         }
                         return ex.retry();
@@ -212,7 +213,7 @@ class forward_compat
     forward_compat(tao::json::value& json)
       : json_(json)
     {
-        txn_log->trace("creating forward_compat from {}", core::utils::json::generate(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);