Wasm middleware: add ability to pass config to guest

middleware/http/wasm/benchmark_test.go

@@ -28,19 +28,19 @@ func BenchmarkNative(b *testing.B) {
 }
 
 func BenchmarkTinygo(b *testing.B) {
-	path := "./internal/e2e-guests/rewrite/main.wasm"
+	path := "file://internal/e2e-guests/rewrite/main.wasm"
 	benchmarkMiddleware(b, path)
 }
 
 // BenchmarkWat gives baseline performance for the same handler by
 // writing it directly in WebAssembly Text Format.
 func BenchmarkWat(b *testing.B) {
-	path := "./internal/testdata/rewrite.wasm"
+	path := "file://internal/testdata/rewrite.wasm"
 	benchmarkMiddleware(b, path)
 }
 
 func benchmarkMiddleware(b *testing.B, path string) {
-	md := metadata.Base{Properties: map[string]string{"path": path}}
+	md := metadata.Base{Properties: map[string]string{"url": path}}
 
 	l := logger.NewLogger(b.Name())
 	l.SetOutput(io.Discard)

middleware/http/wasm/httpwasm.go

@@ -20,6 +20,8 @@ import (
 	"github.com/dapr/kit/logger"
 )
 
+const metadataConfig = "config"
+
 type middleware struct {
 	logger logger.Logger
 }
@@ -43,6 +45,8 @@ func (m *middleware) getHandler(ctx context.Context, metadata dapr.Metadata) (*r
 		return nil, fmt.Errorf("wasm: failed to parse metadata: %w", err)
 	}
 
+	wasmConfig := []byte(metadata.Properties[metadataConfig])
+
 	var stdout, stderr bytes.Buffer
 	mw, err := wasmnethttp.NewMiddleware(ctx, meta.Guest,
 		handler.Logger(m),
@@ -54,7 +58,8 @@ func (m *middleware) getHandler(ctx context.Context, metadata dapr.Metadata) (*r
 			WithRandSource(rand.Reader).
 			WithSysNanosleep().
 			WithSysWalltime().
-			WithSysNanosleep()))
+			WithSysNanosleep()),
+		handler.GuestConfig(wasmConfig))
 	if err != nil {
 		return nil, err
 	}

middleware/http/wasm/internal/e2e-guests/config/main.go

@@ -0,0 +1,12 @@
+// Package main ensures tests can prove logging or stdio isn't missed, both
+// during initialization (main) and request (rewrite).
+package main
+
+import (
+	"github.com/http-wasm/http-wasm-guest-tinygo/handler"
+	"github.com/http-wasm/http-wasm-guest-tinygo/handler/api"
+)
+
+func main() {
+	handler.Host.Log(api.LogLevelInfo, string(handler.Host.GetConfig()))
+}

middleware/http/wasm/internal/e2e_test.go

@@ -24,11 +24,12 @@ var guestWasm map[string][]byte
 const (
 	guestWasmOutput  = "output"
 	guestWasmRewrite = "rewrite"
+	guestWasmConfig  = "config"
 )
 
 // TestMain ensures we can read the test wasm prior to running e2e tests.
 func TestMain(m *testing.M) {
-	wasms := []string{guestWasmOutput, guestWasmRewrite}
+	wasms := []string{guestWasmOutput, guestWasmRewrite, guestWasmConfig}
 	guestWasm = make(map[string][]byte, len(wasms))
 	for _, name := range wasms {
 		if wasm, err := os.ReadFile(path.Join("e2e-guests", name, "main.wasm")); err != nil {
@@ -47,9 +48,10 @@ func Test_EndToEnd(t *testing.T) {
 	l.SetOutput(&buf)
 
 	type testCase struct {
-		name  string
-		guest []byte
-		test  func(t *testing.T, handler http.Handler, log *bytes.Buffer)
+		name     string
+		guest    []byte
+		property map[string]string
+		test     func(t *testing.T, handler http.Handler, log *bytes.Buffer)
 	}
 
 	tests := []testCase{
@@ -126,6 +128,14 @@ func Test_EndToEnd(t *testing.T) {
 				require.Equal(t, "/v1.0/hello?name=teddy", r.URL.RequestURI())
 			},
 		},
+		{
+			name:     "consoleLog config",
+			guest:    guestWasm[guestWasmConfig],
+			property: map[string]string{"config": "config bytes in any format"},
+			test: func(t *testing.T, handler http.Handler, log *bytes.Buffer) {
+				require.Contains(t, log.String(), "config bytes in any format")
+			},
+		},
 	}
 
 	for _, tt := range tests {
@@ -137,6 +147,11 @@ func Test_EndToEnd(t *testing.T) {
 			require.NoError(t, os.WriteFile(wasmPath, tc.guest, 0o600))
 
 			meta := metadata.Base{Properties: map[string]string{"url": "file://" + wasmPath}}
+			if len(tc.property) > 0 {
+				for k, v := range tc.property {
+					meta.Properties[k] = v
+				}
+			}
 			handlerFn, err := wasm.NewMiddleware(l).GetHandler(context.Background(), middleware.Metadata{Base: meta})
 			require.NoError(t, err)
 			handler := handlerFn(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))