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

pub struct Builder<I, E = Exec> { /* fields omitted */ }

A builder for a Server.

Methods

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

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

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]

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

Default is true.

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

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 false will automatically close any connection immediately if read detects an EOF.

Default is true.

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

Sets whether HTTP/1 is required.

Default is false.

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

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

Note

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.

Default is true.

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

Sets whether HTTP/2 is required.

Default is false.

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

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

Default is 65,535

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

Sets the max connection-level flow control for HTTP2

Default is 65,535

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

Sets the SETTINGS_MAX_CONCURRENT_STREAMS option for HTTP2 connections.

Default is no limit (None).

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

Set the maximum buffer size.

Default is ~ 400kb.

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

Sets the Executor to deal with connection tasks.

Default is tokio::spawn.

ⓘImportant traits for Server<I, S, E>
pub fn serve<S, B, IO, IE>(self, new_service: S) -> Server<I, S, E> where
    I: Stream<Item = Result<IO, 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>>,
    S::Service: 'static,
    B: Payload,
    B::Data: Unpin,
    E: NewSvcExec<IO, S::Future, S::Service, E, NoopWatcher>,
    E: H2Exec<<S::Service as Service<Body>>::Future, B>, [src]

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

// Finally, spawn `server` onto an Executor...

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

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

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]

Set the value of TCP_NODELAY option for accepted connections.

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

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]

Auto Trait Implementations

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

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

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, 

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

Blanket Implementations

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

impl<T> From<T> for 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.

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

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

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