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>

fn bind_connection<S, I, Bd>(
    &self,
    handle: &Handle,
    io: I,
    remote_addr: SocketAddr,
    service: S
) where
    S: Service<Request = Request, Response = Response<Bd>, Error = Error> + 'static,
    Bd: Stream<Item = B, Error = Error> + 'static,
    I: AsyncRead + AsyncWrite + 'static, 

Deprecated since 0.11.11

: All usage of the tokio-proto crate is going away.

Use this Http instance to create a new server task which handles the connection io provided.

Deprecated

This method is deprecated. If seeking a replacement, consider Http::serve_connection.

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

fn new() -> Http<B>

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

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

Enables or disables HTTP keep-alive.

Default is true.

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

Set the maximum buffer size for the connection.

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

Aggregates flushes to better support pipelined responses.

Experimental, may be have bugs.

Default is false.

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.

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.

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.

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.

Trait Implementations

impl<T, B> ServerProto<T> for Http<B> where
    T: AsyncRead + AsyncWrite + 'static,
    B: AsRef<[u8]> + 'static, 

type Request = __ProtoRequest

Request headers.

type RequestBody = Chunk

Request body chunks.

type Response = __ProtoResponse

Response headers.

type ResponseBody = B

Response body chunks.

type Error = Error

Errors, which are used both for error frames and for the service itself.

type Transport = __ProtoTransport<T, B>

The frame transport, which usually take T as a parameter.

type BindTransport = __ProtoBindTransport<T, B>

A future for initializing a transport from an I/O object.

fn bind_transport(&self, io: T) -> Self::BindTransport

Build a transport from the given I/O object, using self for any configuration.

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.