Struct hyper::server::Http
[−]
[src]
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>
[src]
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,
[src]
&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,
: 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>
[src]
fn new() -> Http<B>
[src]
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
[src]
Enables or disables HTTP keep-alive.
Default is true.
fn max_buf_size(&mut self, max: usize) -> &mut Self
[src]
Set the maximum buffer size for the connection.
fn pipeline(&mut self, enabled: bool) -> &mut Self
[src]
Aggregates flushes to better support pipelined responses.
Experimental, may be have bugs.
Default is false.
fn sleep_on_errors(&mut self, enabled: bool) -> &mut Self
[src]
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.
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>,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
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<T, B> ServerProto<T> for Http<B> where
T: AsyncRead + AsyncWrite + 'static,
B: AsRef<[u8]> + 'static,
[src]
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. Read more
fn bind_transport(&self, io: T) -> Self::BindTransport
[src]
Build a transport from the given I/O object, using self
for any configuration. Read more
impl<B> Clone for Http<B>
[src]
fn clone(&self) -> Http<B>
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more