Remove pubsub integration

Pubsub was never used to my knowledge, and made the queue builder more complicated.
This:
- Removes pubsub integration
- Changes `QueueInProgress` to no longer track how many crates were
  built since the last pubsub update
- Makes the `BuilderState` enum much simpler
- Fixes a bug where an error building a crate would freeze the whole queue for 60 seconds (since it would remain in whatever state it had before rather than calling increment).
- Fixes a couple typos

In particular, the queue builder is no longer doing network IO, so it's
less likely anything can go wrong outside of a build.

Author: jyn514

src/build_queue.rs

@@ -153,7 +153,7 @@ impl BuildQueue {
         self.lock_path().exists()
     }
 
-    /// Creates a lock file. Daemon will check this lock file and stop operating if its exists.
+    /// Creates a lock file. Daemon will check this lock file and stop operating if it exists.
     pub fn lock(&self) -> Result<()> {
         let path = self.lock_path();
         if !path.exists() {

src/utils/mod.rs

@@ -17,7 +17,6 @@ pub mod consistency;
 mod copy;
 pub(crate) mod daemon;
 mod html;
-mod pubsubhubbub;
 mod queue;
 mod queue_builder;
 mod rustc_version;

src/utils/pubsubhubbub.rs

@@ -1,9 +1,5 @@
-use crate::{
-    docbuilder::RustwideBuilder,
-    utils::{pubsubhubbub, report_error},
-    BuildQueue,
-};
-use anyhow::{Context, Error};
+use crate::{docbuilder::RustwideBuilder, utils::report_error, BuildQueue};
+use anyhow::Error;
 use log::{debug, error, info, warn};
 use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::sync::Arc;
@@ -23,81 +19,47 @@ pub fn queue_builder(
         EmptyQueue,
         /// The builder has just seen the lock file.
         Locked,
-        /// The builder has just finished building a crate. The enclosed count is the number of
-        /// crates built since the caches have been refreshed.
-        QueueInProgress(usize),
+        /// The builder has started (or just finished) building a crate.
+        QueueInProgress,
     }
 
     let mut status = BuilderState::Fresh;
 
     loop {
-        if !status.is_in_progress() {
+        if !matches!(status, BuilderState::QueueInProgress) {
             thread::sleep(Duration::from_secs(60));
         }
 
         // check lock file
         if build_queue.is_locked() {
-            warn!("Lock file exits, skipping building new crates");
+            warn!("Lock file exists, skipping building new crates");
             status = BuilderState::Locked;
             continue;
         }
 
-        if status.count() >= 10 {
-            // periodically, ping the hubs
-            debug!("10 builds in a row; pinging pubsubhubhub");
-            status = BuilderState::QueueInProgress(0);
-
-            match pubsubhubbub::ping_hubs().context("Failed to ping hub") {
-                Err(e) => report_error(&e),
-                Ok(n) => debug!("Succesfully pinged {} hubs", n),
-            }
-        }
-
         // Only build crates if there are any to build
         debug!("Checking build queue");
-        match build_queue
-            .pending_count()
-            .context("Failed to read the number of crates in the queue")
-        {
+        match build_queue.pending_count() {
             Err(e) => {
-                report_error(&e);
+                report_error(&e.context("Failed to read the number of crates in the queue"));
                 continue;
             }
 
             Ok(0) => {
-                if status.count() > 0 {
-                    // ping the hubs before continuing
-                    match pubsubhubbub::ping_hubs().context("Failed to ping hub") {
-                        Err(e) => report_error(&e),
-                        Ok(n) => debug!("Succesfully pinged {} hubs", n),
-                    }
-                }
                 debug!("Queue is empty, going back to sleep");
                 status = BuilderState::EmptyQueue;
                 continue;
             }
 
-            Ok(queue_count) => {
-                info!(
-                    "Starting build with {} crates in queue (currently on a {} crate streak)",
-                    queue_count,
-                    status.count()
-                );
-            }
+            Ok(queue_count) => info!("Starting build with {} crates in queue", queue_count),
         }
 
+        status = BuilderState::QueueInProgress;
+
         // If a panic occurs while building a crate, lock the queue until an admin has a chance to look at it.
         let res = catch_unwind(AssertUnwindSafe(|| {
-            match build_queue
-                .build_next_queue_package(&mut builder)
-                .context("Failed to build crate from queue")
-            {
-                Err(e) => report_error(&e),
-                Ok(crate_built) => {
-                    if crate_built {
-                        status.increment();
-                    }
-                }
+            if let Err(e) = build_queue.build_next_queue_package(&mut builder) {
+                report_error(&e.context("Failed to build crate from queue"));
             }
         }));
 
@@ -107,21 +69,4 @@ pub fn queue_builder(
             build_queue.lock().expect("failed to lock queue");
         }
     }
-
-    impl BuilderState {
-        fn count(&self) -> usize {
-            match *self {
-                BuilderState::QueueInProgress(n) => n,
-                _ => 0,
-            }
-        }
-
-        fn is_in_progress(&self) -> bool {
-            matches!(*self, BuilderState::QueueInProgress(_))
-        }
-
-        fn increment(&mut self) {
-            *self = BuilderState::QueueInProgress(self.count() + 1);
-        }
-    }
 }