From 5fa7a2a74252537e85fc0e9876ce1250b296e86a Mon Sep 17 00:00:00 2001 From: Bat Date: Sat, 6 Oct 2018 12:06:02 +0100 Subject: [PATCH] Remove legacy setup script --- Cargo.lock | 1 + src/main.rs | 13 ++- src/setup.rs | 269 --------------------------------------------------- 3 files changed, 12 insertions(+), 271 deletions(-) delete mode 100644 src/setup.rs diff --git a/Cargo.lock b/Cargo.lock index d98b660..60d3775 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1558,6 +1558,7 @@ dependencies = [ "diesel 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)", "dotenv 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)", "plume-models 0.2.0", + "rpassword 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] diff --git a/src/main.rs b/src/main.rs index 682f4a1..3296152 100644 --- a/src/main.rs +++ b/src/main.rs @@ -34,20 +34,29 @@ extern crate validator_derive; extern crate webfinger; extern crate workerpool; +use diesel::r2d2::ConnectionManager; use rocket::State; use rocket_contrib::Template; use rocket_csrf::CsrfFairingBuilder; +use plume_models::{DB_URL, Connection, db_conn::PgPool}; use workerpool::{Pool, thunk::ThunkWorker}; mod api; mod inbox; -mod setup; mod routes; type Worker<'a> = State<'a, Pool>>; +/// Initializes a database pool. +fn init_pool() -> Option { + dotenv::dotenv().ok(); + + let manager = ConnectionManager::::new(DB_URL.as_str()); + PgPool::new(manager).ok() +} + fn main() { - let pool = setup::check(); + let pool = init_pool(); rocket::ignite() .mount("/", routes![ routes::blogs::paginated_details, diff --git a/src/setup.rs b/src/setup.rs deleted file mode 100644 index 16736d1..0000000 --- a/src/setup.rs +++ /dev/null @@ -1,269 +0,0 @@ -use colored::Colorize; -use diesel::r2d2::{ConnectionManager, Pool}; -use dotenv::dotenv; -use std::fs::{self, File}; -use std::io; -use std::path::Path; -use std::process::{exit, Command}; -use rpassword; -use plume_models::safe_string::SafeString; - -use plume_models::{ - Connection, - DB_URL, - db_conn::{DbConn, DbPool}, - instance::*, - users::* -}; - -/// Initializes a database pool. -fn init_pool() -> Option { - dotenv().ok(); - - let manager = ConnectionManager::::new(DB_URL.as_str()); - Pool::new(manager).ok() -} - -pub fn check() -> DbPool { - if let Some(pool) = init_pool() { - match pool.get() { - Ok(conn) => { - let db_conn = DbConn(conn); - if Instance::get_local(&*db_conn).is_none() { - run_setup(Some(db_conn)); - } - } - Err(_) => panic!("Couldn't connect to database") - } - migrate(); - pool - } else { - run_setup(None); - init_pool().unwrap() - } -} - -fn run_setup(conn: Option) { - println!("\n\n"); - println!("{}\n{}\n{}\n\n{}", - "Welcome in the Plume setup tool.".magenta(), - "It will help you setup your new instance, by asking you a few questions.".magenta(), - "Then you'll be able to enjoy Plume!".magenta(), - "First let's check that you have all the required dependencies. Press Enter to start." - ); - read_line(); - check_native_deps(); - let conn = setup_db(conn); - setup_type(conn); - dotenv().ok(); - - println!("{}\n{}\n{}", - "Your Plume instance is now ready to be used.".magenta(), - "We hope you will enjoy it.".magenta(), - "If you ever encounter a problem, feel free to report it at https://github.com/Plume-org/Plume/issues/".magenta(), - ); - - println!("\nPress Enter to start it.\n"); -} - -fn setup_db(conn: Option) -> DbConn { - write_to_dotenv("DB_URL", DB_URL.as_str().to_string()); - - match conn { - Some(conn) => conn, - None => { - println!("\n{}\n", "We are going to setup the database.".magenta()); - println!("{}\n", "About to create a new PostgreSQL user named 'plume'".blue()); - Command::new("createuser") - .arg("-d") - .arg("-P") - .arg("plume") - .status() - .map(|s| { - if s.success() { - println!("{}\n", " ✔️ Done".green()); - } - }) - .expect("Couldn't create new user"); - - println!("{}\n", "About to create a new PostgreSQL database named 'plume'".blue()); - Command::new("createdb") - .arg("-O") - .arg("plume") - .arg("plume") - .status() - .map(|s| { - if s.success() { - println!("{}\n", " ✔️ Done".green()); - } - }) - .expect("Couldn't create new table"); - - migrate(); - - init_pool() - .expect("Couldn't init DB pool") - .get() - .map(|c| DbConn(c)) - .expect("Couldn't connect to the database") - } - } -} - -fn migrate() { - println!("{}\n", "Running migrations…".blue()); - Command::new("diesel") - .arg("migration") - .arg("run") - .arg("--database-url") - .arg(DB_URL.as_str()) - .status() - .map(|s| { - if s.success() { - println!("{}\n", " ✔️ Done".green()); - } - }) - .expect("Couldn't run migrations"); -} - -fn setup_type(conn: DbConn) { - println!("\nDo you prefer a simple setup, or to customize everything?\n"); - println!(" 1 - Simple setup"); - println!(" 2 - Complete setup"); - match read_line().as_ref() { - "Simple" | "simple" | "s" | "S" | - "1" => quick_setup(conn), - "Complete" | "complete" | "c" | "C" | - "2" => complete_setup(conn), - x => { - println!("Invalid choice. Choose between '1' or '2'. {}", x); - setup_type(conn); - } - } -} - -fn quick_setup(conn: DbConn) { - println!("What is your instance domain?"); - let domain = read_line(); - write_to_dotenv("BASE_URL", domain.clone()); - - println!("\nWhat is your instance name?"); - let name = read_line(); - - let instance = Instance::insert(&*conn, NewInstance { - public_domain: domain, - name: name, - local: true, - long_description: SafeString::new(""), - short_description: SafeString::new(""), - default_license: String::from("CC-0"), - open_registrations: true, - short_description_html: String::new(), - long_description_html: String::new() - }); - - println!("{}\n", " ✔️ Your instance was succesfully created!".green()); - - // Generate Rocket secret key. - let key = Command::new("openssl") - .arg("rand") - .arg("-base64") - .arg("32") - .output() - .map(|o| String::from_utf8(o.stdout).expect("Invalid output from openssl")) - .expect("Couldn't generate secret key."); - write_to_dotenv("ROCKET_SECRET_KEY", key); - - create_admin(instance, conn); -} - -fn complete_setup(conn: DbConn) { - quick_setup(conn); - - println!("\nOn which port should Plume listen? (default: 7878)"); - let port = read_line_or("7878"); - write_to_dotenv("ROCKET_PORT", port); - - println!("\nOn which address should Plume listen? (default: 0.0.0.0)"); - let address = read_line_or("0.0.0.0"); - write_to_dotenv("ROCKET_ADDRESS", address); -} - -fn create_admin(instance: Instance, conn: DbConn) { - println!("{}\n\n", "You are now about to create your admin account".magenta()); - - println!("What is your username? (default: admin)"); - let name = read_line_or("admin"); - - println!("What is your email?"); - let email = read_line(); - - println!("What is your password?"); - let password = rpassword::read_password().expect("Couldn't read your password."); - - NewUser::new_local( - &*conn, - name.clone(), - name, - true, - format!("Admin of {}", instance.name), - email, - User::hash_pass(password), - ).update_boxes(&*conn); - - println!("{}\n", " ✔️ Your account was succesfully created!".green()); -} - -fn check_native_deps() { - let mut not_found = Vec::new(); - if !try_run("psql") { - not_found.push(("PostgreSQL", "sudo apt install postgresql")); - } - if !try_run("gettext") { - not_found.push(("GetText", "sudo apt install gettext")) - } - if !try_run("diesel") { - not_found.push(("Diesel CLI", "cargo install diesel_cli")) - } - - if not_found.len() > 0 { - println!("{}\n", "Some native dependencies are missing:".red()); - for (dep, install) in not_found.into_iter() { - println!("{}", format!(" - {} (can be installed with `{}`, on Debian based distributions)", dep, install).red()) - } - println!("\nRetry once you have installed them."); - exit(1); - } else { - println!("{}", " ✔️ All native dependencies are present.".green()) - } -} - -fn try_run(command: &'static str) -> bool { - Command::new(command) - .output() - .is_ok() -} - -fn read_line() -> String { - let mut input = String::new(); - io::stdin().read_line(&mut input).expect("Unable to read line"); - input.retain(|c| c != '\n'); - input -} - -fn read_line_or(or: &str) -> String { - let input = read_line(); - if input.len() == 0 { - or.to_string() - } else { - input - } -} - -fn write_to_dotenv(var: &'static str, val: String) { - if !Path::new(".env").exists() { - File::create(".env").expect("Error while creating .env file"); - } - - fs::write(".env", format!("{}\n{}={}", fs::read_to_string(".env").expect("Unable to read .env"), var, val)).expect("Unable to write .env"); -}