message_builders.hpp

Go to the documentation of this file.

/*
    restinio
*/

/*!
    Builders for messages.
*/

#pragma once

#include <ctime>
#include <chrono>

#include <restinio/impl/include_fmtlib.hpp>

#include <restinio/common_types.hpp>
#include <restinio/http_headers.hpp>
#include <restinio/os.hpp>
#include <restinio/sendfile.hpp>
#include <restinio/impl/connection_base.hpp>

#include <restinio/impl/header_helpers.hpp>

namespace restinio
{

//
// make_date_field_value()
//

//! Format a timepoint to a string of a propper format.
inline std::string
make_date_field_value( std::time_t t )
{
    const auto tpoint = make_gmtime( t );

    std::array< char, 64 > buf;
    // TODO: is there a faster way to get time string?
    strftime(
        buf.data(),
        buf.size(),
        "%a, %d %b %Y %H:%M:%S GMT",
        &tpoint );

    return std::string{ buf.data() };
}

inline std::string
make_date_field_value( std::chrono::system_clock::time_point tp )
{
    return make_date_field_value( std::chrono::system_clock::to_time_t( tp ) );
}

//
// base_response_builder_t
//

template < typename Response_Builder >
class base_response_builder_t
{
    public:
        base_response_builder_t( const base_response_builder_t & ) = delete;
        base_response_builder_t & operator = ( const base_response_builder_t & ) = delete;

        base_response_builder_t( base_response_builder_t && ) noexcept = default;
        base_response_builder_t & operator =( base_response_builder_t && ) noexcept = default;

        virtual ~base_response_builder_t() = default;

        base_response_builder_t(
            http_status_line_t status_line,
            impl::connection_handle_t connection,
            request_id_t request_id,
            bool should_keep_alive )
            :   m_header{ std::move( status_line ) }
            ,   m_connection{ std::move( connection ) }
            ,   m_request_id{ request_id }
        {
            m_header.should_keep_alive( should_keep_alive );
        }

        //! Accessors for header.
        //! \{
        http_response_header_t &
        header() noexcept
        {
            return m_header;
        }

        const http_response_header_t &
        header() const noexcept
        {
            return m_header;
        }
        //! \}

        //! Add header field.
        Response_Builder &
        append_header(
            std::string field_name,
            std::string field_value ) &
        {
            m_header.add_field(
                std::move( field_name ),
                std::move( field_value ) );
            return upcast_reference();
        }

        //! Add header field.
        Response_Builder &&
        append_header(
            std::string field_name,
            std::string field_value ) &&
        {
            return std::move( this->append_header(
                                        std::move( field_name ),
                                        std::move( field_value ) ) );
        }

        //! Add header field.
        Response_Builder &
        append_header( http_header_field_t http_header_field ) &
        {
            m_header.add_field( std::move( http_header_field ) );
            return upcast_reference();
        }

        //! Add header field.
        Response_Builder &&
        append_header( http_header_field_t http_header_field ) &&
        {
            return std::move( this->append_header(
                                        std::move( http_header_field ) ) );
        }

        //! Add header field.
        Response_Builder &
        append_header(
            http_field_t field_id,
            std::string field_value ) &
        {
            m_header.add_field(
                field_id,
                std::move( field_value ) );
            return upcast_reference();
        }

        //! Add header field.
        Response_Builder &&
        append_header(
            http_field_t field_id,
            std::string field_value ) &&
        {
            return std::move( this->append_header(
                                        field_id,
                                        std::move( field_value ) ) );
        }


        //! Add header `Date` field.
        Response_Builder &
        append_header_date_field(
            std::chrono::system_clock::time_point tp =
                std::chrono::system_clock::now() ) &
        {
            m_header.set_field( http_field_t::date, make_date_field_value( tp ) );
            return upcast_reference();
        }

        //! Add header `Date` field.
        Response_Builder &&
        append_header_date_field(
            std::chrono::system_clock::time_point tp =
                std::chrono::system_clock::now() ) &&
        {
            return std::move( this->append_header_date_field( tp ) );
        }

        //! Set connection close.
        Response_Builder &
        connection_close() & noexcept
        {
            m_header.should_keep_alive( false );
            return upcast_reference();
        }

        //! Set connection close.
        Response_Builder &&
        connection_close() && noexcept
        {
            return std::move( this->connection_close() );
        }


        //! Set connection keep-alive.
        Response_Builder &
        connection_keep_alive() & noexcept
        {
            m_header.should_keep_alive();
            return upcast_reference();
        }

        Response_Builder &&
        connection_keep_alive() && noexcept
        {
            return std::move( this->connection_keep_alive() );
        }

    protected:
        std::size_t
        calculate_status_line_size() const noexcept
        {
            // "HTTP/1.1 *** <reason-phrase>"
            return 8 + 1 + 3 + 1 + m_header.status_line().reason_phrase().size();
        }

        http_response_header_t m_header;

        impl::connection_handle_t m_connection;
        const request_id_t m_request_id;

        void
        throw_done_must_be_called_once() const
        {
            throw exception_t{ "done() cannot be called twice" };
        }

    private:
        Response_Builder &
        upcast_reference() noexcept
        {
            return static_cast< Response_Builder & >( *this );
        }
};

//
// response_builder_t
//

//! Forbid arbitrary response_builder_t instantiations.
template < typename Response_Output_Strategy >
class response_builder_t
{
    response_builder_t() = delete;
};

//! Tag type for RESTinio controlled output response builder.
struct restinio_controlled_output_t {};

//! Simple standard response builder.
/*!
    Requires user to set header and body.
    Content length is automatically calculated.
    Once the data is ready, the user calls done() method
    and the resulting response is scheduled for sending.
*/
template <>
class response_builder_t< restinio_controlled_output_t > final
    :   public base_response_builder_t< response_builder_t< restinio_controlled_output_t > >
{
    public:
        using base_type_t =
            base_response_builder_t< response_builder_t< restinio_controlled_output_t > >;
        using self_type_t =
            response_builder_t< restinio_controlled_output_t >;

        response_builder_t( response_builder_t && ) = default;

        // Reuse construstors from base.
        using base_type_t::base_type_t;

        //! Set body.
        self_type_t &
        set_body( writable_item_t body ) &
        {
            auto size = body.size();
            return set_body_impl( body, size );
        }

        //! Set body.
        self_type_t &&
        set_body( writable_item_t body ) &&
        {
            return std::move( this->set_body( std::move( body ) ) );
        }

        //! Append body.
        self_type_t &
        append_body( writable_item_t body_part ) &
        {
            auto size = body_part.size();
            return append_body_impl( body_part, size );
        }

        //! Append body.
        self_type_t &&
        append_body( writable_item_t body_part ) &&
        {
            return std::move( this->append_body( std::move( body_part ) ) );
        }

        //! Complete response.
        request_handling_status_t
        done( write_status_cb_t wscb = write_status_cb_t{} )
        {
            if( m_connection )
            {
                const response_output_flags_t
                    response_output_flags{
                        response_parts_attr_t::final_parts,
                        response_connection_attr( m_header.should_keep_alive() ) };

                m_header.content_length( m_body_size );

                if_neccessary_reserve_first_element_for_header();

                m_response_parts[ 0 ] =
                    writable_item_t{ impl::create_header_string( m_header ) };

                write_group_t wg{ std::move( m_response_parts ) };
                wg.status_line_size( calculate_status_line_size() );

                if( wscb )
                {
                    wg.after_write_notificator( std::move( wscb ) );
                }

                auto conn = std::move( m_connection );

                conn->write_response_parts(
                    m_request_id,
                    response_output_flags,
                    std::move( wg ) );
            }
            else
            {
                throw_done_must_be_called_once();
            }

            return restinio::request_accepted();
        }

    private:
        self_type_t &
        set_body_impl( writable_item_t & body, std::size_t body_size )
        {
            if_neccessary_reserve_first_element_for_header();

            // Leave only buf that is reserved for header,
            // so forget all the previous data.
            m_response_parts.resize( 1 );

            if( 0 < body_size )
            {
                m_response_parts.emplace_back( std::move( body ) );
            }

            m_body_size = body_size;

            return *this;
        }

        self_type_t &
        append_body_impl( writable_item_t & body_part, std::size_t append_size )
        {
            if_neccessary_reserve_first_element_for_header();

            if( 0 < append_size )
            {
                    m_response_parts.emplace_back( std::move( body_part ) );
                    m_body_size += append_size;
            }

            return *this;
        }

        void
        if_neccessary_reserve_first_element_for_header()
        {
            if( m_response_parts.empty() )
            {
                m_response_parts.reserve( 2 );
                m_response_parts.emplace_back();
            }
        }

        std::size_t m_body_size{ 0 };
        writable_items_container_t m_response_parts;
};

//! Tag type for user controlled output response builder.
struct user_controlled_output_t {};

//! User controlled response output builder.
/*!
    This type of output allows user
    to send body divided into parts.
    But it is up to user to set the correct
    Content-Length field.
*/
template <>
class response_builder_t< user_controlled_output_t > final
    :   public base_response_builder_t< response_builder_t< user_controlled_output_t > >
{
    public:
        using base_type_t =
            base_response_builder_t< response_builder_t< user_controlled_output_t > >;
        using self_type_t =
            response_builder_t< user_controlled_output_t >;

        response_builder_t( response_builder_t && ) = default;

        // Reuse construstors from base.
        using base_type_t::base_type_t;

        //! Manualy set content length.
        self_type_t &
        set_content_length( std::size_t content_length ) &
        {
            m_header.content_length( content_length );
            return *this;
        }

        //! Manualy set content length.
        self_type_t &&
        set_content_length( std::size_t content_length ) &&
        {
            return std::move( this->set_content_length( content_length ) );
        }

        //! Set body (part).
        self_type_t &
        set_body( writable_item_t body ) &
        {
            auto size = body.size();
            return set_body_impl( body, size );
        }

        //! Set body (part).
        self_type_t &&
        set_body( writable_item_t body ) &&
        {
            return std::move( this->set_body( std::move( body ) ) );
        }

        //! Append body.
        self_type_t &
        append_body( writable_item_t body_part ) &
        {
            auto size = body_part.size();

            if( 0 == size )
                return *this;

            return append_body_impl( body_part );
        }

        //! Append body.
        self_type_t &&
        append_body( writable_item_t body_part ) &&
        {
            return std::move( this->append_body( std::move( body_part ) ) );
        }

        //! Flush ready outgoing data.
        /*!
            Schedules for sending currently ready data.
        */
        self_type_t &
        flush( write_status_cb_t wscb = write_status_cb_t{} ) &
        {
            if( m_connection )
            {
                send_ready_data(
                    m_connection,
                    response_parts_attr_t::not_final_parts,
                    std::move( wscb ) );
            }

            return *this;
        }

        //! Flush ready outgoing data.
        self_type_t &&
        flush( write_status_cb_t wscb = write_status_cb_t{} ) &&
        {
            return std::move( this->flush( std::move( wscb ) ) );
        }

        //! Complete response.
        request_handling_status_t
        done( write_status_cb_t wscb = write_status_cb_t{} )
        {
            if( m_connection )
            {
                // Note: m_connection should become empty after return
                // from that method.
                impl::connection_handle_t old_conn_handle{
                        std::move(m_connection) };
                send_ready_data(
                    old_conn_handle,
                    response_parts_attr_t::final_parts,
                    std::move( wscb ) );
            }
            else
            {
                throw_done_must_be_called_once();
            }

            return restinio::request_accepted();
        }

    private:
        void
        send_ready_data(
            const impl::connection_handle_t & conn,
            response_parts_attr_t response_parts_attr,
            write_status_cb_t wscb )
        {
            std::size_t status_line_size{ 0 };

            if( !m_header_was_sent )
            {
                m_should_keep_alive_when_header_was_sent =
                    m_header.should_keep_alive();

                if_neccessary_reserve_first_element_for_header();

                m_response_parts[ 0 ] =
                    writable_item_t{ impl::create_header_string( m_header ) };

                m_header_was_sent = true;
                status_line_size = calculate_status_line_size();
            }

            if( !m_response_parts.empty() ||
                wscb ||
                response_parts_attr_t::final_parts == response_parts_attr )
            {
                const response_output_flags_t
                    response_output_flags{
                        response_parts_attr,
                        response_connection_attr( m_should_keep_alive_when_header_was_sent ) };

                write_group_t wg{ std::move( m_response_parts ) };
                wg.status_line_size( status_line_size );

                if( wscb )
                {
                    wg.after_write_notificator( std::move( wscb ) );
                }

                conn->write_response_parts(
                    m_request_id,
                    response_output_flags,
                    std::move( wg ) );
            }
        }

        self_type_t &
        set_body_impl( writable_item_t & body, std::size_t body_size )
        {
            if_neccessary_reserve_first_element_for_header();

            // Leave only buf that is reserved for header,
            // so forget all the previous data.
            if( !m_header_was_sent )
                m_response_parts.resize( 1 );
            else
                m_response_parts.resize( 0 );

            if( 0 < body_size )
            {
                // if body is not empty:
                m_response_parts.emplace_back( std::move( body ) );
            }

            return *this;
        }

        self_type_t &
        append_body_impl( writable_item_t & body_part )
        {
            if_neccessary_reserve_first_element_for_header();

            m_response_parts.emplace_back( std::move( body_part ) );
            return *this;
        }

        void
        if_neccessary_reserve_first_element_for_header()
        {
            if( !m_header_was_sent && m_response_parts.empty() )
            {
                m_response_parts.reserve( 2 );
                m_response_parts.emplace_back();
            }
        }


        //! Flag used by flush() function.
        bool m_header_was_sent{ false };

        //! Saved keep_alive attr actual at the point
        //! a header data was sent.
        /*!
            It is neccessary to guarantee that all parts of response
            will have the same response-connection-attr
            (keep-alive or close);
        */
        bool m_should_keep_alive_when_header_was_sent{ true };

        //! Body accumulator.
        /*!
            For this type of output it contains a part of a body.
            On each flush it is cleared.
        */
        writable_items_container_t m_response_parts;
};

//! Tag type for chunked output response builder.
struct chunked_output_t {};

//! Chunked transfer encoding output builder.
/*!
    This type of output sets transfer-encoding to chunked
    and expects user to set body using chunks of data.
*/
template <>
class response_builder_t< chunked_output_t > final
    :   public base_response_builder_t< response_builder_t< chunked_output_t > >
{
    public:
        using base_type_t =
            base_response_builder_t< response_builder_t< chunked_output_t > >;
        using self_type_t =
            response_builder_t< chunked_output_t >;

        response_builder_t(
            http_status_line_t status_line,
            impl::connection_handle_t connection,
            request_id_t request_id,
            bool should_keep_alive )
            :   base_type_t{
                    std::move( status_line ),
                    std::move( connection ),
                    request_id,
                    should_keep_alive }
        {
            m_chunks.reserve( 4 );
        }

        response_builder_t( response_builder_t && ) = default;

        //! Append current chunk.
        self_type_t &
        append_chunk( writable_item_t chunk ) &
        {
            auto size = chunk.size();

            if( 0 != size )
                m_chunks.emplace_back( std::move( chunk ) );

            return *this;
        }

        //! Append current chunk.
        self_type_t &&
        append_chunk( writable_item_t chunk ) &&
        {
            return std::move( this->append_chunk( std::move( chunk ) ) );
        }

        //! Flush ready outgoing data.
        /*!
            Schedules for sending currently ready data.
        */
        self_type_t &
        flush( write_status_cb_t wscb = write_status_cb_t{} ) &
        {
            if( m_connection )
            {
                send_ready_data(
                    m_connection,
                    response_parts_attr_t::not_final_parts,
                    std::move( wscb ) );
            }

            return *this;
        }

        //! Flush ready outgoing data.
        self_type_t &&
        flush( write_status_cb_t wscb = write_status_cb_t{} ) &&
        {
            return std::move( this->flush( std::move( wscb ) ) );
        }

        //! Complete response.
        request_handling_status_t
        done( write_status_cb_t wscb = write_status_cb_t{} )
        {
            if( m_connection )
            {
                // Note: m_connection should become empty after return
                // from that method.
                impl::connection_handle_t old_conn_handle{
                        std::move(m_connection) };
                send_ready_data(
                    old_conn_handle,
                    response_parts_attr_t::final_parts,
                    std::move( wscb ) );
            }
            else
            {
                throw_done_must_be_called_once();
            }

            return restinio::request_accepted();
        }

    private:
        void
        send_ready_data(
            const impl::connection_handle_t & conn,
            response_parts_attr_t response_parts_attr,
            write_status_cb_t wscb )
        {
            std::size_t status_line_size{ 0 };
            if( !m_header_was_sent )
            {
                status_line_size = calculate_status_line_size();
                prepare_header_for_sending();
            }

            auto bufs = create_bufs( response_parts_attr_t::final_parts == response_parts_attr );
            m_header_was_sent = true;

            const response_output_flags_t
                response_output_flags{
                    response_parts_attr,
                    response_connection_attr( m_should_keep_alive_when_header_was_sent ) };

            // We have buffers or at least we have after-write notificator.
            if( !bufs.empty() || wscb )
            {
                write_group_t wg{ std::move( bufs ) };
                wg.status_line_size( status_line_size );

                if( wscb )
                {
                    wg.after_write_notificator( std::move( wscb ) );
                }

                conn->write_response_parts(
                    m_request_id,
                    response_output_flags,
                    std::move( wg ) );
            }
        }

        void
        prepare_header_for_sending()
        {
            m_should_keep_alive_when_header_was_sent =
                m_header.should_keep_alive();

            constexpr const char value[] = "chunked";
            if( !m_header.has_field( restinio::http_field::transfer_encoding ) )
            {
                m_header.add_field(
                    restinio::http_field::transfer_encoding,
                    std::string{ value, impl::ct_string_len( value ) } );
            }
            else
            {
                auto & current_value =
                    m_header.get_field( restinio::http_field::transfer_encoding );
                if( std::string::npos == current_value.find( value ) )
                {
                    constexpr const char comma_value[] = ",chunked";
                    m_header.append_field(
                        restinio::http_field::transfer_encoding,
                        std::string{
                            comma_value,
                            impl::ct_string_len( comma_value ) } );
                }
            }
        }

        writable_items_container_t
        create_bufs( bool add_zero_chunk )
        {
            writable_items_container_t bufs;

            std::size_t reserve_size = 2 * m_chunks.size() + 1;

            if( !m_header_was_sent )
            {
                ++reserve_size;
            }
            if( add_zero_chunk )
            {
                ++reserve_size;
            }

            bufs.reserve( reserve_size );

            if( !m_header_was_sent )
            {
                bufs.emplace_back(
                    impl::create_header_string(
                        m_header,
                        impl::content_length_field_presence_t::skip_content_length ) );
            }

            const char * format_string = "{:X}\r\n";
            for( auto & chunk : m_chunks )
            {
                bufs.emplace_back(
                    fmt::format(
                        format_string,
                        asio_ns::buffer_size( chunk.buf() ) ) );

                // Now include "\r\n"-ending for a previous chunk to format string.
                format_string = "\r\n{:X}\r\n";

                bufs.emplace_back( std::move( chunk ) );

            }

            const char * const ending_representation = "\r\n" "0\r\n\r\n";
            const char * appendix_begin = ending_representation + 2;
            const char * appendix_end = appendix_begin;

            if( !m_chunks.empty() )
            {
                // Add "\r\n"part to appendix.
                appendix_begin -= 2;
                // bufs.emplace_back( const_buffer( rn_ending, 2 ) );
            }

            if( add_zero_chunk )
            {
                // Add "0\r\n\r\n"part to appendix.
                appendix_end += 5;
            }

            if( appendix_begin != appendix_end )
            {
                bufs.emplace_back( const_buffer(
                        appendix_begin,
                        static_cast<std::size_t>(appendix_end - appendix_begin)
                    ) );
            }

            m_chunks.clear();

            return bufs;
        }

        //! Flag used by flush() function.
        bool m_header_was_sent{ false };

        //! Saved keep_alive attr actual at the point
        //! a header data was sent.
        /*!
            It is neccessary to guarantee that all parts of response
            will have the same response-connection-attr
            (keep-alive or close);
        */
        bool m_should_keep_alive_when_header_was_sent{ true };

        //! Chunks accumulator.
        writable_items_container_t m_chunks;
};

} /* namespace restinio */