feat: add command runner

Author: jnsgruk

snap/snapcraft.yaml

@@ -1,16 +1,16 @@
 name: oxidizr
 adopt-info: oxidizr
-summary: TODO
+summary: A tool for experimenting with Rust-based packages on Ubuntu
 description: |
-  TODO
+  A tool for enabling/disabling experimental Rust-based packages on Ubuntu.
 
 license: Apache-2.0
 contact: https://github.com/jnsgruk/oxidizr/issues
 issues: https://github.com/jnsgruk/oxidizr/issues
 source-code: https://github.com/jnsgruk/oxidizr
 
 base: core24
-confinement: strict
+confinement: classic
 grade: stable
 compression: lzo
 
@@ -22,7 +22,9 @@ parts:
   oxidizr:
     plugin: rust
     source: .
-    override-prime: |
+    build-attributes:
+      - enable-patchelf
+    override-stage: |
       craftctl default
       bin_version="$($CRAFT_PRIME/bin/oxidizr --version | cut -d" " -f2)"
       craftctl set version="$bin_version"

src/main.rs

@@ -1,11 +1,15 @@
 pub mod packages;
 pub mod utils;
 
+use std::sync::Arc;
+
 use anyhow::Result;
 use clap::Parser;
 use clap_verbosity_flag::{InfoLevel, Verbosity};
+use packages::{Experiment, RustCoreutils, RustDiffutils, RustFindutils};
+use tracing::info;
 use tracing_subscriber::{fmt, prelude::*};
-use utils::update_package_lists;
+use utils::{update_package_lists, System};
 
 /// A command-line utility to install modern Rust-based replacements of essential
 /// packages such as coreutils, findutils, diffutils and sudo and make them the
@@ -34,15 +38,22 @@ fn main() -> Result<()> {
         "This program must be run as root"
     );
 
+    let system = Arc::new(System {});
+
+    let coreutils = RustCoreutils::new(system.clone());
+    let findutils = RustFindutils::new(system.clone());
+    let diffutils = RustDiffutils::new(system.clone());
+
     if args.restore {
-        packages::RustCoreutils::restore()?;
-        packages::RustFindutils::restore()?;
-        packages::RustDiffutils::restore()?;
+        coreutils.restore()?;
+        findutils.restore()?;
+        diffutils.restore()?;
     } else {
-        update_package_lists()?;
-        packages::RustCoreutils::install()?;
-        packages::RustFindutils::install()?;
-        packages::RustDiffutils::install()?;
+        info!("Updating apt cache");
+        update_package_lists(system.clone())?;
+        coreutils.install()?;
+        findutils.install()?;
+        diffutils.install()?;
     }
 
     Ok(())

src/packages/coreutils.rs

@@ -1,43 +1,59 @@
 use crate::utils::{
     install_package, list_files, release, remove_package, replace_file_with_symlink, restore_file,
+    Worker,
 };
 use anyhow::Result;
-use std::path::PathBuf;
-use tracing::{debug, info, warn};
+use std::{path::PathBuf, sync::Arc};
+use tracing::{info, warn};
+
+use super::Experiment;
 
 const PACKAGE: &str = "rust-coreutils";
 const FIRST_SUPPORTED_RELEASE: &str = "24.04";
 
-pub struct RustCoreutils {}
+pub struct RustCoreutils {
+    system: Arc<dyn Worker>,
+}
 
 impl RustCoreutils {
-    pub fn install() -> Result<()> {
+    fn installed() -> bool {
+        list_files("/usr/lib/cargo/bin/coreutils").is_ok()
+    }
+
+    fn compatible() -> bool {
+        match release() {
+            Ok(codename) => codename.as_str() >= FIRST_SUPPORTED_RELEASE,
+            Err(_) => false,
+        }
+    }
+}
+
+impl Experiment for RustCoreutils {
+    fn new(system: Arc<dyn Worker>) -> Self {
+        Self { system }
+    }
+
+    fn install(&self) -> Result<()> {
         if !Self::compatible() {
             warn!("Skipping '{PACKAGE}'. Minimum supported release is {FIRST_SUPPORTED_RELEASE}.");
             return Ok(());
         }
 
         info!("Installing and configuring {}", PACKAGE);
 
-        install_package(PACKAGE)?;
+        install_package(self.system.clone(), PACKAGE)?;
 
-        let files = list_files("/usr/lib/cargo/bin/coreutils")?;
+        let files = self.system.list_files("/usr/lib/cargo/bin/coreutils")?;
 
         for f in files {
             let filename = f.file_name().unwrap();
             let existing = PathBuf::from("/usr/bin").join(filename);
             replace_file_with_symlink(PathBuf::from("/usr/bin/coreutils"), existing.clone())?;
-
-            debug!(
-                "Replaced {} with symlink to {}",
-                existing.display(),
-                f.display()
-            );
         }
         Ok(())
     }
 
-    pub fn restore() -> Result<()> {
+    fn restore(&self) -> Result<()> {
         if !Self::installed() || !Self::compatible() {
             warn!("{PACKAGE} not found, skipping restore");
             return Ok(());
@@ -53,19 +69,42 @@ impl RustCoreutils {
             restore_file(existing)?;
         }
 
-        remove_package(PACKAGE)?;
+        remove_package(self.system.clone(), PACKAGE)?;
 
         Ok(())
     }
+}
 
-    fn installed() -> bool {
-        list_files("/usr/lib/cargo/bin/coreutils").is_ok()
-    }
-
-    fn compatible() -> bool {
-        match release() {
-            Ok(codename) => codename.as_str() >= FIRST_SUPPORTED_RELEASE,
-            Err(_) => false,
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::utils::{tests::MockSystem, Command};
+
+    #[test]
+    fn test_coreutils_install() -> Result<()> {
+        let runner = Arc::new(MockSystem::new());
+        let coreutils = RustCoreutils::new(runner.clone());
+
+        let mock_files = &[
+            "/usr/lib/cargo/bin/coreutils/date",
+            "/usr/lib/cargo/bin/coreutils/sort",
+            "/usr/lib/cargo/bin/diffutils/diff",
+            "/usr/lib/share/foo",
+        ];
+
+        for file in mock_files {
+            runner.mock_file(PathBuf::from(file), "");
         }
+
+        // assert!(coreutils.install().is_ok());
+        let cmd = Command::build("lsb_release", &["-cs"]);
+        runner.run(&cmd)?;
+
+        assert_eq!(
+            runner.commands.clone().into_inner(),
+            vec!("lsb_release -cs")
+        );
+
+        Ok(())
     }
 }

src/packages/diffutils.rs

@@ -1,24 +1,46 @@
 use crate::utils::{
     install_package, list_files, release, remove_package, replace_file_with_symlink, restore_file,
+    Worker,
 };
 use anyhow::Result;
-use std::path::PathBuf;
+use std::{path::PathBuf, sync::Arc};
 use tracing::{info, warn};
 
+use super::Experiment;
+
 const PACKAGE: &str = "rust-diffutils";
 const FIRST_SUPPORTED_RELEASE: &str = "24.10";
-pub struct RustDiffutils {}
+pub struct RustDiffutils {
+    system: Arc<dyn Worker>,
+}
 
 impl RustDiffutils {
-    pub fn install() -> Result<()> {
+    fn installed() -> bool {
+        list_files("/usr/lib/cargo/bin/diffutils").is_ok()
+    }
+
+    fn compatible() -> bool {
+        match release() {
+            Ok(codename) => codename.as_str() >= FIRST_SUPPORTED_RELEASE,
+            Err(_) => false,
+        }
+    }
+}
+
+impl Experiment for RustDiffutils {
+    fn new(system: Arc<dyn Worker>) -> Self {
+        Self { system }
+    }
+
+    fn install(&self) -> Result<()> {
         if !Self::compatible() {
             warn!("Skipping '{PACKAGE}'. Minimum supported release is {FIRST_SUPPORTED_RELEASE}.");
             return Ok(());
         }
 
         info!("Installing and configuring {}", PACKAGE);
 
-        install_package(PACKAGE)?;
+        install_package(self.system.clone(), PACKAGE)?;
 
         let files = list_files("/usr/lib/cargo/bin/diffutils")?;
 
@@ -30,7 +52,7 @@ impl RustDiffutils {
         Ok(())
     }
 
-    pub fn restore() -> Result<()> {
+    fn restore(&self) -> Result<()> {
         if !Self::installed() || !Self::compatible() {
             warn!("{PACKAGE} not found, skipping restore");
             return Ok(());
@@ -46,19 +68,8 @@ impl RustDiffutils {
             restore_file(existing)?;
         }
 
-        remove_package(PACKAGE)?;
+        remove_package(self.system.clone(), PACKAGE)?;
 
         Ok(())
     }
-
-    fn installed() -> bool {
-        list_files("/usr/lib/cargo/bin/diffutils").is_ok()
-    }
-
-    fn compatible() -> bool {
-        match release() {
-            Ok(codename) => codename.as_str() >= FIRST_SUPPORTED_RELEASE,
-            Err(_) => false,
-        }
-    }
 }

src/packages/findutils.rs

@@ -1,25 +1,47 @@
 use crate::utils::{
     install_package, list_files, release, remove_package, replace_file_with_symlink, restore_file,
+    Worker,
 };
 use anyhow::Result;
-use std::path::PathBuf;
+use std::{path::PathBuf, sync::Arc};
 use tracing::{info, warn};
 
+use super::Experiment;
+
 const PACKAGE: &str = "rust-findutils";
 const FIRST_SUPPORTED_RELEASE: &str = "24.04";
 
-pub struct RustFindutils {}
+pub struct RustFindutils {
+    system: Arc<dyn Worker>,
+}
 
 impl RustFindutils {
-    pub fn install() -> Result<()> {
+    fn installed() -> bool {
+        list_files("/usr/lib/cargo/bin/findutils").is_ok()
+    }
+
+    fn compatible() -> bool {
+        match release() {
+            Ok(codename) => codename.as_str() >= FIRST_SUPPORTED_RELEASE,
+            Err(_) => false,
+        }
+    }
+}
+
+impl Experiment for RustFindutils {
+    fn new(system: Arc<dyn Worker>) -> Self {
+        Self { system }
+    }
+
+    fn install(&self) -> Result<()> {
         if !Self::compatible() {
             warn!("Skipping '{PACKAGE}'. Minimum supported release is {FIRST_SUPPORTED_RELEASE}.");
             return Ok(());
         }
 
         info!("Installing and configuring {}", PACKAGE);
 
-        install_package(PACKAGE)?;
+        install_package(self.system.clone(), PACKAGE)?;
 
         let files = list_files("/usr/lib/cargo/bin/findutils")?;
 
@@ -31,7 +53,7 @@ impl RustFindutils {
         Ok(())
     }
 
-    pub fn restore() -> Result<()> {
+    fn restore(&self) -> Result<()> {
         if !Self::installed() || !Self::compatible() {
             warn!("{PACKAGE} not found, skipping restore");
             return Ok(());
@@ -47,19 +69,8 @@ impl RustFindutils {
             restore_file(existing)?;
         }
 
-        remove_package(PACKAGE)?;
+        remove_package(self.system.clone(), PACKAGE)?;
 
         Ok(())
     }
-
-    fn installed() -> bool {
-        list_files("/usr/lib/cargo/bin/findutils").is_ok()
-    }
-
-    fn compatible() -> bool {
-        match release() {
-            Ok(codename) => codename.as_str() >= FIRST_SUPPORTED_RELEASE,
-            Err(_) => false,
-        }
-    }
 }

src/packages/mod.rs

@@ -2,6 +2,18 @@ mod coreutils;
 mod diffutils;
 mod findutils;
 
+use std::sync::Arc;
+
 pub use coreutils::RustCoreutils;
 pub use diffutils::RustDiffutils;
 pub use findutils::RustFindutils;
+
+use anyhow::Result;
+
+use crate::utils::Worker;
+
+pub trait Experiment {
+    fn new(system: Arc<dyn Worker>) -> Self;
+    fn install(&self) -> Result<()>;
+    fn restore(&self) -> Result<()>;
+}