blacksmith: cache the manifests and targets for an hour (#293)

Before this, the preprocessor fetched the channel manifests to figure
out the stable version and the available targets every single build.
This was annoying especially when running `mdbook serve`, which rebuilds
the content automatically every time a file changes on disk.

This caches that information in an ignored .blacksmith-cache.json file,
with a TTL of an hour. Within the hour the old data will be reused, and
after that amount of time new data will be fetched to refresh the cache.

This shouldn't affect CI or other production builds, as the repository
as a whole isn't cached between builds.

Author: pietroalbini

.gitignore

@@ -1 +1,2 @@
 book
+.blacksmith-cache.json

blacksmith/src/lib.rs

@@ -5,6 +5,7 @@ use std::{
     fmt::Write,
     io::{BufRead, BufReader},
     path::Path,
+    time::SystemTime,
 };
 
 use mdbook::{
@@ -21,6 +22,7 @@ const RUSTUP_URLS: &str =
 /// A representation of a rust target platform. `stable`, `beta`, and `nightly`
 /// represent whether the platform is available on that channel. `stable` also
 /// carries the specific stable compiler version.
+#[derive(serde::Serialize, serde::Deserialize)]
 pub struct Platform {
     stable: Option<String>,
     beta: bool,
@@ -38,8 +40,9 @@ impl Default for Platform {
 }
 
 /// `Blacksmith` builds dynamic tables and lists to display in the Rust Forge.
-#[derive(Default)]
+#[derive(Default, serde::Serialize, serde::Deserialize)]
 pub struct Blacksmith {
+    last_update: Option<u64>,
     rustup: Vec<String>,
     stable_version: Option<String>,
     platforms: BTreeMap<String, Platform>,
@@ -51,17 +54,30 @@ impl Blacksmith {
         Self::default()
     }
 
+    /// Check if the data in this `Blacksmith` instance was not updated within the TTL.
+    pub fn is_stale(&self, ttl: u64) -> bool {
+        if let (Some(last_update), Some(now)) = (self.last_update, unix_time()) {
+            last_update + ttl < now
+        } else {
+            true
+        }
+    }
+
     /// Populates a `Blacksmith` instance with data gathered from Rust's CI and
     /// distribution channels.
-    pub fn init(mut self) -> Result<Self, Box<dyn std::error::Error>> {
+    pub fn init() -> Result<Self, Box<dyn std::error::Error>> {
+        let mut blacksmith = Self::new();
+
         let rustup_url_regex =
             regex::Regex::new(r"^rustup/dist/([^/]+)/rustup-init(?:\.exe)?$").unwrap();
         for line in BufReader::new(reqwest::get(RUSTUP_URLS)?).lines() {
             if let Some(m) = rustup_url_regex.captures(&(line?)) {
-                self.rustup.push(m.get(1).unwrap().as_str().to_string());
+                blacksmith
+                    .rustup
+                    .push(m.get(1).unwrap().as_str().to_string());
             }
         }
-        log::info!("Found {} targets for rustup", self.rustup.len());
+        log::info!("Found {} targets for rustup", blacksmith.rustup.len());
 
         for &channel_name in CHANNELS {
             let channel_url = format!("{}{}.toml", CHANNEL_URL_PREFIX, channel_name);
@@ -90,11 +106,11 @@ impl Blacksmith {
                 .collect::<Vec<_>>();
 
             if channel_name == "stable" {
-                self.stable_version = Some(vers.clone());
+                blacksmith.stable_version = Some(vers.clone());
             }
 
             for platform in platforms {
-                let entry = self
+                let entry = blacksmith
                     .platforms
                     .entry(platform)
                     .or_insert_with(Platform::default);
@@ -108,7 +124,8 @@ impl Blacksmith {
             }
         }
 
-        Ok(self)
+        blacksmith.last_update = unix_time();
+        Ok(blacksmith)
     }
 
     fn generate_redirects(&self, ctx: &PreprocessorContext) {
@@ -299,6 +316,13 @@ fn generate_standalone_links(base: &str, stem: &str, name: &str, extension: &str
     )
 }
 
+fn unix_time() -> Option<u64> {
+    SystemTime::now()
+        .duration_since(SystemTime::UNIX_EPOCH)
+        .ok()
+        .map(|d| d.as_secs())
+}
+
 impl Preprocessor for Blacksmith {
     fn name(&self) -> &str {
         "blacksmith"

blacksmith/src/main.rs

@@ -1,10 +1,16 @@
-use std::{env, io, process};
+use std::{env, io, path::Path, process};
 
 use clap::{clap_app, ArgMatches};
-use mdbook::{errors::Error, preprocess::{CmdPreprocessor, Preprocessor}};
+use mdbook::{
+    errors::Error,
+    preprocess::{CmdPreprocessor, Preprocessor},
+};
 
 use mdbook_blacksmith::Blacksmith;
 
+const CACHE_FILE: &str = ".blacksmith-cache.json";
+const CACHE_TTL_SECONDS: u64 = 3600; // 1 hour
+
 fn main() {
     // If RUST_LOG is present use that, else default to info level printing.
     if env::var("RUST_LOG").is_ok() {
@@ -21,7 +27,8 @@ fn main() {
             (about: "Check whether a renderer is supported by this preprocessor")
             (@arg renderer: +takes_value +required)
         )
-    ).get_matches();
+    )
+    .get_matches();
 
     macro_rules! log_unwrap {
         ($result:expr) => {
@@ -32,15 +39,37 @@ fn main() {
                     process::exit(1);
                 }
             }
-        }
+        };
     }
 
-    let blacksmith = Blacksmith::new();
+    let cache_file = Path::new(CACHE_FILE);
+    let mut blacksmith = if cache_file.is_file() {
+        log_unwrap!(serde_json::from_slice(&log_unwrap!(std::fs::read(
+            &cache_file
+        ))))
+    } else {
+        Blacksmith::new()
+    };
 
     if let Some(sub_args) = matches.subcommand_matches("supports") {
         handle_supports(&blacksmith, sub_args);
-    } else  {
-        log_unwrap!(handle_preprocessing(&log_unwrap!(blacksmith.init())))
+    } else {
+        let mut update_cache = false;
+        if blacksmith.is_stale(CACHE_TTL_SECONDS) {
+            blacksmith = log_unwrap!(Blacksmith::init());
+            update_cache = true;
+        } else {
+            log::info!("Using cached data in {}", cache_file.display());
+        }
+        log_unwrap!(handle_preprocessing(&blacksmith));
+
+        if update_cache {
+            log::info!("Storing the cache in {}", cache_file.display());
+            log_unwrap!(std::fs::write(
+                &cache_file,
+                &log_unwrap!(serde_json::to_vec(&blacksmith))
+            ));
+        }
     }
 }
 
@@ -76,4 +105,3 @@ fn handle_supports(pre: &Blacksmith, sub_args: &ArgMatches) -> ! {
         process::exit(1);
     }
 }
-