couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/internal/transactions_cleanup.hxx

@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <couchbase/cluster.hxx>
+#include <core/cluster.hxx>
 #include <couchbase/transactions/transaction_config.hxx>
 
 #include <atomic>
@@ -26,20 +26,13 @@
 #include "atr_cleanup_entry.hxx"
 #include "client_record.hxx"
 
-namespace couchbase
-{
-namespace client
-{
-    class cluster;
-}
-
-namespace transactions
+namespace couchbase::transactions
 {
     // only really used when we force cleanup, in tests
     class transactions_cleanup_attempt
     {
       private:
-        const couchbase::document_id atr_id_;
+        const core::document_id atr_id_;
         const std::string attempt_id_;
         const std::string atr_bucket_name_;
         bool success_;
@@ -56,7 +49,7 @@ namespace transactions
         {
             success_ = success;
         }
-        CB_NODISCARD const couchbase::document_id& atr_id() const
+        CB_NODISCARD const core::document_id& atr_id() const
         {
             return atr_id_;
         }
@@ -92,10 +85,10 @@ namespace transactions
     class transactions_cleanup
     {
       public:
-        transactions_cleanup(couchbase::cluster& cluster, const transaction_config& config);
+        transactions_cleanup(core::cluster& cluster, const transaction_config& config);
         ~transactions_cleanup();
 
-        CB_NODISCARD couchbase::cluster& cluster_ref() const
+        CB_NODISCARD core::cluster& cluster_ref() const
         {
             return cluster_;
         };
@@ -118,13 +111,13 @@ namespace transactions
         // only used for testing
         void force_cleanup_entry(atr_cleanup_entry& entry, transactions_cleanup_attempt& attempt);
         // only used for testing
-        const atr_cleanup_stats force_cleanup_atr(const couchbase::document_id& atr_id, std::vector<transactions_cleanup_attempt>& results);
+        const atr_cleanup_stats force_cleanup_atr(const core::document_id& atr_id, std::vector<transactions_cleanup_attempt>& results);
         const client_record_details get_active_clients(const std::string& bucket_name, const std::string& uuid);
         void remove_client_record_from_all_buckets(const std::string& uuid);
         void close();
 
       private:
-        couchbase::cluster& cluster_;
+        core::cluster& cluster_;
         const transaction_config& config_;
         const std::chrono::milliseconds cleanup_loop_delay_{ 100 };
 
@@ -144,9 +137,8 @@ namespace transactions
         void lost_attempts_loop();
         void clean_lost_attempts_in_bucket(const std::string& bucket_name);
         void create_client_record(const std::string& bucket_name);
-        const atr_cleanup_stats handle_atr_cleanup(const couchbase::document_id& atr_id,
+        const atr_cleanup_stats handle_atr_cleanup(const core::document_id& atr_id,
                                                    std::vector<transactions_cleanup_attempt>* result = nullptr);
         std::atomic<bool> running_{ false };
     };
-} // namespace transactions
-} // namespace couchbase
+    } // namespace couchbase::transactions

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/internal/utils.hxx

@@ -17,9 +17,10 @@
 #include "../../../../src/transactions/result.hxx"
 #include "couchbase/transactions/internal/exceptions_internal.hxx"
 #include <chrono>
-#include <couchbase/errors.hxx>
-#include <couchbase/operations.hxx>
-#include <couchbase/operations/management/bucket_get_all.hxx>
+#include <core/cluster.hxx>
+#include <core/operations.hxx>
+#include <core/operations/management/bucket_get_all.hxx>
+#include <couchbase/error_codes.hxx>
 #include <couchbase/transactions/transaction_config.hxx>
 #include <functional>
 #include <future>
@@ -61,39 +62,39 @@ namespace transactions
         return obj.dump();
     }
 
-    static inline std::string collection_spec_from_id(const couchbase::document_id& id)
+    static inline std::string collection_spec_from_id(const core::document_id& id)
     {
         std::string retval = id.scope();
         return retval.append(".").append(id.collection());
     }
 
-    static inline bool document_ids_equal(const couchbase::document_id& id1, const couchbase::document_id& id2)
+    static inline bool document_ids_equal(const core::document_id& id1, const core::document_id& id2)
     {
         return id1.key() == id2.key() && id1.bucket() == id2.bucket() && id1.scope() == id2.scope() && id1.collection() == id2.collection();
     }
 
     template<typename OStream>
-    OStream& operator<<(OStream& os, const couchbase::document_id& id)
+    OStream& operator<<(OStream& os, const core::document_id& id)
     {
         os << "document_id{bucket: " << id.bucket() << ", scope: " << id.scope() << ", collection: " << id.collection()
            << ", key: " << id.key() << "}";
         return os;
     }
 
-    static inline protocol::durability_level durability(durability_level level)
+    static inline couchbase::durability_level durability(durability_level level)
     {
         switch (level) {
             case durability_level::NONE:
-                return protocol::durability_level::none;
+                return couchbase::durability_level::none;
             case durability_level::MAJORITY:
-                return protocol::durability_level::majority;
+                return couchbase::durability_level::majority;
             case durability_level::MAJORITY_AND_PERSIST_TO_ACTIVE:
-                return protocol::durability_level::majority_and_persist_to_active;
+                return couchbase::durability_level::majority_and_persist_to_active;
             case durability_level::PERSIST_TO_MAJORITY:
-                return protocol::durability_level::persist_to_majority;
+                return couchbase::durability_level::persist_to_majority;
             default:
                 // mimic java here
-                return protocol::durability_level::majority;
+                return couchbase::durability_level::majority;
         }
     }
 
@@ -131,7 +132,7 @@ namespace transactions
         // 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::error::key_value_errc::document_not_found;
+            res.ec = couchbase::errc::key_value::document_not_found;
             throw client_error(res);
         }
         if (!res.values.empty() && !ignore_subdoc_errors) {
@@ -161,12 +162,12 @@ namespace transactions
     template<typename Resp>
     static bool is_error(const Resp& resp)
     {
-        return !!resp.ctx.ec;
+        return !!resp.ctx.ec();
     }
     template<>
-    bool is_error(const couchbase::operations::mutate_in_response& resp)
+    bool is_error(const core::operations::mutate_in_response& resp)
     {
-        return resp.ctx.ec || resp.first_error_index;
+        return resp.ctx.ec() || resp.ctx.first_error_index();
     }
 
     template<typename Resp>
@@ -176,16 +177,16 @@ namespace transactions
     }
 
     template<>
-    std::optional<error_class> error_class_from_response_extras(const couchbase::operations::mutate_in_response& resp)
+    std::optional<error_class> error_class_from_response_extras(const core::operations::mutate_in_response& resp)
     {
-        if (!resp.first_error_index) {
+        if (!resp.ctx.first_error_index()) {
             return {};
         }
-        auto status = resp.fields.at(*resp.first_error_index).status;
-        if (status == couchbase::protocol::status::subdoc_path_not_found) {
+        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 == couchbase::protocol::status::subdoc_path_exists) {
+        if (status == key_value_status_code::subdoc_path_exists) {
             return FAIL_PATH_ALREADY_EXISTS;
         }
         return FAIL_OTHER;
@@ -197,35 +198,33 @@ namespace transactions
         if (!is_error(resp)) {
             return {};
         }
-        if (resp.ctx.ec == couchbase::error::key_value_errc::document_not_found) {
+        if (resp.ctx.ec() == couchbase::errc::key_value::document_not_found) {
             return FAIL_DOC_NOT_FOUND;
         }
-        if (resp.ctx.ec == couchbase::error::key_value_errc::document_exists) {
+        if (resp.ctx.ec() == couchbase::errc::key_value::document_exists) {
             return FAIL_DOC_ALREADY_EXISTS;
         }
-        if (resp.ctx.ec == couchbase::error::common_errc::cas_mismatch) {
+        if (resp.ctx.ec() == couchbase::errc::common::cas_mismatch) {
             return FAIL_CAS_MISMATCH;
         }
-        if (resp.ctx.ec == couchbase::error::key_value_errc::value_too_large) {
+        if (resp.ctx.ec() == couchbase::errc::key_value::value_too_large) {
             return FAIL_ATR_FULL;
         }
-        if (resp.ctx.ec == couchbase::error::common_errc::unambiguous_timeout ||
-            resp.ctx.ec == couchbase::error::common_errc::temporary_failure ||
-            resp.ctx.ec == couchbase::error::key_value_errc::durable_write_in_progress) {
+        if (resp.ctx.ec() == couchbase::errc::common::unambiguous_timeout || resp.ctx.ec() == couchbase::errc::common::temporary_failure ||
+            resp.ctx.ec() == couchbase::errc::key_value::durable_write_in_progress) {
             return FAIL_TRANSIENT;
         }
-        if (resp.ctx.ec == couchbase::error::key_value_errc::durability_ambiguous ||
-            resp.ctx.ec == couchbase::error::common_errc::ambiguous_timeout ||
-            resp.ctx.ec == couchbase::error::common_errc::request_canceled) {
+        if (resp.ctx.ec() == couchbase::errc::key_value::durability_ambiguous ||
+            resp.ctx.ec() == couchbase::errc::common::ambiguous_timeout || resp.ctx.ec() == couchbase::errc::common::request_canceled) {
             return FAIL_AMBIGUOUS;
         }
-        if (resp.ctx.ec == couchbase::error::key_value_errc::path_not_found) {
+        if (resp.ctx.ec() == couchbase::errc::key_value::path_not_found) {
             return FAIL_PATH_NOT_FOUND;
         }
-        if (resp.ctx.ec == couchbase::error::key_value_errc::path_exists) {
+        if (resp.ctx.ec() == couchbase::errc::key_value::path_exists) {
             return FAIL_PATH_ALREADY_EXISTS;
         }
-        if (resp.ctx.ec) {
+        if (resp.ctx.ec()) {
             return FAIL_OTHER;
         }
         return error_class_from_response_extras(resp);
@@ -373,15 +372,15 @@ namespace transactions
         }
     };
 
-    static std::list<std::string> get_and_open_buckets(cluster& c)
+    static std::list<std::string> get_and_open_buckets(core::cluster& c)
     {
-        couchbase::operations::management::bucket_get_all_request req{};
+        core::operations::management::bucket_get_all_request req{};
         // don't wrap this one, as the kv timeout isn't appropriate here.
         auto mtx = std::make_shared<std::mutex>();
         auto cv = std::make_shared<std::condition_variable>();
         size_t count = 1; // non-zero so we know not to stop waiting immediately
         std::list<std::string> bucket_names;
-        c.execute(req, [cv, &bucket_names, &c, mtx, &count](couchbase::operations::management::bucket_get_all_response resp) {
+        c.execute(req, [cv, &bucket_names, &c, mtx, &count](core::operations::management::bucket_get_all_response resp) {
             std::unique_lock<std::mutex> lock(*mtx);
             // now set count to correct # of buckets to try to open
             count = resp.buckets.size();

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/per_transaction_config.hxx

@@ -19,11 +19,11 @@
 #include <chrono>
 #include <optional>
 
-#include <couchbase/operations/document_query.hxx>
+#include <core/operations/document_query.hxx>
 #include <couchbase/transactions/durability_level.hxx>
 #include <couchbase/transactions/transaction_config.hxx>
 
-using couchbase::operations::query_request;
+using couchbase::core::operations::query_request;
 using couchbase::transactions::durability_level;
 using std::chrono::milliseconds;
 using std::chrono::nanoseconds;
@@ -44,12 +44,12 @@ class per_transaction_config
     {
         return durability_;
     }
-    per_transaction_config& scan_consistency(couchbase::query_scan_consistency scan_consistency)
+    per_transaction_config& scan_consistency(core::query_scan_consistency scan_consistency)
     {
         scan_consistency_ = scan_consistency;
         return *this;
     }
-    std::optional<couchbase::query_scan_consistency> scan_consistency()
+    std::optional<core::query_scan_consistency> scan_consistency()
     {
         return scan_consistency_;
     }
@@ -107,7 +107,7 @@ class per_transaction_config
 
   private:
     std::optional<couchbase::transactions::durability_level> durability_;
-    std::optional<couchbase::query_scan_consistency> scan_consistency_;
+    std::optional<couchbase::core::query_scan_consistency> scan_consistency_;
     std::optional<milliseconds> kv_timeout_;
     std::optional<nanoseconds> expiration_time_;
     std::optional<transaction_keyspace> custom_metadata_collection_;

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/transaction_config.hxx

@@ -16,7 +16,7 @@
 #pragma once
 
 #include <chrono>
-#include <couchbase/operations/document_query.hxx>
+#include <core/operations/document_query.hxx>
 #include <couchbase/support.hxx>
 #include <couchbase/transactions/durability_level.hxx>
 #include <couchbase/transactions/transaction_keyspace.hxx>
@@ -148,7 +148,7 @@ namespace transactions
          *
          * @param scan_consistency Desired default scan consistency
          */
-        void scan_consistency(couchbase::query_scan_consistency scan_consistency)
+        void scan_consistency(core::query_scan_consistency scan_consistency)
         {
             scan_consistency_ = scan_consistency;
         }
@@ -157,7 +157,7 @@ namespace transactions
          *
          * @return scan consistency for transactional query operations.
          */
-        CB_NODISCARD couchbase::query_scan_consistency scan_consistency() const
+        CB_NODISCARD core::query_scan_consistency scan_consistency() const
         {
             return scan_consistency_;
         }
@@ -222,7 +222,7 @@ namespace transactions
             return custom_metadata_collection_;
         }
 
-        couchbase::document_id atr_id_from_bucket_and_key(const std::string& bucket, const std::string& key) const
+        core::document_id atr_id_from_bucket_and_key(const std::string& bucket, const std::string& key) const
         {
             if (custom_metadata_collection_) {
                 return {
@@ -256,7 +256,7 @@ namespace transactions
         bool cleanup_client_attempts_;
         std::unique_ptr<attempt_context_testing_hooks> attempt_context_hooks_;
         std::unique_ptr<cleanup_testing_hooks> cleanup_hooks_;
-        couchbase::query_scan_consistency scan_consistency_;
+        core::query_scan_consistency scan_consistency_;
         std::optional<transaction_keyspace> custom_metadata_collection_;
     };
 } // namespace transactions

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/transaction_get_result.hxx

@@ -16,9 +16,9 @@
 
 #pragma once
 
-#include <couchbase/document_id.hxx>
+#include <core/document_id.hxx>
+#include <core/operations.hxx>
 #include <couchbase/internal/nlohmann/json.hpp>
-#include <couchbase/operations.hxx>
 #include <couchbase/transactions/document_metadata.hxx>
 #include <couchbase/transactions/transaction_links.hxx>
 #include <couchbase/transactions/transcoder.hxx>
@@ -38,7 +38,7 @@ namespace transactions
     {
       private:
         std::string value_;
-        couchbase::document_id id_;
+        core::document_id id_;
         uint64_t cas_;
         transaction_links links_;
 
@@ -67,7 +67,7 @@ namespace transactions
 
         /** @internal */
         template<typename Content>
-        transaction_get_result(const couchbase::document_id& id,
+        transaction_get_result(const core::document_id& id,
                                Content content,
                                uint64_t cas,
                                transaction_links links,
@@ -80,7 +80,7 @@ namespace transactions
         {
         }
         /** @internal */
-        transaction_get_result(const couchbase::document_id& id, const nlohmann::json& json)
+        transaction_get_result(const core::document_id& id, const nlohmann::json& json)
           : id_(id)
           , links_(json)
           , metadata_(json.contains("scas") ? json["scas"].get<std::string>() : "")
@@ -130,10 +130,10 @@ namespace transactions
         }
 
         /** @internal */
-        static transaction_get_result create_from(const couchbase::document_id& id, const result& res);
+        static transaction_get_result create_from(const core::document_id& id, const result& res);
 
         /** @internal */
-        static transaction_get_result create_from(const couchbase::operations::lookup_in_response& resp);
+        static transaction_get_result create_from(const core::operations::lookup_in_response& resp);
 
         /** @internal */
         template<typename Content>
@@ -202,7 +202,7 @@ namespace transactions
          *
          * @return the id of this document.
          */
-        CB_NODISCARD const couchbase::document_id& id() const
+        CB_NODISCARD const core::document_id& id() const
         {
             return id_;
         }

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/transaction_keyspace.hxx

@@ -15,7 +15,7 @@
  */
 #pragma once
 
-#include <couchbase/document_id.hxx>
+#include <core/document_id.hxx>
 #include <string>
 
 namespace couchbase::transactions
@@ -46,7 +46,7 @@ struct transaction_keyspace {
     {
     }
 
-    transaction_keyspace(const couchbase::document_id& id)
+    transaction_keyspace(const core::document_id& id)
       : bucket(id.bucket())
       , scope(id.scope())
       , collection(id.collection())

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/transaction_query_options.hxx

@@ -15,7 +15,8 @@
  */
 #pragma once
 
-#include <couchbase/operations/document_query.hxx>
+#include <core/operations/document_query.hxx>
+
 namespace couchbase::transactions
 {
 
@@ -29,17 +30,17 @@ class transaction_query_options
         // set defaults specific to query in transactions.
         query_req_.metrics = true;
     }
-    transaction_query_options(const couchbase::operations::query_request& req)
+    transaction_query_options(const core::operations::query_request& req)
       : query_req_(req)
     {
     }
 
-    couchbase::operations::query_request query_request() const
+    core::operations::query_request query_request() const
     {
         return query_req_;
     }
 
-    transaction_query_options& raw(const std::string& key, const couchbase::json_string& value)
+    transaction_query_options& raw(const std::string& key, const core::json_string& value)
     {
         query_req_.raw[key] = value;
         return *this;
@@ -51,13 +52,13 @@ class transaction_query_options
         return *this;
     }
 
-    transaction_query_options& scan_consistency(couchbase::query_scan_consistency scan_consistency)
+    transaction_query_options& scan_consistency(core::query_scan_consistency scan_consistency)
     {
         query_req_.scan_consistency = scan_consistency;
         return *this;
     }
 
-    transaction_query_options& profile(couchbase::query_profile_mode mode)
+    transaction_query_options& profile(core::query_profile_mode mode)
     {
         query_req_.profile = mode;
         return *this;
@@ -99,13 +100,13 @@ class transaction_query_options
         return *this;
     }
 
-    transaction_query_options& positional_parameters(std::vector<couchbase::json_string> params)
+    transaction_query_options& positional_parameters(std::vector<core::json_string> params)
     {
         query_req_.positional_parameters = params;
         return *this;
     }
 
-    transaction_query_options& named_parameters(std::map<std::string, couchbase::json_string> params)
+    transaction_query_options& named_parameters(std::map<std::string, core::json_string> params)
     {
         query_req_.named_parameters = params;
         return *this;
@@ -135,9 +136,9 @@ class transaction_query_options
         return *this;
     }
 
-    couchbase::operations::query_request wrap_request(const transaction_context& txn_ctx) const;
+    core::operations::query_request wrap_request(const transaction_context& txn_ctx) const;
 
   private:
-    couchbase::operations::query_request query_req_;
+    core::operations::query_request query_req_;
 };
 } // namespace couchbase::transactions

package/deps/couchbase-transactions-cxx/include/couchbase/transactions.hxx

@@ -20,8 +20,8 @@
 #include <functional>
 #include <thread>
 
-#include <couchbase/cluster.hxx>
-#include <couchbase/logger/logger.hxx>
+#include <core/cluster.hxx>
+#include <core/logger/logger.hxx>
 #include <couchbase/transactions/async_attempt_context.hxx>
 #include <couchbase/transactions/attempt_context.hxx>
 #include <couchbase/transactions/exceptions.hxx>
@@ -57,12 +57,12 @@ namespace transactions
     /**
      * @brief set log level for transactions
      */
-    void set_transactions_log_level(couchbase::logger::level level);
+    void set_transactions_log_level(core::logger::level level);
 
     /**
      * @brief create the loggers, using a custom spdlog::sink, if desired.
      */
-    void create_loggers(couchbase::logger::level level = couchbase::logger::level::off, spdlog::sink_ptr = nullptr);
+    void create_loggers(core::logger::level level = core::logger::level::off, spdlog::sink_ptr = nullptr);
 
     /**
      * @mainpage
@@ -137,7 +137,7 @@ namespace transactions
          * @param cluster The cluster to use for the transactions.
          * @param config The configuration parameters to use for the transactions.
          */
-        transactions(cluster& cluster, const transaction_config& config);
+        transactions(core::cluster& cluster, const transaction_config& config);
 
         /**
          * @brief Destructor
@@ -230,17 +230,17 @@ namespace transactions
         }
 
         /**
-         * @brief Return a reference to the @ref cluster
+         * @brief Return a reference to the @ref core::cluster
          *
          * @return Ref to the cluster used by this transaction object.
          */
-        CB_NODISCARD cluster& cluster_ref()
+        CB_NODISCARD core::cluster& cluster_ref()
         {
             return cluster_;
         }
 
       private:
-        cluster& cluster_;
+        core::cluster& cluster_;
         transaction_config config_;
         std::unique_ptr<transactions_cleanup> cleanup_;
         const size_t max_attempts_{ 1000 };

package/deps/couchbase-transactions-cxx/src/transactions/active_transaction_record.cxx

@@ -17,9 +17,8 @@
 #include "active_transaction_record.hxx"
 #include "couchbase/transactions/internal/exceptions_internal.hxx"
 #include "couchbase/transactions/internal/utils.hxx"
-#include <couchbase/cluster.hxx>
-#include <couchbase/errors.hxx>
-#include <couchbase/operations.hxx>
+#include <core/cluster.hxx>
+#include <core/operations.hxx>
 #include <optional>
 
 #include <future>