Struct HttpConfig

pub struct HttpConfig { /* private fields */ }

Represents a configuration for the Http protocol. This allows for detailed customization of various HTTP/1 and HTTP/2 settings.

Implementations

impl HttpConfig

pub fn new() -> HttpConfig

Creates a new HttpConfig with default settings.

Examples found in repository

examples/configure_http.rs (line 13)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let config = HttpConfig::new()
        .http1_only(true)
        .http2_only(false)
        .max_buf_size(8192)
        .build();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    hyper_server::bind(addr)
        .http_config(config)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

pub fn build(&mut self) -> Self

Clones the current configuration state and returns it. Useful for building configurations dynamically.

Examples found in repository

examples/configure_http.rs (line 17)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let config = HttpConfig::new()
        .http1_only(true)
        .http2_only(false)
        .max_buf_size(8192)
        .build();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    hyper_server::bind(addr)
        .http_config(config)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

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

Configures whether to exclusively support HTTP/1.

When enabled, only HTTP/1 requests are processed, and HTTP/2 requests are rejected.

Default is false.

Examples found in repository

examples/configure_http.rs (line 14)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let config = HttpConfig::new()
        .http1_only(true)
        .http2_only(false)
        .max_buf_size(8192)
        .build();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    hyper_server::bind(addr)
        .http_config(config)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

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

Specifies if HTTP/1 connections should be allowed to use half-closures.

A half-closure in TCP occurs when one side of the data stream is terminated, but the other side remains open. This setting, when true, ensures the server doesn’t immediately close a connection if a client shuts down their sending side while waiting for a response.

Default is false.

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

Enables or disables the keep-alive feature for HTTP/1 connections.

Keep-alive allows the connection to be reused for multiple requests and responses.

Default is true.

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

Determines if HTTP/1 connections should write headers with title-case naming.

For example, turning this setting true would send headers as “Content-Type” instead of “content-type”. Note that this has no effect on HTTP/2 connections.

Default is false.

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

Determines if HTTP/1 connections should preserve the original case of headers.

By default, headers might be normalized. Enabling this will ensure headers retain their original casing. This setting doesn’t influence HTTP/2.

Default is false.

pub fn http1_header_read_timeout(&mut self, val: Duration) -> &mut Self

Configures a timeout for how long the server will wait for client headers.

If the client doesn’t send all headers within this duration, the connection is terminated.

Default is None, meaning no timeout.

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

Specifies whether to use vectored writes for HTTP/1 connections.

Vectored writes can be efficient for multiple non-contiguous data segments. However, certain transports (like many TLS implementations) may not handle vectored writes well. When disabled, data is flattened into a single buffer before writing.

Default is auto, where the best method is determined dynamically.

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

Configures the server to exclusively support HTTP/2.

When enabled, only HTTP/2 requests are processed, and HTTP/1 requests are rejected.

Default is false.

Examples found in repository

examples/configure_http.rs (line 15)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let config = HttpConfig::new()
        .http1_only(true)
        .http2_only(false)
        .max_buf_size(8192)
        .build();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    hyper_server::bind(addr)
        .http_config(config)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

pub fn http2_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.

pub fn http2_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.

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

Sets whether to use an adaptive flow control.

Enabling this will override the limits set in http2_initial_stream_window_size and http2_initial_connection_window_size.

pub fn http2_enable_connect_protocol(&mut self) -> &mut Self

Enables the extended CONNECT protocol.

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

Sets the maximum frame size to use for HTTP2.

Passing None will do nothing.

If not set, hyper will use a default.

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

Sets the SETTINGS_MAX_CONCURRENT_STREAMS option for HTTP2 connections.

Default is no limit (std::u32::MAX). Passing None will do nothing.

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

Sets the max size of received header frames.

Default is currently ~16MB, but may change.

pub fn http2_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.3.17, it is 20.

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

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

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

Default is currently ~400KB, but may change.

Panics

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

pub fn http2_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.

pub fn http2_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 http2_keep_alive_interval is disabled.

Default is 20 seconds.

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

Set the maximum buffer size for the HTTP/1 connection.

Default is ~400kb.

Panics

The minimum value allowed is 8192. This method panics if the passed max is less than the minimum.

Examples found in repository

examples/configure_http.rs (line 16)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let config = HttpConfig::new()
        .http1_only(true)
        .http2_only(false)
        .max_buf_size(8192)
        .build();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    hyper_server::bind(addr)
        .http_config(config)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

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

Determines if multiple responses should be buffered and sent together to support pipelined responses.

This can improve throughput in certain situations, but is experimental and might contain issues.

Default is false.

Trait Implementations

impl Clone for HttpConfig

fn clone(&self) -> HttpConfig

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HttpConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for HttpConfig

fn default() -> Self

Provides a default HTTP configuration.