pub struct Builder<I, E = Exec> { /* private fields */ }Expand description
A builder for a Server.
Implementations
sourceimpl<I, E> Builder<I, E>
impl<I, E> Builder<I, E>
sourcepub fn new(incoming: I, protocol: Http_<E>) -> Self
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.
sourcepub fn http1_keepalive(self, val: bool) -> Self
pub fn http1_keepalive(self, val: bool) -> Self
Sets whether to use keep-alive for HTTP/1 connections.
Default is true.
sourcepub fn http1_half_close(self, val: bool) -> Self
pub fn http1_half_close(self, val: bool) -> Self
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 true will
prevent closing the connection immediately if read
detects an EOF in the middle of a request.
Default is false.
sourcepub fn http1_max_buf_size(self, val: usize) -> Self
pub fn http1_max_buf_size(self, val: usize) -> Self
Set the maximum buffer size.
Default is ~ 400kb.
sourcepub fn http1_writev(self, enabled: bool) -> Self
pub fn http1_writev(self, enabled: bool) -> Self
Set whether HTTP/1 connections should try to use vectored writes, or always flatten into a single buffer.
Note that 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.
Setting this to true will force hyper to use queued strategy which may eliminate unnecessary cloning on some TLS backends
Default is auto. In this mode hyper will try to guess which
mode to use
sourcepub fn http1_title_case_headers(self, val: bool) -> Self
pub fn http1_title_case_headers(self, val: bool) -> Self
Set whether HTTP/1 connections will write header names as title case at the socket level.
Note that this setting does not affect HTTP/2.
Default is false.
sourcepub fn http1_preserve_header_case(self, val: bool) -> Self
pub fn http1_preserve_header_case(self, val: bool) -> Self
Set whether to support preserving original header cases.
Currently, this will record the original cases received, and store them
in a private extension on the Request. It will also look for and use
such an extension in any provided Response.
Since the relevant extension is still private, there is no way to interact with the original cases. The only effect this can have now is to forward the cases in a proxy-like fashion.
Note that this setting does not affect HTTP/2.
Default is false.
sourcepub fn http1_header_read_timeout(self, read_timeout: Duration) -> Self
pub fn http1_header_read_timeout(self, read_timeout: Duration) -> Self
Set a timeout for reading client request headers. If a client does not transmit the entire header within this time, the connection is closed.
Default is None.
sourcepub fn http1_only(self, val: bool) -> Self
pub fn http1_only(self, val: bool) -> Self
Sets whether HTTP/1 is required.
Default is false.
sourcepub fn executor<E2>(self, executor: E2) -> Builder<I, E2>
pub fn executor<E2>(self, executor: E2) -> Builder<I, E2>
Sets the Executor to deal with connection tasks.
Default is tokio::spawn.
sourcepub fn serve<S, B>(self, make_service: S) -> Server<I, S, E>ⓘNotable traits for Server<I, S, E>impl<I, IO, IE, S, B, E> Future for Server<I, S, E>where
I: Accept<Conn = IO, Error = 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>>,
B: HttpBody + 'static,
B::Error: Into<Box<dyn StdError + Send + Sync>>,
E: ConnStreamExec<<S::Service as HttpService<Body>>::Future, B>,
E: NewSvcExec<IO, S::Future, S::Service, E, NoopWatcher>, type Output = Result<()>;where
I: Accept,
I::Error: Into<Box<dyn StdError + Send + Sync>>,
I::Conn: AsyncRead + AsyncWrite + Unpin + Send + 'static,
S: MakeServiceRef<I::Conn, Body, ResBody = B>,
S::Error: Into<Box<dyn StdError + Send + Sync>>,
B: HttpBody + 'static,
B::Error: Into<Box<dyn StdError + Send + Sync>>,
E: NewSvcExec<I::Conn, S::Future, S::Service, E, NoopWatcher>,
E: ConnStreamExec<<S::Service as HttpService<Body>>::Future, B>,
pub fn serve<S, B>(self, make_service: S) -> Server<I, S, E>ⓘNotable traits for Server<I, S, E>impl<I, IO, IE, S, B, E> Future for Server<I, S, E>where
I: Accept<Conn = IO, Error = 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>>,
B: HttpBody + 'static,
B::Error: Into<Box<dyn StdError + Send + Sync>>,
E: ConnStreamExec<<S::Service as HttpService<Body>>::Future, B>,
E: NewSvcExec<IO, S::Future, S::Service, E, NoopWatcher>, type Output = Result<()>;where
I: Accept,
I::Error: Into<Box<dyn StdError + Send + Sync>>,
I::Conn: AsyncRead + AsyncWrite + Unpin + Send + 'static,
S: MakeServiceRef<I::Conn, Body, ResBody = B>,
S::Error: Into<Box<dyn StdError + Send + Sync>>,
B: HttpBody + 'static,
B::Error: Into<Box<dyn StdError + Send + Sync>>,
E: NewSvcExec<I::Conn, S::Future, S::Service, E, NoopWatcher>,
E: ConnStreamExec<<S::Service as HttpService<Body>>::Future, B>,
I: Accept<Conn = IO, Error = 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>>,
B: HttpBody + 'static,
B::Error: Into<Box<dyn StdError + Send + Sync>>,
E: ConnStreamExec<<S::Service as HttpService<Body>>::Future, B>,
E: NewSvcExec<IO, S::Future, S::Service, E, NoopWatcher>, type Output = Result<()>;
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);
// Run forever-ish...
if let Err(err) = server.await {
eprintln!("server error: {}", err);
}sourceimpl<E> Builder<AddrIncoming, E>
impl<E> Builder<AddrIncoming, E>
sourcepub fn tcp_keepalive(self, keepalive: Option<Duration>) -> Self
pub fn tcp_keepalive(self, keepalive: Option<Duration>) -> Self
Set the duration to remain idle before sending TCP keepalive probes.
If None is specified, keepalive is disabled.
sourcepub fn tcp_keepalive_interval(self, interval: Option<Duration>) -> Self
pub fn tcp_keepalive_interval(self, interval: Option<Duration>) -> Self
Set the duration between two successive TCP keepalive retransmissions, if acknowledgement to the previous keepalive transmission is not received.
sourcepub fn tcp_keepalive_retries(self, retries: Option<u32>) -> Self
pub fn tcp_keepalive_retries(self, retries: Option<u32>) -> Self
Set the number of retransmissions to be carried out before declaring that remote end is not available.
sourcepub fn tcp_nodelay(self, enabled: bool) -> Self
pub fn tcp_nodelay(self, enabled: bool) -> Self
Set the value of TCP_NODELAY option for accepted connections.
sourcepub fn tcp_sleep_on_accept_errors(self, val: bool) -> Self
pub fn tcp_sleep_on_accept_errors(self, val: bool) -> Self
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