Features/wasm components

.vscode/tasks.json

@@ -0,0 +1,163 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "mix test",
+      "type": "shell",
+      "command": "mix",
+      "args": [
+        "test",
+        "--color"
+      ],
+      "options": {
+        "cwd": "${workspaceRoot}",
+        "requireFiles": [
+          "test/**/test_helper.exs",
+          "test/**/*_test.exs"
+        ]
+      },
+      "problemMatcher": "$mixTestFailure"
+    },
+    {
+      "label": "mix test failed",
+      "type": "shell",
+      "command": "mix",
+      "args": [
+        "test",
+        "--color",
+        "--failed",
+        "--trace"
+      ],
+      "options": {
+        "cwd": "${workspaceRoot}",
+        "requireFiles": [
+          "test/**/test_helper.exs",
+          "test/**/*_test.exs"
+        ]
+      },
+      "problemMatcher": "$mixTestFailure"
+    },
+    {
+      "label": "mix test file",
+      "type": "shell",
+      "command": "mix",
+      "args": [
+        "test",
+        "${relativeFile}",
+        "--color",
+        "--trace"
+      ],
+      "options": {
+        "cwd": "${workspaceRoot}",
+        "env": {
+          "WASMEX_BUILD": "true"
+        },
+        "requireFiles": [
+          "test/**/test_helper.exs",
+          "test/**/*_test.exs"
+        ]
+      },
+      "problemMatcher": "$mixTestFailure"
+    },
+    {
+      "label": "mix test focused",
+      "type": "shell",
+      "command": "mix",
+      "args": [
+        "test",
+        "${relativeFile}:${lineNumber}",
+        "--color",
+        "--trace"
+      ],
+      "options": {
+        "cwd": "${workspaceRoot}",
+        "requireFiles": [
+          "test/**/test_helper.exs",
+          "test/**/*_test.exs"
+        ],
+        "env": {
+          "WASMEX_BUILD": "true"
+        }
+      },
+      "problemMatcher": "$mixTestFailure",
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      }
+    },
+    {
+      "label": "Initial Setup",
+      "type": "process",
+      "command": "mix",
+      "args": [
+        "setup"
+      ],
+      "options": {
+        "cwd": "${workspaceRoot}"
+      },
+      "problemMatcher": [
+        "$mixCompileError"
+      ]
+    },
+    {
+      "label": "mix compile",
+      "type": "process",
+      "command": "mix",
+      "args": [
+        "test",
+        "--exclude",
+        "test",
+        "--warnings-as-errors"
+      ],
+      "options": {
+        "cwd": "${workspaceRoot}"
+      },
+      "problemMatcher": [
+        "$mixCompileWarning",
+        "$mixCompileError"
+      ],
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      }
+    },
+    {
+      "label": "mix format",
+      "type": "process",
+      "command": "mix",
+      "args": [
+        "format"
+      ],
+      "options": {
+        "cwd": "${workspaceRoot}"
+      },
+      "problemMatcher": [
+        "$mixCompileWarning",
+        "$mixCompileError"
+      ],
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      }
+    },
+    {
+      "label": "mix check",
+      "type": "process",
+      "command": "mix",
+      "args": [
+        "check"
+      ],
+      "options": {
+        "cwd": "${workspaceRoot}"
+      },
+      "problemMatcher": [
+        "$mixCompileWarning",
+        "$mixCompileError"
+      ],
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      }
+    }
+  ]
+}

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/components/component.ex

@@ -0,0 +1,29 @@
+defmodule Wasmex.Components.Component do
+  @type t :: %__MODULE__{
+          resource: binary(),
+          reference: reference()
+        }
+
+  defstruct resource: nil,
+            # The actual NIF store resource.
+            # Normally the compiler will happily do stuff like inlining the
+            # resource in attributes. This will convert the resource into an
+            # empty binary with no warning. This will make that harder to
+            # accidentally do.
+            reference: nil
+
+  def __wrap_resource__(resource) do
+    %__MODULE__{
+      resource: resource,
+      reference: make_ref()
+    }
+  end
+
+  def new(store_or_caller, component_bytes) do
+    %{resource: store_or_caller_resource} = store_or_caller
+    case Wasmex.Native.component_new(store_or_caller_resource, component_bytes) do
+      {:error, err} -> {:error, err}
+      resource -> {:ok, __wrap_resource__(resource)}
+    end
+  end
+end

lib/wasmex/components/component_instance.ex

@@ -0,0 +1,36 @@
+defmodule Wasmex.Components.Instance do
+  defstruct store_resource: nil,
+            instance_resource: nil,
+            # The actual NIF store resource.
+            # Normally the compiler will happily do stuff like inlining the
+            # resource in attributes. This will convert the resource into an
+            # empty binary with no warning. This will make that harder to
+            # accidentally do.
+            reference: nil
+
+  def __wrap_resource__(store_resource, instance_resource) do
+    %__MODULE__{
+      store_resource: store_resource,
+      instance_resource: instance_resource,
+      reference: make_ref()
+    }
+  end
+
+  def new(store_or_caller, component) 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
+      {:error, err} -> {:error, err}
+      resource -> {:ok, __wrap_resource__(store_or_caller_resource, resource)}
+    end
+  end
+
+  def call_function(
+        %__MODULE__{store_resource: store_resource, instance_resource: instance_resource},
+        function,
+        args
+      ) do
+    Wasmex.Native.component_call_function(store_resource, instance_resource, function, args)
+  end
+end

lib/wasmex/components/component_store.ex

@@ -0,0 +1,26 @@
+defmodule Wasmex.Components.Store do
+  alias Wasmex.Wasi.WasiP2Options
+  alias Wasmex.Engine
+
+  defstruct resource: nil, reference: nil
+
+  def __wrap_resource__(resource) do
+    %__MODULE__{
+      resource: resource,
+      reference: make_ref()
+    }
+  end
+
+  def new(%WasiP2Options{} = options, store_limits \\ nil, engine \\ nil) do
+    %Engine{resource: engine_resource} = engine || Engine.default()
+
+    case Wasmex.Native.store_new_wasi_p2(
+           options,
+           store_limits,
+           engine_resource
+         ) do
+      {:error, err} -> {:error, err}
+      resource -> {:ok, __MODULE__.__wrap_resource__(resource)}
+    end
+  end
+end

lib/wasmex/engine_config.ex

@@ -19,7 +19,8 @@ defmodule Wasmex.EngineConfig do
   defstruct consume_fuel: false,
             cranelift_opt_level: :none,
             wasm_backtrace_details: false,
-            memory64: false
+            memory64: false,
+            wasm_component_model: true
 
   @type t :: %__MODULE__{
           consume_fuel: boolean(),

lib/wasmex/native.ex

@@ -80,10 +80,17 @@ defmodule Wasmex.Native do
 
   def store_new(_store_limits, _engine_resource), do: error()
   def store_new_wasi(_wasi_options, _store_limits, _engine_resource), do: error()
+  def store_new_wasi_p2(_wasi_options, _store_limits, _engine_resource), do: error()
 
   def store_or_caller_get_fuel(_store_or_caller_resource), do: error()
   def store_or_caller_set_fuel(_store_or_caller_resource, _fuel), do: error()
 
+  def component_new(_store, _component_bytes), do: error()
+
+  def component_instance_new(_store, _component), do: error()
+
+  def component_call_function(_store, _instance, _function_name, _params), do: error()
+
   # When the NIF is loaded, it will override functions in this module.
   # Calling error is handles the case when the nif could not be loaded.
   defp error, do: :erlang.nif_error(:nif_not_loaded)

lib/wasmex/wasi/wasi_p2_options.ex

@@ -0,0 +1,22 @@
+defmodule Wasmex.Wasi.WasiP2Options do
+  @moduledoc ~S"""
+  Configures WASI P2 support for a Wasmex.Components.Store.
+
+  """
+
+  defstruct inherit_stdin: true,
+            inherit_stdout: true,
+            inherit_stderr: true,
+            allow_http: false,
+            args: [],
+            env: %{}
+
+  @type t :: %__MODULE__{
+          args: [String.t()],
+          env: %{String.t() => String.t()},
+          inherit_stdin: boolean(),
+          inherit_stdout: boolean(),
+          inherit_stdin: boolean(),
+          allow_http: boolean()
+        }
+end

mix.exs

@@ -9,6 +9,7 @@ defmodule Wasmex.MixProject do
       version: @version,
       elixir: "~> 1.12",
       start_permanent: Mix.env() == :prod,
+      elixirc_paths: elixirc_paths(Mix.env()),
       name: "wasmex",
       description: description(),
       package: package(),
@@ -37,6 +38,10 @@ defmodule Wasmex.MixProject do
     "Wasmex is an Elixir library for executing WebAssembly binaries"
   end
 
+    # Specifies which paths to compile per environment.
+  defp elixirc_paths(:test), do: ["lib", "test/component_fixtures"]
+  defp elixirc_paths(_), do: ["lib"]
+
   defp package() do
     [
       # These are the default files included in the package