couchbase 4.1.1 → 4.1.3

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

@@ -0,0 +1,38 @@
+/* -*- 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::core::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;
+
+template<typename T>
+struct supports_parent_span : public std::false_type {
+};
+
+template<typename T>
+inline constexpr bool supports_parent_span_v = supports_parent_span<T>::value;
+
+} // namespace couchbase::core::io::mcbp_traits

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

@@ -0,0 +1,71 @@
+/* -*- 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::core
+{
+class query_cache
+{
+  public:
+    struct entry {
+        std::string name;
+        std::optional<std::string> plan{};
+    };
+
+    void erase(const std::string& statement)
+    {
+        std::scoped_lock lock(store_mutex_);
+        auto it = store_.find(statement);
+        if (it == store_.end()) {
+            return;
+        }
+        store_.erase(it);
+    }
+
+    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::core

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

@@ -0,0 +1,30 @@
+/* -*- 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::core::io
+{
+struct retry_action {
+    bool retry_requested{ false };
+    std::chrono::milliseconds duration{};
+};
+
+} // namespace couchbase::core::io

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

@@ -0,0 +1,38 @@
+/* -*- 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 "retry_strategy.hxx"
+#include <couchbase/retry_reason.hxx>
+
+#include <chrono>
+#include <set>
+
+namespace couchbase::core::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::core::io

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

@@ -0,0 +1,112 @@
+/* -*- 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 "core/logger/logger.hxx"
+#include "retry_action.hxx"
+#include "retry_reason.hxx"
+
+#include <chrono>
+#include <memory>
+
+namespace couchbase::core::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::core::io::retry_orchestrator

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

@@ -0,0 +1,86 @@
+/* -*- 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/retry_reason.hxx>
+
+namespace couchbase::core::io
+{
+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::core::io

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

@@ -0,0 +1,152 @@
+/* -*- 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 "retry_action.hxx"
+#include "retry_reason.hxx"
+
+#include <cmath>
+#include <gsl/assert>
+
+namespace couchbase::core::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, couchbase::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::core::io::retry_strategy