Struct RequestBodyLimit

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

Available on crate feature limit only.

Middleware that intercepts requests with body lengths greater than the configured limit and converts them into 413 Payload Too Large responses.

See the module docs for an example.

Implementations

impl<S> RequestBodyLimit<S>

pub fn new(inner: S, limit: usize) -> Self

Create a new RequestBodyLimit with the given body length limit.

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(limit: usize) -> RequestBodyLimitLayer

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

Trait Implementations

impl<S: Clone> Clone for RequestBodyLimit<S>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for RequestBodyLimit<S>

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

Formats the value using the given formatter.

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

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

type Response = Response<ResponseBody<ResBody>>

Responses given by the service.

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

Errors produced by the service.

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

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

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

fn call(&mut self, req: Request<ReqBody>) -> Self::Future

Process the request and return the response asynchronously.

impl<S: Copy> Copy for RequestBodyLimit<S>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.