Struct hyper::server::Builder[][src]

pub struct Builder<I, E = Exec> { /* fields omitted */ }
This is supported on crate feature server only.

A builder for a Server.

Implementations

impl<I, E> Builder<I, E>[src]

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

This is supported on crate features http1 or http2 only.

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

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

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

This is supported on (crate features http1 or http2) and crate feature http1 only.

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

Default is true.

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

This is supported on (crate features http1 or http2) and crate feature http1 only.

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.

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

This is supported on (crate features http1 or http2) and crate feature http1 only.

Set the maximum buffer size.

Default is ~ 400kb.

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

This is supported on (crate features http1 or http2) and crate feature http1 only.

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.

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

This is supported on (crate features http1 or http2) and crate feature http1 only.

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

Note that this setting does not affect HTTP/2.

Default is false.

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

This is supported on (crate features http1 or http2) and crate feature http1 only.

Sets whether HTTP/1 is required.

Default is false.

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

This is supported on (crate features http1 or http2) and crate feature http2 only.

Sets whether HTTP/2 is required.

Default is false.

pub fn http2_initial_stream_window_size(
    self,
    sz: impl Into<Option<u32>>
) -> Self
[src]

This is supported on (crate features http1 or http2) and crate feature http2 only.

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(
    self,
    sz: impl Into<Option<u32>>
) -> Self
[src]

This is supported on (crate features http1 or http2) and crate feature http2 only.

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(self, enabled: bool) -> Self[src]

This is supported on (crate features http1 or http2) and crate feature http2 only.

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_max_frame_size(self, sz: impl Into<Option<u32>>) -> Self[src]

This is supported on (crate features http1 or http2) and crate feature http2 only.

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(self, max: impl Into<Option<u32>>) -> Self[src]

This is supported on (crate features http1 or http2) and crate feature http2 only.

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_keep_alive_interval(
    self,
    interval: impl Into<Option<Duration>>
) -> Self
[src]

This is supported on (crate features http1 or http2) and crate feature http2 only.

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.

pub fn http2_keep_alive_timeout(self, timeout: Duration) -> Self[src]

This is supported on (crate features http1 or http2) and crate feature http2 only.

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.

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

This is supported on crate features http1 or http2 only.

Sets the Executor to deal with connection tasks.

Default is tokio::spawn.

pub fn serve<S, B>(self, new_service: S) -> Server<I, S, E>

Notable traits for Server<I, S, E>

impl<I, IO, IE, S, B, E> Future for Server<I, S, E> where
    I: Accept<Conn = IO, Error = IE>,
    IE: Into<Box<dyn StdError + Send + Sync>>,
    IO: AsyncRead + AsyncWrite + Unpin + Send + 'static,
    S: MakeServiceRef<IO, Body, ResBody = B>,
    S::Error: Into<Box<dyn StdError + Send + Sync>>,
    B: HttpBody + 'static,
    B::Error: Into<Box<dyn StdError + Send + Sync>>,
    E: ConnStreamExec<<S::Service as HttpService<Body>>::Future, B>,
    E: NewSvcExec<IO, S::Future, S::Service, E, NoopWatcher>, 
type Output = Result<()>;
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>,
    E: ConnStreamExec<<S::Service as HttpService<Body>>::Future, B>, 
[src]

This is supported on crate features http1 or http2 only.

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);
}

impl<E> Builder<AddrIncoming, E>[src]

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

This is supported on crate features http1 or http2 only.

Set whether TCP keepalive messages are enabled on accepted connections.

If None is specified, keepalive is disabled, otherwise the duration specified will be the time to remain idle before sending TCP keepalive probes.

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

This is supported on crate features http1 or http2 only.

Set the value of TCP_NODELAY option for accepted connections.

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

This is supported on crate features http1 or http2 only.

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

Trait Implementations

impl<I: Debug, E: Debug> Debug for Builder<I, E>[src]

This is supported on crate features http1 or http2 only.

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

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T> Instrument for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

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

The type returned in the event of a conversion error.