Struct tower_http::auth::add_authorization::AddAuthorization

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

Available on crate feature auth only.

Middleware that adds authorization all requests using the Authorization header.

See the module docs for an example.

You can also use SetRequestHeader if you have a use case that isn’t supported by this middleware.

Implementations

impl<S> AddAuthorization<S>

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

Authorize requests using a username and password pair.

The Authorization header will be set to 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.

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

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

The Authorization header will be set to Bearer {token}.

Panics

Panics if the token is not a valid HeaderValue.

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 as_sensitive(self, sensitive: bool) -> Self

Mark the header as sensitive.

This can for example be used to hide the header value from logs.

Trait Implementations

impl<S: Clone> Clone for AddAuthorization<S>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for AddAuthorization<S>

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

Formats the value using the given formatter.

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

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

Responses given by the service.

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

Errors produced by the service.

type Future = <S as Service<Request<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.