Try to build crates if there is any in queue

In addition to #90 this change will also run `build_queue` in it's own
thread to catch panics (only panicked twice in last 6 months).

This commit also introduces an attempt count to avoid endless tries to build
yanked crates. This only happens if a crate gets yanked before docs.rs tries.
docs.rs will only try to build a crate 5 times and ignore them after it but it
will still leave it in queue for inspection.

Author: onur

src/db/mod.rs

@@ -159,6 +159,8 @@ pub fn create_tables(conn: &Connection) -> Result<(), Error> {
             id SERIAL, \
             name VARCHAR(255), \
             version VARCHAR(100), \
+            attempt INT DEFAULT 0, \
+            date_added TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, \
             UNIQUE(name, version) \
         )",
         "CREATE TABLE files ( \

src/docbuilder/queue.rs

@@ -8,25 +8,37 @@ use crates_index_diff::{ChangeKind, Index};
 
 
 impl DocBuilder {
-    /// Updates crates.io-index repository and adds new crates into build queue
-    pub fn get_new_crates(&mut self) -> Result<()> {
+    /// Updates crates.io-index repository and adds new crates into build queue.
+    /// Returns size of queue
+    pub fn get_new_crates(&mut self) -> Result<i64> {
         let conn = try!(connect_db());
         let index = try!(Index::from_path_or_cloned(&self.options.crates_io_index_path));
-        let changes = try!(index.fetch_changes());
+        let mut changes = try!(index.fetch_changes());
+
+        // I belive this will fix ordering of queue if we get more than one crate from changes
+        changes.reverse();
+
         for krate in changes.iter().filter(|k| k.kind != ChangeKind::Yanked) {
             conn.execute("INSERT INTO queue (name, version) VALUES ($1, $2)",
                          &[&krate.name, &krate.version]).ok();
+            debug!("{}-{} added into build queue", krate.name, krate.version);
         }
 
-        Ok(())
+        let queue_count = conn.query("SELECT COUNT(*) FROM queue WHERE attempt < 5",
+                                     &[]).unwrap().get(0).get(0);
+
+        Ok(queue_count)
     }
 
 
     /// Builds packages from queue
     pub fn build_packages_queue(&mut self) -> Result<()> {
         let conn = try!(connect_db());
 
-        for row in &try!(conn.query("SELECT id, name, version FROM queue ORDER BY id ASC", &[])) {
+        for row in &try!(conn.query("SELECT id, name, version \
+                                     FROM queue \
+                                     WHERE attempt < 5 \
+                                     ORDER BY id ASC", &[])) {
             let id: i32 = row.get(0);
             let name: String = row.get(1);
             let version: String = row.get(2);
@@ -36,6 +48,9 @@ impl DocBuilder {
                     let _ = conn.execute("DELETE FROM queue WHERE id = $1", &[&id]);
                 }
                 Err(e) => {
+                    // Increase attempt count
+                    let _ = conn.execute("UPDATE queue SET attempt = attempt + 1 WHERE id = $1",
+                                         &[&id]);
                     error!("Failed to build package {}-{} from queue: {}",
                            name,
                            version,

src/utils/daemon.rs

@@ -45,23 +45,10 @@ pub fn start_daemon() {
     }
 
 
-    // check new crates every 5 minutes
-    // FIXME: why not just check new crates and build them if there is any?
+    // check new crates every minute
     thread::spawn(move || {
         loop {
-            thread::sleep(Duration::from_secs(300));
-            debug!("Checking new crates");
-            if let Err(e) = DocBuilder::new(opts()).get_new_crates() {
-                error!("Failed to get new crates: {}", e);
-            }
-        }
-    });
-
-
-    // build crates in que every 5 minutes
-    thread::spawn(move || {
-        loop {
-            thread::sleep(Duration::from_secs(300));
+            thread::sleep(Duration::from_secs(60));
 
             let mut opts = opts();
             opts.skip_if_exists = true;
@@ -72,25 +59,54 @@ pub fn start_daemon() {
                 continue;
             }
 
+            let mut doc_builder = DocBuilder::new(opts);
+
+            debug!("Checking new crates");
+            let queue_count = match doc_builder.get_new_crates() {
+                Ok(size) => size,
+                Err(e) => {
+                    error!("Failed to get new crates: {}", e);
+                    continue;
+                }
+            };
+
+            // Only build crates if there is any
+            if queue_count == 0 {
+                debug!("Queue is empty, going back to sleep");
+                continue;
+            }
+
+            info!("Building {} crates from queue", queue_count);
+
             // update index
             if let Err(e) = update_sources() {
                 error!("Failed to update sources: {}", e);
                 continue;
             }
 
-            let mut doc_builder = DocBuilder::new(opts);
             if let Err(e) = doc_builder.load_cache() {
                 error!("Failed to load cache: {}", e);
                 continue;
             }
 
-            debug!("Building new crates");
-            if let Err(e) = doc_builder.build_packages_queue() {
-                error!("Failed build new crates: {}", e);
-            }
 
-            if let Err(e) = doc_builder.save_cache() {
-                error!("Failed to save cache: {}", e);
+            // Run build_packages_queue in it's own thread to catch panics
+            // This only panicked twice in the last 6 months but its just a better
+            // idea to do this.
+            let res = thread::spawn(move || {
+                if let Err(e) = doc_builder.build_packages_queue() {
+                    error!("Failed build new crates: {}", e);
+                }
+
+                if let Err(e) = doc_builder.save_cache() {
+                    error!("Failed to save cache: {}", e);
+                }
+
+                debug!("Finished building new crates, going back to sleep");
+            }).join();
+
+            if let Err(e) = res {
+                error!("GRAVE ERROR Building new crates panicked: {:?}", e);
             }
         }
     });

src/web/releases.rs

@@ -505,7 +505,10 @@ pub fn activity_handler(req: &mut Request) -> IronResult<Response> {
 pub fn build_queue_handler(req: &mut Request) -> IronResult<Response> {
     let conn = extension!(req, Pool);
     let mut crates: Vec<(String, String)> = Vec::new();
-    for krate in &conn.query("SELECT name, version FROM queue ORDER BY id ASC", &[]).unwrap() {
+    for krate in &conn.query("SELECT name, version
+                              FROM queue
+                              WHERE attempt < 5
+                              ORDER BY id ASC", &[]).unwrap() {
         crates.push((krate.get(0), krate.get(1)));
     }
     let is_empty = crates.is_empty();