Method trySendExceptionToClient

src/Server/HTTPHandler.cpp:656–714

}

bool HTTPHandler::trySendExceptionToClient(
    int exception_code, const std::string & message, HTTPServerRequest & request, HTTPServerResponse & response, Output & used_output)
try
{
    if (!used_output.out_holder && !used_output.exception_is_written)
    {
        /// If nothing was sent yet and we don't even know if we must compress the response.
        auto wb = WriteBufferFromHTTPServerResponse(response, request.getMethod() == HTTPRequest::HTTP_HEAD);
        return wb.cancelWithException(request, exception_code, message, nullptr);
    }

    chassert(used_output.out_maybe_compressed);

    /// Destroy CascadeBuffer to actualize buffers' positions and reset extra references
    if (used_output.hasDelayed())
    {
        /// do not call finalize here for CascadeWriteBuffer used_output.out_maybe_delayed_and_compressed,
        /// exception is written into used_output.out_maybe_compressed later
        auto write_buffers = used_output.out_delayed_and_compressed_holder->getResultBuffers();
        /// cancel the rest unused buffers
        for (auto & wb : write_buffers)
            if (isSharedPtrUnique(wb))
                wb->cancel();

        used_output.out_maybe_delayed_and_compressed = used_output.out_maybe_compressed;
        used_output.out_delayed_and_compressed_holder.reset();
    }

    if (used_output.exception_is_written)
    {
        LOG_TRACE(log, "Exception has already been written to output format by current output formatter, nothing to do");
        /// everything has been held by output format write
        return true;
    }

    /// We might have special formatter for exception message.
    if (used_output.exception_writer)
    {
        used_output.exception_writer(*used_output.out_maybe_compressed, exception_code, message);
        return true;
    }

    /// This is the worst case scenario
    /// There is no support from output_format.
    /// output_format either did not faced the exception or did not support the exception writing

    /// Send the error message into already used (and possibly compressed) stream.
    /// Note that the error message will possibly be sent after some data.
    /// Also HTTP code 200 could have already been sent.
    return used_output.out_holder->cancelWithException(request, exception_code, message, used_output.out_maybe_compressed.get());
}
catch (...)
{
    /// The message could be not sent due to error on allocations
    /// or due to exception in used_output.exception_writer
    /// or because the socket is broken
    tryLogCurrentException(log, "Cannot send exception to client");
    return false;