Method process_request

src/server/connection.cpp:73–135

}

void Connection::process_request()
{
    response_ = {};
    response_.version(request_.version());

    boost::asio::ip::address remote_address;
    boost::beast::error_code endpoint_ec;
    const auto endpoint = stream_.socket().remote_endpoint(endpoint_ec);
    if (!endpoint_ec)
    {
        remote_address = endpoint.address();
    }

    try
    {
        request_handler_.HandleRequest(request_, response_, remote_address);
    }
    catch (const std::exception &e)
    {
        util::Log(logERROR) << "Request processing error: " << e.what();
        SetInternalServerError(response_);
    }

    const bool keep_alive = should_keep_alive();
    response_.keep_alive(keep_alive);

    if (keep_alive)
    {
        response_.set(bhttp::field::connection, "keep-alive");
        response_.set("Keep-Alive",
                      std::format("timeout={}, max={}",
                                  keepalive_timeout_,
                                  KEEPALIVE_MAX_REQUESTS - processed_requests_));
    }
    else
    {
        response_.set(bhttp::field::connection, "close");
    }

    const auto compression = determine_compression();
    if (compression != http::no_compression && !response_.body().empty())
    {
        auto compressed = compress_buffers(response_.body(), compression);
        response_.body() = std::move(compressed);

        if (compression == http::gzip_rfc1952)
        {
            response_.set(bhttp::field::content_encoding, "gzip");
        }
        else if (compression == http::deflate_rfc1951)
        {
            response_.set(bhttp::field::content_encoding, "deflate");
        }

        response_.set(bhttp::field::vary, "Accept-Encoding");
    }

    response_.prepare_payload();