[sled-agent] Create an "Executor", which intercepts requests through std::process::Command

Cargo.toml

@@ -56,6 +56,9 @@ members = [
     "sled-hardware",
     "sp-sim",
     "test-utils",
+    "helios/fusion",
+    "helios/protostar",
+    "helios/tokamak",
     "tufaceous-lib",
     "tufaceous",
     "update-engine",
@@ -118,6 +121,9 @@ default-members = [
     "sled-hardware",
     "sp-sim",
     "test-utils",
+    "helios/fusion",
+    "helios/protostar",
+    "helios/tokamak",
     "tufaceous",
     "tufaceous-lib",
     "update-engine",
@@ -194,6 +200,9 @@ gateway-test-utils = { path = "gateway-test-utils" }
 glob = "0.3.1"
 headers = "0.3.9"
 heck = "0.4"
+helios-fusion = { path = "helios/fusion" }
+helios-protostar = { path = "helios/protostar" }
+helios-tokamak = { path = "helios/tokamak" }
 hex = "0.4.3"
 hex-literal = "0.4.1"
 hkdf = "0.12.3"
@@ -221,7 +230,6 @@ libc = "0.2.148"
 linear-map = "1.2.0"
 macaddr = { version = "1.0.1", features = ["serde_std"] }
 mime_guess = "2.0.4"
-mockall = "0.11"
 newtype_derive = "0.1.6"
 nexus-client = { path = "nexus-client" }
 nexus-db-model = { path = "nexus/db-model" }
@@ -308,10 +316,10 @@ serde_path_to_error = "0.1.14"
 serde_tokenstream = "0.2"
 serde_urlencoded = "0.7.1"
 serde_with = "2.3.3"
-serial_test = "0.10"
 sha2 = "0.10.7"
 sha3 = "0.10.8"
 shell-words = "1.1.0"
+shlex = "1.1.0"
 signal-hook = "0.3"
 signal-hook-tokio = { version = "0.3", features = [ "futures-v0_3" ] }
 similar-asserts = "1.5.0"
@@ -323,7 +331,7 @@ slog-async = "2.8"
 slog-dtrace = "0.2"
 slog-envlogger = "2.2"
 slog-term = "2.9"
-smf = "0.2"
+smf = "0.2.2"
 snafu = "0.7"
 sp-sim = { path = "sp-sim" }
 sprockets-common = { git = "http://github.com/oxidecomputer/sprockets", rev = "77df31efa5619d0767ffc837ef7468101608aee9" }
@@ -374,7 +382,7 @@ wicket-common = { path = "wicket-common" }
 wicketd-client = { path = "wicketd-client" }
 zeroize = { version = "1.6.0", features = ["zeroize_derive", "std"] }
 zip = { version = "0.6.6", default-features = false, features = ["deflate","bzip2"] }
-zone = { version = "0.2", default-features = false, features = ["async"] }
+zone = { version = "0.3", default-features = false, features = ["async"] }
 
 [profile.dev]
 panic = "abort"

helios/README.adoc

@@ -0,0 +1,13 @@
+:showtitle:
+:toc: left
+:icons: font
+
+= helios
+
+This directory describes various interfaces for acting upon a Helios system.
+
+* `fusion` describes an interface for interacting with the underlying OS.
+* `tokamak` provides a fake implementation of `fusion` - not enough
+to be virtualized, but enough to test code depending on `fusion` under test.
+* `protostar` provides a real implementation of `fusion`, which should actually
+make calls to the underlying OS.

helios/fusion/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "helios-fusion"
+description = "Interface to access an underlying Helios system"
+version = "0.1.0"
+edition = "2021"
+license = "MPL-2.0"
+
+[dependencies]
+async-trait.workspace = true
+itertools.workspace = true
+shlex.workspace = true
+slog.workspace = true
+thiserror.workspace = true
+tokio.workspace = true
+omicron-workspace-hack = { version = "0.1", path = "../../workspace-hack" }

helios/fusion/src/error.rs

@@ -0,0 +1,75 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use slog::error;
+
+#[derive(Debug)]
+pub struct FailureInfo {
+    pub command: String,
+    pub status: std::process::ExitStatus,
+    pub stdout: String,
+    pub stderr: String,
+}
+
+impl std::fmt::Display for FailureInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(
+            f,
+            "Command [{}] executed and failed with status: {}",
+            self.command, self.status
+        )?;
+        write!(f, "  stdout: {}", self.stdout)?;
+        write!(f, "  stderr: {}", self.stderr)
+    }
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum ExecutionError {
+    #[error("Failed to start execution of [{command}]: {err}")]
+    ExecutionStart { command: String, err: std::io::Error },
+
+    #[error("{0}")]
+    CommandFailure(Box<FailureInfo>),
+
+    #[error("Failed to manipulate process contract: {err}")]
+    ContractFailure { err: std::io::Error },
+
+    #[error("Zone not running")]
+    NotRunning,
+}
+
+/// Convenience trait for turning [std::process::Command] into a String.
+pub trait AsCommandStr {
+    fn into_str(&self) -> String;
+}
+
+impl AsCommandStr for String {
+    fn into_str(&self) -> String {
+        self.into()
+    }
+}
+
+impl AsCommandStr for &std::process::Command {
+    fn into_str(&self) -> String {
+        shlex::join(
+            std::iter::once(self.get_program())
+                .chain(self.get_args())
+                .map(|s| s.to_str().expect("Invalid UTF-8")),
+        )
+    }
+}
+
+impl ExecutionError {
+    pub fn from_output<S: AsCommandStr>(
+        command: S,
+        output: &std::process::Output,
+    ) -> Self {
+        Self::CommandFailure(Box::new(FailureInfo {
+            command: command.into_str(),
+            status: output.status,
+            stdout: String::from_utf8_lossy(&output.stdout).to_string(),
+            stderr: String::from_utf8_lossy(&output.stderr).to_string(),
+        }))
+    }
+}

helios/fusion/src/executor.rs

@@ -0,0 +1,111 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+//! Interfaces used to interact with the underlying host system.
+
+use crate::{error::ExecutionError, input::Input, output::Output};
+
+use async_trait::async_trait;
+use itertools::Itertools;
+use slog::{debug, info, Logger};
+use std::io::{Read, Write};
+use std::process::Command;
+use std::str::from_utf8;
+use std::sync::Arc;
+
+fn to_space_separated_string<T, I>(iter: T) -> String
+where
+    T: IntoIterator<Item = I>,
+    I: std::fmt::Debug,
+{
+    Itertools::intersperse(
+        iter.into_iter().map(|arg| format!("{arg:?}")),
+        " ".into(),
+    )
+    .collect::<String>()
+}
+
+pub fn log_input(log: &Logger, id: u64, command: &Command) {
+    info!(
+        log,
+        "running command via executor"; "id" => id, "command" => %Input::from(command)
+    );
+    debug!(
+        log,
+        "running command via executor"; "id" => id, "envs" => %to_space_separated_string(command.get_envs())
+    );
+}
+
+pub fn log_output(log: &Logger, id: u64, output: &Output) {
+    info!(
+        log,
+        "finished running command via executor";
+        "id" => id,
+        "succeeded" => output.status.success(),
+        "status" => output.status.code()
+    );
+    if !output.stdout.is_empty() {
+        debug!(
+            log,
+            "finished command stdout";
+            "id" => id,
+            "stdout" => from_utf8(&output.stdout).unwrap_or("<Not valid UTF-8>"),
+        );
+    }
+    if !output.stderr.is_empty() {
+        debug!(
+            log,
+            "finished command stderr";
+            "id" => id,
+            "stderr" => from_utf8(&output.stderr).unwrap_or("<Not valid UTF-8>"),
+        );
+    }
+}
+
+/// Describes the commonly-used "safe-to-reference" type describing the
+/// Executor as a trait object.
+pub type BoxedExecutor = Arc<dyn Executor>;
+
+/// Describes an "executor", which can run [Command]s and return a response.
+///
+/// - In production, this is usually `helios_protostar`'s executor.
+/// - Under test, this can be customized, and `helios_tokamak`'s executor may be used.
+#[async_trait]
+pub trait Executor: Send + Sync {
+    /// Executes a task, waiting for it to complete, and returning output.
+    async fn execute_async(
+        &self,
+        command: &mut tokio::process::Command,
+    ) -> Result<Output, ExecutionError>;
+
+    /// Executes a task, waiting for it to complete, and returning output.
+    fn execute(&self, command: &mut Command) -> Result<Output, ExecutionError>;
+
+    /// Spawns a task, without waiting for it to complete.
+    fn spawn(
+        &self,
+        command: &mut Command,
+    ) -> Result<BoxedChild, ExecutionError>;
+}
+
+/// A wrapper around a spawned [Child] process.
+pub type BoxedChild = Box<dyn Child>;
+
+/// A child process spawned by the executor.
+pub trait Child: Send {
+    /// Accesses the stdin of the spawned child, as a Writer.
+    fn take_stdin(&mut self) -> Option<Box<dyn Write + Send>>;
+
+    /// Accesses the stdout of the spawned child, as a Reader.
+    fn take_stdout(&mut self) -> Option<Box<dyn Read + Send>>;
+
+    /// Accesses the stderr of the spawned child, as a Reader.
+    fn take_stderr(&mut self) -> Option<Box<dyn Read + Send>>;
+
+    /// OS-assigned PID identifier for the child
+    fn id(&self) -> u32;
+
+    /// Waits for the child to complete, and returns the output.
+    fn wait(self: Box<Self>) -> Result<Output, ExecutionError>;
+}

helios/fusion/src/input.rs

@@ -0,0 +1,67 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use std::process::Command;
+
+/// Wrapper around the input of a [std::process::Command] as strings.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Input {
+    pub program: String,
+    pub args: Vec<String>,
+    pub envs: Vec<(String, String)>,
+}
+
+impl Input {
+    pub fn new<S: Into<String>>(program: S, args: Vec<S>) -> Self {
+        Self {
+            program: program.into(),
+            args: args.into_iter().map(|s| s.into()).collect(),
+            envs: vec![],
+        }
+    }
+
+    /// Short-hand for a whitespace-separated string, which can be provided
+    /// "like a shell command".
+    pub fn shell<S: AsRef<str>>(input: S) -> Self {
+        let mut args = shlex::split(input.as_ref()).expect("Invalid input");
+
+        if args.is_empty() {
+            panic!("Empty input is invalid");
+        }
+
+        Self::new(args.remove(0), args)
+    }
+}
+
+impl std::fmt::Display for Input {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", shlex::quote(&self.program))?;
+        for arg in &self.args {
+            write!(f, " {}", shlex::quote(arg))?;
+        }
+        Ok(())
+    }
+}
+
+fn os_str_to_string(s: &std::ffi::OsStr) -> String {
+    s.to_string_lossy().to_string()
+}
+
+impl From<&Command> for Input {
+    fn from(command: &Command) -> Self {
+        Self {
+            program: os_str_to_string(command.get_program()),
+            args: command.get_args().map(os_str_to_string).collect(),
+            envs: command
+                .get_envs()
+                .map(|(k, v)| {
+                    (
+                        os_str_to_string(k),
+                        os_str_to_string(v.unwrap_or_default()),
+                    )
+                })
+                .collect(),
+        }
+    }
+}

helios/fusion/src/lib.rs

@@ -0,0 +1,17 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+//! Interfaces used to interact with the underlying host system.
+
+mod error;
+mod executor;
+mod input;
+mod output;
+
+pub use error::*;
+pub use executor::*;
+pub use input::*;
+pub use output::*;
+
+pub const PFEXEC: &str = "/usr/bin/pfexec";