pub struct Builder<I, E = Exec> { /* private fields */ }
Expand description
A builder for a Server
.
Implementations
impl<I, E> Builder<I, E>
impl<I, E> Builder<I, E>
pub fn new(incoming: I, protocol: Http<E>) -> Builder<I, E>
pub fn new(incoming: I, protocol: Http<E>) -> Builder<I, E>
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) -> Builder<I, E>
pub fn http1_keepalive(self, val: bool) -> Builder<I, E>
Sets whether to use keep-alive for HTTP/1 connections.
Default is true
.
pub fn http1_half_close(self, val: bool) -> Builder<I, E>
pub fn http1_half_close(self, val: bool) -> Builder<I, E>
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
.
pub fn http1_max_buf_size(self, val: usize) -> Builder<I, E>
pub fn http1_max_buf_size(self, val: usize) -> Builder<I, E>
Set the maximum buffer size.
Default is ~ 400kb.
pub fn http1_writev(self, enabled: bool) -> Builder<I, E>
pub fn http1_writev(self, enabled: bool) -> Builder<I, E>
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
pub fn http1_title_case_headers(self, val: bool) -> Builder<I, E>
pub fn http1_title_case_headers(self, val: bool) -> Builder<I, E>
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.
pub fn http1_preserve_header_case(self, val: bool) -> Builder<I, E>
pub fn http1_preserve_header_case(self, val: bool) -> Builder<I, E>
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.
pub fn http1_only(self, val: bool) -> Builder<I, E>
pub fn http1_only(self, val: bool) -> Builder<I, E>
Sets whether HTTP/1 is required.
Default is false
.
pub fn http2_only(self, val: bool) -> Builder<I, E>
pub fn http2_only(self, val: bool) -> Builder<I, E>
Sets whether HTTP/2 is required.
Default is false
.
pub fn http2_initial_stream_window_size(
self,
sz: impl Into<Option<u32>>
) -> Builder<I, E>
pub fn http2_initial_stream_window_size(
self,
sz: impl Into<Option<u32>>
) -> Builder<I, E>
Sets the SETTINGS_INITIAL_WINDOW_SIZE
option for HTTP2
stream-level flow control.
Passing None
will do nothing.
If not set, hyper will use a default.
pub fn http2_initial_connection_window_size(
self,
sz: impl Into<Option<u32>>
) -> Builder<I, E>
pub fn http2_initial_connection_window_size(
self,
sz: impl Into<Option<u32>>
) -> Builder<I, E>
Sets the max connection-level flow control for HTTP2
Passing None
will do nothing.
If not set, hyper will use a default.
pub fn http2_adaptive_window(self, enabled: bool) -> Builder<I, E>
pub fn http2_adaptive_window(self, enabled: bool) -> Builder<I, E>
Sets whether to use an adaptive flow control.
Enabling this will override the limits set in
http2_initial_stream_window_size
and
http2_initial_connection_window_size
.
pub fn http2_max_frame_size(self, sz: impl Into<Option<u32>>) -> Builder<I, E>
pub fn http2_max_frame_size(self, sz: impl Into<Option<u32>>) -> Builder<I, E>
Sets the maximum frame size to use for HTTP2.
Passing None
will do nothing.
If not set, hyper will use a default.
pub fn http2_max_concurrent_streams(
self,
max: impl Into<Option<u32>>
) -> Builder<I, E>
pub fn http2_max_concurrent_streams(
self,
max: impl Into<Option<u32>>
) -> Builder<I, E>
Sets the SETTINGS_MAX_CONCURRENT_STREAMS
option for HTTP2
connections.
Default is no limit (std::u32::MAX
). Passing None
will do nothing.
pub fn http2_max_send_buf_size(self, max: usize) -> Builder<I, E>
pub fn http2_max_send_buf_size(self, max: usize) -> Builder<I, E>
Set the maximum write buffer size for each HTTP/2 stream.
Default is currently ~400KB, but may change.
Panics
The value must be no larger than u32::MAX
.
pub fn http2_enable_connect_protocol(self) -> Builder<I, E>
pub fn http2_enable_connect_protocol(self) -> Builder<I, E>
Enables the extended CONNECT protocol.
pub 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
.
pub fn serve<S, B>(self, new_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 Error + Send + Sync + 'static, Global>>,
IO: 'static + AsyncRead + AsyncWrite + Unpin + Send,
S: MakeServiceRef<IO, Body, ResBody = B>,
B: 'static + Body,
E: ConnStreamExec<<<S as MakeServiceRef<IO, Body>>::Service as HttpService<Body>>::Future, B> + NewSvcExec<IO, <S as MakeServiceRef<IO, Body>>::Future, <S as MakeServiceRef<IO, Body>>::Service, E, NoopWatcher>,
<S as MakeServiceRef<IO, Body>>::Error: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
<B as Body>::Error: Into<Box<dyn Error + Send + Sync + 'static, Global>>, type Output = Result<(), Error>;
where
I: Accept,
S: MakeServiceRef<<I as Accept>::Conn, Body, ResBody = B>,
B: 'static + Body,
E: NewSvcExec<<I as Accept>::Conn, <S as MakeServiceRef<<I as Accept>::Conn, Body>>::Future, <S as MakeServiceRef<<I as Accept>::Conn, Body>>::Service, E, NoopWatcher> + ConnStreamExec<<<S as MakeServiceRef<<I as Accept>::Conn, Body>>::Service as HttpService<Body>>::Future, B>,
<I as Accept>::Error: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
<I as Accept>::Conn: 'static,
<I as Accept>::Conn: AsyncRead,
<I as Accept>::Conn: AsyncWrite,
<I as Accept>::Conn: Unpin,
<I as Accept>::Conn: Send,
<S as MakeServiceRef<<I as Accept>::Conn, Body>>::Error: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
<B as Body>::Error: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
pub fn serve<S, B>(self, new_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 Error + Send + Sync + 'static, Global>>,
IO: 'static + AsyncRead + AsyncWrite + Unpin + Send,
S: MakeServiceRef<IO, Body, ResBody = B>,
B: 'static + Body,
E: ConnStreamExec<<<S as MakeServiceRef<IO, Body>>::Service as HttpService<Body>>::Future, B> + NewSvcExec<IO, <S as MakeServiceRef<IO, Body>>::Future, <S as MakeServiceRef<IO, Body>>::Service, E, NoopWatcher>,
<S as MakeServiceRef<IO, Body>>::Error: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
<B as Body>::Error: Into<Box<dyn Error + Send + Sync + 'static, Global>>, type Output = Result<(), Error>;
where
I: Accept,
S: MakeServiceRef<<I as Accept>::Conn, Body, ResBody = B>,
B: 'static + Body,
E: NewSvcExec<<I as Accept>::Conn, <S as MakeServiceRef<<I as Accept>::Conn, Body>>::Future, <S as MakeServiceRef<<I as Accept>::Conn, Body>>::Service, E, NoopWatcher> + ConnStreamExec<<<S as MakeServiceRef<<I as Accept>::Conn, Body>>::Service as HttpService<Body>>::Future, B>,
<I as Accept>::Error: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
<I as Accept>::Conn: 'static,
<I as Accept>::Conn: AsyncRead,
<I as Accept>::Conn: AsyncWrite,
<I as Accept>::Conn: Unpin,
<I as Accept>::Conn: Send,
<S as MakeServiceRef<<I as Accept>::Conn, Body>>::Error: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
<B as Body>::Error: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
I: Accept<Conn = IO, Error = IE>,
IE: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
IO: 'static + AsyncRead + AsyncWrite + Unpin + Send,
S: MakeServiceRef<IO, Body, ResBody = B>,
B: 'static + Body,
E: ConnStreamExec<<<S as MakeServiceRef<IO, Body>>::Service as HttpService<Body>>::Future, B> + NewSvcExec<IO, <S as MakeServiceRef<IO, Body>>::Future, <S as MakeServiceRef<IO, Body>>::Service, E, NoopWatcher>,
<S as MakeServiceRef<IO, Body>>::Error: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
<B as Body>::Error: Into<Box<dyn Error + Send + Sync + 'static, Global>>, type Output = Result<(), Error>;
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);
}
impl<E> Builder<AddrIncoming, E>
impl<E> Builder<AddrIncoming, E>
pub fn tcp_keepalive(
self,
keepalive: Option<Duration>
) -> Builder<AddrIncoming, E>
pub fn tcp_keepalive(
self,
keepalive: Option<Duration>
) -> Builder<AddrIncoming, E>
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) -> Builder<AddrIncoming, E>
pub fn tcp_nodelay(self, enabled: bool) -> Builder<AddrIncoming, E>
Set the value of TCP_NODELAY
option for accepted connections.
pub fn tcp_sleep_on_accept_errors(self, val: bool) -> Builder<AddrIncoming, E>
pub fn tcp_sleep_on_accept_errors(self, val: bool) -> Builder<AddrIncoming, E>
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
Trait Implementations
Auto Trait Implementations
impl<I, E> RefUnwindSafe for Builder<I, E> where
E: RefUnwindSafe,
I: RefUnwindSafe,
impl<I, E> Send for Builder<I, E> where
E: Send,
I: Send,
impl<I, E> Sync for Builder<I, E> where
E: Sync,
I: Sync,
impl<I, E> Unpin for Builder<I, E> where
E: Unpin,
I: Unpin,
impl<I, E> UnwindSafe for Builder<I, E> where
E: UnwindSafe,
I: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourcefn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
T: Future, type Output = <T as Future>::Output;
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
fn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more