http_response.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/server/http/http_response.hpp
/// @brief @copybrief server::http::HttpResponse
 
#include <chrono>
#include <limits>
#include <memory>
#include <string>
#include <string_view>
#include <variant>
 
#include <userver/engine/single_consumer_event.hpp>
#include <userver/http/content_type.hpp>
#include <userver/http/header_map.hpp>
#include <userver/server/http/http_response_cookie.hpp>
#include <userver/utils/impl/projecting_view.hpp>
#include <userver/utils/str_icase.hpp>
 
#include "http_status.hpp"
 
// TODO remove extra include.
#include <userver/compiler/impl/lifetime.hpp>
#include <userver/concurrent/queue.hpp>
#include <userver/concurrent/striped_counter.hpp>
#include <userver/utils/fast_pimpl.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace server::request {
class ResponseDataAccounter;
}  // namespace server::request
 
namespace server::http {
 
// RFC 9110 states that in case of missing Content-Type it may be assumed to be
// application/octet-stream.
//
// text/plain was our first guess, but we should provide an encoding with that
// type, which we do not know for sure. "application/octet-stream" has no
// charset https://www.iana.org/assignments/media-types/application/octet-stream
inline constexpr std::string_view kDefaultContentType = "application/octet-stream";
 
class Http2ResponseWriter;
class HttpResponseImpl;
 
namespace impl {
 
class ChunkStorage final {
public:
    ChunkStorage() = default;
    explicit ChunkStorage(std::string data);
    explicit ChunkStorage(std::shared_ptr<const std::string> data);
 
    ChunkStorage(const ChunkStorage&) = delete;
    ChunkStorage(ChunkStorage&&) noexcept = default;
    ChunkStorage& operator=(const ChunkStorage&) = delete;
    ChunkStorage& operator=(ChunkStorage&&) noexcept = default;
 
    bool Empty() const noexcept;
    std::size_t Size() const noexcept;
    std::string_view View() const noexcept;
    const std::string& AsString() const;
 
private:
    std::variant<std::string, std::shared_ptr<const std::string>> storage_{};
};
 
}  // namespace impl
 
class HttpRequest;
 
/// @brief HTTP Response data
class HttpResponse {
public:
    HttpResponse(const HttpResponse&) = delete;
    HttpResponse(HttpResponse&&) = delete;
 
    using HeadersMap = USERVER_NAMESPACE::http::headers::HeaderMap;
 
    using HeadersMapKeys = decltype(utils::impl::MakeKeysView(HeadersMap()));
 
    using CookiesMap = Cookie::CookiesMap;
 
    using CookiesMapKeys = decltype(utils::impl::MakeKeysView(CookiesMap()));
 
    void SetData(std::string data);
    /// @brief Sets response body without copying, keeping @a data alive.
    /// Useful for serving cached static content.
    void SetSharedData(std::shared_ptr<const std::string> data);
    const std::string& GetData() const;
 
    /// @brief Add a new response header or rewrite an existing one.
    /// @returns true if the header was set. Returns false if headers
    /// were already sent for stream'ed response and the new header was not set,
    /// or the header overrides system header.
    bool SetHeader(std::string name, std::string value);
 
    /// @brief Add a new response header or rewrite an existing one.
    /// @returns true if the header was set. Returns false if headers
    /// were already sent for stream'ed response and the new header was not set,
    /// or the header overrides system header.
    bool SetHeader(std::string_view name, std::string value);
 
    /// @overload
    bool SetHeader(const USERVER_NAMESPACE::http::headers::PredefinedHeader& header, std::string value);
 
    /// @brief Add or rewrite the Content-Type header.
    void SetContentType(const USERVER_NAMESPACE::http::ContentType& type);
 
    /// @brief Add or rewrite the Content-Encoding header.
    void SetContentEncoding(std::string encoding);
 
    /// @brief Set the HTTP response status code.
    /// @returns true if the status was set. Returns false if headers
    /// were already sent for stream'ed response and the new status was not set.
    bool SetStatus(HttpStatus status) noexcept;
 
    /// @brief Remove all headers from response, except system headers.
    /// @returns true if the headers were cleared. Returns false if headers
    /// were already sent for stream'ed response and the headers were not cleared.
    bool ClearUserHeaders();
 
    /// @brief Sets a cookie if it was not set before.
    void SetCookie(Cookie cookie);
 
    /// @brief Remove all cookies from response.
    void ClearCookies();
 
    /// @return HTTP response status
    HttpStatus GetStatus() const noexcept { return status_; }
 
    /// @return List of HTTP system headers names.
    HeadersMapKeys GetSystemHeaderNames() const;
 
    /// @return List of HTTP user headers names.
    HeadersMapKeys GetUserHeaderNames() const;
 
    /// @return Value of the header with case insensitive name header_name, or an
    /// empty string if no such header.
    const std::string& GetHeader(std::string_view header_name) const;
    /// @overload
    const std::string& GetHeader(const USERVER_NAMESPACE::http::headers::PredefinedHeader& header_name) const;
 
    /// @return true if header with case insensitive name header_name exists,
    /// false otherwise.
    bool HasHeader(std::string_view header_name) const;
    /// @overload
    bool HasHeader(const USERVER_NAMESPACE::http::headers::PredefinedHeader& header_name) const;
 
    /// @return List of cookies names.
    CookiesMapKeys GetCookieNames() const;
 
    /// @return Value of the cookie with case sensitive name cookie_name, or an
    /// empty string if no such cookie exists.
    const Cookie& GetCookie(std::string_view cookie_name) const;
 
    void SetStatusServiceUnavailable() { SetStatus(HttpStatus::kServiceUnavailable); }
    void SetStatusOk() { SetStatus(HttpStatus::kOk); }
    void SetStatusNotFound() { SetStatus(HttpStatus::kNotFound); }
 
    bool WaitForHeadersEnd();
    void SetHeadersEnd();
 
    /// @returns true if response headers were committed and cannot be changed.
    [[nodiscard]] bool IsHeadersEnd() const noexcept { return headers_end_.IsReady(); }
 
    [[nodiscard]] bool IsBodyStreamed() const noexcept { return is_stream_body_; }
 
    [[nodiscard]] bool IsSent() const noexcept { return is_sent_; }
 
protected:
    HttpResponse(const HttpRequest& request, request::ResponseDataAccounter& data_accounter);
    HttpResponse(
        const HttpRequest& request,
        request::ResponseDataAccounter& data_accounter,
        std::chrono::steady_clock::time_point now,
        utils::StrCaseHash hasher
    );
    ~HttpResponse() noexcept;
 
private:
    friend class HttpResponseImpl;
    friend class Http2ResponseWriter;
 
    void StoreData(impl::ChunkStorage data);
 
    [[nodiscard]] bool IsHeadersMutable() const noexcept { return !headers_end_.IsReady(); }
 
    static constexpr auto kUnset = std::chrono::steady_clock::time_point::min();
 
    request::ResponseDataAccounter& accounter_;
    impl::ChunkStorage data_;
    std::chrono::steady_clock::time_point create_time_;
    std::chrono::steady_clock::time_point ready_time_{kUnset};
    std::size_t accounted_size_ = 0;
    std::size_t bytes_sent_ = 0;
    bool is_sent_ = false;
 
    const bool is_final_;
    bool is_head_request_;
    const std::uint8_t http_major_;
    const std::uint8_t http_minor_;
    HttpStatus status_ = HttpStatus::kOk;
    HeadersMap system_headers_;
    HeadersMap user_headers_;
    CookiesMap cookies_;
 
    bool is_stream_body_{false};
    bool system_headers_ended_ = false;
    engine::SingleConsumerEvent headers_end_{engine::SingleConsumerEvent::NoAutoReset()};
};
 
void SetThrottleReason(http::HttpResponse& http_response, std::string log_reason, std::string http_header_reason);
 
}  // namespace server::http
 
USERVER_NAMESPACE_END