Struct AuthorizationHeaderMiddleware

pub struct AuthorizationHeaderMiddleware { /* private fields */ }

AuthorizationHeaderMiddleware

Provided a TokenSource implementation, this middleware will set the Authorization header of the request with the token value obtained from this token source.

The token source is expected to provide a valid token (e.g including renewal), or an error if the token could not be obtained.

How to use

 use reqwest_middleware::ClientBuilder;
 use token_source::{TokenSource, TokenSourceProvider};
 use std::sync::Arc;
 use reqwest_auth::AuthorizationHeaderMiddleware;
  
 // In real cases you should have a token source provider
 // that provides a token source implementation.
 // Here we are using a simple example with a hardcoded token value.

 // For demonstration purposes.
 #[derive(Debug)]
 struct MyTokenSource {
   pub token: String,
 }

 // For demonstration purposes.
 #[async_trait::async_trait]
 impl TokenSource for MyTokenSource {
   async fn token(&self) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
      Ok(self.token.clone())
   }
 }

 // For demonstration purposes.
 #[derive(Debug)]
 struct MyTokenProvider {
   pub ts: Arc<MyTokenSource>,
 }

 // For demonstration purposes.
 impl TokenSourceProvider for MyTokenProvider {
   fn token_source(&self) -> Arc<dyn TokenSource> {
     self.ts.clone()
   }
 }

 // For demonstration purposes.
 let ts_provider = MyTokenProvider {
   ts: Arc::new(MyTokenSource {
     token: "Bearer my-token".to_string(),
   }),
 };

 // Create the middleware from the token source
 let auth_middleware = AuthorizationHeaderMiddleware::from(ts_provider.token_source());

 // Create your reqwest client with the middleware
 let client = ClientBuilder::new(reqwest::Client::default())
   // Ideally, the authorization middleware should come last,
   // especially if you are using a retry middleware as well.
   // This way, your retry requests will benefit from the renewals of the token,
   // as long as your token source implementation is able to renew the token.
   .with(auth_middleware)
   .build();

Trait Implementations

impl From<Arc<dyn TokenSource>> for AuthorizationHeaderMiddleware

fn from(ts: Arc<dyn TokenSource>) -> Self

Converts to this type from the input type.

impl From<Box<dyn TokenSource>> for AuthorizationHeaderMiddleware

fn from(ts: Box<dyn TokenSource>) -> Self

Converts to this type from the input type.

impl Middleware for AuthorizationHeaderMiddleware

fn handle<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, req: Request, extensions: &'life1 mut Extensions, next: Next<'life2>, ) -> Pin<Box<dyn Future<Output = Result<Response>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Invoked with a request before sending it. If you want to continue processing the request, you should explicitly call next.run(req, extensions).