Fix tests and examples that relied on timing out

ludfjig · ludfjig · commit 00c8ae6faf41 · 2025-06-03T08:45:55.000-07:00
Signed-off-by: Ludvig Liljenberg &lt;4257730+ludfjig@users.noreply.github.com&gt;
diff --git a/src/hyperlight_host/examples/logging/main.rs b/src/hyperlight_host/examples/logging/main.rs
@@ -16,6 +16,8 @@ limitations under the License.
 #![allow(clippy::disallowed_macros)]
 extern crate hyperlight_host;
 
+use std::sync::{Arc, Barrier};
+
 use hyperlight_host::sandbox::uninitialized::UninitializedSandbox;
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
@@ -82,15 +84,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();
+    let barrier = Arc::new(Barrier::new(2));
+    let barrier2 = barrier.clone();
+    const NUM_CALLS: i32 = 5;
+    let thread = std::thread::spawn(move || {
+        for _ in 0..NUM_CALLS {
+            barrier2.wait();
+            // 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();
-
+        barrier.wait();
         ctx.call::<()>("Spin", ()).unwrap_err();
         multiuse_sandbox = ctx.finish().unwrap();
     }
+    thread.join().unwrap();
 
     Ok(())
 }
diff --git a/src/hyperlight_host/examples/metrics/main.rs b/src/hyperlight_host/examples/metrics/main.rs
@@ -15,6 +15,7 @@ limitations under the License.
 */
 #![allow(clippy::disallowed_macros)]
 extern crate hyperlight_host;
+use std::sync::{Arc, Barrier};
 use std::thread::{spawn, JoinHandle};
 
 use hyperlight_host::sandbox::uninitialized::UninitializedSandbox;
@@ -95,12 +96,27 @@ 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 barrier = Arc::new(Barrier::new(2));
+    let barrier2 = barrier.clone();
+
+    let thread = std::thread::spawn(move || {
+        for _ in 0..NUM_CALLS {
+            barrier2.wait();
+            // Sleep for a short time to allow the guest function to run after the `wait`.
+            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();
-
+        barrier.wait();
         ctx.call::<()>("Spin", ()).unwrap_err();
         multiuse_sandbox = ctx.finish().unwrap();
     }
@@ -109,6 +125,7 @@ fn do_hyperlight_stuff() {
         let result = join_handle.join();
         assert!(result.is_ok());
     }
+    thread.join().unwrap();
 }
 
 fn fn_writer(_msg: String) -> Result<i32> {
diff --git a/src/hyperlight_host/examples/tracing-otlp/main.rs b/src/hyperlight_host/examples/tracing-otlp/main.rs
@@ -16,16 +16,15 @@ limitations under the License.
 #![allow(clippy::disallowed_macros)]
 //use opentelemetry_sdk::resource::ResourceBuilder;
 use opentelemetry_sdk::trace::SdkTracerProvider;
-use rand::Rng;
 use tracing::{span, Level};
 use tracing_opentelemetry::OpenTelemetryLayer;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
 extern crate hyperlight_host;
 use std::error::Error;
 use std::io::stdin;
-use std::sync::{Arc, Mutex};
-use std::thread::{self, spawn, JoinHandle};
+use std::sync::{Arc, Barrier, Mutex};
+use std::thread::{spawn, JoinHandle};
 
 use hyperlight_host::sandbox::uninitialized::UninitializedSandbox;
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
@@ -157,8 +156,23 @@ fn run_example(wait_input: bool) -> HyperlightResult<()> {
                 }
 
                 // Call a function that gets cancelled by the host function 5 times to generate some log entries.
-
-                for i in 0..5 {
+                const NUM_CALLS: i32 = 5;
+                let barrier = Arc::new(Barrier::new(2));
+                let barrier2 = barrier.clone();
+
+                let interrupt_handle = multiuse_sandbox.interrupt_handle();
+
+                let thread = std::thread::spawn(move || {
+                    for _ in 0..NUM_CALLS {
+                        barrier2.wait();
+                        // 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..NUM_CALLS {
                     let id = Uuid::new_v4();
                     // Construct a new span named "hyperlight tracing call cancellation example thread" with INFO  level.
                     let span = span!(
@@ -169,15 +183,11 @@ fn run_example(wait_input: bool) -> HyperlightResult<()> {
                     );
                     let _entered = span.enter();
                     let mut ctx = multiuse_sandbox.new_call_context();
-
+                    barrier.wait();
                     ctx.call::<()>("Spin", ()).unwrap_err();
                     multiuse_sandbox = ctx.finish().unwrap();
                 }
-                let sleep_for = {
-                    let mut rng = rand::rng();
-                    rng.random_range(500..3000)
-                };
-                thread::sleep(std::time::Duration::from_millis(sleep_for));
+                thread.join().expect("Thread panicked");
             }
             Ok(())
         });
diff --git a/src/hyperlight_host/examples/tracing/main.rs b/src/hyperlight_host/examples/tracing/main.rs
@@ -16,6 +16,7 @@ limitations under the License.
 #![allow(clippy::disallowed_macros)]
 use tracing::{span, Level};
 extern crate hyperlight_host;
+use std::sync::{Arc, Barrier};
 use std::thread::{spawn, JoinHandle};
 
 use hyperlight_host::sandbox::uninitialized::UninitializedSandbox;
@@ -110,10 +111,24 @@ 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.
-
-    for i in 0..5 {
+    const NUM_CALLS: i32 = 5;
+    let barrier = Arc::new(Barrier::new(2));
+    let barrier2 = barrier.clone();
+
+    let thread = std::thread::spawn(move || {
+        for _ in 0..NUM_CALLS {
+            barrier2.wait();
+            // 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..NUM_CALLS {
         let id = Uuid::new_v4();
         // Construct a new span named "hyperlight tracing call cancellation example thread" with INFO  level.
         let span = span!(
@@ -124,7 +139,7 @@ fn run_example() -> Result<()> {
         );
         let _entered = span.enter();
         let mut ctx = multiuse_sandbox.new_call_context();
-
+        barrier.wait();
         ctx.call::<()>("Spin", ()).unwrap_err();
         multiuse_sandbox = ctx.finish().unwrap();
     }
@@ -133,6 +148,7 @@ fn run_example() -> Result<()> {
         let result = join_handle.join();
         assert!(result.is_ok());
     }
+    thread.join().unwrap();
 
     Ok(())
 }
diff --git a/src/hyperlight_host/src/metrics/mod.rs b/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,
