haskal
/
Plume
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove legacy setup script

This commit is contained in:
Bat 2018-10-06 12:06:02 +01:00
parent caa4c38948
commit 5fa7a2a742
3 changed files with 12 additions and 271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@ -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]]

13
src/main.rs
View File

@ -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<ThunkWorker<()>>>;
/// Initializes a database pool.
fn init_pool() -> Option<PgPool> {
dotenv::dotenv().ok();
let manager = ConnectionManager::<Connection>::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,

269
src/setup.rs
View File

@ -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<DbPool> {
dotenv().ok();
let manager = ConnectionManager::<Connection>::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<DbConn>) {
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>) -> 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");
}