couchbase 4.2.0 → 4.2.2

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

@@ -1,59 +0,0 @@
-/*
- *     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 "internal/get_and_open_buckets.hxx"
-
-#include "core/cluster.hxx"
-#include "core/operations/management/bucket_get_all.hxx"
-
-#include <condition_variable>
-
-namespace couchbase::core::transactions
-{
-std::list<std::string>
-get_and_open_buckets(std::shared_ptr<core::cluster> c)
-{
-    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>();
-    std::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](core::operations::management::bucket_get_all_response resp) {
-        {
-            std::unique_lock lock(*mtx);
-            // now set count to correct # of buckets to try to open
-            count = resp.buckets.size();
-        }
-        for (const auto& b : resp.buckets) {
-            // open the bucket
-            c->open_bucket(b.name, [cv, name = b.name, &bucket_names, mtx, &count](std::error_code ec) {
-                std::unique_lock lock(*mtx);
-                if (!ec) {
-                    // push bucket name into list only if we successfully opened it
-                    bucket_names.push_back(name);
-                }
-                if (--count == 0) {
-                    cv->notify_all();
-                }
-            });
-        }
-    });
-    std::unique_lock<std::mutex> lock(*mtx);
-    cv->wait(lock);
-    return bucket_names;
-}
-} // namespace couchbase::core::transactions

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

@@ -1,107 +0,0 @@
-/*
- *     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 "internal/logging.hxx"
-#include "core/transactions.hxx"
-
-#include <spdlog/sinks/stdout_sinks.h>
-
-namespace couchbase::core::transactions
-{
-// TODO: consider always using async logger?  Makes life easier, I think, in
-//       wrappers.  For instance, in python the GIL may, or may not, be held
-//       by the thread that is logging.   So there are deadlock possibilities
-//       that can only be worked around by making the custom sink asynchronous.
-//       A single thread in the thread pool that services each async logger would
-//       keep ordering in place, _and_ make a much simpler sink to implement.
-//       That would have to also be done in the client, and of course, there is the
-//       sizing of the queue to take into account, etc...
-std::shared_ptr<spdlog::logger>
-init_txn_log()
-{
-    static auto txnlogger = spdlog::stderr_logger_mt(TXN_LOG);
-    return txnlogger;
-}
-
-std::shared_ptr<spdlog::logger>
-init_attempt_cleanup_log()
-{
-    static auto txnlogger = spdlog::stderr_logger_mt(ATTEMPT_CLEANUP_LOG);
-    return txnlogger;
-}
-std::shared_ptr<spdlog::logger>
-init_lost_attempts_log()
-{
-    static auto txnlogger = spdlog::stderr_logger_mt(LOST_ATTEMPT_CLEANUP_LOG);
-    return txnlogger;
-}
-
-// TODO: better integration with client, so we don't need to repeat this private
-// method.
-spdlog::level::level_enum
-translate_level(core::logger::level level)
-{
-    switch (level) {
-        case core::logger::level::trace:
-            return spdlog::level::level_enum::trace;
-        case core::logger::level::debug:
-            return spdlog::level::level_enum::debug;
-        case core::logger::level::info:
-            return spdlog::level::level_enum::info;
-        case core::logger::level::warn:
-            return spdlog::level::level_enum::warn;
-        case core::logger::level::err:
-            return spdlog::level::level_enum::err;
-        case core::logger::level::critical:
-            return spdlog::level::level_enum::critical;
-        case core::logger::level::off:
-            return spdlog::level::level_enum::off;
-    }
-    return spdlog::level::level_enum::trace;
-}
-
-void
-set_transactions_log_level(core::logger::level level)
-{
-    spdlog::level::level_enum lvl = translate_level(level);
-    txn_log->set_level(lvl);
-    attempt_cleanup_log->set_level(lvl);
-    lost_attempts_cleanup_log->set_level(lvl);
-}
-
-// This cannot be done in multiple threads at the same time.   We could
-// consider a mutex, but eventually we will merge with the cxx_client so
-// this will be fine for now.   Unsure if this will lead to issues if called
-// while logging is happening in other threads.  Do this once, at startup.
-void
-create_loggers(core::logger::level level, spdlog::sink_ptr sink)
-{
-    if (nullptr != sink) {
-        sink->set_level(translate_level(level));
-        txn_log->flush();
-        txn_log->sinks().clear();
-        txn_log->sinks().push_back(sink);
-        attempt_cleanup_log->flush();
-        attempt_cleanup_log->sinks().clear();
-        attempt_cleanup_log->sinks().push_back(sink);
-        lost_attempts_cleanup_log->flush();
-        lost_attempts_cleanup_log->sinks().clear();
-        lost_attempts_cleanup_log->sinks().push_back(sink);
-    }
-    set_transactions_log_level(level);
-}
-
-} // namespace couchbase::core::transactions

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

@@ -1,76 +0,0 @@
-/*
- *     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 "attempt_context_testing_hooks.hxx"
-#include "cleanup_testing_hooks.hxx"
-
-#include "couchbase/transactions/transaction_config.hxx"
-
-namespace couchbase::transactions
-{
-
-transaction_config::transaction_config()
-  : level_(couchbase::durability_level::majority)
-  , cleanup_window_(std::chrono::seconds(120))
-  , expiration_time_(std::chrono::seconds(15))
-  , cleanup_lost_attempts_(true)
-  , cleanup_client_attempts_(true)
-  , attempt_context_hooks_(new core::transactions::attempt_context_testing_hooks())
-  , cleanup_hooks_(new core::transactions::cleanup_testing_hooks())
-  , scan_consistency_(query_scan_consistency::request_plus)
-{
-}
-
-transaction_config::~transaction_config() = default;
-
-transaction_config::transaction_config(const transaction_config& config)
-  : level_(config.durability_level())
-  , cleanup_window_(config.cleanup_window())
-  , expiration_time_(config.expiration_time())
-  , cleanup_lost_attempts_(config.cleanup_lost_attempts())
-  , cleanup_client_attempts_(config.cleanup_client_attempts())
-  , attempt_context_hooks_(new core::transactions::attempt_context_testing_hooks(config.attempt_context_hooks()))
-  , cleanup_hooks_(new core::transactions::cleanup_testing_hooks(config.cleanup_hooks()))
-  , scan_consistency_(config.scan_consistency())
-  , custom_metadata_collection_(config.custom_metadata_collection())
-
-{
-}
-
-transaction_config&
-transaction_config::operator=(const transaction_config& c)
-{
-    level_ = c.durability_level();
-    cleanup_window_ = c.cleanup_window();
-    expiration_time_ = c.expiration_time();
-    cleanup_lost_attempts_ = c.cleanup_lost_attempts();
-    cleanup_client_attempts_ = c.cleanup_client_attempts();
-    attempt_context_hooks_.reset(new core::transactions::attempt_context_testing_hooks(c.attempt_context_hooks()));
-    cleanup_hooks_.reset(new core::transactions::cleanup_testing_hooks(c.cleanup_hooks()));
-    scan_consistency_ = c.scan_consistency();
-    custom_metadata_collection_ = c.custom_metadata_collection();
-    return *this;
-}
-
-void
-transaction_config::test_factories(core::transactions::attempt_context_testing_hooks& hooks,
-                                   core::transactions::cleanup_testing_hooks& cleanup_hooks)
-{
-    attempt_context_hooks_.reset(new core::transactions::attempt_context_testing_hooks(hooks));
-    cleanup_hooks_.reset(new core::transactions::cleanup_testing_hooks(cleanup_hooks));
-}
-
-} // namespace couchbase::transactions

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

@@ -1,39 +0,0 @@
-/*
- *     Copyright 2022 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 "transaction_query_options.hxx"
-#include "internal/transaction_context.hxx"
-
-namespace couchbase::core::transactions
-{
-
-core::operations::query_request
-transaction_query_options::wrap_request(const transaction_context& txn_context) const
-{
-    // set timeout stuff using the config/context.
-    // extra time so we don't timeout right at expiry.
-    auto extra =
-      txn_context.config().kv_timeout() ? txn_context.config().kv_timeout().value() : core::timeout_defaults::key_value_durable_timeout;
-    core::operations::query_request req = query_req_;
-    if (!req.scan_consistency) {
-        req.scan_consistency = txn_context.config().scan_consistency();
-    }
-    auto remaining = std::chrono::duration_cast<std::chrono::milliseconds>(txn_context.remaining());
-    req.timeout = remaining + extra;
-    req.raw["txtimeout"] = fmt::format("\"{}ms\"", remaining.count());
-    req.timeout = std::chrono::duration_cast<std::chrono::milliseconds>(txn_context.remaining()) + extra;
-    return req;
-}
-} // namespace couchbase::core::transactions

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

@@ -1,265 +0,0 @@
-/*
- *     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 "couchbase/transactions/transaction_keyspace.hxx"
-
-#include "core/document_id.hxx"
-#include "couchbase/query_scan_consistency.hxx"
-
-#include <chrono>
-#include <memory>
-#include <optional>
-
-namespace couchbase::core::transactions
-{
-/** @internal */
-struct attempt_context_testing_hooks;
-
-/** @internal */
-struct cleanup_testing_hooks;
-} // namespace couchbase::core::transactions
-
-namespace couchbase::transactions
-{
-/**
- * @brief Configuration parameters for transactions.
- */
-class transaction_config
-{
-  public:
-    transaction_config();
-
-    ~transaction_config();
-
-    transaction_config(const transaction_config& c);
-
-    transaction_config& operator=(const transaction_config& c);
-
-    /**
-     * @brief Get the default durability level for all transaction operations
-     *
-     * @return The default durability level used for write operations.
-     */
-    [[nodiscard]] couchbase::durability_level durability_level() const
-    {
-        return level_;
-    }
-
-    /**
-     * @brief Set the default durability level for all transaction operations
-     *
-     * @param level The default durability level desired for write operations.
-     */
-    void durability_level(enum couchbase::durability_level level)
-    {
-        level_ = level;
-    }
-
-    /**
-     * @brief Get cleanup window
-     *
-     * Each @ref transactions instance has background threads which looks for evidence of
-     * transactions that somehow were not cleaned up during ordinary processing.  There is one
-     * of these per bucket.  The thread looks through the active transaction records on that bucket
-     * once during each window.  There are potentially 1024 of these records, so over one cleanup
-     * window period, the thread will look for all 1024 of these, and examine any it finds.  Note
-     * you can disable this by setting @ref cleanup_lost_attempts() false.
-     *
-     * @return The cleanup window.
-     */
-    [[nodiscard]] std::chrono::milliseconds cleanup_window() const
-    {
-        return cleanup_window_;
-    }
-
-    /**
-     * @brief Set cleanup window
-     *
-     * @see cleanup_window() for more info.
-     * @param duration An std::chrono::duration representing the cleanup window duration.
-     */
-    template<typename T>
-    void cleanup_window(T duration)
-    {
-        cleanup_window_ = std::chrono::duration_cast<std::chrono::milliseconds>(duration);
-    }
-
-    /**
-     * @brief Set kv_timeout
-     *
-     * @see kv_timeout()
-     * @param duration An std::chrono::duration representing the desired default kv operation timeout.
-     */
-    template<typename T>
-    void kv_timeout(T duration)
-    {
-        kv_timeout_ = std::chrono::duration_cast<std::chrono::milliseconds>(duration);
-    }
-
-    /**
-     * @brief Get kv_timeout
-     *
-     * This is the default kv operation timeout used throughout the transactions.  Note all the operations
-     * have an options class which allows you to override this value for a particular operation, if desired.
-     *
-     * @return The default kv operation timeout.
-     */
-    [[nodiscard]] std::optional<std::chrono::milliseconds> kv_timeout() const
-    {
-        return kv_timeout_;
-    }
-
-    /**
-     * @brief Get expiration time for transactions
-     *
-     * Transactions can conflict with eachother (or other operations on those documents), and may retry.
-     * This is the maximum time a transaction can take, including any retries.  The transaction will throw
-     * an @ref transaction_expired and rollback when this occurs.
-     *
-     * @return expiration time for transactions.
-     */
-    [[nodiscard]] std::chrono::nanoseconds expiration_time() const
-    {
-        return expiration_time_;
-    }
-    /**
-     * @brief Set the expiration time for transactions.
-     *
-     * @param duration desired expiration for transactions. see @expiration_time().
-     */
-    template<typename T>
-    void expiration_time(T duration)
-    {
-        expiration_time_ = std::chrono::duration_cast<std::chrono::nanoseconds>(duration);
-    }
-    /**
-     *  @brief Set default scan consistency for all transactional query operations.
-     *
-     * @param scan_consistency Desired default scan consistency
-     */
-    void scan_consistency(query_scan_consistency scan_consistency)
-    {
-        scan_consistency_ = scan_consistency;
-    }
-    /**
-     * @brief Get default scan consistency for all transactional query operations.
-     *
-     * @return scan consistency for transactional query operations.
-     */
-    [[nodiscard]] query_scan_consistency scan_consistency() const
-    {
-        return scan_consistency_;
-    }
-
-    /**
-     * @brief Enable/disable the lost attempts cleanup loop.
-     * @see @ref cleanup_window() for description of the cleanup lost attempts loop.
-     *
-     * @param value If false, do not start the lost attempts cleanup threads.
-     */
-    void cleanup_lost_attempts(bool value)
-    {
-        cleanup_lost_attempts_ = value;
-    }
-    /**
-     * @brief Get lost attempts cleanup loop status.
-     * @see @ref cleanup_window() for description of the lost attempts cleanup loop.
-     *
-     * @return If false, no lost attempts cleanup threads will be launched.
-     */
-    [[nodiscard]] bool cleanup_lost_attempts() const
-    {
-        return cleanup_lost_attempts_;
-    }
-
-    /**
-     * @brief Set state for the client attempts cleanup loop.
-     * @see @ref cleanup_client_attempts()
-     *
-     * @param value If true, run the cleanup client attempts loop.
-     */
-    void cleanup_client_attempts(bool value)
-    {
-        cleanup_client_attempts_ = value;
-    }
-
-    /**
-     * @brief Get state of client attempts cleanup loop.
-     *
-     * A transactions object will create a background thread to do any cleanup necessary
-     * for the transactions it has attempted.  This can be disabled if set to false.
-     *
-     * @return true if the thread is enabled, false if not.
-     */
-    [[nodiscard]] bool cleanup_client_attempts() const
-    {
-        return cleanup_client_attempts_;
-    }
-
-    void custom_metadata_collection(const couchbase::transactions::transaction_keyspace& keyspace)
-    {
-        custom_metadata_collection_ = keyspace;
-    }
-
-    void custom_metadata_collection(const std::string& bucket, const std::string& scope, const std::string& collection)
-    {
-        custom_metadata_collection_.emplace(bucket, scope, collection);
-    }
-
-    [[nodiscard]] std::optional<couchbase::transactions::transaction_keyspace> custom_metadata_collection() const
-    {
-        return custom_metadata_collection_;
-    }
-
-    core::document_id atr_id_from_bucket_and_key(const std::string& bucket, const std::string& key) const
-    {
-        if (custom_metadata_collection_) {
-            return {
-                custom_metadata_collection_->bucket, custom_metadata_collection_->scope, custom_metadata_collection_->collection, key
-            };
-        }
-        return { bucket, couchbase::scope::default_name, couchbase::collection::default_name, key };
-    }
-
-    /** @internal */
-    void test_factories(core::transactions::attempt_context_testing_hooks& hooks, core::transactions::cleanup_testing_hooks& cleanup_hooks);
-
-    /** @internal */
-    core::transactions::attempt_context_testing_hooks& attempt_context_hooks() const
-    {
-        return *attempt_context_hooks_;
-    }
-
-    /** @internal */
-    core::transactions::cleanup_testing_hooks& cleanup_hooks() const
-    {
-        return *cleanup_hooks_;
-    }
-
-  protected:
-    couchbase::durability_level level_;
-    std::chrono::milliseconds cleanup_window_;
-    std::chrono::nanoseconds expiration_time_;
-    std::optional<std::chrono::milliseconds> kv_timeout_;
-    bool cleanup_lost_attempts_;
-    bool cleanup_client_attempts_;
-    std::unique_ptr<core::transactions::attempt_context_testing_hooks> attempt_context_hooks_;
-    std::unique_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks_;
-    query_scan_consistency scan_consistency_;
-    std::optional<couchbase::transactions::transaction_keyspace> custom_metadata_collection_;
-};
-} // namespace couchbase::transactions