Trait reqwest_middleware::Middleware

pub trait Middleware: 'static + Send + Sync {
    // Required method
    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;
}

When attached to a ClientWithMiddleware (generally using with), middleware is run whenever the client issues a request, in the order it was attached.

Example

use reqwest::{Client, Request, Response};
use reqwest_middleware::{ClientBuilder, Middleware, Next, Result};
use task_local_extensions::Extensions;

struct TransparentMiddleware;

#[async_trait::async_trait]
impl Middleware for TransparentMiddleware {
    async fn handle(
        &self,
        req: Request,
        extensions: &mut Extensions,
        next: Next<'_>,
    ) -> Result<Response> {
        next.run(req, extensions).await
    }
}

Required Methods

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).

If you need to forward data down the middleware stack, you can use the extensions argument.

Implementors

impl<F> Middleware for F

where F: Send + Sync + 'static + for<'a> Fn(Request, &'a mut Extensions, Next<'a>) -> Pin<Box<dyn Future<Output = Result<Response>> + Send + 'a>>,