Add trait to abstract over sandboxes in guest function calling

This is useful to allow host-side code to work on both core Hyperlight
sandboxes and wrapped sandboxes like Hyperlight Wasm.

Signed-off-by: Lucy Menon <[email protected]>

Author: syntactically

src/hyperlight_host/benches/benchmarks.rs

@@ -15,7 +15,9 @@ limitations under the License.
 */
 
 use criterion::{criterion_group, criterion_main, Criterion};
-use hyperlight_host::sandbox::{MultiUseSandbox, SandboxConfiguration, UninitializedSandbox};
+use hyperlight_host::sandbox::{
+    Callable, MultiUseSandbox, SandboxConfiguration, UninitializedSandbox,
+};
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
 use hyperlight_host::GuestBinary;

src/hyperlight_host/examples/func_ctx/main.rs

@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 use hyperlight_host::func::call_ctx::MultiUseGuestCallContext;
-use hyperlight_host::sandbox::{MultiUseSandbox, UninitializedSandbox};
+use hyperlight_host::sandbox::{Callable, MultiUseSandbox, UninitializedSandbox};
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
 use hyperlight_host::{GuestBinary, Result};

src/hyperlight_host/examples/logging/main.rs

@@ -19,6 +19,7 @@ extern crate hyperlight_host;
 use std::sync::{Arc, Barrier};
 
 use hyperlight_host::sandbox::uninitialized::UninitializedSandbox;
+use hyperlight_host::sandbox::Callable;
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
 use hyperlight_host::{GuestBinary, MultiUseSandbox, Result};

src/hyperlight_host/examples/metrics/main.rs

@@ -19,6 +19,7 @@ use std::sync::{Arc, Barrier};
 use std::thread::{spawn, JoinHandle};
 
 use hyperlight_host::sandbox::uninitialized::UninitializedSandbox;
+use hyperlight_host::sandbox::Callable;
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
 use hyperlight_host::{GuestBinary, MultiUseSandbox, Result};

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

@@ -27,6 +27,7 @@ use std::sync::{Arc, Barrier, Mutex};
 use std::thread::{spawn, JoinHandle};
 
 use hyperlight_host::sandbox::uninitialized::UninitializedSandbox;
+use hyperlight_host::sandbox::Callable;
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
 use hyperlight_host::{GuestBinary, MultiUseSandbox, Result as HyperlightResult};

src/hyperlight_host/examples/tracing/main.rs

@@ -20,6 +20,7 @@ use std::sync::{Arc, Barrier};
 use std::thread::{spawn, JoinHandle};
 
 use hyperlight_host::sandbox::uninitialized::UninitializedSandbox;
+use hyperlight_host::sandbox::Callable;
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
 use hyperlight_host::{GuestBinary, MultiUseSandbox, Result};

src/hyperlight_host/src/func/call_ctx.rs

@@ -17,6 +17,7 @@ limitations under the License.
 use tracing::{instrument, Span};
 
 use super::{ParameterTuple, SupportedReturnType};
+use crate::sandbox::Callable;
 use crate::{MultiUseSandbox, Result};
 /// A context for calling guest functions.
 ///
@@ -47,6 +48,31 @@ impl MultiUseGuestCallContext {
         Self { sbox }
     }
 
+    /// Close out the context and get back the internally-stored
+    /// `MultiUseSandbox`. Future contexts opened by the returned sandbox
+    /// will have guest state restored.
+    #[instrument(err(Debug), skip(self), parent = Span::current())]
+    pub fn finish(mut self) -> Result<MultiUseSandbox> {
+        self.sbox.restore_state()?;
+        Ok(self.sbox)
+    }
+    /// Close out the context and get back the internally-stored
+    /// `MultiUseSandbox`.
+    ///
+    /// Note that this method is pub(crate) and does not reset the state of the
+    /// sandbox.
+    ///
+    /// It is intended to be used when evolving a MultiUseSandbox to a new state
+    /// and is not intended to be called publicly. It allows the state of the guest to be altered
+    /// during the evolution of one sandbox state to another, enabling the new state created
+    /// to be captured and stored in the Sandboxes state stack.
+    ///
+    pub(crate) fn finish_no_reset(self) -> MultiUseSandbox {
+        self.sbox
+    }
+}
+
+impl Callable for MultiUseGuestCallContext {
     /// Call the guest function called `func_name` with the given arguments
     /// `args`, and expect the return value have the same type as
     /// `func_ret_type`.
@@ -58,7 +84,7 @@ impl MultiUseGuestCallContext {
     /// If you want  to reset state, call `finish()` on this `MultiUseGuestCallContext`
     /// and get a new one from the resulting `MultiUseSandbox`
     #[instrument(err(Debug),skip(self, args),parent = Span::current())]
-    pub fn call<Output: SupportedReturnType>(
+    fn call<Output: SupportedReturnType>(
         &mut self,
         func_name: &str,
         args: impl ParameterTuple,
@@ -75,29 +101,6 @@ impl MultiUseGuestCallContext {
         );
         Output::from_value(ret?)
     }
-
-    /// Close out the context and get back the internally-stored
-    /// `MultiUseSandbox`. Future contexts opened by the returned sandbox
-    /// will have guest state restored.
-    #[instrument(err(Debug), skip(self), parent = Span::current())]
-    pub fn finish(mut self) -> Result<MultiUseSandbox> {
-        self.sbox.restore_state()?;
-        Ok(self.sbox)
-    }
-    /// Close out the context and get back the internally-stored
-    /// `MultiUseSandbox`.
-    ///
-    /// Note that this method is pub(crate) and does not reset the state of the
-    /// sandbox.
-    ///
-    /// It is intended to be used when evolving a MultiUseSandbox to a new state
-    /// and is not intended to be called publicly. It allows the state of the guest to be altered
-    /// during the evolution of one sandbox state to another, enabling the new state created
-    /// to be captured and stored in the Sandboxes state stack.
-    ///
-    pub(crate) fn finish_no_reset(self) -> MultiUseSandbox {
-        self.sbox
-    }
 }
 
 #[cfg(test)]
@@ -108,6 +111,7 @@ mod tests {
     use hyperlight_testing::simple_guest_as_string;
 
     use super::MultiUseGuestCallContext;
+    use crate::sandbox::Callable;
     use crate::sandbox_state::sandbox::EvolvableSandbox;
     use crate::sandbox_state::transition::Noop;
     use crate::{GuestBinary, HyperlightError, MultiUseSandbox, Result, UninitializedSandbox};

src/hyperlight_host/src/sandbox/callable.rs

@@ -0,0 +1,28 @@
+/*
+Copyright 2024 The Hyperlight Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+ */
+
+use crate::func::{ParameterTuple, SupportedReturnType};
+use crate::Result;
+
+/// Trait used by the macros to paper over the differences between hyperlight and hyperlight-wasm
+pub trait Callable {
+    /// Call a guest function dynamically
+    fn call<Output: SupportedReturnType>(
+        &mut self,
+        func_name: &str,
+        args: impl ParameterTuple,
+    ) -> Result<Output>;
+}

src/hyperlight_host/src/sandbox/initialized_multi_use.rs

@@ -321,7 +321,7 @@ mod tests {
     use hyperlight_testing::simple_guest_as_string;
 
     use crate::func::call_ctx::MultiUseGuestCallContext;
-    use crate::sandbox::SandboxConfiguration;
+    use crate::sandbox::{Callable, SandboxConfiguration};
     use crate::sandbox_state::sandbox::{DevolvableSandbox, EvolvableSandbox};
     use crate::sandbox_state::transition::{MultiUseContextCallback, Noop};
     use crate::{GuestBinary, HyperlightError, MultiUseSandbox, Result, UninitializedSandbox};

src/hyperlight_host/src/sandbox/mod.rs

@@ -37,6 +37,11 @@ pub mod uninitialized;
 /// initialized `Sandbox`es.
 pub(crate) mod uninitialized_evolve;
 
+/// Trait used by the macros to paper over the differences between hyperlight and hyperlight-wasm
+mod callable;
+
+/// Trait used by the macros to paper over the differences between hyperlight and hyperlight-wasm
+pub use callable::Callable;
 /// Re-export for `SandboxConfiguration` type
 pub use config::SandboxConfiguration;
 /// Re-export for the `MultiUseSandbox` type