Struct HyperConnections 

pub struct HyperConnections { /* private fields */ }

Accepts at one address and serves each connection with one service.

This is all a framework needs to be served when it exposes a service rather than an accept loop. The listener stays here, so closing drops it and frees the address immediately, while connections already accepted are given the drain to finish.

Implementations

impl HyperConnections

pub fn serve<Answering, ResponseBody>( listener: TcpListener, service: Answering, drain: Duration, ) -> Self

where Answering: Service<Request<Incoming>, Response = Response<ResponseBody>> + Clone + 'static, Answering::Error: Into<ConnectionsError>, Answering::Future: Send, ResponseBody: Body + Send + 'static, ResponseBody::Data: Send, ResponseBody::Error: Into<ConnectionsError>,

Serves every connection accepted at listener with service, draining for drain.

The drain is stated here rather than fixed, because how long a request may take is what the surface being served decides, not what accepting it does. DRAIN is the usual answer.

pub async fn close(&mut self)

Releases the address, leaving what is already being served to finish on its own.

Aborting the accept task drops the listener, which is what frees the address, and awaiting the handle is what makes it free on return rather than shortly after. Each connection is then told to shut down gracefully, which is what makes one finish: it answers what it is producing and then ends, rather than waiting for a request no caller will send. This does not wait for that, which is what Self::end is for.

pub async fn end(&mut self)

Releases the address, then gives what is already being served up to the drain to finish.

Whatever is still serving when the drain runs out is ended, so this resolves within the drain of Self::close however slow a request is.

Trait Implementations

impl Drop for HyperConnections

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.