feat(system): represent the host OS as a SupportedOs enum with per-executor support gates

Only supported Oses can be represented, the runner will bail if it
detects a non supported os.
Then, each executor can define its support level for the current system
depending on the Os and, for example, the linux distribution/version.

Author: GuillaumeLagrange

src/cli/setup.rs

@@ -1,4 +1,4 @@
-use crate::executor::{ToolInstallStatus, get_all_executors};
+use crate::executor::{ExecutorSupport, ToolInstallStatus, get_all_executors};
 use crate::prelude::*;
 use crate::system::SystemInfo;
 use clap::{Args, Subcommand};
@@ -22,10 +22,7 @@ enum SetupCommands {
 pub async fn run(args: SetupArgs, setup_cache_dir: Option<&Path>) -> Result<()> {
     match args.command {
         None => setup(setup_cache_dir).await,
-        Some(SetupCommands::Status) => {
-            status();
-            Ok(())
-        }
+        Some(SetupCommands::Status) => status(),
     }
 }
 
@@ -34,41 +31,81 @@ async fn setup(setup_cache_dir: Option<&Path>) -> Result<()> {
     let executors = get_all_executors();
     start_group!("Setting up the environment for all executors");
     for executor in executors {
-        info!(
-            "Setting up the environment for the executor: {}",
-            executor.name()
-        );
-        executor.setup(&system_info, setup_cache_dir).await?;
+        match executor.support_level(&system_info) {
+            ExecutorSupport::Unsupported => {
+                info!(
+                    "Skipping setup for the {} executor: not supported on {}",
+                    executor.name(),
+                    system_info.os
+                );
+            }
+            ExecutorSupport::RequiresManualInstallation => {
+                info!(
+                    "Skipping automatic setup for the {} executor on {}; install required tooling manually.",
+                    executor.name(),
+                    system_info.os
+                );
+            }
+            ExecutorSupport::FullySupported => {
+                info!(
+                    "Setting up the environment for the executor: {}",
+                    executor.name()
+                );
+                executor.setup(&system_info, setup_cache_dir).await?;
+            }
+        }
     }
     info!("Environment setup completed");
     end_group!();
     Ok(())
 }
 
-pub fn status() {
+pub fn status() -> Result<()> {
+    let system_info = SystemInfo::new()?;
     info!("{}", style("Tools").bold());
     for executor in get_all_executors() {
-        let tool_status = executor.tool_status();
-        match &tool_status.status {
-            ToolInstallStatus::Installed { version } => {
-                info!("  {} {} ({})", check_mark(), tool_status.tool_name, version);
-            }
-            ToolInstallStatus::IncorrectVersion { version, message } => {
-                info!(
-                    "  {} {} ({}, {})",
-                    warn_mark(),
-                    tool_status.tool_name,
-                    version,
-                    message
-                );
-            }
-            ToolInstallStatus::NotInstalled => {
+        // Don't probe for tooling that can't be used on this OS anyway.
+        if executor.support_level(&system_info) == ExecutorSupport::Unsupported {
+            continue;
+        }
+        match executor.tool_status() {
+            Some(tool_status) => match &tool_status.status {
+                ToolInstallStatus::Installed { version } => {
+                    info!(
+                        "  {} {} executor: {} ({})",
+                        check_mark(),
+                        executor.name(),
+                        tool_status.tool_name,
+                        version
+                    );
+                }
+                ToolInstallStatus::IncorrectVersion { version, message } => {
+                    info!(
+                        "  {} {} executor: {} ({}, {})",
+                        warn_mark(),
+                        executor.name(),
+                        tool_status.tool_name,
+                        version,
+                        message
+                    );
+                }
+                ToolInstallStatus::NotInstalled => {
+                    info!(
+                        "  {} {} executor: {} (not installed)",
+                        cross_mark(),
+                        executor.name(),
+                        tool_status.tool_name
+                    );
+                }
+            },
+            None => {
                 info!(
-                    "  {} {} (not installed)",
-                    cross_mark(),
-                    tool_status.tool_name
+                    "  {} {} executor: No tool to install",
+                    check_mark(),
+                    executor.name()
                 );
             }
         }
     }
+    Ok(())
 }

src/cli/status.rs

@@ -22,17 +22,14 @@ pub async fn run(api_client: &CodSpeedAPIClient) -> Result<()> {
     info!("");
 
     // Setup/tools status
-    super::setup::status();
+    super::setup::status()?;
     info!("");
 
     // System info
     info!("{}", style("System").bold());
     info!("  codspeed {VERSION}");
     let system_info = SystemInfo::new()?;
-    info!(
-        "  {} {} ({})",
-        system_info.os, system_info.os_version, system_info.arch
-    );
+    info!("  {} ({})", system_info.os, system_info.arch);
     info!(
         "  {} ({}C / {}GB)",
         system_info.cpu_brand, system_info.cpu_cores, system_info.total_memory_gb

src/executor/helpers/apt.rs

@@ -1,13 +1,13 @@
 use super::run_with_sudo::run_with_sudo;
 use crate::prelude::*;
-use crate::system::SystemInfo;
+use crate::system::{SupportedOs, SystemInfo};
 use std::path::Path;
 use std::process::Command;
 
 const METADATA_FILENAME: &str = "./tmp/codspeed-cache-metadata.txt";
 
 fn is_system_compatible(system_info: &SystemInfo) -> bool {
-    system_info.os == "ubuntu" || system_info.os == "debian"
+    matches!(system_info.os, SupportedOs::Linux(ref distro) if distro.is_supported())
 }
 
 /// Installs packages with caching support.

src/executor/memory/executor.rs

@@ -1,4 +1,5 @@
 use crate::executor::ExecutorName;
+use crate::executor::ExecutorSupport;
 use crate::executor::ToolStatus;
 use crate::executor::helpers::command::CommandBuilder;
 use crate::executor::helpers::env::get_base_injected_env;
@@ -11,7 +12,7 @@ use crate::executor::{ExecutionContext, Executor};
 use crate::instruments::mongo_tracer::MongoTracer;
 use crate::prelude::*;
 use crate::runner_mode::RunnerMode;
-use crate::system::SystemInfo;
+use crate::system::{SupportedOs, SystemInfo};
 use async_trait::async_trait;
 use ipc_channel::ipc;
 use memtrack::MemtrackIpcClient;
@@ -72,8 +73,15 @@ impl Executor for MemoryExecutor {
         ExecutorName::Memory
     }
 
-    fn tool_status(&self) -> ToolStatus {
-        get_memtrack_status()
+    fn tool_status(&self) -> Option<ToolStatus> {
+        Some(get_memtrack_status())
+    }
+
+    fn support_level(&self, system_info: &SystemInfo) -> ExecutorSupport {
+        match &system_info.os {
+            SupportedOs::Linux(_) => ExecutorSupport::FullySupported,
+            SupportedOs::Macos { .. } => ExecutorSupport::Unsupported,
+        }
     }
 
     async fn setup(

src/executor/mod.rs

@@ -73,12 +73,28 @@ pub enum ToolInstallStatus {
     NotInstalled,
 }
 
+/// How well a given executor runs on a given [`SupportedOs`].
+#[derive(Debug, Eq, PartialEq, Clone, Copy)]
+pub enum ExecutorSupport {
+    /// The executor cannot run on this OS at all — `run_executor` hard-bails.
+    Unsupported,
+    /// The executor runs on this OS, but the user is responsible for installing the required tooling themselves.
+    RequiresManualInstallation,
+    /// The executor runs on this OS and `setup()` knows how to auto-install tooling.
+    FullySupported,
+}
+
 #[async_trait(?Send)]
 pub trait Executor {
     fn name(&self) -> ExecutorName;
 
     /// Report the installation status of the tool(s) this executor depends on.
-    fn tool_status(&self) -> ToolStatus;
+    fn tool_status(&self) -> Option<ToolStatus>;
+
+    /// Declare how well this executor runs on the host system. Drives whether `setup()` is invoked
+    /// (only when [`ExecutorSupport::FullySupported`]) and whether we bail out of running the
+    /// executor at all (on [`ExecutorSupport::Unsupported`]).
+    fn support_level(&self, system_info: &SystemInfo) -> ExecutorSupport;
 
     async fn setup(
         &self,
@@ -107,11 +123,24 @@ pub async fn run_executor(
     execution_context: &ExecutionContext,
     setup_cache_dir: Option<&Path>,
 ) -> Result<()> {
-    if !execution_context.config.skip_setup {
-        executor
-            .setup(&orchestrator.system_info, setup_cache_dir)
-            .await?;
+    match executor.support_level(&orchestrator.system_info) {
+        ExecutorSupport::Unsupported => {
+            bail!(
+                "The {} executor is not supported on {}",
+                executor.name(),
+                orchestrator.system_info.os
+            );
+        }
+        ExecutorSupport::RequiresManualInstallation | ExecutorSupport::FullySupported => {
+            if !execution_context.config.skip_setup {
+                executor
+                    .setup(&orchestrator.system_info, setup_cache_dir)
+                    .await?;
+            }
+        }
+    }
 
+    if !execution_context.config.skip_setup {
         // TODO: refactor and move directly in the Instruments struct as a `setup` method
         if execution_context.config.instruments.is_mongodb_enabled() {
             install_mongodb_tracer().await?;

src/executor/orchestrator.rs

@@ -11,7 +11,7 @@ use crate::local_logger::rolling_buffer::{activate_rolling_buffer, deactivate_ro
 use crate::prelude::*;
 use crate::run_environment::{self, RunEnvironment, RunEnvironmentProvider};
 use crate::runner_mode::RunnerMode;
-use crate::system::{self, SystemInfo};
+use crate::system::SystemInfo;
 use crate::upload::poll_results::poll_results;
 use crate::upload::{UploadResult, upload};
 use serde_json::Value;
@@ -43,7 +43,6 @@ impl Orchestrator {
     ) -> Result<Self> {
         let provider = run_environment::get_provider(&config, api_client).await?;
         let system_info = SystemInfo::new()?;
-        system::check_system(&system_info)?;
         let logger = Logger::new(provider.as_ref())?;
 
         if provider.get_run_environment() == RunEnvironment::Local {

src/executor/valgrind/executor.rs

@@ -3,12 +3,14 @@ use std::path::Path;
 
 use crate::executor::Executor;
 use crate::executor::ToolStatus;
-use crate::executor::{ExecutionContext, ExecutorName};
+use crate::executor::{ExecutionContext, ExecutorName, ExecutorSupport};
 use crate::instruments::mongo_tracer::MongoTracer;
 use crate::prelude::*;
-use crate::system::SystemInfo;
+use crate::system::{SupportedOs, SystemInfo};
 
-use super::setup::{get_valgrind_status, install_valgrind};
+use super::setup::get_valgrind_status;
+use super::setup::install_valgrind;
+use super::setup::is_codspeed_valgrind_installation_supported;
 use super::{helpers::perf_maps::harvest_perf_maps, helpers::venv_compat, measure};
 
 pub struct ValgrindExecutor;
@@ -19,8 +21,21 @@ impl Executor for ValgrindExecutor {
         ExecutorName::Valgrind
     }
 
-    fn tool_status(&self) -> ToolStatus {
-        get_valgrind_status()
+    fn tool_status(&self) -> Option<ToolStatus> {
+        Some(get_valgrind_status())
+    }
+
+    fn support_level(&self, system_info: &SystemInfo) -> ExecutorSupport {
+        match &system_info.os {
+            SupportedOs::Linux(_) => {
+                if is_codspeed_valgrind_installation_supported(system_info) {
+                    ExecutorSupport::FullySupported
+                } else {
+                    ExecutorSupport::RequiresManualInstallation
+                }
+            }
+            SupportedOs::Macos { .. } => ExecutorSupport::Unsupported,
+        }
     }
 
     async fn setup(&self, system_info: &SystemInfo, setup_cache_dir: Option<&Path>) -> Result<()> {