fixup! update uses of call_guest_function_by_name with run

Signed-off-by: Jorge Prendes <[email protected]>

Author: jprendes

src/hyperlight_host/benches/benchmarks.rs

@@ -16,9 +16,7 @@ limitations under the License.
 
 use criterion::{Criterion, criterion_group, criterion_main};
 use hyperlight_host::GuestBinary;
-use hyperlight_host::sandbox::{
-    MultiUseSandbox, SandboxConfiguration, UninitializedSandbox,
-};
+use hyperlight_host::sandbox::{MultiUseSandbox, SandboxConfiguration, UninitializedSandbox};
 use hyperlight_testing::simple_guest_as_string;
 
 fn create_uninit_sandbox() -> UninitializedSandbox {
@@ -65,11 +63,7 @@ fn guest_call_benchmark(c: &mut Criterion) {
 
         let mut multiuse_sandbox: MultiUseSandbox = uninitialized_sandbox.evolve().unwrap();
 
-        b.iter(|| {
-            multiuse_sandbox
-                .run::<i32>("Add", (1_i32, 41_i32))
-                .unwrap()
-        });
+        b.iter(|| multiuse_sandbox.run::<i32>("Add", (1_i32, 41_i32)).unwrap());
     });
 
     group.finish();
@@ -99,10 +93,7 @@ fn guest_call_benchmark_large_param(c: &mut Criterion) {
 
         b.iter(|| {
             sandbox
-                .run::<()>(
-                    "LargeParameters",
-                    (large_vec.clone(), large_string.clone()),
-                )
+                .run::<()>("LargeParameters", (large_vec.clone(), large_string.clone()))
                 .unwrap()
         });
     });

src/hyperlight_host/examples/func_ctx/main.rs

@@ -29,13 +29,9 @@ fn main() {
 
     // Do several calls against a sandbox running the `simpleguest.exe` binary,
     // and print their results
-    let res: String = sbox
-        .run("Echo", "hello".to_string())
-        .unwrap();
+    let res: String = sbox.run("Echo", "hello".to_string()).unwrap();
     println!("got Echo res: {res}");
 
-    let res: i32 = sbox
-        .run("CallMalloc", 200_i32)
-        .unwrap();
+    let res: i32 = sbox.run("CallMalloc", 200_i32).unwrap();
     println!("got CallMalloc res: {res}");
 }

src/hyperlight_host/examples/logging/main.rs

@@ -94,9 +94,7 @@ fn main() -> Result<()> {
 
     for _ in 0..NUM_CALLS {
         barrier.wait();
-        multiuse_sandbox
-            .run::<()>("Spin", ())
-            .unwrap_err();
+        multiuse_sandbox.run::<()>("Spin", ()).unwrap_err();
     }
     thread.join().unwrap();
 

src/hyperlight_host/examples/metrics/main.rs

@@ -108,9 +108,7 @@ fn do_hyperlight_stuff() {
 
     for _ in 0..NUM_CALLS {
         barrier.wait();
-        multiuse_sandbox
-            .run::<()>("Spin", ())
-            .unwrap_err();
+        multiuse_sandbox.run::<()>("Spin", ()).unwrap_err();
     }
 
     for join_handle in join_handles {

src/hyperlight_host/examples/tracing-otlp/main.rs

@@ -179,9 +179,7 @@ fn run_example(wait_input: bool) -> HyperlightResult<()> {
                     );
                     let _entered = span.enter();
                     barrier.wait();
-                    multiuse_sandbox
-                        .run::<()>("Spin", ())
-                        .unwrap_err();
+                    multiuse_sandbox.run::<()>("Spin", ()).unwrap_err();
                 }
                 thread.join().expect("Thread panicked");
             }

src/hyperlight_host/examples/tracing/main.rs

@@ -131,9 +131,7 @@ fn run_example() -> Result<()> {
         );
         let _entered = span.enter();
         barrier.wait();
-        multiuse_sandbox
-            .run::<()>("Spin", ())
-            .unwrap_err();
+        multiuse_sandbox.run::<()>("Spin", ()).unwrap_err();
     }
 
     for join_handle in join_handles {

src/hyperlight_host/src/metrics/mod.rs

@@ -119,9 +119,7 @@ mod tests {
                 .run::<i32>("PrintOutput", "Hello".to_string())
                 .unwrap();
 
-            multi
-                .run::<i32>("Spin", ())
-                .unwrap_err();
+            multi.run::<i32>("Spin", ()).unwrap_err();
             thread.join().unwrap();
 
             snapshotter.snapshot()

src/hyperlight_host/src/sandbox/initialized_multi_use.rs

@@ -373,10 +373,12 @@ mod tests {
         let _ = sbox.run::<i32>("AddToStatic", 5i32).unwrap();
         let res: i32 = sbox.run("GetStatic", ()).unwrap();
         assert_eq!(res, 5);
-        
+
         sbox.restore(&snapshot).unwrap();
         #[allow(deprecated)]
-        let _ = sbox.call_guest_function_by_name::<i32>("AddToStatic", 5i32).unwrap();
+        let _ = sbox
+            .call_guest_function_by_name::<i32>("AddToStatic", 5i32)
+            .unwrap();
         #[allow(deprecated)]
         let res: i32 = sbox.call_guest_function_by_name("GetStatic", ()).unwrap();
         assert_eq!(res, 0);
@@ -646,9 +648,7 @@ mod tests {
 
                     let mut multi_use_sandbox: MultiUseSandbox = usbox.evolve().unwrap();
 
-                    let res: i32 = multi_use_sandbox
-                        .run("GetStatic", ())
-                        .unwrap();
+                    let res: i32 = multi_use_sandbox.run("GetStatic", ()).unwrap();
 
                     assert_eq!(res, 0);
                 }

src/hyperlight_host/tests/integration_test.rs

@@ -70,9 +70,7 @@ fn interrupt_host_call() {
         }
     });
 
-    let result = sandbox
-        .run::<i32>("CallHostSpin", ())
-        .unwrap_err();
+    let result = sandbox.run::<i32>("CallHostSpin", ()).unwrap_err();
     assert!(matches!(result, HyperlightError::ExecutionCanceledByHost()));
 
     thread.join().unwrap();
@@ -96,16 +94,12 @@ fn interrupt_in_progress_guest_call() {
         assert!(interrupt_handle.dropped());
     });
 
-    let res = sbox1
-        .run::<i32>("Spin", ())
-        .unwrap_err();
+    let res = sbox1.run::<i32>("Spin", ()).unwrap_err();
     assert!(matches!(res, HyperlightError::ExecutionCanceledByHost()));
 
     barrier.wait();
     // Make sure we can still call guest functions after the VM was interrupted
-    sbox1
-        .run::<String>("Echo", "hello".to_string())
-        .unwrap();
+    sbox1.run::<String>("Echo", "hello".to_string()).unwrap();
 
     // drop vm to make sure other thread can detect it
     drop(sbox1);
@@ -131,15 +125,11 @@ fn interrupt_guest_call_in_advance() {
     });
 
     barrier.wait(); // wait until `kill()` is called before starting the guest call
-    let res = sbox1
-        .run::<i32>("Spin", ())
-        .unwrap_err();
+    let res = sbox1.run::<i32>("Spin", ()).unwrap_err();
     assert!(matches!(res, HyperlightError::ExecutionCanceledByHost()));
 
     // Make sure we can still call guest functions after the VM was interrupted
-    sbox1
-        .run::<String>("Echo", "hello".to_string())
-        .unwrap();
+    sbox1.run::<String>("Echo", "hello".to_string()).unwrap();
 
     // drop vm to make sure other thread can detect it
     drop(sbox1);
@@ -257,9 +247,7 @@ fn interrupt_moved_sandbox() {
 
     let thread = thread::spawn(move || {
         barrier2.wait();
-        let res = sbox1
-            .run::<i32>("Spin", ())
-            .unwrap_err();
+        let res = sbox1.run::<i32>("Spin", ()).unwrap_err();
         assert!(matches!(res, HyperlightError::ExecutionCanceledByHost()));
     });
 
@@ -272,9 +260,7 @@ fn interrupt_moved_sandbox() {
         assert!(interrupt_handle2.kill());
     });
 
-    let res = sbox2
-        .run::<i32>("Spin", ())
-        .unwrap_err();
+    let res = sbox2.run::<i32>("Spin", ()).unwrap_err();
     assert!(matches!(res, HyperlightError::ExecutionCanceledByHost()));
 
     thread.join().expect("Thread should finish");
@@ -315,9 +301,7 @@ fn interrupt_custom_signal_no_and_retry_delay() {
     });
 
     for _ in 0..NUM_ITERS {
-        let res = sbox1
-            .run::<i32>("Spin", ())
-            .unwrap_err();
+        let res = sbox1.run::<i32>("Spin", ()).unwrap_err();
         assert!(matches!(res, HyperlightError::ExecutionCanceledByHost()));
         // immediately reenter another guest function call after having being cancelled,
         // so that the vcpu is running again before the interruptor-thread has a chance to see that the vcpu is not running
@@ -441,10 +425,7 @@ fn guest_abort_with_context2() {
                                 Proin sagittis nisl rhoncus mattis rhoncus urna. Magna eget est lorem ipsum.";
 
     let res = sbox1
-        .run::<()>(
-            "GuestAbortWithMessage",
-            (60_i32, abort_message.to_string()),
-        )
+        .run::<()>("GuestAbortWithMessage", (60_i32, abort_message.to_string()))
         .unwrap_err();
     println!("{:?}", res);
     assert!(
@@ -494,9 +475,7 @@ fn guest_malloc() {
     let mut sbox1 = new_uninit_rust().unwrap().evolve().unwrap();
 
     let size_to_allocate = 2000_i32;
-    sbox1
-        .run::<i32>("TestMalloc", size_to_allocate)
-        .unwrap();
+    sbox1.run::<i32>("TestMalloc", size_to_allocate).unwrap();
 }
 
 #[test]
@@ -522,9 +501,7 @@ fn guest_malloc_abort() {
 
     let size = 20000000_i32; // some big number that should fail when allocated
 
-    let res = sbox1
-        .run::<i32>("TestMalloc", size)
-        .unwrap_err();
+    let res = sbox1.run::<i32>("TestMalloc", size).unwrap_err();
     println!("{:?}", res);
     assert!(
         matches!(res, HyperlightError::GuestAborted(code, _) if code == ErrorCode::MallocFailed as u8)
@@ -564,9 +541,7 @@ fn dynamic_stack_allocate_c_guest() {
     let uninit = UninitializedSandbox::new(guest_path, None);
     let mut sbox1: MultiUseSandbox = uninit.unwrap().evolve().unwrap();
 
-    let res: i32 = sbox1
-        .run("StackAllocate", 100_i32)
-        .unwrap();
+    let res: i32 = sbox1.run("StackAllocate", 100_i32).unwrap();
     assert_eq!(res, 100);
 
     let res = sbox1
@@ -588,9 +563,7 @@ fn static_stack_allocate() {
 #[test]
 fn static_stack_allocate_overflow() {
     let mut sbox1 = new_uninit().unwrap().evolve().unwrap();
-    let res = sbox1
-        .run::<i32>("LargeVar", ())
-        .unwrap_err();
+    let res = sbox1.run::<i32>("LargeVar", ()).unwrap_err();
     assert!(matches!(res, HyperlightError::StackOverflow()));
 }
 
@@ -601,9 +574,7 @@ fn recursive_stack_allocate() {
 
     let iterations = 1_i32;
 
-    sbox1
-        .run::<i32>("StackOverflow", iterations)
-        .unwrap();
+    sbox1.run::<i32>("StackOverflow", iterations).unwrap();
 }
 
 // checks stack guard page (between guest stack and heap)
@@ -646,19 +617,15 @@ fn guard_page_check_2() {
     // this test is rust-guest only
     let mut sbox1 = new_uninit_rust().unwrap().evolve().unwrap();
 
-    let result = sbox1
-        .run::<()>("InfiniteRecursion", ())
-        .unwrap_err();
+    let result = sbox1.run::<()>("InfiniteRecursion", ()).unwrap_err();
     assert!(matches!(result, HyperlightError::StackOverflow()));
 }
 
 #[test]
 fn execute_on_stack() {
     let mut sbox1 = new_uninit().unwrap().evolve().unwrap();
 
-    let result = sbox1
-        .run::<String>("ExecuteOnStack", ())
-        .unwrap_err();
+    let result = sbox1.run::<String>("ExecuteOnStack", ()).unwrap_err();
 
     let err = result.to_string();
     assert!(
@@ -693,9 +660,7 @@ fn recursive_stack_allocate_overflow() {
 
     let iterations = 10_i32;
 
-    let res = sbox1
-        .run::<()>("StackOverflow", iterations)
-        .unwrap_err();
+    let res = sbox1.run::<()>("StackOverflow", iterations).unwrap_err();
     println!("{:?}", res);
     assert!(matches!(res, HyperlightError::StackOverflow()));
 }

src/hyperlight_host/tests/sandbox_host_tests.rs

@@ -85,9 +85,7 @@ fn float_roundtrip() {
     ];
     let mut sandbox: MultiUseSandbox = new_uninit().unwrap().evolve().unwrap();
     for f in doubles.iter() {
-        let res: f64 = sandbox
-            .run("EchoDouble", *f)
-            .unwrap();
+        let res: f64 = sandbox.run("EchoDouble", *f).unwrap();
 
         assert!(
             res.total_cmp(f).is_eq(),
@@ -97,9 +95,7 @@ fn float_roundtrip() {
         );
     }
     for f in floats.iter() {
-        let res: f32 = sandbox
-            .run("EchoFloat", *f)
-            .unwrap();
+        let res: f32 = sandbox.run("EchoFloat", *f).unwrap();
 
         assert!(
             res.total_cmp(f).is_eq(),
@@ -260,14 +256,10 @@ fn simple_test_helper() -> Result<()> {
     let message2 = "world";
 
     for mut sandbox in get_simpleguest_sandboxes(Some(writer.into())).into_iter() {
-        let res: i32 = sandbox
-            .run("PrintOutput", message.to_string())
-            .unwrap();
+        let res: i32 = sandbox.run("PrintOutput", message.to_string()).unwrap();
         assert_eq!(res, 5);
 
-        let res: String = sandbox
-            .run("Echo", message2.to_string())
-            .unwrap();
+        let res: String = sandbox.run("Echo", message2.to_string()).unwrap();
         assert_eq!(res, "world");
 
         let buffer = [1u8, 2, 3, 4, 5, 6];