Struct hyper::server::Http

pub struct Http<B = Chunk> { /* fields omitted */ }

A configuration of the HTTP protocol.

This structure is used to create instances of Server or to spawn off tasks which handle a connection to an HTTP server. Each instance of Http can be configured with various protocol-level options such as keepalive.

Methods

impl<B: AsRef<[u8]> + 'static> Http<B>

pub fn new() -> Http<B>

Creates a new instance of the HTTP protocol, ready to spawn a server or start accepting connections.

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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

Enables or disables HTTP keep-alive.

Default is true.

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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

Set the maximum buffer size for the connection.

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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

Aggregates flushes to better support pipelined responses.

Experimental, may be have bugs.

Default is false.

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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

Swallow connection accept errors. Instead of passing up IO errors when the server is under heavy load the errors will be ignored. Some connection accept errors (like "connection reset") can be ignored, some (like "too many files open") may consume 100% CPU and a timout of 10ms is used in that case.

Default is false.

pub fn bind<S, Bd>(     &self,     addr: &SocketAddr,     new_service: S ) -> Result<Server<S, Bd>> where     S: NewService<Request = Request, Response = Response<Bd>, Error = Error> + 'static,     Bd: Stream<Item = B, Error = Error>,

Bind the provided addr and return a server ready to handle connections.

This method will bind the addr provided with a new TCP listener ready to accept connections. Each connection will be processed with the new_service object provided as well, creating a new service per connection.

The returned Server contains one method, run, which is used to actually run the server.

pub fn serve_addr_handle<S, Bd>(     &self,     addr: &SocketAddr,     handle: &Handle,     new_service: S ) -> Result<Serve<AddrIncoming, S>> where     S: NewService<Request = Request, Response = Response<Bd>, Error = Error>,     Bd: Stream<Item = B, Error = Error>,

Bind the provided addr and return a server with a shared Core.

This method allows the ability to share a Core with multiple servers.

This is method will bind the addr provided with a new TCP listener ready to accept connections. Each connection will be processed with the new_service object provided as well, creating a new service per connection.

pub fn serve_incoming<I, S, Bd>(     &self,     incoming: I,     new_service: S ) -> Serve<I, S> where     I: Stream<Error = Error>,     I::Item: AsyncRead + AsyncWrite,     S: NewService<Request = Request, Response = Response<Bd>, Error = Error>,     Bd: Stream<Item = B, Error = Error>,

Bind the provided stream of incoming IO objects with a NewService.

This method allows the ability to share a Core with multiple servers.

pub fn serve_connection<S, I, Bd>(&self, io: I, service: S) -> Connection<I, S> where     S: Service<Request = Request, Response = Response<Bd>, Error = Error>,     Bd: Stream<Error = Error>,     Bd::Item: AsRef<[u8]>,     I: AsyncRead + AsyncWrite,

Bind a connection together with a Service.

This returns a Future that must be polled in order for HTTP to be driven on the connection.

Example

let http = Http::<hyper::Chunk>::new();
let conn = http.serve_connection(some_io, some_service);

let fut = conn
    .map(|_| ())
    .map_err(|e| eprintln!("server connection error: {}", e));

some_handle.spawn(fut);

Trait Implementations

impl<B> Clone for Http<B>

fn clone(&self) -> Http<B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B> Debug for Http<B>

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

Formats the value using the given formatter.