hyper::client::conn::http2

Struct Builder

pub struct Builder<Ex> { /* private fields */ }

Available on crate feature client and (crate features http1 or http2) and crate feature http2 only.

Expand description

A builder to configure an HTTP connection.

After setting options, the builder is used to create a handshake future.

Note: The default values of options are not considered stable. They are subject to change at any time.

Implementations§

Source §

impl<Ex> Builder<Ex>
where Ex: Clone,

Source

pub fn new(exec: Ex) -> Builder<Ex>

Creates a new connection builder.

Source

pub fn timer<M>(&mut self, timer: M) -> &mut Builder<Ex>
where M: Timer + Send + Sync + 'static,

Provide a timer to execute background HTTP2 tasks.

Source

pub fn initial_stream_window_size( &mut self, sz: impl Into<Option<u32>>, ) -> &mut Self

Sets the SETTINGS_INITIAL_WINDOW_SIZE option for HTTP2 stream-level flow control.

Passing None will do nothing.

If not set, hyper will use a default.

Source

pub fn initial_connection_window_size( &mut self, sz: impl Into<Option<u32>>, ) -> &mut Self

Sets the max connection-level flow control for HTTP2

Passing None will do nothing.

If not set, hyper will use a default.

Source

pub fn initial_max_send_streams( &mut self, initial: impl Into<Option<usize>>, ) -> &mut Self

Sets the initial maximum of locally initiated (send) streams.

This value will be overwritten by the value included in the initial SETTINGS frame received from the peer as part of a connection preface.

Passing None will do nothing.

If not set, hyper will use a default.

Source

pub fn adaptive_window(&mut self, enabled: bool) -> &mut Self

Sets whether to use an adaptive flow control.

Enabling this will override the limits set in initial_stream_window_size and initial_connection_window_size.

Source

pub fn max_frame_size(&mut self, sz: impl Into<Option<u32>>) -> &mut Self

Sets the maximum frame size to use for HTTP2.

Default is currently 16KB, but can change.

Source

pub fn max_header_list_size(&mut self, max: u32) -> &mut Self

Sets the max size of received header frames.

Default is to not send the setting, allowing the peer’s default.

Source

pub fn header_table_size(&mut self, size: impl Into<Option<u32>>) -> &mut Self

Sets the header table size.

This setting informs the peer of the maximum size of the header compression table used to encode header blocks, in octets. The encoder may select any value equal to or less than the header table size specified by the sender.

The default value of crate h2 is 4,096.

Source

pub fn enable_push(&mut self, enabled: bool) -> &mut Self

Sets whether to enable server push.

This setting can be used to disable server push. Clients SHOULD set this to false, as server push is rarely used and can be a security risk.

The default value is false.

Source

pub fn max_concurrent_streams( &mut self, max: impl Into<Option<u32>>, ) -> &mut Self

Sets the maximum number of concurrent streams.

The maximum concurrent streams setting only controls the maximum number of streams that can be initiated by the remote peer. In other words, when this setting is set to 100, this does not limit the number of concurrent streams that can be created by the caller.

It is recommended that this value be no smaller than 100, so as to not unnecessarily limit parallelism. However, any value is legal, including 0. If max is set to 0, then the remote will not be permitted to initiate streams.

Note that streams in the reserved state, i.e., push promises that have been reserved but the stream has not started, do not count against this setting.

Also note that if the remote does exceed the value set here, it is not a protocol level error. Instead, the h2 library will immediately reset the stream.

See Section 5.1.2 in the HTTP/2 spec for more details.

Source

pub fn keep_alive_interval( &mut self, interval: impl Into<Option<Duration>>, ) -> &mut Self

Sets an interval for HTTP2 Ping frames should be sent to keep a connection alive.

Pass None to disable HTTP2 keep-alive.

Default is currently disabled.

Source

pub fn keep_alive_timeout(&mut self, timeout: Duration) -> &mut Self

Sets a timeout for receiving an acknowledgement of the keep-alive ping.

If the ping is not acknowledged within the timeout, the connection will be closed. Does nothing if keep_alive_interval is disabled.

Default is 20 seconds.

Source

pub fn keep_alive_while_idle(&mut self, enabled: bool) -> &mut Self

Sets whether HTTP2 keep-alive should apply while the connection is idle.

If disabled, keep-alive pings are only sent while there are open request/responses streams. If enabled, pings are also sent when no streams are active. Does nothing if keep_alive_interval is disabled.

Default is false.

Source

pub fn max_concurrent_reset_streams(&mut self, max: usize) -> &mut Self

Sets the maximum number of HTTP2 concurrent locally reset streams.

See the documentation of h2::client::Builder::max_concurrent_reset_streams for more details.

The default value is determined by the h2 crate.

Source

pub fn max_send_buf_size(&mut self, max: usize) -> &mut Self

Set the maximum write buffer size for each HTTP/2 stream.

Default is currently 1MB, but may change.

§Panics

The value must be no larger than u32::MAX.

Source

pub fn max_pending_accept_reset_streams( &mut self, max: impl Into<Option<usize>>, ) -> &mut Self

Configures the maximum number of pending reset streams allowed before a GOAWAY will be sent.

This will default to the default value set by the h2 crate. As of v0.4.0, it is 20.

See https://github.com/hyperium/hyper/issues/2877 for more information.

Source

pub fn headers_pseudo_order(&mut self, order: PseudoOrder) -> &mut Self

Sets the HTTP/2 pseudo-header field order for outgoing HEADERS frames.

This determines the order in which pseudo-header fields (such as :method, :scheme, etc.) are encoded in the HEADERS frame. Customizing the order may be useful for interoperability or testing purposes.

Source

pub fn headers_priority(&mut self, data: Option<(u8, u32, bool)>) -> &mut Self

Sets whether to include PRIORITY flag in HTTP/2 HEADERS frames.

When enabled, HEADERS frames will include priority data (weight=0, stream_dependency=0, exclusive=1) matching Chrome’s HTTP/2 behavior.

Source

pub fn headers_order(&mut self, order: Vec<HeaderName>) -> &mut Self

Sets the HTTP/2 regular header ordering for browser fingerprinting.

When set, headers are encoded in the specified order instead of hash-based order.

Source

pub fn settings_order(&mut self, order: SettingsOrder) -> &mut Self

Sets the HTTP/2 SETTINGS frame order for the connection preface.

This determines the order in which settings are sent in the initial SETTINGS frame. Customizing the order may be useful for testing or protocol compliance.

Source

pub fn no_rfc7540_priorities(&mut self, enabled: bool) -> &mut Self

Sets whether to disable RFC 7540 priorities.

This corresponds to the SETTINGS_NO_RFC7540_PRIORITIES (0x9) setting. When enabled, the client will not send priority frames and will ignore priority frames received from the server.

Default is None (not set).

Source

pub fn enable_connect_protocol(&mut self, val: bool) -> &mut Self

Sets the SETTINGS_ENABLE_CONNECT_PROTOCOL value.

This corresponds to the SETTINGS_ENABLE_CONNECT_PROTOCOL (0x8) setting. When enabled, the client advertises support for Extended CONNECT (RFC 8441).

Default is None (not set).

Source

pub fn initial_stream_id(&mut self, stream_id: u32) -> &mut Self

Sets the initial HTTP/2 stream ID for the connection.

Firefox starts at stream ID 3 (skipping stream 1), Chrome uses the default of 1.

Source

pub fn initial_stream_window_size_increment(&mut self, size: u32) -> &mut Self

Sets extra receive window capacity to add to new locally-initiated streams.

When set, after creating a new stream, a WINDOW_UPDATE frame will be sent to increase the stream’s receive window by this amount. This is used for browser fingerprinting (e.g. Firefox adds 12451840 to the first stream’s receive window).

Source