settings.hpp

Go to the documentation of this file.

/*
    restinio
*/

 
#pragma once
 
#include <restinio/asio_include.hpp>
 
#include <restinio/exception.hpp>
#include <restinio/request_handler.hpp>
#include <restinio/traits.hpp>
 
#include <restinio/incoming_http_msg_limits.hpp>
 
#include <chrono>
#include <variant>
#include <tuple>
#include <utility>
 
namespace restinio
{
 
namespace details
{

template < typename Object >
inline auto
create_default_unique_object_instance( std::false_type )
{
    return std::unique_ptr< Object >{};
}
 
template < typename Object >
inline auto
create_default_unique_object_instance( std::true_type )
{
    return std::make_unique< Object >();
}

template < typename Object >
inline auto
create_default_shared_object_instance( std::false_type )
{
    return std::shared_ptr< Object >{};
}
 
template < typename Object >
inline auto
create_default_shared_object_instance( std::true_type )
{
    return std::make_shared< Object >();
}
 
} /* namespace details */
 
//
// create_default_unique_object_instance
//

template < typename Object>
inline auto
create_default_unique_object_instance()
{
    typename std::is_default_constructible< Object >::type tag;
    return details::create_default_unique_object_instance< Object >( tag );
}

template <>
inline auto
create_default_unique_object_instance< default_request_handler_t >()
{
    return details::create_default_unique_object_instance< default_request_handler_t >(
            std::false_type{} );
}
 
//
// create_default_shared_object_instance
//

template < typename Object>
inline auto
create_default_shared_object_instance()
{
    typename std::is_default_constructible< Object >::type tag;
    return details::create_default_shared_object_instance< Object >( tag );
}

template <>
inline auto
create_default_shared_object_instance< default_request_handler_t >()
{
    return details::create_default_shared_object_instance< default_request_handler_t >(
            std::false_type{} );
}
 
//
// ensure_created()
//

template < typename Object >
auto
ensure_created(
    std::unique_ptr< Object > mb_created_one,
    string_view_t fail_description )
{
    if( !mb_created_one )
        mb_created_one = create_default_unique_object_instance< Object >();
 
    if( !mb_created_one )
        throw exception_t{ fail_description };
 
    return mb_created_one;
}
 
//
// unsure_created()
//

template < typename Object >
auto
ensure_created(
    std::shared_ptr< Object > mb_created_one,
    string_view_t fail_description )
{
    if( !mb_created_one )
        mb_created_one = create_default_shared_object_instance< Object >();
 
    if( !mb_created_one )
        throw exception_t{ fail_description };
 
    return mb_created_one;
}
 
 
//
// socket_type_dependent_settings_t
//

template < typename Settings, typename Socket >
class socket_type_dependent_settings_t
{
protected :
    ~socket_type_dependent_settings_t() noexcept = default;
 
public :
    socket_type_dependent_settings_t() noexcept = default;
 
    socket_type_dependent_settings_t(const socket_type_dependent_settings_t &) noexcept = default;
    socket_type_dependent_settings_t(socket_type_dependent_settings_t &&) noexcept = default;
 
    socket_type_dependent_settings_t &
    operator=(const socket_type_dependent_settings_t &) noexcept = default;
 
    socket_type_dependent_settings_t &
    operator=(socket_type_dependent_settings_t &&) noexcept = delete;
 
    // No extra settings by default.
};
 
//
// acceptor_options_t
//


class acceptor_options_t
{
    public:
        acceptor_options_t( asio_ns::ip::tcp::acceptor & acceptor )
            :   m_acceptor{ acceptor }
        {}

        template< typename Option >
        void
        set_option( const Option & option )
        {
            m_acceptor.set_option( option );
        }
 
        template< typename Option >
        void
        set_option( const Option & option, asio_ns::error_code & ec )
        {
            m_acceptor.set_option( option, ec );
        }
 
        template< typename Option >
        void
        get_option( Option & option )
        {
            m_acceptor.get_option( option );
        }
 
        template< typename Option >
        void
        get_option( Option & option, asio_ns::error_code & ec )
        {
            m_acceptor.get_option( option, ec );
        }

 
    private:
        asio_ns::ip::tcp::acceptor & m_acceptor;
};
 
using acceptor_options_setter_t = std::function< void ( acceptor_options_t & ) >;
 
template <>
inline auto
create_default_unique_object_instance< acceptor_options_setter_t >()
{
    return std::make_unique< acceptor_options_setter_t >(
        []( acceptor_options_t & options ){
            options.set_option( asio_ns::ip::tcp::acceptor::reuse_address( true ) );
        } );
}
 
//
// socket_options_t
//


class socket_options_t
{
    public:
        socket_options_t(
            asio_ns::basic_socket< asio_ns::ip::tcp > & socket )
            :   m_socket{ socket }
        {}

        template< typename Option >
        void
        set_option( const Option & option )
        {
            m_socket.set_option( option );
        }
 
        template< typename Option >
        void
        set_option( const Option & option, asio_ns::error_code & ec )
        {
            m_socket.set_option( option, ec );
        }
 
        template< typename Option >
        void
        get_option( Option & option )
        {
            m_socket.get_option( option );
        }
 
        template< typename Option >
        void
        get_option( Option & option, asio_ns::error_code & ec )
        {
            m_socket.get_option( option, ec );
        }

 
    private:
        asio_ns::basic_socket< asio_ns::ip::tcp > & m_socket;
};
 
using socket_options_setter_t = std::function< void ( socket_options_t & ) >;
 
template <>
inline auto
create_default_unique_object_instance< socket_options_setter_t >()
{
    return std::make_unique< socket_options_setter_t >( []( auto & ){} );
}
 
//
// cleanup_functor_t
//
using cleanup_functor_t = std::function< void(void) >;
 
//
// connection_state_listener_holder_t
//
template< typename Listener >
struct connection_state_listener_holder_t
{
    std::shared_ptr< Listener > m_connection_state_listener;
 
    static constexpr bool has_actual_connection_state_listener = true;


    void
    check_valid_connection_state_listener_pointer() const
    {
        if( !m_connection_state_listener )
            throw exception_t{ "connection state listener is not specified" };
    }
};

template<>
struct connection_state_listener_holder_t< connection_state::noop_listener_t >
{
    static constexpr bool has_actual_connection_state_listener = false;
 
    void
    check_valid_connection_state_listener_pointer() const
    {
        // Nothing to do.
    }
};
 
//
// ip_blocker_holder_t
//
template< typename Ip_Blocker >
struct ip_blocker_holder_t
{
    static_assert(
            noexcept( std::declval<Ip_Blocker>().inspect(
                    std::declval<ip_blocker::incoming_info_t>() ) ),
            "Ip_Blocker::inspect() method should be noexcept" );
 
    static_assert(
            std::is_same<
                    restinio::ip_blocker::inspection_result_t,
                    decltype(std::declval<Ip_Blocker>().inspect(
                            std::declval<ip_blocker::incoming_info_t>())) >::value,
            "Ip_Blocker::inspect() should return "
            "restinio::ip_blocker::inspection_result_t" );
 
    std::shared_ptr< Ip_Blocker > m_ip_blocker;
 
    static constexpr bool has_actual_ip_blocker = true;


    void
    check_valid_ip_blocker_pointer() const
    {
        if( !m_ip_blocker )
            throw exception_t{ "IP-blocker is not specified" };
    }
};

template<>
struct ip_blocker_holder_t< ip_blocker::noop_ip_blocker_t >
{
    static constexpr bool has_actual_ip_blocker = false;
 
    void
    check_valid_ip_blocker_pointer() const
    {
        // Nothing to do.
    }
};
 
//
// acceptor_post_bind_hook_t
//
using acceptor_post_bind_hook_t = std::function<
        void(asio_ns::ip::tcp::acceptor &) >;
 
namespace details
{
 
//
// no_address_specified_t
//
struct no_address_specified_t {};
 
//
// address_variant_t
//
using address_variant_t = std::variant<
        no_address_specified_t,
        std::string,
        asio_ns::ip::address >;
 
//
// max_parallel_connections_holder_t
//
template< typename Count_Limiter >
struct max_parallel_connections_holder_t
{
    static constexpr bool has_actual_max_parallel_connections = true;

    std::size_t m_max_parallel_connections{
            std::numeric_limits<std::size_t>::max()
        };
 
    std::size_t
    max_parallel_connections() const noexcept
    {
        return m_max_parallel_connections;
    }
 
    void
    set_max_parallel_connections( std::size_t v ) noexcept
    {
        m_max_parallel_connections = v;
    }
};

template<>
struct max_parallel_connections_holder_t<
        ::restinio::connection_count_limits::noop_connection_count_limiter_t >
{
    static constexpr bool has_actual_max_parallel_connections = false;
 
    std::size_t
    max_parallel_connections() const noexcept
    {
        return std::numeric_limits<std::size_t>::max();
    }
};
 
} /* namespace details */
 
//
// basic_server_settings_t
//


template<typename Derived, typename Traits>
class basic_server_settings_t
    :   public socket_type_dependent_settings_t< Derived, typename Traits::stream_socket_t >
    ,   protected connection_state_listener_holder_t<
            typename Traits::connection_state_listener_t >
    ,   protected ip_blocker_holder_t< typename Traits::ip_blocker_t >
    ,   protected details::max_parallel_connections_holder_t<
            typename connection_count_limit_types<Traits>::limiter_t >
{
        using base_type_t = socket_type_dependent_settings_t<
                Derived, typename Traits::stream_socket_t>;
 
        using max_parallel_connections_holder_base_t =
                details::max_parallel_connections_holder_t<
                        typename connection_count_limit_types<Traits>::limiter_t >;
 
        using connection_state_listener_holder_t<
                        typename Traits::connection_state_listener_t
                    >::has_actual_connection_state_listener;
 
        using ip_blocker_holder_t<
                        typename Traits::ip_blocker_t
                    >::has_actual_ip_blocker;
 
        using max_parallel_connections_holder_base_t::has_actual_max_parallel_connections;
 
    public:
        basic_server_settings_t(
            std::uint16_t port = 8080,
            asio_ns::ip::tcp protocol = asio_ns::ip::tcp::v4() )
            :   base_type_t{}
            ,   m_port{ port }
            ,   m_protocol{ protocol }
        {}

        Derived &
        port( std::uint16_t p ) &
        {
            m_port = p;
            return reference_to_derived();
        }
 
        Derived &&
        port( std::uint16_t p ) &&
        {
            return std::move( this->port( p ) );
        }
 
        [[nodiscard]]
        std::uint16_t
        port() const
        {
            return m_port;
        }
 
        Derived &
        protocol( asio_ns::ip::tcp p ) &
        {
            m_protocol = p;
            return reference_to_derived();
        }
 
        Derived &&
        protocol( asio_ns::ip::tcp p ) &&
        {
            return std::move( this->protocol( p ) );
        }
 
        [[nodiscard]]
        asio_ns::ip::tcp
        protocol() const
        {
            return m_protocol;
        }

        Derived &
        address( std::string addr ) &
        {
            m_address = std::move(addr);
            return reference_to_derived();
        }

        Derived &&
        address( std::string addr ) &&
        {
            return std::move( this->address( std::move( addr ) ) );
        }

        Derived &
        address( asio_ns::ip::address addr ) &
        {
            m_address = addr;
            return reference_to_derived();
        }

        Derived &&
        address( asio_ns::ip::address addr ) &&
        {
            return std::move( this->address( addr ) );
        }
 
        [[nodiscard]]
        const details::address_variant_t &
        address() const
        {
            return m_address;
        }



        Derived &
        buffer_size( std::size_t s ) &
        {
            m_buffer_size = s;
            return reference_to_derived();
        }
 
        Derived &&
        buffer_size( std::size_t s ) &&
        {
            return std::move( this->buffer_size( s ) );
        }
 
        std::size_t
        buffer_size() const
        {
            return m_buffer_size;
        }



        Derived &
        read_next_http_message_timelimit( std::chrono::steady_clock::duration d ) &
        {
            m_read_next_http_message_timelimit = std::move( d );
            return reference_to_derived();
        }
 
        Derived &&
        read_next_http_message_timelimit( std::chrono::steady_clock::duration d ) &&
        {
            return std::move( this->read_next_http_message_timelimit( std::move( d ) ) );
        }
 
        std::chrono::steady_clock::duration
        read_next_http_message_timelimit() const
        {
            return m_read_next_http_message_timelimit;
        }


        Derived &
        write_http_response_timelimit( std::chrono::steady_clock::duration d ) &
        {
            m_write_http_response_timelimit = std::move( d );
            return reference_to_derived();
        }
 
        Derived &&
        write_http_response_timelimit( std::chrono::steady_clock::duration d ) &&
        {
            return std::move( this->write_http_response_timelimit( std::move( d ) ) );
        }
 
        std::chrono::steady_clock::duration
        write_http_response_timelimit() const
        {
            return m_write_http_response_timelimit;
        }


        Derived &
        handle_request_timeout( std::chrono::steady_clock::duration d ) &
        {
            m_handle_request_timeout = std::move( d );
            return reference_to_derived();
        }
 
        Derived &&
        handle_request_timeout( std::chrono::steady_clock::duration d ) &&
        {
            return std::move( this->handle_request_timeout( std::move( d ) ) );
        }
 
        std::chrono::steady_clock::duration
        handle_request_timeout() const
        {
            return m_handle_request_timeout;
        }


        Derived &
        max_pipelined_requests( std::size_t mpr ) &
        {
            m_max_pipelined_requests = mpr;
            return reference_to_derived();
        }
 
        Derived &&
        max_pipelined_requests( std::size_t mpr ) &&
        {
            return std::move( this->max_pipelined_requests( mpr ) );
        }
 
        std::size_t
        max_pipelined_requests() const
        {
            return m_max_pipelined_requests;
        }

 

        using request_handler_t = request_handler_type_from_traits_t< Traits >;
 
        Derived &
        request_handler( std::unique_ptr< request_handler_t > handler ) &
        {
            m_request_handler = std::move( handler );
            return reference_to_derived();
        }
 
        template< typename... Params >
        Derived &
        request_handler( Params &&... params ) &
        {
            return set_unique_instance(
                    m_request_handler,
                    std::forward< Params >( params )... );
        }
 
 
        template< typename... Params >
        Derived &&
        request_handler( Params &&... params ) &&
        {
            return std::move( this->request_handler( std::forward< Params >( params )... ) );
        }
 
        std::unique_ptr< request_handler_t >
        request_handler()
        {
            return ensure_created(
                std::move( m_request_handler ),
                "request handler must be set" );
        }

 


        using timer_manager_t = typename Traits::timer_manager_t;
        using timer_factory_t = typename timer_manager_t::factory_t;

        template< typename... Params >
        Derived &
        timer_manager( Params &&... params ) &
        {
            return set_unique_instance(
                    m_timer_factory,
                    std::forward< Params >( params )... );
        }

        template< typename... Params >
        Derived &&
        timer_manager( Params &&... params ) &&
        {
            return std::move( this->timer_manager( std::forward< Params >( params )... ) );
        }
 
        std::unique_ptr< timer_factory_t >
        timer_factory()
        {
            return ensure_created(
                std::move( m_timer_factory ),
                "timer manager is not set" );
        }


        using logger_t = typename Traits::logger_t;
 
        template< typename... Params >
        Derived &
        logger( Params &&... params ) &
        {
            return set_unique_instance(
                    m_logger,
                    std::forward< Params >( params )... );
        }
 
        template< typename... Params >
        Derived &&
        logger( Params &&... params ) &&
        {
            return std::move( this->logger( std::forward< Params >( params )... ) );
        }
 
        std::unique_ptr< logger_t >
        logger()
        {
            return ensure_created(
                std::move( m_logger ),
                "logger must be set" );
        }


        Derived &
        acceptor_options_setter( acceptor_options_setter_t aos ) &
        {
            if( !aos )
                throw exception_t{ "acceptor options setter cannot be empty" };
 
            return set_unique_instance(
                    m_acceptor_options_setter,
                    std::move( aos ) );
        }
 
        Derived &&
        acceptor_options_setter( acceptor_options_setter_t aos ) &&
        {
            return std::move( this->acceptor_options_setter( std::move( aos ) ) );
        }
 
        std::unique_ptr< acceptor_options_setter_t >
        acceptor_options_setter()
        {
            return ensure_created(
                std::move( m_acceptor_options_setter ),
                "acceptor options setter must be set" );
        }


        Derived &
        socket_options_setter( socket_options_setter_t sos ) &
        {
            if( !sos )
                throw exception_t{ "socket options setter cannot be empty" };
 
            return set_unique_instance(
                    m_socket_options_setter,
                    std::move( sos ) );
        }
 
        Derived &&
        socket_options_setter( socket_options_setter_t sos ) &&
        {
            return std::move( this->socket_options_setter( std::move( sos ) ) );
        }
 
        std::unique_ptr< socket_options_setter_t >
        socket_options_setter()
        {
            return ensure_created(
                std::move( m_socket_options_setter ),
                "socket options setter must be set" );
        }



        Derived &
        concurrent_accepts_count( std::size_t n ) &
        {
            if( 0 == n || 1024 < n )
                throw exception_t{
                    fmt::format(
                        RESTINIO_FMT_FORMAT_STRING(
                            "invalid value for number of cuncurrent connects: {}" ),
                        n ) };
 
            m_concurrent_accepts_count = n;
            return reference_to_derived();
        }
 
        Derived &&
        concurrent_accepts_count( std::size_t n ) &&
        {
            return std::move( this->concurrent_accepts_count( n ) );
        }
 
        std::size_t
        concurrent_accepts_count() const
        {
            return m_concurrent_accepts_count;
        }



        Derived &
        separate_accept_and_create_connect( bool do_separate ) & noexcept
        {
            m_separate_accept_and_create_connect = do_separate;
            return reference_to_derived();
        }
 
        Derived &&
        separate_accept_and_create_connect( bool do_separate ) && noexcept
        {
            return std::move( this->separate_accept_and_create_connect( do_separate ) );
        }
 
        bool
        separate_accept_and_create_connect() const noexcept
        {
            return m_separate_accept_and_create_connect;
        }


        template< typename Func >
        Derived &
        cleanup_func( Func && func ) &
        {
            m_cleanup_functor = std::move(func);
            return reference_to_derived();
        }
 
        template< typename Func >
        Derived &&
        cleanup_func( Func && func ) &&
        {
            return std::move(this->cleanup_func( std::forward<Func>(func) ));
        }

        [[nodiscard]]
        cleanup_functor_t
        giveaway_cleanup_func()
        {
            return std::move(m_cleanup_functor);
        }


        Derived &
        connection_state_listener(
            std::shared_ptr< typename Traits::connection_state_listener_t > listener ) &
        {
            static_assert(
                    has_actual_connection_state_listener,
                    "connection_state_listener(listener) can't be used "
                    "for the default connection_state::noop_listener_t" );
 
            this->m_connection_state_listener = std::move(listener);
            return reference_to_derived();
        }

        Derived &&
        connection_state_listener(
            std::shared_ptr< typename Traits::connection_state_listener_t > listener ) &&
        {
            return std::move(this->connection_state_listener(
                    std::move(listener)));
        }

        const std::shared_ptr< typename Traits::connection_state_listener_t > &
        connection_state_listener() const noexcept
        {
            static_assert(
                    has_actual_connection_state_listener,
                    "connection_state_listener() can't be used "
                    "for the default connection_state::noop_listener_t" );
 
            return this->m_connection_state_listener;
        }

        void
        ensure_valid_connection_state_listener()
        {
            this->check_valid_connection_state_listener_pointer();
        }

        Derived &
        ip_blocker(
            std::shared_ptr< typename Traits::ip_blocker_t > blocker ) &
        {
            static_assert(
                    basic_server_settings_t::has_actual_ip_blocker,
                    "ip_blocker(blocker) can't be used "
                    "for the default ip_blocker::noop_ip_blocker_t" );
 
            this->m_ip_blocker = std::move(blocker);
            return reference_to_derived();
        }

        Derived &&
        ip_blocker(
            std::shared_ptr< typename Traits::ip_blocker_t > blocker ) &&
        {
            return std::move(this->ip_blocker(std::move(blocker)));
        }

        const std::shared_ptr< typename Traits::ip_blocker_t > &
        ip_blocker() const noexcept
        {
            static_assert(
                    basic_server_settings_t::has_actual_ip_blocker,
                    "ip_blocker() can't be used "
                    "for the default ip_blocker::noop_ip_blocker_t" );
 
            return this->m_ip_blocker;
        }

        void
        ensure_valid_ip_blocker()
        {
            this->check_valid_ip_blocker_pointer();
        }
 
        // Acceptor post-bind hook.
        Derived &
        acceptor_post_bind_hook( acceptor_post_bind_hook_t hook ) &
        {
            if( !hook )
                throw exception_t{ "acceptor_post_bind_hook cannot be empty" };
 
            m_acceptor_post_bind_hook = std::move(hook);
            return reference_to_derived();
        }

        Derived &&
        acceptor_post_bind_hook( acceptor_post_bind_hook_t hook ) &&
        {
            return std::move(this->acceptor_post_bind_hook( std::move(hook) ));
        }

        [[nodiscard]]
        acceptor_post_bind_hook_t
        giveaway_acceptor_post_bind_hook()
        {
            return std::move(m_acceptor_post_bind_hook);
        }

        [[nodiscard]]
        const incoming_http_msg_limits_t &
        incoming_http_msg_limits() const noexcept
        {
            return m_incoming_http_msg_limits;
        }

        Derived &
        incoming_http_msg_limits(
            const incoming_http_msg_limits_t & limits ) & noexcept
        {
            m_incoming_http_msg_limits = limits;
            return reference_to_derived();
        }

        Derived &&
        incoming_http_msg_limits(
            const incoming_http_msg_limits_t & limits ) && noexcept
        {
            return std::move(this->incoming_http_msg_limits(limits));
        }

        Derived &
        max_parallel_connections( std::size_t value ) & noexcept
        {
            static_assert(
                    basic_server_settings_t::has_actual_max_parallel_connections,
                    "max_parallel_connections(value) can't be used "
                    "for the noop_connection_count_limiter_t" );
 
            this->set_max_parallel_connections( value );
            return reference_to_derived();
        }

        Derived &&
        max_parallel_connections( std::size_t value ) && noexcept 
        {
            return std::move(this->max_parallel_connections( value ));
        }
 
        using max_parallel_connections_holder_base_t::max_parallel_connections;

        using extra_data_factory_t = typename Traits::extra_data_factory_t;
        using extra_data_factory_handle_t = std::shared_ptr< extra_data_factory_t >;

        Derived &
        extra_data_factory(
            extra_data_factory_handle_t factory ) &
        {
            this->m_extra_data_factory = std::move(factory);
            return reference_to_derived();
        }

        Derived &&
        extra_data_factory(
            extra_data_factory_handle_t factory ) &&
        {
            return std::move(this->extra_data_factory( std::move(factory) ));
        }

        [[nodiscard]]
        extra_data_factory_handle_t
        giveaway_extra_data_factory() const noexcept
        {
            return ensure_created(
                    std::move(this->m_extra_data_factory),
                    "extra_data_factory is not set" );
        }

 
    private:
        Derived &
        reference_to_derived()
        {
            return static_cast<Derived &>(*this);
        }
 
        template< typename Target, typename... Params >
        Derived &
        set_unique_instance( std::unique_ptr< Target > & t, Params &&... params )
        {
            t =
                std::make_unique< Target >(
                    std::forward< Params >( params )... );
 
            return reference_to_derived();
        }
 
        template< typename Target, typename... Params >
        Derived &
        set_shared_instance( std::shared_ptr< Target > & t, Params &&... params )
        {
            t =
                std::make_shared< Target >(
                    std::forward< Params >( params )... );
 
            return reference_to_derived();
        }

        std::uint16_t m_port;
        asio_ns::ip::tcp m_protocol;
        details::address_variant_t m_address;

        std::size_t m_buffer_size{ 4 * 1024 };

        std::chrono::steady_clock::duration
            m_read_next_http_message_timelimit{ std::chrono::seconds( 60 ) };
 
        std::chrono::steady_clock::duration
            m_write_http_response_timelimit{ std::chrono::seconds( 5 ) };
 
        std::chrono::steady_clock::duration
            m_handle_request_timeout{ std::chrono::seconds( 10 ) };

        std::size_t m_max_pipelined_requests{ 1 };

        std::unique_ptr< request_handler_t > m_request_handler;

        std::unique_ptr< timer_factory_t > m_timer_factory;

        std::unique_ptr< logger_t > m_logger;

        std::unique_ptr< acceptor_options_setter_t > m_acceptor_options_setter;


        acceptor_post_bind_hook_t m_acceptor_post_bind_hook{
                [](asio_ns::ip::tcp::acceptor &) {}
            };

        std::unique_ptr< socket_options_setter_t > m_socket_options_setter;
 
        std::size_t m_concurrent_accepts_count{ 1 };

        bool m_separate_accept_and_create_connect{ false };

        cleanup_functor_t m_cleanup_functor;

        incoming_http_msg_limits_t m_incoming_http_msg_limits;

        extra_data_factory_handle_t m_extra_data_factory;
};
 
//
// server_settings_t
//

template<typename Traits = default_traits_t>
class server_settings_t final
    :   public basic_server_settings_t< server_settings_t<Traits>, Traits >
{
    using base_type_t = basic_server_settings_t<
                server_settings_t<Traits>, Traits>;
public:
    using base_type_t::base_type_t;
};
 
template < typename Traits, typename Configurator >
auto
exec_configurator( Configurator && configurator )
{
    server_settings_t< Traits > result;
 
    configurator( result );
 
    return result;
}
 
} /* namespace restinio */