Method HTTPServerRequest

src/Server/HTTP/HTTPServerRequest.cpp:30–112

namespace DB
{
HTTPServerRequest::HTTPServerRequest(HTTPContextPtr context, HTTPServerResponse & response, Poco::Net::HTTPServerSession & session, const ProfileEvents::Event & read_event)
    : max_uri_size(context->getMaxUriSize())
    , max_fields_number(context->getMaxFields())
    , max_field_name_size(context->getMaxFieldNameSize())
    , max_field_value_size(context->getMaxFieldValueSize())
    , max_request_header_size(context->getMaxRequestHeaderSize())
{
    response.attachRequest(this);

    /// Now that we know socket is still connected, obtain addresses
    client_address = session.clientAddress();
    server_address = session.serverAddress();
    secure = session.socket().secure();

    auto receive_timeout = context->getReceiveTimeout();
    auto send_timeout = context->getSendTimeout();
    auto headers_read_timeout = context->getHeadersReadTimeout();

    /// Use the smaller of headers_read_timeout and receive_timeout during header parsing
    /// to enforce a total deadline on the entire handshake phase.
    auto effective_timeout = (headers_read_timeout > Poco::Timespan(0) &&
                              (receive_timeout <= Poco::Timespan(0) || headers_read_timeout < receive_timeout))
        ? headers_read_timeout : receive_timeout;

    session.socket().setReceiveTimeout(effective_timeout);
    session.socket().setSendTimeout(send_timeout);

    auto socket_in = std::make_unique<ReadBufferFromPocoSocket>(session.socket(), read_event);
    socket = session.socket().impl();

    /// Wrap the socket buffer with a deadline check if configured.
    /// The deadline is enforced in DeadlineReadBuffer::nextImpl on every buffer refill,
    /// which protects all parsing (request line, URI, headers) automatically.
    if (headers_read_timeout > Poco::Timespan(0))
    {
        auto deadline = std::chrono::steady_clock::now()
            + std::chrono::microseconds(headers_read_timeout.totalMicroseconds());
        DeadlineReadBuffer deadline_in(*socket_in, deadline);
        readRequest(deadline_in);  /// Try parse according to RFC7230
    }
    else
    {
        readRequest(*socket_in);  /// Try parse according to RFC7230
    }

    /// Restore the original receive timeout for body reads.
    session.socket().setReceiveTimeout(receive_timeout);

    /// Build the body stream from the underlying socket buffer (not the deadline wrapper).
    auto in = std::move(socket_in);

    /// If a client crashes, most systems will gracefully terminate the connection with FIN just like it's done on close().
    /// So we will get 0 from recv(...) and will not be able to understand that something went wrong (well, we probably
    /// will get RST later on attempt to write to the socket that closed on the other side, but it will happen when the query is finished).
    /// If we are extremely unlucky and data format is TSV, for example, then we may stop parsing exactly between rows
    /// and decide that it's EOF (but it is not). It may break deduplication, because clients cannot control it
    /// and retry with exactly the same (incomplete) set of rows.
    /// That's why we have to check body size if it's provided.