main.go

package main

// #include <stdlib.h>
//
// extern void opa_abort(void *context, int32_t addr);
// extern int32_t opa_builtin0(void *context, int32_t builtin_id, int32_t ctx);
// extern int32_t opa_builtin1(void *context, int32_t builtin_id, int32_t ctx, int32_t arg0);
// extern int32_t opa_builtin2(void *context, int32_t builtin_id, int32_t ctx, int32_t arg0, int32_t arg1);
// extern int32_t opa_builtin3(void *context, int32_t builtin_id, int32_t ctx, int32_t arg0, int32_t arg1, int32_t arg2);
// extern int32_t opa_builtin4(void *context, int32_t builtin_id, int32_t ctx, int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3);
import "C"

import (
	"fmt"
	"io/ioutil"
	"runtime"
	"time"
	"unsafe"

	wasm "github.com/wasmerio/go-ext-wasm/wasmer"
)

// PrintMemUsage outputs the current, total and OS memory being used. As well as the number
// of garage collection cycles completed.
func PrintMemUsage() {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	// For info on each, see: https://golang.org/pkg/runtime/#MemStats
	fmt.Printf("Alloc = %v MiB", bToMb(m.Alloc))
	fmt.Printf("\tTotalAlloc = %v MiB", bToMb(m.TotalAlloc))
	fmt.Printf("\tSys = %v MiB", bToMb(m.Sys))
	fmt.Printf("\tNumGC = %v\n", m.NumGC)
}

func bToMb(b uint64) uint64 {
	return b / 1024 / 1024
}

func main() {

	go func() {
		for {
			PrintMemUsage()
			time.Sleep(time.Second)
		}
	}()

	v := newVM()
	_ = v

	ch := make(chan struct{})
	<-ch
}

type vm struct {
	instance *wasm.Instance
	memory   *wasm.Memory
}

func newVM() *vm {
	memory, err := wasm.NewMemory(2, 0)
	if err != nil {
		panic(err)
	}

	imports, err := opaFunctions(wasm.NewImports())
	if err != nil {
		panic(err)
	}

	imports, err = imports.AppendMemory("memory", memory)
	if err != nil {
		panic(err)
	}

	policy, err := ioutil.ReadFile("policy.wasm")
	if err != nil {
		panic(err)
	}

	i, err := wasm.NewInstanceWithImports(policy, imports)
	if err != nil {
		panic(err)
	}

	v := &vm{
		instance: &i,
		memory:   memory,
	}

	return v
}

func (i *vm) Abort(arg int32) {
	panic("abort")
}

func (i *vm) Builtin(builtinID, ctx int32, args ...int32) int32 {
	panic("built-in")
}

func opaFunctions(imports *wasm.Imports) (*wasm.Imports, error) {
	imports, err := imports.AppendFunction("opa_abort", opa_abort, C.opa_abort)
	if err != nil {
		return nil, err
	}

	imports, err = imports.AppendFunction("opa_builtin0", opa_builtin0, C.opa_builtin0)
	if err != nil {
		return nil, err
	}

	imports, err = imports.AppendFunction("opa_builtin1", opa_builtin1, C.opa_builtin1)
	if err != nil {
		return nil, err
	}

	imports, err = imports.AppendFunction("opa_builtin2", opa_builtin2, C.opa_builtin2)
	if err != nil {
		return nil, err
	}

	imports, err = imports.AppendFunction("opa_builtin3", opa_builtin3, C.opa_builtin3)
	if err != nil {
		return nil, err
	}

	return imports.AppendFunction("opa_builtin4", opa_builtin4, C.opa_builtin4)
}

//export opa_abort
func opa_abort(ctx unsafe.Pointer, addr int32) {
	getVM(ctx).Abort(addr)
}

//export opa_builtin0
func opa_builtin0(ctx unsafe.Pointer, builtinID, context int32) int32 {
	return getVM(ctx).Builtin(builtinID, context)
}

//export opa_builtin1
func opa_builtin1(ctx unsafe.Pointer, builtinID, context, arg0 int32) int32 {
	return getVM(ctx).Builtin(builtinID, context, arg0)
}

//export opa_builtin2
func opa_builtin2(ctx unsafe.Pointer, builtinID, context, arg0, arg1 int32) int32 {
	return getVM(ctx).Builtin(builtinID, context, arg0, arg1)
}

//export opa_builtin3
func opa_builtin3(ctx unsafe.Pointer, builtinID, context, arg0, arg1, arg2 int32) int32 {
	return getVM(ctx).Builtin(builtinID, context, arg0, arg1, arg2)
}

//export opa_builtin4
func opa_builtin4(ctx unsafe.Pointer, builtinID, context, arg0, arg1, arg2, arg3 int32) int32 {
	return getVM(ctx).Builtin(builtinID, context, arg0, arg1, arg2, arg3)
}

func getVM(ctx unsafe.Pointer) *vm {
	ictx := wasm.IntoInstanceContext(ctx)
	return ictx.Data().(*vm)
}