migrate to axum

backend/Cargo.toml

@@ -6,8 +6,12 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-rocket = { version= "0.5.0-rc.1", features = ["json"] }
+tokio = { version = "1.15", features = ["full"] }
-diesel = { version = "1.4.4", features = ["postgres", "r2d2", "chrono"] }
+hyper = "0.14"
+axum = { version = "0.4", features = ["json", "headers"] }
+diesel = { version = "1.4.4", features = ["postgres", "chrono"] }
+bb8 = "0.7"
+bb8-diesel = "0.2"
 dotenv = "0.15.0"
 rust-argon2 = "0.8"
 rand = "0.8.4"
@@ -18,10 +22,5 @@ serde_json = "1.0"
 base64 = "0.13.0"
 zip = "0.5"
 
-
-[dependencies.rocket_sync_db_pools]
-version = "0.1.0-rc.1"
-features = ["diesel_postgres_pool"]
-
 [dev-dependencies]
 parking_lot = "0.11"

backend/src/db/bots.rs

@@ -2,7 +2,6 @@ use diesel::prelude::*;
 use serde::{Deserialize, Serialize};
 
 use crate::schema::{bots, code_bundles};
-use crate::DbConn;
 use chrono;
 
 #[derive(Insertable)]

backend/src/db/users.rs

@@ -1,4 +1,4 @@
-use crate::{schema::users, DbConn};
+use crate::schema::users;
 use argon2;
 use diesel::{prelude::*, PgConnection};
 use rand::Rng;

backend/src/lib.rs

@@ -1,10 +1,5 @@
 #![feature(proc_macro_hygiene, decl_macro)]
 
-use rocket::{Build, Rocket};
-use rocket_sync_db_pools::database;
-
-#[macro_use]
-extern crate rocket;
 #[macro_use]
 extern crate diesel;
 
@@ -12,27 +7,79 @@ pub mod db;
 pub mod routes;
 pub mod schema;
 
-#[database("postgresql_database")]
+use std::ops::Deref;
-pub struct DbConn(diesel::PgConnection);
 
-#[get("/")]
+use axum;
-fn index() -> &'static str {
+use bb8::PooledConnection;
+use bb8_diesel::{self, DieselConnectionManager};
+use diesel::PgConnection;
+
+use axum::{
+    async_trait,
+    extract::{Extension, FromRequest, RequestParts},
+    http::StatusCode,
+    routing::{get, post},
+    AddExtensionLayer, Router,
+};
+
+async fn index_handler() -> &'static str {
     "Hello, world!"
 }
 
-pub fn rocket() -> Rocket<Build> {
+type ConnectionPool = bb8::Pool<DieselConnectionManager<PgConnection>>;
-    rocket::build()
+
-        .mount(
+pub async fn app() -> Router {
-            "/",
+    let database_url = "postgresql://planetwars:planetwars@localhost/planetwars";
-            routes![
+    let manager = DieselConnectionManager::<PgConnection>::new(database_url);
-                index,
+    let pool = bb8::Pool::builder().build(manager).await.unwrap();
-                routes::users::register,
+
-                routes::users::login,
+    let app = Router::new()
-                routes::users::current_user,
+        .route("/", get(index_handler))
-                routes::bots::create_bot,
+        .route("/users/register", post(routes::users::register))
-                routes::bots::get_bot,
+        .route("/users/login", post(routes::users::login))
-                routes::bots::upload_bot_code,
+        .route("/users/me", get(routes::users::current_user))
-            ],
+        .route("/bots", post(routes::bots::create_bot))
-        )
+        .route("/bots/:bot_id", get(routes::bots::get_bot))
-        .attach(DbConn::fairing())
+        .route("/bots/:bot_id/upload", post(routes::bots::upload_bot_code))
+        .layer(AddExtensionLayer::new(pool));
+    app
+}
+
+// we can also write a custom extractor that grabs a connection from the pool
+// which setup is appropriate depends on your application
+pub struct DatabaseConnection(PooledConnection<'static, DieselConnectionManager<PgConnection>>);
+
+impl Deref for DatabaseConnection {
+    type Target = PooledConnection<'static, DieselConnectionManager<PgConnection>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[async_trait]
+impl<B> FromRequest<B> for DatabaseConnection
+where
+    B: Send,
+{
+    type Rejection = (StatusCode, String);
+
+    async fn from_request(req: &mut RequestParts<B>) -> Result<Self, Self::Rejection> {
+        let Extension(pool) = Extension::<ConnectionPool>::from_request(req)
+            .await
+            .map_err(internal_error)?;
+
+        let conn = pool.get_owned().await.map_err(internal_error)?;
+
+        Ok(Self(conn))
+    }
+}
+
+/// Utility function for mapping any error into a `500 Internal Server Error`
+/// response.
+fn internal_error<E>(err: E) -> (StatusCode, String)
+where
+    E: std::error::Error,
+{
+    (StatusCode::INTERNAL_SERVER_ERROR, err.to_string())
 }

backend/src/main.rs

@@ -1,8 +1,16 @@
-#[macro_use]
+use std::net::SocketAddr;
-extern crate rocket;
-extern crate mozaic4_backend;
 
-#[launch]
+extern crate mozaic4_backend;
-fn launch() -> rocket::Rocket<rocket::Build> {
+extern crate tokio;
-    mozaic4_backend::rocket()
+
+#[tokio::main]
+async fn main() {
+    let app = mozaic4_backend::app().await;
+
+    let addr = SocketAddr::from(([127, 0, 0, 1], 9000));
+
+    axum::Server::bind(&addr)
+        .serve(app.into_make_service())
+        .await
+        .unwrap();
 }

backend/src/routes/bots.rs

@@ -1,16 +1,14 @@
+use axum::extract::{Path, RawBody};
+use axum::http::StatusCode;
+use axum::Json;
 use rand::Rng;
-use rocket::data::ToByteUnit;
-use rocket::fs::TempFile;
-use rocket::Data;
-use rocket::{response::status, serde::json::Json};
 use serde::{Deserialize, Serialize};
 use std::io::Cursor;
-use std::path::Path;
+use std::path;
-
-use crate::DbConn;
 
 use crate::db::bots::{self, CodeBundle};
 use crate::db::users::User;
+use crate::DatabaseConnection;
 use bots::Bot;
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -18,52 +16,36 @@ pub struct BotParams {
     name: String,
 }
 
-// TODO: handle errors
-#[post("/bots", data = "<params>")]
 pub async fn create_bot(
-    db_conn: DbConn,
+    conn: DatabaseConnection,
     user: User,
     params: Json<BotParams>,
-) -> status::Created<Json<Bot>> {
+) -> (StatusCode, Json<Bot>) {
-    db_conn
-        .run(move |conn| {
     let bot_params = bots::NewBot {
         owner_id: user.id,
         name: &params.name,
     };
-            let bot = bots::create_bot(&bot_params, conn).unwrap();
+    let bot = bots::create_bot(&bot_params, &conn).unwrap();
-            let bot_url = uri!(get_bot(bot.id)).to_string();
+    (StatusCode::CREATED, Json(bot))
-            status::Created::new(bot_url).body(Json(bot))
-        })
-        .await
 }
 
 // TODO: handle errors
-#[get("/bots/<bot_id>")]
+pub async fn get_bot(conn: DatabaseConnection, Path(bot_id): Path<i32>) -> Json<Bot> {
-pub async fn get_bot(db_conn: DbConn, bot_id: i32) -> Json<Bot> {
+    let bot = bots::find_bot(bot_id, &conn).unwrap();
-    db_conn
-        .run(move |conn| {
-            let bot = bots::find_bot(bot_id, conn).unwrap();
     Json(bot)
-        })
-        .await
 }
 
 // TODO: proper error handling
-#[post("/bots/<bot_id>/upload", data = "<data>")]
 pub async fn upload_bot_code(
-    db_conn: DbConn,
+    conn: DatabaseConnection,
     user: User,
-    bot_id: i32,
+    Path(bot_id): Path<i32>,
-    data: Data<'_>,
+    RawBody(body): RawBody,
-) -> status::Created<Json<CodeBundle>> {
+) -> (StatusCode, Json<CodeBundle>) {
     // TODO: put in config somewhere
     let data_path = "./data/bots";
 
-    let bot = db_conn
+    let bot = bots::find_bot(bot_id, &conn).expect("Bot not found");
-        .run(move |conn| bots::find_bot(bot_id, conn))
-        .await
-        .expect("Bot not found");
 
     assert_eq!(user.id, bot.owner_id);
 
@@ -71,26 +53,23 @@ pub async fn upload_bot_code(
     let token: [u8; 16] = rand::thread_rng().gen();
     let name = base64::encode(&token);
 
-    let path = Path::new(data_path).join(name);
+    let path = path::Path::new(data_path).join(name);
-    let capped_buf = data.open(10usize.megabytes()).into_bytes().await.unwrap();
+    // let capped_buf = data.open(10usize.megabytes()).into_bytes().await.unwrap();
-    assert!(capped_buf.is_complete());
+    // assert!(capped_buf.is_complete());
-    let buf = capped_buf.into_inner();
+    // let buf = capped_buf.into_inner();
+    let buf = hyper::body::to_bytes(body).await.unwrap();
 
     zip::ZipArchive::new(Cursor::new(buf))
         .unwrap()
         .extract(&path)
         .unwrap();
 
-    let code_bundle = db_conn
-        .run(move |conn| {
     let bundle = bots::NewCodeBundle {
         bot_id: bot.id,
         path: path.to_str().unwrap(),
     };
-            bots::create_code_bundle(&bundle, conn).expect("Failed to create code bundle")
+    let code_bundle =
-        })
+        bots::create_code_bundle(&bundle, &conn).expect("Failed to create code bundle");
-        .await;
 
-    // TODO: proper location
+    (StatusCode::CREATED, Json(code_bundle))
-    status::Created::new("").body(Json(code_bundle))
 }

backend/src/routes/users.rs

@@ -1,48 +1,32 @@
+use crate::db::users::{Credentials, User};
 use crate::db::{sessions, users};
-use crate::{
+use crate::DatabaseConnection;
-    db::users::{Credentials, User},
+use axum::extract::{FromRequest, RequestParts, TypedHeader};
-    DbConn,
+use axum::headers::authorization::Bearer;
-};
+use axum::headers::Authorization;
-use rocket::serde::json::Json;
+use axum::http::StatusCode;
+use axum::{async_trait, Json};
 use serde::{Deserialize, Serialize};
 
-use rocket::http::Status;
+type AuthorizationHeader = TypedHeader<Authorization<Bearer>>;
-use rocket::request::{FromRequest, Outcome, Request};
-use rocket::response::status;
 
-#[derive(Debug)]
+#[async_trait]
-pub enum AuthTokenError {
+impl<B> FromRequest<B> for User
-    BadCount,
+where
-    Missing,
+    B: Send,
-    Invalid,
+{
-}
+    type Rejection = (StatusCode, String);
 
-// TODO: error handling and proper lifetimes
+    async fn from_request(req: &mut RequestParts<B>) -> Result<Self, Self::Rejection> {
-#[rocket::async_trait]
+        let conn = DatabaseConnection::from_request(req).await?;
-impl<'r> FromRequest<'r> for User {
+        let TypedHeader(Authorization(bearer)) = AuthorizationHeader::from_request(req)
-    type Error = AuthTokenError;
+            .await
+            .map_err(|_| (StatusCode::UNAUTHORIZED, "".to_string()))?;
 
-    async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self::Error> {
+        let (_session, user) = sessions::find_user_by_session(bearer.token(), &conn)
-        let keys: Vec<_> = request.headers().get("Authorization").collect();
+            .map_err(|_| (StatusCode::UNAUTHORIZED, "".to_string()))?;
-        let auth_header = match keys.len() {
-            0 => return Outcome::Failure((Status::BadRequest, AuthTokenError::Missing)),
-            1 => keys[0],
-            _ => return Outcome::Failure((Status::BadRequest, AuthTokenError::BadCount)),
-        };
 
-        let token = match auth_header.strip_prefix("Bearer ") {
+        Ok(user)
-            Some(token) => token.to_string(),
-            None => return Outcome::Failure((Status::BadRequest, AuthTokenError::Invalid)),
-        };
-
-        let db = request.guard::<DbConn>().await.unwrap();
-        let res = db
-            .run(move |conn| sessions::find_user_by_session(&token, conn))
-            .await;
-        match res {
-            Ok((_session, user)) => Outcome::Success(user),
-            Err(_) => Outcome::Failure((Status::Unauthorized, AuthTokenError::Invalid)),
-        }
     }
 }
 
@@ -67,18 +51,16 @@ pub struct RegistrationParams {
     pub password: String,
 }
 
-#[post("/register", data = "<params>")]
+pub async fn register(
-pub async fn register(db_conn: DbConn, params: Json<RegistrationParams>) -> Json<UserData> {
+    conn: DatabaseConnection,
-    db_conn
+    params: Json<RegistrationParams>,
-        .run(move |conn| {
+) -> Json<UserData> {
     let credentials = Credentials {
         username: &params.username,
         password: &params.password,
     };
-            let user = users::create_user(&credentials, conn).unwrap();
+    let user = users::create_user(&credentials, &conn).unwrap();
     Json(user.into())
-        })
-        .await
 }
 
 #[derive(Deserialize)]
@@ -87,32 +69,26 @@ pub struct LoginParams {
     pub password: String,
 }
 
-#[post("/login", data = "<params>")]
 pub async fn login(
-    db_conn: DbConn,
+    conn: DatabaseConnection,
     params: Json<LoginParams>,
-) -> Result<String, status::Forbidden<&'static str>> {
+) -> Result<String, StatusCode> {
-    db_conn
-        .run(move |conn| {
     let credentials = Credentials {
         username: &params.username,
         password: &params.password,
     };
     // TODO: handle failures
-            let authenticated = users::authenticate_user(&credentials, conn);
+    let authenticated = users::authenticate_user(&credentials, &conn);
 
     match authenticated {
-                None => Err(status::Forbidden(Some("invalid auth"))),
+        None => Err(StatusCode::FORBIDDEN),
         Some(user) => {
-                    let session = sessions::create_session(&user, conn);
+            let session = sessions::create_session(&user, &conn);
             Ok(session.token)
         }
     }
-        })
-        .await
 }
 
-#[get("/users/me")]
 pub async fn current_user(user: User) -> Json<UserData> {
     Json(user.into())
 }