Add blacklist functionality

Changes:
- add a table blacklisted_crates to keep track of crate names
- add a new module db::blacklist to interact with blacklisted_crates
- expose blacklist functionality in the cratesfyi CLI
- check if a crate is on the blacklist before building its docs and return Err if so

Author: Koenraad Verheyden

src/bin/cratesfyi.rs

@@ -77,6 +77,21 @@ pub fn main() {
             .subcommand(SubCommand::with_name("unlock")
                 .about("Unlocks cratesfyi daemon to continue building new crates"))
             .subcommand(SubCommand::with_name("print-options")))
+        .subcommand(SubCommand::with_name("blacklist")
+            .about("Blacklist operations")
+            .setting(AppSettings::ArgRequiredElseHelp)
+            .subcommand(SubCommand::with_name("add")
+                .about("Add a crate to the blacklist")
+                .arg(Arg::with_name("CRATE_NAME")
+                    .index(1)
+                    .required(true)
+                    .help("Crate name")))
+            .subcommand(SubCommand::with_name("remove")
+                .about("Remove a crate from the blacklist")
+                .arg(Arg::with_name("CRATE_NAME")
+                    .index(1)
+                    .required(true)
+                    .help("Crate name"))))
         .subcommand(SubCommand::with_name("start-web-server")
             .about("Starts web server")
             .arg(Arg::with_name("SOCKET_ADDR")
@@ -200,6 +215,18 @@ pub fn main() {
             println!("{:?}", docbuilder.options());
         }
 
+    } else if let Some(matches) = matches.subcommand_matches("blacklist") {
+        let conn = db::connect_db().expect("Failed to connect to the database");
+
+        if let Some(matches) = matches.subcommand_matches("add") {
+            let crate_name = matches.value_of("CRATE_NAME").expect("Verified by clap");
+            db::blacklist::add_crate(&conn, crate_name).expect("Failed to add crate to blacklist");
+
+        } else if let Some(matches) = matches.subcommand_matches("remove") {
+            let crate_name = matches.value_of("CRATE_NAME").expect("Verified by clap");
+            db::blacklist::remove_crate(&conn, crate_name).expect("Failed to remove crate from blacklist");
+        }
+
     } else if let Some(matches) = matches.subcommand_matches("database") {
         if let Some(matches) = matches.subcommand_matches("migrate") {
             let version = matches.value_of("VERSION").map(|v| v.parse::<i64>()

src/db/blacklist.rs

@@ -0,0 +1,84 @@
+use failure::Error;
+use postgres::Connection;
+
+#[derive(Debug, Fail)]
+enum BlacklistError {
+    #[fail(display = "crate {} is already on the blacklist", _0)]
+    CrateAlreadyOnBlacklist(String),
+
+    #[fail(display = "crate {} is not on the blacklist", _0)]
+    CrateNotOnBlacklist(String),
+}
+
+pub fn is_blacklisted(conn: &Connection, name: &str) -> Result<bool, Error> {
+    let rows = conn.query(
+        "SELECT COUNT(*) FROM blacklisted_crates WHERE crate_name = $1;",
+        &[&name],
+    )?;
+    let count: i64 = rows.get(0).get(0);
+
+    Ok(count != 0)
+}
+
+pub fn add_crate(conn: &Connection, name: &str) -> Result<(), Error> {
+    if is_blacklisted(conn, name)? {
+        return Err(BlacklistError::CrateAlreadyOnBlacklist(name.into()).into());
+    }
+
+    conn.execute(
+        "INSERT INTO blacklisted_crates (crate_name) VALUES ($1);",
+        &[&name],
+    )?;
+
+    Ok(())
+}
+
+pub fn remove_crate(conn: &Connection, name: &str) -> Result<(), Error> {
+    if !is_blacklisted(conn, name)? {
+        return Err(BlacklistError::CrateNotOnBlacklist(name.into()).into());
+    }
+
+    conn.execute(
+        "DELETE FROM blacklisted_crates WHERE crate_name = $1;",
+        &[&name],
+    )?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_add_to_and_remove_from_blacklist() {
+        crate::test::with_database(|db| {
+            assert!(is_blacklisted(db.conn(), "crate foo")? == false);
+            add_crate(db.conn(), "crate foo")?;
+            assert!(is_blacklisted(db.conn(), "crate foo")? == true);
+            remove_crate(db.conn(), "crate foo")?;
+            assert!(is_blacklisted(db.conn(), "crate foo")? == false);
+            Ok(())
+        });
+    }
+
+    #[test]
+    fn test_add_twice_to_blacklist() {
+        crate::test::with_database(|db| {
+            add_crate(db.conn(), "crate foo")?;
+            assert!(add_crate(db.conn(), "crate foo").is_err());
+            add_crate(db.conn(), "crate bar")?;
+
+            Ok(())
+        });
+    }
+
+    #[test]
+    fn test_remove_non_existing_crate() {
+        crate::test::with_database(|db| {
+            assert!(remove_crate(db.conn(), "crate foo").is_err());
+
+            Ok(())
+        });
+    }
+}

src/db/migrate.rs

@@ -256,6 +256,19 @@ fn migrate_inner(version: Option<Version>, conn: &Connection, apply_mode: ApplyM
             // downgrade query
             "ALTER TABLE releases ALTER COLUMN target_name DROP NOT NULL",
         ),
+        migration!(
+            context,
+            // version
+            6,
+            // description
+            "Added blacklisted_crates table",
+            // upgrade query
+            "CREATE TABLE blacklisted_crates (
+                 crate_name VARCHAR NOT NULL PRIMARY KEY
+             );",
+            // downgrade query
+            "DROP TABLE blacklisted_crates;"
+        ),
     ];
 
     for migration in migrations {

src/db/mod.rs

@@ -17,6 +17,7 @@ mod add_package;
 pub mod file;
 mod migrate;
 mod delete_crate;
+pub mod blacklist;
 
 
 /// Connects to database

src/docbuilder/rustwide_builder.rs

@@ -1,4 +1,5 @@
 use super::DocBuilder;
+use db::blacklist::is_blacklisted;
 use db::file::add_path_into_database;
 use db::{add_build_into_database, add_package_into_database, connect_db, CratesIoData};
 use docbuilder::{crates::crates_from_path, Limits};
@@ -242,6 +243,11 @@ impl RustwideBuilder {
         info!("building package {} {}", name, version);
 
         let conn = connect_db()?;
+
+        if is_blacklisted(&conn, name)? {
+            return Err(::failure::err_msg("crate is on the blacklist"));
+        }
+
         let limits = Limits::for_crate(&conn, name)?;
 
         let mut build_dir = self.workspace.build_dir(&format!("{}-{}", name, version));