migrate to axum

This commit is contained in:
Ilion Beyst 2021-12-29 16:11:27 +01:00
parent 52242b03f1
commit 1fb4a5151b
7 changed files with 172 additions and 164 deletions

View file

@ -6,8 +6,12 @@ edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies] [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" dotenv = "0.15.0"
rust-argon2 = "0.8" rust-argon2 = "0.8"
rand = "0.8.4" rand = "0.8.4"
@ -18,10 +22,5 @@ serde_json = "1.0"
base64 = "0.13.0" base64 = "0.13.0"
zip = "0.5" zip = "0.5"
[dependencies.rocket_sync_db_pools]
version = "0.1.0-rc.1"
features = ["diesel_postgres_pool"]
[dev-dependencies] [dev-dependencies]
parking_lot = "0.11" parking_lot = "0.11"

View file

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

View file

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

View file

@ -1,10 +1,5 @@
#![feature(proc_macro_hygiene, decl_macro)] #![feature(proc_macro_hygiene, decl_macro)]
use rocket::{Build, Rocket};
use rocket_sync_db_pools::database;
#[macro_use]
extern crate rocket;
#[macro_use] #[macro_use]
extern crate diesel; extern crate diesel;
@ -12,27 +7,79 @@ pub mod db;
pub mod routes; pub mod routes;
pub mod schema; 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!" "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())
} }

View file

@ -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();
} }

View file

@ -1,16 +1,14 @@
use axum::extract::{Path, RawBody};
use axum::http::StatusCode;
use axum::Json;
use rand::Rng; 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 serde::{Deserialize, Serialize};
use std::io::Cursor; use std::io::Cursor;
use std::path::Path; use std::path;
use crate::DbConn;
use crate::db::bots::{self, CodeBundle}; use crate::db::bots::{self, CodeBundle};
use crate::db::users::User; use crate::db::users::User;
use crate::DatabaseConnection;
use bots::Bot; use bots::Bot;
#[derive(Serialize, Deserialize, Debug)] #[derive(Serialize, Deserialize, Debug)]
@ -18,52 +16,36 @@ pub struct BotParams {
name: String, name: String,
} }
// TODO: handle errors
#[post("/bots", data = "<params>")]
pub async fn create_bot( pub async fn create_bot(
db_conn: DbConn, conn: DatabaseConnection,
user: User, user: User,
params: Json<BotParams>, params: Json<BotParams>,
) -> status::Created<Json<Bot>> { ) -> (StatusCode, Json<Bot>) {
db_conn
.run(move |conn| {
let bot_params = bots::NewBot { let bot_params = bots::NewBot {
owner_id: user.id, owner_id: user.id,
name: &params.name, 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 // 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) Json(bot)
})
.await
} }
// TODO: proper error handling // TODO: proper error handling
#[post("/bots/<bot_id>/upload", data = "<data>")]
pub async fn upload_bot_code( pub async fn upload_bot_code(
db_conn: DbConn, conn: DatabaseConnection,
user: User, 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 // TODO: put in config somewhere
let data_path = "./data/bots"; 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); 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 token: [u8; 16] = rand::thread_rng().gen();
let name = base64::encode(&token); 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)) zip::ZipArchive::new(Cursor::new(buf))
.unwrap() .unwrap()
.extract(&path) .extract(&path)
.unwrap(); .unwrap();
let code_bundle = db_conn
.run(move |conn| {
let bundle = bots::NewCodeBundle { let bundle = bots::NewCodeBundle {
bot_id: bot.id, bot_id: bot.id,
path: path.to_str().unwrap(), 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))
} }

View file

@ -1,48 +1,32 @@
use crate::db::users::{Credentials, User};
use crate::db::{sessions, users}; 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 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, 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 { let credentials = Credentials {
username: &params.username, username: &params.username,
password: &params.password, password: &params.password,
}; };
let user = users::create_user(&credentials, conn).unwrap(); let user = users::create_user(&credentials, &conn).unwrap();
Json(user.into()) Json(user.into())
})
.await
} }
#[derive(Deserialize)] #[derive(Deserialize)]
@ -87,32 +69,26 @@ pub struct LoginParams {
pub password: String, pub password: String,
} }
#[post("/login", data = "<params>")]
pub async fn login( pub async fn login(
db_conn: DbConn, conn: DatabaseConnection,
params: Json<LoginParams>, params: Json<LoginParams>,
) -> Result<String, status::Forbidden<&'static str>> { ) -> Result<String, StatusCode> {
db_conn
.run(move |conn| {
let credentials = Credentials { let credentials = Credentials {
username: &params.username, username: &params.username,
password: &params.password, password: &params.password,
}; };
// TODO: handle failures // TODO: handle failures
let authenticated = users::authenticate_user(&credentials, conn); let authenticated = users::authenticate_user(&credentials, &conn);
match authenticated { match authenticated {
None => Err(status::Forbidden(Some("invalid auth"))), None => Err(StatusCode::FORBIDDEN),
Some(user) => { Some(user) => {
let session = sessions::create_session(&user, conn); let session = sessions::create_session(&user, &conn);
Ok(session.token) Ok(session.token)
} }
} }
})
.await
} }
#[get("/users/me")]
pub async fn current_user(user: User) -> Json<UserData> { pub async fn current_user(user: User) -> Json<UserData> {
Json(user.into()) Json(user.into())
} }