refactor: move tokenserver's Db to async-trait (#1799)

Closes STOR-142

Author: pjenvey

tokenserver-db/src/error.rs

@@ -7,7 +7,6 @@ use syncserver_db_common::error::SqlError;
 use thiserror::Error;
 use tokenserver_common::TokenserverError;
 
-pub(crate) type DbFuture<'a, T> = syncserver_db_common::DbFuture<'a, T, DbError>;
 pub(crate) type DbResult<T> = Result<T, DbError>;
 
 /// An error type that represents any database-related errors that may occur while processing a

tokenserver-db/src/lib.rs

@@ -13,15 +13,3 @@ pub mod results;
 
 pub use models::{Db, TokenserverDb};
 pub use pool::{DbPool, TokenserverPool};
-
-#[macro_export]
-macro_rules! async_db_method {
-    ($name:ident, $async_name:path, $type:ident) => {
-        async_db_method!($name, $async_name, $type, results::$type);
-    };
-    ($name:ident, $async_name:path, $type:ident, $result:ty) => {
-        fn $name(&mut self, params: params::$type) -> DbFuture<'_, $result, DbError> {
-            Box::pin($async_name(self, params))
-        }
-    };
-}

tokenserver-db/src/mock.rs

@@ -1,10 +1,9 @@
 #![allow(clippy::new_without_default)]
 
 use async_trait::async_trait;
-use futures::future;
 use syncserver_db_common::{GetPoolState, PoolState};
 
-use super::error::{DbError, DbFuture};
+use super::error::DbError;
 use super::models::Db;
 use super::params;
 use super::pool::DbPool;
@@ -49,112 +48,125 @@ impl MockDb {
     }
 }
 
+#[async_trait(?Send)]
 impl Db for MockDb {
-    fn replace_user(&mut self, _params: params::ReplaceUser) -> DbFuture<'_, results::ReplaceUser> {
-        Box::pin(future::ok(()))
+    async fn replace_user(
+        &mut self,
+        _params: params::ReplaceUser,
+    ) -> Result<results::ReplaceUser, DbError> {
+        Ok(())
     }
 
-    fn replace_users(
+    async fn replace_users(
         &mut self,
         _params: params::ReplaceUsers,
-    ) -> DbFuture<'_, results::ReplaceUsers> {
-        Box::pin(future::ok(()))
+    ) -> Result<results::ReplaceUsers, DbError> {
+        Ok(())
     }
 
-    fn post_user(&mut self, _params: params::PostUser) -> DbFuture<'_, results::PostUser> {
-        Box::pin(future::ok(results::PostUser::default()))
+    async fn post_user(&mut self, _params: params::PostUser) -> Result<results::PostUser, DbError> {
+        Ok(results::PostUser::default())
     }
 
-    fn put_user(&mut self, _params: params::PutUser) -> DbFuture<'_, results::PutUser> {
-        Box::pin(future::ok(()))
+    async fn put_user(&mut self, _params: params::PutUser) -> Result<results::PutUser, DbError> {
+        Ok(())
     }
 
-    fn check(&mut self) -> DbFuture<'_, results::Check> {
-        Box::pin(future::ok(true))
+    async fn check(&mut self) -> Result<results::Check, DbError> {
+        Ok(true)
     }
 
-    fn get_node_id(&mut self, _params: params::GetNodeId) -> DbFuture<'_, results::GetNodeId> {
-        Box::pin(future::ok(results::GetNodeId::default()))
+    async fn get_node_id(
+        &mut self,
+        _params: params::GetNodeId,
+    ) -> Result<results::GetNodeId, DbError> {
+        Ok(results::GetNodeId::default())
     }
 
-    fn get_best_node(
+    async fn get_best_node(
         &mut self,
         _params: params::GetBestNode,
-    ) -> DbFuture<'_, results::GetBestNode> {
-        Box::pin(future::ok(results::GetBestNode::default()))
+    ) -> Result<results::GetBestNode, DbError> {
+        Ok(results::GetBestNode::default())
     }
 
-    fn add_user_to_node(
+    async fn add_user_to_node(
         &mut self,
         _params: params::AddUserToNode,
-    ) -> DbFuture<'_, results::AddUserToNode> {
-        Box::pin(future::ok(()))
+    ) -> Result<results::AddUserToNode, DbError> {
+        Ok(())
     }
 
-    fn get_users(&mut self, _params: params::GetUsers) -> DbFuture<'_, results::GetUsers> {
-        Box::pin(future::ok(results::GetUsers::default()))
+    async fn get_users(&mut self, _params: params::GetUsers) -> Result<results::GetUsers, DbError> {
+        Ok(results::GetUsers::default())
     }
 
-    fn get_or_create_user(
+    async fn get_or_create_user(
         &mut self,
         _params: params::GetOrCreateUser,
-    ) -> DbFuture<'_, results::GetOrCreateUser> {
-        Box::pin(future::ok(results::GetOrCreateUser::default()))
+    ) -> Result<results::GetOrCreateUser, DbError> {
+        Ok(results::GetOrCreateUser::default())
     }
 
-    fn get_service_id(
+    async fn get_service_id(
         &mut self,
         _params: params::GetServiceId,
-    ) -> DbFuture<'_, results::GetServiceId> {
-        Box::pin(future::ok(results::GetServiceId::default()))
+    ) -> Result<results::GetServiceId, DbError> {
+        Ok(results::GetServiceId::default())
     }
 
     #[cfg(test)]
-    fn set_user_created_at(
+    async fn set_user_created_at(
         &mut self,
         _params: params::SetUserCreatedAt,
-    ) -> DbFuture<'_, results::SetUserCreatedAt> {
-        Box::pin(future::ok(()))
+    ) -> Result<results::SetUserCreatedAt, DbError> {
+        Ok(())
     }
 
     #[cfg(test)]
-    fn set_user_replaced_at(
+    async fn set_user_replaced_at(
         &mut self,
         _params: params::SetUserReplacedAt,
-    ) -> DbFuture<'_, results::SetUserReplacedAt> {
-        Box::pin(future::ok(()))
+    ) -> Result<results::SetUserReplacedAt, DbError> {
+        Ok(())
     }
 
     #[cfg(test)]
-    fn get_user(&mut self, _params: params::GetUser) -> DbFuture<'_, results::GetUser> {
-        Box::pin(future::ok(results::GetUser::default()))
+    async fn get_user(&mut self, _params: params::GetUser) -> Result<results::GetUser, DbError> {
+        Ok(results::GetUser::default())
     }
 
     #[cfg(test)]
-    fn post_node(&mut self, _params: params::PostNode) -> DbFuture<'_, results::PostNode> {
-        Box::pin(future::ok(results::PostNode::default()))
+    async fn post_node(&mut self, _params: params::PostNode) -> Result<results::PostNode, DbError> {
+        Ok(results::PostNode::default())
     }
 
     #[cfg(test)]
-    fn get_node(&mut self, _params: params::GetNode) -> DbFuture<'_, results::GetNode> {
-        Box::pin(future::ok(results::GetNode::default()))
+    async fn get_node(&mut self, _params: params::GetNode) -> Result<results::GetNode, DbError> {
+        Ok(results::GetNode::default())
     }
 
     #[cfg(test)]
-    fn unassign_node(
+    async fn unassign_node(
         &mut self,
         _params: params::UnassignNode,
-    ) -> DbFuture<'_, results::UnassignNode> {
-        Box::pin(future::ok(()))
+    ) -> Result<results::UnassignNode, DbError> {
+        Ok(())
     }
 
     #[cfg(test)]
-    fn remove_node(&mut self, _params: params::RemoveNode) -> DbFuture<'_, results::RemoveNode> {
-        Box::pin(future::ok(()))
+    async fn remove_node(
+        &mut self,
+        _params: params::RemoveNode,
+    ) -> Result<results::RemoveNode, DbError> {
+        Ok(())
     }
 
     #[cfg(test)]
-    fn post_service(&mut self, _params: params::PostService) -> DbFuture<'_, results::PostService> {
-        Box::pin(future::ok(results::PostService::default()))
+    async fn post_service(
+        &mut self,
+        _params: params::PostService,
+    ) -> Result<results::PostService, DbError> {
+        Ok(results::PostService::default())
     }
 }