feat: auto install codspeed-memtrack during executor setup

Author: GuillaumeLagrange

src/binary_installer/mod.rs

@@ -0,0 +1,96 @@
+use crate::prelude::*;
+use crate::run::helpers::download_file;
+use semver::Version;
+use std::process::Command;
+use tempfile::NamedTempFile;
+use url::Url;
+
+mod versions;
+
+/// Ensure a binary is installed, or install it from a runner's GitHub release using the installer script.
+///
+/// This function checks if the binary is already installed with the correct version.
+/// If not, it downloads and executes an installer script from the CodSpeed runner repository.
+///
+/// # Arguments
+/// * `binary_name` - The binary command name (e.g., "codspeed-memtrack", "codspeed-exec-harness")
+/// * `version` - The version to install (e.g., "4.4.2-alpha.2")
+/// * `installer_name` - Optional installer script name. If None, defaults to "{binary_name}-installer.sh"
+pub async fn ensure_binary_installed(
+    binary_name: &str,
+    version: &str,
+    installer_name: Option<&str>,
+) -> Result<()> {
+    if is_command_installed(
+        binary_name,
+        Version::parse(version).context("Invalid version format")?,
+    ) {
+        debug!("{binary_name} version {version} is already installed");
+        return Ok(());
+    }
+
+    let installer_script = installer_name
+        .map(String::from)
+        .unwrap_or_else(|| format!("{binary_name}-installer.sh"));
+    let installer_url = Url::parse(&format!(
+        "https://github.com/CodSpeedHQ/runner/releases/download/v{version}/{installer_script}"
+    ))
+    .context("Invalid installer URL")?;
+
+    debug!("Downloading installer from: {installer_url}");
+
+    // Download the installer script to a temporary file
+    let temp_file = NamedTempFile::new().context("Failed to create temporary file")?;
+    download_file(&installer_url, temp_file.path()).await?;
+
+    // Execute the installer script
+    let output = Command::new("sh")
+        .arg(temp_file.path())
+        .output()
+        .context("Failed to execute installer command")?;
+
+    if !output.status.success() {
+        bail!(
+            "Failed to install {binary_name} version {version}. Installer exited with output: {output:?}",
+        );
+    }
+
+    info!("Successfully installed {binary_name} version {version}");
+    Ok(())
+}
+
+/// Check if the given command is installed and its version matches the expected version.
+///
+/// Expects the command to support the `--version` flag and return a version string.
+fn is_command_installed(command: &str, expected_version: Version) -> bool {
+    let is_command_installed = Command::new("which")
+        .arg(command)
+        .output()
+        .is_ok_and(|output| output.status.success());
+
+    if !is_command_installed {
+        debug!("{command} is not installed");
+        return false;
+    }
+
+    let Ok(version_output) = Command::new(command).arg("--version").output() else {
+        return false;
+    };
+
+    if !version_output.status.success() {
+        debug!(
+            "Failed to get valgrind version. stderr: {}",
+            String::from_utf8_lossy(&version_output.stderr)
+        );
+        return false;
+    }
+
+    let version_string = String::from_utf8_lossy(&version_output.stdout);
+    let Ok(version) = versions::parse_from_output(&version_string) else {
+        return false;
+    };
+
+    debug!("Found {command} version: {version}");
+
+    versions::is_compatible(command, &version, &expected_version)
+}

src/binary_installer/versions.rs

@@ -0,0 +1,134 @@
+use crate::prelude::*;
+use semver::Version;
+
+/// Parse a version string from command output.
+///
+/// Expects the output format to be: "command_name version_string"
+/// Example: "codspeed-memtrack 4.4.2"
+pub(super) fn parse_from_output(output: &str) -> Result<Version> {
+    let version_str = output
+        .split_once(" ")
+        .context("Unexpected version output format: missing space separator")?
+        .1
+        .trim();
+
+    Version::parse(version_str)
+        .with_context(|| format!("Failed to parse version from: {version_str}"))
+}
+
+/// Check if an installed version is compatible with the expected version.
+///
+/// Returns true if the installed version is greater than or equal to the expected version.
+/// Logs warnings for outdated or experimental versions.
+pub(super) fn is_compatible(command: &str, installed: &Version, expected: &Version) -> bool {
+    match installed.cmp(expected) {
+        std::cmp::Ordering::Less => {
+            warn!(
+                "{command} is installed but the version is too old. expecting {expected} or higher but found installed: {installed}",
+            );
+            false
+        }
+        std::cmp::Ordering::Greater => {
+            warn!(
+                "Using experimental {command} version {installed}. The recommended version is {expected}",
+            );
+            true
+        }
+        std::cmp::Ordering::Equal => true,
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    mod parse_version_from_output {
+        use super::*;
+
+        #[test]
+        fn parses_valid_version() {
+            let output = "codspeed-memtrack 4.4.2";
+            let version = parse_from_output(output).unwrap();
+            assert_eq!(version, Version::new(4, 4, 2));
+        }
+
+        #[test]
+        fn parses_version_with_prerelease() {
+            let output = "codspeed-exec-harness 4.4.2-alpha.2";
+            let version = parse_from_output(output).unwrap();
+            assert_eq!(version.major, 4);
+            assert_eq!(version.minor, 4);
+            assert_eq!(version.patch, 2);
+            assert_eq!(version.pre.as_str(), "alpha.2");
+        }
+    }
+
+    mod is_version_compatible {
+        use super::*;
+
+        #[test]
+        fn returns_true_for_equal_versions() {
+            let installed = Version::new(4, 4, 2);
+            let expected = Version::new(4, 4, 2);
+            assert!(is_compatible("test-cmd", &installed, &expected));
+        }
+
+        #[test]
+        fn returns_true_for_newer_version() {
+            let installed = Version::new(4, 5, 0);
+            let expected = Version::new(4, 4, 2);
+            assert!(is_compatible("test-cmd", &installed, &expected));
+        }
+
+        #[test]
+        fn returns_false_for_older_version() {
+            let installed = Version::new(4, 3, 0);
+            let expected = Version::new(4, 4, 2);
+            assert!(!is_compatible("test-cmd", &installed, &expected));
+        }
+
+        #[test]
+        fn handles_prerelease_versions() {
+            let installed = Version::parse("4.4.2-alpha.2").unwrap();
+            let expected = Version::new(4, 4, 1);
+            // 4.4.2-alpha.2 > 4.4.1 because 4.4.2 > 4.4.1
+            assert!(is_compatible("test-cmd", &installed, &expected));
+        }
+
+        #[test]
+        fn prerelease_different_stage() {
+            {
+                let installed = Version::parse("4.4.2-alpha.2").unwrap();
+                let expected = Version::new(4, 4, 2);
+                // 4.4.2-alpha.2 < 4.4.2
+                assert!(!is_compatible("test-cmd", &installed, &expected));
+            }
+
+            {
+                let installed = Version::parse("4.4.2-beta.1").unwrap();
+                let expected = Version::parse("4.4.2-alpha.1").unwrap();
+                assert!(is_compatible("test-cmd", &installed, &expected));
+            }
+
+            {
+                let installed = Version::new(4, 4, 2);
+                let expected = Version::parse("4.4.2-alpha.2").unwrap();
+                // 4.4.2 > 4.4.2-alpha.2
+                assert!(is_compatible("test-cmd", &installed, &expected));
+            }
+
+            {
+                let installed = Version::parse("4.4.2-alpha.1").unwrap();
+                let expected = Version::parse("4.4.2-beta.1").unwrap();
+                assert!(!is_compatible("test-cmd", &installed, &expected));
+            }
+        }
+
+        #[test]
+        fn prerelease_same_stage() {
+            let installed = Version::parse("4.4.2-alpha.1").unwrap();
+            let expected = Version::parse("4.4.2-alpha.2").unwrap();
+
+            assert!(!is_compatible("test-cmd", &installed, &expected));
+        }
+    }
+}

src/executor/memory/executor.rs

@@ -1,3 +1,4 @@
+use crate::binary_installer::ensure_binary_installed;
 use crate::executor::ExecutorName;
 use crate::executor::helpers::command::CommandBuilder;
 use crate::executor::helpers::get_bench_command::get_bench_command;
@@ -16,9 +17,11 @@ use runner_shared::artifacts::{ArtifactExt, ExecutionTimestamps};
 use runner_shared::fifo::Command as FifoCommand;
 use runner_shared::fifo::IntegrationMode;
 use std::path::Path;
-use std::process::Command;
 use std::rc::Rc;
 
+const MEMTRACK_COMMAND: &str = "codspeed-memtrack";
+const MEMTRACK_CODSPEED_VERSION: &str = env!("CARGO_PKG_VERSION");
+
 pub struct MemoryExecutor;
 
 impl MemoryExecutor {
@@ -57,19 +60,12 @@ impl Executor for MemoryExecutor {
         _system_info: &SystemInfo,
         _setup_cache_dir: Option<&Path>,
     ) -> Result<()> {
-        // Validate that the codspeed-memtrack command is available
-        let memtrack_path = std::env::var("CODSPEED_MEMTRACK_BINARY")
-            .unwrap_or_else(|_| "codspeed-memtrack".to_string());
-
-        info!("Validating memtrack binary at path: {memtrack_path}");
-        let output = Command::new(&memtrack_path).arg("--version").output()?;
-        if !output.status.success() {
-            bail!(
-                "codspeed-memtrack command is not available or failed to execute\nstdout: {}\nstderr: {}",
-                String::from_utf8_lossy(&output.stdout),
-                String::from_utf8_lossy(&output.stderr)
-            );
-        }
+        ensure_binary_installed(
+            MEMTRACK_COMMAND,
+            MEMTRACK_CODSPEED_VERSION,
+            Some("memtrack-installer.sh"),
+        )
+        .await?;
 
         Ok(())
     }

src/main.rs

@@ -1,6 +1,7 @@
 mod api_client;
 mod app;
 mod auth;
+mod binary_installer;
 mod config;
 mod exec;
 mod executor;