Update funky to use read context as a generic map (#4)

Serializing the context to a predefined go struct causes any property not in the struct to be ignored. This change serializes the context into a generic map so that any new fields will be passed to the language server.

Author: tenczar

main.go

@@ -28,7 +28,7 @@ type funkyHandler struct {
 }
 
 func (f funkyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	var body funky.Message
+	var body funky.Request
 	err := json.NewDecoder(r.Body).Decode(&body)
 	if err != nil {
 		resp := funky.Message{

pkg/funky/mocks/server.go

@@ -9,6 +9,12 @@ const (
 	SystemError   = "SystemError"
 )
 
+// Request a struct to hold the request body sent to a Dispatch function
+type Request struct {
+	Context map[string]interface{} `json:"context"`
+	Payload interface{}            `json:"payload"`
+}
+
 // Message a struct to hold the response to a Dispatch function invocation
 type Message struct {
 	Context *Context    `json:"context"`

pkg/funky/mocks/server_factory.go

@@ -21,7 +21,7 @@ var Healthy = make(chan struct{})
 
 // Router an interface for delegating function invocations to idle servers
 type Router interface {
-	Delegate(input *Message) (*Message, error)
+	Delegate(input *Request) (*Message, error)
 	Shutdown() error
 }
 
@@ -53,7 +53,7 @@ func NewRouter(numServers int, serverFactory ServerFactory) (*DefaultRouter, err
 }
 
 // Delegate delegates function invocation to an idle server
-func (r *DefaultRouter) Delegate(input *Message) (*Message, error) {
+func (r *DefaultRouter) Delegate(input *Request) (*Message, error) {
 	server, err := r.findFreeServer()
 	if err != nil {
 		return nil, err

pkg/funky/response.go

@@ -21,7 +21,7 @@ import (
 // Server an interface for managing function servers
 type Server interface {
 	GetPort() uint16
-	Invoke(input *Message) (interface{}, error)
+	Invoke(input *Request) (interface{}, error)
 	Stdout() []string
 	Stderr() []string
 	Start() error
@@ -92,12 +92,18 @@ func (s *DefaultServer) GetPort() uint16 {
 }
 
 // Invoke calls the server with the given input to invoke a Dispatch function
-func (s *DefaultServer) Invoke(input *Message) (interface{}, error) {
+func (s *DefaultServer) Invoke(input *Request) (interface{}, error) {
 	p, err := json.Marshal(input)
 
 	timeout := time.Duration(0)
-	if input.Context.Deadline != nil {
-		timeout = time.Until(*input.Context.Deadline)
+	if deadline, ok := input.Context["deadline"]; ok {
+		if dl, ok := deadline.(string); ok {
+			t, err := time.Parse(time.RFC3339, dl)
+			if err != nil {
+				return nil, BadRequestError(fmt.Sprintf("Unable to parse deadline: %s", err))
+			}
+			timeout = time.Until(t)
+		}
 	}
 
 	if timeout < 0 {

pkg/funky/router.go

@@ -72,7 +72,7 @@ func TestDelegateSuccess(t *testing.T) {
 	server.On("Start").Return(nil)
 	server.On("IsIdle").Return(true)
 	server.On("SetIdle", mock.AnythingOfType("bool")).Return().Return()
-	server.On("Invoke", &funky.Message{}).Return(nil, nil)
+	server.On("Invoke", &funky.Request{}).Return(nil, nil)
 	server.On("Stdout").Return([]string{})
 	server.On("Stderr").Return([]string{})
 
@@ -81,7 +81,7 @@ func TestDelegateSuccess(t *testing.T) {
 
 	router, _ := funky.NewRouter(1, serverFactory)
 
-	_, err := router.Delegate(&funky.Message{})
+	_, err := router.Delegate(&funky.Request{})
 
 	if err != nil {
 		t.Error("Received unexpected error calling Delegate")

pkg/funky/server.go

@@ -57,8 +57,8 @@ func TestInvokeSuccess(t *testing.T) {
 		t.Fatalf("Failed to create new server: %+v", err)
 	}
 
-	req := funky.Message{
-		Context: &funky.Context{},
+	req := funky.Request{
+		Context: map[string]interface{}{},
 	}
 
 	resp, err := server.Invoke(&req)
@@ -82,9 +82,8 @@ func TestInvokeBadRequest(t *testing.T) {
 		resp := map[string]string{
 			"myField": "Hello, Jon from Winterfell",
 		}
-		respBytes, _ := json.Marshal(resp)
 		w.WriteHeader(400)
-		fmt.Fprint(w, string(respBytes))
+		json.NewEncoder(w).Encode(resp)
 	}))
 	defer ts.Close()
 
@@ -99,8 +98,8 @@ func TestInvokeBadRequest(t *testing.T) {
 		t.Fatalf("Failed to create new server: %+v", err)
 	}
 
-	req := funky.Message{
-		Context: &funky.Context{},
+	req := funky.Request{
+		Context: map[string]interface{}{},
 	}
 
 	_, err = server.Invoke(&req)
@@ -113,3 +112,62 @@ func TestInvokeBadRequest(t *testing.T) {
 		t.Errorf("Expected FunctionServerError got %s", err)
 	}
 }
+
+func TestInvokeContextPassthrough(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var req funky.Request
+		err := json.NewDecoder(r.Body).Decode(&req)
+		if err != nil {
+			t.Errorf("Failed parsing json payload: %s", err)
+		}
+
+		resp := map[string]interface{}{
+			"myField": "Hello, Jon from Winterfell",
+			"context": req.Context,
+		}
+
+		json.NewEncoder(w).Encode(resp)
+	}))
+	defer ts.Close()
+
+	urlParts := strings.Split(ts.URL, ":")
+	port, err := strconv.Atoi(urlParts[len(urlParts)-1])
+	if err != nil {
+		t.Fatalf("Could not convert port %s", urlParts[len(urlParts)-1])
+	}
+
+	server, err := funky.NewServer(uint16(port), exec.Command("echo"))
+	if err != nil {
+		t.Fatalf("Failed to create new server: %+v", err)
+	}
+
+	context := map[string]interface{}{
+		"unknown": "field",
+	}
+
+	req := funky.Request{
+		Context: context,
+	}
+
+	resp, err := server.Invoke(&req)
+
+	if err != nil {
+		t.Fatalf("Failed to invoke function. Expected success")
+	}
+
+	if result, ok := resp.(map[string]interface{}); ok {
+		if obj, ok := result["context"]; ok {
+			if ctx, ok := obj.(map[string]interface{}); ok {
+				if unknown, ok := ctx["unknown"]; !ok || unknown != "field" {
+					t.Errorf("Did not properly pass along context value. Received: %s", unknown)
+				}
+			} else {
+				t.Errorf("Expected context to be a map[string]interface")
+			}
+		} else {
+			t.Errorf("Expected context key not found")
+		}
+	} else {
+		t.Errorf("Result from invoke was not a map[string]interface{} like expected")
+	}
+}