Obtaining FromRequest values manually

[sazzer]

Hi there,

I've got a custom type that I've written and implemented FromRequest, which means that I can receive an instance of it as a parameter to my handlers just fine.

Is there any mechanism to do this when not in a handler though? Specifically, I'm wanting to do this in a Responder implementation and can't see any way to do this - both because the from_request() method is async and because it needs both the HttpRequest and Payload.

(For additional detail, my custom FromRequest type is the authorization details of the user, and my Responder that wants to use it is because it will render differently depending on if and how the client is authorized.)

In case it matters, this is using:

• actix-rt = "2.2.0"
• actix-service = "2.0.0"
• actix-web = "=4.0.0-beta.18"
• actix-cors = "=0.6.0-beta.8"
• actix-http = "=3.0.0-beta.17"

Cheers

[aliemjay]

If you want a dummy payload, you can use Payload::None.

One solution is to simplify you responder type to do the async processing inside the handler. This is the easiest solution.

If you REALLY need async Responder, you can achieve this with a middleware that posprocesses the response. You can pass arbitrary data from the responder impl to middleware using HttpResponse::extensions and there you can grab the payload, and do async posprocessing.

impl Responder for MyResponsder {
fn respond_to(self) {
  HttpResponse::new().extensions_mut().insert(self)
}
}

App::new()
.wrap_fn(|req, srv| {
  let fut = srv.call(req);
  async move {
    let resp = fut.await?;
    let my_responder  = req.extensions().remove::<MyResponder>();
    if let Some(my) = my_responder {
      // modify the response in async environ with payload
    } else {
      Ok(resp)
    }
  }
}

[sazzer]

Hmm - that's an interesting thought. Might look into that.

Why would it cost type safety though? Looks like
req.req_data().get::<Authorization>() is typesafe to me?

Cheers

[aliemjay]

I mean you don't get a compile error when using the responder without setting the handler paramter. Nothing I' would care about really.

[sazzer]

Ok, so this is my inexperience with Lifetimes, Async and Futures showing through I'm certain, but I can't work out how to be able to manipulate the HttpRequest in as Async Middleware :(

What I've got working so far is:

impl<S, B> Service<ServiceRequest> for MiddlewareImpl<S>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,

    B: MessageBody + 'static,
    B::Error: Into<Error>,
{
    type Response = ServiceResponse<EitherBody<B>>;
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<ServiceResponse<EitherBody<B>>, Error>>;

    actix_service::forward_ready!(service);

    fn call(&self, req: ServiceRequest) -> Self::Future {
        req.req_data_mut().insert(Authorization::Unauthorized);

        let fut = self.service.call(req);

        async move {
            let res = fut.await;

            res.map_err(Into::into).map(|res| res.map_into_left_body())
        }
        .boxed_local()
    }
}

And that works, and lets me access req.req_data().get::<Authorization>() correctly.

However, actually authorizing a request is an async process - since it needs to potentially fetch a JWKSet to verify the token - so I'd want to do that inside the async block. But if I try that then it all fails:

impl<S, B> Service<ServiceRequest> for MiddlewareImpl<S>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,

    B: MessageBody + 'static,
    B::Error: Into<Error>,
{
    type Response = ServiceResponse<EitherBody<B>>;
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<ServiceResponse<EitherBody<B>>, Error>>;

    actix_service::forward_ready!(service);

    fn call(&self, req: ServiceRequest) -> Self::Future {
        async move {
            req.req_data_mut().insert(Authorization::Unauthorized);

            let res = self.service.call(req).await;

            res.map_err(Into::into).map(|res| res.map_into_left_body())
        }
        .boxed_local()
    }
}

-----
error[E0759]: `self` has an anonymous lifetime `'_` but it needs to satisfy a `'static` lifetime requirement
  --> src/adapters/primary/http/authorization.rs:88:20
   |
87 |       fn call(&self, req: ServiceRequest) -> Self::Future {
   |               ----- this data with an anonymous lifetime `'_`...
88 |           async move {
   |  ____________________^
89 | |             req.req_data_mut().insert(Authorization::Unauthorized);
90 | |
91 | |             let res = self.service.call(req).await;
92 | |
93 | |             res.map_err(Into::into).map(|res| res.map_into_left_body())
94 | |         }
   | |_________^ ...is used and required to live as long as `'static` here
   |
note: `'static` lifetime requirement introduced by the return type
  --> src/adapters/primary/http/authorization.rs:87:44
   |
87 |       fn call(&self, req: ServiceRequest) -> Self::Future {
   |                                              ^^^^^^^^^^^^ requirement introduced by this return type
88 | /         async move {
89 | |             req.req_data_mut().insert(Authorization::Unauthorized);
90 | |
91 | |             let res = self.service.call(req).await;
...  |
94 | |         }
95 | |         .boxed_local()
   | |______________________- because of this returned expression

Does anyone happen to have any examples/pointers of how to do this? I'm sure it's probably easy if I can just work out this error! :(

Cheers

[aliemjay]

The future can't capture &self (because we don't yet have GAT feature on stable rust). The typical solution is to extract owned data from self outside the future and the move into the future or alternatively make Self cheaply cloneable (such as by Rc) and then

let this  = self.clone();
async move { self; }

[sazzer]

I'd literally just come to the same solution :) Amazing what getting away from the keyboard can do to help!

Thanks :)