Struct PropagateHeader

pub struct PropagateHeader<S> { /* private fields */ }

Middleware that propagates headers from requests to responses.

If the header is present on the request it’ll be applied to the response as well. This could for example be used to propagate headers such as X-Request-Id.

See the module docs for more details.

Implementations

impl<S> PropagateHeader<S>

pub fn new(inner: S, header: HeaderName) -> PropagateHeader<S>

Create a new PropagateHeader that propagates the given header.

pub fn get_ref(&self) -> &S

Gets a reference to the underlying service.

pub fn get_mut(&mut self) -> &mut S

Gets a mutable reference to the underlying service.

pub fn into_inner(self) -> S

Consumes self, returning the underlying service.

pub fn layer(header: HeaderName) -> PropagateHeaderLayer

Returns a new Layer that wraps services with a PropagateHeader middleware.

Trait Implementations

impl<S> Clone for PropagateHeader<S>

where S: Clone,

fn clone(&self) -> PropagateHeader<S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S> Debug for PropagateHeader<S>

where S: Debug,

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

Formats the value using the given formatter.

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for PropagateHeader<S>

where S: Service<Request<ReqBody>, Response = Response<ResBody>>,

type Response = <S as Service<Request<ReqBody>>>::Response

Responses given by the service.

type Error = <S as Service<Request<ReqBody>>>::Error

Errors produced by the service.

type Future = ResponseFuture<<S as Service<Request<ReqBody>>>::Future>

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <PropagateHeader<S> as Service<Request<ReqBody>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, req: Request<ReqBody>, ) -> <PropagateHeader<S> as Service<Request<ReqBody>>>::Future

Process the request and return the response asynchronously.