Struct hyper::server::Builder

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

A builder for a Server.

Methods

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

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.

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

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

Default is true.

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

Sets whether HTTP/1 is required.

Default is false.

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

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

Sets whether HTTP/2 is required.

Default is false.

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

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> where     I: Stream,     I::Error: Into<Box<Error + Send + Sync>>,     I::Item: AsyncRead + AsyncWrite + Send + 'static,     S: MakeServiceRef<I::Item, ReqBody = Body, ResBody = B>,     S::Error: Into<Box<Error + Send + Sync>>,     S::Service: 'static,     B: Payload,     E: NewSvcExec<I::Item, S::Future, S::Service, E, NoopWatcher>,     E: H2Exec<<S::Service as Service>::Future, B>,

Consume this Builder, creating a Server.

Example

use hyper::{Body, Response, Server};
use hyper::service::service_fn_ok;

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

// And a NewService to handle each connection...
let new_service = || {
    service_fn_ok(|_req| {
        Response::new(Body::from("Hello World"))
    })
};

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

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

impl<E> Builder<AddrIncoming, E>

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

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

Set the value of TCP_NODELAY option for accepted connections.

Trait Implementations

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

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

Formats the value using the given formatter.