85template<
typename Traits>
88 run_on_this_thread_settings_t<Traits>,
121template<
typename Traits = default_single_thread_traits_t>
136template<
typename Traits>
139 run_on_thread_pool_settings_t<Traits>,
181template<
typename Traits = default_traits_t>
182run_on_thread_pool_settings_t<Traits>
185 std::size_t pool_size )
214template<
typename Traits>
219 asio_ns::io_context & ioctx,
228 std::forward<settings_t>(settings) };
230 std::exception_ptr exception_caught;
232 asio_ns::signal_set break_signals{ server.io_context(), SIGINT };
233 break_signals.async_wait(
234 [&](
const asio_ns::error_code & ec,
int ){
242 [&exception_caught]( std::exception_ptr ex ){
245 exception_caught = ex;
252 [&ioctx, &exception_caught]( std::exception_ptr ex ){
257 exception_caught = ex;
263 if( exception_caught )
264 std::rethrow_exception( exception_caught );
281template<
typename Traits>
286 asio_ns::io_context io_context;
301template<
typename Io_Context_Holder,
typename Traits>
312 std::forward<settings_t>(settings) };
314 std::exception_ptr exception_caught;
316 asio_ns::signal_set break_signals{ server.io_context(), SIGINT };
317 break_signals.async_wait(
318 [&](
const asio_ns::error_code & ec,
int ){
326 [&exception_caught]( std::exception_ptr ex ){
329 exception_caught = ex;
336 [&pool, &exception_caught]( std::exception_ptr ex ){
341 exception_caught = ex;
348 if( exception_caught )
349 std::rethrow_exception( exception_caught );
368template<
typename Traits>
375 thread_pool_t pool( settings.pool_size() );
399template<
typename Traits>
404 asio_ns::io_context & ioctx,
411 thread_pool_t pool{ settings.pool_size(), ioctx };
428template<
typename Traits>
492template<
typename Traits>
493run_existing_server_on_thread_pool_t<Traits>
495 std::size_t pool_size,
499 return { pool_size, break_handling, server };
518template<
typename Io_Context_Holder,
typename Traits>
524 std::exception_ptr exception_caught;
526 asio_ns::signal_set break_signals{ server.
io_context(), SIGINT };
527 break_signals.async_wait(
528 [&](
const asio_ns::error_code & ec,
int ){
536 [&exception_caught]( std::exception_ptr ex ){
539 exception_caught = ex;
546 [&pool, &exception_caught]( std::exception_ptr ex ){
551 exception_caught = ex;
558 if( exception_caught )
559 std::rethrow_exception( exception_caught );
575template<
typename Io_Context_Holder,
typename Traits>
581 std::exception_ptr exception_caught;
585 [&pool, &exception_caught]( std::exception_ptr ex ){
590 exception_caught = ex;
597 if( exception_caught )
598 std::rethrow_exception( exception_caught );
630template<
typename Traits>
637 thread_pool_t pool{ params.pool_size(), params.server().
io_context() };
679template<
typename Traits>
745template<
typename Http_Server>
762 std::size_t pool_size,
766 Http_Server & server )
768 ,
m_pool{ pool_size, server.io_context() }
818 typename On_Ok_Callback,
819 typename On_Error_Callback >
823 On_Ok_Callback && on_ok,
831 On_Error_Callback && on_error )
833 static_assert(
noexcept(on_ok()),
"On_Ok_Callback should be noexcept" );
834 static_assert(
noexcept(on_error(std::declval<std::exception_ptr>())),
835 "On_Error_Callback should be noexcept" );
838 [callback =
std::move(on_ok)]{ callback(); },
839 [
this, callback =
std::move(on_error)]( std::exception_ptr ex ){
859 []( std::exception_ptr )
noexcept { } );
881 []( std::exception_ptr ){
908template<
typename Http_Server >
909class running_server_instance_t;
921template<
typename Traits >
923 std::unique_ptr< running_server_instance_t< http_server_t<Traits> > >;
940template<
typename Http_Server >
943 template<
typename Traits >
948 std::size_t thread_pool_size );
960 std::size_t thread_pool_size )
977 std::promise<void> p;
978 auto f = p.get_future();
980 [&p]()
noexcept { p.set_value(); },
981 [&p]( std::exception_ptr ex )
noexcept {
1109template<
typename Traits = default_traits_t >
1111running_server_handle_t< Traits >
1115 std::size_t thread_pool_size )
Basic container for http_server settings.
socket_type_dependent_settings_t< run_on_this_thread_settings_t< Traits >, typename Traits::stream_socket_t > base_type_t
void close_sync()
Stop server.
void open_async(Server_Open_Ok_CB open_ok_cb, Server_Open_Error_CB open_err_cb)
Starts server in async way.
void close_async(Server_Close_Ok_CB close_ok_cb, Server_Close_Error_CB close_err_cb)
Closes server in async way.
asio_ns::io_context & io_context() noexcept
Get io_context on which server runs.
A class for holding a reference to external Asio's io_context.
auto & io_context() noexcept
Get access to io_context object.
asio_ns::io_context & io_context() noexcept
A class for holding actual instance of Asio's io_context.
Helper class for holding shared pointer to io_context.
Helper class for running an existing HTTP-server on a thread pool without blocking the current thread...
void wait() noexcept
Wait for full stop of the server.
void start()
Start the server.
on_pool_runner_t(std::size_t pool_size, Http_Server &server)
Initializing constructor.
impl::ioctx_on_thread_pool_t< impl::external_io_context_for_thread_pool_t > m_pool
Thread pool for running the server.
void stop() noexcept
Stop the server.
on_pool_runner_t(const on_pool_runner_t &)=delete
bool started() const noexcept
Is server started.
void start(On_Ok_Callback &&on_ok, On_Error_Callback &&on_error)
Start the server with callbacks that will be called on success or failure.
on_pool_runner_t(on_pool_runner_t &&)=delete
Http_Server & m_server
HTTP-server to be run.
Helper type for holding parameters necessary for running HTTP-server on a thread pool.
http_server_t< Traits > * m_server
HTTP-server to be used on a thread pool.
break_signal_handling_t m_break_handling
Should break signal handler be used?
break_signal_handling_t break_handling() const noexcept
run_existing_server_on_thread_pool_t(std::size_t pool_size, break_signal_handling_t break_handling, http_server_t< Traits > &server)
Initializing constructor.
std::size_t pool_size() const noexcept
http_server_t< Traits > & server() const noexcept
std::size_t m_pool_size
Size of thread pool.
Settings for the case when http_server must be run on the context of the current thread.
Settings for the case when http_server must be run on the context of the current thread.
std::size_t m_pool_size
Size of the pool.
std::size_t pool_size() const
Get the pool size.
run_on_thread_pool_settings_t(std::size_t pool_size)
Constructor.
A helper class used in an implementation of run_async function.
void start()
Start the HTTP-server.
void wait() noexcept
Wait for the shutdown of HTTP-server.
Http_Server m_server
Actual server instance.
running_server_instance_t(io_context_holder_t io_context, server_settings_t< typename Http_Server::traits_t > &&settings, std::size_t thread_pool_size)
Initializing constructor.
on_pool_runner_t< Http_Server > m_runner
The runner of the server.
friend running_server_handle_t< Traits > run_async(io_context_holder_t, server_settings_t< Traits > &&, std::size_t thread_pool_size)
Creates an instance of HTTP-server and launches it on a separate thread or thread pool.
A fluent style interface for setting http server params.
#define RESTINIO_NODISCARD
void run_without_break_signal_handling(ioctx_on_thread_pool_t< Io_Context_Holder > &pool, http_server_t< Traits > &server)
An implementation of run-function for thread pool case with existing http_server instance.
void run(ioctx_on_thread_pool_t< Io_Context_Holder > &pool, run_on_thread_pool_settings_t< Traits > &&settings)
An implementation of run-function for thread pool case.
void run_with_break_signal_handling(ioctx_on_thread_pool_t< Io_Context_Holder > &pool, http_server_t< Traits > &server)
An implementation of run-function for thread pool case with existing http_server instance.
constexpr break_signal_handling_t skip_break_signal_handling() noexcept
Make the indicator for absence of break signal handler.
run_on_thread_pool_settings_t< Traits > on_thread_pool(std::size_t pool_size)
A special marker for the case when http_server must be run on an thread pool.
run_on_this_thread_settings_t< Traits > on_this_thread()
A special marker for the case when http_server must be run on the context of the current thread.
std::unique_ptr< running_server_instance_t< http_server_t< Traits > > > running_server_handle_t
The type to be used as a handle for running server instance.
io_context_holder_t external_io_context(asio_ns::io_context &ctx)
Function which tells that http_server should use external instance of io_context and should not contr...
constexpr break_signal_handling_t use_break_signal_handling() noexcept
Make the indicator for usage of break signal handler.
void run(asio_ns::io_context &ioctx, run_on_this_thread_settings_t< Traits > &&settings)
Helper function for running http server until ctrl+c is hit.
RESTINIO_NODISCARD running_server_handle_t< Traits > run_async(io_context_holder_t io_context, server_settings_t< Traits > &&settings, std::size_t thread_pool_size)
Creates an instance of HTTP-server and launches it on a separate thread or thread pool.
break_signal_handling_t
Indication of usage of break signal handlers for some forms of run functions.
@ used
Signal handler should be used by run() function.
@ skipped
Signal handler should not be used by run() function.
void initiate_shutdown(http_server_t< Traits > &server)
Helper function for initiation of server shutdown.