feat: allow caching installed executor instruments on ubuntu/debian

Author: GuillaumeLagrange

Cargo.lock

@@ -56,6 +56,7 @@ memmap2 = "0.9.5"
 nix = { version = "0.29.0", features = ["fs", "time", "user"] }
 futures = "0.3.31"
 runner-shared = { path = "crates/runner-shared" }
+shellexpand = { version = "3.1.1", features = ["tilde"] }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 procfs = "0.17.0"

Cargo.toml

@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
 use crate::{
     api_client::CodSpeedAPIClient,
     auth,
@@ -38,6 +40,13 @@ pub struct Cli {
     #[arg(long, env = "CODSPEED_OAUTH_TOKEN", global = true, hide = true)]
     pub oauth_token: Option<String>,
 
+    /// The directory to use for caching installed tools
+    /// The runner will restore cached tools from this directory before installing them.
+    /// After successful installation, the runner will cache the installed tools to this directory.
+    /// Only supported on ubuntu and debian systems.
+    #[arg(long, env = "CODSPEED_SETUP_CACHE_DIR", global = true)]
+    pub setup_cache_dir: Option<String>,
+
     #[command(subcommand)]
     command: Commands,
 }
@@ -56,6 +65,12 @@ pub async fn run() -> Result<()> {
     let cli = Cli::parse();
     let codspeed_config = CodSpeedConfig::load_with_override(cli.oauth_token.as_deref())?;
     let api_client = CodSpeedAPIClient::try_from((&cli, &codspeed_config))?;
+    // In the context of the CI, it is likely that a ~ made its way here without being expanded by the shell
+    let setup_cache_dir = cli
+        .setup_cache_dir
+        .as_ref()
+        .map(|d| PathBuf::from(shellexpand::tilde(d).as_ref()));
+    let setup_cache_dir = setup_cache_dir.as_deref();
 
     match cli.command {
         Commands::Run(_) => {} // Run is responsible for its own logger initialization
@@ -65,9 +80,11 @@ pub async fn run() -> Result<()> {
     }
 
     match cli.command {
-        Commands::Run(args) => run::run(args, &api_client, &codspeed_config).await?,
+        Commands::Run(args) => {
+            run::run(args, &api_client, &codspeed_config, setup_cache_dir).await?
+        }
         Commands::Auth(args) => auth::run(args, &api_client).await?,
-        Commands::Setup => setup::setup().await?,
+        Commands::Setup => setup::setup(setup_cache_dir).await?,
     }
     Ok(())
 }

src/app.rs

@@ -9,6 +9,7 @@ use instruments::mongo_tracer::{MongoTracer, install_mongodb_tracer};
 use run_environment::interfaces::{RepositoryProvider, RunEnvironment};
 use runner::get_run_data;
 use serde::Serialize;
+use std::path::Path;
 use std::path::PathBuf;
 
 pub mod check_system;
@@ -176,6 +177,7 @@ pub async fn run(
     args: RunArgs,
     api_client: &CodSpeedAPIClient,
     codspeed_config: &CodSpeedConfig,
+    setup_cache_dir: Option<&Path>,
 ) -> Result<()> {
     let output_json = args.message_format == Some(MessageFormat::Json);
     let mut config = Config::try_from(args)?;
@@ -202,7 +204,7 @@ pub async fn run(
 
     if !config.skip_setup {
         start_group!("Preparing the environment");
-        executor.setup(&system_info).await?;
+        executor.setup(&system_info, setup_cache_dir).await?;
         // TODO: refactor and move directly in the Instruments struct as a `setup` method
         if config.instruments.is_mongodb_enabled() {
             install_mongodb_tracer().await?;

src/run/mod.rs

@@ -3,12 +3,17 @@ use crate::prelude::*;
 use crate::run::instruments::mongo_tracer::MongoTracer;
 use crate::run::{check_system::SystemInfo, config::Config};
 use async_trait::async_trait;
+use std::path::Path;
 
 #[async_trait(?Send)]
 pub trait Executor {
     fn name(&self) -> ExecutorName;
 
-    async fn setup(&self, _system_info: &SystemInfo) -> Result<()> {
+    async fn setup(
+        &self,
+        _system_info: &SystemInfo,
+        _setup_cache_dir: Option<&Path>,
+    ) -> Result<()> {
         Ok(())
     }
 

src/run/runner/executor.rs

@@ -0,0 +1,188 @@
+use super::run_with_sudo::run_with_sudo;
+use crate::prelude::*;
+use crate::run::check_system::SystemInfo;
+use std::path::Path;
+use std::process::Command;
+
+fn is_system_compatible(system_info: &SystemInfo) -> bool {
+    system_info.os == "ubuntu" || system_info.os == "debian"
+}
+
+/// Installs packages with caching support.
+///
+/// This function provides a common pattern for installing tools on Ubuntu/Debian systems
+/// with automatic caching to speed up subsequent installations (e.g., in CI environments).
+///
+/// # Arguments
+///
+/// * `system_info` - System information to determine compatibility
+/// * `setup_cache_dir` - Optional directory to restore from/save to cache
+/// * `is_installed` - Function that checks if the tool is already installed
+/// * `install_packages` - Async closure that:
+///   1. Performs the installation (e.g., downloads .deb files, calls `apt::install`)
+///   2. Returns a Vec of package names that should be cached via `dpkg -L`
+///
+/// # Flow
+///
+/// 1. Check if already installed - if yes, skip everything
+/// 2. Try to restore from cache (if cache_dir provided)
+/// 3. Check again if installed - if yes, we're done
+/// 4. Run the install closure to install and get package names
+/// 5. Save installed packages to cache (if cache_dir provided)
+///
+/// # Example
+///
+/// ```rust,ignore
+/// apt::install_cached(
+///     system_info,
+///     setup_cache_dir,
+///     || Command::new("which").arg("perf").status().is_ok(),
+///     || async {
+///         let packages = vec!["linux-tools-common".to_string()];
+///         let refs: Vec<&str> = packages.iter().map(|s| s.as_str()).collect();
+///         apt::install(system_info, &refs)?;
+///         Ok(packages) // Return package names for caching
+///     },
+/// ).await?;
+/// ```
+pub async fn install_cached<F, I, Fut>(
+    system_info: &SystemInfo,
+    setup_cache_dir: Option<&Path>,
+    is_installed: F,
+    install_packages: I,
+) -> Result<()>
+where
+    F: Fn() -> bool,
+    I: FnOnce() -> Fut,
+    Fut: std::future::Future<Output = Result<Vec<String>>>,
+{
+    if is_installed() {
+        info!("Tool already installed, skipping installation");
+        return Ok(());
+    }
+
+    // Try to restore from cache first
+    if let Some(cache_dir) = setup_cache_dir {
+        restore_from_cache(system_info, cache_dir)?;
+
+        if is_installed() {
+            info!("Tool has been successfully restored from cache");
+            return Ok(());
+        }
+    }
+
+    // Install and get the package names for caching
+    let cache_packages = install_packages().await?;
+
+    info!("Installation completed successfully");
+
+    // Save to cache after successful installation
+    if let Some(cache_dir) = setup_cache_dir {
+        let cache_refs: Vec<&str> = cache_packages.iter().map(|s| s.as_str()).collect();
+        save_to_cache(system_info, cache_dir, &cache_refs)?;
+    }
+
+    Ok(())
+}
+
+pub fn install(system_info: &SystemInfo, packages: &[&str]) -> Result<()> {
+    if !is_system_compatible(system_info) {
+        bail!(
+            "Package installation is not supported on this system, please install necessary packages manually"
+        );
+    }
+
+    debug!("Installing packages: {packages:?}");
+
+    run_with_sudo(&["apt-get", "update"])?;
+    let mut install_cmd = vec!["apt-get", "install", "-y", "--allow-downgrades"];
+    install_cmd.extend_from_slice(packages);
+    run_with_sudo(&install_cmd)?;
+
+    debug!("Packages installed successfully");
+    Ok(())
+}
+
+/// Restore cached tools from the cache directory to the root filesystem
+fn restore_from_cache(system_info: &SystemInfo, cache_dir: &Path) -> Result<()> {
+    if !is_system_compatible(system_info) {
+        warn!("Cache restore is not supported on this system, skipping");
+        return Ok(());
+    }
+
+    if !cache_dir.exists() {
+        debug!("Cache directory does not exist: {}", cache_dir.display());
+        return Ok(());
+    }
+
+    // Check if the directory has any contents
+    let has_contents = std::fs::read_dir(cache_dir)
+        .map(|mut entries| entries.next().is_some())
+        .unwrap_or(false);
+
+    if !has_contents {
+        debug!("Cache directory is empty: {}", cache_dir.display());
+        return Ok(());
+    }
+
+    debug!(
+        "Restoring tools from cache directory: {}",
+        cache_dir.display()
+    );
+
+    // Use bash to properly handle glob expansion
+    let cache_dir_str = cache_dir
+        .to_str()
+        .ok_or_else(|| anyhow!("Invalid cache directory path"))?;
+
+    let copy_cmd = format!("cp -r {cache_dir_str}/* /");
+
+    run_with_sudo(&["bash", "-c", &copy_cmd])?;
+
+    debug!("Cache restored successfully");
+    Ok(())
+}
+
+/// Save installed packages to the cache directory
+fn save_to_cache(system_info: &SystemInfo, cache_dir: &Path, packages: &[&str]) -> Result<()> {
+    if !is_system_compatible(system_info) {
+        warn!("Caching of installed package is not supported on this system, skipping");
+        return Ok(());
+    }
+
+    debug!(
+        "Saving installed packages to cache: {}",
+        cache_dir.display()
+    );
+
+    // Create cache directory if it doesn't exist
+    std::fs::create_dir_all(cache_dir).context("Failed to create cache directory")?;
+
+    let cache_dir_str = cache_dir
+        .to_str()
+        .ok_or_else(|| anyhow!("Invalid cache directory path"))?;
+
+    // Logic taken from https://stackoverflow.com/a/59277514
+    // This shell command lists all the files outputted by the given packages and copy them to the cache directory
+    let packages_str = packages.join(" ");
+    let shell_cmd = format!(
+        "dpkg -L {packages_str} | while IFS= read -r f; do if test -f \"$f\"; then echo \"$f\"; fi; done | xargs cp --parents --target-directory {cache_dir_str}",
+    );
+
+    debug!("Running cache save command: {shell_cmd}");
+
+    let output = Command::new("sh")
+        .arg("-c")
+        .arg(&shell_cmd)
+        .output()
+        .context("Failed to execute cache save command")?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        error!("stderr: {stderr}");
+        bail!("Failed to save packages to cache");
+    }
+
+    debug!("Packages cached successfully");
+    Ok(())
+}

src/run/runner/helpers/apt.rs

@@ -1,7 +1,8 @@
+pub mod apt;
 pub mod env;
 pub mod get_bench_command;
 pub mod introspected_golang;
 pub mod introspected_nodejs;
 pub mod profile_folder;
 pub mod run_command_with_log_pipe;
-pub mod setup;
+pub mod run_with_sudo;

src/run/runner/helpers/mod.rs

@@ -1,5 +1,4 @@
 use crate::prelude::*;
-use log::{debug, info};
 use std::process::{Command, Stdio};
 
 /// Run a command with sudo if available