From 52242b03f1af7f73e73592c2e5ee2bc54813a64d Mon Sep 17 00:00:00 2001 From: Ilion Beyst Date: Sun, 19 Dec 2021 00:16:46 +0100 Subject: [PATCH] simple bot uploads --- backend/Cargo.toml | 3 +- .../2021-12-18-130837_bots/down.sql | 3 + .../migrations/2021-12-18-130837_bots/up.sql | 14 +++ backend/src/db/bots.rs | 54 ++++++++++ backend/src/db/mod.rs | 1 + backend/src/db/sessions.rs | 2 +- backend/src/db/users.rs | 2 +- backend/src/lib.rs | 9 +- backend/src/routes/bots.rs | 96 ++++++++++++++++++ backend/src/routes/mod.rs | 1 + backend/src/routes/users.rs | 2 +- backend/src/schema.rs | 21 +++- backend/tests/bots.rs | 98 +++++++++++++++++++ backend/tests/login.rs | 26 ++--- backend/tests/util/mod.rs | 28 +++++- 15 files changed, 328 insertions(+), 32 deletions(-) create mode 100644 backend/migrations/2021-12-18-130837_bots/down.sql create mode 100644 backend/migrations/2021-12-18-130837_bots/up.sql create mode 100644 backend/src/db/bots.rs create mode 100644 backend/src/routes/bots.rs create mode 100644 backend/tests/bots.rs diff --git a/backend/Cargo.toml b/backend/Cargo.toml index cd70bc0..ed64ac3 100644 --- a/backend/Cargo.toml +++ b/backend/Cargo.toml @@ -7,7 +7,7 @@ edition = "2021" [dependencies] rocket = { version= "0.5.0-rc.1", features = ["json"] } -diesel = { version = "1.4.4", features = ["postgres", "r2d2"] } +diesel = { version = "1.4.4", features = ["postgres", "r2d2", "chrono"] } dotenv = "0.15.0" rust-argon2 = "0.8" rand = "0.8.4" @@ -16,6 +16,7 @@ serde_bytes = "0.11" chrono = { version = "0.4", features = ["serde"] } serde_json = "1.0" base64 = "0.13.0" +zip = "0.5" [dependencies.rocket_sync_db_pools] diff --git a/backend/migrations/2021-12-18-130837_bots/down.sql b/backend/migrations/2021-12-18-130837_bots/down.sql new file mode 100644 index 0000000..3d14604 --- /dev/null +++ b/backend/migrations/2021-12-18-130837_bots/down.sql @@ -0,0 +1,3 @@ +DROP TABLE code_bundles; +DROP INDEX bots_index; +DROP TABLE bots; \ No newline at end of file diff --git a/backend/migrations/2021-12-18-130837_bots/up.sql b/backend/migrations/2021-12-18-130837_bots/up.sql new file mode 100644 index 0000000..27f3582 --- /dev/null +++ b/backend/migrations/2021-12-18-130837_bots/up.sql @@ -0,0 +1,14 @@ +CREATE TABLE bots ( + id serial PRIMARY KEY, + owner_id integer REFERENCES users(id) NOT NULL, + name text NOT NULL +); + +CREATE UNIQUE INDEX bots_index ON bots(owner_id, name); + +CREATE TABLE code_bundles ( + id serial PRIMARY KEY, + bot_id integer REFERENCES bots(id) NOT NULL, + path text NOT NULL, + created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP +); \ No newline at end of file diff --git a/backend/src/db/bots.rs b/backend/src/db/bots.rs new file mode 100644 index 0000000..d359e28 --- /dev/null +++ b/backend/src/db/bots.rs @@ -0,0 +1,54 @@ +use diesel::prelude::*; +use serde::{Deserialize, Serialize}; + +use crate::schema::{bots, code_bundles}; +use crate::DbConn; +use chrono; + +#[derive(Insertable)] +#[table_name = "bots"] +pub struct NewBot<'a> { + pub owner_id: i32, + pub name: &'a str, +} + +#[derive(Queryable, Debug, PartialEq, Serialize, Deserialize)] +pub struct Bot { + pub id: i32, + pub owner_id: i32, + pub name: String, +} + +pub fn create_bot(new_bot: &NewBot, conn: &PgConnection) -> QueryResult { + diesel::insert_into(bots::table) + .values(new_bot) + .get_result(conn) +} + +pub fn find_bot(id: i32, conn: &PgConnection) -> QueryResult { + bots::table.find(id).first(conn) +} + +#[derive(Insertable)] +#[table_name = "code_bundles"] +pub struct NewCodeBundle<'a> { + pub bot_id: i32, + pub path: &'a str, +} + +#[derive(Queryable, Serialize, Deserialize, Debug)] +pub struct CodeBundle { + pub id: i32, + pub bot_id: i32, + pub path: String, + pub created_at: chrono::NaiveDateTime, +} + +pub fn create_code_bundle( + new_code_bundle: &NewCodeBundle, + conn: &PgConnection, +) -> QueryResult { + diesel::insert_into(code_bundles::table) + .values(new_code_bundle) + .get_result(conn) +} diff --git a/backend/src/db/mod.rs b/backend/src/db/mod.rs index b6e3efc..947b789 100644 --- a/backend/src/db/mod.rs +++ b/backend/src/db/mod.rs @@ -1,2 +1,3 @@ +pub mod bots; pub mod sessions; pub mod users; diff --git a/backend/src/db/sessions.rs b/backend/src/db/sessions.rs index 0cc3f1a..96f3926 100644 --- a/backend/src/db/sessions.rs +++ b/backend/src/db/sessions.rs @@ -22,7 +22,7 @@ pub struct Session { pub fn create_session(user: &User, conn: &PgConnection) -> Session { let new_session = NewSession { token: gen_session_token(), - user_id: user.user_id, + user_id: user.id, }; let session = insert_into(sessions::table) .values(&new_session) diff --git a/backend/src/db/users.rs b/backend/src/db/users.rs index 29cee88..0817766 100644 --- a/backend/src/db/users.rs +++ b/backend/src/db/users.rs @@ -20,7 +20,7 @@ pub struct NewUser<'a> { #[derive(Queryable, Debug)] pub struct User { - pub user_id: i32, + pub id: i32, pub username: String, pub password_salt: Vec, pub password_hash: Vec, diff --git a/backend/src/lib.rs b/backend/src/lib.rs index 0a21850..8807637 100644 --- a/backend/src/lib.rs +++ b/backend/src/lib.rs @@ -8,9 +8,9 @@ extern crate rocket; #[macro_use] extern crate diesel; -mod db; -mod routes; -mod schema; +pub mod db; +pub mod routes; +pub mod schema; #[database("postgresql_database")] pub struct DbConn(diesel::PgConnection); @@ -29,6 +29,9 @@ pub fn rocket() -> Rocket { routes::users::register, routes::users::login, routes::users::current_user, + routes::bots::create_bot, + routes::bots::get_bot, + routes::bots::upload_bot_code, ], ) .attach(DbConn::fairing()) diff --git a/backend/src/routes/bots.rs b/backend/src/routes/bots.rs new file mode 100644 index 0000000..413c145 --- /dev/null +++ b/backend/src/routes/bots.rs @@ -0,0 +1,96 @@ +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 crate::DbConn; + +use crate::db::bots::{self, CodeBundle}; +use crate::db::users::User; +use bots::Bot; + +#[derive(Serialize, Deserialize, Debug)] +pub struct BotParams { + name: String, +} + +// TODO: handle errors +#[post("/bots", data = "")] +pub async fn create_bot( + db_conn: DbConn, + user: User, + params: Json, +) -> status::Created> { + db_conn + .run(move |conn| { + let bot_params = bots::NewBot { + owner_id: user.id, + name: ¶ms.name, + }; + let bot = bots::create_bot(&bot_params, conn).unwrap(); + let bot_url = uri!(get_bot(bot.id)).to_string(); + status::Created::new(bot_url).body(Json(bot)) + }) + .await +} + +// TODO: handle errors +#[get("/bots/")] +pub async fn get_bot(db_conn: DbConn, bot_id: i32) -> Json { + db_conn + .run(move |conn| { + let bot = bots::find_bot(bot_id, conn).unwrap(); + Json(bot) + }) + .await +} + +// TODO: proper error handling +#[post("/bots//upload", data = "")] +pub async fn upload_bot_code( + db_conn: DbConn, + user: User, + bot_id: i32, + data: Data<'_>, +) -> status::Created> { + // TODO: put in config somewhere + let data_path = "./data/bots"; + + let bot = db_conn + .run(move |conn| bots::find_bot(bot_id, conn)) + .await + .expect("Bot not found"); + + assert_eq!(user.id, bot.owner_id); + + // generate a random filename + let token: [u8; 16] = rand::thread_rng().gen(); + let name = base64::encode(&token); + + let path = Path::new(data_path).join(name); + let capped_buf = data.open(10usize.megabytes()).into_bytes().await.unwrap(); + assert!(capped_buf.is_complete()); + let buf = capped_buf.into_inner(); + + 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") + }) + .await; + + // TODO: proper location + status::Created::new("").body(Json(code_bundle)) +} diff --git a/backend/src/routes/mod.rs b/backend/src/routes/mod.rs index 913bd46..718d7ef 100644 --- a/backend/src/routes/mod.rs +++ b/backend/src/routes/mod.rs @@ -1 +1,2 @@ +pub mod bots; pub mod users; diff --git a/backend/src/routes/users.rs b/backend/src/routes/users.rs index 72a857f..45a94b9 100644 --- a/backend/src/routes/users.rs +++ b/backend/src/routes/users.rs @@ -55,7 +55,7 @@ pub struct UserData { impl From for UserData { fn from(user: User) -> Self { UserData { - user_id: user.user_id, + user_id: user.id, username: user.username, } } diff --git a/backend/src/schema.rs b/backend/src/schema.rs index 04ecbd7..bf58434 100644 --- a/backend/src/schema.rs +++ b/backend/src/schema.rs @@ -1,3 +1,20 @@ +table! { + bots (id) { + id -> Int4, + owner_id -> Int4, + name -> Text, + } +} + +table! { + code_bundles (id) { + id -> Int4, + bot_id -> Int4, + path -> Text, + created_at -> Timestamp, + } +} + table! { sessions (id) { id -> Int4, @@ -15,6 +32,8 @@ table! { } } +joinable!(bots -> users (owner_id)); +joinable!(code_bundles -> bots (bot_id)); joinable!(sessions -> users (user_id)); -allow_tables_to_appear_in_same_query!(sessions, users,); +allow_tables_to_appear_in_same_query!(bots, code_bundles, sessions, users,); diff --git a/backend/tests/bots.rs b/backend/tests/bots.rs new file mode 100644 index 0000000..fe81712 --- /dev/null +++ b/backend/tests/bots.rs @@ -0,0 +1,98 @@ +#![feature(async_closure)] +extern crate mozaic4_backend; +extern crate zip; + +use rocket::http::{ContentType, Status}; + +mod util; +use mozaic4_backend::db::{bots, sessions, users}; +use mozaic4_backend::DbConn; +use sessions::Session; +use users::{Credentials, User}; +use util::{run_test, BearerAuth}; + +async fn user_with_session(conn: &DbConn) -> (User, Session) { + conn.run(|conn| { + let credentials = Credentials { + username: "piepkonijn", + password: "geheim123", + }; + let user = users::create_user(&credentials, conn).unwrap(); + let session = sessions::create_session(&user, conn); + (user, session) + }) + .await +} + +#[rocket::async_test] +async fn test_bot_create() { + run_test(async move |client, conn| { + let (user, session) = user_with_session(&conn).await; + + let response = client + .post("/bots") + .header(BearerAuth::new(session.token.clone())) + .header(ContentType::JSON) + .body( + r#"{ + "name": "testbot" + }"#, + ) + .dispatch() + .await; + + assert_eq!(response.status(), Status::Created); + assert_eq!(response.content_type(), Some(ContentType::JSON)); + + let resp_text = response.into_string().await.unwrap(); + let json: serde_json::Value = serde_json::from_str(&resp_text).unwrap(); + assert_eq!(json["name"], "testbot"); + assert_eq!(json["owner_id"], user.id); + }) + .await +} + +// create an example zipfile for bot upload +fn create_zip() -> std::io::Result> { + use std::io::Write; + use zip::write::FileOptions; + + let cursor = std::io::Cursor::new(Vec::new()); + let mut zip = zip::ZipWriter::new(cursor); + + zip.start_file("test.txt", FileOptions::default())?; + zip.write_all(b"sup brudi")?; + let buf = zip.finish()?; + Ok(buf.into_inner()) +} + +#[rocket::async_test] +async fn test_bot_upload() { + run_test(async move |client, conn| { + let (user, session) = user_with_session(&conn).await; + + let owner_id = user.id; + let bot = conn + .run(move |conn| { + let new_bot = bots::NewBot { + name: "testbot", + owner_id: owner_id, + }; + bots::create_bot(&new_bot, conn).unwrap() + }) + .await; + + let zip_file = create_zip().unwrap(); + + let response = client + .post(format!("/bots/{}/upload", bot.id)) + .header(BearerAuth::new(session.token.clone())) + .header(ContentType::JSON) + .body(zip_file) + .dispatch() + .await; + + assert_eq!(response.status(), Status::Created); + }) + .await +} diff --git a/backend/tests/login.rs b/backend/tests/login.rs index b4e07e3..60c5d6f 100644 --- a/backend/tests/login.rs +++ b/backend/tests/login.rs @@ -1,27 +1,11 @@ #![feature(async_closure)] extern crate mozaic4_backend; -use rocket::http::{ContentType, Header, Status}; +use rocket::http::{ContentType, Status}; mod util; use util::run_test; -pub struct BearerAuth { - token: String, -} - -impl BearerAuth { - pub fn new(token: String) -> Self { - Self { token } - } -} - -impl<'a> Into> for BearerAuth { - fn into(self) -> Header<'a> { - Header::new("Authorization", format!("Bearer {}", self.token)) - } -} - #[rocket::async_test] async fn test_registration() { run_test(async move |client, _conn| { @@ -47,7 +31,7 @@ async fn test_registration() { let response = client .get("/users/me") - .header(BearerAuth::new(token)) + .header(util::BearerAuth::new(token)) .dispatch() .await; @@ -56,7 +40,8 @@ async fn test_registration() { let resp = response.into_string().await.unwrap(); let json: serde_json::Value = serde_json::from_str(&resp).unwrap(); assert_eq!(json["username"], "piepkonijn"); - }).await + }) + .await } #[rocket::async_test] @@ -71,5 +56,6 @@ async fn test_reject_invalid_credentials() { assert_eq!(response.status(), Status::Forbidden); // assert_eq!(response.content_type(), Some(ContentType::JSON)); - }).await + }) + .await } diff --git a/backend/tests/util/mod.rs b/backend/tests/util/mod.rs index 3502ddb..f34e9f3 100644 --- a/backend/tests/util/mod.rs +++ b/backend/tests/util/mod.rs @@ -2,7 +2,7 @@ use std::future::Future; use diesel::RunQueryDsl; use mozaic4_backend::DbConn; -use rocket::local::asynchronous::Client; +use rocket::{http::Header, local::asynchronous::Client}; // We use a lock to synchronize between tests so DB operations don't collide. // For now. In the future, we'll have a nice way to run each test in a DB @@ -11,9 +11,13 @@ static DB_LOCK: parking_lot::Mutex<()> = parking_lot::const_mutex(()); async fn reset_db(db: &DbConn) { db.run(|conn| { - diesel::sql_query("TRUNCATE TABLE users, sessions") - .execute(conn) - .expect("drop all tables"); + diesel::sql_query( + r#" + TRUNCATE TABLE users, sessions, + bots, code_bundles"#, + ) + .execute(conn) + .expect("drop all tables"); }) .await } @@ -37,3 +41,19 @@ where test_closure(client, db).await; } + +pub struct BearerAuth { + token: String, +} + +impl BearerAuth { + pub fn new(token: String) -> Self { + Self { token } + } +} + +impl<'a> Into> for BearerAuth { + fn into(self) -> Header<'a> { + Header::new("Authorization", format!("Bearer {}", self.token)) + } +}