From 2d1bd7085e37a55ed6393f0e3f1b9a0b06db4d5d Mon Sep 17 00:00:00 2001 From: Yusuke Tanaka Date: Sat, 13 Jan 2024 17:47:20 +0900 Subject: [PATCH] fix(http2): `initial_max_send_streams` defaults to 100 --- src/client/conn/http2.rs | 8 ++++++-- src/proto/h2/client.rs | 17 ++++++++++++----- 2 files changed, 18 insertions(+), 7 deletions(-) diff --git a/src/client/conn/http2.rs b/src/client/conn/http2.rs index 711cf0f9fe..47d13ce878 100644 --- a/src/client/conn/http2.rs +++ b/src/client/conn/http2.rs @@ -310,11 +310,15 @@ where /// This value will be overwritten by the value included in the initial /// SETTINGS frame received from the peer as part of a [connection preface]. /// - /// The default value is determined by the `h2` crate, but may change. + /// Passing `None` will do nothing. + /// + /// If not set, hyper will use a default. /// /// [connection preface]: https://httpwg.org/specs/rfc9113.html#preface pub fn initial_max_send_streams(&mut self, initial: impl Into>) -> &mut Self { - self.h2_builder.initial_max_send_streams = initial.into(); + if let Some(initial) = initial.into() { + self.h2_builder.initial_max_send_streams = initial; + } self } diff --git a/src/proto/h2/client.rs b/src/proto/h2/client.rs index 7a716ed9f3..7bc62de57a 100644 --- a/src/proto/h2/client.rs +++ b/src/proto/h2/client.rs @@ -52,12 +52,21 @@ const DEFAULT_STREAM_WINDOW: u32 = 1024 * 1024 * 2; // 2mb const DEFAULT_MAX_FRAME_SIZE: u32 = 1024 * 16; // 16kb const DEFAULT_MAX_SEND_BUF_SIZE: usize = 1024 * 1024; // 1mb +// The maximum number of concurrent streams that the client is allowed to open +// before it receives the initial SETTINGS frame from the server. +// This default value is derived from what the HTTP/2 spec recommends as the +// minimum value that endpoints advertise to their peers. It means that using +// this value will minimize the chance of the failure where the local endpoint +// attempts to open too many streams and gets rejected by the remote peer with +// the `REFUSED_STREAM` error. +const DEFAULT_INITIAL_MAX_SEND_STREAMS: usize = 100; + #[derive(Clone, Debug)] pub(crate) struct Config { pub(crate) adaptive_window: bool, pub(crate) initial_conn_window_size: u32, pub(crate) initial_stream_window_size: u32, - pub(crate) initial_max_send_streams: Option, + pub(crate) initial_max_send_streams: usize, pub(crate) max_frame_size: u32, pub(crate) keep_alive_interval: Option, pub(crate) keep_alive_timeout: Duration, @@ -72,7 +81,7 @@ impl Default for Config { adaptive_window: false, initial_conn_window_size: DEFAULT_CONN_WINDOW, initial_stream_window_size: DEFAULT_STREAM_WINDOW, - initial_max_send_streams: None, + initial_max_send_streams: DEFAULT_INITIAL_MAX_SEND_STREAMS, max_frame_size: DEFAULT_MAX_FRAME_SIZE, keep_alive_interval: None, keep_alive_timeout: Duration::from_secs(20), @@ -86,14 +95,12 @@ impl Default for Config { fn new_builder(config: &Config) -> Builder { let mut builder = Builder::default(); builder + .initial_max_send_streams(config.initial_max_send_streams) .initial_window_size(config.initial_stream_window_size) .initial_connection_window_size(config.initial_conn_window_size) .max_frame_size(config.max_frame_size) .max_send_buffer_size(config.max_send_buffer_size) .enable_push(false); - if let Some(initial_max_send_streams) = config.initial_max_send_streams { - builder.initial_max_send_streams(initial_max_send_streams); - } if let Some(max) = config.max_concurrent_reset_streams { builder.max_concurrent_reset_streams(max); }