RESTinio
Loading...
Searching...
No Matches
settings.hpp
Go to the documentation of this file.
1/*
2 restinio
3*/
4
9#pragma once
10
12
15#include <restinio/traits.hpp>
16
18
19#include <restinio/variant.hpp>
20
21#include <chrono>
22#include <tuple>
23#include <utility>
24
25namespace restinio
26{
27
28namespace details
29{
30
32template < typename Object >
33inline auto
35{
36 return std::unique_ptr< Object >{};
37}
38
39template < typename Object >
40inline auto
42{
43 return std::make_unique< Object >();
44}
45
47template < typename Object >
48inline auto
50{
51 return std::shared_ptr< Object >{};
52}
53
54template < typename Object >
55inline auto
57{
58 return std::make_shared< Object >();
59}
60
61} /* namespace details */
62
63//
64// create_default_unique_object_instance
65//
66
68template < typename Object>
69inline auto
71{
72 typename std::is_default_constructible< Object >::type tag;
73 return details::create_default_unique_object_instance< Object >( tag );
74}
75
77template <>
78inline auto
80{
81 return details::create_default_unique_object_instance< default_request_handler_t >(
82 std::false_type{} );
83}
84
85//
86// create_default_shared_object_instance
87//
88
90template < typename Object>
91inline auto
93{
94 typename std::is_default_constructible< Object >::type tag;
95 return details::create_default_shared_object_instance< Object >( tag );
96}
97
99template <>
100inline auto
102{
103 return details::create_default_shared_object_instance< default_request_handler_t >(
104 std::false_type{} );
105}
106
107//
108// ensure_created()
109//
110
112template < typename Object >
113auto
115 std::unique_ptr< Object > mb_created_one,
116 string_view_t fail_description )
117{
118 if( !mb_created_one )
119 mb_created_one = create_default_unique_object_instance< Object >();
120
121 if( !mb_created_one )
122 throw exception_t{ fail_description };
123
124 return mb_created_one;
125}
126
127//
128// unsure_created()
129//
130
132template < typename Object >
133auto
135 std::shared_ptr< Object > mb_created_one,
136 string_view_t fail_description )
137{
138 if( !mb_created_one )
139 mb_created_one = create_default_shared_object_instance< Object >();
140
141 if( !mb_created_one )
142 throw exception_t{ fail_description };
143
144 return mb_created_one;
145}
146
147
148//
149// socket_type_dependent_settings_t
150//
151
153template < typename Settings, typename Socket >
155{
156protected :
158
159public :
161
164
166 operator=(const socket_type_dependent_settings_t &) noexcept = default;
167
169 operator=(socket_type_dependent_settings_t &&) noexcept = delete;
170
171 // No extra settings by default.
172};
173
174//
175// acceptor_options_t
176//
177
179
185{
186 public:
187 acceptor_options_t( asio_ns::ip::tcp::acceptor & acceptor )
188 : m_acceptor{ acceptor }
189 {}
190
193 template< typename Option >
194 void
195 set_option( const Option & option )
196 {
197 m_acceptor.set_option( option );
198 }
199
200 template< typename Option >
201 void
202 set_option( const Option & option, asio_ns::error_code & ec )
203 {
204 m_acceptor.set_option( option, ec );
205 }
206
207 template< typename Option >
208 void
209 get_option( Option & option )
210 {
211 m_acceptor.get_option( option );
212 }
213
214 template< typename Option >
215 void
216 get_option( Option & option, asio_ns::error_code & ec )
217 {
218 m_acceptor.get_option( option, ec );
219 }
221
222 private:
223 asio_ns::ip::tcp::acceptor & m_acceptor;
224};
225
226using acceptor_options_setter_t = std::function< void ( acceptor_options_t & ) >;
227
228template <>
229inline auto
231{
232 return std::make_unique< acceptor_options_setter_t >(
233 []( acceptor_options_t & options ){
234 options.set_option( asio_ns::ip::tcp::acceptor::reuse_address( true ) );
235 } );
236}
237
238//
239// socket_options_t
240//
241
243
249{
250 public:
253 asio_ns::basic_socket< asio_ns::ip::tcp > & socket )
254 : m_socket{ socket }
255 {}
256
259 template< typename Option >
260 void
261 set_option( const Option & option )
262 {
263 m_socket.set_option( option );
264 }
265
266 template< typename Option >
267 void
268 set_option( const Option & option, asio_ns::error_code & ec )
269 {
270 m_socket.set_option( option, ec );
271 }
272
273 template< typename Option >
274 void
275 get_option( Option & option )
276 {
277 m_socket.get_option( option );
278 }
279
280 template< typename Option >
281 void
282 get_option( Option & option, asio_ns::error_code & ec )
283 {
284 m_socket.get_option( option, ec );
285 }
287
288 private:
290 asio_ns::basic_socket< asio_ns::ip::tcp > & m_socket;
291};
292
293using socket_options_setter_t = std::function< void ( socket_options_t & ) >;
294
295template <>
296inline auto
298{
299 return std::make_unique< socket_options_setter_t >( []( auto & ){} );
300}
301
302//
303// cleanup_functor_t
304//
308using cleanup_functor_t = std::function< void(void) >;
309
310//
311// connection_state_listener_holder_t
312//
322template< typename Listener >
324{
325 std::shared_ptr< Listener > m_connection_state_listener;
326
327 static constexpr bool has_actual_connection_state_listener = true;
328
330
333 void
335 {
336 if( !m_connection_state_listener )
337 throw exception_t{ "connection state listener is not specified" };
338 }
339};
340
349template<>
350struct connection_state_listener_holder_t< connection_state::noop_listener_t >
351{
352 static constexpr bool has_actual_connection_state_listener = false;
353
354 void
356 {
357 // Nothing to do.
358 }
359};
360
361//
362// ip_blocker_holder_t
363//
373template< typename Ip_Blocker >
375{
376 static_assert(
377 noexcept( std::declval<Ip_Blocker>().inspect(
378 std::declval<ip_blocker::incoming_info_t>() ) ),
379 "Ip_Blocker::inspect() method should be noexcept" );
380
381 static_assert(
382 std::is_same<
384 decltype(std::declval<Ip_Blocker>().inspect(
385 std::declval<ip_blocker::incoming_info_t>())) >::value,
386 "Ip_Blocker::inspect() should return "
387 "restinio::ip_blocker::inspection_result_t" );
388
389 std::shared_ptr< Ip_Blocker > m_ip_blocker;
390
391 static constexpr bool has_actual_ip_blocker = true;
392
394
397 void
399 {
400 if( !m_ip_blocker )
401 throw exception_t{ "IP-blocker is not specified" };
402 }
403};
404
413template<>
414struct ip_blocker_holder_t< ip_blocker::noop_ip_blocker_t >
415{
416 static constexpr bool has_actual_ip_blocker = false;
417
418 void
420 {
421 // Nothing to do.
422 }
423};
424
425//
426// acceptor_post_bind_hook_t
427//
434using acceptor_post_bind_hook_t = std::function<
435 void(asio_ns::ip::tcp::acceptor &) >;
436
437namespace details
438{
439
440//
441// no_address_specified_t
442//
450
451//
452// address_variant_t
453//
462 std::string,
463 asio_ns::ip::address >;
464
465//
466// max_parallel_connections_holder_t
467//
480template< typename Count_Limiter >
482{
483 static constexpr bool has_actual_max_parallel_connections = true;
484
490 std::size_t m_max_parallel_connections{
491 std::numeric_limits<std::size_t>::max()
492 };
493
494 std::size_t
496 {
497 return m_max_parallel_connections;
498 }
499
500 void
501 set_max_parallel_connections( std::size_t v ) noexcept
502 {
503 m_max_parallel_connections = v;
504 }
505};
506
518template<>
521{
522 static constexpr bool has_actual_max_parallel_connections = false;
523
524 std::size_t
526 {
527 return std::numeric_limits<std::size_t>::max();
528 }
529};
530
531} /* namespace details */
532
533//
534// basic_server_settings_t
535//
536
538
548template<typename Derived, typename Traits>
550 : public socket_type_dependent_settings_t< Derived, typename Traits::stream_socket_t >
552 typename Traits::connection_state_listener_t >
553 , protected ip_blocker_holder_t< typename Traits::ip_blocker_t >
555 typename connection_count_limit_types<Traits>::limiter_t >
556{
558 Derived, typename Traits::stream_socket_t>;
559
563
565 typename Traits::connection_state_listener_t
566 >::has_actual_connection_state_listener;
567
569 typename Traits::ip_blocker_t
570 >::has_actual_ip_blocker;
571
572 using max_parallel_connections_holder_base_t::has_actual_max_parallel_connections;
573
574 public:
576 std::uint16_t port = 8080,
577 asio_ns::ip::tcp protocol = asio_ns::ip::tcp::v4() )
578 : base_type_t{}
579 , m_port{ port }
580 , m_protocol{ protocol }
581 {}
582
585 Derived &
586 port( std::uint16_t p ) &
587 {
588 m_port = p;
589 return reference_to_derived();
590 }
591
592 Derived &&
593 port( std::uint16_t p ) &&
594 {
595 return std::move( this->port( p ) );
596 }
597
599 std::uint16_t
600 port() const
601 {
602 return m_port;
603 }
604
605 Derived &
606 protocol( asio_ns::ip::tcp p ) &
607 {
608 m_protocol = p;
609 return reference_to_derived();
610 }
611
612 Derived &&
613 protocol( asio_ns::ip::tcp p ) &&
614 {
615 return std::move( this->protocol( p ) );
616 }
617
619 asio_ns::ip::tcp
620 protocol() const
621 {
622 return m_protocol;
623 }
624
642 Derived &
643 address( std::string addr ) &
644 {
645 m_address = std::move(addr);
646 return reference_to_derived();
647 }
648
662 Derived &&
663 address( std::string addr ) &&
664 {
665 return std::move( this->address( std::move( addr ) ) );
666 }
667
687 Derived &
688 address( asio_ns::ip::address addr ) &
689 {
690 m_address = addr;
691 return reference_to_derived();
692 }
693
709 Derived &&
710 address( asio_ns::ip::address addr ) &&
711 {
712 return std::move( this->address( addr ) );
713 }
714
717 address() const
718 {
719 return m_address;
720 }
722
724
729 Derived &
730 buffer_size( std::size_t s ) &
731 {
732 m_buffer_size = s;
733 return reference_to_derived();
734 }
735
736 Derived &&
737 buffer_size( std::size_t s ) &&
738 {
739 return std::move( this->buffer_size( s ) );
740 }
741
742 std::size_t
744 {
745 return m_buffer_size;
746 }
748
752
756 Derived &
757 read_next_http_message_timelimit( std::chrono::steady_clock::duration d ) &
758 {
759 m_read_next_http_message_timelimit = std::move( d );
760 return reference_to_derived();
761 }
762
763 Derived &&
764 read_next_http_message_timelimit( std::chrono::steady_clock::duration d ) &&
765 {
766 return std::move( this->read_next_http_message_timelimit( std::move( d ) ) );
767 }
768
769 std::chrono::steady_clock::duration
771 {
772 return m_read_next_http_message_timelimit;
773 }
775
778 Derived &
779 write_http_response_timelimit( std::chrono::steady_clock::duration d ) &
780 {
781 m_write_http_response_timelimit = std::move( d );
782 return reference_to_derived();
783 }
784
785 Derived &&
786 write_http_response_timelimit( std::chrono::steady_clock::duration d ) &&
787 {
788 return std::move( this->write_http_response_timelimit( std::move( d ) ) );
789 }
790
791 std::chrono::steady_clock::duration
793 {
794 return m_write_http_response_timelimit;
795 }
797
800 Derived &
801 handle_request_timeout( std::chrono::steady_clock::duration d ) &
802 {
803 m_handle_request_timeout = std::move( d );
804 return reference_to_derived();
805 }
806
807 Derived &&
808 handle_request_timeout( std::chrono::steady_clock::duration d ) &&
809 {
810 return std::move( this->handle_request_timeout( std::move( d ) ) );
811 }
812
813 std::chrono::steady_clock::duration
815 {
816 return m_handle_request_timeout;
817 }
819
822 Derived &
823 max_pipelined_requests( std::size_t mpr ) &
824 {
825 m_max_pipelined_requests = mpr;
826 return reference_to_derived();
827 }
828
829 Derived &&
830 max_pipelined_requests( std::size_t mpr ) &&
831 {
832 return std::move( this->max_pipelined_requests( mpr ) );
833 }
834
835 std::size_t
837 {
838 return m_max_pipelined_requests;
839 }
841
842
846
847 Derived &
848 request_handler( std::unique_ptr< request_handler_t > handler ) &
849 {
850 m_request_handler = std::move( handler );
851 return reference_to_derived();
852 }
853
854 template< typename... Params >
855 Derived &
856 request_handler( Params &&... params ) &
857 {
858 return set_unique_instance(
859 m_request_handler,
860 std::forward< Params >( params )... );
861 }
862
863
864 template< typename... Params >
865 Derived &&
866 request_handler( Params &&... params ) &&
867 {
868 return std::move( this->request_handler( std::forward< Params >( params )... ) );
869 }
870
871 std::unique_ptr< request_handler_t >
873 {
874 return ensure_created(
875 std::move( m_request_handler ),
876 "request handler must be set" );
877 }
879
880
883 using timer_manager_t = typename Traits::timer_manager_t;
884 using timer_factory_t = typename timer_manager_t::factory_t;
885
886 template< typename... Params >
887 Derived &
888 timer_manager( Params &&... params ) &
889 {
890 return set_unique_instance(
891 m_timer_factory,
892 std::forward< Params >( params )... );
893 }
894
895 template< typename... Params >
896 Derived &&
897 timer_manager( Params &&... params ) &&
898 {
899 return std::move( this->timer_manager( std::forward< Params >( params )... ) );
900 }
901
902 std::unique_ptr< timer_factory_t >
904 {
905 return ensure_created(
906 std::move( m_timer_factory ),
907 "timer manager is not set" );
908 }
910
913 using logger_t = typename Traits::logger_t;
914
915 template< typename... Params >
916 Derived &
917 logger( Params &&... params ) &
918 {
919 return set_unique_instance(
920 m_logger,
921 std::forward< Params >( params )... );
922 }
923
924 template< typename... Params >
925 Derived &&
926 logger( Params &&... params ) &&
927 {
928 return std::move( this->logger( std::forward< Params >( params )... ) );
929 }
930
931 std::unique_ptr< logger_t >
933 {
934 return ensure_created(
935 std::move( m_logger ),
936 "logger must be set" );
937 }
939
942 Derived &
944 {
945 if( !aos )
946 throw exception_t{ "acceptor options setter cannot be empty" };
947
948 return set_unique_instance(
949 m_acceptor_options_setter,
950 std::move( aos ) );
951 }
952
953 Derived &&
955 {
956 return std::move( this->acceptor_options_setter( std::move( aos ) ) );
957 }
958
959 std::unique_ptr< acceptor_options_setter_t >
961 {
962 return ensure_created(
963 std::move( m_acceptor_options_setter ),
964 "acceptor options setter must be set" );
965 }
967
970 Derived &
972 {
973 if( !sos )
974 throw exception_t{ "socket options setter cannot be empty" };
975
976 return set_unique_instance(
977 m_socket_options_setter,
978 std::move( sos ) );
979 }
980
981 Derived &&
983 {
984 return std::move( this->socket_options_setter( std::move( sos ) ) );
985 }
986
987 std::unique_ptr< socket_options_setter_t >
989 {
990 return ensure_created(
991 std::move( m_socket_options_setter ),
992 "socket options setter must be set" );
993 }
995
997
1002 Derived &
1003 concurrent_accepts_count( std::size_t n ) &
1004 {
1005 if( 0 == n || 1024 < n )
1006 throw exception_t{
1007 fmt::format(
1009 "invalid value for number of cuncurrent connects: {}" ),
1010 n ) };
1011
1012 m_concurrent_accepts_count = n;
1013 return reference_to_derived();
1014 }
1015
1016 Derived &&
1017 concurrent_accepts_count( std::size_t n ) &&
1018 {
1019 return std::move( this->concurrent_accepts_count( n ) );
1020 }
1021
1022 std::size_t
1024 {
1025 return m_concurrent_accepts_count;
1026 }
1028
1030
1039 Derived &
1040 separate_accept_and_create_connect( bool do_separate ) & noexcept
1041 {
1042 m_separate_accept_and_create_connect = do_separate;
1043 return reference_to_derived();
1044 }
1045
1046 Derived &&
1047 separate_accept_and_create_connect( bool do_separate ) && noexcept
1048 {
1049 return std::move( this->separate_accept_and_create_connect( do_separate ) );
1050 }
1051
1052 bool
1054 {
1055 return m_separate_accept_and_create_connect;
1056 }
1058
1061 template< typename Func >
1062 Derived &
1063 cleanup_func( Func && func ) &
1064 {
1065 m_cleanup_functor = std::move(func);
1066 return reference_to_derived();
1067 }
1068
1069 template< typename Func >
1070 Derived &&
1071 cleanup_func( Func && func ) &&
1072 {
1073 return std::move(this->cleanup_func( std::forward<Func>(func) ));
1074 }
1075
1085 {
1086 return std::move(m_cleanup_functor);
1087 }
1089
1120 Derived &
1122 std::shared_ptr< typename Traits::connection_state_listener_t > listener ) &
1123 {
1124 static_assert(
1125 has_actual_connection_state_listener,
1126 "connection_state_listener(listener) can't be used "
1127 "for the default connection_state::noop_listener_t" );
1128
1129 this->m_connection_state_listener = std::move(listener);
1130 return reference_to_derived();
1131 }
1132
1164 Derived &&
1166 std::shared_ptr< typename Traits::connection_state_listener_t > listener ) &&
1167 {
1168 return std::move(this->connection_state_listener(
1169 std::move(listener)));
1170 }
1171
1180 const std::shared_ptr< typename Traits::connection_state_listener_t > &
1182 {
1183 static_assert(
1184 has_actual_connection_state_listener,
1185 "connection_state_listener() can't be used "
1186 "for the default connection_state::noop_listener_t" );
1187
1188 return this->m_connection_state_listener;
1189 }
1190
1200 void
1202 {
1203 this->check_valid_connection_state_listener_pointer();
1204 }
1205
1237 Derived &
1239 std::shared_ptr< typename Traits::ip_blocker_t > blocker ) &
1240 {
1241 static_assert(
1242 basic_server_settings_t::has_actual_ip_blocker,
1243 "ip_blocker(blocker) can't be used "
1244 "for the default ip_blocker::noop_ip_blocker_t" );
1245
1246 this->m_ip_blocker = std::move(blocker);
1247 return reference_to_derived();
1248 }
1249
1282 Derived &&
1284 std::shared_ptr< typename Traits::ip_blocker_t > blocker ) &&
1285 {
1286 return std::move(this->ip_blocker(std::move(blocker)));
1287 }
1288
1297 const std::shared_ptr< typename Traits::ip_blocker_t > &
1299 {
1300 static_assert(
1301 basic_server_settings_t::has_actual_ip_blocker,
1302 "ip_blocker() can't be used "
1303 "for the default ip_blocker::noop_ip_blocker_t" );
1304
1305 return this->m_ip_blocker;
1306 }
1307
1316 void
1318 {
1319 this->check_valid_ip_blocker_pointer();
1320 }
1321
1322 // Acceptor post-bind hook.
1346 Derived &
1348 {
1349 if( !hook )
1350 throw exception_t{ "acceptor_post_bind_hook cannot be empty" };
1351
1352 m_acceptor_post_bind_hook = std::move(hook);
1353 return reference_to_derived();
1354 }
1355
1375 Derived &&
1377 {
1378 return std::move(this->acceptor_post_bind_hook( std::move(hook) ));
1379 }
1380
1394 {
1395 return std::move(m_acceptor_post_bind_hook);
1396 }
1397
1414 {
1415 return m_incoming_http_msg_limits;
1416 }
1417
1440 Derived &
1442 const incoming_http_msg_limits_t & limits ) & noexcept
1443 {
1444 m_incoming_http_msg_limits = limits;
1445 return reference_to_derived();
1446 }
1447
1470 Derived &&
1472 const incoming_http_msg_limits_t & limits ) && noexcept
1473 {
1474 return std::move(this->incoming_http_msg_limits(limits));
1475 }
1476
1501 Derived &
1502 max_parallel_connections( std::size_t value ) & noexcept
1503 {
1504 static_assert(
1505 basic_server_settings_t::has_actual_max_parallel_connections,
1506 "max_parallel_connections(value) can't be used "
1507 "for the noop_connection_count_limiter_t" );
1508
1509 this->set_max_parallel_connections( value );
1510 return reference_to_derived();
1511 }
1512
1536 Derived &&
1537 max_parallel_connections( std::size_t value ) && noexcept
1538 {
1539 return std::move(this->max_parallel_connections( value ));
1540 }
1541
1542 using max_parallel_connections_holder_base_t::max_parallel_connections;
1543
1552 using extra_data_factory_t = typename Traits::extra_data_factory_t;
1557 using extra_data_factory_handle_t = std::shared_ptr< extra_data_factory_t >;
1558
1592 Derived &
1594 extra_data_factory_handle_t factory ) &
1595 {
1596 this->m_extra_data_factory = std::move(factory);
1597 return reference_to_derived();
1598 }
1599
1632 Derived &&
1634 extra_data_factory_handle_t factory ) &&
1635 {
1636 return std::move(this->extra_data_factory( std::move(factory) ));
1637 }
1638
1644 extra_data_factory_handle_t
1646 {
1647 return ensure_created(
1648 std::move(this->m_extra_data_factory),
1649 "extra_data_factory is not set" );
1650 }
1655 private:
1656 Derived &
1658 {
1659 return static_cast<Derived &>(*this);
1660 }
1661
1662 template< typename Target, typename... Params >
1663 Derived &
1664 set_unique_instance( std::unique_ptr< Target > & t, Params &&... params )
1665 {
1666 t =
1667 std::make_unique< Target >(
1668 std::forward< Params >( params )... );
1669
1670 return reference_to_derived();
1671 }
1672
1673 template< typename Target, typename... Params >
1674 Derived &
1675 set_shared_instance( std::shared_ptr< Target > & t, Params &&... params )
1676 {
1677 t =
1678 std::make_shared< Target >(
1679 std::forward< Params >( params )... );
1680
1681 return reference_to_derived();
1682 }
1683
1686 std::uint16_t m_port;
1687 asio_ns::ip::tcp m_protocol;
1694
1696 std::size_t m_buffer_size{ 4 * 1024 };
1697
1700 std::chrono::steady_clock::duration
1701 m_read_next_http_message_timelimit{ std::chrono::seconds( 60 ) };
1702
1703 std::chrono::steady_clock::duration
1704 m_write_http_response_timelimit{ std::chrono::seconds( 5 ) };
1705
1706 std::chrono::steady_clock::duration
1707 m_handle_request_timeout{ std::chrono::seconds( 10 ) };
1709
1711 std::size_t m_max_pipelined_requests{ 1 };
1712
1714 std::unique_ptr< request_handler_t > m_request_handler;
1715
1717 std::unique_ptr< timer_factory_t > m_timer_factory;
1718
1720 std::unique_ptr< logger_t > m_logger;
1721
1723 std::unique_ptr< acceptor_options_setter_t > m_acceptor_options_setter;
1724
1726
1731 acceptor_post_bind_hook_t m_acceptor_post_bind_hook{
1732 [](asio_ns::ip::tcp::acceptor &) {}
1733 };
1734
1736 std::unique_ptr< socket_options_setter_t > m_socket_options_setter;
1737
1738 std::size_t m_concurrent_accepts_count{ 1 };
1739
1741 bool m_separate_accept_and_create_connect{ false };
1742
1745
1752
1759};
1760
1761//
1762// server_settings_t
1763//
1764
1766template<typename Traits = default_traits_t>
1768 : public basic_server_settings_t< server_settings_t<Traits>, Traits >
1769{
1772public:
1774};
1775
1776template < typename Traits, typename Configurator >
1777auto
1778exec_configurator( Configurator && configurator )
1779{
1781
1782 configurator( result );
1783
1784 return result;
1785}
1786
1787} /* namespace restinio */
1788
An adapter for setting acceptor options before running server.
Definition: settings.hpp:185
void set_option(const Option &option, asio_ns::error_code &ec)
Definition: settings.hpp:202
void set_option(const Option &option)
API for setting/getting options.
Definition: settings.hpp:195
void get_option(Option &option, asio_ns::error_code &ec)
Definition: settings.hpp:216
void get_option(Option &option)
Definition: settings.hpp:209
asio_ns::ip::tcp::acceptor & m_acceptor
Definition: settings.hpp:223
acceptor_options_t(asio_ns::ip::tcp::acceptor &acceptor)
Definition: settings.hpp:187
Basic container for http_server settings.
Definition: settings.hpp:556
RESTINIO_NODISCARD const incoming_http_msg_limits_t & incoming_http_msg_limits() const noexcept
Getter of optional limits for incoming HTTP messages.
Definition: settings.hpp:1413
typename timer_manager_t::factory_t timer_factory_t
Definition: settings.hpp:884
const std::shared_ptr< typename Traits::ip_blocker_t > & ip_blocker() const noexcept
Get reference to IP-blocker.
Definition: settings.hpp:1298
std::unique_ptr< request_handler_t > m_request_handler
Request handler.
Definition: settings.hpp:1714
RESTINIO_NODISCARD extra_data_factory_handle_t giveaway_extra_data_factory() const noexcept
Extractor for extra-data-factory.
Definition: settings.hpp:1645
std::unique_ptr< acceptor_options_setter_t > m_acceptor_options_setter
Acceptor options setter.
Definition: settings.hpp:1723
std::size_t concurrent_accepts_count() const
Definition: settings.hpp:1023
std::unique_ptr< socket_options_setter_t > m_socket_options_setter
Socket options setter.
Definition: settings.hpp:1736
RESTINIO_NODISCARD const details::address_variant_t & address() const
Definition: settings.hpp:717
typename Traits::logger_t logger_t
Logger.
Definition: settings.hpp:913
Derived & port(std::uint16_t p) &
Server endpoint.
Definition: settings.hpp:586
Derived && handle_request_timeout(std::chrono::steady_clock::duration d) &&
Definition: settings.hpp:808
Derived & ip_blocker(std::shared_ptr< typename Traits::ip_blocker_t > blocker) &
Setter for IP-blocker.
Definition: settings.hpp:1238
Derived && concurrent_accepts_count(std::size_t n) &&
Definition: settings.hpp:1017
Derived & buffer_size(std::size_t s) &
Size of buffer for io operations.
Definition: settings.hpp:730
Derived & concurrent_accepts_count(std::size_t n) &
Max number of running concurrent accepts.
Definition: settings.hpp:1003
Derived && separate_accept_and_create_connect(bool do_separate) &&noexcept
Definition: settings.hpp:1047
Derived && cleanup_func(Func &&func) &&
Definition: settings.hpp:1071
Derived & max_parallel_connections(std::size_t value) &noexcept
Setter for connection count limit.
Definition: settings.hpp:1502
std::unique_ptr< socket_options_setter_t > socket_options_setter()
Definition: settings.hpp:988
Derived && extra_data_factory(extra_data_factory_handle_t factory) &&
Setter for extra-data-factory.
Definition: settings.hpp:1633
RESTINIO_NODISCARD asio_ns::ip::tcp protocol() const
Definition: settings.hpp:620
Derived & request_handler(Params &&... params) &
Definition: settings.hpp:856
Derived && socket_options_setter(socket_options_setter_t sos) &&
Definition: settings.hpp:982
void ensure_valid_connection_state_listener()
Internal method for checking presence of state listener object.
Definition: settings.hpp:1201
std::uint16_t m_port
Server endpoint.
Definition: settings.hpp:1686
Derived && logger(Params &&... params) &&
Definition: settings.hpp:926
std::unique_ptr< logger_t > m_logger
Logger.
Definition: settings.hpp:1720
Derived && max_parallel_connections(std::size_t value) &&noexcept
Setter for connection count limit.
Definition: settings.hpp:1537
Derived && timer_manager(Params &&... params) &&
Definition: settings.hpp:897
Derived & write_http_response_timelimit(std::chrono::steady_clock::duration d) &
A period of time wait for response to be written to socket.
Definition: settings.hpp:779
std::shared_ptr< extra_data_factory_t > extra_data_factory_handle_t
Type of shared-pointer to extra-data-factory.
Definition: settings.hpp:1557
extra_data_factory_handle_t m_extra_data_factory
User-data-factory for server.
Definition: settings.hpp:1758
Derived & cleanup_func(Func &&func) &
Cleanup function.
Definition: settings.hpp:1063
std::unique_ptr< request_handler_t > request_handler()
Definition: settings.hpp:872
Derived && acceptor_options_setter(acceptor_options_setter_t aos) &&
Definition: settings.hpp:954
Derived && connection_state_listener(std::shared_ptr< typename Traits::connection_state_listener_t > listener) &&
Setter for connection state listener.
Definition: settings.hpp:1165
Derived & protocol(asio_ns::ip::tcp p) &
Definition: settings.hpp:606
Derived & request_handler(std::unique_ptr< request_handler_t > handler) &
Definition: settings.hpp:848
basic_server_settings_t(std::uint16_t port=8080, asio_ns::ip::tcp protocol=asio_ns::ip::tcp::v4())
Definition: settings.hpp:575
Derived && read_next_http_message_timelimit(std::chrono::steady_clock::duration d) &&
Definition: settings.hpp:764
Derived & incoming_http_msg_limits(const incoming_http_msg_limits_t &limits) &noexcept
Setter of optional limits for incoming HTTP messages.
Definition: settings.hpp:1441
Derived && ip_blocker(std::shared_ptr< typename Traits::ip_blocker_t > blocker) &&
Setter for IP-blocker.
Definition: settings.hpp:1283
Derived && max_pipelined_requests(std::size_t mpr) &&
Definition: settings.hpp:830
incoming_http_msg_limits_t m_incoming_http_msg_limits
Limits for incoming HTTP messages.
Definition: settings.hpp:1751
std::size_t buffer_size() const
Definition: settings.hpp:743
Derived & handle_request_timeout(std::chrono::steady_clock::duration d) &
A period of time that is given for a handler to create response.
Definition: settings.hpp:801
std::unique_ptr< timer_factory_t > m_timer_factory
Timers factory.
Definition: settings.hpp:1717
Derived & timer_manager(Params &&... params) &
Definition: settings.hpp:888
Derived && request_handler(Params &&... params) &&
Definition: settings.hpp:866
Derived && address(std::string addr) &&
Definition: settings.hpp:663
std::chrono::steady_clock::duration handle_request_timeout() const
Definition: settings.hpp:814
Derived & logger(Params &&... params) &
Definition: settings.hpp:917
std::unique_ptr< acceptor_options_setter_t > acceptor_options_setter()
Definition: settings.hpp:960
Derived & address(asio_ns::ip::address addr) &
Definition: settings.hpp:688
void ensure_valid_ip_blocker()
Internal method for checking presence of IP-blocker object.
Definition: settings.hpp:1317
Derived & acceptor_options_setter(acceptor_options_setter_t aos) &
Acceptor options setter.
Definition: settings.hpp:943
Derived & extra_data_factory(extra_data_factory_handle_t factory) &
Setter for extra-data-factory.
Definition: settings.hpp:1593
Derived && write_http_response_timelimit(std::chrono::steady_clock::duration d) &&
Definition: settings.hpp:786
RESTINIO_NODISCARD cleanup_functor_t giveaway_cleanup_func()
Definition: settings.hpp:1084
std::chrono::steady_clock::duration read_next_http_message_timelimit() const
Definition: settings.hpp:770
Derived & max_pipelined_requests(std::size_t mpr) &
Max pipelined requests able to receive on single connection.
Definition: settings.hpp:823
Derived & set_unique_instance(std::unique_ptr< Target > &t, Params &&... params)
Definition: settings.hpp:1664
typename Traits::timer_manager_t timer_manager_t
Timers manager.
Definition: settings.hpp:883
typename Traits::extra_data_factory_t extra_data_factory_t
The actual type of extra-data-factory.
Definition: settings.hpp:1552
Derived & set_shared_instance(std::shared_ptr< Target > &t, Params &&... params)
Definition: settings.hpp:1675
const std::shared_ptr< typename Traits::connection_state_listener_t > & connection_state_listener() const noexcept
Get reference to connection state listener.
Definition: settings.hpp:1181
std::size_t max_pipelined_requests() const
Definition: settings.hpp:836
Derived && acceptor_post_bind_hook(acceptor_post_bind_hook_t hook) &&
A setter for post-bind callback.
Definition: settings.hpp:1376
cleanup_functor_t m_cleanup_functor
Optional cleanup functor.
Definition: settings.hpp:1744
Derived && port(std::uint16_t p) &&
Definition: settings.hpp:593
std::unique_ptr< timer_factory_t > timer_factory()
Definition: settings.hpp:903
Derived && address(asio_ns::ip::address addr) &&
Definition: settings.hpp:710
Derived & socket_options_setter(socket_options_setter_t sos) &
Socket options setter.
Definition: settings.hpp:971
Derived & acceptor_post_bind_hook(acceptor_post_bind_hook_t hook) &
A setter for post-bind callback.
Definition: settings.hpp:1347
Derived && incoming_http_msg_limits(const incoming_http_msg_limits_t &limits) &&noexcept
Setter of optional limits for incoming HTTP messages.
Definition: settings.hpp:1471
std::chrono::steady_clock::duration write_http_response_timelimit() const
Definition: settings.hpp:792
details::address_variant_t m_address
Definition: settings.hpp:1692
request_handler_type_from_traits_t< Traits > request_handler_t
Request handler.
Definition: settings.hpp:845
Derived && buffer_size(std::size_t s) &&
Definition: settings.hpp:737
Derived & separate_accept_and_create_connect(bool do_separate) &noexcept
Do separate an accept operation and connection instantiation.
Definition: settings.hpp:1040
Derived & read_next_http_message_timelimit(std::chrono::steady_clock::duration d) &
}
Definition: settings.hpp:757
RESTINIO_NODISCARD std::uint16_t port() const
Definition: settings.hpp:600
RESTINIO_NODISCARD acceptor_post_bind_hook_t giveaway_acceptor_post_bind_hook()
A getter for post-bind callback.
Definition: settings.hpp:1393
Derived & address(std::string addr) &
Definition: settings.hpp:643
Derived & connection_state_listener(std::shared_ptr< typename Traits::connection_state_listener_t > listener) &
Setter for connection state listener.
Definition: settings.hpp:1121
Derived && protocol(asio_ns::ip::tcp p) &&
Definition: settings.hpp:613
bool separate_accept_and_create_connect() const noexcept
Definition: settings.hpp:1053
std::unique_ptr< logger_t > logger()
Definition: settings.hpp:932
An implementation of connection count limiter for the case when connection count is not limited.
Exception class for all exceptions thrown by RESTinio.
Definition: exception.hpp:26
A type of holder of limits related to an incoming HTTP message.
A fluent style interface for setting http server params.
Definition: settings.hpp:1769
An adapter for setting acceptor options before running server.
Definition: settings.hpp:249
void set_option(const Option &option, asio_ns::error_code &ec)
Definition: settings.hpp:268
asio_ns::basic_socket< asio_ns::ip::tcp > & m_socket
A reference on the most base class with interface of setting options.
Definition: settings.hpp:290
void get_option(Option &option)
Definition: settings.hpp:275
void get_option(Option &option, asio_ns::error_code &ec)
Definition: settings.hpp:282
socket_options_t(asio_ns::basic_socket< asio_ns::ip::tcp > &socket)
Definition: settings.hpp:251
void set_option(const Option &option)
API for setting/getting options.
Definition: settings.hpp:261
Extra settings needed for working with socket.
Definition: settings.hpp:155
~socket_type_dependent_settings_t() noexcept=default
#define RESTINIO_NODISCARD
#define RESTINIO_FMT_FORMAT_STRING(s)
Stuff related to limits of an incoming HTTP message.
inspection_result_t
Enumeration of result of inspecting new incoming connection.
Definition: ip_blocker.hpp:31
auto ensure_created(std::unique_ptr< Object > mb_created_one, string_view_t fail_description)
Ensure that object was created.
Definition: settings.hpp:114
auto create_default_unique_object_instance< acceptor_options_setter_t >()
Definition: settings.hpp:230
std::function< void(asio_ns::ip::tcp::acceptor &) > acceptor_post_bind_hook_t
A type of callback to be called after a successful invocation of bind() function for the acceptor.
Definition: settings.hpp:435
nonstd::string_view string_view_t
Definition: string_view.hpp:19
auto create_default_shared_object_instance()
Default instantiation for a specific type.
Definition: settings.hpp:92
std::function< void(void) > cleanup_functor_t
Type of holder for user's cleanup function.
Definition: settings.hpp:308
auto exec_configurator(Configurator &&configurator)
Definition: settings.hpp:1778
auto create_default_shared_object_instance< default_request_handler_t >()
Default instantiation for default_request_handler_t.
Definition: settings.hpp:101
std::function< void(socket_options_t &) > socket_options_setter_t
Definition: settings.hpp:293
typename details::actual_request_handler_type_detector< typename Traits::request_handler_t, typename Traits::extra_data_factory_t >::request_handler_t request_handler_type_from_traits_t
A metafunction for extraction a request-handler type from server's traits.
Definition: traits.hpp:379
auto create_default_unique_object_instance()
Default instantiation for a specific type.
Definition: settings.hpp:70
auto create_default_unique_object_instance< default_request_handler_t >()
Default instantiation for default_request_handler_t.
Definition: settings.hpp:79
std::function< void(acceptor_options_t &) > acceptor_options_setter_t
Definition: settings.hpp:226
auto create_default_unique_object_instance< socket_options_setter_t >()
Definition: settings.hpp:297
typename std::conditional< Traits::use_connection_count_limiter, connection_count_limits::connection_count_limiter_t< typename Traits::strand_t >, connection_count_limits::noop_connection_count_limiter_t >::type limiter_t
A special class for holding actual connection state listener.
Definition: settings.hpp:324
std::shared_ptr< Listener > m_connection_state_listener
Definition: settings.hpp:325
void check_valid_connection_state_listener_pointer() const
Checks that pointer to state listener is not null.
Definition: settings.hpp:334
A special type for holding the value of maximum allowed count of parallel connections.
Definition: settings.hpp:482
void set_max_parallel_connections(std::size_t v) noexcept
Definition: settings.hpp:501
std::size_t max_parallel_connections() const noexcept
Definition: settings.hpp:495
A special indicator for the case when IP address for a server is not set explicitly.
Definition: settings.hpp:449
A special class for holding actual IP-blocker object.
Definition: settings.hpp:375
void check_valid_ip_blocker_pointer() const
Checks that pointer to IP-blocker is not null.
Definition: settings.hpp:398
std::shared_ptr< Ip_Blocker > m_ip_blocker
Definition: settings.hpp:389
#define const
Definition: zconf.h:230