Big fix

Signed-off-by: Ludvig Liljenberg <[email protected]>

Author: ludfjig

Cargo.lock

@@ -17,16 +17,11 @@ limitations under the License.
 extern crate flatbuffers;
 
 use alloc::string::{String, ToString};
-use alloc::vec::Vec;
 
-use anyhow::{Error, Result};
-use flatbuffers::size_prefixed_root;
 #[cfg(feature = "tracing")]
 use tracing::{Span, instrument};
 
-use crate::flatbuffers::hyperlight::generated::{
-    ErrorCode as FbErrorCode, GuestError as FbGuestError, GuestErrorArgs,
-};
+use crate::flatbuffers::hyperlight::generated::ErrorCode as FbErrorCode;
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 #[repr(C)]
@@ -48,6 +43,7 @@ pub enum ErrorCode {
     GuestFunctionParameterTypeMismatch = 14,
     GuestError = 15,
     ArrayLengthParamIsMissing = 16,
+    HostFunctionError = 17,
 }
 
 impl From<ErrorCode> for FbErrorCode {
@@ -73,6 +69,7 @@ impl From<ErrorCode> for FbErrorCode {
             }
             ErrorCode::GuestError => Self::GuestError,
             ErrorCode::ArrayLengthParamIsMissing => Self::ArrayLengthParamIsMissing,
+            ErrorCode::HostFunctionError => Self::HostError,
         }
     }
 }
@@ -147,6 +144,7 @@ impl From<ErrorCode> for u64 {
             ErrorCode::GuestFunctionParameterTypeMismatch => 14,
             ErrorCode::GuestError => 15,
             ErrorCode::ArrayLengthParamIsMissing => 16,
+            ErrorCode::HostFunctionError => 17,
         }
     }
 }
@@ -174,6 +172,7 @@ impl From<ErrorCode> for String {
             }
             ErrorCode::GuestError => "GuestError".to_string(),
             ErrorCode::ArrayLengthParamIsMissing => "ArrayLengthParamIsMissing".to_string(),
+            ErrorCode::HostFunctionError => "HostFunctionError".to_string(),
         }
     }
 }
@@ -194,44 +193,6 @@ impl GuestError {
     }
 }
 
-impl TryFrom<&[u8]> for GuestError {
-    type Error = Error;
-    fn try_from(value: &[u8]) -> Result<Self> {
-        let guest_error_fb = size_prefixed_root::<FbGuestError>(value)
-            .map_err(|e| anyhow::anyhow!("Error while reading GuestError: {:?}", e))?;
-        let code = guest_error_fb.code();
-        let message = match guest_error_fb.message() {
-            Some(message) => message.to_string(),
-            None => String::new(),
-        };
-        Ok(Self {
-            code: code.into(),
-            message,
-        })
-    }
-}
-
-impl TryFrom<&GuestError> for Vec<u8> {
-    type Error = Error;
-    #[cfg_attr(feature = "tracing", instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace"))]
-    fn try_from(value: &GuestError) -> Result<Vec<u8>> {
-        let mut builder = flatbuffers::FlatBufferBuilder::new();
-        let message = builder.create_string(&value.message);
-
-        let guest_error_fb = FbGuestError::create(
-            &mut builder,
-            &GuestErrorArgs {
-                code: value.code.into(),
-                message: Some(message),
-            },
-        );
-        builder.finish_size_prefixed(guest_error_fb, None);
-        let res = builder.finished_data().to_vec();
-
-        Ok(res)
-    }
-}
-
 impl Default for GuestError {
     #[cfg_attr(feature = "tracing", instrument(parent = Span::current(), level= "Trace"))]
     fn default() -> Self {

src/hyperlight_common/src/flatbuffer_wrappers/function_types.rs

@@ -21,7 +21,8 @@ use flatbuffers::FlatBufferBuilder;
 use crate::flatbuffer_wrappers::function_types::ParameterValue;
 use crate::flatbuffers::hyperlight::generated::{
     FunctionCallResult as FbFunctionCallResult, FunctionCallResultArgs as FbFunctionCallResultArgs,
-    ReturnValue as FbReturnValue, hlbool as Fbhlbool, hlboolArgs as FbhlboolArgs,
+    FunctionCallResultType as FbFunctionCallResultType, ReturnValue as FbReturnValue,
+    ReturnValueBox, ReturnValueBoxArgs, hlbool as Fbhlbool, hlboolArgs as FbhlboolArgs,
     hldouble as Fbhldouble, hldoubleArgs as FbhldoubleArgs, hlfloat as Fbhlfloat,
     hlfloatArgs as FbhlfloatArgs, hlint as Fbhlint, hlintArgs as FbhlintArgs, hllong as Fbhllong,
     hllongArgs as FbhllongArgs, hlsizeprefixedbuffer as Fbhlsizeprefixedbuffer,
@@ -34,8 +35,8 @@ use crate::flatbuffers::hyperlight::generated::{
 /// Flatbuffer-encodes the given value
 pub fn get_flatbuffer_result<T: FlatbufferSerializable>(val: T) -> Vec<u8> {
     let mut builder = FlatBufferBuilder::new();
-    let res = &T::serialize(&val, &mut builder);
-    let result_offset = FbFunctionCallResult::create(&mut builder, res);
+    let res = T::serialize(&val, &mut builder);
+    let result_offset = FbFunctionCallResult::create(&mut builder, &res);
 
     builder.finish_size_prefixed(result_offset, None);
 
@@ -50,123 +51,183 @@ pub trait FlatbufferSerializable {
 
 impl FlatbufferSerializable for () {
     fn serialize(&self, builder: &mut FlatBufferBuilder) -> FbFunctionCallResultArgs {
+        let void_off = Fbhlvoid::create(builder, &FbhlvoidArgs {});
+        let rv_box = ReturnValueBox::create(
+            builder,
+            &ReturnValueBoxArgs {
+                value_type: FbReturnValue::hlvoid,
+                value: Some(void_off.as_union_value()),
+            },
+        );
         FbFunctionCallResultArgs {
-            return_value: Some(Fbhlvoid::create(builder, &FbhlvoidArgs {}).as_union_value()),
-            return_value_type: FbReturnValue::hlvoid,
+            result_type: FbFunctionCallResultType::ReturnValueBox,
+            result: Some(rv_box.as_union_value()),
         }
     }
 }
 
 impl FlatbufferSerializable for &str {
     fn serialize(&self, builder: &mut FlatBufferBuilder) -> FbFunctionCallResultArgs {
         let string_offset = builder.create_string(self);
+        let str_off = Fbhlstring::create(
+            builder,
+            &FbhlstringArgs {
+                value: Some(string_offset),
+            },
+        );
+        let rv_box = ReturnValueBox::create(
+            builder,
+            &ReturnValueBoxArgs {
+                value_type: FbReturnValue::hlstring,
+                value: Some(str_off.as_union_value()),
+            },
+        );
         FbFunctionCallResultArgs {
-            return_value: Some(
-                Fbhlstring::create(
-                    builder,
-                    &FbhlstringArgs {
-                        value: Some(string_offset),
-                    },
-                )
-                .as_union_value(),
-            ),
-            return_value_type: FbReturnValue::hlstring,
+            result_type: FbFunctionCallResultType::ReturnValueBox,
+            result: Some(rv_box.as_union_value()),
         }
     }
 }
 
 impl FlatbufferSerializable for &[u8] {
     fn serialize(&self, builder: &mut FlatBufferBuilder) -> FbFunctionCallResultArgs {
-        let vec_offset = builder.create_vector(self);
+        let vec_off = builder.create_vector(self);
+        let buf_off = Fbhlsizeprefixedbuffer::create(
+            builder,
+            &FbhlsizeprefixedbufferArgs {
+                size: self.len() as i32,
+                value: Some(vec_off),
+            },
+        );
+        let rv_box = ReturnValueBox::create(
+            builder,
+            &ReturnValueBoxArgs {
+                value_type: FbReturnValue::hlsizeprefixedbuffer,
+                value: Some(buf_off.as_union_value()),
+            },
+        );
         FbFunctionCallResultArgs {
-            return_value: Some(
-                Fbhlsizeprefixedbuffer::create(
-                    builder,
-                    &FbhlsizeprefixedbufferArgs {
-                        size: self.len() as i32,
-                        value: Some(vec_offset),
-                    },
-                )
-                .as_union_value(),
-            ),
-            return_value_type: FbReturnValue::hlsizeprefixedbuffer,
+            result_type: FbFunctionCallResultType::ReturnValueBox,
+            result: Some(rv_box.as_union_value()),
         }
     }
 }
 
 impl FlatbufferSerializable for f32 {
     fn serialize(&self, builder: &mut FlatBufferBuilder) -> FbFunctionCallResultArgs {
+        let off = Fbhlfloat::create(builder, &FbhlfloatArgs { value: *self });
+        let rv_box = ReturnValueBox::create(
+            builder,
+            &ReturnValueBoxArgs {
+                value_type: FbReturnValue::hlfloat,
+                value: Some(off.as_union_value()),
+            },
+        );
         FbFunctionCallResultArgs {
-            return_value: Some(
-                Fbhlfloat::create(builder, &FbhlfloatArgs { value: *self }).as_union_value(),
-            ),
-            return_value_type: FbReturnValue::hlfloat,
+            result_type: FbFunctionCallResultType::ReturnValueBox,
+            result: Some(rv_box.as_union_value()),
         }
     }
 }
 
 impl FlatbufferSerializable for f64 {
     fn serialize(&self, builder: &mut FlatBufferBuilder) -> FbFunctionCallResultArgs {
+        let off = Fbhldouble::create(builder, &FbhldoubleArgs { value: *self });
+        let rv_box = ReturnValueBox::create(
+            builder,
+            &ReturnValueBoxArgs {
+                value_type: FbReturnValue::hldouble,
+                value: Some(off.as_union_value()),
+            },
+        );
         FbFunctionCallResultArgs {
-            return_value: Some(
-                Fbhldouble::create(builder, &FbhldoubleArgs { value: *self }).as_union_value(),
-            ),
-            return_value_type: FbReturnValue::hldouble,
+            result_type: FbFunctionCallResultType::ReturnValueBox,
+            result: Some(rv_box.as_union_value()),
         }
     }
 }
 
 impl FlatbufferSerializable for i32 {
     fn serialize(&self, builder: &mut FlatBufferBuilder) -> FbFunctionCallResultArgs {
+        let off = Fbhlint::create(builder, &FbhlintArgs { value: *self });
+        let rv_box = ReturnValueBox::create(
+            builder,
+            &ReturnValueBoxArgs {
+                value_type: FbReturnValue::hlint,
+                value: Some(off.as_union_value()),
+            },
+        );
         FbFunctionCallResultArgs {
-            return_value: Some(
-                Fbhlint::create(builder, &FbhlintArgs { value: *self }).as_union_value(),
-            ),
-            return_value_type: FbReturnValue::hlint,
+            result_type: FbFunctionCallResultType::ReturnValueBox,
+            result: Some(rv_box.as_union_value()),
         }
     }
 }
 
 impl FlatbufferSerializable for i64 {
     fn serialize(&self, builder: &mut FlatBufferBuilder) -> FbFunctionCallResultArgs {
+        let off = Fbhllong::create(builder, &FbhllongArgs { value: *self });
+        let rv_box = ReturnValueBox::create(
+            builder,
+            &ReturnValueBoxArgs {
+                value_type: FbReturnValue::hllong,
+                value: Some(off.as_union_value()),
+            },
+        );
         FbFunctionCallResultArgs {
-            return_value: Some(
-                Fbhllong::create(builder, &FbhllongArgs { value: *self }).as_union_value(),
-            ),
-            return_value_type: FbReturnValue::hllong,
+            result_type: FbFunctionCallResultType::ReturnValueBox,
+            result: Some(rv_box.as_union_value()),
         }
     }
 }
 
 impl FlatbufferSerializable for u32 {
     fn serialize(&self, builder: &mut FlatBufferBuilder) -> FbFunctionCallResultArgs {
+        let off = Fbhluint::create(builder, &FbhluintArgs { value: *self });
+        let rv_box = ReturnValueBox::create(
+            builder,
+            &ReturnValueBoxArgs {
+                value_type: FbReturnValue::hluint,
+                value: Some(off.as_union_value()),
+            },
+        );
         FbFunctionCallResultArgs {
-            return_value: Some(
-                Fbhluint::create(builder, &FbhluintArgs { value: *self }).as_union_value(),
-            ),
-            return_value_type: FbReturnValue::hluint,
+            result_type: FbFunctionCallResultType::ReturnValueBox,
+            result: Some(rv_box.as_union_value()),
         }
     }
 }
 
 impl FlatbufferSerializable for u64 {
     fn serialize(&self, builder: &mut FlatBufferBuilder) -> FbFunctionCallResultArgs {
+        let off = Fbhlulong::create(builder, &FbhlulongArgs { value: *self });
+        let rv_box = ReturnValueBox::create(
+            builder,
+            &ReturnValueBoxArgs {
+                value_type: FbReturnValue::hlulong,
+                value: Some(off.as_union_value()),
+            },
+        );
         FbFunctionCallResultArgs {
-            return_value: Some(
-                Fbhlulong::create(builder, &FbhlulongArgs { value: *self }).as_union_value(),
-            ),
-            return_value_type: FbReturnValue::hlulong,
+            result_type: FbFunctionCallResultType::ReturnValueBox,
+            result: Some(rv_box.as_union_value()),
         }
     }
 }
 
 impl FlatbufferSerializable for bool {
     fn serialize(&self, builder: &mut FlatBufferBuilder) -> FbFunctionCallResultArgs {
+        let off = Fbhlbool::create(builder, &FbhlboolArgs { value: *self });
+        let rv_box = ReturnValueBox::create(
+            builder,
+            &ReturnValueBoxArgs {
+                value_type: FbReturnValue::hlbool,
+                value: Some(off.as_union_value()),
+            },
+        );
         FbFunctionCallResultArgs {
-            return_value: Some(
-                Fbhlbool::create(builder, &FbhlboolArgs { value: *self }).as_union_value(),
-            ),
-            return_value_type: FbReturnValue::hlbool,
+            result_type: FbFunctionCallResultType::ReturnValueBox,
+            result: Some(rv_box.as_union_value()),
         }
     }
 }