Struct BindBodyToConn 

pub struct BindBodyToConn<C> { /* private fields */ }

Available on crate features http-full and http and std only.

A connection wrapper that binds the connection to the lifetime of the response body it produces.

A connector returns its connection at response headers, but the connection is logically still in use until the response body has been read off the wire. On serve, this wrapper moves the connection whole into the returned response body (via GuardedBody), so the connection’s Drop (freeing a stream slot, returning it to the pool, …) fires when the body reaches end-of-stream or is dropped, instead of at headers.

The connection is moved into the response body on serve (it is served exactly once per request), so there is no shared ownership of it.

Warning: the connection returned by this service should only be used for a single request, since it will be transfered to the response body and not be useable after that.

Implementations

impl<C> BindBodyToConn<C>

where C: ExtensionsRef,

pub fn new(conn: C) -> BindBodyToConn<C>

Wrap conn so its lifetime extends to the response body of its serve.

Trait Implementations

impl<C> Debug for BindBodyToConn<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<C> ExtensionsRef for BindBodyToConn<C>

fn extensions(&self) -> &Extensions

Get reference to the underlying Extensions store

impl<C, ReqBody, RespBody> Service<Request<ReqBody>> for BindBodyToConn<C>

where C: Service<Request<ReqBody>, Output = Response<RespBody>, Error = Box<dyn Error + Send + Sync>>, ReqBody: Send + 'static, RespBody: Body<Data = Bytes> + Send + Sync + 'static, <RespBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

The type of the output returned by the service.

type Error = Box<dyn Error + Send + Sync>

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<<BindBodyToConn<C> as Service<Request<ReqBody>>>::Output, <BindBodyToConn<C> as Service<Request<ReqBody>>>::Error>

Serve an output or an error for the given input

fn boxed(self) -> BoxService<Input, Self::Output, Self::Error>

Box this service to allow for dynamic dispatch.