wip

Signed-off-by: Matej Hrica <mhrica@redhat.com>

Author: mtjhrc

tests/runner/src/main.rs

@@ -8,7 +8,9 @@ use std::panic::catch_unwind;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 use tempdir::TempDir;
-use test_cases::{test_cases, rootfs_images, Report, ShouldRun, Test, TestCase, TestOutcome, TestSetup};
+use test_cases::{
+    rootfs_images, test_cases, Report, ShouldRun, Test, TestCase, TestOutcome, TestSetup,
+};
 
 struct TestResult {
     name: String,
@@ -328,8 +330,10 @@ fn build_images() -> anyhow::Result<()> {
 
     for (name, _) in rootfs_images() {
         eprint!("Building rootfs image {name}...");
-        rootfs::build_rootfs(name)?;
-        eprintln!(" done");
+        match rootfs::build_rootfs(name) {
+            Ok(()) => eprintln!(" done"),
+            Err(e) => eprintln!(" skipped ({e})"),
+        }
     }
     Ok(())
 }

tests/test_cases/src/common.rs

@@ -58,7 +58,11 @@ pub fn setup_existing_rootfs_and_enter(
     test_setup: TestSetup,
     rootfs_dir: &Path,
 ) -> anyhow::Result<()> {
-    anyhow::ensure!(rootfs_dir.is_dir(), "rootfs directory not found: {}", rootfs_dir.display());
+    anyhow::ensure!(
+        rootfs_dir.is_dir(),
+        "rootfs directory not found: {}",
+        rootfs_dir.display()
+    );
     let path_str = CString::new(rootfs_dir.as_os_str().as_bytes()).context("CString::new")?;
     copy_guest_agent(rootfs_dir)?;
     unsafe {

tests/test_cases/src/lib.rs

@@ -72,25 +72,44 @@ pub fn test_cases() -> Vec<TestCase> {
         TestCase::new("net-tap", Box::new(TestNet::new_tap())),
         TestCase::new("net-gvproxy", Box::new(TestNet::new_gvproxy())),
         TestCase::new("multiport-console", Box::new(TestMultiportConsole)),
-        TestCase::new("perf-net-passt-upload", Box::new(TestNetPerf::new_passt_upload())),
-        TestCase::new("perf-net-passt-download", Box::new(TestNetPerf::new_passt_download())),
-        TestCase::new("perf-net-tap-upload", Box::new(TestNetPerf::new_tap_upload())),
-        TestCase::new("perf-net-tap-download", Box::new(TestNetPerf::new_tap_download())),
-        TestCase::new("perf-net-gvproxy-upload", Box::new(TestNetPerf::new_gvproxy_upload())),
-        TestCase::new("perf-net-gvproxy-download", Box::new(TestNetPerf::new_gvproxy_download())),
+        TestCase::new(
+            "perf-net-passt-upload",
+            Box::new(TestNetPerf::new_passt_upload()),
+        ),
+        TestCase::new(
+            "perf-net-passt-download",
+            Box::new(TestNetPerf::new_passt_download()),
+        ),
+        TestCase::new(
+            "perf-net-tap-upload",
+            Box::new(TestNetPerf::new_tap_upload()),
+        ),
+        TestCase::new(
+            "perf-net-tap-download",
+            Box::new(TestNetPerf::new_tap_download()),
+        ),
+        TestCase::new(
+            "perf-net-gvproxy-upload",
+            Box::new(TestNetPerf::new_gvproxy_upload()),
+        ),
+        TestCase::new(
+            "perf-net-gvproxy-download",
+            Box::new(TestNetPerf::new_gvproxy_download()),
+        ),
     ]
 }
 
 /// Registry of container images used by tests.
 /// Each entry maps a name to a Containerfile that will be built and cached via podman.
 #[host]
 pub fn rootfs_images() -> &'static [(&'static str, &'static str)] {
-    &[
-        ("fedora-iperf3", "\
+    &[(
+        "fedora-iperf3",
+        "\
 FROM fedora:43
 RUN dnf install -y iperf3 && dnf clean all
-"),
-    ]
+",
+    )]
 }
 
 ////////////////////

tests/test_cases/src/net_config.rs

@@ -59,7 +59,12 @@ pub fn make_sockaddr_in(ip: [u8; 4]) -> nix::libc::sockaddr {
 
 /// Configure a network interface with IP address and netmask, and bring it UP
 pub fn configure_interface(name: &str, ip: [u8; 4], netmask: [u8; 4]) -> nix::Result<()> {
-    let sock = socket(AddressFamily::Inet, SockType::Datagram, SockFlag::empty(), None)?;
+    let sock = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )?;
     let fd = sock.as_raw_fd();
 
     // Set IP address

tests/test_cases/src/rootfs.rs

@@ -66,7 +66,9 @@ pub fn build_rootfs(name: &str) -> anyhow::Result<()> {
         .write_all(containerfile.as_bytes())
         .context("writing containerfile to podman stdin")?;
 
-    let output = build.wait_with_output().context("waiting for podman build")?;
+    let output = build
+        .wait_with_output()
+        .context("waiting for podman build")?;
     if !output.status.success() {
         let stderr = String::from_utf8_lossy(&output.stderr);
         bail!("podman build failed: {stderr}");

tests/test_cases/src/test_net/gvproxy.rs

@@ -39,7 +39,9 @@ fn gvproxy_path() -> Option<String> {
         .ok()
         .and_then(|o| {
             if o.status.success() {
-                String::from_utf8(o.stdout).ok().map(|s| s.trim().to_string())
+                String::from_utf8(o.stdout)
+                    .ok()
+                    .map(|s| s.trim().to_string())
             } else {
                 None
             }
@@ -101,10 +103,7 @@ pub(crate) fn setup_backend(ctx: u32, test_setup: &TestSetup) -> anyhow::Result<
     let socket_path = tmp_dir.join("gvproxy.sock");
     let gvproxy_log = tmp_dir.join("gvproxy.log");
 
-    let _gvproxy_child = start_gvproxy(
-        socket_path.to_str().unwrap(),
-        &gvproxy_log,
-    )?;
+    let _gvproxy_child = start_gvproxy(socket_path.to_str().unwrap(), &gvproxy_log)?;
 
     anyhow::ensure!(
         wait_for_socket(&socket_path, 5000),

tests/test_cases/src/test_net/mod.rs

@@ -11,12 +11,12 @@ use macros::{guest, host};
 #[host]
 use crate::{ShouldRun, TestSetup};
 
+#[cfg(feature = "host")]
+pub(crate) mod gvproxy;
 #[cfg(feature = "host")]
 pub(crate) mod passt;
 #[cfg(feature = "host")]
 pub(crate) mod tap;
-#[cfg(feature = "host")]
-pub(crate) mod gvproxy;
 
 /// Virtio-net test with configurable backend
 pub struct TestNet {
@@ -93,7 +93,8 @@ mod host {
 
     impl Test for TestNet {
         fn should_run(&self) -> ShouldRun {
-            if unsafe { krun_call_u32!(krun_has_feature(KRUN_FEATURE_NET.into())) }.ok() != Some(1) {
+            if unsafe { krun_call_u32!(krun_has_feature(KRUN_FEATURE_NET.into())) }.ok() != Some(1)
+            {
                 return ShouldRun::No("libkrun compiled without NET");
             }
             (self.should_run)()
@@ -148,8 +149,12 @@ mod guest {
     }
 
     fn set_timeouts(stream: &mut TcpStream) {
-        stream.set_read_timeout(Some(Duration::from_secs(10))).unwrap();
-        stream.set_write_timeout(Some(Duration::from_secs(10))).unwrap();
+        stream
+            .set_read_timeout(Some(Duration::from_secs(10)))
+            .unwrap();
+        stream
+            .set_write_timeout(Some(Duration::from_secs(10)))
+            .unwrap();
     }
 
     impl Test for TestNet {
@@ -161,7 +166,9 @@ mod guest {
             // Connect to host TCP server
             let host_ip = self.host_ip;
             let addr = SocketAddr::new(
-                IpAddr::V4(Ipv4Addr::new(host_ip[0], host_ip[1], host_ip[2], host_ip[3])),
+                IpAddr::V4(Ipv4Addr::new(
+                    host_ip[0], host_ip[1], host_ip[2], host_ip[3],
+                )),
                 self.port,
             );
 

tests/test_cases/src/test_net/tap.rs

@@ -77,7 +77,10 @@ fn make_sockaddr_in(ip: [u8; 4]) -> libc::sockaddr {
 }
 
 fn create_tap(name: &str) -> std::io::Result<()> {
-    let tun = OpenOptions::new().read(true).write(true).open("/dev/net/tun")?;
+    let tun = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .open("/dev/net/tun")?;
     let mut ifr: Ifreq = unsafe { std::mem::zeroed() };
     set_interface_name(&mut ifr, name);
     ifr.ifr_ifru.ifru_flags = IFF_TAP | IFF_NO_PI | IFF_VNET_HDR;
@@ -89,7 +92,12 @@ fn create_tap(name: &str) -> std::io::Result<()> {
 }
 
 fn configure_host_interface(name: &str, ip: [u8; 4], netmask: [u8; 4]) -> nix::Result<()> {
-    let sock = socket(AddressFamily::Inet, SockType::Datagram, SockFlag::empty(), None)?;
+    let sock = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )?;
     let fd = sock.as_raw_fd();
 
     let mut ifr: Ifreq = unsafe { std::mem::zeroed() };
@@ -126,7 +134,11 @@ pub(crate) fn should_run() -> ShouldRun {
 }
 
 pub(crate) fn cleanup() {
-    if let Ok(tun) = OpenOptions::new().read(true).write(true).open("/dev/net/tun") {
+    if let Ok(tun) = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .open("/dev/net/tun")
+    {
         let mut ifr: Ifreq = unsafe { std::mem::zeroed() };
         set_interface_name(&mut ifr, DEFAULT_TAP_NAME);
         ifr.ifr_ifru.ifru_flags = IFF_TAP | IFF_NO_PI;

tests/test_cases/src/test_net_perf/mod.rs

@@ -212,7 +212,11 @@ mod host {
         fn fmt_text(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             let i = f.width().unwrap_or(0);
             writeln!(f, "{:i$}iperf3 — {}\n", "", self.label())?;
-            writeln!(f, "{:i$}{:<9}  {:>18}  {:>14}", "", "Interval", "Throughput", "Transferred")?;
+            writeln!(
+                f,
+                "{:i$}{:<9}  {:>18}  {:>14}",
+                "", "Interval", "Throughput", "Transferred"
+            )?;
             writeln!(f, "{:i$}{:-<9}  {:-<18}  {:-<14}", "", "", "", "")?;
             for interval in &self.output.intervals {
                 let s = &interval.sum;
@@ -268,7 +272,8 @@ mod host {
             if option_env!("IPERF_DURATION").is_none() {
                 return ShouldRun::No("IPERF_DURATION not set");
             }
-            if unsafe { krun_call_u32!(krun_has_feature(KRUN_FEATURE_NET.into())) }.ok() != Some(1) {
+            if unsafe { krun_call_u32!(krun_has_feature(KRUN_FEATURE_NET.into())) }.ok() != Some(1)
+            {
                 return ShouldRun::No("libkrun compiled without NET");
             }
             let backend_result = (self.should_run)();
@@ -376,8 +381,7 @@ mod guest {
 
                 if output.status.success() {
                     // Print JSON output to stdout (host will read it)
-                    let stdout =
-                        String::from_utf8(output.stdout).expect("iperf3 output not UTF-8");
+                    let stdout = String::from_utf8(output.stdout).expect("iperf3 output not UTF-8");
                     print!("{}", stdout);
                     return;
                 }