Lifetime issues when calling async function from request in extractor

[shotor]

New to Rust and don't understand lifetimes very well yet. I'm trying to implement user auth, with active and return cookies.

I have a TokenService in the request context that can validate the cookies. This service is added to the request context. It's async.

I can extract the cookies from the request by implementing the FromRequest trait. But as soon as I try to call the TokenService, I get lifetime issues. I tried using Box::pin as per this SO: https://stackoverflow.com/questions/63308246/how-to-use-async-code-in-actix-web-extractors. But I get an error that request doesn't satisfy the lifetime requirements. Trying to add 'static anywhere throws even more errors.

Questions:

• What's the recommended way to do this? Parse 2 cookies (active, return) from the request, validate them against a service. And access the result in route handlers. Extractor, middleware, other?
• If this is the recommended way: How do you call an async service from the request context in an extractor?

The error:

error[E0759]: `req` has an anonymous lifetime `'_` but it needs to satisfy a `'static` lifetime requirement
  --> server/src/context.rs:20:23
   |
19 |     fn from_request(req: &HttpRequest, _: &mut dev::Payload) -> Self::Future {
   |                          ------------ this data with an anonymous lifetime `'_`...
20 |       let service = req.app_data::<TokenService>().unwrap().clone();
   |                     --- ^^^^^^^^
   |                     |
   |                     ...is captured here...
21 | 
22 | /     Box::pin(async move {
23 | |       let from_headers = match req.headers().get("cookie") {
24 | |         Some(cookie) => cookie,
25 | |         None => {
...  |
61 | |       };
62 | |     })
   | |______- ...and is required to live as long as `'static` here

The code:

use crate::modules::auth::services::TokenService;
use actix_web::{cookie, dev, Error, FromRequest, HttpRequest};
use async_std::task;
use chrono::{DateTime, Utc};
use futures_util::future::{err, ok, Future, Ready};
use std::pin::Pin;

pub struct Token {
  pub user_id: i32,
  pub value: String,
  pub expires: DateTime<Utc>,
}

impl FromRequest for Token {
  type Error = Error;
  type Future = Pin<Box<dyn Future<Output = Result<Self, Self::Error>>>>;

  type Config = ();

  fn from_request(req: &HttpRequest, _: &mut dev::Payload) -> Self::Future {
    // req doesn't satisfy lifetime requirement
    let service = req.app_data::<TokenService>().unwrap().clone();

    Box::pin(async move {
      let from_headers = match req.headers().get("cookie") {
        Some(cookie) => cookie,
        None => {
          return Err(actix_web::error::ErrorForbidden(format!(
            "Authentication Cookie Not Found"
          )))
        }
      };

      let as_str = match from_headers.to_str() {
        Ok(cookie) => cookie,
        Err(_) => {
          return Err(actix_web::error::ErrorForbidden(format!(
            "Invalid Cookie"
          )))
        }
      };

      let parsed = match cookie::Cookie::parse(as_str) {
        Ok(cookie) => cookie,
        Err(_) => {
          return Err(actix_web::error::ErrorForbidden(format!(
            "Invalid Cookie"
          )))
        }
      };

      let token_result = service.validate(format!("test")).await;

      return match token_result {
        Ok(token) => Ok(Token {
          expires: token.expires,
          user_id: token.user_id,
          value: token.value,
        }),
        Err(_) => {
          Err(actix_web::error::ErrorForbidden(format!("Invalid Cookie")))
        }
      };
    })
  }
}

[robjtede]

HttpRequest is cheap to clone and will give you the 'static lifetime needed to use it (or it's parts) in the async block.

Your approach looks fine.

[robjtede]

Async traits are a weak part of Rust right now so don't feel bad for needing help here.

[shotor]

Wow, that works! So anything constructed in a higher scope is considered borrowing. Cloning has no effect on that.

edit: No worries, I feel like a beginner again. But it's a lot of fun to learn Rust. Thanks for the quick response!

[robjtede]

I didn't check but I suspect that the clone there is actually invoking this clone: https://doc.rust-lang.org/1.51.0/std/clone/trait.Clone.html#method.clone-133 a &T -> &T clone. The ambiguity is cleared up using the syntax I showed.

[shotor]

For my understanding, is it possible to tell the rust compiler which clone to use? Something like

req.clone<HttpRequest>()

// or

HttpRequest::clone(req)

[robjtede]

Yeah you'll see things like this (HttpRequest::clone(&req)) sometimes; especially with Rc and Arc.