add support for X-Up-Timeout header field. Closes #815

the use-case was to bypass API Gateway by calling the Lambda function directly
with a request event, thus no longer bound to the proxy.timeout max of 25s

Author: tj

http/relay/relay.go

@@ -11,6 +11,7 @@ import (
 	"net/url"
 	"os"
 	"os/exec"
+	"strconv"
 	"sync"
 	"time"
 
@@ -74,21 +75,11 @@ func New(c *up.Config) (http.Handler, error) {
 
 	timeout := time.Duration(c.Proxy.Timeout) * time.Second
 
-	transport := &http.Transport{
-		DialContext: (&net.Dialer{
-			Timeout:   2 * time.Second,
-			KeepAlive: 2 * time.Second,
-			DualStack: true,
-		}).DialContext,
-		ResponseHeaderTimeout: timeout,
-		DisableKeepAlives:     true,
-	}
-
 	p := &Proxy{
 		config:    c,
 		stdout:    writer.New(stdout, ctx),
 		stderr:    writer.New(stderr, ctx),
-		transport: transport,
+		transport: newTransport(timeout),
 	}
 
 	if err := p.Start(); err != nil {
@@ -145,8 +136,16 @@ func (p *Proxy) Restart() error {
 func (p *Proxy) RoundTrip(r *http.Request) (*http.Response, error) {
 	id := r.Header.Get("X-Request-Id")
 	ctx = ctx.WithField("id", id)
+	transport := p.transport
+
+	// timeout header
+	if s := r.Header.Get("X-Up-Timeout"); s != "" {
+		if n, err := strconv.ParseInt(s, 10, 64); err == nil {
+			transport = newTransport(time.Duration(n) * time.Second)
+		}
+	}
 
-	res, err := p.transport.RoundTrip(r)
+	res, err := transport.RoundTrip(r)
 
 	// timeout error
 	if e, ok := err.(net.Error); ok && e.Timeout() {
@@ -213,6 +212,19 @@ func (p *Proxy) command(s string, env []string) *exec.Cmd {
 	return cmd
 }
 
+// newTransport returns a new http.Transport with the given timeout.
+func newTransport(timeout time.Duration) *http.Transport {
+	return &http.Transport{
+		DialContext: (&net.Dialer{
+			Timeout:   2 * time.Second,
+			KeepAlive: 2 * time.Second,
+			DualStack: true,
+		}).DialContext,
+		ResponseHeaderTimeout: timeout,
+		DisableKeepAlives:     true,
+	}
+}
+
 // env returns an environment variable.
 func env(name string, val interface{}) string {
 	return fmt.Sprintf("%s=%v", name, val)

http/relay/relay_test.go

@@ -145,6 +145,29 @@ func TestRelay(t *testing.T) {
 		assert.Equal(t, 200, res.Code)
 		assertString(t, "Hello World", res.Body.String())
 	})
+
+	t.Run("timeout header field", func(t *testing.T) {
+		newHandler(t)
+
+		// first
+		start := time.Now()
+		res := httptest.NewRecorder()
+		req := httptest.NewRequest("GET", "/timeout", nil)
+		req.Header.Set("X-Up-Timeout", "1")
+		h.ServeHTTP(res, req)
+
+		assert.True(t, time.Since(start) < time.Second*2)
+		assert.Equal(t, 502, res.Code)
+		assertString(t, "", res.Body.String())
+
+		// second
+		res = httptest.NewRecorder()
+		req = httptest.NewRequest("GET", "/hello", nil)
+		h.ServeHTTP(res, req)
+
+		assert.Equal(t, 200, res.Code)
+		assertString(t, "Hello World", res.Body.String())
+	})
 }
 
 func assertString(t testing.TB, want, got string) {