Adding configurability to the interceptor's HTTP round tripper

interceptor/config/timeouts.go

@@ -19,6 +19,21 @@ type Timeouts struct {
 	// DeploymentReplicas is how long to wait for the backing deployment
 	// to have 1 or more replicas before connecting and sending the HTTP request.
 	DeploymentReplicas time.Duration `envconfig:"KEDA_CONDITION_WAIT_TIMEOUT" default:"1500ms"`
+	// ForceHTTP2 toggles whether to try to force HTTP2 for all requests
+	ForceHTTP2 bool `envconfig:"KEDA_HTTP_FORCE_HTTP2" default:"false"`
+	// MaxIdleConns is the max number of connections that can be idle in the
+	// interceptor's internal connection pool
+	MaxIdleConns int `envconfig:"KEDA_HTTP_MAX_IDLE_CONNS" default:"100"`
+	// IdleConnTimeout is the timeout after which a connection in the interceptor's
+	// internal connection pool will be closed
+	IdleConnTimeout time.Duration `envconfig:"KEDA_HTTP_IDLE_CONN_TIMEOUT" default:"90s"`
+	// TLSHandshakeTimeout is the max amount of time the interceptor will
+	// wait to establish a TLS connection
+	TLSHandshakeTimeout time.Duration `envconfig:"KEDA_HTTP_TLS_HANDSHAKE_TIMEOUT" default:"10s"`
+	// ExpectContinueTimeout is the max amount of time the interceptor will wait
+	// after sending request headers if the server returned an Expect: 100-continue
+	// header
+	ExpectContinueTimeout time.Duration `envconfig:"KEDA_HTTP_EXPECT_CONTINUE_TIMEOUT" default:"1s"`
 }
 
 // Backoff returns a wait.Backoff based on the timeouts in t

interceptor/main.go

@@ -231,8 +231,7 @@ func runProxyServer(
 			routingTable,
 			dialContextFunc,
 			waitFunc,
-			timeouts.DeploymentReplicas,
-			timeouts.ResponseHeader,
+			newForwardingConfigFromTimeouts(timeouts),
 		),
 	)
 

interceptor/proxy_handlers.go

@@ -7,12 +7,31 @@ import (
 	"time"
 
 	"github.com/go-logr/logr"
+	"github.com/kedacore/http-add-on/interceptor/config"
 	kedanet "github.com/kedacore/http-add-on/pkg/net"
 	"github.com/kedacore/http-add-on/pkg/routing"
 )
 
-func moreThanPtr(i *int32, target int32) bool {
-	return i != nil && *i > target
+type forwardingConfig struct {
+	waitTimeout           time.Duration
+	respHeaderTimeout     time.Duration
+	forceAttemptHTTP2     bool
+	maxIdleConns          int
+	idleConnTimeout       time.Duration
+	tlsHandshakeTimeout   time.Duration
+	expectContinueTimeout time.Duration
+}
+
+func newForwardingConfigFromTimeouts(t *config.Timeouts) forwardingConfig {
+	return forwardingConfig{
+		waitTimeout:           t.DeploymentReplicas,
+		respHeaderTimeout:     t.ResponseHeader,
+		forceAttemptHTTP2:     t.ForceHTTP2,
+		maxIdleConns:          t.MaxIdleConns,
+		idleConnTimeout:       t.IdleConnTimeout,
+		tlsHandshakeTimeout:   t.TLSHandshakeTimeout,
+		expectContinueTimeout: t.ExpectContinueTimeout,
+	}
 }
 
 // newForwardingHandler takes in the service URL for the app backend
@@ -26,18 +45,17 @@ func newForwardingHandler(
 	routingTable *routing.Table,
 	dialCtxFunc kedanet.DialContextFunc,
 	waitFunc forwardWaitFunc,
-	waitTimeout time.Duration,
-	respHeaderTimeout time.Duration,
+	fwdCfg forwardingConfig,
 ) http.Handler {
 	roundTripper := &http.Transport{
 		Proxy:                 http.ProxyFromEnvironment,
 		DialContext:           dialCtxFunc,
-		ForceAttemptHTTP2:     true,
-		MaxIdleConns:          100,
-		IdleConnTimeout:       90 * time.Second,
-		TLSHandshakeTimeout:   10 * time.Second,
-		ExpectContinueTimeout: 1 * time.Second,
-		ResponseHeaderTimeout: respHeaderTimeout,
+		ForceAttemptHTTP2:     fwdCfg.forceAttemptHTTP2,
+		MaxIdleConns:          fwdCfg.maxIdleConns,
+		IdleConnTimeout:       fwdCfg.idleConnTimeout,
+		TLSHandshakeTimeout:   fwdCfg.tlsHandshakeTimeout,
+		ExpectContinueTimeout: fwdCfg.expectContinueTimeout,
+		ResponseHeaderTimeout: fwdCfg.respHeaderTimeout,
 	}
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		host, err := getHost(r)
@@ -52,7 +70,8 @@ func newForwardingHandler(
 			w.Write([]byte(fmt.Sprintf("Host %s not found", r.Host)))
 			return
 		}
-		ctx, done := context.WithTimeout(r.Context(), waitTimeout)
+
+		ctx, done := context.WithTimeout(r.Context(), fwdCfg.waitTimeout)
 		defer done()
 		if err := waitFunc(ctx, routingTarget.Deployment); err != nil {
 			lggr.Error(err, "wait function failed, not forwarding request")

interceptor/proxy_handlers_integration_test.go

@@ -290,8 +290,10 @@ func newHarness(
 		routingTable,
 		dialContextFunc,
 		waitFunc,
-		deployReplicasTimeout,
-		responseHeaderTimeout,
+		forwardingConfig{
+			waitTimeout:       deployReplicasTimeout,
+			respHeaderTimeout: responseHeaderTimeout,
+		},
 	)
 
 	originHdl := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

interceptor/proxy_handlers_test.go

@@ -49,8 +49,10 @@ func TestImmediatelySuccessfulProxy(t *testing.T) {
 		routingTable,
 		dialCtxFunc,
 		waitFunc,
-		timeouts.DeploymentReplicas,
-		timeouts.ResponseHeader,
+		forwardingConfig{
+			waitTimeout:       timeouts.DeploymentReplicas,
+			respHeaderTimeout: timeouts.ResponseHeader,
+		},
 	)
 	const path = "/testfwd"
 	res, req, err := reqAndRes(path)
@@ -91,8 +93,10 @@ func TestWaitFailedConnection(t *testing.T) {
 		routingTable,
 		dialCtxFunc,
 		waitFunc,
-		timeouts.DeploymentReplicas,
-		timeouts.ResponseHeader,
+		forwardingConfig{
+			waitTimeout:       timeouts.DeploymentReplicas,
+			respHeaderTimeout: timeouts.ResponseHeader,
+		},
 	)
 	const path = "/testfwd"
 	res, req, err := reqAndRes(path)
@@ -129,8 +133,10 @@ func TestTimesOutOnWaitFunc(t *testing.T) {
 		routingTable,
 		dialCtxFunc,
 		waitFunc,
-		timeouts.DeploymentReplicas,
-		timeouts.ResponseHeader,
+		forwardingConfig{
+			waitTimeout:       timeouts.DeploymentReplicas,
+			respHeaderTimeout: timeouts.ResponseHeader,
+		},
 	)
 	const path = "/testfwd"
 	res, req, err := reqAndRes(path)
@@ -192,8 +198,10 @@ func TestWaitsForWaitFunc(t *testing.T) {
 		routingTable,
 		dialCtxFunc,
 		waitFunc,
-		timeouts.DeploymentReplicas,
-		timeouts.ResponseHeader,
+		forwardingConfig{
+			waitTimeout:       timeouts.DeploymentReplicas,
+			respHeaderTimeout: timeouts.ResponseHeader,
+		},
 	)
 	const path = "/testfwd"
 	res, req, err := reqAndRes(path)
@@ -259,8 +267,10 @@ func TestWaitHeaderTimeout(t *testing.T) {
 		routingTable,
 		dialCtxFunc,
 		waitFunc,
-		timeouts.DeploymentReplicas,
-		timeouts.ResponseHeader,
+		forwardingConfig{
+			waitTimeout:       timeouts.DeploymentReplicas,
+			respHeaderTimeout: timeouts.ResponseHeader,
+		},
 	)
 	const path = "/testfwd"
 	res, req, err := reqAndRes(path)