Merge branch 'main' into unix-socket-mode-test

Author: dmah42

.github/workflows/000-fmt-check.yml

@@ -0,0 +1,35 @@
+# ---------------------------------------------------------------------------- #
+#                |   █████╗ ██╗   ██╗██████╗  █████╗ ███████╗ |                #
+#                |  ██╔══██╗██║   ██║██╔══██╗██╔══██╗██╔════╝ |                #
+#                |  ███████║██║   ██║██████╔╝███████║█████╗   |                #
+#                |  ██╔══██║██║   ██║██╔══██╗██╔══██║██╔══╝   |                #
+#                |  ██║  ██║╚██████╔╝██║  ██║██║  ██║███████╗ |                #
+#                |  ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝ |                #
+#                +--------------------------------------------+                #
+#                                                                              #
+#                         Distributed Systems Runtime                          #
+# ---------------------------------------------------------------------------- #
+# Copyright 2022 - 2024, the aurae contributors                                #
+# SPDX-License-Identifier: Apache-2.0                                          #
+# ---------------------------------------------------------------------------- #
+#
+# Ensure the codebase is formatted. Fails if `cargo fmt` would change files.
+#
+name: "(000) [ubuntu:latest] cargo fmt --check"
+
+on:
+  push:
+    branches: main
+  pull_request:
+    branches: main
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  fmt:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Check formatting
+        run: cargo fmt --all -- --check

auraed/src/init/mod.rs

@@ -81,14 +81,15 @@ pub async fn init(
     socket_address: Option<String>,
 ) -> (Context, SocketStream) {
     let context = Context::get(nested);
-    let init_result = match context {
-        Context::Pid1 => Pid1SystemRuntime {}.init(verbose, socket_address),
-        Context::Cell => CellSystemRuntime {}.init(verbose, socket_address),
-        Context::Container => {
-            ContainerSystemRuntime {}.init(verbose, socket_address)
-        }
-        Context::Daemon => DaemonSystemRuntime {}.init(verbose, socket_address),
-    }
+    let init_result = init_with_runtimes(
+        context,
+        verbose,
+        socket_address,
+        Pid1SystemRuntime {},
+        CellSystemRuntime {},
+        ContainerSystemRuntime {},
+        DaemonSystemRuntime {},
+    )
     .await;
 
     match init_result {
@@ -97,6 +98,31 @@ pub async fn init(
     }
 }
 
+async fn init_with_runtimes<RPid1, RCell, RContainer, RDaemon>(
+    context: Context,
+    verbose: bool,
+    socket_address: Option<String>,
+    pid1_runtime: RPid1,
+    cell_runtime: RCell,
+    container_runtime: RContainer,
+    daemon_runtime: RDaemon,
+) -> Result<SocketStream, SystemRuntimeError>
+where
+    RPid1: SystemRuntime,
+    RCell: SystemRuntime,
+    RContainer: SystemRuntime,
+    RDaemon: SystemRuntime,
+{
+    match context {
+        Context::Pid1 => pid1_runtime.init(verbose, socket_address).await,
+        Context::Cell => cell_runtime.init(verbose, socket_address).await,
+        Context::Container => {
+            container_runtime.init(verbose, socket_address).await
+        }
+        Context::Daemon => daemon_runtime.init(verbose, socket_address).await,
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub enum Context {
     /// auraed is running as true PID 1
@@ -215,6 +241,16 @@ fn in_new_cgroup_namespace() -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::init::system_runtimes::{
+        SocketStream, SystemRuntime, SystemRuntimeError,
+    };
+    use anyhow::anyhow;
+    use std::sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    };
+    use tokio::runtime::Runtime;
+    use tonic::async_trait;
 
     fn pid_one() -> u32 {
         1
@@ -282,4 +318,83 @@ mod tests {
             Context::Cell
         );
     }
+
+    #[derive(Clone)]
+    struct MockRuntime {
+        calls: Arc<AtomicUsize>,
+        label: &'static str,
+    }
+
+    impl MockRuntime {
+        fn new(label: &'static str) -> Self {
+            Self { calls: Arc::new(AtomicUsize::new(0)), label }
+        }
+    }
+
+    #[async_trait]
+    impl SystemRuntime for Arc<MockRuntime> {
+        async fn init(
+            self,
+            _verbose: bool,
+            _socket_address: Option<String>,
+        ) -> Result<SocketStream, SystemRuntimeError> {
+            let _ = self.calls.fetch_add(1, Ordering::SeqCst);
+            Err(SystemRuntimeError::Other(anyhow!(self.label)))
+        }
+    }
+
+    fn assert_called_once(mock: &Arc<MockRuntime>) {
+        assert_eq!(
+            mock.calls.load(Ordering::SeqCst),
+            1,
+            "expected {} to be called once",
+            mock.label
+        );
+    }
+
+    #[test]
+    fn init_should_call_matching_system_runtime() {
+        // This test ensures the `init` dispatcher chooses the correct runtime
+        // implementation for each Context. We avoid spinning up real runtimes
+        // by injecting cheap mocks that count how many times they're called.
+        let rt = Runtime::new().expect("tokio runtime");
+
+        let pid1 = Arc::new(MockRuntime::new("pid1"));
+        let cell = Arc::new(MockRuntime::new("cell"));
+        let container = Arc::new(MockRuntime::new("container"));
+        let daemon = Arc::new(MockRuntime::new("daemon"));
+
+        rt.block_on(async {
+            // Each tuple represents (nested flag, pid, in_cgroup_namespace).
+            // We exercise the four Context variants the same way Context::get does.
+            let runtimes = [
+                (false, 1, false),
+                (true, 1, false),
+                (false, 42, true),
+                (false, 42, false),
+            ];
+
+            for (nested, pid, in_cgroup) in runtimes {
+                let ctx = derive_context(nested, pid, in_cgroup);
+
+                // Call the same routing code init() uses, but with our mocks.
+                let _ = init_with_runtimes(
+                    ctx,
+                    false,
+                    None,
+                    pid1.clone(),
+                    cell.clone(),
+                    container.clone(),
+                    daemon.clone(),
+                )
+                .await;
+            }
+        });
+
+        // Each mock should have been called exactly once by its matching Context.
+        assert_called_once(&pid1);
+        assert_called_once(&cell);
+        assert_called_once(&container);
+        assert_called_once(&daemon);
+    }
 }

auraed/src/lib.rs

@@ -355,3 +355,25 @@ pub fn prep_oci_spec_for_spawn(output: &str) -> Result<(), anyhow::Error> {
         .map_err(|e| anyhow!("building default oci spec: {e}"))?;
     spawn_auraed_oci_to(PathBuf::from(output), spec)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn auraed_runtime_default_socket_address_should_use_runtime_dir() {
+        let default_runtime = AuraedRuntime::default();
+        assert_eq!(
+            default_runtime.default_socket_address(),
+            PathBuf::from("/var/run/aurae/aurae.sock")
+        );
+
+        let custom_runtime_dir = PathBuf::from("/tmp/aurae-test-runtime");
+        let mut runtime = AuraedRuntime::default();
+        runtime.runtime_dir = custom_runtime_dir.clone();
+        assert_eq!(
+            runtime.default_socket_address(),
+            custom_runtime_dir.join("aurae.sock")
+        );
+    }
+}

auraed/tests/common/mod.rs

@@ -75,9 +75,11 @@ macro_rules! retry {
     }};
 }
 
+#[allow(dead_code)]
 static RT: Lazy<tokio::runtime::Runtime> =
     Lazy::new(|| tokio::runtime::Runtime::new().unwrap());
 
+#[allow(dead_code)]
 pub fn test<F>(f: F) -> F::Output
 where
     F: Future + Send + 'static,