Features/wasm components

lib/wasmex/components.ex

@@ -0,0 +1,39 @@
+defmodule Wasmex.Components do
+  use GenServer
+
+  def start_link(%{bytes: component_bytes}) do
+    with {:ok, store} <- Wasmex.Components.Store.new(%Wasmex.Wasi.WasiP2Options{}),
+         {:ok, component} <- Wasmex.Components.Component.new(store, component_bytes) do
+      GenServer.start_link(__MODULE__, %{store: store, component: component})
+    end
+  end
+
+  @spec call_function(pid(), String.t() | atom(), list(number()), pos_integer()) ::
+          {:ok, list(number())} | {:error, any()}
+  def call_function(pid, name, params, timeout \\ 5000) do
+    GenServer.call(pid, {:call_function, stringify(name), params}, timeout)
+  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}
+    end
+  end
+
+  @impl true
+  def handle_call(
+        {:call_function, name, params},
+        _from,
+        %{instance: instance} = state
+      ) do
+    case Wasmex.Components.Instance.call_function(instance, name, params) do
+      {:ok, result} -> {:reply, {:ok, result}, state}
+      {:error, error} -> {:error, error}
+    end
+  end
+
+  defp stringify(s) when is_binary(s), do: s
+  defp stringify(s) when is_atom(s), do: Atom.to_string(s)
+end

lib/wasmex/component.ex → lib/wasmex/components/component.ex

@@ -1,4 +1,4 @@
-defmodule Wasmex.Component do
+defmodule Wasmex.Components.Component do
   @type t :: %__MODULE__{
           resource: binary(),
           reference: reference()

lib/wasmex/component_instance.ex → lib/wasmex/components/component_instance.ex

@@ -1,4 +1,4 @@
-defmodule Wasmex.Component.Instance do
+defmodule Wasmex.Components.Instance do
   defstruct store_resource: nil,
             instance_resource: nil,
             # The actual NIF store resource.

lib/wasmex/component_store.ex → lib/wasmex/components/component_store.ex

@@ -1,4 +1,4 @@
-defmodule Wasmex.ComponentStore do
+defmodule Wasmex.Components.Store do
   alias Wasmex.Wasi.WasiP2Options
   alias Wasmex.Engine
 

lib/wasmex/wasi/wasi_p2_options.ex

@@ -1,6 +1,6 @@
 defmodule Wasmex.Wasi.WasiP2Options do
   @moduledoc ~S"""
-  Configures WASI P2 support for a Wasmex.ComponentStore.
+  Configures WASI P2 support for a Wasmex.Components.Store.
 
   """
 

mix.exs

@@ -39,7 +39,7 @@ defmodule Wasmex.MixProject do
   end
 
     # Specifies which paths to compile per environment.
-  defp elixirc_paths(:test), do: ["lib", "test/support"]
+  defp elixirc_paths(:test), do: ["lib", "test/component_fixtures"]
   defp elixirc_paths(_), do: ["lib"]
 
   defp package() do

native/wasmex/src/component_instance.rs

@@ -176,7 +176,6 @@ fn val_to_term<'a>(val: &Val, env: rustler::Env<'a>) -> Term<'a> {
                 .map(|(key, val)| (key, val_to_term(val, env)))
                 .collect::<Vec<(&String, Term<'a>)>>();
             Term::map_from_pairs(env, converted_pairs.as_slice()).unwrap()
-            // String::from("wut").encode(env)
         }
         Val::Tuple(tuple) => {
             let tuple_terms = tuple

test/components/component_test.exs

@@ -0,0 +1,66 @@
+defmodule Wasmex.WasmComponentsTest do
+  use ExUnit.Case, async: true
+
+  alias Wasmex.Engine
+  alias Wasmex.EngineConfig
+
+  test "invoke component func" do
+    {:ok, store} = Wasmex.Components.Store.new(%Wasmex.Wasi.WasiP2Options{})
+    component_bytes = File.read!("test/component_fixtures/hello_world/hello_world.wasm")
+    {:ok, component} = Wasmex.Components.Component.new(store, component_bytes)
+    IO.inspect("building instance")
+    {:ok, instance} = Wasmex.Components.Instance.new(store, component)
+    IO.inspect("executing component function")
+
+    assert {:ok, "Hello, Elixir!"} =
+             Wasmex.Components.Instance.call_function(instance, "greet", ["Elixir"])
+
+    assert {:ok, ["Hello, Elixir!", "Hello, Elixir!"]} =
+             Wasmex.Components.Instance.call_function(instance, "multi-greet", ["Elixir", 2])
+  end
+
+  test "functions with maps and lists" do
+    {:ok, store} = Wasmex.Components.Store.new(%Wasmex.Wasi.WasiP2Options{inherit_stdout: true})
+
+    component_bytes = File.read!("test/component_fixtures/live_state/live-state.wasm")
+    {:ok, component} = Wasmex.Components.Component.new(store, component_bytes)
+    {:ok, instance} = Wasmex.Components.Instance.new(store, component)
+
+    assert {:ok, %{"customers" => [customer]} = state} =
+             Wasmex.Components.Instance.call_function(instance, "init", [])
+
+    assert customer["email"] == "[email protected]"
+
+    customer2 = Map.put(customer, "last-name", "Smith")
+
+    assert {:ok, shown} =
+             Wasmex.Components.Instance.call_function(instance, "show-customer", [customer2])
+
+    assert {:ok, %{"customers" => customers} = state} =
+             Wasmex.Components.Instance.call_function(instance, "add-customer", [customer2, state])
+
+    assert Enum.count(customers) == 2
+  end
+
+  describe "error handling" do
+    setup do
+      {:ok, store} = Wasmex.Components.Store.new(%Wasmex.Wasi.WasiP2Options{inherit_stdout: true})
+
+      component_bytes = File.read!("test/component_fixtures/hello_world/hello_world.wasm")
+      {:ok, component} = Wasmex.Components.Component.new(store, component_bytes)
+      {:ok, instance} = Wasmex.Components.Instance.new(store, component)
+      %{instance: instance}
+    end
+
+    test "function not exported", %{instance: instance} do
+
+      assert {:error, error} = Wasmex.Components.Instance.call_function(instance, "garbage", [:wut])
+      assert error =~ "garbage not exported"
+    end
+
+    test "invalid arguments", %{instance: instance} do
+      assert {:error, error} = Wasmex.Components.Instance.call_function(instance, "greet", [1])
+      assert error =~ "type mismatch"
+    end
+  end
+end

test/components/component_types_test.exs

@@ -0,0 +1,53 @@
+defmodule Wasm.Components.ComponentTypesTest do
+  use ExUnit.Case, async: true
+
+  alias Wasmex.Engine
+  alias Wasmex.EngineConfig
+
+  setup do
+    {:ok, store} = Wasmex.Components.Store.new(%Wasmex.Wasi.WasiP2Options{})
+    component_bytes = File.read!("test/component_fixtures/component_types/component_types.wasm")
+    {:ok, component} = Wasmex.Components.Component.new(store, component_bytes)
+    {:ok, instance} = Wasmex.Components.Instance.new(store, component)
+    [instance: instance]
+  end
+
+  test "strings", %{instance: instance} do
+    assert {:ok, "mom"} = Wasmex.Components.Instance.call_function(instance, "id-string", ["mom"])
+  end
+
+  test "boolean", %{instance: instance} do
+    assert {:ok, true} = Wasmex.Components.Instance.call_function(instance, "id-bool", [true])
+  end
+
+  test "integers", %{instance: instance} do
+    # all the integer types
+    for type <- ["u8", "u16", "u32", "u64", "s8", "s16", "s32", "s64"] do
+      assert {:ok, 7} = Wasmex.Components.Instance.call_function(instance, "id-#{type}", [7])
+    end
+  end
+
+  test "floats", %{instance: instance} do
+    pi = 3.14592
+    assert {:ok, pi} = Wasmex.Components.Instance.call_function(instance, "id-f32", [pi])
+    assert {:ok, pi} = Wasmex.Components.Instance.call_function(instance, "id-f64", [pi])
+  end
+
+  test "records", %{instance: instance} do
+    # don't love this yet, be nicer to support atom keys
+    assert {:ok, %{"x" => 1, "y" => 2}} =
+             Wasmex.Components.Instance.call_function(instance, "id-record", [
+               %{"x" => 1, "y" => 2}
+             ])
+  end
+
+  test "lists", %{instance: instance} do
+    assert {:ok, [1, 2, 3]} =
+             Wasmex.Components.Instance.call_function(instance, "id-list", [[1, 2, 3]])
+  end
+
+  test "tuples", %{instance: instance} do
+    assert {:ok, {1, "two"}} =
+             Wasmex.Components.Instance.call_function(instance, "id-tuple", [{1, "two"}])
+  end
+end

test/components/components_test.exs

@@ -0,0 +1,9 @@
+defmodule Wasmex.ComponentsTest do
+  use ExUnit.Case, async: true
+
+  test "interacting with a component server" do
+    component_bytes = File.read!("test/component_fixtures/component_types/component_types.wasm")
+    component = start_supervised!({Wasmex.Components, %{bytes: component_bytes}})
+    assert {:ok, "mom"} = Wasmex.Components.call_function(component, "id-string", ["mom"])
+  end
+end