[host,simpleguest] removed remaining references to HostPrint

- updated our hello-world example,
- updated the README,
- changed last remaining use of HostPrint to use print (wrapper for using the DebugPrint OutbAction), and
- added an extra test in sandbox_builder.

Signed-off-by: danbugs <[email protected]>

Author: danbugs

README.md

@@ -48,8 +48,8 @@ fn main() -> hyperlight_host::Result<()> {
     )?;
 
     // Register a host function
-    fn sleep_5_secs() -> hyperlight_host::Result<()> {
-        thread::sleep(std::time::Duration::from_secs(5));
+    fn host_add() -> hyperlight_host::Result<()> {
+        
         Ok(())
     }
 
@@ -92,41 +92,43 @@ use hyperlight_common::flatbuffer_wrappers::function_types::{
     ParameterType, ParameterValue, ReturnType,
 };
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
-use hyperlight_common::flatbuffer_wrappers::util::get_flatbuffer_result_from_int;
 
 use hyperlight_guest::error::{HyperlightGuestError, Result};
 use hyperlight_guest::guest_function_definition::GuestFunctionDefinition;
 use hyperlight_guest::guest_function_register::register_function;
-use hyperlight_guest::host_function_call::{
-    call_host_function, get_host_value_return_as_int,
-};
+use hyperlight_common::host_calling::{call_host_function, get_host_return_value};
 
-fn print_output(function_call: &FunctionCall) -> Result<Vec<u8>> {
-    if let ParameterValue::String(message) = function_call.parameters.clone().unwrap()[0].clone() {
+fn add(function_call: &FunctionCall) -> Result<Vec<u8>> {
+    if let (ParameterValue::Int(a), ParameterValue::Int(b)) = (
+        function_call.parameters.clone().unwrap()[0].clone(),
+        function_call.parameters.clone().unwrap()[1].clone(),
+    ) {
         call_host_function(
-            "HostPrint",
-            Some(Vec::from(&[ParameterValue::String(message.to_string())])),
+            "HostAdd",
+            Some(Vec::from(&[ParameterValue::Int(a), ParameterValue::Int(b)])),
             ReturnType::Int,
         )?;
-        let result = get_host_value_return_as_int()?;
-        Ok(get_flatbuffer_result_from_int(result))
+
+        let res = get_host_return_value::<i32>()?;
+
+        Ok(get_flatbuffer_result(res))
     } else {
         Err(HyperlightGuestError::new(
             ErrorCode::GuestFunctionParameterTypeMismatch,
-            "Invalid parameters passed to simple_print_output".to_string(),
+            "Invalid parameters passed to add".to_string(),
         ))
     }
 }
 
 #[no_mangle]
 pub extern "C" fn hyperlight_main() {
-    let print_output_def = GuestFunctionDefinition::new(
-        "PrintOutput".to_string(),
-        Vec::from(&[ParameterType::String]),
+    let add_def = GuestFunctionDefinition::new(
+        "Add".to_string(),
+        Vec::from(&[ParameterType::Int, ParameterType::Int]),
         ReturnType::Int,
-        print_output as i64,
+        add as usize,
     );
-    register_function(print_output_def);
+    register_function(add_def);
 }
 
 #[no_mangle]

src/hyperlight_host/examples/hello-world/main.rs

@@ -15,48 +15,43 @@ limitations under the License.
 */
 
 use std::sync::{Arc, Mutex};
-use std::thread;
 
 use hyperlight_common::flatbuffer_wrappers::function_types::{ParameterValue, ReturnType};
-use hyperlight_host::func::HostFunction0;
+use hyperlight_host::func::HostFunction2;
+use hyperlight_host::sandbox::sandbox_builder::SandboxBuilder;
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
-use hyperlight_host::{MultiUseSandbox, UninitializedSandbox};
+use hyperlight_host::{GuestBinary, MultiUseSandbox};
+use hyperlight_testing::simple_guest_as_string;
 
 fn main() -> hyperlight_host::Result<()> {
     // Create an uninitialized sandbox with a guest binary
-    let mut uninitialized_sandbox = UninitializedSandbox::new(
-        hyperlight_host::GuestBinary::FilePath(
-            hyperlight_testing::simple_guest_as_string().unwrap(),
-        ),
-        None, // default configuration
-        None, // default run options
-        None, // default host print function
-    )?;
+    let sandbox_builder = SandboxBuilder::new(GuestBinary::FilePath(simple_guest_as_string()?))?;
+
+    let mut uninitialized_sandbox = sandbox_builder.build()?;
 
-    // Register a host functions
-    fn sleep_5_secs() -> hyperlight_host::Result<()> {
-        thread::sleep(std::time::Duration::from_secs(5));
-        Ok(())
+    // Register a host function
+    fn add(a: i32, b: i32) -> hyperlight_host::Result<i32> {
+        Ok(a + b)
     }
+    let host_function = Arc::new(Mutex::new(add));
+    host_function.register(&mut uninitialized_sandbox, "HostAdd")?;
 
-    let host_function = Arc::new(Mutex::new(sleep_5_secs));
+    let host_function = Arc::new(Mutex::new(add));
 
-    host_function.register(&mut uninitialized_sandbox, "Sleep5Secs")?;
-    // Note: This function is unused, it's just here for demonstration purposes
+    host_function.register(&mut uninitialized_sandbox, "HostAdd")?;
 
     // Initialize sandbox to be able to call host functions
     let mut multi_use_sandbox: MultiUseSandbox = uninitialized_sandbox.evolve(Noop::default())?;
 
     // Call guest function
-    let message = "Hello, World! I am executing inside of a VM :)\n".to_string();
     let result = multi_use_sandbox.call_guest_function_by_name(
-        "PrintOutput", // function must be defined in the guest binary
+        "Add", // function must be defined in the guest binary
         ReturnType::Int,
-        Some(vec![ParameterValue::String(message.clone())]),
-    );
+        Some(vec![ParameterValue::Int(1), ParameterValue::Int(41)]),
+    )?;
 
-    assert!(result.is_ok());
+    println!("Guest function result: 1 + 41 = {:?}", result);
 
     Ok(())
 }

src/hyperlight_host/src/sandbox/host_funcs.rs

@@ -79,21 +79,6 @@ impl HostFuncsWrapper {
         register_host_function_helper(self, mgr, hfd, func, Some(extra_allowed_syscalls))
     }
 
-    /// Assuming a host function called `"HostPrint"` exists, and takes a
-    /// single string parameter, call it with the given `msg` parameter.
-    ///
-    /// Return `Ok` if the function was found and was of the right signature,
-    /// and `Err` otherwise.
-    #[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
-    pub(super) fn host_print(&mut self, msg: String) -> Result<i32> {
-        let res = call_host_func_impl(
-            self.get_host_funcs(),
-            "HostPrint",
-            vec![ParameterValue::String(msg)],
-        )?;
-        res.try_into()
-            .map_err(|_| HostFunctionNotFound("HostPrint".to_string()))
-    }
     /// From the set of registered host functions, attempt to get the one
     /// named `name`. If it exists, call it with the given arguments list
     /// `args` and return its result.

src/hyperlight_host/src/sandbox/sandbox_builder.rs

@@ -882,7 +882,9 @@ mod tests {
     use hyperlight_common::flatbuffer_wrappers::function_types::{
         ParameterValue, ReturnType, ReturnValue,
     };
-    use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode::GuestFunctionParameterTypeMismatch;
+    use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode::{
+        GuestFunctionNotFound, GuestFunctionParameterTypeMismatch,
+    };
     use hyperlight_testing::simple_guest_as_string;
 
     use super::*;
@@ -1051,4 +1053,30 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_sandbox_builder_try_calling_nonexistent_guest_function() -> Result<()> {
+        // Tests building an uninitialized sandbox w/ the sandbox builder
+        let sandbox_builder =
+            SandboxBuilder::new(GuestBinary::FilePath(simple_guest_as_string()?))?;
+
+        let uninitialized_sandbox = sandbox_builder.build()?;
+
+        // Tests evolving to a multi-use sandbox
+        let mut multi_use_sandbox = uninitialized_sandbox.evolve(Noop::default())?;
+
+        let result = multi_use_sandbox.call_guest_function_by_name(
+            "SomeNonExistentFunction",
+            ReturnType::Void,
+            None,
+        );
+
+        // Should get Error: GuestError(GuestFunctionNotFound, "SomeNonExistentFunction")
+        assert!(matches!(
+            result,
+            Err(HyperlightError::GuestError(GuestFunctionNotFound { .. }, _,))
+        ));
+
+        Ok(())
+    }
 }

src/tests/rust_guests/simpleguest/src/main.rs

@@ -1127,20 +1127,14 @@ pub fn guest_dispatch_function(function_call: FunctionCall) -> Result<Vec<u8>> {
         1,
     );
 
-    call_host_function(
-        "HostPrint",
-        Some(Vec::from(&[ParameterValue::String(message.to_string())])),
-        ReturnType::Int,
-    )?;
-    let result = get_host_return_value::<i32>()?;
+    print(message);
     let function_name = function_call.function_name.clone();
     let param_len = function_call.parameters.clone().unwrap_or_default().len();
     let call_type = function_call.function_call_type().clone();
 
     if function_name != "ThisIsNotARealFunctionButTheNameIsImportant"
         || param_len != 0
         || call_type != FunctionCallType::Guest
-        || result != 100
     {
         return Err(HyperlightGuestError::new(
             ErrorCode::GuestFunctionNotFound,