couchbase 4.1.2 → 4.1.3

package/deps/couchbase-cxx-client/couchbase/io/mcbp_traits.hxx

@@ -1,30 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-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 <type_traits>
-
-namespace couchbase::io::mcbp_traits
-{
-template<typename T>
-struct supports_durability : public std::false_type {
-};
-
-template<typename T>
-inline constexpr bool supports_durability_v = supports_durability<T>::value;
-} // namespace couchbase::io::mcbp_traits

package/deps/couchbase-cxx-client/couchbase/io/query_cache.hxx

@@ -1,61 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 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 <map>
-#include <mutex>
-#include <optional>
-#include <string>
-
-namespace couchbase
-{
-class query_cache
-{
-  public:
-    struct entry {
-        std::string name;
-        std::optional<std::string> plan{};
-    };
-
-    void put(const std::string& statement, const std::string& prepared)
-    {
-        std::scoped_lock lock(store_mutex_);
-        store_.try_emplace(statement, entry{ prepared });
-    }
-
-    void put(const std::string& statement, const std::string& name, const std::string& encoded_plan)
-    {
-        std::scoped_lock lock(store_mutex_);
-        store_.try_emplace(statement, entry{ name, encoded_plan });
-    }
-
-    std::optional<entry> get(const std::string& statement)
-    {
-        std::scoped_lock lock(store_mutex_);
-        auto it = store_.find(statement);
-        if (it == store_.end()) {
-            return {};
-        }
-        return it->second;
-    }
-
-  private:
-    std::map<std::string, entry> store_;
-    std::mutex store_mutex_{};
-};
-} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/io/retry_action.hxx

@@ -1,30 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 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 <chrono>
-#include <optional>
-
-namespace couchbase::io
-{
-struct retry_action {
-    bool retry_requested{ false };
-    std::chrono::milliseconds duration{};
-};
-
-} // namespace couchbase::io

package/deps/couchbase-cxx-client/couchbase/io/retry_context.hxx

@@ -1,38 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 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/io/retry_reason.hxx>
-#include <couchbase/io/retry_strategy.hxx>
-
-#include <chrono>
-#include <set>
-
-namespace couchbase::io
-{
-
-template<class RetryStrategy>
-struct retry_context {
-    bool idempotent;
-    int retry_attempts{ 0 };
-    std::chrono::milliseconds last_duration{ 0 };
-    std::set<retry_reason> reasons{};
-    RetryStrategy strategy{};
-};
-
-} // namespace couchbase::io

package/deps/couchbase-cxx-client/couchbase/io/retry_orchestrator.hxx

@@ -1,112 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 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/io/retry_action.hxx>
-#include <couchbase/io/retry_reason.hxx>
-#include <couchbase/logger/logger.hxx>
-
-#include <chrono>
-#include <memory>
-
-namespace couchbase::io::retry_orchestrator
-{
-
-namespace priv
-{
-template<class Command>
-std::chrono::milliseconds
-cap_duration(std::chrono::milliseconds uncapped, std::shared_ptr<Command> command)
-{
-    auto theoretical_deadline = std::chrono::steady_clock::now() + uncapped;
-    auto absolute_deadline = command->deadline.expiry();
-    if (auto delta = std::chrono::duration_cast<std::chrono::milliseconds>(theoretical_deadline - absolute_deadline); delta.count() > 0) {
-        auto capped = uncapped - delta;
-        if (capped.count() < 0) {
-            return uncapped; // something went wrong, return the uncapped one as a safety net
-        }
-        return capped;
-    }
-    return uncapped;
-}
-
-inline std::chrono::milliseconds
-controlled_backoff(int retry_attempts)
-{
-    switch (retry_attempts) {
-        case 0:
-            return std::chrono::milliseconds(1);
-        case 1:
-            return std::chrono::milliseconds(10);
-        case 2:
-            return std::chrono::milliseconds(50);
-        case 3:
-            return std::chrono::milliseconds(100);
-        case 4:
-            return std::chrono::milliseconds(500);
-        default:
-            return std::chrono::milliseconds(1000);
-    }
-}
-
-template<class Manager, class Command>
-void
-retry_with_duration(std::shared_ptr<Manager> manager,
-                    std::shared_ptr<Command> command,
-                    retry_reason reason,
-                    std::chrono::milliseconds duration)
-{
-    ++command->request.retries.retry_attempts;
-    command->request.retries.reasons.insert(reason);
-    command->request.retries.last_duration = duration;
-    LOG_TRACE(R"({} retrying operation {} (duration={}ms, id="{}", reason={}, attempts={}))",
-              manager->log_prefix(),
-              decltype(command->request)::encoded_request_type::body_type::opcode,
-              duration.count(),
-              command->id_,
-              reason,
-              command->request.retries.retry_attempts);
-    manager->schedule_for_retry(command, duration);
-}
-
-} // namespace priv
-
-template<class Manager, class Command>
-void
-maybe_retry(std::shared_ptr<Manager> manager, std::shared_ptr<Command> command, retry_reason reason, std::error_code ec)
-{
-    if (always_retry(reason)) {
-        return priv::retry_with_duration(manager, command, reason, priv::controlled_backoff(command->request.retries.retry_attempts));
-    }
-
-    if (retry_action action = command->request.retries.strategy.should_retry(command->request, reason); action.retry_requested) {
-        return priv::retry_with_duration(manager, command, reason, priv::cap_duration(action.duration, command));
-    }
-
-    LOG_TRACE(R"({} not retrying operation {} (id="{}", reason={}, attempts={}, ec={} ({})))",
-              manager->log_prefix(),
-              decltype(command->request)::encoded_request_type::body_type::opcode,
-              command->id_,
-              reason,
-              command->request.retries.retry_attempts,
-              ec.value(),
-              ec.message());
-    return command->invoke_handler(ec);
-}
-
-} // namespace couchbase::io::retry_orchestrator

package/deps/couchbase-cxx-client/couchbase/io/retry_reason.hxx

@@ -1,158 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 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::io
-{
-enum class retry_reason {
-    /**
-     * default value, e.g. when we don't need to retry
-     */
-    do_not_retry,
-
-    /**
-     * All unexpected/unknown retry errors must not be retried to avoid accidental data loss and non-deterministic behavior.
-     */
-    unknown,
-
-    /**
-     * The socket is not available into which the operation should’ve been written.
-     */
-    socket_not_available,
-
-    /**
-     * The service on a node (i.e. kv, query) is not available.
-     */
-    service_not_available,
-
-    /**
-     * The node where the operation is supposed to be dispatched to is not available.
-     */
-    node_not_available,
-
-    /**
-     * A not my vbucket response has been received.
-     */
-    kv_not_my_vbucket,
-
-    /**
-     * A KV response has been received which signals an outdated collection.
-     */
-    kv_collection_outdated,
-
-    /**
-     * An unknown response was returned and the consulted KV error map indicated a retry.
-     */
-    kv_error_map_retry_indicated,
-
-    kv_locked,
-
-    kv_temporary_failure,
-
-    kv_sync_write_in_progress,
-
-    kv_sync_write_re_commit_in_progress,
-
-    service_response_code_indicated,
-
-    /**
-     * While an operation was in-flight, the underlying socket has been closed.
-     */
-    socket_closed_while_in_flight,
-
-    /**
-     * The circuit breaker is open for the given socket/endpoint and as a result the operation is not sent into it.
-     */
-    circuit_breaker_open,
-
-    query_prepared_statement_failure,
-
-    query_index_not_found,
-
-    analytics_temporary_failure,
-
-    search_too_many_requests,
-
-    views_temporary_failure,
-
-    views_no_active_partition,
-};
-
-constexpr bool
-allows_non_idempotent_retry(retry_reason reason)
-{
-    switch (reason) {
-        case retry_reason::socket_not_available:
-        case retry_reason::service_not_available:
-        case retry_reason::node_not_available:
-        case retry_reason::kv_not_my_vbucket:
-        case retry_reason::kv_collection_outdated:
-        case retry_reason::kv_error_map_retry_indicated:
-        case retry_reason::kv_locked:
-        case retry_reason::kv_temporary_failure:
-        case retry_reason::kv_sync_write_in_progress:
-        case retry_reason::kv_sync_write_re_commit_in_progress:
-        case retry_reason::service_response_code_indicated:
-        case retry_reason::circuit_breaker_open:
-        case retry_reason::query_prepared_statement_failure:
-        case retry_reason::query_index_not_found:
-        case retry_reason::analytics_temporary_failure:
-        case retry_reason::search_too_many_requests:
-        case retry_reason::views_temporary_failure:
-        case retry_reason::views_no_active_partition:
-            return true;
-        case retry_reason::do_not_retry:
-        case retry_reason::socket_closed_while_in_flight:
-        case retry_reason::unknown:
-            return false;
-    }
-    return false;
-}
-
-constexpr bool
-always_retry(retry_reason reason)
-{
-    switch (reason) {
-        case retry_reason::kv_not_my_vbucket:
-        case retry_reason::kv_collection_outdated:
-        case retry_reason::views_no_active_partition:
-            return true;
-        case retry_reason::do_not_retry:
-        case retry_reason::socket_not_available:
-        case retry_reason::service_not_available:
-        case retry_reason::node_not_available:
-        case retry_reason::kv_error_map_retry_indicated:
-        case retry_reason::kv_locked:
-        case retry_reason::kv_temporary_failure:
-        case retry_reason::kv_sync_write_in_progress:
-        case retry_reason::kv_sync_write_re_commit_in_progress:
-        case retry_reason::service_response_code_indicated:
-        case retry_reason::socket_closed_while_in_flight:
-        case retry_reason::circuit_breaker_open:
-        case retry_reason::query_prepared_statement_failure:
-        case retry_reason::query_index_not_found:
-        case retry_reason::analytics_temporary_failure:
-        case retry_reason::search_too_many_requests:
-        case retry_reason::views_temporary_failure:
-        case retry_reason::unknown:
-            return false;
-    }
-    return false;
-}
-
-} // namespace couchbase::io

package/deps/couchbase-cxx-client/couchbase/io/retry_reason_fmt.hxx

@@ -1,103 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 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/io/retry_reason.hxx>
-
-#include <fmt/core.h>
-
-template<>
-struct fmt::formatter<couchbase::io::retry_reason> {
-    template<typename ParseContext>
-    constexpr auto parse(ParseContext& ctx)
-    {
-        return ctx.begin();
-    }
-
-    template<typename FormatContext>
-    auto format(couchbase::io::retry_reason reason, FormatContext& ctx) const
-    {
-        string_view name = "unknown";
-        switch (reason) {
-            case couchbase::io::retry_reason::do_not_retry:
-                name = "do_not_retry";
-                break;
-            case couchbase::io::retry_reason::unknown:
-                name = "unknown";
-                break;
-            case couchbase::io::retry_reason::socket_not_available:
-                name = "socket_not_available";
-                break;
-            case couchbase::io::retry_reason::service_not_available:
-                name = "service_not_available";
-                break;
-            case couchbase::io::retry_reason::node_not_available:
-                name = "node_not_available";
-                break;
-            case couchbase::io::retry_reason::kv_not_my_vbucket:
-                name = "kv_not_my_vbucket";
-                break;
-            case couchbase::io::retry_reason::kv_collection_outdated:
-                name = "kv_collection_outdated";
-                break;
-            case couchbase::io::retry_reason::kv_error_map_retry_indicated:
-                name = "kv_error_map_retry_indicated";
-                break;
-            case couchbase::io::retry_reason::kv_locked:
-                name = "kv_locked";
-                break;
-            case couchbase::io::retry_reason::kv_temporary_failure:
-                name = "kv_temporary_failure";
-                break;
-            case couchbase::io::retry_reason::kv_sync_write_in_progress:
-                name = "kv_sync_write_in_progress";
-                break;
-            case couchbase::io::retry_reason::kv_sync_write_re_commit_in_progress:
-                name = "kv_sync_write_re_commit_in_progress";
-                break;
-            case couchbase::io::retry_reason::service_response_code_indicated:
-                name = "service_response_code_indicated";
-                break;
-            case couchbase::io::retry_reason::socket_closed_while_in_flight:
-                name = "socket_closed_while_in_flight";
-                break;
-            case couchbase::io::retry_reason::circuit_breaker_open:
-                name = "circuit_breaker_open";
-                break;
-            case couchbase::io::retry_reason::query_prepared_statement_failure:
-                name = "query_prepared_statement_failure";
-                break;
-            case couchbase::io::retry_reason::query_index_not_found:
-                name = "query_index_not_found";
-                break;
-            case couchbase::io::retry_reason::analytics_temporary_failure:
-                name = "analytics_temporary_failure";
-                break;
-            case couchbase::io::retry_reason::search_too_many_requests:
-                name = "search_too_many_requests";
-                break;
-            case couchbase::io::retry_reason::views_temporary_failure:
-                name = "views_temporary_failure";
-                break;
-            case couchbase::io::retry_reason::views_no_active_partition:
-                name = "views_no_active_partition";
-                break;
-        }
-        return format_to(ctx.out(), "{}", name);
-    }
-};

package/deps/couchbase-cxx-client/couchbase/io/retry_strategy.hxx

@@ -1,152 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 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/io/retry_action.hxx>
-#include <couchbase/io/retry_reason.hxx>
-
-#include <cmath>
-#include <gsl/assert>
-
-namespace couchbase::io::retry_strategy
-{
-namespace backoff
-{
-struct backoff_delay {
-    std::chrono::milliseconds delay;
-    std::chrono::milliseconds min_delay;
-    std::chrono::milliseconds max_delay;
-};
-
-class fixed
-{
-  private:
-    backoff_delay delay_;
-
-  public:
-    explicit fixed(std::chrono::milliseconds delay)
-      : delay_{ delay, delay, delay }
-    {
-    }
-
-    template<class Request>
-    backoff_delay operator()(Request&)
-    {
-        return delay_;
-    }
-};
-
-class exponential
-{
-  public:
-    /**
-     * Backoff function with exponential backoff delay. Retries are performed after a backoff interval of
-     *
-     *   first_backoff * (factor^n)
-     *
-     * where n is the iteration. If max_backoff is not zero, the maximum backoff applied will be limited to max_backoff.
-     *
-     * If based_on_previous_value is true, backoff will be calculated using
-     *
-     *   prev_backoff * factor
-     *
-     * When backoffs are combined with jitter, this value will be different from the actual exponential value for the iteration.
-     *
-     * @param first_backoff First backoff duration
-     * @param factor The multiplicand for calculating backoff
-     * @param max_backoff Maximum backoff duration
-     * @param based_on_previous_value If true, calculation is based on previous value which may be a backoff with jitter applied
-     */
-    exponential(std::chrono::milliseconds first_backoff,
-                int factor,
-                std::chrono::milliseconds max_backoff = {},
-                bool based_on_previous_value = false)
-    {
-        Expects(first_backoff.count() > 0);
-        if (max_backoff.count() <= 0) {
-            max_backoff = std::chrono::milliseconds{ std::numeric_limits<std::chrono::milliseconds::rep>::max() };
-        }
-        Expects(max_backoff > first_backoff);
-        first_backoff_ = first_backoff;
-        max_backoff_ = max_backoff;
-        factor_ = factor;
-        based_on_previous_value_ = based_on_previous_value;
-    }
-
-    template<class Request>
-    backoff_delay operator()(Request& request)
-    {
-        std::chrono::milliseconds previous_backoff = request.retries.last_duration;
-        std::chrono::milliseconds next_backoff;
-
-        if (based_on_previous_value_) {
-            if (previous_backoff >= max_backoff_) {
-                next_backoff = max_backoff_;
-            } else {
-                next_backoff = previous_backoff * factor_;
-            }
-            if (next_backoff < first_backoff_) {
-                next_backoff = first_backoff_;
-            }
-        } else {
-            if (previous_backoff >= max_backoff_) {
-                next_backoff = max_backoff_;
-            } else {
-                next_backoff = first_backoff_ * static_cast<int>(std::pow(factor_, request.retries.retry_attempts));
-            }
-        }
-        return { next_backoff, first_backoff_, max_backoff_ };
-    }
-
-  private:
-    std::chrono::milliseconds first_backoff_;
-    std::chrono::milliseconds max_backoff_;
-    int factor_;
-    bool based_on_previous_value_;
-};
-
-} // namespace backoff
-
-class best_effort
-{
-  public:
-    template<class Request>
-    retry_action should_retry(Request& request, retry_reason reason)
-    {
-        if (request.retries.idempotent || allows_non_idempotent_retry(reason)) {
-            backoff::backoff_delay delay = backoff_(request);
-            return { true, delay.delay };
-        }
-        return { false };
-    }
-
-  private:
-    backoff::exponential backoff_{ std::chrono::milliseconds(1), 2, std::chrono::milliseconds(500) };
-};
-
-class fail_fast
-{
-  public:
-    template<class Request>
-    retry_action should_retry(Request&, retry_reason)
-    {
-        return { false };
-    }
-};
-
-} // namespace couchbase::io::retry_strategy