1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
// Copyright (c) Mysten Labs, Inc.
// SPDX-License-Identifier: Apache-2.0
use std::time::Duration;
const DEFAULT_HTTP2_KEEPALIVE_TIMEOUT_SECS: u64 = 20;
const DEFAULT_TLS_HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(5);
const DEFAULT_MAX_PENDING_CONNECTIONS: usize = 4096;
#[derive(Debug, Clone)]
pub struct Config {
init_stream_window_size: Option<u32>,
init_connection_window_size: Option<u32>,
max_concurrent_streams: Option<u32>,
pub(crate) tcp_keepalive: Option<Duration>,
pub(crate) tcp_nodelay: bool,
http2_keepalive_interval: Option<Duration>,
http2_keepalive_timeout: Option<Duration>,
http2_adaptive_window: Option<bool>,
http2_max_pending_accept_reset_streams: Option<usize>,
http2_max_header_list_size: Option<u32>,
max_frame_size: Option<u32>,
pub(crate) accept_http1: bool,
enable_connect_protocol: bool,
pub(crate) max_connection_age: Option<Duration>,
pub(crate) tls_handshake_timeout: Duration,
pub(crate) max_pending_connections: usize,
}
impl Default for Config {
fn default() -> Self {
Self {
init_stream_window_size: None,
init_connection_window_size: None,
max_concurrent_streams: None,
tcp_keepalive: None,
tcp_nodelay: true,
http2_keepalive_interval: None,
http2_keepalive_timeout: None,
http2_adaptive_window: None,
http2_max_pending_accept_reset_streams: None,
http2_max_header_list_size: None,
max_frame_size: None,
accept_http1: true,
enable_connect_protocol: true,
max_connection_age: None,
tls_handshake_timeout: DEFAULT_TLS_HANDSHAKE_TIMEOUT,
max_pending_connections: DEFAULT_MAX_PENDING_CONNECTIONS,
}
}
}
impl Config {
/// Sets the [`SETTINGS_INITIAL_WINDOW_SIZE`][spec] option for HTTP2
/// stream-level flow control.
///
/// Default is 65,535
///
/// [spec]: https://httpwg.org/specs/rfc9113.html#InitialWindowSize
pub fn initial_stream_window_size(self, sz: impl Into<Option<u32>>) -> Self {
Self {
init_stream_window_size: sz.into(),
..self
}
}
/// Sets the max connection-level flow control for HTTP2
///
/// Default is 65,535
pub fn initial_connection_window_size(self, sz: impl Into<Option<u32>>) -> Self {
Self {
init_connection_window_size: sz.into(),
..self
}
}
/// Sets the [`SETTINGS_MAX_CONCURRENT_STREAMS`][spec] option for HTTP2
/// connections.
///
/// Default is no limit (`None`).
///
/// [spec]: https://httpwg.org/specs/rfc9113.html#n-stream-concurrency
pub fn max_concurrent_streams(self, max: impl Into<Option<u32>>) -> Self {
Self {
max_concurrent_streams: max.into(),
..self
}
}
/// Sets the maximum time option in milliseconds that a connection may exist
///
/// Default is no limit (`None`).
pub fn max_connection_age(self, max_connection_age: Duration) -> Self {
Self {
max_connection_age: Some(max_connection_age),
..self
}
}
/// Set whether HTTP2 Ping frames are enabled on accepted connections.
///
/// If `None` is specified, HTTP2 keepalive is disabled, otherwise the duration
/// specified will be the time interval between HTTP2 Ping frames.
/// The timeout for receiving an acknowledgement of the keepalive ping
/// can be set with [`Config::http2_keepalive_timeout`].
///
/// Default is no HTTP2 keepalive (`None`)
pub fn http2_keepalive_interval(self, http2_keepalive_interval: Option<Duration>) -> Self {
Self {
http2_keepalive_interval,
..self
}
}
/// Sets a timeout for receiving an acknowledgement of the keepalive ping.
///
/// If the ping is not acknowledged within the timeout, the connection will be closed.
/// Does nothing if http2_keep_alive_interval is disabled.
///
/// Default is 20 seconds.
pub fn http2_keepalive_timeout(self, http2_keepalive_timeout: Option<Duration>) -> Self {
Self {
http2_keepalive_timeout,
..self
}
}
/// Sets whether to use an adaptive flow control. Defaults to false.
/// Enabling this will override the limits set in http2_initial_stream_window_size and
/// http2_initial_connection_window_size.
pub fn http2_adaptive_window(self, enabled: Option<bool>) -> Self {
Self {
http2_adaptive_window: enabled,
..self
}
}
/// Configures the maximum number of pending reset streams allowed before a GOAWAY will be sent.
///
/// This will default to whatever the default in h2 is. As of v0.3.17, it is 20.
///
/// See <https://github.com/hyperium/hyper/issues/2877> for more information.
pub fn http2_max_pending_accept_reset_streams(self, max: Option<usize>) -> Self {
Self {
http2_max_pending_accept_reset_streams: max,
..self
}
}
/// Set whether TCP keepalive messages are enabled on accepted connections.
///
/// If `None` is specified, keepalive is disabled, otherwise the duration
/// specified will be the time to remain idle before sending TCP keepalive
/// probes.
///
/// Default is no keepalive (`None`)
pub fn tcp_keepalive(self, tcp_keepalive: Option<Duration>) -> Self {
Self {
tcp_keepalive,
..self
}
}
/// Set the value of `TCP_NODELAY` option for accepted connections. Enabled by default.
pub fn tcp_nodelay(self, enabled: bool) -> Self {
Self {
tcp_nodelay: enabled,
..self
}
}
/// Sets the max size of received header frames.
///
/// This will default to whatever the default in hyper is. As of v1.4.1, it is 16 KiB.
pub fn http2_max_header_list_size(self, max: impl Into<Option<u32>>) -> Self {
Self {
http2_max_header_list_size: max.into(),
..self
}
}
/// Sets the maximum frame size to use for HTTP2.
///
/// Passing `None` will do nothing.
///
/// If not set, will default from underlying transport.
pub fn max_frame_size(self, frame_size: impl Into<Option<u32>>) -> Self {
Self {
max_frame_size: frame_size.into(),
..self
}
}
/// Allow this accepting http1 requests.
///
/// Default is `true`.
pub fn accept_http1(self, accept_http1: bool) -> Self {
Config {
accept_http1,
..self
}
}
/// Sets the timeout for TLS handshakes on incoming connections.
///
/// Connections that do not complete the TLS handshake within this duration are dropped.
///
/// Default is 5 seconds.
pub fn tls_handshake_timeout(self, timeout: Duration) -> Self {
Config {
tls_handshake_timeout: timeout,
..self
}
}
/// Sets the maximum number of pending TLS handshakes.
///
/// When this limit is reached, new incoming connections are dropped until existing
/// handshakes complete or time out.
///
/// Default is 4096.
pub fn max_pending_connections(self, max: usize) -> Self {
Config {
max_pending_connections: max,
..self
}
}
pub(crate) fn connection_builder(
&self,
) -> hyper_util::server::conn::auto::Builder<hyper_util::rt::TokioExecutor> {
let mut builder =
hyper_util::server::conn::auto::Builder::new(hyper_util::rt::TokioExecutor::new());
if !self.accept_http1 {
builder = builder.http2_only();
}
if self.enable_connect_protocol {
builder.http2().enable_connect_protocol();
}
let http2_keepalive_timeout = self
.http2_keepalive_timeout
.unwrap_or_else(|| Duration::new(DEFAULT_HTTP2_KEEPALIVE_TIMEOUT_SECS, 0));
builder
.http2()
.timer(hyper_util::rt::TokioTimer::new())
.initial_connection_window_size(self.init_connection_window_size)
.initial_stream_window_size(self.init_stream_window_size)
.max_concurrent_streams(self.max_concurrent_streams)
.keep_alive_interval(self.http2_keepalive_interval)
.keep_alive_timeout(http2_keepalive_timeout)
.adaptive_window(self.http2_adaptive_window.unwrap_or_default())
.max_pending_accept_reset_streams(self.http2_max_pending_accept_reset_streams)
.max_frame_size(self.max_frame_size);
if let Some(max_header_list_size) = self.http2_max_header_list_size {
builder.http2().max_header_list_size(max_header_list_size);
}
builder
}
}