couchbase 3.5.1 → 3.5.2

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

@@ -48,35 +48,41 @@ transactions_config::transactions_config(transactions_config&& c) noexcept
 transactions_config::transactions_config(const transactions_config& config)
   : level_(config.durability_level())
   , timeout_(config.timeout())
-  , attempt_context_hooks_(std::make_shared<core::transactions::attempt_context_testing_hooks>(config.attempt_context_hooks()))
-  , cleanup_hooks_(std::make_shared<core::transactions::cleanup_testing_hooks>(config.cleanup_hooks()))
+  , attempt_context_hooks_(std::make_shared<core::transactions::attempt_context_testing_hooks>(
+      config.attempt_context_hooks()))
+  , cleanup_hooks_(
+      std::make_shared<core::transactions::cleanup_testing_hooks>(config.cleanup_hooks()))
   , metadata_collection_(config.metadata_collection())
   , query_config_(config.query_config())
   , cleanup_config_(config.cleanup_config())
 {
 }
 
-transactions_config&
-transactions_config::operator=(const transactions_config& c)
+auto
+transactions_config::operator=(const transactions_config& c) -> transactions_config&
 {
-    if (this != &c) {
-        level_ = c.level_;
-        timeout_ = c.timeout_;
-        attempt_context_hooks_ = c.attempt_context_hooks_;
-        cleanup_hooks_ = c.cleanup_hooks_;
-        query_config_ = c.query_config_;
-        metadata_collection_ = c.metadata_collection_;
-        cleanup_config_ = c.cleanup_config_;
-    }
-    return *this;
+  if (this != &c) {
+    level_ = c.level_;
+    timeout_ = c.timeout_;
+    attempt_context_hooks_ = c.attempt_context_hooks_;
+    cleanup_hooks_ = c.cleanup_hooks_;
+    query_config_ = c.query_config_;
+    metadata_collection_ = c.metadata_collection_;
+    cleanup_config_ = c.cleanup_config_;
+  }
+  return *this;
 }
 
-transactions_config::built
-transactions_config::build() const
+auto
+transactions_config::build() const -> transactions_config::built
 {
-    return {
-        level_, timeout_, attempt_context_hooks_, cleanup_hooks_, metadata_collection_, query_config_.build(), cleanup_config_.build()
-    };
+  return { level_,
+           timeout_,
+           attempt_context_hooks_,
+           cleanup_hooks_,
+           metadata_collection_,
+           query_config_.build(),
+           cleanup_config_.build() };
 }
 
 } // namespace couchbase::transactions

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

@@ -20,8 +20,8 @@
 
 // TODO: Remove this, and just use client directly
 
-std::string
-couchbase::core::transactions::uid_generator::next()
+auto
+couchbase::core::transactions::uid_generator::next() -> std::string
 {
-    return core::uuid::to_string(core::uuid::random());
+  return core::uuid::to_string(core::uuid::random());
 }

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

@@ -23,7 +23,7 @@ namespace couchbase::core::transactions
 {
 class uid_generator
 {
-  public:
-    static std::string next();
+public:
+  static auto next() -> std::string;
 };
 } // namespace couchbase::core::transactions

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

@@ -14,125 +14,138 @@
  *   limitations under the License.
  */
 
+#include "internal/utils.hxx"
+
 #include "core/operations.hxx"
+#include "core/operations/document_lookup_in.hxx"
 #include "core/operations/management/bucket_get_all.hxx"
+#include "core/transactions/error_class.hxx"
 
-#include "internal/utils.hxx"
+#include <couchbase/collection.hxx>
+#include <couchbase/scope.hxx>
 
 namespace couchbase::core::transactions
 {
-std::string
-collection_spec_from_id(const core::document_id& id)
+auto
+collection_spec_from_id(const core::document_id& id) -> std::string
 {
-    std::string retval = id.scope();
-    return retval.append(".").append(id.collection());
+  std::string retval = id.scope();
+  return retval.append(".").append(id.collection());
 }
 
-bool
-document_ids_equal(const core::document_id& id1, const core::document_id& id2)
+auto
+document_ids_equal(const core::document_id& id1, const core::document_id& id2) -> bool
 {
-    return id1.key() == id2.key() && id1.bucket() == id2.bucket() && id1.scope() == id2.scope() && id1.collection() == id2.collection();
+  return id1.key() == id2.key() && id1.bucket() == id2.bucket() && id1.scope() == id2.scope() &&
+         id1.collection() == id2.collection();
 }
 
-std::string
-jsonify(const tao::json::value& obj)
+auto
+jsonify(const tao::json::value& obj) -> std::string
 {
-    return core::utils::json::generate(obj);
+  return core::utils::json::generate(obj);
 }
 
-std::uint64_t
-now_ns_from_vbucket(const tao::json::value& vbucket)
+auto
+now_ns_from_vbucket(const tao::json::value& vbucket) -> std::uint64_t
 {
-    std::string now_str = vbucket.at("HLC").at("now").get_string();
-    return stoull(now_str, nullptr, 10) * 1000000000;
+  std::string now_str = vbucket.at("HLC").at("now").get_string();
+  return stoull(now_str, nullptr, 10) * 1000000000;
 }
 
 void
 wrap_collection_call(result& res, std::function<void(result&)> call)
 {
-    call(res);
-    if (!res.is_success()) {
+  call(res);
+  if (!res.is_success()) {
+    throw client_error(res);
+  }
+  if (!res.values.empty() && !res.ignore_subdoc_errors) {
+    for (const auto& v : res.values) {
+      if (v.status != subdoc_result::status_type::success) {
         throw client_error(res);
+      }
     }
-    if (!res.values.empty() && !res.ignore_subdoc_errors) {
-        for (const auto& v : res.values) {
-            if (v.status != subdoc_result::status_type::success) {
-                throw client_error(res);
-            }
-        }
-    }
+  }
 }
 
 void
 validate_operation_result(result& res, bool ignore_subdoc_errors)
 {
-    if (!res.is_success()) {
-        throw client_error(res);
-    }
-    // we should raise here, as we are doing a non-subdoc request and can't specify
-    // access_deleted.  TODO: consider changing client to return document_not_found
-    if (res.is_deleted && res.values.empty()) {
-        res.ec = couchbase::errc::key_value::document_not_found;
+  if (!res.is_success()) {
+    throw client_error(res);
+  }
+  // we should raise here, as we are doing a non-subdoc request and can't specify
+  // access_deleted.  TODO: consider changing client to return document_not_found
+  if (res.is_deleted && res.values.empty()) {
+    res.ec = couchbase::errc::key_value::document_not_found;
+    throw client_error(res);
+  }
+  if (!res.values.empty() && !ignore_subdoc_errors) {
+    for (const auto& v : res.values) {
+      if (v.status != subdoc_result::status_type::success) {
         throw client_error(res);
+      }
     }
-    if (!res.values.empty() && !ignore_subdoc_errors) {
-        for (const auto& v : res.values) {
-            if (v.status != subdoc_result::status_type::success) {
-                throw client_error(res);
-            }
-        }
-    }
+  }
 }
 
-result
-wrap_operation_future(std::future<result>& fut, bool ignore_subdoc_errors)
+auto
+wrap_operation_future(std::future<result>& fut, bool ignore_subdoc_errors) -> result
 {
-    auto res = fut.get();
-    validate_operation_result(res, ignore_subdoc_errors);
-    return res;
+  auto res = fut.get();
+  validate_operation_result(res, ignore_subdoc_errors);
+  return res;
 }
 
-std::optional<error_class>
+auto
 wait_for_hook(std::function<void(utils::movable_function<void(std::optional<error_class>)>)> hook)
+  -> std::optional<error_class>
 {
-    auto hook_barrier = std::make_shared<std::promise<std::optional<error_class>>>();
-    auto hook_future = hook_barrier->get_future();
-    hook([hook_barrier](std::optional<error_class> ec) mutable { return hook_barrier->set_value(ec); });
-    return hook_future.get();
+  auto hook_barrier = std::make_shared<std::promise<std::optional<error_class>>>();
+  auto hook_future = hook_barrier->get_future();
+  hook([hook_barrier](std::optional<error_class> ec) mutable {
+    return hook_barrier->set_value(ec);
+  });
+  return hook_future.get();
 }
 
 template<>
-bool
-is_error(const core::operations::mutate_in_response& resp)
+auto
+is_error(const core::operations::mutate_in_response& resp) -> bool
 {
-    return resp.ctx.ec() || resp.ctx.first_error_index();
+  return resp.ctx.ec() || resp.ctx.first_error_index();
 }
 
 template<>
-std::optional<error_class>
+auto
 error_class_from_response_extras(const core::operations::mutate_in_response& resp)
+  -> std::optional<error_class>
 {
-    if (!resp.ctx.first_error_index()) {
-        return {};
-    }
-    auto status = resp.fields.at(*resp.ctx.first_error_index()).status;
-    if (status == key_value_status_code::subdoc_path_not_found) {
-        return FAIL_PATH_NOT_FOUND;
-    }
-    if (status == key_value_status_code::subdoc_path_exists) {
-        return FAIL_PATH_ALREADY_EXISTS;
-    }
-    return FAIL_OTHER;
+  if (!resp.ctx.first_error_index()) {
+    return {};
+  }
+  auto status = resp.fields.at(*resp.ctx.first_error_index()).status;
+  if (status == key_value_status_code::subdoc_path_not_found) {
+    return FAIL_PATH_NOT_FOUND;
+  }
+  if (status == key_value_status_code::subdoc_path_exists) {
+    return FAIL_PATH_ALREADY_EXISTS;
+  }
+  return FAIL_OTHER;
 }
 
-core::document_id
+auto
 atr_id_from_bucket_and_key(const couchbase::transactions::transactions_config::built& cfg,
                            const std::string& bucket,
-                           const std::string& key)
+                           const std::string& key) -> core::document_id
 {
-    if (cfg.metadata_collection) {
-        return { cfg.metadata_collection->bucket, cfg.metadata_collection->scope, cfg.metadata_collection->collection, key };
-    }
-    return { bucket, couchbase::scope::default_name, couchbase::collection::default_name, key };
+  if (cfg.metadata_collection) {
+    return { cfg.metadata_collection->bucket,
+             cfg.metadata_collection->scope,
+             cfg.metadata_collection->collection,
+             key };
+  }
+  return { bucket, couchbase::scope::default_name, couchbase::collection::default_name, key };
 }
 } // namespace couchbase::core::transactions

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

@@ -26,165 +26,179 @@ namespace couchbase::core::transactions
 
 class async_operation_conflict : public std::runtime_error
 {
-  public:
-    async_operation_conflict(const std::string& msg)
-      : std::runtime_error(msg)
-    {
-    }
+public:
+  async_operation_conflict(const std::string& msg)
+    : std::runtime_error(msg)
+  {
+  }
 };
 struct attempt_mode {
-    enum class modes { KV, QUERY };
-    modes mode;
-    std::string query_node;
+  enum class modes {
+    KV,
+    QUERY
+  };
+  modes mode;
+  std::string query_node;
 
-    attempt_mode()
-      : mode(modes::KV)
-    {
-    }
+  attempt_mode()
+    : mode(modes::KV)
+  {
+  }
 
-    bool is_query()
-    {
-        return mode == modes::QUERY;
-    }
+  auto is_query() -> bool
+  {
+    return mode == modes::QUERY;
+  }
 };
 
 class waitable_op_list
 {
-  public:
-    waitable_op_list()
-      : count_(0)
-      , allow_ops_(true)
-      , mode_()
-      , in_flight_(0)
-    {
-    }
+public:
+  waitable_op_list()
+    : count_(0)
+    , allow_ops_(true)
+    , mode_()
+    , in_flight_(0)
+  {
+  }
 
-    void increment_ops()
-    {
-        change_count(1);
+  void increment_ops()
+  {
+    change_count(1);
+  }
+  void decrement_ops()
+  {
+    change_count(-1);
+  }
+  void wait_and_block_ops()
+  {
+    std::unique_lock<std::mutex> lock(mutex_);
+    cv_ops_.wait(lock, [this]() {
+      return (0 == count_);
+    });
+    // we have the lock.  Block all further ops
+    allow_ops_ = false;
+  }
+  auto get_mode() -> attempt_mode
+  {
+    std::unique_lock<std::mutex> lock(mutex_);
+    if (mode_.mode == attempt_mode::modes::KV) {
+      return {};
     }
-    void decrement_ops()
-    {
-        change_count(-1);
-    }
-    void wait_and_block_ops()
-    {
-        std::unique_lock<std::mutex> lock(mutex_);
-        cv_ops_.wait(lock, [this]() { return (0 == count_); });
-        // we have the lock.  Block all further ops
-        allow_ops_ = false;
-    }
-    attempt_mode get_mode()
-    {
-        std::unique_lock<std::mutex> lock(mutex_);
-        if (mode_.mode == attempt_mode::modes::KV) {
-            return {};
-        }
-        if (!mode_.query_node.empty()) {
-            return mode_;
-        }
-        // Another op has set the query_mode_, and hasn't set the
-        // query_node_ yet.   So we wait.
-        cv_query_.wait(lock, [this]() { return !mode_.query_node.empty(); });
-        return mode_;
+    if (!mode_.query_node.empty()) {
+      return mode_;
     }
+    // Another op has set the query_mode_, and hasn't set the
+    // query_node_ yet.   So we wait.
+    cv_query_.wait(lock, [this]() {
+      return !mode_.query_node.empty();
+    });
+    return mode_;
+  }
 
-    template<typename BeginWorkHandler, typename DoQueryHandler>
-    void set_query_mode(BeginWorkHandler&& begin_work_cb, DoQueryHandler&& cb)
-    {
-        std::unique_lock<std::mutex> lock(mutex_);
-        // called within an op, so decrement in_flight from that op, wait for
-        // other in_flight to complete.
-        in_flight_--;
-        if (mode_.mode == attempt_mode::modes::KV) {
-            // wait until all in_flight ops are done
-            CB_TXN_LOG_TRACE("set_query_mode: waiting for in_flight ops to go to 0...");
-            cv_in_flight_.wait(lock, [this]() { return (0 == in_flight_); });
-            // ok, now no outstanding ops(apart from the query that called this), and I have the lock, so...
-            if (mode_.mode == attempt_mode::modes::KV) {
-                CB_TXN_LOG_TRACE("set_query_mode: in_flight ops = 0, we were kv, setting mode to query");
-                // still kv, so now (while blocking) set the mode
-                mode_.mode = attempt_mode::modes::QUERY;
-                // ok to unlock now, as any racing set_query_mode will wait for
-                // a node to be set.
-                in_flight_++;
-                lock.unlock();
-                // now (outside the lock), call the callback, which does the begin_work
-                // when initially setting query mode.
-                begin_work_cb();
-                return;
-            }
-        }
-        // you make it here, and someone else is currently setting the node (a byproduct of
-        // calling the callback).  So wait for that.
-        CB_TXN_LOG_TRACE("set_query_mode: mode already query, waiting for node to be set...");
-        cv_query_.wait(lock, [this]() { return !mode_.query_node.empty(); });
-        cv_in_flight_.wait(lock, [this]() { return 0 == in_flight_; });
+  template<typename BeginWorkHandler, typename DoQueryHandler>
+  void set_query_mode(BeginWorkHandler&& begin_work_cb, DoQueryHandler&& cb)
+  {
+    std::unique_lock<std::mutex> lock(mutex_);
+    // called within an op, so decrement in_flight from that op, wait for
+    // other in_flight to complete.
+    in_flight_--;
+    if (mode_.mode == attempt_mode::modes::KV) {
+      // wait until all in_flight ops are done
+      CB_TXN_LOG_TRACE("set_query_mode: waiting for in_flight ops to go to 0...");
+      cv_in_flight_.wait(lock, [this]() {
+        return (0 == in_flight_);
+      });
+      // ok, now no outstanding ops(apart from the query that called this), and I have the lock,
+      // so...
+      if (mode_.mode == attempt_mode::modes::KV) {
+        CB_TXN_LOG_TRACE("set_query_mode: in_flight ops = 0, we were kv, setting mode to query");
+        // still kv, so now (while blocking) set the mode
+        mode_.mode = attempt_mode::modes::QUERY;
+        // ok to unlock now, as any racing set_query_mode will wait for
+        // a node to be set.
         in_flight_++;
-        CB_TXN_LOG_TRACE("set_query_mode: node set, continuing...");
         lock.unlock();
-        cb();
-    }
-    void reset_query_mode()
-    {
-        // when begin work errors out, it is fatal, so reset to kv mode here, allowing
-        // rollback to function properly.
-        std::unique_lock<std::mutex> lock;
-        mode_.mode = attempt_mode::modes::KV;
-        cv_query_.notify_all();
+        // now (outside the lock), call the callback, which does the begin_work
+        // when initially setting query mode.
+        begin_work_cb();
+        return;
+      }
     }
+    // you make it here, and someone else is currently setting the node (a byproduct of
+    // calling the callback).  So wait for that.
+    CB_TXN_LOG_TRACE("set_query_mode: mode already query, waiting for node to be set...");
+    cv_query_.wait(lock, [this]() {
+      return !mode_.query_node.empty();
+    });
+    cv_in_flight_.wait(lock, [this]() {
+      return 0 == in_flight_;
+    });
+    in_flight_++;
+    CB_TXN_LOG_TRACE("set_query_mode: node set, continuing...");
+    lock.unlock();
+    cb();
+  }
+  void reset_query_mode()
+  {
+    // when begin work errors out, it is fatal, so reset to kv mode here, allowing
+    // rollback to function properly.
+    std::unique_lock<std::mutex> lock;
+    mode_.mode = attempt_mode::modes::KV;
+    cv_query_.notify_all();
+  }
 
-    void set_query_node(const std::string& node)
-    {
-        std::unique_lock<std::mutex> lock(mutex_);
-        assert(mode_.mode == attempt_mode::modes::QUERY);
-        mode_.query_node = node;
-        // now notify everyone waiting in get_mode()
-        cv_query_.notify_all();
-    }
-    void decrement_in_flight()
-    {
-        std::lock_guard<std::mutex> lock(mutex_);
-        in_flight_--;
-        CB_TXN_LOG_TRACE("in_flight decremented to {}", in_flight_);
-        assert(in_flight_ >= 0);
-        if (0 == in_flight_) {
-            cv_in_flight_.notify_all();
-        }
+  void set_query_node(const std::string& node)
+  {
+    std::unique_lock<std::mutex> lock(mutex_);
+    assert(mode_.mode == attempt_mode::modes::QUERY);
+    mode_.query_node = node;
+    // now notify everyone waiting in get_mode()
+    cv_query_.notify_all();
+  }
+  void decrement_in_flight()
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    in_flight_--;
+    CB_TXN_LOG_TRACE("in_flight decremented to {}", in_flight_);
+    assert(in_flight_ >= 0);
+    if (0 == in_flight_) {
+      cv_in_flight_.notify_all();
     }
+  }
 
-  private:
-    void change_count(int32_t val)
-    {
-        std::lock_guard<std::mutex> lock(mutex_);
-        if (allow_ops_) {
-            count_ += val;
-            if (val > 0) {
-                in_flight_ += val;
-            }
-            CB_TXN_LOG_TRACE("op count changed by {} to {}, {} in_flight", val, count_, in_flight_);
-            assert(count_ >= 0);
-            assert(in_flight_ >= 0);
-            if (0 == count_) {
-                cv_ops_.notify_all();
-            }
-            if (0 == in_flight_) {
-                cv_in_flight_.notify_all();
-            }
-        } else {
-            CB_TXN_LOG_ERROR("operation attempted after commit/rollback");
-            throw async_operation_conflict("Operation attempted after commit or rollback");
-        }
+private:
+  void change_count(int32_t val)
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (allow_ops_) {
+      count_ += val;
+      if (val > 0) {
+        in_flight_ += val;
+      }
+      CB_TXN_LOG_TRACE("op count changed by {} to {}, {} in_flight", val, count_, in_flight_);
+      assert(count_ >= 0);
+      assert(in_flight_ >= 0);
+      if (0 == count_) {
+        cv_ops_.notify_all();
+      }
+      if (0 == in_flight_) {
+        cv_in_flight_.notify_all();
+      }
+    } else {
+      CB_TXN_LOG_ERROR("operation attempted after commit/rollback");
+      throw async_operation_conflict("Operation attempted after commit or rollback");
     }
+  }
 
-  private:
-    int32_t count_;
-    bool allow_ops_;
-    attempt_mode mode_;
-    int32_t in_flight_;
-    std::condition_variable cv_ops_;
-    std::condition_variable cv_query_;
-    std::condition_variable cv_in_flight_;
-    std::mutex mutex_;
+private:
+  int32_t count_;
+  bool allow_ops_;
+  attempt_mode mode_;
+  int32_t in_flight_;
+  std::condition_variable cv_ops_;
+  std::condition_variable cv_query_;
+  std::condition_variable cv_in_flight_;
+  std::mutex mutex_;
 };
 } // namespace couchbase::core::transactions