50d9fa58a1
This reverts `Runtime.NewModule` back to `InstantiateModule` as it calls
more attention to the registration aspect of it, and also makes a chain
of `NewXX` more clear. This is particularly helpful as this change
introduces `ModuleBuilder` which is created by `NewModuleBuilder`.
`ModuleBuilder` is a way to define a WebAssembly 1.0 (20191205) in Go.
The first iteration allows setting the module name and exported
functions. The next PR will add globals.
Ex. Below defines and instantiates a module named "env" with one function:
```go
hello := func() {
fmt.Fprintln(stdout, "hello!")
}
_, err := r.NewModuleBuilder("env").ExportFunction("hello", hello).InstantiateModule()
```
If the same module may be instantiated multiple times, it is more efficient to separate steps. Ex.
```go
env, err := r.NewModuleBuilder("env").ExportFunction("get_random_string", getRandomString).Build()
_, err := r.InstantiateModule(env.WithName("env.1"))
_, err := r.InstantiateModule(env.WithName("env.2"))
```
Note: Builder methods do not return errors, to allow chaining. Any validation errors are deferred until Build.
Note: Insertion order is not retained. Anything defined by this builder is sorted lexicographically on Build.
Signed-off-by: Adrian Cole <adrian@tetrate.io>
63 lines
1.9 KiB
Go
63 lines
1.9 KiB
Go
package examples
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/tetratelabs/wazero"
|
|
"github.com/tetratelabs/wazero/wasi"
|
|
"github.com/tetratelabs/wazero/wasm"
|
|
)
|
|
|
|
func Test_WASI(t *testing.T) {
|
|
// built-in WASI function to write a random value to memory
|
|
randomGet := func(ctx wasm.Module, buf, bufLen uint32) wasi.Errno {
|
|
panic("unimplemented")
|
|
}
|
|
|
|
stdout := new(bytes.Buffer)
|
|
random := func(ctx wasm.Module) {
|
|
// Write 8 random bytes to memory using WASI.
|
|
errno := randomGet(ctx, 0, 8)
|
|
require.Equal(t, wasi.ErrnoSuccess, errno)
|
|
|
|
// Read them back and print it in hex!
|
|
random, ok := ctx.Memory().ReadUint64Le(0)
|
|
require.True(t, ok)
|
|
_, _ = fmt.Fprintf(stdout, "random: %x\n", random)
|
|
}
|
|
|
|
r := wazero.NewRuntime()
|
|
|
|
// Host functions can be exported as any module name, including the empty string.
|
|
_, err := r.NewModuleBuilder("").ExportFunction("random", random).Instantiate()
|
|
require.NoError(t, err)
|
|
|
|
// Configure WASI and implement the function to use it
|
|
we, err := r.InstantiateModule(wazero.WASISnapshotPreview1())
|
|
require.NoError(t, err)
|
|
randomGetFn := we.ExportedFunction("random_get")
|
|
|
|
// Implement the function pointer. This mainly shows how you can decouple a host function dependency.
|
|
randomGet = func(ctx wasm.Module, buf, bufLen uint32) wasi.Errno {
|
|
res, err := randomGetFn.Call(ctx, uint64(buf), uint64(bufLen))
|
|
require.NoError(t, err)
|
|
return wasi.Errno(res[0])
|
|
}
|
|
|
|
// The "random" function was imported as $random in Wasm. Since it was marked as the start
|
|
// function, it is invoked on instantiation. Ensure that worked: "random" was called!
|
|
_, err = r.InstantiateModuleFromSource([]byte(`(module $wasi
|
|
(import "wasi_snapshot_preview1" "random_get"
|
|
(func $wasi.random_get (param $buf i32) (param $buf_len i32) (result (;errno;) i32)))
|
|
(import "" "random" (func $random))
|
|
(memory 1)
|
|
(start $random)
|
|
)`))
|
|
require.NoError(t, err)
|
|
require.Contains(t, stdout.String(), "random: ")
|
|
}
|