Implement --no-cache global parameter

Author: gaborcsardi

src/args.rs

@@ -2233,6 +2233,13 @@ pub fn rig_app() -> Command {
                 .long("admin")
                 .global(true)
                 .action(clap::ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new("no-cache")
+                .help("Do not read or write rig's cache (overrides RIG_NO_CACHE and config)")
+                .long("no-cache")
+                .global(true)
+                .action(clap::ArgAction::SetTrue),
         );
 
     rig = rig

src/built.rs

@@ -73,6 +73,10 @@ impl BuiltCache {
     /// Never an error: not caching a build is a missed optimization, not a
     /// failure, so everything that can go wrong here is logged and dropped.
     pub fn new(r_version: &str, r_binary: &str) -> Option<BuiltCache> {
+        if crate::cache::no_cache() {
+            debug!("Not caching built packages, --no-cache");
+            return None;
+        }
         let cache = match get_cache_dir() {
             Ok(cache) => cache,
             Err(err) => {

src/cache.rs

@@ -1,24 +1,131 @@
 use std::error::Error;
 use std::path::PathBuf;
+use std::sync::OnceLock;
 
 use directories::ProjectDirs;
 use log::*;
 use simple_error::bail;
 
 use crate::output::OUTPUT;
 
+static NO_CACHE: OnceLock<bool> = OnceLock::new();
+
+/// Record whether this run may use rig's cache, from the `--no-cache` flag.
+pub fn set_no_cache(value: bool) -> Result<(), Box<dyn Error>> {
+    match NO_CACHE.set(value) {
+        Ok(()) => Ok(()),
+        Err(existing) if existing == value => Ok(()),
+        Err(existing) => bail!(
+            "Cannot set no-cache to {}, already set to {}",
+            value,
+            existing
+        ),
+    }
+}
+
+/// Whether this run must neither read nor write rig's cache.
+pub fn no_cache() -> bool {
+    if let Some(cached) = NO_CACHE.get() {
+        return *cached;
+    }
+
+    let value = if let Ok(val) = std::env::var("RIG_NO_CACHE") {
+        match parse_bool(&val) {
+            Some(val) => val,
+            None => {
+                warn!(
+                    "Invalid RIG_NO_CACHE value: '{}', expected 'true' or 'false', ignoring it",
+                    val
+                );
+                false
+            }
+        }
+    } else {
+        match crate::config::get_global_config_bool("no-cache") {
+            Ok(val) => val.unwrap_or(false),
+            Err(err) => {
+                warn!("{}, ignoring it", err);
+                false
+            }
+        }
+    };
+
+    let _ = NO_CACHE.set(value);
+    value
+}
+
+fn parse_bool(value: &str) -> Option<bool> {
+    match value.trim().to_lowercase().as_str() {
+        "true" | "yes" | "on" | "1" => Some(true),
+        "false" | "no" | "off" | "0" | "" => Some(false),
+        _ => None,
+    }
+}
+
 /// Get the project cache directory
 ///
 /// Returns the cache directory for the rig application.
 /// This is used for storing temporary data like downloaded packages.
 pub fn get_cache_dir() -> Result<PathBuf, Box<dyn Error>> {
+    if no_cache() {
+        return ephemeral_cache_dir();
+    }
+    real_cache_dir()
+}
+
+/// The persistent cache directory, whatever `--no-cache` says.
+pub fn real_cache_dir() -> Result<PathBuf, Box<dyn Error>> {
     let cache_dir = ProjectDirs::from("com", "gaborcsardi", "rig")
         .ok_or("Cannot determine cache directory")?
         .cache_dir()
         .to_path_buf();
     Ok(cache_dir)
 }
 
+static EPHEMERAL_CACHE_DIR: OnceLock<PathBuf> = OnceLock::new();
+
+fn ephemeral_cache_dir() -> Result<PathBuf, Box<dyn Error>> {
+    if let Some(dir) = EPHEMERAL_CACHE_DIR.get() {
+        return Ok(dir.clone());
+    }
+
+    let dir = std::env::temp_dir().join(ephemeral_cache_dir_name());
+    create_download_dir_checked(&dir)?;
+    debug!("Using the throwaway cache directory {}", dir.display());
+    let _ = EPHEMERAL_CACHE_DIR.set(dir.clone());
+    Ok(dir)
+}
+
+#[cfg(any(target_os = "macos", target_os = "linux"))]
+fn ephemeral_cache_dir_name() -> String {
+    format!(
+        "rig-nocache-{}-{}",
+        nix::unistd::geteuid().as_raw(),
+        std::process::id()
+    )
+}
+
+#[cfg(target_os = "windows")]
+fn ephemeral_cache_dir_name() -> String {
+    // `%TEMP%` is already per user on Windows, see `default_download_dir()`.
+    format!("rig-nocache-{}", std::process::id())
+}
+
+pub fn cleanup_ephemeral_cache_dir() {
+    let dir = match EPHEMERAL_CACHE_DIR.get() {
+        Some(dir) => dir,
+        None => return,
+    };
+    match std::fs::remove_dir_all(dir) {
+        Ok(()) => debug!("Removed the throwaway cache directory {}", dir.display()),
+        Err(err) => debug!(
+            "Cannot remove the throwaway cache directory {}: {}",
+            dir.display(),
+            err
+        ),
+    }
+}
+
 /// Get the project data directory
 ///
 /// Returns the data directory for the rig application.

src/config.rs

@@ -181,6 +181,29 @@ pub fn get_global_config_value(key: &str) -> Result<Option<String>, Box<dyn Erro
     }
 }
 
+/// A boolean configuration entry.
+pub fn get_global_config_bool(key: &str) -> Result<Option<bool>, Box<dyn Error>> {
+    let map = load_raw_config()?;
+    match map.get(key) {
+        None => Ok(None),
+        Some(serde_json::Value::Bool(b)) => Ok(Some(*b)),
+        Some(serde_json::Value::String(s)) => match s.as_str() {
+            "true" => Ok(Some(true)),
+            "false" => Ok(Some(false)),
+            _ => bail!(
+                "Invalid '{}' in rig config: '{}', expected 'true' or 'false'",
+                key,
+                s
+            ),
+        },
+        Some(other) => bail!(
+            "Invalid '{}' in rig config: {}, expected 'true' or 'false'",
+            key,
+            other
+        ),
+    }
+}
+
 pub fn set_global_config_value(key: &str, value: &str) -> Result<(), Box<dyn Error>> {
     let mut map = load_raw_config()?;
     map.insert(

src/dirs.rs

@@ -27,7 +27,7 @@ use log::error;
 use simple_error::bail;
 use tabular::{row, Table};
 
-use crate::cache::{get_cache_dir, get_data_dir, get_download_dir, get_logs_dir};
+use crate::cache::{get_data_dir, get_download_dir, get_logs_dir, real_cache_dir};
 use crate::output::OUTPUT;
 use crate::utils::{get_binary_dir, get_mode};
 
@@ -143,7 +143,9 @@ pub fn rig_dirs(arch: &str) -> Result<RigDirs, Box<dyn Error>> {
         data_dir: path_string(get_data_dir()?),
         #[cfg(target_os = "linux")]
         fonts_dir: path_string(get_fontconfig_dir()?),
-        cache_dir: path_string(get_cache_dir()?),
+        // The real one, not the throwaway directory `--no-cache` swaps in: this
+        // reports where rig keeps things, not where this process happens to.
+        cache_dir: path_string(real_cache_dir()?),
         download_dir: path_string(get_download_dir()?),
         logs_dir: path_string(get_logs_dir()?),
     })
@@ -208,7 +210,7 @@ pub fn sc_system_dirs(args: &ArgMatches, mainargs: &ArgMatches) -> Result<(), Bo
                 #[cfg(target_os = "linux")]
                 println!("{}", path_string(get_fontconfig_dir()?));
             }
-            "cache" => println!("{}", path_string(get_cache_dir()?)),
+            "cache" => println!("{}", path_string(real_cache_dir()?)),
             "download" => println!("{}", path_string(get_download_dir()?)),
             "log" => println!("{}", path_string(get_logs_dir()?)),
             _ => unreachable!(),

src/download.rs

@@ -91,7 +91,11 @@ pub fn download_file_sync(
 ) -> Result<OsString, Box<dyn Error>> {
     let tmp_dir = crate::cache::ensure_download_dir()?;
     let target = tmp_dir.join(filename);
-    if target.exists() && (infinite_cache || not_too_old(&target)) {
+    // `infinite_cache` goes around `not_too_old()`, so `--no-cache` has to be
+    // checked here as well and not only there.
+    let cached =
+        target.exists() && !crate::cache::no_cache() && (infinite_cache || not_too_old(&target));
+    if cached {
         OUTPUT.success(&format!("{} is cached at {}", filename, target.display()));
         info!("{} is cached at {}", filename, target.display());
     } else {

src/escalate.rs

@@ -45,6 +45,7 @@ pub fn escalate(task: &str) -> Result<(), Box<dyn Error>> {
             "RIG_FONTS_SHA256",
             "RIG_FONTS_URL",
             "RIG_MODE",
+            "RIG_NO_CACHE",
             "RIG_R_INSTALL_DIR",
             "RUST_BACKTRACE",
             "http_proxy",