import migrations and don't require diesel_cli for admins (#555)

* import migrations via macro

* panic on database not to the latest migration

* add subcommand to plm

* create migration that run tantivy index creation

* remove diesel_cli from places it was

* use our migration system for tests

* create table __diesel_schema_migrations if needed

plume-cli/src/main.rs

@@ -10,6 +10,7 @@ use plume_models::{Connection as Conn, CONFIG};
 use std::io::{self, prelude::*};
 
 mod instance;
+mod migration;
 mod search;
 mod users;
 
@@ -19,8 +20,9 @@ fn main() {
         .version(env!("CARGO_PKG_VERSION"))
         .about("Collection of tools to manage your Plume instance.")
         .subcommand(instance::command())
-        .subcommand(users::command())
-        .subcommand(search::command());
+        .subcommand(migration::command())
+        .subcommand(search::command())
+        .subcommand(users::command());
     let matches = app.clone().get_matches();
 
     dotenv::dotenv().ok();
@@ -30,12 +32,15 @@ fn main() {
         ("instance", Some(args)) => {
             instance::run(args, &conn.expect("Couldn't connect to the database."))
         }
-        ("users", Some(args)) => {
-            users::run(args, &conn.expect("Couldn't connect to the database."))
+        ("migration", Some(args)) => {
+            migration::run(args, &conn.expect("Couldn't connect to the database."))
         }
         ("search", Some(args)) => {
             search::run(args, &conn.expect("Couldn't connect to the database."))
         }
+        ("users", Some(args)) => {
+            users::run(args, &conn.expect("Couldn't connect to the database."))
+        }
         _ => app.print_help().expect("Couldn't print help"),
     };
 }

plume-cli/src/migration.rs

@@ -0,0 +1,59 @@
+use clap::{App, Arg, ArgMatches, SubCommand};
+
+use plume_models::{migrations::IMPORTED_MIGRATIONS, Connection};
+use std::path::Path;
+
+pub fn command<'a, 'b>() -> App<'a, 'b> {
+    SubCommand::with_name("migration")
+        .about("Manage migrations")
+        .subcommand(
+            SubCommand::with_name("run")
+                .arg(
+                    Arg::with_name("path")
+                        .short("p")
+                        .long("path")
+                        .takes_value(true)
+                        .required(false)
+                        .help("Path to Plume's working directory"),
+                )
+                .about("Run migrations"),
+        )
+        .subcommand(
+            SubCommand::with_name("redo")
+                .arg(
+                    Arg::with_name("path")
+                        .short("p")
+                        .long("path")
+                        .takes_value(true)
+                        .required(false)
+                        .help("Path to Plume's working directory"),
+                )
+                .about("Rerun latest migration"),
+        )
+}
+
+pub fn run<'a>(args: &ArgMatches<'a>, conn: &Connection) {
+    let conn = conn;
+    match args.subcommand() {
+        ("run", Some(x)) => run_(x, conn),
+        ("redo", Some(x)) => redo(x, conn),
+        ("", None) => command().print_help().unwrap(),
+        _ => println!("Unknown subcommand"),
+    }
+}
+
+fn run_<'a>(args: &ArgMatches<'a>, conn: &Connection) {
+    let path = args.value_of("path").unwrap_or(".");
+
+    IMPORTED_MIGRATIONS
+        .run_pending_migrations(conn, Path::new(path))
+        .expect("Failed to run migrations")
+}
+
+fn redo<'a>(args: &ArgMatches<'a>, conn: &Connection) {
+    let path = args.value_of("path").unwrap_or(".");
+
+    IMPORTED_MIGRATIONS
+        .rerun_last_migration(conn, Path::new(path))
+        .expect("Failed to rerun migrations")
+}

plume-cli/src/search.rs

@@ -1,7 +1,6 @@
 use clap::{App, Arg, ArgMatches, SubCommand};
-use diesel::{ExpressionMethods, QueryDsl, RunQueryDsl};
 
-use plume_models::{posts::Post, schema::posts, search::Searcher, Connection, CONFIG};
+use plume_models::{search::Searcher, Connection, CONFIG};
 use std::fs::{read_dir, remove_file};
 use std::io::ErrorKind;
 use std::path::Path;
@@ -98,18 +97,7 @@ fn refill<'a>(args: &ArgMatches<'a>, conn: &Connection, searcher: Option<Searche
     let path = Path::new(path).join("search_index");
     let searcher = searcher.unwrap_or_else(|| Searcher::open(&path).unwrap());
 
-    let posts = posts::table
-        .filter(posts::published.eq(true))
-        .load::<Post>(conn)
-        .expect("Post::get_recents: loading error");
-
-    let len = posts.len();
-    for (i, post) in posts.iter().enumerate() {
-        println!("Importing {}/{} : {}", i + 1, len, post.title);
-        searcher
-            .update_document(conn, &post)
-            .expect("Couldn't import post");
-    }
+    searcher.fill(conn).expect("Couldn't import post");
     println!("Commiting result");
     searcher.commit();
 }