couchbase 4.1.2 → 4.1.3

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

@@ -1,174 +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/http_session.hxx>
-#include <couchbase/metrics/meter.hxx>
-#include <couchbase/service_type_fmt.hxx>
-#include <couchbase/tracing/request_tracer.hxx>
-#include <couchbase/utils/movable_function.hxx>
-#include <utility>
-
-namespace couchbase::operations
-{
-
-using http_command_handler = utils::movable_function<void(std::error_code, io::http_response&&)>;
-
-template<typename Request>
-struct http_command : public std::enable_shared_from_this<http_command<Request>> {
-    using encoded_request_type = typename Request::encoded_request_type;
-    using encoded_response_type = typename Request::encoded_response_type;
-    using error_context_type = typename Request::error_context_type;
-    asio::steady_timer deadline;
-    asio::steady_timer retry_backoff;
-    Request request;
-    encoded_request_type encoded;
-    std::shared_ptr<tracing::request_tracer> tracer_;
-    std::shared_ptr<tracing::request_span> span_{ nullptr };
-    std::shared_ptr<metrics::meter> meter_{};
-    std::shared_ptr<io::http_session> session_{};
-    http_command_handler handler_{};
-    std::chrono::milliseconds timeout_{};
-    std::string client_context_id_;
-
-    http_command(asio::io_context& ctx,
-                 Request req,
-                 std::shared_ptr<tracing::request_tracer> tracer,
-                 std::shared_ptr<metrics::meter> meter,
-                 std::chrono::milliseconds default_timeout)
-      : deadline(ctx)
-      , retry_backoff(ctx)
-      , request(req)
-      , tracer_(std::move(tracer))
-      , meter_(std::move(meter))
-      , timeout_(request.timeout.value_or(default_timeout))
-      , client_context_id_(request.client_context_id.value_or(uuid::to_string(uuid::random())))
-    {
-    }
-
-    void finish_dispatch(const std::string& remote_address, const std::string& local_address)
-    {
-        if (span_ == nullptr) {
-            return;
-        }
-        span_->add_tag(tracing::attributes::remote_socket, remote_address);
-        span_->add_tag(tracing::attributes::local_socket, local_address);
-        span_->end();
-        span_ = nullptr;
-    }
-
-    void start(http_command_handler&& handler)
-    {
-        span_ = tracer_->start_span(tracing::span_name_for_http_service(request.type));
-        span_->add_tag(tracing::attributes::service, tracing::service_name_for_http_service(request.type));
-        span_->add_tag(tracing::attributes::operation_id, client_context_id_);
-        handler_ = std::move(handler);
-        deadline.expires_after(timeout_);
-        deadline.async_wait([self = this->shared_from_this()](std::error_code ec) {
-            if (ec == asio::error::operation_aborted) {
-                return;
-            }
-            self->cancel();
-        });
-    }
-
-    void cancel()
-    {
-        if (session_) {
-            session_->stop();
-        }
-        invoke_handler(error::common_errc::unambiguous_timeout, {});
-    }
-
-    void invoke_handler(std::error_code ec, io::http_response&& msg)
-    {
-        if (span_ != nullptr) {
-            span_->end();
-            span_ = nullptr;
-        }
-        if (handler_) {
-            handler_(ec, std::move(msg));
-        }
-        handler_ = nullptr;
-        retry_backoff.cancel();
-        deadline.cancel();
-    }
-
-    void send_to(std::shared_ptr<io::http_session> session)
-    {
-        if (!handler_) {
-            return;
-        }
-        session_ = std::move(session);
-        span_->add_tag(tracing::attributes::local_id, session_->id());
-        send();
-    }
-
-  private:
-    void send()
-    {
-        encoded.type = request.type;
-        encoded.client_context_id = client_context_id_;
-        encoded.timeout = timeout_;
-        if (auto ec = request.encode_to(encoded, session_->http_context()); ec) {
-            return invoke_handler(ec, {});
-        }
-        encoded.headers["client-context-id"] = client_context_id_;
-        LOG_TRACE(R"({} HTTP request: {}, method={}, path="{}", client_context_id="{}", timeout={}ms)",
-                  session_->log_prefix(),
-                  encoded.type,
-                  encoded.method,
-                  encoded.path,
-                  client_context_id_,
-                  timeout_.count());
-        session_->write_and_subscribe(
-          encoded,
-          [self = this->shared_from_this(), start = std::chrono::steady_clock::now()](std::error_code ec, io::http_response&& msg) {
-              if (ec == asio::error::operation_aborted) {
-                  return self->invoke_handler(error::common_errc::ambiguous_timeout, std::move(msg));
-              }
-              static std::string meter_name = "db.couchbase.operations";
-              static std::map<std::string, std::string> tags = {
-                  { "db.couchbase.service", fmt::format("{}", self->request.type) },
-                  { "db.operation", self->encoded.path },
-              };
-              if (self->meter_) {
-                  self->meter_->get_value_recorder(meter_name, tags)
-                    ->record_value(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - start).count());
-              }
-              self->deadline.cancel();
-              self->finish_dispatch(self->session_->remote_address(), self->session_->local_address());
-              LOG_TRACE(R"({} HTTP response: {}, client_context_id="{}", status={}, body={})",
-                        self->session_->log_prefix(),
-                        self->request.type,
-                        self->client_context_id_,
-                        msg.status_code,
-                        msg.status_code == 200 ? "[hidden]" : msg.body.data());
-              if (auto parser_ec = msg.body.ec(); !ec && parser_ec) {
-                  ec = parser_ec;
-              }
-              try {
-                  self->invoke_handler(ec, std::move(msg));
-              } catch (const priv::retry_http_request&) {
-                  self->send();
-              }
-          });
-    }
-};
-
-} // namespace couchbase::operations

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

@@ -1,40 +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/cluster_options.hxx>
-#include <couchbase/io/query_cache.hxx>
-#include <couchbase/topology/configuration.hxx>
-
-namespace couchbase
-{
-struct http_context {
-    const topology::configuration& config;
-    const cluster_options& options;
-    query_cache& cache;
-    std::string hostname;
-    std::uint16_t port;
-};
-
-namespace priv
-{
-class retry_http_request : public std::exception
-{
-};
-} // namespace priv
-} // namespace couchbase

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

@@ -1,116 +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/service_type.hxx>
-#include <couchbase/utils/json_streaming_lexer.hxx>
-
-#include <chrono>
-#include <map>
-#include <optional>
-#include <string>
-
-namespace couchbase::io
-{
-
-struct streaming_settings {
-    std::string pointer_expression;
-    std::uint32_t depth;
-    std::function<utils::json::stream_control(std::string&& row)> row_handler;
-};
-
-struct http_request {
-    service_type type;
-    std::string method;
-    std::string path;
-    std::map<std::string, std::string> headers{};
-    std::string body{};
-    std::optional<streaming_settings> streaming{};
-    std::string client_context_id{};     /* effective client context ID, random-generated or provided in user's request */
-    std::chrono::milliseconds timeout{}; /* effective timeout, service default or provided in user's request */
-};
-
-class http_response_body
-{
-    struct storage {
-        std::string data_{};
-        std::error_code ec_{};
-        std::size_t number_of_rows_{};
-    };
-
-  public:
-    http_response_body()
-      : storage_(std::make_shared<storage>())
-    {
-    }
-
-    void use_json_streaming(streaming_settings&& settings)
-    {
-        lexer_ = std::make_unique<utils::json::streaming_lexer>(settings.pointer_expression, settings.depth);
-        lexer_->on_row(std::move(settings.row_handler));
-        lexer_->on_complete([storage = storage_](std::error_code ec, std::size_t number_of_rows, std::string&& meta) {
-            storage->ec_ = ec;
-            storage->number_of_rows_ = number_of_rows;
-            storage->data_ = std::move(meta);
-        });
-    }
-
-    void append(std::string_view chunk)
-    {
-        if (lexer_) {
-            lexer_->feed(chunk);
-        } else {
-            storage_->data_.append(chunk);
-        }
-    }
-
-    [[nodiscard]] const std::string& data() const
-    {
-        return storage_->data_;
-    }
-
-    [[nodiscard]] const std::size_t& number_of_rows() const
-    {
-        return storage_->number_of_rows_;
-    }
-
-    [[nodiscard]] const std::error_code& ec() const
-    {
-        return storage_->ec_;
-    }
-
-  private:
-    std::shared_ptr<storage> storage_{};
-    std::unique_ptr<utils::json::streaming_lexer> lexer_{};
-};
-
-struct http_response {
-    uint32_t status_code;
-    std::string status_message;
-    std::map<std::string, std::string> headers;
-    http_response_body body{};
-
-    [[nodiscard]] bool must_close_connection() const
-    {
-        if (const auto it = headers.find("connection"); it != headers.end()) {
-            return it->second == "close";
-        }
-        return false;
-    }
-};
-} // namespace couchbase::io

package/deps/couchbase-cxx-client/couchbase/io/http_parser.cxx

@@ -1,141 +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.
- */
-
-#include <couchbase/io/http_parser.hxx>
-
-#include <algorithm>
-#include <fmt/core.h>
-#include <http_parser.h>
-
-static inline int
-static_on_status(::http_parser* parser, const char* at, std::size_t length)
-{
-    auto* wrapper = static_cast<couchbase::io::http_parser*>(parser->data);
-    wrapper->response.status_message.assign(at, length);
-    wrapper->response.status_code = parser->status_code;
-    return 0;
-}
-
-static inline int
-static_on_header_field(::http_parser* parser, const char* at, std::size_t length)
-{
-    auto* wrapper = static_cast<couchbase::io::http_parser*>(parser->data);
-    wrapper->header_field.assign(at, length);
-    std::transform(wrapper->header_field.begin(), wrapper->header_field.end(), wrapper->header_field.begin(), [](unsigned char c) {
-        return std::tolower(c);
-    });
-    return 0;
-}
-
-static inline int
-static_on_header_value(::http_parser* parser, const char* at, std::size_t length)
-{
-    auto* wrapper = static_cast<couchbase::io::http_parser*>(parser->data);
-    wrapper->response.headers[wrapper->header_field] = std::string(at, length);
-    return 0;
-}
-
-static inline int
-static_on_body(::http_parser* parser, const char* at, std::size_t length)
-{
-    auto* wrapper = static_cast<couchbase::io::http_parser*>(parser->data);
-    wrapper->response.body.append(std::string_view{ at, length });
-    return 0;
-}
-
-static inline int
-static_on_message_complete(::http_parser* parser)
-{
-    auto* wrapper = static_cast<couchbase::io::http_parser*>(parser->data);
-    wrapper->complete = true;
-    return 0;
-}
-
-namespace couchbase::io
-{
-struct http_parser_state {
-    ::http_parser_settings settings_{};
-    ::http_parser parser_{};
-};
-
-http_parser::http_parser()
-{
-    state_ = std::make_shared<http_parser_state>();
-    state_->parser_.data = this;
-    state_->settings_.on_status = static_on_status;
-    state_->settings_.on_header_field = static_on_header_field;
-    state_->settings_.on_header_value = static_on_header_value;
-    state_->settings_.on_body = static_on_body;
-    state_->settings_.on_message_complete = static_on_message_complete;
-    ::http_parser_init(&state_->parser_, HTTP_RESPONSE);
-}
-
-http_parser::http_parser(http_parser&& other) noexcept
-  : response(std::move(other.response))
-  , header_field(std::move(other.header_field))
-  , complete(other.complete)
-  , state_(std::move(other.state_))
-{
-    if (state_) {
-        state_->parser_.data = this;
-    }
-}
-
-http_parser&
-http_parser::operator=(http_parser&& other) noexcept
-{
-    response = std::move(other.response);
-    header_field = std::move(other.header_field);
-    complete = other.complete;
-    state_ = std::move(other.state_);
-    if (state_) {
-        state_->parser_.data = this;
-    }
-    return *this;
-}
-void
-http_parser::reset()
-{
-    complete = false;
-    response = {};
-    header_field = {};
-    ::http_parser_init(&state_->parser_, HTTP_RESPONSE);
-}
-
-std::string
-http_parser::error_message() const
-{
-#define HTTP_ERRNO_GEN(n, s)                                                                                                               \
-    case HPE_##n:                                                                                                                          \
-        return fmt::format("HPE_" #n " ({})", s);
-
-    switch (state_->parser_.http_errno) {
-        HTTP_ERRNO_MAP(HTTP_ERRNO_GEN)
-    }
-#undef HTTP_ERRNO_GEN
-    return "unknown error: " + std::to_string(state_->parser_.http_errno);
-}
-
-http_parser::feeding_result
-http_parser::feed(const char* data, size_t data_len)
-{
-    if (std::size_t bytes_parsed = ::http_parser_execute(&state_->parser_, &state_->settings_, data, data_len); bytes_parsed != data_len) {
-        return { true, complete, error_message() };
-    }
-    return { false, complete };
-}
-} // namespace couchbase::io

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

@@ -1,55 +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/http_message.hxx>
-
-#include <algorithm>
-#include <memory>
-
-namespace couchbase::io
-{
-struct http_parser_state;
-
-struct http_parser {
-    struct feeding_result {
-        bool failure{ false };
-        bool complete{ false };
-        std::string error{};
-    };
-
-    http_response response;
-    std::string header_field;
-    bool complete{ false };
-
-    http_parser();
-    http_parser(http_parser&& other) noexcept;
-    http_parser& operator=(http_parser&& other) noexcept;
-    http_parser(const http_parser& other) = delete;
-    http_parser& operator=(const http_parser& other) = delete;
-
-    void reset();
-
-    std::string error_message() const;
-
-    feeding_result feed(const char* data, size_t data_len);
-
-  private:
-    std::shared_ptr<http_parser_state> state_{};
-};
-} // namespace couchbase::io