Implement echov4 and use new APIGatewayV2HTTPRequest and APIGatewayV2HTTPResponse structs

kurtmc · kurtmc · commit 66b6370d901b · 2020-05-24T15:05:43.000+12:00
diff --git a/core/request.go b/core/request.go
@@ -116,6 +116,15 @@ func (r *RequestAccessor) ProxyEventToHTTPRequest(req events.APIGatewayProxyRequ
 	return addToHeader(httpRequest, req)
 }
 
+func (r *RequestAccessor) ProxyEventToHTTPRequestV2(req events.APIGatewayV2HTTPRequest) (*http.Request, error) {
+	httpRequest, err := r.EventToRequestV2(req)
+	if err != nil {
+		log.Println(err)
+		return nil, err
+	}
+	return addToHeaderV2(httpRequest, req)
+}
+
 // EventToRequestWithContext converts an API Gateway proxy event and context into an http.Request object.
 // Returns the populated http request with lambda context, stage variables and APIGatewayProxyRequestContext as part of its context.
 // Access those using GetAPIGatewayContextFromContext, GetStageVarsFromContext and GetRuntimeContextFromContext functions in this package.
@@ -128,6 +137,15 @@ func (r *RequestAccessor) EventToRequestWithContext(ctx context.Context, req eve
 	return addToContext(ctx, httpRequest, req), nil
 }
 
+func (r *RequestAccessor) EventToRequestWithContextV2(ctx context.Context, req events.APIGatewayV2HTTPRequest) (*http.Request, error) {
+	httpRequest, err := r.EventToRequestV2(req)
+	if err != nil {
+		log.Println(err)
+		return nil, err
+	}
+	return addToContextV2(ctx, httpRequest, req), nil
+}
+
 // EventToRequest converts an API Gateway proxy event into an http.Request object.
 // Returns the populated request maintaining headers
 func (r *RequestAccessor) EventToRequest(req events.APIGatewayProxyRequest) (*http.Request, error) {
@@ -196,6 +214,73 @@ func (r *RequestAccessor) EventToRequest(req events.APIGatewayProxyRequest) (*ht
 	return httpRequest, nil
 }
 
+func (r *RequestAccessor) EventToRequestV2(req events.APIGatewayV2HTTPRequest) (*http.Request, error) {
+	decodedBody := []byte(req.Body)
+	if req.IsBase64Encoded {
+		base64Body, err := base64.StdEncoding.DecodeString(req.Body)
+		if err != nil {
+			return nil, err
+		}
+		decodedBody = base64Body
+	}
+
+	path := req.RequestContext.HTTP.Path
+	if r.stripBasePath != "" && len(r.stripBasePath) > 1 {
+		if strings.HasPrefix(path, r.stripBasePath) {
+			path = strings.Replace(path, r.stripBasePath, "", 1)
+		}
+	}
+	if !strings.HasPrefix(path, "/") {
+		path = "/" + path
+	}
+	serverAddress := DefaultServerAddress
+	if customAddress, ok := os.LookupEnv(CustomHostVariable); ok {
+		serverAddress = customAddress
+	}
+	path = serverAddress + path
+
+	if len(req.QueryStringParameters) > 0 {
+		queryString := ""
+		for q, l := range req.QueryStringParameters {
+			values := strings.Split(l, ",")
+			for _, v := range values {
+				if queryString != "" {
+					queryString += "&"
+				}
+				queryString += url.QueryEscape(q) + "=" + url.QueryEscape(v)
+			}
+		}
+		path += "?" + queryString
+	} else if len(req.QueryStringParameters) > 0 {
+		// Support `QueryStringParameters` for backward compatibility.
+		// https://github.com/awslabs/aws-lambda-go-api-proxy/issues/37
+		queryString := ""
+		for q := range req.QueryStringParameters {
+			if queryString != "" {
+				queryString += "&"
+			}
+			queryString += url.QueryEscape(q) + "=" + url.QueryEscape(req.QueryStringParameters[q])
+		}
+		path += "?" + queryString
+	}
+
+	httpRequest, err := http.NewRequest(
+		strings.ToUpper(req.RequestContext.HTTP.Method),
+		path,
+		bytes.NewReader(decodedBody),
+	)
+
+	if err != nil {
+		fmt.Printf("Could not convert request %s:%s to http.Request\n", req.RequestContext.HTTP.Method, req.RequestContext.HTTP.Path)
+		log.Println(err)
+		return nil, err
+	}
+	for h := range req.Headers {
+		httpRequest.Header.Add(h, req.Headers[h])
+	}
+	return httpRequest, nil
+}
+
 func addToHeader(req *http.Request, apiGwRequest events.APIGatewayProxyRequest) (*http.Request, error) {
 	stageVars, err := json.Marshal(apiGwRequest.StageVariables)
 	if err != nil {
@@ -212,13 +297,36 @@ func addToHeader(req *http.Request, apiGwRequest events.APIGatewayProxyRequest)
 	return req, nil
 }
 
+func addToHeaderV2(req *http.Request, apiGwRequest events.APIGatewayV2HTTPRequest) (*http.Request, error) {
+	stageVars, err := json.Marshal(apiGwRequest.StageVariables)
+	if err != nil {
+		log.Println("Could not marshal stage variables for custom header")
+		return nil, err
+	}
+	req.Header.Add(APIGwStageVarsHeader, string(stageVars))
+	apiGwContext, err := json.Marshal(apiGwRequest.RequestContext)
+	if err != nil {
+		log.Println("Could not Marshal API GW context for custom header")
+		return req, err
+	}
+	req.Header.Add(APIGwContextHeader, string(apiGwContext))
+	return req, nil
+}
+
 func addToContext(ctx context.Context, req *http.Request, apiGwRequest events.APIGatewayProxyRequest) *http.Request {
 	lc, _ := lambdacontext.FromContext(ctx)
 	rc := requestContext{lambdaContext: lc, gatewayProxyContext: apiGwRequest.RequestContext, stageVars: apiGwRequest.StageVariables}
 	ctx = context.WithValue(ctx, ctxKey{}, rc)
 	return req.WithContext(ctx)
 }
 
+func addToContextV2(ctx context.Context, req *http.Request, apiGwRequest events.APIGatewayV2HTTPRequest) *http.Request {
+	lc, _ := lambdacontext.FromContext(ctx)
+	rc := requestContextV2{lambdaContext: lc, gatewayProxyContext: apiGwRequest.RequestContext, stageVars: apiGwRequest.StageVariables}
+	ctx = context.WithValue(ctx, ctxKey{}, rc)
+	return req.WithContext(ctx)
+}
+
 // GetAPIGatewayContextFromContext retrieve APIGatewayProxyRequestContext from context.Context
 func GetAPIGatewayContextFromContext(ctx context.Context) (events.APIGatewayProxyRequestContext, bool) {
 	v, ok := ctx.Value(ctxKey{}).(requestContext)
@@ -244,3 +352,9 @@ type requestContext struct {
 	gatewayProxyContext events.APIGatewayProxyRequestContext
 	stageVars           map[string]string
 }
+
+type requestContextV2 struct {
+	lambdaContext       *lambdacontext.LambdaContext
+	gatewayProxyContext events.APIGatewayV2HTTPRequestContext
+	stageVars           map[string]string
+}
diff --git a/core/response.go b/core/response.go
@@ -18,19 +18,19 @@ const contentTypeHeaderKey = "Content-Type"
 // ProxyResponseWriter implements http.ResponseWriter and adds the method
 // necessary to return an events.APIGatewayProxyResponse object
 type ProxyResponseWriter struct {
-	headers http.Header
-	body    bytes.Buffer
-	status  int
-	observers []chan <-bool
+	headers   http.Header
+	body      bytes.Buffer
+	status    int
+	observers []chan<- bool
 }
 
 // NewProxyResponseWriter returns a new ProxyResponseWriter object.
 // The object is initialized with an empty map of headers and a
 // status code of -1
 func NewProxyResponseWriter() *ProxyResponseWriter {
 	return &ProxyResponseWriter{
-		headers: make(http.Header),
-		status:  defaultStatusCode,
+		headers:   make(http.Header),
+		status:    defaultStatusCode,
 		observers: make([]chan<- bool, 0),
 	}
 
@@ -111,7 +111,41 @@ func (r *ProxyResponseWriter) GetProxyResponse() (events.APIGatewayProxyResponse
 
 	return events.APIGatewayProxyResponse{
 		StatusCode:        r.status,
-		Headers:         proxyHeaders,
+		Headers:           proxyHeaders,
+		MultiValueHeaders: http.Header(r.headers),
+		Body:              output,
+		IsBase64Encoded:   isBase64,
+	}, nil
+}
+
+func (r *ProxyResponseWriter) GetProxyResponseV2() (events.APIGatewayV2HTTPResponse, error) {
+	r.notifyClosed()
+
+	if r.status == defaultStatusCode {
+		return events.APIGatewayV2HTTPResponse{}, errors.New("Status code not set on response")
+	}
+
+	var output string
+	isBase64 := false
+
+	bb := (&r.body).Bytes()
+
+	if utf8.Valid(bb) {
+		output = string(bb)
+	} else {
+		output = base64.StdEncoding.EncodeToString(bb)
+		isBase64 = true
+	}
+
+	proxyHeaders := make(map[string]string)
+
+	for h := range r.headers {
+		proxyHeaders[h] = r.headers.Get(h)
+	}
+
+	return events.APIGatewayV2HTTPResponse{
+		StatusCode:        r.status,
+		Headers:           proxyHeaders,
 		MultiValueHeaders: http.Header(r.headers),
 		Body:              output,
 		IsBase64Encoded:   isBase64,
diff --git a/core/types.go b/core/types.go
@@ -12,6 +12,10 @@ func GatewayTimeout() events.APIGatewayProxyResponse {
 	return events.APIGatewayProxyResponse{StatusCode: http.StatusGatewayTimeout}
 }
 
+func GatewayTimeoutV2() events.APIGatewayV2HTTPResponse {
+	return events.APIGatewayV2HTTPResponse{StatusCode: http.StatusGatewayTimeout}
+}
+
 // NewLoggedError generates a new error and logs it to stdout
 func NewLoggedError(format string, a ...interface{}) error {
 	err := fmt.Errorf(format, a...)
diff --git a/echov4/adapter.go b/echov4/adapter.go
@@ -0,0 +1,89 @@
+// Packge echolambda add Echo support for the aws-severless-go-api library.
+// Uses the core package behind the scenes and exposes the New method to
+// get a new instance and Proxy method to send request to the echo.Echo
+package echov4adapter
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/aws/aws-lambda-go/events"
+	"github.com/awslabs/aws-lambda-go-api-proxy/core"
+	"github.com/labstack/echo/v4"
+)
+
+// EchoLambda makes it easy to send API Gateway proxy events to a echo.Echo.
+// The library transforms the proxy event into an HTTP request and then
+// creates a proxy response object from the http.ResponseWriter
+type EchoLambda struct {
+	core.RequestAccessor
+
+	Echo *echo.Echo
+}
+
+// New creates a new instance of the EchoLambda object.
+// Receives an initialized *echo.Echo object - normally created with echo.New().
+// It returns the initialized instance of the EchoLambda object.
+func New(e *echo.Echo) *EchoLambda {
+	return &EchoLambda{Echo: e}
+}
+
+// Proxy receives an API Gateway proxy event, transforms it into an http.Request
+// object, and sends it to the echo.Echo for routing.
+// It returns a proxy response object generated from the http.ResponseWriter.
+func (e *EchoLambda) Proxy(req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
+	echoRequest, err := e.ProxyEventToHTTPRequest(req)
+	return e.proxyInternal(echoRequest, err)
+}
+
+func (e *EchoLambda) ProxyV2(req events.APIGatewayV2HTTPRequest) (events.APIGatewayV2HTTPResponse, error) {
+	echoRequest, err := e.ProxyEventToHTTPRequestV2(req)
+	return e.proxyInternalV2(echoRequest, err)
+}
+
+// ProxyWithContext receives context and an API Gateway proxy event,
+// transforms them into an http.Request object, and sends it to the echo.Echo for routing.
+// It returns a proxy response object generated from the http.ResponseWriter.
+func (e *EchoLambda) ProxyWithContext(ctx context.Context, req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
+	echoRequest, err := e.EventToRequestWithContext(ctx, req)
+	return e.proxyInternal(echoRequest, err)
+}
+
+func (e *EchoLambda) ProxyWithContextV2(ctx context.Context, req events.APIGatewayV2HTTPRequest) (events.APIGatewayV2HTTPResponse, error) {
+	echoRequest, err := e.EventToRequestWithContextV2(ctx, req)
+	return e.proxyInternalV2(echoRequest, err)
+}
+
+func (e *EchoLambda) proxyInternal(req *http.Request, err error) (events.APIGatewayProxyResponse, error) {
+
+	if err != nil {
+		return core.GatewayTimeout(), core.NewLoggedError("Could not convert proxy event to request: %v", err)
+	}
+
+	respWriter := core.NewProxyResponseWriter()
+	e.Echo.ServeHTTP(http.ResponseWriter(respWriter), req)
+
+	proxyResponse, err := respWriter.GetProxyResponse()
+	if err != nil {
+		return core.GatewayTimeout(), core.NewLoggedError("Error while generating proxy response: %v", err)
+	}
+
+	return proxyResponse, nil
+}
+
+func (e *EchoLambda) proxyInternalV2(req *http.Request, err error) (events.APIGatewayV2HTTPResponse, error) {
+
+	if err != nil {
+		return core.GatewayTimeoutV2(), core.NewLoggedError("Could not convert proxy event to request: %v", err)
+	}
+
+	respWriter := core.NewProxyResponseWriter()
+	e.Echo.ServeHTTP(http.ResponseWriter(respWriter), req)
+
+	proxyResponse, err := respWriter.GetProxyResponseV2()
+	if err != nil {
+		return core.GatewayTimeoutV2(), core.NewLoggedError("Error while generating proxy response: %v", err)
+	}
+
+	return proxyResponse, nil
+}
diff --git a/echov4/echo_suite_test.go b/echov4/echo_suite_test.go
@@ -0,0 +1,13 @@
+package echov4adapter_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestEcho(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Echo Suite")
+}
diff --git a/echov4/echolambda_test.go b/echov4/echolambda_test.go
@@ -0,0 +1,37 @@
+package echov4adapter_test
+
+import (
+	"log"
+
+	"github.com/aws/aws-lambda-go/events"
+	"github.com/labstack/echo/v4"
+	"github.com/awslabs/aws-lambda-go-api-proxy/echov4"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("EchoLambda tests", func() {
+	Context("Simple ping request", func() {
+		It("Proxies the event correctly", func() {
+			log.Println("Starting test")
+			e := echo.New()
+			e.GET("/ping", func(c echo.Context) error {
+				log.Println("Handler!!")
+				return c.String(200, "pong")
+			})
+
+			adapter := echov4adapter.New(e)
+
+			req := events.APIGatewayProxyRequest{
+				Path:       "/ping",
+				HTTPMethod: "GET",
+			}
+
+			resp, err := adapter.Proxy(req)
+
+			Expect(err).To(BeNil())
+			Expect(resp.StatusCode).To(Equal(200))
+		})
+	})
+})
diff --git a/go.mod b/go.mod
diff --git a/go.sum b/go.sum
