Fix tests and examples that relied on timing out

Signed-off-by: Ludvig Liljenberg <[email protected]>

Author: ludfjig

src/hyperlight_host/examples/logging/main.rs

@@ -82,15 +82,27 @@ fn main() -> Result<()> {
     let no_op = Noop::<UninitializedSandbox, MultiUseSandbox>::default();
 
     let mut multiuse_sandbox = usandbox.evolve(no_op)?;
+    let interrupt_handle = multiuse_sandbox.interrupt_handle();
+
+    const NUM_CALLS: i32 = 5;
+    let thread = std::thread::spawn(move || {
+        for _ in 0..NUM_CALLS {
+            // Sleep for a short time to allow the guest function to run.
+            std::thread::sleep(std::time::Duration::from_millis(500));
+            // Cancel the host function call.
+            interrupt_handle.kill();
+        }
+    });
 
     // Call a function that gets cancelled by the host function 5 times to generate some log entries.
 
-    for _ in 0..5 {
+    for _ in 0..NUM_CALLS {
         let mut ctx = multiuse_sandbox.new_call_context();
 
         ctx.call::<()>("Spin", ()).unwrap_err();
         multiuse_sandbox = ctx.finish().unwrap();
     }
+    thread.join().unwrap();
 
     Ok(())
 }

src/hyperlight_host/examples/metrics/main.rs

@@ -95,10 +95,22 @@ fn do_hyperlight_stuff() {
     let no_op = Noop::<UninitializedSandbox, MultiUseSandbox>::default();
 
     let mut multiuse_sandbox = usandbox.evolve(no_op).expect("Failed to evolve sandbox");
+    let interrupt_handle = multiuse_sandbox.interrupt_handle();
+
+    const NUM_CALLS: i32 = 5;
+
+    let thread = std::thread::spawn(move || {
+        for _ in 0..NUM_CALLS {
+            // Sleep for a short time to allow the guest function to run.
+            std::thread::sleep(std::time::Duration::from_millis(500));
+            // Cancel the host function call.
+            interrupt_handle.kill();
+        }
+    });
 
     // Call a function that gets cancelled by the host function 5 times to generate some metrics.
 
-    for _ in 0..5 {
+    for _ in 0..NUM_CALLS {
         let mut ctx = multiuse_sandbox.new_call_context();
 
         ctx.call::<()>("Spin", ()).unwrap_err();
@@ -109,6 +121,7 @@ fn do_hyperlight_stuff() {
         let result = join_handle.join();
         assert!(result.is_ok());
     }
+    thread.join().unwrap();
 }
 
 fn fn_writer(_msg: String) -> Result<i32> {

src/hyperlight_host/examples/tracing/main.rs

@@ -110,8 +110,18 @@ fn run_example() -> Result<()> {
     let no_op = Noop::<UninitializedSandbox, MultiUseSandbox>::default();
 
     let mut multiuse_sandbox = usandbox.evolve(no_op)?;
+    let interrupt_handle = multiuse_sandbox.interrupt_handle();
 
     // Call a function that gets cancelled by the host function 5 times to generate some log entries.
+    const NUM_CALLS: i32 = 5;
+    let thread = std::thread::spawn(move || {
+        for _ in 0..NUM_CALLS {
+            // Sleep for a short time to allow the guest function to run.
+            std::thread::sleep(std::time::Duration::from_millis(500));
+            // Cancel the host function call.
+            interrupt_handle.kill();
+        }
+    });
 
     for i in 0..5 {
         let id = Uuid::new_v4();
@@ -133,6 +143,7 @@ fn run_example() -> Result<()> {
         let result = join_handle.join();
         assert!(result.is_ok());
     }
+    thread.join().unwrap();
 
     Ok(())
 }

src/hyperlight_host/src/metrics/mod.rs

@@ -85,8 +85,11 @@ pub(crate) fn maybe_time_and_emit_host_call<T, F: FnOnce() -> T>(
 
 #[cfg(test)]
 mod tests {
+    use std::thread;
+    use std::time::Duration;
+
     use hyperlight_testing::simple_guest_as_string;
-    use metrics::Key;
+    use metrics::{with_local_recorder, Key};
     use metrics_util::CompositeKey;
 
     use super::*;
@@ -95,24 +98,24 @@ mod tests {
     use crate::{GuestBinary, UninitializedSandbox};
 
     #[test]
-    #[ignore = "This test needs to be run separately to avoid having other tests interfere with it"]
     fn test_metrics_are_emitted() {
-        // Set up the recorder and snapshotter
         let recorder = metrics_util::debugging::DebuggingRecorder::new();
         let snapshotter = recorder.snapshotter();
-
-        // we cannot use with_local_recorder, since that won't capture the metrics
-        // emitted by the hypervisor-thread (which is all of them)
-        recorder.install().unwrap();
-
-        let snapshot = {
+        let snapshot = with_local_recorder(&recorder, || {
             let uninit = UninitializedSandbox::new(
                 GuestBinary::FilePath(simple_guest_as_string().unwrap()),
                 None,
             )
             .unwrap();
 
             let mut multi = uninit.evolve(Noop::default()).unwrap();
+            let interrupt_handle = multi.interrupt_handle();
+
+            // interrupt the guest function call to "Spin" after 1 second
+            let thread = thread::spawn(move || {
+                thread::sleep(Duration::from_secs(1));
+                assert!(interrupt_handle.kill());
+            });
 
             multi
                 .call_guest_function_by_name::<i32>("PrintOutput", "Hello".to_string())
@@ -121,9 +124,10 @@ mod tests {
             multi
                 .call_guest_function_by_name::<i32>("Spin", ())
                 .unwrap_err();
+            thread.join().unwrap();
 
             snapshotter.snapshot()
-        };
+        });
 
         // Convert snapshot into a hashmap for easier lookup
         #[expect(clippy::mutable_key_type)]
@@ -132,27 +136,17 @@ mod tests {
         cfg_if::cfg_if! {
             if #[cfg(feature = "function_call_metrics")] {
                 use metrics::Label;
-                // Verify that the histogram metrics are recorded correctly
-                assert_eq!(snapshot.len(), 4, "Expected two metrics in the snapshot");
 
-                // 1. Host print duration
-                let histogram_key = CompositeKey::new(
-                    metrics_util::MetricKind::Histogram,
-                    Key::from_parts(
-                        METRIC_HOST_FUNC_DURATION,
-                        vec![Label::new("function_name", "HostPrint")],
-                    ),
-                );
-                let histogram_value = &snapshot.get(&histogram_key).unwrap().2;
-                assert!(
-                    matches!(
-                        histogram_value,
-                        metrics_util::debugging::DebugValue::Histogram(histogram) if histogram.len() == 1
-                    ),
-                    "Histogram metric does not match expected value"
-                );
+                let expected_num_metrics = if cfg!(all(feature = "seccomp", target_os = "linux")) {
+                    3 // if seccomp enabled, the host call duration metric is emitted on a separate thread which this local recorder doesn't capture
+                } else {
+                    4
+                };
 
-                // 2. Guest call duration
+                // Verify that the histogram metrics are recorded correctly
+                assert_eq!(snapshot.len(), expected_num_metrics);
+
+                // 1. Guest call duration
                 let histogram_key = CompositeKey::new(
                     metrics_util::MetricKind::Histogram,
                     Key::from_parts(
@@ -169,7 +163,7 @@ mod tests {
                     "Histogram metric does not match expected value"
                 );
 
-                // 3. Guest cancellation
+                // 2. Guest cancellation
                 let counter_key = CompositeKey::new(
                     metrics_util::MetricKind::Counter,
                     Key::from_name(METRIC_GUEST_CANCELLATION),
@@ -179,7 +173,7 @@ mod tests {
                     metrics_util::debugging::DebugValue::Counter(1)
                 );
 
-                // 4. Guest call duration
+                // 3. Guest call duration
                 let histogram_key = CompositeKey::new(
                     metrics_util::MetricKind::Histogram,
                     Key::from_parts(
@@ -195,9 +189,28 @@ mod tests {
                     ),
                     "Histogram metric does not match expected value"
                 );
+
+                if !cfg!(all(feature = "seccomp", target_os = "linux")) {
+                    // 4. Host call duration
+                    let histogram_key = CompositeKey::new(
+                        metrics_util::MetricKind::Histogram,
+                        Key::from_parts(
+                            METRIC_HOST_FUNC_DURATION,
+                            vec![Label::new("function_name", "HostPrint")],
+                        ),
+                    );
+                    let histogram_value = &snapshot.get(&histogram_key).unwrap().2;
+                    assert!(
+                        matches!(
+                            histogram_value,
+                            metrics_util::debugging::DebugValue::Histogram(histogram) if histogram.len() == 1
+                        ),
+                        "Histogram metric does not match expected value"
+                    );
+                }
             } else {
                 // Verify that the counter metrics are recorded correctly
-                assert_eq!(snapshot.len(), 1, "Expected two metrics in the snapshot");
+                assert_eq!(snapshot.len(), 1);
 
                 let counter_key = CompositeKey::new(
                     metrics_util::MetricKind::Counter,