Struct ValidateRequestHeaderLayer 

pub struct ValidateRequestHeaderLayer<T> { /* private fields */ }

Available on crate feature validate-request only.

Layer that applies ValidateRequestHeader which validates all requests.

See the module docs for an example.

Implementations

impl<ResBody> ValidateRequestHeaderLayer<Basic<ResBody>>

pub fn basic(username: &str, password: &str) -> Self

where ResBody: Default,

👎Deprecated since 0.6.7:

too basic to be useful in real applications

Available on crate feature auth only.

Authorize requests using a username and password pair.

The Authorization header is required to be Basic {credentials} where credentials is base64_encode("{username}:{password}").

Since the username and password is sent in clear text it is recommended to use HTTPS/TLS with this method. However use of HTTPS/TLS is not enforced by this middleware.

impl<ResBody> ValidateRequestHeaderLayer<Bearer<ResBody>>

pub fn bearer(token: &str) -> Self

where ResBody: Default,

👎Deprecated since 0.6.7:

too basic to be useful in real applications

Available on crate feature auth only.

Authorize requests using a “bearer token”. Commonly used for OAuth 2.

The Authorization header is required to be Bearer {token}.

Panics

Panics if the token is not a valid HeaderValue.

impl<ResBody> ValidateRequestHeaderLayer<AcceptHeader<ResBody>>

pub fn accept(value: &str) -> Self

where ResBody: Default,

Validate requests have the required Accept header.

The Accept header is required to be */*, type/* or type/subtype, as configured.

Panics

Panics if header_value is not in the form: type/subtype, such as application/json See AcceptHeader::new for when this method panics.

Example

use http_body_util::Full;
use bytes::Bytes;
use tower_http::validate_request::{AcceptHeader, ValidateRequestHeaderLayer};

let layer = ValidateRequestHeaderLayer::<AcceptHeader<Full<Bytes>>>::accept("application/json");

impl<ResBody> ValidateRequestHeaderLayer<RequiredHeaderValue<ResBody>>

pub fn has_header_value( expected_header_name: &str, expected_header_value: &str, ) -> Result<Self, InvalidHeaderName>

where ResBody: Default,

Validate requests have a required header with a specific value.

Rejects with 403 Forbidden if the header is missing or does not have the expected value. Header values that are not valid UTF-8 are treated as non-matching.

If the request contains multiple values for the header, only the first occurrence is checked.

Errors

Returns an error if expected_header_name is not a valid HTTP header name per RFC 7230 (non-empty, at most 32,768 bytes, containing only valid token characters).

Example

use http::{Request, Response, StatusCode};
use http_body_util::Full;
use bytes::Bytes;
use tower::{Service, ServiceBuilder, ServiceExt, service_fn};
use tower_http::validate_request::ValidateRequestHeaderLayer;

async fn handle(request: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, std::convert::Infallible> {
    Ok(Response::new(request.into_body()))
}

let mut service = ServiceBuilder::new()
    .layer(ValidateRequestHeaderLayer::has_header_value(
        "x-custom-header",
        "random-value-1234567890",
    ).expect("invalid validate header"))
    .service_fn(handle);

let request = Request::builder()
    .header("x-custom-header", "random-value-1234567890")
    .body(Full::default())
    .unwrap();

let response = service.ready().await.unwrap().call(request).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);

impl<T> ValidateRequestHeaderLayer<T>

pub fn custom(validate: T) -> ValidateRequestHeaderLayer<T>

Validate requests using a custom method.

Trait Implementations

impl<T: Clone> Clone for ValidateRequestHeaderLayer<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ValidateRequestHeaderLayer<T>

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

Formats the value using the given formatter.

impl<S, T> Layer<S> for ValidateRequestHeaderLayer<T>

where T: Clone,

type Service = ValidateRequestHeader<S, T>

The wrapped service

fn layer(&self, inner: S) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.