wip

Signed-off-by: mathetake <[email protected]>

Author: mathetake

examples/http_auth_random/main.go

@@ -48,7 +48,7 @@ func (ctx *httpAuthRandom) OnHttpRequestHeaders(int, bool) types.Action {
 		proxywasm.LogInfof("request header: %s: %s", h[0], h[1])
 	}
 
-	if err := proxywasm.DispatchHttpCall(clusterName, hs, "", [][2]string{},
+	if _, err := proxywasm.DispatchHttpCall(clusterName, hs, "", [][2]string{},
 		50000, httpCallResponseCallback); err != nil {
 		proxywasm.LogCriticalf("dipatch httpcall failed: %v", err)
 		return types.ActionContinue
@@ -96,9 +96,3 @@ func httpCallResponseCallback(_ int, bodySize int, _ int) {
 		{"powered-by", "proxy-wasm-go-sdk!!"},
 	}, msg)
 }
-
-// override default
-func (ctx *httpAuthRandom) OnVMDone() bool {
-	proxywasm.LogInfof("%d finished", ctx.contextID)
-	return true
-}

examples/http_auth_random/main_test.go

@@ -11,14 +11,18 @@ import (
 )
 
 func TestHttpAuthRandom_OnHttpRequestHeaders(t *testing.T) {
-	host, done := proxytest.NewHttpFilterHost(newContext)
-	defer done()
+	host := proxytest.NewHostEmulator(nil, nil, nil, nil, newContext)
+	defer host.Done()
 
-	id := host.InitContext()
-	host.PutRequestHeaders(id, [][2]string{{"key", "value"}}) // OnHttpRequestHeaders called
+	contextID := host.HttpFilterInitContext()
+	host.HttpFilterPutRequestHeaders(contextID, [][2]string{{"key", "value"}}) // OnHttpRequestHeaders called
 
-	require.True(t, host.IsDispatchCalled(id))                     // check if http call is dispatched
-	require.Equal(t, types.ActionPause, host.GetCurrentAction(id)) // check if the current action is pause
+	attrs := host.GetCalloutAttributesFromContext(contextID)
+	require.Equal(t, len(attrs), 1) // verify DispatchHttpCall is called
+
+	require.Equal(t, "httpbin", attrs[0].Upstream)
+	require.Equal(t, types.ActionPause,
+		host.HttpFilterGetCurrentStreamAction(contextID)) // check if the current action is pause
 
 	logs := host.GetLogs(types.LogLevelInfo)
 	require.GreaterOrEqual(t, len(logs), 2)
@@ -28,8 +32,8 @@ func TestHttpAuthRandom_OnHttpRequestHeaders(t *testing.T) {
 }
 
 func TestHttpAuthRandom_OnHttpCallResponse(t *testing.T) {
-	host, done := proxytest.NewHttpFilterHost(newContext)
-	defer done()
+	host := proxytest.NewHostEmulator(nil, nil, nil, nil, newContext)
+	defer host.Done()
 
 	// http://httpbin.org/uuid
 	headers := [][2]string{
@@ -40,20 +44,30 @@ func TestHttpAuthRandom_OnHttpCallResponse(t *testing.T) {
 	}
 
 	// access granted body
-	id := host.InitContext()
+	contextID := host.HttpFilterInitContext()
+	host.HttpFilterPutRequestHeaders(contextID, nil) // OnHttpRequestHeaders called
+
 	body := []byte(`{"uuid": "7b10a67a-1c67-4199-835b-cbefcd4a63d4"}`)
-	host.PutCalloutResponse(id, headers, nil, body)
-	assert.Nil(t, host.GetSentLocalResponse(id))
+	attrs := host.GetCalloutAttributesFromContext(contextID)
+	require.Equal(t, len(attrs), 1) // verify DispatchHttpCall is called
+
+	host.PutCalloutResponse(attrs[0].CalloutID, headers, nil, body)
+	assert.Nil(t, host.HttpFilterGetSentLocalResponse(contextID))
 
 	logs := host.GetLogs(types.LogLevelInfo)
 	require.Greater(t, len(logs), 1)
 	assert.Equal(t, "access granted", logs[len(logs)-1])
 
 	// access denied body
-	id = host.InitContext()
+	contextID = host.HttpFilterInitContext()
+	host.HttpFilterPutRequestHeaders(contextID, nil) // OnHttpRequestHeaders called
+
 	body = []byte(`{"uuid": "aaaaaaaa-1c67-4199-835b-cbefcd4a63d4"}`)
-	host.PutCalloutResponse(id, headers, nil, body)
-	localResponse := host.GetSentLocalResponse(id) // check local responses
+	attrs = host.GetCalloutAttributesFromContext(contextID)
+	require.Equal(t, len(attrs), 1) // verify DispatchHttpCall is called
+
+	host.PutCalloutResponse(attrs[0].CalloutID, headers, nil, body)
+	localResponse := host.HttpFilterGetSentLocalResponse(contextID) // check local responses
 	assert.NotNil(t, localResponse)
 	logs = host.GetLogs(types.LogLevelInfo)
 	assert.Equal(t, "access forbidden", logs[len(logs)-1])

examples/http_headers/main_test.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -11,31 +12,36 @@ import (
 )
 
 func TestHttpHeaders_OnHttpRequestHeaders(t *testing.T) {
-	host, done := proxytest.NewHttpFilterHost(newContext)
-	defer done()
-	id := host.InitContext()
+	host := proxytest.NewHostEmulator(nil, nil, nil, nil, newContext)
+	defer host.Done()
+	id := host.HttpFilterInitContext()
 
 	hs := [][2]string{{"key1", "value1"}, {"key2", "value2"}}
-	host.PutRequestHeaders(id, hs) // call OnHttpRequestHeaders
+	host.HttpFilterPutRequestHeaders(id, hs) // call OnHttpRequestHeaders
+
+	host.HttpFilterCompleteHttpStream(id)
 
 	logs := host.GetLogs(types.LogLevelInfo)
 	require.Greater(t, len(logs), 1)
 
-	assert.Equal(t, "request header --> key2: value2", logs[len(logs)-1])
-	assert.Equal(t, "request header --> key1: value1", logs[len(logs)-2])
+	assert.Equal(t, fmt.Sprintf("%d finished", id), logs[len(logs)-1])
+	assert.Equal(t, "request header --> key2: value2", logs[len(logs)-2])
+	assert.Equal(t, "request header --> key1: value1", logs[len(logs)-3])
 }
 
 func TestHttpHeaders_OnHttpResponseHeaders(t *testing.T) {
-	host, done := proxytest.NewHttpFilterHost(newContext)
-	defer done()
-	id := host.InitContext()
+	host := proxytest.NewHostEmulator(nil, nil, nil, nil, newContext)
+	defer host.Done()
+	id := host.HttpFilterInitContext()
 
 	hs := [][2]string{{"key1", "value1"}, {"key2", "value2"}}
-	host.PutResponseHeaders(id, hs) // call OnHttpResponseHeaders
+	host.HttpFilterPutResponseHeaders(id, hs) // call OnHttpRequestHeaders
+	host.HttpFilterCompleteHttpStream(id)     // call OnHttpStreamDone
 
 	logs := host.GetLogs(types.LogLevelInfo)
 	require.Greater(t, len(logs), 1)
 
-	assert.Equal(t, "response header <-- key2: value2", logs[len(logs)-1])
-	assert.Equal(t, "response header <-- key1: value1", logs[len(logs)-2])
+	assert.Equal(t, fmt.Sprintf("%d finished", id), logs[len(logs)-1])
+	assert.Equal(t, "response header <-- key2: value2", logs[len(logs)-2])
+	assert.Equal(t, "response header <-- key1: value1", logs[len(logs)-3])
 }

examples/metrics/main.go

@@ -20,22 +20,25 @@ import (
 )
 
 func main() {
-	proxywasm.SetNewRootContext(func(uint32) proxywasm.RootContext { return &metric{} })
-	proxywasm.SetNewHttpContext(func(uint32) proxywasm.HttpContext { return &metric{} })
+	proxywasm.SetNewRootContext(newRootContext)
+	proxywasm.SetNewHttpContext(newHttpContext)
 }
 
 var counter proxywasm.MetricCounter
 
 const metricsName = "proxy_wasm_go.request_counter"
 
-type metric struct {
+type metricRootContext struct {
 	// you must embed the default context so that you need not to reimplement all the methods by yourself
 	proxywasm.DefaultRootContext
-	proxywasm.DefaultHttpContext
+}
+
+func newRootContext(uint32) proxywasm.RootContext {
+	return &metricRootContext{}
 }
 
 // override
-func (ctx *metric) OnVMStart(int) bool {
+func (ctx *metricRootContext) OnVMStart(int) bool {
 	ct, err := proxywasm.DefineCounterMetric(metricsName)
 	if err != nil {
 		proxywasm.LogCriticalf("error defining metrics: %v", err)
@@ -44,8 +47,17 @@ func (ctx *metric) OnVMStart(int) bool {
 	return true
 }
 
+type metricHttpContext struct {
+	// you must embed the default context so that you need not to reimplement all the methods by yourself
+	proxywasm.DefaultHttpContext
+}
+
+func newHttpContext(uint32) proxywasm.HttpContext {
+	return &metricHttpContext{}
+}
+
 // override
-func (ctx *metric) OnHttpRequestHeaders(int, bool) types.Action {
+func (ctx *metricHttpContext) OnHttpRequestHeaders(int, bool) types.Action {
 	prev, err := counter.Get()
 	if err != nil {
 		proxywasm.LogCriticalf("error retrieving previous metric: %v", err)

examples/metrics/main_test.go

@@ -11,16 +11,17 @@ import (
 )
 
 func TestMetric(t *testing.T) {
+	host := proxytest.NewHostEmulator(nil, nil,
+		newRootContext, nil, newHttpContext,
+	)
+	defer host.Done() // release the host emulation lock so that other test cases can insert their own host emulation
 
-	ctx := metric{}
-	host, done := proxytest.NewRootContextHostEmulator(ctx, nil, nil)
-	defer done() // release the host emulation lock so that other test cases can insert their own host emulation
-
-	host.StartVM() // define metric
+	host.StartVM() // call OnVMStart: define metric
 
+	contextID := host.HttpFilterInitContext()
 	exp := uint64(3)
 	for i := uint64(0); i < exp; i++ {
-		ctx.OnHttpRequestHeaders(0, false) // increment
+		host.HttpFilterPutRequestHeaders(contextID, nil)
 	}
 
 	logs := host.GetLogs(types.LogLevelInfo)

examples/network/main.go

@@ -25,17 +25,20 @@ var (
 )
 
 func main() {
-	proxywasm.SetNewStreamContext(func(contextID uint32) proxywasm.StreamContext { return &context{} })
-	proxywasm.SetNewRootContext(func(contextID uint32) proxywasm.RootContext { return &context{} })
+	proxywasm.SetNewRootContext(newRootContext)
+	proxywasm.SetNewStreamContext(newNetworkContext)
 }
 
-type context struct {
+type rootContext struct {
 	// you must embed the default context so that you need not to reimplement all the methods by yourself
 	proxywasm.DefaultRootContext
-	proxywasm.DefaultStreamContext
 }
 
-func (ctx *context) OnVMStart(int) bool {
+func newRootContext(uint32) proxywasm.RootContext {
+	return &rootContext{}
+}
+
+func (ctx *rootContext) OnVMStart(int) bool {
 	var err error
 	counter, err = proxywasm.DefineCounterMetric(connectionCounterName)
 	if err != nil {
@@ -44,12 +47,21 @@ func (ctx *context) OnVMStart(int) bool {
 	return true
 }
 
-func (ctx *context) OnNewConnection() types.Action {
+type networkContext struct {
+	// you must embed the default context so that you need not to reimplement all the methods by yourself
+	proxywasm.DefaultStreamContext
+}
+
+func newNetworkContext(uint32) proxywasm.StreamContext {
+	return &networkContext{}
+}
+
+func (ctx *networkContext) OnNewConnection() types.Action {
 	proxywasm.LogInfo("new connection!")
 	return types.ActionContinue
 }
 
-func (ctx *context) OnDownstreamData(dataSize int, _ bool) types.Action {
+func (ctx *networkContext) OnDownstreamData(dataSize int, _ bool) types.Action {
 	if dataSize == 0 {
 		return types.ActionContinue
 	}
@@ -63,12 +75,12 @@ func (ctx *context) OnDownstreamData(dataSize int, _ bool) types.Action {
 	return types.ActionContinue
 }
 
-func (ctx *context) OnDownstreamClose(types.PeerType) {
+func (ctx *networkContext) OnDownstreamClose(types.PeerType) {
 	proxywasm.LogInfo("downstream connection close!")
 	return
 }
 
-func (ctx *context) OnUpstreamData(dataSize int, _ bool) types.Action {
+func (ctx *networkContext) OnUpstreamData(dataSize int, _ bool) types.Action {
 	if dataSize == 0 {
 		return types.ActionContinue
 	}
@@ -89,7 +101,7 @@ func (ctx *context) OnUpstreamData(dataSize int, _ bool) types.Action {
 	return types.ActionContinue
 }
 
-func (ctx *context) OnStreamDone() {
+func (ctx *networkContext) OnStreamDone() {
 	err := counter.Increment(1)
 	if err != nil {
 		proxywasm.LogCriticalf("failed to increment connection counter: %v", err)

examples/network/main_test.go

@@ -21,72 +21,74 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/tetratelabs/proxy-wasm-go-sdk/proxytest"
-	"github.com/tetratelabs/proxy-wasm-go-sdk/proxywasm"
 	"github.com/tetratelabs/proxy-wasm-go-sdk/proxywasm/types"
 )
 
-func newStreamContext(uint32) proxywasm.StreamContext {
-	return &context{}
-}
-
 func TestNetwork_OnNewConnection(t *testing.T) {
-	host, done := proxytest.NewNetworkFilterHost(newStreamContext)
-	defer done() // release the host emulation lock so that other test cases can insert their own host emulation
+	host := proxytest.NewHostEmulator(nil, nil,
+		newRootContext, newNetworkContext, nil)
+	defer host.Done() // release the host emulation lock so that other test cases can insert their own host emulation
+
+	host.StartVM() // call OnVMStart: init metric
 
-	_ = host.InitConnection() // OnNewConnection is called
+	_ = host.NetworkFilterInitConnection() // OnNewConnection is called
 
 	logs := host.GetLogs(types.LogLevelInfo) // retrieve logs emitted to Envoy
 	assert.Equal(t, logs[0], "new connection!")
 }
 
 func TestNetwork_OnDownstreamClose(t *testing.T) {
-	host, done := proxytest.NewNetworkFilterHost(newStreamContext)
-	defer done() // release the host emulation lock so that other test cases can insert their own host emulation
+	host := proxytest.NewHostEmulator(nil, nil,
+		newRootContext, newNetworkContext, nil)
+	defer host.Done() // release the host emulation lock so that other test cases can insert their own host emulation
 
-	contextID := host.InitConnection()        // OnNewConnection is called
-	host.CloseDownstreamConnection(contextID) // OnDownstreamClose is called
+	contextID := host.NetworkFilterInitConnection()        // OnNewConnection is called
+	host.NetworkFilterCloseDownstreamConnection(contextID) // OnDownstreamClose is called
 
 	logs := host.GetLogs(types.LogLevelInfo) // retrieve logs emitted to Envoy
 	require.Len(t, logs, 2)
 	assert.Equal(t, logs[1], "downstream connection close!")
 }
 
 func TestNetwork_OnDownstreamData(t *testing.T) {
-	host, done := proxytest.NewNetworkFilterHost(newStreamContext)
-	defer done() // release the host emulation lock so that other test cases can insert their own host emulation
+	host := proxytest.NewHostEmulator(nil, nil,
+		newRootContext, newNetworkContext, nil)
+	defer host.Done() // release the host emulation lock so that other test cases can insert their own host emulation
 
-	contextID := host.InitConnection() // OnNewConnection is called
+	contextID := host.NetworkFilterInitConnection() // OnNewConnection is called
 
 	msg := "this is downstream data"
 	data := []byte(msg)
-	host.PutDownstreamData(contextID, data) // OnDownstreamData is called
+	host.NetworkFilterPutDownstreamData(contextID, data) // OnDownstreamData is called
 
 	logs := host.GetLogs(types.LogLevelInfo) // retrieve logs emitted to Envoy
 	assert.Equal(t, ">>>>>> downstream data received >>>>>>\n"+msg, logs[len(logs)-1])
 }
 
 func TestNetwork_OnUpstreamData(t *testing.T) {
-	host, done := proxytest.NewNetworkFilterHost(newStreamContext)
-	defer done() // release the host emulation lock so that other test cases can insert their own host emulation
+	host := proxytest.NewHostEmulator(nil, nil,
+		newRootContext, newNetworkContext, nil)
+	defer host.Done() // release the host emulation lock so that other test cases can insert their own host emulation
 
-	contextID := host.InitConnection() // OnNewConnection is called
+	contextID := host.NetworkFilterInitConnection() // OnNewConnection is called
 
 	msg := "this is upstream data"
 	data := []byte(msg)
-	host.PutUpstreamData(contextID, data) // OnUpstreamData is called
+	host.NetworkFilterPutUpstreamData(contextID, data) // OnUpstreamData is called
 
 	logs := host.GetLogs(types.LogLevelInfo) // retrieve logs emitted to Envoy
 	assert.Equal(t, "<<<<<< upstream data received <<<<<<\n"+msg, logs[len(logs)-1])
 }
 
 func TestNetwork_counter(t *testing.T) {
-	host, done := proxytest.NewNetworkFilterHost(newStreamContext)
-	defer done() // release the host emulation lock so that other test cases can insert their own host emulation
+	host := proxytest.NewHostEmulator(nil, nil,
+		newRootContext, newNetworkContext, nil)
+	defer host.Done() // release the host emulation lock so that other test cases can insert their own host emulation
 
-	context{}.OnVMStart(0) // init metric
+	host.StartVM() // call OnVMStart: init metric
 
-	contextID := host.InitConnection()
-	host.CompleteConnection(contextID) // call OnDone on contextID -> increment the connection counter
+	contextID := host.NetworkFilterInitConnection()
+	host.NetworkFilterCompleteConnection(contextID) // call OnStreamDone on contextID -> increment the connection counter
 
 	logs := host.GetLogs(types.LogLevelInfo)
 	require.Greater(t, len(logs), 0)