move towards using #[rocket::async_trait]

this also upgrades some dependencies
some of that fixes stuff, others breaks stuff.

plume-models/src/admin.rs

@@ -1,42 +1,40 @@
 use crate::users::User;
 use rocket::{
     http::Status,
-    request::{self, FromRequestAsync, Request},
+    request::{self, FromRequest, Request},
     Outcome,
 };
 
 /// Wrapper around User to use as a request guard on pages reserved to admins.
 pub struct Admin(pub User);
 
-impl<'a, 'r> FromRequestAsync<'a, 'r> for Admin {
+#[rocket::async_trait]
+impl<'a, 'r> FromRequest<'a, 'r> for Admin {
     type Error = ();
 
-    fn from_request(request: &'a Request<'r>) -> request::FromRequestFuture<'a, Self, Self::Error> {
-        Box::pin(async move {
-            let user = try_outcome!(User::from_request(request).await);
-            if user.is_admin() {
-                Outcome::Success(Admin(user))
-            } else {
-                Outcome::Failure((Status::Unauthorized, ()))
-            }
-        })
+    async fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+        let user = try_outcome!(User::from_request(request).await);
+        if user.is_admin() {
+            Outcome::Success(Admin(user))
+        } else {
+            Outcome::Failure((Status::Unauthorized, ()))
+        }
     }
 }
 
 /// Same as `Admin` but for moderators.
 pub struct Moderator(pub User);
 
-impl<'a, 'r> FromRequestAsync<'a, 'r> for Moderator {
+#[rocket::async_trait]
+impl<'a, 'r> FromRequest<'a, 'r> for Moderator {
     type Error = ();
 
-    fn from_request(request: &'a Request<'r>) -> request::FromRequestFuture<'a, Self, Self::Error> {
-        Box::pin(async move {
-            let user = try_outcome!(User::from_request(request).await);
-            if user.is_moderator() {
-                Outcome::Success(Moderator(user))
-            } else {
-                Outcome::Failure((Status::Unauthorized, ()))
-            }
-        })
+    async fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+        let user = try_outcome!(User::from_request(request).await);
+        if user.is_moderator() {
+            Outcome::Success(Moderator(user))
+        } else {
+            Outcome::Failure((Status::Unauthorized, ()))
+        }
     }
 }

plume-models/src/api_tokens.rs

@@ -3,7 +3,7 @@ use chrono::NaiveDateTime;
 use diesel::{self, ExpressionMethods, QueryDsl, RunQueryDsl};
 use rocket::{
     http::Status,
-    request::{self, FromRequestAsync, Request},
+    request::{self, FromRequest, Request},
     Outcome,
 };
 
@@ -76,39 +76,38 @@ pub enum TokenError {
     DbError,
 }
 
-impl<'a, 'r> FromRequestAsync<'a, 'r> for ApiToken {
+#[rocket::async_trait]
+impl<'a, 'r> FromRequest<'a, 'r> for ApiToken {
     type Error = TokenError;
 
-    fn from_request(request: &'a Request<'r>) -> request::FromRequestFuture<'a, Self, Self::Error> {
-        Box::pin(async move {
-            let headers: Vec<_> = request.headers().get("Authorization").collect();
-            if headers.len() != 1 {
-                return Outcome::Failure((Status::BadRequest, TokenError::NoHeader));
-            }
+    async fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+        let headers: Vec<_> = request.headers().get("Authorization").collect();
+        if headers.len() != 1 {
+            return Outcome::Failure((Status::BadRequest, TokenError::NoHeader));
+        }
 
-            let mut parsed_header = headers[0].split(' ');
-            if let Some(auth_type) = parsed_header.next() {
-                if let Some(val) = parsed_header.next() {
-                    if auth_type == "Bearer" {
-                        if let Outcome::Success(conn) = DbConn::from_request(request).await {
-                            if let Ok(token) = ApiToken::find_by_value(&*conn, val) {
-                                return Outcome::Success(token);
-                            }
-                        } else {
-                            return Outcome::Failure((
-                                Status::InternalServerError,
-                                TokenError::DbError,
-                            ));
+        let mut parsed_header = headers[0].split(' ');
+        if let Some(auth_type) = parsed_header.next() {
+            if let Some(val) = parsed_header.next() {
+                if auth_type == "Bearer" {
+                    if let Outcome::Success(conn) = DbConn::from_request(request).await {
+                        if let Ok(token) = ApiToken::find_by_value(&*conn, val) {
+                            return Outcome::Success(token);
                         }
+                    } else {
+                        return Outcome::Failure((
+                            Status::InternalServerError,
+                            TokenError::DbError,
+                        ));
                     }
-                } else {
-                    return Outcome::Failure((Status::BadRequest, TokenError::NoValue));
                 }
             } else {
-                return Outcome::Failure((Status::BadRequest, TokenError::NoType));
+                return Outcome::Failure((Status::BadRequest, TokenError::NoValue));
             }
+        } else {
+            return Outcome::Failure((Status::BadRequest, TokenError::NoType));
+        }
 
-            Outcome::Forward(())
-        })
+        Outcome::Forward(())
     }
 }

plume-models/src/db_conn.rs

@@ -6,7 +6,7 @@ use diesel::r2d2::{
 use diesel::{dsl::sql_query, ConnectionError, RunQueryDsl};
 use rocket::{
     http::Status,
-    request::{self, FromRequestAsync},
+    request::{self, FromRequest},
     Outcome, Request,
 };
 use std::ops::Deref;
@@ -21,16 +21,15 @@ pub struct DbConn(pub PooledConnection<ConnectionManager<Connection>>);
 /// Attempts to retrieve a single connection from the managed database pool. If
 /// no pool is currently managed, fails with an `InternalServerError` status. If
 /// no connections are available, fails with a `ServiceUnavailable` status.
-impl<'a, 'r> FromRequestAsync<'a, 'r> for DbConn {
+#[rocket::async_trait]
+impl<'a, 'r> FromRequest<'a, 'r> for DbConn {
     type Error = ();
 
-    fn from_request(request: &'a Request<'r>) -> request::FromRequestFuture<'a, Self, Self::Error> {
-        Box::pin(async move {
-            match DbConn::from_request(request).await {
-                Outcome::Success(a) => return Outcome::Success(a),
-                _ => return Outcome::Failure((Status::ServiceUnavailable, ())),
-            };
-        })
+    async fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+        match DbConn::from_request(request).await {
+            Outcome::Success(a) => return Outcome::Success(a),
+            _ => return Outcome::Failure((Status::ServiceUnavailable, ())),
+        };
     }
 }
 

plume-models/src/headers.rs

@@ -6,10 +6,11 @@ use rocket::{
 
 pub struct Headers<'r>(pub HeaderMap<'r>);
 
+#[rocket::async_trait]
 impl<'a, 'r> FromRequest<'a, 'r> for Headers<'r> {
     type Error = ();
 
-    fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, ()> {
+    async fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, ()> {
         let mut headers = HeaderMap::new();
         for header in request.headers().clone().into_iter() {
             headers.add(header);

plume-models/src/plume_rocket.rs

@@ -4,7 +4,7 @@ pub use self::module::PlumeRocket;
 mod module {
     use crate::{db_conn::DbConn, search, users};
     use rocket::{
-        request::{self, FlashMessage, FromRequestAsync, Request},
+        request::{self, FlashMessage, FromRequest, Request},
         Outcome, State,
     };
     use scheduled_thread_pool::ScheduledThreadPool;
@@ -20,29 +20,38 @@ mod module {
         pub flash_msg: Option<(String, String)>,
     }
 
-    impl<'a, 'r> FromRequestAsync<'a, 'r> for PlumeRocket {
+    #[rocket::async_trait]
+    impl<'a, 'r> FromRequest<'a, 'r> for PlumeRocket {
         type Error = ();
 
-        fn from_request(
-            request: &'a Request<'r>,
-        ) -> request::FromRequestFuture<'a, Self, Self::Error> {
-            Box::pin(async move {
-                let conn = try_outcome!(DbConn::from_request(request).await);
-                let intl = try_outcome!(rocket_i18n::I18n::from_request(request).await);
-                let user = try_outcome!(users::User::from_request(request).await);
-                let worker =
-                    try_outcome!(request.guard::<'_, State<'_, Arc<ScheduledThreadPool>>>());
-                let searcher =
-                    try_outcome!(request.guard::<'_, State<'_, Arc<search::Searcher>>>());
-                let flash_msg = request.guard::<FlashMessage<'_, '_>>().succeeded();
-                Outcome::Success(PlumeRocket {
-                    conn,
-                    intl,
-                    user: Some(user),
-                    flash_msg: flash_msg.map(|f| (f.name().into(), f.msg().into())),
-                    worker: worker.clone(),
-                    searcher: searcher.clone(),
-                })
+        async fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+            let conn = DbConn::from_request(request).await.succeeded().unwrap();
+            let intl = rocket_i18n::I18n::from_request(request)
+                .await
+                .succeeded()
+                .unwrap();
+            let user = users::User::from_request(request)
+                .await
+                .succeeded()
+                .unwrap();
+            let worker = request
+                .guard::<State<'_, Arc<ScheduledThreadPool>>>()
+                .await
+                .succeeded()
+                .unwrap();
+            let searcher = request
+                .guard::<State<'_, Arc<search::Searcher>>>()
+                .await
+                .succeeded()
+                .unwrap();
+            let flash_msg = request.guard::<FlashMessage<'_, '_>>().await.succeeded();
+            Outcome::Success(PlumeRocket {
+                conn,
+                intl,
+                user: Some(user),
+                flash_msg: flash_msg.map(|f| (f.name().into(), f.msg().into())),
+                worker: worker.clone(),
+                searcher: searcher.clone(),
             })
         }
     }
@@ -52,7 +61,7 @@ mod module {
 mod module {
     use crate::{db_conn::DbConn, search, users};
     use rocket::{
-        request::{self, FromRequestAsync, Request},
+        request::{self, FromRequest, Request},
         Outcome, State,
     };
     use scheduled_thread_pool::ScheduledThreadPool;
@@ -66,25 +75,20 @@ mod module {
         pub worker: Arc<ScheduledThreadPool>,
     }
 
-    impl<'a, 'r> FromRequestAsync<'a, 'r> for PlumeRocket {
+    #[rocket::async_trait]
+    impl<'a, 'r> FromRequest<'a, 'r> for PlumeRocket {
         type Error = ();
 
-        fn from_request(
-            request: &'a Request<'r>,
-        ) -> request::FromRequestFuture<'a, Self, Self::Error> {
-            Box::pin(async move {
-                let conn = try_outcome!(DbConn::from_request(request).await);
-                let user = try_outcome!(users::User::from_request(request).await);
-                let worker =
-                    try_outcome!(request.guard::<'_, State<'_, Arc<ScheduledThreadPool>>>());
-                let searcher =
-                    try_outcome!(request.guard::<'_, State<'_, Arc<search::Searcher>>>());
-                Outcome::Success(PlumeRocket {
-                    conn,
-                    user: Some(user),
-                    worker: worker.clone(),
-                    searcher: searcher.clone(),
-                })
+        async fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+            let conn = try_outcome!(DbConn::from_request(request).await);
+            let user = try_outcome!(users::User::from_request(request).await);
+            let worker = try_outcome!(request.guard::<'_, State<'_, Arc<ScheduledThreadPool>>>());
+            let searcher = try_outcome!(request.guard::<'_, State<'_, Arc<search::Searcher>>>());
+            Outcome::Success(PlumeRocket {
+                conn,
+                user: Some(user),
+                worker: worker.clone(),
+                searcher: searcher.clone(),
             })
         }
     }

plume-models/src/users.rs

@@ -35,7 +35,7 @@ use reqwest::{
 };
 use rocket::{
     outcome::IntoOutcome,
-    request::{self, FromRequestAsync, Request},
+    request::{self, FromRequest, Request},
 };
 use serde_json;
 use std::{
@@ -796,19 +796,18 @@ impl User {
     }
 }
 
-impl<'a, 'r> FromRequestAsync<'a, 'r> for User {
+#[rocket::async_trait]
+impl<'a, 'r> FromRequest<'a, 'r> for User {
     type Error = ();
 
-    fn from_request(request: &'a Request<'r>) -> request::FromRequestFuture<'a, Self, Self::Error> {
-        Box::pin(async move {
-            let conn = try_outcome!(DbConn::from_request(request).await);
-            request
-                .cookies()
-                .get_private(AUTH_COOKIE)
-                .and_then(|cookie| cookie.value().parse().ok())
-                .and_then(|id| User::get(&*conn, id).ok())
-                .or_forward(())
-        })
+    async fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+        let conn = try_outcome!(DbConn::from_request(request).await);
+        request
+            .cookies()
+            .get_private(AUTH_COOKIE)
+            .and_then(|cookie| cookie.value().parse().ok())
+            .and_then(|id| User::get(&*conn, id).ok())
+            .or_forward(())
     }
 }