Struct hyper::server::server::Builder

source ·
pub struct Builder<I, E = Exec> {
    incoming: I,
    protocol: Http<E>,
}
Expand description

A builder for a Server.

Fields§

§incoming: I§protocol: Http<E>

Implementations§

source§

impl<I, E> Builder<I, E>

source

pub fn new(incoming: I, protocol: Http_<E>) -> Self

Start a new builder, wrapping an incoming stream and low-level options.

For a more convenient constructor, see Server::bind.

source

pub fn http1_keepalive(self, val: bool) -> Self

Sets whether to use keep-alive for HTTP/1 connections.

Default is true.

source

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

Set whether HTTP/1 connections should support half-closures.

Clients can chose to shutdown their write-side while waiting for the server to respond. Setting this to true will prevent closing the connection immediately if read detects an EOF in the middle of a request.

Default is false.

source

pub fn http1_max_buf_size(self, val: usize) -> Self

Set the maximum buffer size.

Default is ~ 400kb.

source

pub fn http1_writev(self, enabled: bool) -> Self

Set whether HTTP/1 connections should try to use vectored writes, or always flatten into a single buffer.

Note that setting this to false may mean more copies of body data, but may also improve performance when an IO transport doesn’t support vectored writes well, such as most TLS implementations.

Setting this to true will force hyper to use queued strategy which may eliminate unnecessary cloning on some TLS backends

Default is auto. In this mode hyper will try to guess which mode to use

source

pub fn http1_title_case_headers(self, val: bool) -> Self

Set whether HTTP/1 connections will write header names as title case at the socket level.

Note that this setting does not affect HTTP/2.

Default is false.

source

pub fn http1_preserve_header_case(self, val: bool) -> Self

Set whether to support preserving original header cases.

Currently, this will record the original cases received, and store them in a private extension on the Request. It will also look for and use such an extension in any provided Response.

Since the relevant extension is still private, there is no way to interact with the original cases. The only effect this can have now is to forward the cases in a proxy-like fashion.

Note that this setting does not affect HTTP/2.

Default is false.

source

pub fn http1_header_read_timeout(self, read_timeout: Duration) -> Self

Set a timeout for reading client request headers. If a client does not transmit the entire header within this time, the connection is closed.

Default is None.

source

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

Sets whether HTTP/1 is required.

Default is false.

source

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

Sets whether HTTP/2 is required.

Default is false.

source

pub fn http2_max_pending_accept_reset_streams( self, max: impl Into<Option<usize>> ) -> 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.

source

pub fn http2_initial_stream_window_size( self, sz: impl Into<Option<u32>> ) -> 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 http2_initial_connection_window_size( self, sz: impl Into<Option<u32>> ) -> 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 http2_adaptive_window(self, enabled: bool) -> 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.

source

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

Sets the maximum frame size to use for HTTP2.

Passing None will do nothing.

If not set, hyper will use a default.

source

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

Sets the max size of received header frames.

Default is currently ~16MB, but may change.

source

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

Sets the SETTINGS_MAX_CONCURRENT_STREAMS option for HTTP2 connections.

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

source

pub fn http2_keep_alive_interval( self, interval: impl Into<Option<Duration>> ) -> 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.

Cargo Feature

Requires the runtime cargo feature to be enabled.

source

pub fn http2_keep_alive_timeout(self, timeout: Duration) -> 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.

Cargo Feature

Requires the runtime cargo feature to be enabled.

source

pub fn http2_max_send_buf_size(self, max: usize) -> 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.

source

pub fn http2_enable_connect_protocol(self) -> Self

source

pub fn executor<E2>(self, executor: E2) -> Builder<I, E2>

Sets the Executor to deal with connection tasks.

Default is tokio::spawn.

source

pub fn serve<S, B>(self, make_service: S) -> Server<I, S, E> where I: Accept, I::Error: Into<Box<dyn StdError + Send + Sync>>, I::Conn: AsyncRead + AsyncWrite + Unpin + Send + 'static, S: MakeServiceRef<I::Conn, Body, ResBody = B>, S::Error: Into<Box<dyn StdError + Send + Sync>>, B: HttpBody + 'static, B::Error: Into<Box<dyn StdError + Send + Sync>>, E: NewSvcExec<I::Conn, S::Future, S::Service, E, NoopWatcher> + ConnStreamExec<<S::Service as HttpService<Body>>::Future, B>,

Consume this Builder, creating a Server.

Example
use hyper::{Body, Error, Response, Server};
use hyper::service::{make_service_fn, service_fn};

// Construct our SocketAddr to listen on...
let addr = ([127, 0, 0, 1], 3000).into();

// And a MakeService to handle each connection...
let make_svc = make_service_fn(|_| async {
    Ok::<_, Error>(service_fn(|_req| async {
        Ok::<_, Error>(Response::new(Body::from("Hello World")))
    }))
});

// Then bind and serve...
let server = Server::bind(&addr)
    .serve(make_svc);

// Run forever-ish...
if let Err(err) = server.await {
    eprintln!("server error: {}", err);
}
source§

impl<E> Builder<AddrIncoming, E>

source

pub fn tcp_keepalive(self, keepalive: Option<Duration>) -> Self

Set the duration to remain idle before sending TCP keepalive probes.

If None is specified, keepalive is disabled.

source

pub fn tcp_keepalive_interval(self, interval: Option<Duration>) -> Self

Set the duration between two successive TCP keepalive retransmissions, if acknowledgement to the previous keepalive transmission is not received.

source

pub fn tcp_keepalive_retries(self, retries: Option<u32>) -> Self

Set the number of retransmissions to be carried out before declaring that remote end is not available.

source

pub fn tcp_nodelay(self, enabled: bool) -> Self

Set the value of TCP_NODELAY option for accepted connections.

source

pub fn tcp_sleep_on_accept_errors(self, val: bool) -> Self

Set whether to sleep on accept errors.

A possible scenario is that the process has hit the max open files allowed, and so trying to accept a new connection will fail with EMFILE. In some cases, it’s preferable to just wait for some time, if the application will likely close some files (or connections), and try to accept the connection again. If this option is true, the error will be logged at the error level, since it is still a big deal, and then the listener will sleep for 1 second.

In other cases, hitting the max open files should be treat similarly to being out-of-memory, and simply error (and shutdown). Setting this option to false will allow that.

For more details see AddrIncoming::set_sleep_on_errors

source

pub fn local_addr(&self) -> SocketAddr

Returns the local address that the server will be bound to.

This might be useful when knowing the address is required before calling Builder::serve, but the address is not otherwise available (for e.g. when binding to port 0).

Trait Implementations§

source§

impl<I: Debug, E: Debug> Debug for Builder<I, E>

source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl<I, E> RefUnwindSafe for Builder<I, E>where E: RefUnwindSafe, I: RefUnwindSafe,

§

impl<I, E> Send for Builder<I, E>where E: Send, I: Send,

§

impl<I, E> Sync for Builder<I, E>where E: Sync, I: Sync,

§

impl<I, E> Unpin for Builder<I, E>where E: Unpin, I: Unpin,

§

impl<I, E> UnwindSafe for Builder<I, E>where E: UnwindSafe, I: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more