Merge pull request #692 from tessi/features/component-imports

Features/component imports

Author: superchris

lib/wasmex/components.ex

@@ -25,8 +25,13 @@ defmodule Wasmex.Components do
   def start_link(opts) when is_list(opts) do
     with {:ok, store} <- build_store(opts),
          component_bytes <- Keyword.get(opts, :bytes),
+         imports <- Keyword.get(opts, :imports, %{}),
          {:ok, component} <- Wasmex.Components.Component.new(store, component_bytes) do
-      GenServer.start_link(__MODULE__, %{store: store, component: component}, opts)
+      GenServer.start_link(
+        __MODULE__,
+        %{store: store, component: component, imports: imports},
+        opts
+      )
     end
   end
 
@@ -45,23 +50,45 @@ defmodule Wasmex.Components do
   end
 
   @impl true
-  def init(%{store: store, component: component} = state) do
-    case Wasmex.Components.Instance.new(store, component) do
-      {:ok, instance} -> {:ok, Map.merge(state, %{instance: instance})}
-      {:error, reason} -> {:error, reason}
+  def init(%{store: store, component: component, imports: imports} = state) do
+    case Wasmex.Components.Instance.new(store, component, imports) do
+      {:ok, instance} ->
+        {:ok, Map.merge(state, %{instance: instance, component: component, imports: imports})}
+
+      {:error, reason} ->
+        {:error, reason}
     end
   end
 
   @impl true
   def handle_call(
         {:call_function, name, params},
-        _from,
+        from,
         %{instance: instance} = state
       ) do
-    case Wasmex.Components.Instance.call_function(instance, name, params) do
-      {:ok, result} -> {:reply, {:ok, result}, state}
-      {:error, error} -> {:reply, {:error, error}, state}
+    :ok = Wasmex.Components.Instance.call_function(instance, name, params, from)
+    {:noreply, state}
+  end
+
+  @impl true
+  def handle_info({:returned_function_call, result, from}, state) do
+    case result do
+      {:raise, reason} -> raise(reason)
+      valid_result -> GenServer.reply(from, valid_result)
     end
+
+    {:noreply, state}
+  end
+
+  @impl true
+  def handle_info(
+        {:invoke_callback, name, token, params},
+        %{imports: imports, instance: _instance, component: component} = state
+      ) do
+    {:fn, function} = Map.get(imports, name)
+    result = apply(function, params)
+    :ok = Wasmex.Native.component_receive_callback_result(component.resource, token, true, result)
+    {:noreply, state}
   end
 
   defp stringify(s) when is_binary(s), do: s

lib/wasmex/components/component.ex

@@ -33,12 +33,14 @@ defmodule Wasmex.Components.Component do
   end
 
   defmacro __using__(opts) do
+    macro_imports = Keyword.get(opts, :imports, %{})
+
     genserver_setup =
       quote do
         use GenServer
 
         def start_link(opts) do
-          Wasmex.Components.start_link(opts)
+          Wasmex.Components.start_link(opts |> Keyword.put(:imports, unquote(macro_imports)))
         end
 
         def handle_call(request, from, state) do

lib/wasmex/components/component_instance.ex

@@ -19,11 +19,15 @@ defmodule Wasmex.Components.Instance do
     }
   end
 
-  def new(store_or_caller, component) do
+  def new(store_or_caller, component, imports) do
     %{resource: store_or_caller_resource} = store_or_caller
     %{resource: component_resource} = component
 
-    case Wasmex.Native.component_instance_new(store_or_caller_resource, component_resource) do
+    case Wasmex.Native.component_instance_new(
+           store_or_caller_resource,
+           component_resource,
+           imports
+         ) do
       {:error, err} -> {:error, err}
       resource -> {:ok, __wrap_resource__(store_or_caller_resource, resource)}
     end
@@ -32,8 +36,9 @@ defmodule Wasmex.Components.Instance do
   def call_function(
         %__MODULE__{store_resource: store_resource, instance_resource: instance_resource},
         function,
-        args
+        args,
+        from
       ) do
-    Wasmex.Native.component_call_function(store_resource, instance_resource, function, args)
+    Wasmex.Native.component_call_function(store_resource, instance_resource, function, args, from)
   end
 end

lib/wasmex/native.ex

@@ -89,9 +89,11 @@ defmodule Wasmex.Native do
 
   def component_new(_store, _component_bytes), do: error()
 
-  def component_instance_new(_store, _component), do: error()
+  def component_instance_new(_store, _component, _imports), do: error()
 
-  def component_call_function(_store, _instance, _function_name, _params), do: error()
+  def component_call_function(_store, _instance, _function_name, _params, _from), do: error()
+
+  def component_receive_callback_result(_component, _2, _3, _4), do: error()
 
   def wit_exported_functions(_path, _wit), do: error()
 

native/wasmex/src/atoms.rs

@@ -1,6 +1,7 @@
 rustler::atoms! {
     ok,
     error,
+    raise,
     __nil__ = "nil",
 
     // memory types

native/wasmex/src/component.rs

@@ -4,12 +4,21 @@ use rustler::Error;
 use rustler::NifResult;
 use rustler::ResourceArc;
 use wasmtime::Store;
+use wit_parser::decoding::DecodedWasm;
+use wit_parser::Resolve;
+use wit_parser::WorldId;
 
 use std::sync::Mutex;
-use wasmtime::component::{Component, Instance, Linker};
+use wasmtime::component::Component;
 
 pub struct ComponentResource {
     pub inner: Mutex<Component>,
+    pub parsed: ParsedComponent,
+}
+
+pub struct ParsedComponent {
+    pub world_id: WorldId,
+    pub resolve: Resolve,
 }
 
 #[rustler::resource_impl()]
@@ -27,49 +36,20 @@ pub fn new_component(
             )))
         })?);
     let bytes = component_binary.as_slice();
+    let decoded_wasm = wit_parser::decoding::decode(bytes)
+        .map_err(|e| Error::Term(Box::new(format!("Unable to decode WASM: {e}"))))?;
+    let parsed_component = match decoded_wasm {
+        DecodedWasm::WitPackage(_, _) => {
+            return Err(rustler::Error::RaiseAtom("Only components are supported"))
+        }
+        DecodedWasm::Component(resolve, world_id) => ParsedComponent { world_id, resolve },
+    };
 
     let component = Component::new(store_or_caller.engine(), bytes)
         .map_err(|err| rustler::Error::Term(Box::new(err.to_string())))?;
 
     Ok(ResourceArc::new(ComponentResource {
         inner: Mutex::new(component),
+        parsed: parsed_component,
     }))
 }
-
-#[rustler::nif(name = "component_instance_new")]
-pub fn new_component_instance(
-    component_store_resource: ResourceArc<ComponentStoreResource>,
-    component_resource: ResourceArc<ComponentResource>,
-) -> NifResult<ResourceArc<ComponentInstanceResource>> {
-    let component_store: &mut Store<ComponentStoreData> =
-        &mut *(component_store_resource.inner.lock().map_err(|e| {
-            rustler::Error::Term(Box::new(format!(
-                "Could not unlock component_store resource as the mutex was poisoned: {e}"
-            )))
-        })?);
-
-    let component = &mut component_resource.inner.lock().map_err(|e| {
-        rustler::Error::Term(Box::new(format!(
-            "Could not unlock component resource as the mutex was poisoned: {e}"
-        )))
-    })?;
-
-    let mut linker = Linker::new(component_store.engine());
-    let _ = wasmtime_wasi::add_to_linker_sync(&mut linker);
-    let _ = wasmtime_wasi_http::add_only_http_to_linker_sync(&mut linker);
-    // Instantiate the component
-    let instance = linker
-        .instantiate(&mut *component_store, component)
-        .map_err(|err| Error::Term(Box::new(err.to_string())))?;
-
-    Ok(ResourceArc::new(ComponentInstanceResource {
-        inner: Mutex::new(instance),
-    }))
-}
-
-pub struct ComponentInstanceResource {
-    pub inner: Mutex<Instance>,
-}
-
-#[rustler::resource_impl()]
-impl rustler::Resource for ComponentInstanceResource {}