RESTinio
Loading...
Searching...
No Matches
http_server.hpp
Go to the documentation of this file.
1/*
2 restinio
3*/
4
9#pragma once
10
12#include <restinio/settings.hpp>
15#include <restinio/traits.hpp>
16
17#include <memory>
18
19namespace restinio
20{
21
22//
23// io_context_shared_ptr_t
24//
25using io_context_shared_ptr_t = std::shared_ptr< asio_ns::io_context >;
26
27//
28// io_context_holder_t
29//
49
50//
51// own_io_context
52//
64inline io_context_holder_t
66{
67 return { std::make_shared< asio_ns::io_context >() };
68}
69
70//
71// external_io_context
72//
86inline io_context_holder_t
87external_io_context( asio_ns::io_context & ctx )
88{
89 return { std::shared_ptr< asio_ns::io_context >(
90 std::addressof(ctx),
91 // Empty deleter.
92 []( asio_ns::io_context * ){} )
93 };
94}
95
96//
97// http_server_t
98//
99
101
171template < typename Traits = default_traits_t >
173{
177 using timer_manager_t = typename Traits::timer_manager_t;
178 using timer_manager_handle_t = std::shared_ptr< timer_manager_t >;
179
180 public:
187
188 // This is not Copyable nor Moveable type.
189 http_server_t( const http_server_t & ) = delete;
191
192 template<typename D>
196 : m_io_context{ io_context.giveaway_context() }
197 , m_cleanup_functor{ settings.giveaway_cleanup_func() }
198 {
199 // Since v.0.5.1 the presence of custom connection state
200 // listener should be checked before the start of HTTP server.
201 settings.ensure_valid_connection_state_listener();
202 // The presence of IP-blocker should also be checked.
203 settings.ensure_valid_ip_blocker();
204
205 // Now we can continue preparation of HTTP server.
206
208
209 auto timer_factory = settings.timer_factory();
210 m_timer_manager = timer_factory->create( this->io_context() );
211
212 auto conn_settings =
213 std::make_shared< connection_settings_t >(
214 std::forward< actual_settings_type >(settings),
215 impl::create_parser_settings< typename Traits::http_methods_mapper_t >(),
217
218 m_acceptor =
219 std::make_shared< acceptor_t >(
220 settings,
221 this->io_context(),
222 std::make_shared< connection_factory_t >(
224 settings.socket_options_setter() ),
225 *( conn_settings->m_logger ) );
226 }
227
228 template<
229 typename Configurator,
230 // Use SFINAE.
231 // This constructor must be called only if Configurator
232 // allows to call operator() with server_settings_t& arg.
233 typename = decltype(
234 std::declval<Configurator>()(
235 std::declval<server_settings_t<Traits>&>() ) ) >
244
247 {
248 // Ensure server is closed after destruction of http_server instance.
249 close_sync();
250 }
251
253 asio_ns::io_context & io_context() noexcept { return *m_io_context; }
254
256
265 template <
266 typename Server_Open_Ok_CB,
267 typename Server_Open_Error_CB >
268 void
272 {
273 asio_ns::post(
274 m_acceptor->get_open_close_operations_executor(),
275 [ this,
276 ok_cb = std::move( open_ok_cb ),
277 err_cb = std::move( open_err_cb ) ]{
278 try
279 {
280 open_sync();
281 call_nothrow_cb( ok_cb );
282 }
283 catch( ... )
284 {
285 call_nothrow_cb( [&err_cb] {
286 err_cb( std::current_exception() );
287 } );
288 }
289 } );
290 }
291
293
297 void
299 {
300 if( running_state_t::not_running == m_running_state )
301 {
302 m_timer_manager->start();
303 m_acceptor->open();
304 m_running_state = running_state_t::running;
305 }
306 }
307
309
344 template <
345 typename Server_Close_Ok_CB,
346 typename Server_Close_Error_CB >
347 void
349 Server_Close_Ok_CB close_ok_cb,
350 Server_Close_Error_CB close_err_cb )
351 {
352 asio_ns::post(
353 m_acceptor->get_open_close_operations_executor(),
354 [ this,
355 ok_cb = std::move( close_ok_cb ),
356 err_cb = std::move( close_err_cb ) ]{
357 try
358 {
359 close_sync();
360 call_nothrow_cb( ok_cb );
361 }
362 catch( ... )
363 {
364 call_nothrow_cb( [&err_cb] {
365 err_cb( std::current_exception() );
366 } );
367 }
368 } );
369 }
370
372
376 void
378 {
379 if( running_state_t::running == m_running_state )
380 {
381 m_timer_manager->stop();
382 m_acceptor->close();
383 call_cleanup_functor();
384 m_running_state = running_state_t::not_running;
385 }
386 }
387
388 private:
391
394
396 std::shared_ptr< acceptor_t > m_acceptor;
397
400
403 {
404 not_running,
405 running,
406 };
407
409 running_state_t m_running_state{ running_state_t::not_running };
410
412
420 void
422 {
423 if( m_cleanup_functor )
424 {
425 cleanup_functor_t fn{ std::move(m_cleanup_functor) };
426 fn();
427 }
428 }
429
431 template< typename Callback >
432 static void call_nothrow_cb( Callback && cb ) noexcept
433 {
434 cb();
435 }
436};
437
438} /* namespace restinio */
439
Basic container for http_server settings.
Definition settings.hpp:555
std::unique_ptr< timer_factory_t > timer_factory()
Definition settings.hpp:940
Class for http-server.
io_context_shared_ptr_t m_io_context
A wrapper for asio io_context where server is running.
Traits traits_t
An alias for Traits type.
typename Traits::timer_manager_t timer_manager_t
void call_cleanup_functor() noexcept
Call a cleanup functor if it is defined.
http_server_t(const http_server_t &)=delete
void close_sync()
Stop server.
std::shared_ptr< acceptor_t > m_acceptor
Acceptor for new connections.
void open_async(Server_Open_Ok_CB open_ok_cb, Server_Open_Error_CB open_err_cb)
Starts server in async way.
http_server_t(io_context_holder_t io_context, basic_server_settings_t< D, Traits > &&settings)
void close_async(Server_Close_Ok_CB close_ok_cb, Server_Close_Error_CB close_err_cb)
Closes server in async way.
timer_manager_handle_t m_timer_manager
Timer manager object.
running_state_t
State of server.
http_server_t(http_server_t &&)=delete
http_server_t(io_context_holder_t io_context, Configurator &&configurator)
asio_ns::io_context & io_context() noexcept
Get io_context on which server runs.
std::shared_ptr< timer_manager_t > timer_manager_handle_t
cleanup_functor_t m_cleanup_functor
An optional user's cleanup functor.
virtual ~http_server_t()
It is allowed to inherit from http_server_t.
void open_sync()
Start server.
static void call_nothrow_cb(Callback &&cb) noexcept
Call callback and terminate the application if callback throws.
Context for accepting http connections.
Definition acceptor.hpp:167
Helper class for holding shared pointer to io_context.
io_context_shared_ptr_t giveaway_context()
io_context_shared_ptr_t m_context
io_context_holder_t(io_context_shared_ptr_t context)
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.
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...
std::function< void(void) > cleanup_functor_t
Type of holder for user's cleanup function.
Definition settings.hpp:307
io_context_holder_t own_io_context()
Function which tells that http_server should create and use its own instance of io_context.
std::shared_ptr< asio_ns::io_context > io_context_shared_ptr_t
Parameters shared between connections.