couchbase 3.3.0 → 3.4.0

data/ext/couchbase/core/bucket.hxx

@@ -0,0 +1,172 @@
+/* -*- 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 "config_listener.hxx"
+#include "io/mcbp_command.hxx"
+#include "operations.hxx"
+
+#include <asio/bind_executor.hpp>
+#include <asio/io_context.hpp>
+#include <asio/post.hpp>
+#include <asio/ssl.hpp>
+
+#include <utility>
+#include <vector>
+
+namespace couchbase
+{
+namespace metrics
+{
+class meter;
+} // namespace metrics
+namespace tracing
+{
+class request_tracer;
+} // namespace tracing
+namespace core
+{
+namespace mcbp
+{
+class queue_request;
+} // namespace mcbp
+namespace diag
+{
+class ping_collector;
+struct diagnostics_result;
+} // namespace diag
+namespace impl
+{
+class bootstrap_state_listener;
+} // namespace impl
+
+class bucket_impl;
+struct origin;
+
+class bucket
+  : public std::enable_shared_from_this<bucket>
+  , public config_listener
+{
+  public:
+    bucket(std::string client_id,
+           asio::io_context& ctx,
+           asio::ssl::context& tls,
+           std::shared_ptr<couchbase::tracing::request_tracer> tracer,
+           std::shared_ptr<couchbase::metrics::meter> meter,
+           std::string name,
+           couchbase::core::origin origin,
+           std::vector<protocol::hello_feature> known_features,
+           std::shared_ptr<impl::bootstrap_state_listener> state_listener);
+    ~bucket() override;
+
+    template<typename Request, typename Handler>
+    void execute(Request request, Handler&& handler)
+    {
+        if (is_closed()) {
+            return;
+        }
+        auto cmd = std::make_shared<operations::mcbp_command<bucket, Request>>(ctx_, shared_from_this(), request, default_timeout());
+        cmd->start([cmd, handler = std::forward<Handler>(handler)](std::error_code ec, std::optional<io::mcbp_message>&& msg) mutable {
+            using encoded_response_type = typename Request::encoded_response_type;
+            std::uint16_t status_code = msg ? msg->header.status() : 0U;
+            auto resp = msg ? encoded_response_type(std::move(*msg)) : encoded_response_type{};
+            auto ctx = make_key_value_error_context(ec, status_code, cmd, resp);
+            handler(cmd->request.make_response(std::move(ctx), std::move(resp)));
+        });
+        if (is_configured()) {
+            return map_and_send(cmd);
+        }
+        return defer_command([self = shared_from_this(), cmd]() { self->map_and_send(cmd); });
+    }
+
+    template<typename Request>
+    void map_and_send(std::shared_ptr<operations::mcbp_command<bucket, Request>> cmd)
+    {
+        if (is_closed()) {
+            return cmd->cancel(retry_reason::do_not_retry);
+        }
+        std::size_t index;
+        if (cmd->request.id.use_any_session()) {
+            index = next_session_index();
+        } else {
+            auto [partition, server] = map_id(cmd->request.id);
+            if (!server.has_value()) {
+                return io::retry_orchestrator::maybe_retry(
+                  cmd->manager_, cmd, retry_reason::node_not_available, errc::common::request_canceled);
+            }
+            cmd->request.partition = partition;
+            index = server.value();
+        }
+        auto session = find_session_by_index(index);
+        if (!session || !session->has_config()) {
+            return defer_command([self = shared_from_this(), cmd]() { self->map_and_send(cmd); });
+        }
+        if (session->is_stopped()) {
+            return io::retry_orchestrator::maybe_retry(
+              cmd->manager_, cmd, retry_reason::node_not_available, errc::common::request_canceled);
+        }
+        cmd->send_to(session.value());
+    }
+
+    template<typename Request>
+    void schedule_for_retry(std::shared_ptr<operations::mcbp_command<bucket, Request>> cmd, std::chrono::milliseconds duration)
+    {
+        if (is_closed()) {
+            return cmd->cancel(retry_reason::do_not_retry);
+        }
+        cmd->retry_backoff.expires_after(duration);
+        cmd->retry_backoff.async_wait([self = shared_from_this(), cmd](std::error_code ec) mutable {
+            if (ec == asio::error::operation_aborted) {
+                return;
+            }
+            self->map_and_send(cmd);
+        });
+    }
+
+    void update_config(topology::configuration config) override;
+    void bootstrap(utils::movable_function<void(std::error_code, topology::configuration)>&& handler);
+    void with_configuration(utils::movable_function<void(std::error_code, topology::configuration)>&& handler);
+
+    void on_configuration_update(std::shared_ptr<config_listener> handler);
+    void close();
+    void export_diag_info(diag::diagnostics_result& res) const;
+    void ping(std::shared_ptr<diag::ping_collector> collector);
+    void defer_command(utils::movable_function<void()> command);
+
+    [[nodiscard]] auto name() const -> const std::string&;
+    [[nodiscard]] auto log_prefix() const -> const std::string&;
+    [[nodiscard]] auto tracer() const -> std::shared_ptr<couchbase::tracing::request_tracer>;
+    [[nodiscard]] auto meter() const -> std::shared_ptr<couchbase::metrics::meter>;
+    [[nodiscard]] auto default_retry_strategy() const -> std::shared_ptr<couchbase::retry_strategy>;
+    [[nodiscard]] auto is_closed() const -> bool;
+    [[nodiscard]] auto is_configured() const -> bool;
+
+    auto direct_dispatch(std::shared_ptr<mcbp::queue_request> req) -> std::error_code;
+    auto direct_re_queue(std::shared_ptr<mcbp::queue_request> req, bool is_retry) -> std::error_code;
+
+  private:
+    [[nodiscard]] auto default_timeout() const -> std::chrono::milliseconds;
+    [[nodiscard]] auto next_session_index() -> std::size_t;
+    [[nodiscard]] auto find_session_by_index(std::size_t index) const -> std::optional<io::mcbp_session>;
+    [[nodiscard]] auto map_id(const document_id& id) -> std::pair<std::uint16_t, std::optional<std::size_t>>;
+
+    asio::io_context& ctx_;
+    std::shared_ptr<bucket_impl> impl_;
+};
+} // namespace core
+} // namespace couchbase

data/ext/couchbase/core/capella_ca.hxx

@@ -0,0 +1,43 @@
+/* -*- 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::core::default_ca
+{
+
+static const char* capellaCaCert = "-----BEGIN CERTIFICATE-----\n"
+                                   "MIIDFTCCAf2gAwIBAgIRANLVkgOvtaXiQJi0V6qeNtswDQYJKoZIhvcNAQELBQAw\n"
+                                   "JDESMBAGA1UECgwJQ291Y2hiYXNlMQ4wDAYDVQQLDAVDbG91ZDAeFw0xOTEyMDYy\n"
+                                   "MjEyNTlaFw0yOTEyMDYyMzEyNTlaMCQxEjAQBgNVBAoMCUNvdWNoYmFzZTEOMAwG\n"
+                                   "A1UECwwFQ2xvdWQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCfvOIi\n"
+                                   "enG4Dp+hJu9asdxEMRmH70hDyMXv5ZjBhbo39a42QwR59y/rC/sahLLQuNwqif85\n"
+                                   "Fod1DkqgO6Ng3vecSAwyYVkj5NKdycQu5tzsZkghlpSDAyI0xlIPSQjoORA/pCOU\n"
+                                   "WOpymA9dOjC1bo6rDyw0yWP2nFAI/KA4Z806XeqLREuB7292UnSsgFs4/5lqeil6\n"
+                                   "rL3ooAw/i0uxr/TQSaxi1l8t4iMt4/gU+W52+8Yol0JbXBTFX6itg62ppb/Eugmn\n"
+                                   "mQRMgL67ccZs7cJ9/A0wlXencX2ohZQOR3mtknfol3FH4+glQFn27Q4xBCzVkY9j\n"
+                                   "KQ20T1LgmGSngBInAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE\n"
+                                   "FJQOBPvrkU2In1Sjoxt97Xy8+cKNMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0B\n"
+                                   "AQsFAAOCAQEARgM6XwcXPLSpFdSf0w8PtpNGehmdWijPM3wHb7WZiS47iNen3oq8\n"
+                                   "m2mm6V3Z57wbboPpfI+VEzbhiDcFfVnK1CXMC0tkF3fnOG1BDDvwt4jU95vBiNjY\n"
+                                   "xdzlTP/Z+qr0cnVbGBSZ+fbXstSiRaaAVcqQyv3BRvBadKBkCyPwo+7svQnScQ5P\n"
+                                   "Js7HEHKVms5tZTgKIw1fbmgR2XHleah1AcANB+MAPBCcTgqurqr5G7W2aPSBLLGA\n"
+                                   "fRIiVzm7VFLc7kWbp7ENH39HVG6TZzKnfl9zJYeiklo5vQQhGSMhzBsO70z4RRzi\n"
+                                   "DPFAN/4qZAgD5q3AFNIq2WWADFQGSwVJhg==\n"
+                                   "-----END CERTIFICATE-----\n";
+
+} // namespace couchbase::core::default_ca

data/ext/couchbase/core/cluster.cxx

@@ -0,0 +1,181 @@
+/* -*- 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.
+ */
+
+#include "cluster.hxx"
+
+#include "core/mcbp/completion_token.hxx"
+#include "core/mcbp/queue_request.hxx"
+#include "ping_collector.hxx"
+#include "ping_reporter.hxx"
+
+namespace couchbase::core
+{
+
+class ping_collector_impl
+  : public std::enable_shared_from_this<ping_collector_impl>
+  , public diag::ping_reporter
+  , public diag::ping_collector
+{
+    diag::ping_result res_;
+    utils::movable_function<void(diag::ping_result)> handler_;
+    std::atomic_int expected_{ 0 };
+    std::mutex mutex_{};
+
+  public:
+    ping_collector_impl(std::string report_id, utils::movable_function<void(diag::ping_result)>&& handler)
+      : res_{ std::move(report_id), meta::sdk_id() }
+      , handler_(std::move(handler))
+    {
+    }
+
+    ~ping_collector_impl()
+    {
+        invoke_handler();
+    }
+
+    [[nodiscard]] diag::ping_result& result()
+    {
+        return res_;
+    }
+
+    void report(diag::endpoint_ping_info&& info) override
+    {
+        std::scoped_lock lock(mutex_);
+        res_.services[info.type].emplace_back(std::move(info));
+        if (--expected_ == 0) {
+            invoke_handler();
+        }
+    }
+
+    auto build_reporter() -> std::shared_ptr<diag::ping_reporter> override
+    {
+        ++expected_;
+        return shared_from_this();
+    }
+
+    void invoke_handler()
+    {
+        if (handler_ != nullptr) {
+            handler_(std::move(res_));
+            handler_ = nullptr;
+        }
+    }
+};
+
+void
+cluster::do_ping(std::optional<std::string> report_id,
+                 std::optional<std::string> bucket_name,
+                 std::set<service_type> services,
+                 utils::movable_function<void(diag::ping_result)> handler)
+{
+    if (!report_id) {
+        report_id = std::make_optional(uuid::to_string(uuid::random()));
+    }
+    if (stopped_) {
+        return handler({ report_id.value(), meta::sdk_id() });
+    }
+    if (services.empty()) {
+        services = {
+            service_type::key_value, service_type::view,       service_type::query,    service_type::search,
+            service_type::analytics, service_type::management, service_type::eventing,
+        };
+    }
+    asio::post(
+      asio::bind_executor(ctx_, [cluster = shared_from_this(), report_id, bucket_name, services, handler = std::move(handler)]() mutable {
+          auto collector = std::make_shared<ping_collector_impl>(report_id.value(), std::move(handler));
+          if (bucket_name) {
+              if (services.find(service_type::key_value) != services.end()) {
+                  if (auto bucket = cluster->find_bucket_by_name(bucket_name.value()); bucket) {
+                      return bucket->ping(collector);
+                  }
+                  cluster->open_bucket(bucket_name.value(), [collector, cluster, bucket_name](std::error_code ec) {
+                      if (!ec) {
+                          if (auto bucket = cluster->find_bucket_by_name(bucket_name.value()); bucket) {
+                              return bucket->ping(collector);
+                          }
+                      }
+                  });
+              }
+          } else {
+              if (services.find(service_type::key_value) != services.end()) {
+                  if (cluster->session_) {
+                      cluster->session_->ping(collector->build_reporter());
+                  }
+                  cluster->for_each_bucket([&collector](auto& bucket) { bucket->ping(collector); });
+              }
+              cluster->session_manager_->ping(services, collector, cluster->origin_.credentials());
+          }
+      }));
+}
+
+std::shared_ptr<bucket>
+cluster::find_bucket_by_name(const std::string& name)
+{
+    std::scoped_lock lock(buckets_mutex_);
+
+    auto bucket = buckets_.find(name);
+    if (bucket == buckets_.end()) {
+        return {};
+    }
+    return bucket->second;
+}
+
+auto
+cluster::direct_dispatch(const std::string& bucket_name, std::shared_ptr<couchbase::core::mcbp::queue_request> req) -> std::error_code
+{
+    if (stopped_) {
+        return errc::network::cluster_closed;
+    }
+    if (bucket_name.empty()) {
+        return errc::common::invalid_argument;
+    }
+    if (auto bucket = find_bucket_by_name(bucket_name); bucket != nullptr) {
+        return bucket->direct_dispatch(std::move(req));
+    }
+
+    open_bucket(bucket_name, [self = shared_from_this(), req = std::move(req), bucket_name](std::error_code ec) mutable {
+        if (ec) {
+            return req->cancel(ec);
+        }
+        self->direct_dispatch(bucket_name, std::move(req));
+    });
+    return {};
+}
+
+auto
+cluster::direct_re_queue(const std::string& bucket_name, std::shared_ptr<mcbp::queue_request> req, bool is_retry) -> std::error_code
+{
+    if (stopped_) {
+        return errc::network::cluster_closed;
+    }
+    if (bucket_name.empty()) {
+        return errc::common::invalid_argument;
+    }
+    if (auto bucket = find_bucket_by_name(bucket_name); bucket != nullptr) {
+        return bucket->direct_re_queue(std::move(req), is_retry);
+    }
+
+    open_bucket(bucket_name, [self = shared_from_this(), bucket_name, req = std::move(req), is_retry](std::error_code ec) mutable {
+        if (ec) {
+            return req->cancel(ec);
+        }
+        self->direct_re_queue(bucket_name, std::move(req), is_retry);
+    });
+    return {};
+}
+
+} // namespace couchbase::core