xxchan · xxchan · Feb 26, 2023 · Feb 26, 2023 · Apr 9, 2023 · Feb 26, 2023
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/fluvio-smartengine/Cargo.toml b/crates/fluvio-smartengine/Cargo.toml
@@ -12,17 +12,21 @@ description = "The official Fluvio SmartEngine"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
-engine = ["wasmtime"]
-wasi = ["wasmtime-wasi", "engine"]
+engine = []
+wasi = ["wasmtime-wasi", "wasmtime-engine", "engine"]
 transformation = ["serde_json", "serde_yaml"]
 default = ["engine"]
-
+wasmtime-engine = ["wasmtime"]
+wasmedge-engine = ["wasmedge-sdk"]
 
 [dependencies]
 tracing ={ workspace = true }
 thiserror = { workspace = true }
 anyhow = { workspace = true }
-serde = { workspace = true,  features = ['derive'] }
+# Use the Clone trait
+wasmedge-sdk = { git = "https://github.com/WasmEdge/WasmEdge", rev = "fe5fe2c", optional = true }
+# std is needed for ser/de AtomicU64
+serde = { workspace = true,  features = ['derive', 'std'] }
 serde_json = { workspace = true, optional = true }
 serde_yaml = { workspace = true, default-features = false, optional = true }
 cfg-if = { workspace = true }

diff --git a/crates/fluvio-smartengine/src/engine/common/init.rs b/crates/fluvio-smartengine/src/engine/common/init.rs
@@ -0,0 +1,63 @@
+use super::{WasmFn, WasmInstance};
+use anyhow::Result;
+use fluvio_smartmodule::dataplane::smartmodule::{
+    SmartModuleInitInput, SmartModuleInitErrorStatus, SmartModuleInitOutput,
+};
+
+pub(crate) const INIT_FN_NAME: &str = "init";
+
+pub(crate) struct SmartModuleInit<F: WasmFn>(F);
+
+impl<F: WasmFn> std::fmt::Debug for SmartModuleInit<F> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "InitFn")
+    }
+}
+
+impl<F: WasmFn + Send + Sync> SmartModuleInit<F> {
+    pub(crate) fn try_instantiate<I>(
+        instance: &mut I,
+        ctx: &mut <I as WasmInstance>::Context,
+    ) -> Result<Option<Self>>
+    where
+        I: WasmInstance<Func = F>,
+        F: WasmFn<Context = I::Context>,
+    {
+        match instance.get_fn(INIT_FN_NAME, ctx)? {
+            Some(func) => Ok(Some(Self(func))),
+            None => Ok(None),
+        }
+    }
+}
+
+impl<F: WasmFn + Send + Sync> SmartModuleInit<F> {
+    /// initialize SmartModule
+    pub(crate) fn initialize<I>(
+        &mut self,
+        input: SmartModuleInitInput,
+        instance: &mut I,
+        ctx: &mut I::Context,
+    ) -> Result<()>
+    where
+        I: WasmInstance,
+        F: WasmFn<Context = I::Context>,
+    {
+        let (ptr, len, version) = instance.write_input(&input, ctx)?;
+        let init_output = self.0.call(ptr, len, version, ctx)?;
+
+        if init_output < 0 {
+            let internal_error = SmartModuleInitErrorStatus::try_from(init_output)
+                .unwrap_or(SmartModuleInitErrorStatus::UnknownError);
+
+            match internal_error {
+                SmartModuleInitErrorStatus::InitError => {
+                    let output: SmartModuleInitOutput = instance.read_output(ctx)?;
+                    Err(output.error.into())
+                }
+                _ => Err(internal_error.into()),
+            }
+        } else {
+            Ok(())
+        }
+    }
+}