Fix up tests that rely on timeout-based cancellation

Signed-off-by: Ludvig Liljenberg <4257730+ludfjig@users.noreply.github.com>

Author: ludfjig

Justfile

@@ -88,9 +88,7 @@ test-isolated target=default-target features="":
     cargo test {{ if features =="" {''} else if features=="no-default-features" {"--no-default-features" } else {"--no-default-features -F " + features } }} --profile={{ if target == "debug" { "dev" } else { target } }} -p hyperlight-host --lib -- mem::shared_mem::tests::test_drop --exact --ignored
     cargo test {{ if features =="" {''} else if features=="no-default-features" {"--no-default-features" } else {"--no-default-features -F " + features } }} --profile={{ if target == "debug" { "dev" } else { target } }} -p hyperlight-host --test integration_test -- log_message --exact --ignored
     @# metrics tests
-    cargo test {{ if features =="" {''} else if features=="no-default-features" {"--no-default-features" } else {"--no-default-features -F " + features } }} --profile={{ if target == "debug" { "dev" } else { target } }} -p hyperlight-host --lib -- metrics::tests::test_metrics_are_emitted --exact --ignored
-    cargo test {{ if features =="" {''} else if features=="no-default-features" {"--no-default-features" } else {"--no-default-features -F function_call_metrics," + features } }} --profile={{ if target == "debug" { "dev" } else { target } }} -p hyperlight-host --lib -- metrics::tests::test_metrics_are_emitted --exact --ignored
-    
+    cargo test {{ if features =="" {''} else if features=="no-default-features" {"--no-default-features" } else {"--no-default-features -F function_call_metrics," + features } }} --profile={{ if target == "debug" { "dev" } else { target } }} -p hyperlight-host --lib -- metrics::tests::test_metrics_are_emitted --exact 
 # runs integration tests. Guest can either be "rust" or "c"
 test-integration guest target=default-target features="":
     @# run execute_on_heap test with feature "executable_heap" on and off

src/hyperlight_host/examples/logging/main.rs

@@ -89,17 +89,29 @@ 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();
 
         let result = ctx.call("Spin", ReturnType::Void, None);
         assert!(result.is_err());
         let result = ctx.finish();
         multiuse_sandbox = result.unwrap();
     }
+    thread.join().unwrap();
 
     Ok(())
 }

src/hyperlight_host/examples/metrics/main.rs

@@ -102,10 +102,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();
 
         let result = ctx.call("Spin", ReturnType::Void, None);
@@ -119,6 +131,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

@@ -117,8 +117,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();
@@ -143,6 +153,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,9 +85,12 @@ 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_common::flatbuffer_wrappers::function_types::{ParameterValue, ReturnType};
     use hyperlight_testing::simple_guest_as_string;
-    use metrics::Key;
+    use metrics::{with_local_recorder, Key};
     use metrics_util::CompositeKey;
 
     use super::*;
@@ -96,24 +99,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(
@@ -126,9 +129,10 @@ mod tests {
             multi
                 .call_guest_function_by_name("Spin", ReturnType::Int, None)
                 .unwrap_err();
+            thread.join().unwrap();
 
             snapshotter.snapshot()
-        };
+        });
 
         // Convert snapshot into a hashmap for easier lookup
         #[expect(clippy::mutable_key_type)]
@@ -137,27 +141,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(ref 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(
@@ -174,7 +168,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),
@@ -184,7 +178,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(
@@ -200,9 +194,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(ref 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,