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

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

Creates a new connection builder.

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

Provide a timer to execute background HTTP2 tasks.

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.

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.

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.

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.

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.

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

Sets the max size of received header frames.

Default is currently 16KB, but can change.

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.

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.

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.

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.

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.

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.

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.

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.

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

Configures the maximum number of local resets due to protocol errors made by the remote end.

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

The default value is 1024.

fn reset_stream_duration(&mut self, dur: Duration) -> &mut Self

Sets the duration to remember locally reset streams.

When a stream is explicitly reset by either the client or the server, the HTTP/2 specification requires that any further frames received for that stream must be ignored for "some time".

In order to satisfy the specification, internal state must be maintained to implement the behavior. This state grows linearly with the number of streams that are locally reset.

The reset_stream_duration setting configures the max amount of time this state will be maintained in memory. Once the duration elapses, the stream state is purged from memory.

Once the stream has been fully purged from memory, any additional frames received for that stream will result in a connection level protocol error, forcing the connection to terminate.

The default value is determined by the h2 crate, and is currently 1 second.

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

fn handshake<T, B>(&self, io: T) -> impl Future<Output = Result<(SendRequest<B>, Connection<T, B, Ex>)>>
where
    T: Read + Write + Unpin,
    B: Body + 'static,
    B::Data: Send,
    B::Error: Into<Box<dyn Error + Send + Sync>>,
    Ex: Http2ClientConnExec<B, T> + Unpin,

Constructs a connection with the configured options and IO. See client::conn for more.

Note, if Connection is not await-ed, SendRequest will do nothing.