Struct Request 

pub struct Request<T = Body> { /* private fields */ }

Represents an HTTP request.

An HTTP request consists of a head and a potentially optional body. The body component is generic, enabling arbitrary types to represent the HTTP body. For example, the body could be Vec<u8>, a Stream of byte chunks, or a value that has been deserialized.

Examples

Creating a Request to send

use rama_http_types::{Request, Response};

let mut request = Request::builder()
    .uri("https://www.rust-lang.org/")
    .header("User-Agent", "my-awesome-agent/1.0");

if needs_awesome_header() {
    request = request.header("Awesome", "yes");
}

let response = send(request.body(()).unwrap());

fn send(req: Request<()>) -> Response<()> {
    // ...
}

Inspecting a request to see what was sent.

use rama_http_types::{Request, Response, Result, StatusCode};

fn respond_to(req: Request<()>) -> Result<Response<()>> {
    if req.uri().as_str() != "/awesome-url" {
        return Response::builder()
            .status(StatusCode::NOT_FOUND)
            .body(())
    }

    let has_awesome_header = req.headers().contains_key("Awesome");
    let body = req.body();

    // ...
}

Deserialize a request of bytes via json:

use rama_http_types::Request;
use serde::de;

fn deserialize<T>(req: Request<Vec<u8>>) -> serde_json::Result<Request<T>>
    where for<'de> T: de::Deserialize<'de>,
{
    let (parts, body) = req.into_parts();
    let body = serde_json::from_slice(&body)?;
    Ok(Request::from_parts(parts, body))
}

Or alternatively, serialize the body of a request to json

use rama_http_types::Request;
use serde::ser;

fn serialize<T>(req: Request<T>) -> serde_json::Result<Request<Vec<u8>>>
    where T: ser::Serialize,
{
    let (parts, body) = req.into_parts();
    let body = serde_json::to_vec(&body)?;
    Ok(Request::from_parts(parts, body))
}

Implementations

impl Request<()>

pub fn builder() -> Builder

Creates a new builder-style object to manufacture a Request

This method returns an instance of Builder which can be used to create a Request.

Examples

let request = Request::builder()
    .method("GET")
    .uri("https://www.rust-lang.org/")
    .header("X-Custom-Foo", "Bar")
    .body(())
    .unwrap();

pub fn builder_with_extensions(ext: Extensions) -> Builder

Same as Request::builder but with the given Extensions to start from.

pub fn get<T>(uri: T) -> Builder

where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a GET method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::get("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn put<T>(uri: T) -> Builder

where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a PUT method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::put("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn post<T>(uri: T) -> Builder

where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a POST method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::post("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn delete<T>(uri: T) -> Builder

where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a DELETE method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::delete("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn options<T>(uri: T) -> Builder

where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with an OPTIONS method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::options("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn head<T>(uri: T) -> Builder

where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a HEAD method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::head("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn connect<T>(uri: T) -> Builder

where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a CONNECT method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::connect("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn patch<T>(uri: T) -> Builder

where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a PATCH method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::patch("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn trace<T>(uri: T) -> Builder

where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a TRACE method and the given URI.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::trace("https://www.rust-lang.org/")
    .body(())
    .unwrap();

pub fn query<T>(uri: T) -> Builder

where T: TryInto<Uri>, <T as TryInto<Uri>>::Error: Into<Error>,

Creates a new Builder initialized with a QUERY method and the given URI.

QUERY (RFC 10008) is a safe, idempotent method whose request content defines the query; remember to set a Content-Type for the body.

This method returns an instance of Builder which can be used to create a Request.

Example

let request = Request::query("https://www.rust-lang.org/")
    .body(())
    .unwrap();

impl<T> Request<T>

pub fn new(body: T) -> Request<T>

Creates a new blank Request with the body

The component parts of this request will be set to their default, e.g. the GET method, no headers, etc.

Examples

let request = Request::new("hello world");

assert_eq!(*request.method(), Method::GET);
assert_eq!(*request.body(), "hello world");

pub fn from_parts(parts: Parts, body: T) -> Request<T>

Creates a new Request with the given components parts and body.

Examples

let request = Request::new("hello world");
let (mut parts, body) = request.into_parts();
parts.method = Method::POST;

let request = Request::from_parts(parts, body);

pub fn method(&self) -> &Method

Returns a reference to the associated HTTP method.

Examples

let request: Request<()> = Request::default();
assert_eq!(*request.method(), Method::GET);

pub fn method_mut(&mut self) -> &mut Method

Returns a mutable reference to the associated HTTP method.

Examples

let mut request: Request<()> = Request::default();
*request.method_mut() = Method::PUT;
assert_eq!(*request.method(), Method::PUT);

pub fn uri(&self) -> &Uri

Returns a reference to the associated URI.

Examples

let request: Request<()> = Request::default();
assert_eq!(request.uri().as_str(), "/");

pub fn request_uri(&self) -> Uri

Get the URI as complete as possible for this request.

Where uri returns the URI exactly as received (often origin-form /path for HTTP/1.1), this fills in the scheme and authority from the request’s effective protocol and authority (URI → TLS SNI → Forwarded → Host header) — a derivation callers can treat as a technical detail.

pub fn uri_mut(&mut self) -> &mut Uri

Returns a mutable reference to the associated URI.

Examples

let mut request: Request<()> = Request::default();
*request.uri_mut() = "/hello".parse().unwrap();
assert_eq!(request.uri().as_str(), "/hello");

pub fn version(&self) -> Version

Returns the associated version.

Examples

let request: Request<()> = Request::default();
assert_eq!(request.version(), Version::HTTP_11);

pub fn version_mut(&mut self) -> &mut Version

Returns a mutable reference to the associated version.

Examples

let mut request: Request<()> = Request::default();
*request.version_mut() = Version::HTTP_2;
assert_eq!(request.version(), Version::HTTP_2);

pub fn headers(&self) -> &HeaderMap

Returns a reference to the associated header field map.

Examples

let request: Request<()> = Request::default();
assert!(request.headers().is_empty());

pub fn headers_mut(&mut self) -> &mut HeaderMap

Returns a mutable reference to the associated header field map.

Examples

let mut request: Request<()> = Request::default();
request.headers_mut().insert(HOST, HeaderValue::from_static("world"));
assert!(!request.headers().is_empty());

pub fn clone_parts(&self) -> Parts

Returned a cloned of the associated HTTP header.

pub fn body(&self) -> &T

Returns a reference to the associated HTTP body.

Examples

let request: Request<String> = Request::default();
assert!(request.body().is_empty());

pub fn body_mut(&mut self) -> &mut T

Returns a mutable reference to the associated HTTP body.

Examples

let mut request: Request<String> = Request::default();
request.body_mut().push_str("hello world");
assert!(!request.body().is_empty());

pub fn into_body(self) -> T

Consumes the request, returning just the body.

Examples

let request = Request::new(10);
let body = request.into_body();
assert_eq!(body, 10);

pub fn into_parts(self) -> (Parts, T)

Consumes the request returning the head and body parts.

Examples

let request = Request::new(());
let (parts, body) = request.into_parts();
assert_eq!(parts.method, Method::GET);

pub fn map<F, U>(self, f: F) -> Request<U>

where F: FnOnce(T) -> U,

Consumes the request returning a new request with body mapped to the return type of the passed in function.

Examples

let request = Request::builder().body("some string").unwrap();
let mapped_request: Request<&[u8]> = request.map(|b| {
  assert_eq!(b, "some string");
  b.as_bytes()
});
assert_eq!(mapped_request.body(), &"some string".as_bytes());

pub fn with_extensions(self, extensions: Extensions) -> Request<T>

pub fn set_extensions(&mut self, extensions: Extensions) -> &mut Request<T>

Trait Implementations

impl<Body> AuthorityInputExt for Request<Body>

fn authority(&self) -> Option<HostWithOptPort>

The routing authority (host[:port]), or None if none is resolvable.

fn host(&self) -> Option<Host>

The authority Host, dropping any port.

fn host_as_domain(&self) -> Option<Domain>

The authority host as a Domain, or None if absent or not a domain (e.g. an IP literal).

fn port(&self) -> Option<u16>

The authority port, if one is set explicitly.

impl<B> Body for Request<B>

where B: Body,

type Data = <B as Body>::Data

Values yielded by the Body.

type Error = <B as Body>::Error

The error type this Body might generate.

fn poll_frame( self: Pin<&mut Request<B>>, cx: &mut Context<'_>, ) -> Poll<Option<Result<Frame<<Request<B> as Body>::Data>, <Request<B> as Body>::Error>>>

Attempt to pull out the next frame of this stream.

fn is_end_stream(&self) -> bool

A hint that may return true when the end of stream has been reached.

fn size_hint(&self) -> SizeHint

A hint that returns the bounds on the remaining length of the stream.

impl<Body> BodyExtractExt for Request<Body>

where Body: Body<Data = Bytes> + Send + Sync + 'static, <Body as Body>::Error: Into<Box<dyn Error + Sync + Send>>,

async fn try_into_json<T>(self) -> Result<T, Box<dyn Error + Sync + Send>>

where T: DeserializeOwned + Send + 'static,

Try to deserialize the (contained) body as a JSON object.

async fn try_into_json_streaming<T>( self, ) -> Result<T, Box<dyn Error + Sync + Send>>

where T: DeserializeOwned + Send + 'static,

Try to deserialize the (contained) body as a JSON object, streaming bytes from the body directly into the JSON parser instead of buffering the whole body first.

async fn try_into_string(self) -> Result<String, Box<dyn Error + Sync + Send>>

Try to turn the (contained) body in an utf-8 string.

async fn try_capture_json( self, selectors: impl IntoIterator<Item = JsonPath> + Send, max_capture_bytes: usize, ) -> Result<Vec<OwnedCapturedValue>, Box<dyn Error + Sync + Send>>

Capture JSON values matching selectors while streaming over the body.

async fn try_into_json_with<T>( self, opts: CollectOptions, ) -> Result<T, CollectError>

where T: DeserializeOwned + Send + 'static,

Like try_into_json, but bounded by opts (a size cap and/or timeout).

async fn try_into_string_with( self, opts: CollectOptions, ) -> Result<String, CollectError>

Like try_into_string, but bounded by opts. See try_into_json_with for the error semantics.

impl<B> ClientIp for Request<B>

fn client_ip(&self) -> Option<IpAddr>

Best-effort client IP — see client_ip for the common resolution.

impl<T> Clone for Request<T>

where T: Clone,

fn clone(&self) -> Request<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Request<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Request<T>

where T: Default,

fn default() -> Request<T>

Returns the “default value” for a type.

impl<B> ExtensionsRef for Request<B>

fn extensions(&self) -> &Extensions

Get reference to the underlying Extensions store

impl FromRequest for Request

type Rejection = Infallible

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

async fn from_request(req: Request) -> Result<Self, Self::Rejection>

Perform the extraction.

impl<Body> HeaderValueGetter for Request<Body>

fn header_str<K>(&self, key: K) -> Result<&str, HeaderValueErr>

where K: AsHeaderName + Copy,

Get a header value as a string.

fn header_bytes<K>(&self, key: K) -> Result<&[u8], HeaderValueErr>

where K: AsHeaderName + Copy,

Get a header value as a byte slice.

impl<Body> HttpRequestParts for Request<Body>

fn method(&self) -> &Method

fn uri(&self) -> &Uri

fn version(&self) -> Version

fn headers(&self) -> &HeaderMap

impl<Body> HttpRequestPartsMut for Request<Body>

fn method_mut(&mut self) -> &mut Method

fn uri_mut(&mut self) -> &mut Uri

fn version_mut(&mut self) -> &mut Version

fn headers_mut(&mut self) -> &mut HeaderMap

impl<Body> HttpVersionInputExt for Request<Body>

fn http_version(&self) -> Option<Version>

The HTTP version, or None for non-HTTP inputs.

impl<Body> Matcher<Request<Body>> for MethodMatcher

fn matches(&self, _ext: Option<&Extensions>, req: &Request<Body>) -> bool

returns true on a match, false otherwise

fn or<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Provide an alternative matcher to match if the current one does not match.

fn and<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Add another condition to match on top of the current one.

fn not(self) -> impl Matcher<Input>

where Self: Sized,

Negate the current condition.

impl<Body> Matcher<Request<Body>> for DomainMatcher

fn matches(&self, _: Option<&Extensions>, req: &Request<Body>) -> bool

returns true on a match, false otherwise

fn or<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Provide an alternative matcher to match if the current one does not match.

fn and<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Add another condition to match on top of the current one.

fn not(self) -> impl Matcher<Input>

where Self: Sized,

Negate the current condition.

impl<Body> Matcher<Request<Body>> for UriMatcher

fn matches(&self, _ext: Option<&Extensions>, req: &Request<Body>) -> bool

returns true on a match, false otherwise

fn or<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Provide an alternative matcher to match if the current one does not match.

fn and<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Add another condition to match on top of the current one.

fn not(self) -> impl Matcher<Input>

where Self: Sized,

Negate the current condition.

impl<Body> Matcher<Request<Body>> for VersionMatcher

fn matches(&self, _ext: Option<&Extensions>, req: &Request<Body>) -> bool

returns true on a match, false otherwise

fn or<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Provide an alternative matcher to match if the current one does not match.

fn and<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Add another condition to match on top of the current one.

fn not(self) -> impl Matcher<Input>

where Self: Sized,

Negate the current condition.

impl<Body> Matcher<Request<Body>> for HeaderMatcher

fn matches(&self, _ext: Option<&Extensions>, req: &Request<Body>) -> bool

returns true on a match, false otherwise

fn or<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Provide an alternative matcher to match if the current one does not match.

fn and<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Add another condition to match on top of the current one.

fn not(self) -> impl Matcher<Input>

where Self: Sized,

Negate the current condition.

impl<Body> Matcher<Request<Body>> for SubdomainTrieMatcher

fn matches(&self, _: Option<&Extensions>, req: &Request<Body>) -> bool

returns true on a match, false otherwise

fn or<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Provide an alternative matcher to match if the current one does not match.

fn and<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Add another condition to match on top of the current one.

fn not(self) -> impl Matcher<Input>

where Self: Sized,

Negate the current condition.

impl<Body> Matcher<Request<Body>> for HttpMatcher<Body>

where Body: Send + 'static,

fn matches(&self, ext: Option<&Extensions>, req: &Request<Body>) -> bool

returns true on a match, false otherwise

fn or<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Provide an alternative matcher to match if the current one does not match.

fn and<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Add another condition to match on top of the current one.

fn not(self) -> impl Matcher<Input>

where Self: Sized,

Negate the current condition.

impl<Body> Matcher<Request<Body>> for HttpMatcherKind<Body>

where Body: Send + 'static,

fn matches(&self, ext: Option<&Extensions>, req: &Request<Body>) -> bool

returns true on a match, false otherwise

fn or<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Provide an alternative matcher to match if the current one does not match.

fn and<M>(self, other: M) -> impl Matcher<Input>

where Self: Sized, M: Matcher<Input>,

Add another condition to match on top of the current one.

fn not(self) -> impl Matcher<Input>

where Self: Sized,

Negate the current condition.

impl<Body> PathInputExt for Request<Body>

fn path_ref(&self) -> PathRef<'_>

The path to route against.

impl<Body> ProtocolInputExt for Request<Body>

fn protocol(&self) -> Option<&Protocol>

The application protocol, or None if it can’t be determined.

fn protocol_default_port(&self) -> Option<u16>

The default port of the resolved Protocol (e.g. 443 for HTTPS), or None if the protocol is unknown or portless.

impl<Body, S> Service<Request<Body>> for DnsResolveModeService<S>

where Body: Send + Sync + 'static, S: Service<Request<Body>, Error: Into<BoxError> + Send + Sync + 'static>,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, request: Request<Body>, ) -> Result<Self::Output, Self::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.

impl<S, Body> Service<Request<Body>> for ErrorHandler<S, ()>

where S: Service<Request<Body>, Output: IntoResponse, Error: Into<ErrorResponse>>, Body: Send + 'static,

type Output = Response

The type of the output returned by the service.

type Error = Infallible

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, F, R, Body> Service<Request<Body>> for ErrorHandler<S, F>

where S: Service<Request<Body>, Output: IntoResponse>, F: Fn(S::Error) -> R + Clone + Send + Sync + 'static, R: IntoResponse + 'static, Body: Send + 'static,

type Output = Response

The type of the output returned by the service.

type Error = Infallible

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<H, S, Body> Service<Request<Body>> for GetForwardedHeaderService<S, H>

where H: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<Body>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

impl<T1, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1,)>

where T1: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<Body>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

impl<T1, T2, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<Body>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

impl<T1, T2, T3, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<Body>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

impl<T1, T2, T3, T4, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<Body>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

impl<T1, T2, T3, T4, T5, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<Body>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

impl<T1, T2, T3, T4, T5, T6, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<Body>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

impl<T1, T2, T3, T4, T5, T6, T7, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<Body>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

impl<T1, T2, T3, T4, T5, T6, T7, T8, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<Body>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<Body>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<Body>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<Body>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, T12: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<Body>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

impl<S, H, Body> Service<Request<Body>> for SetForwardedHeaderService<S, H>

where S: Service<Request<Body>, Error: Into<BoxError>>, H: ForwardHeader + Send + Sync + 'static, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, T1, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1,)>

where T1: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>, Error: Into<BoxError>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, T1, T2, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>, Error: Into<BoxError>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, T1, T2, T3, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>, Error: Into<BoxError>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, T1, T2, T3, T4, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>, Error: Into<BoxError>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, T1, T2, T3, T4, T5, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>, Error: Into<BoxError>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, T1, T2, T3, T4, T5, T6, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>, Error: Into<BoxError>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, T1, T2, T3, T4, T5, T6, T7, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>, Error: Into<BoxError>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>, Error: Into<BoxError>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>, Error: Into<BoxError>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>, Error: Into<BoxError>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>, Error: Into<BoxError>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, T12: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>, Error: Into<BoxError>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<T, S, Body, E> Service<Request<Body>> for HeaderConfigService<T, S>

where S: Service<Request<Body>, Error = E>, T: DeserializeOwned + Extension, Body: Send + Sync + 'static, E: Into<BoxError> + Send + Sync + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, request: Request<Body>, ) -> Result<Self::Output, Self::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.

impl<T, S, Body, E, C> Service<Request<Body>> for HeaderFromStrConfigService<T, S, C>

where S: Service<Request<Body>, Error = E>, T: FromStr<Err: Into<BoxError> + Send + Sync + 'static> + Send + Sync + Clone + Debug + Extension + 'static, C: FromIterator<T> + Send + Sync + Clone + Debug + Extension + 'static, Body: Send + Sync + 'static, E: Into<BoxError> + Send + Sync + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, request: Request<Body>, ) -> Result<Self::Output, Self::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.

impl<T, S, Body, E> Service<Request<Body>> for HeaderOptionValueService<T, S>

where S: Service<Request<Body>, Error = E>, T: Default + Extension, Body: Send + Sync + 'static, E: Into<BoxError> + Send + Sync + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, request: Request<Body>, ) -> Result<Self::Output, Self::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.

impl<P, S, Body> Service<Request<Body>> for Retry<P, S>

where P: Policy<S::Output, S::Error>, S: Service<Request<RetryBody>, Error: Into<BoxError>>, Body: StreamingBody<Data: Send + 'static, Error: Into<BoxError>> + Send + 'static,

type Output = <S as Service<Request<RetryBody>>>::Output

The type of the output returned by the service.

type Error = RetryError

The type of error returned by the service.

async fn serve( &self, request: Request<Body>, ) -> Result<Self::Output, Self::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.

impl<Body> Service<Request<Body>> for DefaultHttpProxyConnectReplyService

where Body: Send + 'static,

type Output = UpgradeResponse<Request<Body>, Response>

The type of the output returned by the service.

type Error = Response

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, Body> Service<Request<Body>> for RequestVersionAdapter<S>

where S: ConnectorService<Request<Body>, Error: Into<BoxError>>, Body: Send + 'static,

type Output = EstablishedClientConnection<<S as ConnectorService<Request<Body>>>::Connection, Request<Body>>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, Body> Service<Request<Body>> for ResponseVersionAdapter<S>

where S: Service<Request<Body>, Output = Response, Error: Into<BoxError>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<S, F, Body> Service<Request<Body>> for RequestMetricsService<S, F>

where S: Service<Request, Output: IntoResponse>, F: AttributesFactory, Body: StreamingBody<Data = Bytes, Error: Into<BoxError>> + Send + Sync + 'static,

Available on crate feature opentelemetry only.

type Output = Response

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

impl<Body, ResBody> Service<Request<Body>> for RedirectStatic<ResBody>

where Body: Send + 'static, ResBody: Send + 'static,

type Output = Response<OptionalBody<ResBody>>

The type of the output returned by the service.

type Error = Infallible

The type of error returned by the service.

async fn serve(&self, _req: Request<Body>) -> Result<Self::Output, Self::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.

impl<R, Body> Service<Request<Body>> for RedirectHttpToHttps<R>

where R: UriMatchReplace + Send + Sync + 'static, Body: Send + 'static,

type Output = Response

The type of the output returned by the service.

type Error = Infallible

The type of error returned by the service.

async fn serve(&self, req: Request<Body>) -> Result<Self::Output, Self::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.

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

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

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

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, ReqBody> Service<Request<ReqBody>> for BodyLimitService<S>

where S: Service<Request<Body>>, ReqBody: StreamingBody<Data = Bytes, Error: Into<BoxError>> + Send + Sync + 'static,

type Output = <S as Service<Request>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, T, ReqBody, ResBody> Service<Request<ReqBody>> for CatchPanic<S, T>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ResBody: Into<Body> + Send + 'static, T: ResponseForPanic + Clone + Send + Sync + 'static, ReqBody: Send + 'static,

type Output = Response

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

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

where S: Service<Request<ReqBody>, Output = Response<ResBody>, Error: Into<BoxError>>, ReqBody: Send + 'static, ResBody: StreamingBody<Data: Send, Error: Error + Send + Sync + 'static> + Send + Sync + 'static,

type Output = Response

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

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

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<OptionalBody<ResBody>>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, T, ReqBody, ResBody> Service<Request<ReqBody>> for Csrf<S, T>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, T: ResponseForProtectionError<ResBody>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<ResBody>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, ReqBody> Service<Request<ReqBody>> for DpiProxyCredentialExtractor<S>

where S: Service<Request<ReqBody>>, ReqBody: Send + 'static,

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

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<ReqBody, ResBody, S, P> Service<Request<ReqBody>> for FollowRedirect<S, P>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: StreamingBody + Default + Send + 'static, ResBody: Send + 'static, P: Policy<ReqBody, S::Error> + Clone,

type Output = Response<ResBody>

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<ReqBody>, ) -> impl Future<Output = Result<Self::Output, Self::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.

impl<R, S, W, ReqBody, ResBody> Service<Request<ReqBody>> for HARExportService<R, S, W>

where R: Recorder, S: Service<Request, Output = Response<ResBody>>, S::Error: Into<BoxError> + Send + Sync + 'static, W: Toggle, ReqBody: StreamingBody<Data = Bytes, Error: Into<BoxError>> + Send + Sync + 'static, ResBody: StreamingBody<Data = Bytes, Error: Into<BoxError>> + Send + Sync + 'static,

type Output = Response

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<F, S, ReqBody, ResBody, NewReqBody> Service<Request<ReqBody>> for MapRequestBody<S, F>

where S: Service<Request<NewReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, NewReqBody: Send + 'static, ResBody: Send + Sync + 'static, F: Fn(ReqBody) -> NewReqBody + Send + Sync + 'static,

type Output = <S as Service<Request<NewReqBody>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<F, S, ReqBody, ResBody, NewResBody> Service<Request<ReqBody>> for MapResponseBody<S, F>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + Sync + 'static, NewResBody: Send + Sync + 'static, F: Fn(ResBody) -> NewResBody + Clone + Send + Sync + 'static,

type Output = Response<NewResBody>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<ReqBody, ResBody, R, S> Service<Request<ReqBody>> for UriMatchRedirectService<R, S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, R: UriMatchReplace + Send + Sync + 'static, ReqBody: Send + 'static, ResBody: StreamingBody<Data = Bytes, Error: Into<BoxError>> + Send + Sync + 'static,

type Output = Response

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

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

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

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

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<ReqBody>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

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

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

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

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<A, C, L, S, ReqBody, ResBody> Service<Request<ReqBody>> for ProxyAuthService<A, C, S, L>

where A: Authority<C, L>, C: Credentials + Extension + Clone, S: Service<Request<ReqBody>, Output = Response<ResBody>, Error: Into<BoxError>>, L: 'static, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<OptionalBody<ResBody>>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

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

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>,

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

The type of the output returned by the service.

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

The type of error returned by the service.

fn serve( &self, req: Request<ReqBody>, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + '_

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.

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

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>,

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

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, M, ReqBody, ResBody> Service<Request<ReqBody>> for SetRequestId<S, M>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, M: MakeRequestId, ReqBody: Send + 'static, ResBody: Send + 'static,

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

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

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

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

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

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

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

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>, Error: Into<BoxError>>,

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

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

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

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>,

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

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<ReqBody, R, S> Service<Request<ReqBody>> for RewriteUriService<R, S>

where S: Service<Request<ReqBody>>, R: UriMatchReplace + Send + Sync + 'static, ReqBody: Send + 'static,

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

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

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

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

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

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

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

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

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

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<ReqBody, ResBody, S, M> Service<Request<ReqBody>> for SetRequestHeader<S, M>

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>, M: MakeHeaderValue<ReqBody>,

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

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<ReqBody, ResBody, S, M> Service<Request<ReqBody>> for SetResponseHeader<S, M>

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>, M: MakeHeaderValueFactory<ReqBody, ResBody>,

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

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

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

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

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

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

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

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<OptionalBody<ResBody>>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, ReqBody> Service<Request<ReqBody>> for RequestBodyTimeout<S>

where S: Service<Request<TimeoutBody<ReqBody>>>, ReqBody: Send + 'static,

type Output = <S as Service<Request<TimeoutBody<ReqBody>>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

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

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<TimeoutBody<ResBody>>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, ReqBody> Service<Request<ReqBody>> for RequestBodyDeadline<S>

where S: Service<Request<DeadlineBody<ReqBody>>>, ReqBody: Send + 'static,

type Output = <S as Service<Request<DeadlineBody<ReqBody>>>>::Output

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

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

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<DeadlineBody<ResBody>>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, ReqBody, ResBody, M, OnRequestT, OnResponseT, OnFailureT, OnBodyChunkT, OnEosT, MakeSpanT> Service<Request<ReqBody>> for Trace<S, M, MakeSpanT, OnRequestT, OnResponseT, OnBodyChunkT, OnEosT, OnFailureT>

where S: Service<Request<ReqBody>, Output = Response<ResBody>, Error: Display>, ReqBody: StreamingBody + Send + 'static, ResBody: StreamingBody<Error: Display> + Send + Sync + 'static, M: MakeClassifier<Classifier: Clone>, MakeSpanT: MakeSpan<ReqBody>, OnRequestT: OnRequest<ReqBody>, OnResponseT: OnResponse<ResBody> + Clone, OnBodyChunkT: OnBodyChunk<ResBody::Data> + Clone, OnEosT: OnEos + Clone, OnFailureT: OnFailure<M::FailureClass> + Clone,

type Output = Response<ResponseBody<ResBody, <M as MakeClassifier>::ClassifyEos, OnBodyChunkT, OnEosT, OnFailureT>>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, W, ReqBody> Service<Request<ReqBody>> for RequestWriterService<S, W>

where S: Service<Request, Error: Into<BoxError>>, ReqBody: StreamingBody<Data = Bytes, Error: Into<BoxError>> + Send + Sync + 'static, W: RequestWriter,

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

The type of error returned by the service.

type Output = <S as Service<Request>>::Output

The type of the output returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, W, ReqBody, ResBody> Service<Request<ReqBody>> for ResponseWriterService<S, W>

where S: Service<Request<ReqBody>, Output = Response<ResBody>, Error: Into<BoxError>>, W: ResponseWriter, ReqBody: Send + 'static, ResBody: StreamingBody<Data = Bytes, Error: Into<BoxError>> + Send + Sync + 'static,

type Output = Response

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<M, S, ReqBody, ModReqBody, ResBody, ModResBody> Service<Request<ReqBody>> for HttpUpgradeMitmRelay<M, S>

where M: ServiceMatcher<Request<ReqBody>, Error: IntoResponse, ModifiedInput = Request<ModReqBody>, Service: ServiceMatcher<Response<ResBody>, Error: Into<S::Error>, ModifiedInput = Response<ModResBody>, Service: Service<BridgeIo<Upgraded, Upgraded>, Output = (), Error: Into<BoxError>>>>, S: Service<Request, Output = Response<ResBody>>, ReqBody: StreamingBody<Data = Bytes, Error: Into<BoxError>> + Send + Sync + 'static, ModReqBody: StreamingBody<Data = Bytes, Error: Into<BoxError>> + Send + Sync + 'static, ResBody: StreamingBody<Data = Bytes, Error: Into<BoxError>> + Send + Sync + 'static, ModResBody: StreamingBody<Data = Bytes, Error: Into<BoxError>> + Send + Sync + 'static,

type Output = Response

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<ReqBody, ServiceResBody, ValidateResBody, S, V> Service<Request<ReqBody>> for ValidateRequestHeader<S, V>

where ReqBody: Send + 'static, ServiceResBody: Send + 'static, ValidateResBody: From<ServiceResBody> + Send + 'static, V: ValidateRequest<ReqBody, ResponseBody = ValidateResBody>, S: Service<Request<ReqBody>, Output = Response<ServiceResBody>>,

type Output = Response<ValidateResBody>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, H, ReqBody, ResBody> Service<Request<ReqBody>> for HtmlRewrite<S, H>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ResBody: StreamingBody<Data: Send + 'static, Error: Into<BoxError> + Send + 'static> + Send + 'static, H: ElementContentHandler + Clone + Send + Sync + 'static, ReqBody: Send + 'static,

Available on crate feature html only.

type Output = Response<HtmlRewriteBody<ResBody, H>>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, H, ReqBody, ResBody> Service<Request<ReqBody>> for JsonRewrite<S, H>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ResBody: StreamingBody<Data: Send + 'static, Error: Into<BoxError> + Send + 'static> + Send + 'static, H: JsonValueHandler + Clone + Send + Sync + 'static, ReqBody: Send + 'static,

type Output = Response<JsonRewriteBody<ResBody, H>>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, H, ReqBody> Service<Request<ReqBody>> for JsonRequestRewrite<S, H>

where S: Service<Request<JsonRewriteBody<ReqBody, H>>>, ReqBody: StreamingBody<Data: Send + 'static, Error: Into<BoxError> + Send + 'static> + Send + 'static, H: JsonValueHandler + Clone + Send + Sync + 'static,

type Output = <S as Service<Request<JsonRewriteBody<ReqBody, H>>>>::Output

The type of the output returned by the service.

type Error = <S as Service<Request<JsonRewriteBody<ReqBody, H>>>>::Error

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<ReqBody, ResBody, S, P> Service<Request<ReqBody>> for StreamCompression<S, P>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ResBody: StreamingBody<Data: Send + 'static, Error: Send + 'static> + Send + 'static, P: Predicate + Send + Sync + 'static, ReqBody: Send + 'static,

Available on crate feature compression only.

type Output = Response<StreamCompressionBody<ResBody>>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<ReqBody, ResBody, S, P> Service<Request<ReqBody>> for Compression<S, P>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ResBody: StreamingBody<Data: Send + 'static, Error: Send + 'static> + Send + 'static, P: Predicate + Send + Sync + 'static, ReqBody: Send + 'static,

Available on crate feature compression only.

type Output = Response<CompressionBody<ResBody>>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

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

where S: Service<Request<DecompressionBody<ReqBody>>, Output = Response<ResBody>, Error: Into<BoxError>>, ReqBody: StreamingBody + Send + 'static, ResBody: StreamingBody<Data = Bytes, Error: Into<BoxError>> + Send + Sync + 'static,

Available on crate feature compression only.

type Output = Response

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, M, ReqBody, ResBody> Service<Request<ReqBody>> for Decompression<S, M>

where S: Service<Request<ReqBody>, Output = Response<ResBody>, Error: Into<BoxError>>, M: ServiceMatcher<Request<ReqBody>, ModifiedInput = Request<ReqBody>, Service: ServiceMatcher<Response<ResBody>, ModifiedInput = Response<ResBody>, Service = (), Error: Into<BoxError>>, Error: Into<BoxError>>, ReqBody: Send + 'static, ResBody: StreamingBody<Data: Send + 'static, Error: Send + 'static> + Send + 'static,

Available on crate feature compression only.

type Output = Response<DecompressionBody<ResBody>>

The type of the output returned by the service.

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

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<ReqBody, F, FResBody> Service<Request<ReqBody>> for ServeDir<F>

where ReqBody: Send + 'static, F: Service<Request<ReqBody>, Output = Response<FResBody>, Error = Infallible> + Clone, FResBody: StreamingBody<Data = Bytes, Error: Into<BoxError>> + Send + Sync + 'static,

type Output = Response

The type of the output returned by the service.

type Error = Infallible

The type of error returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<ReqBody> Service<Request<ReqBody>> for DefaultServeDirFallback

where ReqBody: Send + 'static,

type Output = Response

The type of the output returned by the service.

type Error = Infallible

The type of error returned by the service.

async fn serve( &self, _req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<ReqBody> Service<Request<ReqBody>> for ServeFile

where ReqBody: Send + 'static,

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

The type of error returned by the service.

type Output = <ServeDir as Service<Request<ReqBody>>>::Output

The type of the output returned by the service.

async fn serve( &self, req: Request<ReqBody>, ) -> Result<Self::Output, Self::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.

impl<S, O, E> Service<Request> for UpgradeService<S, O>

where S: Service<Request, Output = O, Error = E>, O: Send + Sync + 'static, E: Send + Sync + 'static,

type Output = O

The type of the output returned by the service.

type Error = E

The type of error returned by the service.

async fn serve(&self, req: Request) -> Result<Self::Output, Self::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.

impl<State> Service<Request> for WebService<State>

where State: Send + Sync + Clone + 'static,

type Output = Response

The type of the output returned by the service.

type Error = Infallible

The type of error returned by the service.

async fn serve(&self, req: Request) -> Result<Self::Output, Self::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.

impl<F, T, State> Service<Request> for EndpointServiceFnWrapper<F, T, State>

where F: EndpointServiceFn<T, State>, T: Send + 'static, State: Send + Sync + Clone + 'static,

type Output = <F as Sealed<T, State>>::Output

The type of the output returned by the service.

type Error = <F as Sealed<T, State>>::Error

The type of error returned by the service.

async fn serve(&self, req: Request) -> Result<Self::Output, Self::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.

impl<State, L, O, E> Service<Request> for Router<State, L, O, E>

where O: Send + 'static, E: Send + From<RouterError> + 'static, L: Send + Sync + 'static, State: Send + Sync + Clone + 'static,

type Output = O

The type of the output returned by the service.

type Error = E

The type of error returned by the service.

async fn serve(&self, req: Request) -> Result<Self::Output, Self::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.

impl<S, Body> ServiceMatcher<Request<Body>> for HttpProxyConnectRelayServiceRequestMatcher<S>

where S: Clone + Send + Sync + 'static, Body: Send + 'static,

type Service = HttpProxyConnectRelayServiceResponseMatcher<S>

The value returned when a match succeeds.

type Error = Infallible

The error that can happen while evaluating the matcher.

type ModifiedInput = Request<Body>

Input returned by matching functions, it might be same as the original input but it can also be modified.

async fn match_service( &self, req: Request<Body>, ) -> Result<ServiceMatch<Self::ModifiedInput, Self::Service>, Self::Error>

Attempt to select a service for input.

async fn into_match_service( self, req: Request<Body>, ) -> Result<ServiceMatch<Self::ModifiedInput, Self::Service>, Self::Error>

Attempt to select a service for input, consuming the matcher.

fn boxed( self, ) -> BoxServiceMatcher<Input, Self::Service, Self::Error, Self::ModifiedInput>

where Self: Sized,

Box this matcher for dynamic dispatch.

impl<ReqBody> ServiceMatcher<Request<ReqBody>> for DefaultDecompressionMatcher

where ReqBody: Send + 'static,

Available on crate feature compression only.

type Service = DefaultResponseDecompressionMatcher

The value returned when a match succeeds.

type Error = Infallible

The error that can happen while evaluating the matcher.

type ModifiedInput = Request<ReqBody>

Input returned by matching functions, it might be same as the original input but it can also be modified.

async fn match_service( &self, input: Request<ReqBody>, ) -> Result<ServiceMatch<Self::ModifiedInput, Self::Service>, Self::Error>

Attempt to select a service for input.

fn into_match_service( self, input: Input, ) -> impl Future<Output = Result<ServiceMatch<Self::ModifiedInput, Self::Service>, Self::Error>> + Send

where Self: Sized, Input: Send,

Attempt to select a service for input, consuming the matcher.

fn boxed( self, ) -> BoxServiceMatcher<Input, Self::Service, Self::Error, Self::ModifiedInput>

where Self: Sized,

Box this matcher for dynamic dispatch.

impl<Body> TransportProtocolInputExt for Request<Body>

fn transport_protocol(&self) -> Option<TransportProtocol>

The transport protocol (TCP or UDP).

impl TryFrom<Request> for Request

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

The type returned in the event of a conversion error.

fn try_from(har_request: Request) -> Result<Self, Self::Error>

Performs the conversion.

impl<T> TryIntoHyperiumHttp for Request<T>

type Output = Request<T>

The hyperium http type produced.

type Error = Error

The conversion error.

fn try_into_hyperium_http(self) -> Result<Request<T>, Error>

Convert self into its hyperium http equivalent.

impl<Body> UriInputExt for Request<Body>

fn uri(&self) -> &Uri

The Uri this input carries.