Merge branch 'master' into f-add-support-for-function-url

# Conflicts:
#	go.mod
#	go.sum

Author: c3d4r

chi/adapter.go

@@ -1,4 +1,4 @@
-// Packge chilambda add Chi support for the aws-severless-go-api library.
+// Package chiadapter add Chi 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 Chi mux.
 package chiadapter

chi/adapterv2.go

@@ -0,0 +1,59 @@
+package chiadapter
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/aws/aws-lambda-go/events"
+	"github.com/awslabs/aws-lambda-go-api-proxy/core"
+	"github.com/go-chi/chi/v5"
+)
+
+// ChiLambdaV2 makes it easy to send API Gateway proxy V2 events to a Chi
+// Mux. The library transforms the proxy event into an HTTP request and then
+// creates a proxy response object from the http.ResponseWriter
+type ChiLambdaV2 struct {
+	core.RequestAccessorV2
+
+	chiMux *chi.Mux
+}
+
+// New creates a new instance of the ChiLambdaV2 object.
+// Receives an initialized *chi.Mux object - normally created with chi.NewRouter().
+// It returns the initialized instance of the ChiLambdaV2 object.
+func NewV2(chi *chi.Mux) *ChiLambdaV2 {
+	return &ChiLambdaV2{chiMux: chi}
+}
+
+// Proxy receives an API Gateway proxy V2 event, transforms it into an http.Request
+// object, and sends it to the chi.Mux for routing.
+// It returns a proxy response object generated from the http.ResponseWriter.
+func (g *ChiLambdaV2) Proxy(req events.APIGatewayV2HTTPRequest) (events.APIGatewayV2HTTPResponse, error) {
+	chiRequest, err := g.ProxyEventToHTTPRequest(req)
+	return g.proxyInternal(chiRequest, err)
+}
+
+// ProxyWithContext receives context and an API Gateway proxy V2 event,
+// transforms them into an http.Request object, and sends it to the chi.Mux for routing.
+// It returns a proxy response object generated from the http.ResponseWriter.
+func (g *ChiLambdaV2) ProxyWithContextV2(ctx context.Context, req events.APIGatewayV2HTTPRequest) (events.APIGatewayV2HTTPResponse, error) {
+	chiRequest, err := g.EventToRequestWithContext(ctx, req)
+	return g.proxyInternal(chiRequest, err)
+}
+
+func (g *ChiLambdaV2) proxyInternal(chiRequest *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.NewProxyResponseWriterV2()
+	g.chiMux.ServeHTTP(http.ResponseWriter(respWriter), chiRequest)
+
+	proxyResponse, err := respWriter.GetProxyResponse()
+	if err != nil {
+		return core.GatewayTimeoutV2(), core.NewLoggedError("Error while generating proxy response: %v", err)
+	}
+
+	return proxyResponse, nil
+}

chi/chilambda_test.go

@@ -41,3 +41,36 @@ var _ = Describe("ChiLambda tests", func() {
 		})
 	})
 })
+
+var _ = Describe("ChiLambdaV2 tests", func() {
+	Context("Simple ping request", func() {
+		It("Proxies the event correctly", func() {
+			log.Println("Starting test")
+
+			r := chi.NewRouter()
+			r.Get("/ping", func(w http.ResponseWriter, r *http.Request) {
+				w.Write([]byte("pong"))
+			})
+
+			adapter := chiadapter.NewV2(r)
+
+			req := events.APIGatewayV2HTTPRequest{
+				RequestContext: events.APIGatewayV2HTTPRequestContext{
+					HTTP: events.APIGatewayV2HTTPRequestContextHTTPDescription{
+						Method: "GET",
+						Path:   "/ping",
+					},
+				},
+			}
+
+			resp, err := adapter.ProxyWithContextV2(context.Background(), req)
+
+			Expect(err).To(BeNil())
+			Expect(resp.StatusCode).To(Equal(200))
+
+			resp, err = adapter.Proxy(req)
+			Expect(err).To(BeNil())
+			Expect(resp.StatusCode).To(Equal(200))
+		})
+	})
+})

core/requestv2.go

@@ -11,6 +11,7 @@ import (
 	"fmt"
 	"log"
 	"net/http"
+	"net/textproto"
 	"net/url"
 	"os"
 	"strings"
@@ -170,7 +171,13 @@ func (r *RequestAccessorV2) EventToRequest(req events.APIGatewayV2HTTPRequest) (
 		httpRequest.Header.Add("Cookie", cookie)
 	}
 
-	for headerKey, headerValue := range req.Headers {
+	singletonHeaders, headers := splitSingletonHeaders(req.Headers)
+
+	for headerKey, headerValue := range singletonHeaders {
+		httpRequest.Header.Add(headerKey, headerValue)
+	}
+
+	for headerKey, headerValue := range headers {
 		for _, val := range strings.Split(headerValue, ",") {
 			httpRequest.Header.Add(headerKey, strings.Trim(val, " "))
 		}
@@ -227,3 +234,38 @@ type requestContextV2 struct {
 	gatewayProxyContext events.APIGatewayV2HTTPRequestContext
 	stageVars           map[string]string
 }
+
+// splitSingletonHeaders splits the headers into single-value headers and other,
+// multi-value capable, headers.
+// Returns (single-value headers, multi-value-capable headers)
+func splitSingletonHeaders(headers map[string]string) (map[string]string, map[string]string) {
+	singletons := make(map[string]string)
+	multitons := make(map[string]string)
+	for headerKey, headerValue := range headers {
+		if ok := singletonHeaders[textproto.CanonicalMIMEHeaderKey(headerKey)]; ok {
+			singletons[headerKey] = headerValue
+		} else {
+			multitons[headerKey] = headerValue
+		}
+	}
+
+	return singletons, multitons
+}
+
+// singletonHeaders is a set of headers, that only accept a single
+// value which may be comma separated (according to RFC 7230)
+var singletonHeaders = map[string]bool{
+	"Content-Type":        true,
+	"Content-Disposition": true,
+	"Content-Length":      true,
+	"User-Agent":          true,
+	"Referer":             true,
+	"Host":                true,
+	"Authorization":       true,
+	"Proxy-Authorization": true,
+	"If-Modified-Since":   true,
+	"If-Unmodified-Since": true,
+	"From":                true,
+	"Location":            true,
+	"Max-Forwards":        true,
+}

core/requestv2_test.go

@@ -136,6 +136,35 @@ var _ = Describe("RequestAccessorV2 tests", func() {
 			}
 		})
 
+		singletonHeaderRequest := getProxyRequestV2("/hello", "GET")
+		singletonHeaderRequest.Headers = map[string]string{
+			// multi-value capable headers
+			"hello": "1",
+			"world": "2,3",
+			// singleton headers, which may be comma separated
+			"user-agent":    "Mozilla/5.0 (Linux; Android 11; Pixel 5 Build/RQ3A.210805.001.A1; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/92.0.4515.159 Mobile Safari/537.36",
+			"authorization": "some custom comma, separated authorization",
+		}
+
+		It("Populates singleton header values correctly", func() {
+			httpReq, err := accessor.EventToRequestWithContext(context.Background(), singletonHeaderRequest)
+			Expect(err).To(BeNil())
+			Expect("/hello").To(Equal(httpReq.URL.Path))
+			Expect("GET").To(Equal(httpReq.Method))
+
+			headers := httpReq.Header
+			Expect(4).To(Equal(len(headers)))
+
+			for k, value := range headers {
+				k = strings.ToLower(k)
+				if k == "hello" || k == "world" {
+					Expect(strings.Join(value, ",")).To(Equal(singletonHeaderRequest.Headers[k]))
+				} else {
+					Expect(headers.Get(k)).To(Equal(singletonHeaderRequest.Headers[k]))
+				}
+			}
+		})
+
 		svhRequest := getProxyRequestV2("/hello", "GET")
 		svhRequest.Headers = map[string]string{
 			"hello": "1",

core/response.go

@@ -82,6 +82,12 @@ func (r *ProxyResponseWriter) WriteHeader(status int) {
 	r.status = status
 }
 
+// Flush implements the Flusher interface which is called by
+// some implementers. This is intentionally a no-op
+func (r *ProxyResponseWriter) Flush() {
+	//no-op
+}
+
 // GetProxyResponse converts the data passed to the response writer into
 // an events.APIGatewayProxyResponse object.
 // Returns a populated proxy response object. If the response is invalid, for example

fiber/adapter.go

@@ -5,9 +5,12 @@ package fiberadapter
 
 import (
 	"context"
-	"io/ioutil"
+	"fmt"
+	"io"
+	"log"
 	"net"
 	"net/http"
+	"strings"
 
 	"github.com/aws/aws-lambda-go/events"
 	"github.com/gofiber/fiber/v2"
@@ -103,7 +106,7 @@ func (f *FiberLambda) adaptor(w http.ResponseWriter, r *http.Request) {
 	defer fasthttp.ReleaseRequest(req)
 
 	// Convert net/http -> fasthttp request
-	body, err := ioutil.ReadAll(r.Body)
+	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		http.Error(w, utils.StatusMessage(fiber.StatusInternalServerError), fiber.StatusInternalServerError)
 		return
@@ -129,8 +132,16 @@ func (f *FiberLambda) adaptor(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	remoteAddr, err := net.ResolveTCPAddr("tcp", r.RemoteAddr)
+	// We need to make sure the net.ResolveTCPAddr call works as it expects a port
+	addrWithPort := r.RemoteAddr
+	if !strings.Contains(r.RemoteAddr, ":") {
+		addrWithPort = r.RemoteAddr + ":80" // assuming a default port
+	}
+
+	remoteAddr, err := net.ResolveTCPAddr("tcp", addrWithPort)
 	if err != nil {
+		fmt.Printf("could not resolve TCP address for addr %s\n", r.RemoteAddr)
+		log.Println(err)
 		http.Error(w, utils.StatusMessage(fiber.StatusInternalServerError), fiber.StatusInternalServerError)
 		return
 	}

fiber/fiberlambda_test.go

@@ -39,6 +39,39 @@ var _ = Describe("FiberLambda tests", func() {
 		})
 	})
 
+	Context("RemoteAddr handling", func() {
+		It("Properly parses the IP address", func() {
+			app := fiber.New()
+			app.Get("/ping", func(c *fiber.Ctx) error {
+				// make sure the ip address is actually set properly
+				Expect(c.Context().RemoteAddr().String()).To(Equal("8.8.8.8:80"))
+				return c.SendString("pong")
+			})
+
+			adapter := fiberadaptor.New(app)
+
+			req := events.APIGatewayProxyRequest{
+				Path:       "/ping",
+				HTTPMethod: "GET",
+				RequestContext: events.APIGatewayProxyRequestContext{
+					Identity: events.APIGatewayRequestIdentity{
+						SourceIP: "8.8.8.8",
+					},
+				},
+			}
+
+			resp, err := adapter.ProxyWithContext(context.Background(), req)
+
+			Expect(err).To(BeNil())
+			Expect(resp.StatusCode).To(Equal(200))
+
+			resp, err = adapter.Proxy(req)
+
+			Expect(err).To(BeNil())
+			Expect(resp.StatusCode).To(Equal(200))
+		})
+	})
+
 	Context("Request header", func() {
 		It("Check pass canonical header to fiber", func() {
 			app := fiber.New()

sample/go.mod

@@ -3,17 +3,12 @@ module github.com/awslabs/aws-lambda-go-api-proxy-sample
 go 1.12
 
 require (
-	github.com/aws/aws-lambda-go v1.37.0
-	github.com/awslabs/aws-lambda-go-api-proxy v0.14.0
-	github.com/bytedance/sonic v1.8.2 // indirect
-	github.com/gin-gonic/gin v1.9.0
+	github.com/aws/aws-lambda-go v1.41.0
+	github.com/awslabs/aws-lambda-go-api-proxy v0.16.0
+	github.com/gin-gonic/gin v1.9.1
 	github.com/google/uuid v1.3.0
-	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
-	github.com/leodido/go-urn v1.2.2 // indirect
-	github.com/onsi/gomega v1.19.0 // indirect
-	github.com/ugorji/go/codec v1.2.10 // indirect
-	golang.org/x/arch v0.2.0 // indirect
-	golang.org/x/crypto v0.6.0 // indirect
+	github.com/kr/pretty v0.3.0 // indirect
+	github.com/rogpeppe/go-internal v1.8.0 // indirect
 )
 
 replace (