POC HTTPRoute Timeouts

* update HTTPRoute interfaces according to latest proposal in GEP-1742
* include Request and BackendRequest in HTTPRouteTimeouts
* add validation for HTTPRouteTimeouts
* add unit tests in httproute_test.go
* relates to kubernetes-sigs#1997

Author: SRodi

apis/v1beta1/httproute_types.go

@@ -244,6 +244,56 @@ type HTTPRouteRule struct {
 	// +optional
 	// +kubebuilder:validation:MaxItems=16
 	BackendRefs []HTTPBackendRef `json:"backendRefs,omitempty"`
+
+	// Timeouts defines the timeouts that can be configured for an HTTP request.
+	//
+	// Support: Extended
+	//
+	// +optional
+	// <gateway:experimental>
+	Timeouts *HTTPRouteTimeouts `json:"timeouts,omitempty"`
+}
+
+// HTTPRouteTimeouts defines timeouts that can be configured for an HTTPRoute.
+// Timeout values are formatted like 1h/1m/1s/1ms as parsed by Golang time.ParseDuration
+// and MUST BE >= 1ms or 0 to disable (no timeout).
+type HTTPRouteTimeouts struct {
+	// Request specifies the duration for processing an HTTP client request after which the
+	// gateway will time out if unable to send a response.
+	//
+	// For example, setting the `rules.timeouts.request` field to the value `10s` in an
+	// `HTTPRoute` will cause a timeout if a client request is taking longer than 10 seconds
+	// to complete.
+	//
+	// This timeout is intended to cover as close to the whole request-response transaction
+	// as possible although an implementation MAY choose to start the timeout after the entire
+	// request stream has been received instead of immediately after the transaction is
+	// initiated by the client.
+	//
+	// When this field is unspecified, request timeout behavior is implementation-dependent.
+	//
+	// Support: Extended
+	//
+	// +optional
+	// +kubebuilder:validation:Format=duration
+	Request *metav1.Duration `json:"request,omitempty"`
+
+	// BackendRequest specifies a timeout for an individual request from the gateway
+	// to a backend service. This covers the time from when the request first starts being
+	// sent from the gateway to when the full response has been received from the backend.
+	//
+	// An entire client HTTP transaction with a gateway, covered by the Request timeout,
+	// may result in more than one call from the gateway to the destination backend service,
+	// for example, if automatic retries are supported.
+	//
+	// Because the Request timeout encompasses the BackendRequest timeout,
+	// the value of BackendRequest defaults to and must be <= the value of Request timeout.
+	//
+	// Support: Extended
+	//
+	// +optional
+	// +kubebuilder:validation:Format=duration
+	BackendRequest *metav1.Duration `json:"backendRequest,omitempty"`
 }
 
 // PathMatchType specifies the semantics of how HTTP paths should be compared.

apis/v1beta1/validation/httproute.go

@@ -21,6 +21,7 @@ import (
 	"net/http"
 	"regexp"
 	"strings"
+	"time"
 
 	"k8s.io/apimachinery/pkg/util/validation/field"
 
@@ -40,6 +41,9 @@ var (
 
 	// All valid path characters per RFC-3986
 	validPathCharacters = "^(?:[A-Za-z0-9\\/\\-._~!$&'()*+,;=:@]|[%][0-9a-fA-F]{2})+$"
+
+	// Minimum value of timeout fields
+	timeoutMinValue = time.Duration(time.Millisecond * 1)
 )
 
 // ValidateHTTPRoute validates HTTPRoute according to the Gateway API specification.
@@ -71,6 +75,10 @@ func ValidateHTTPRouteSpec(spec *gatewayv1b1.HTTPRouteSpec, path *field.Path) fi
 				errs = append(errs, validateHTTPQueryParamMatches(m.QueryParams, matchPath.Child("queryParams"))...)
 			}
 		}
+
+		if rule.Timeouts != nil {
+			errs = append(errs, validateHTTPRouteTimeouts(rule.Timeouts, path.Child("rules").Child("timeouts"))...)
+		}
 	}
 	errs = append(errs, validateHTTPRouteBackendServicePorts(spec.Rules, path.Child("rules"))...)
 	errs = append(errs, ValidateParentRefs(spec.ParentRefs, path.Child("spec"))...)
@@ -334,6 +342,31 @@ func validateHTTPHeaderModifier(filter gatewayv1b1.HTTPHeaderFilter, path *field
 	return errs
 }
 
+func validateHTTPRouteTimeouts(timeouts *gatewayv1b1.HTTPRouteTimeouts, path *field.Path) field.ErrorList {
+	var errs field.ErrorList
+	errorString := fmt.Sprintf("timeout value must be greater than or equal to %s", timeoutMinValue)
+	if timeouts.BackendRequest != nil {
+		backendTimeout := timeouts.BackendRequest.Duration
+		if backendTimeout < timeoutMinValue && backendTimeout != 0 {
+			errs = append(errs, field.Invalid(path.Child("backendRequest"), backendTimeout, errorString))
+		}
+		if timeouts.Request != nil {
+			timeout := timeouts.Request.Duration
+			if backendTimeout > timeout && timeout != 0 {
+				errs = append(errs, field.Invalid(path.Child("backendRequest"), backendTimeout, "backendRequest timeout cannot be longer than request timeout"))
+			}
+		}
+	}
+	if timeouts.Request != nil {
+		timeout := timeouts.Request.Duration
+		if timeout < timeoutMinValue && timeout != 0 {
+			errs = append(errs, field.Invalid(path.Child("request"), timeout, errorString))
+		}
+	}
+
+	return errs
+}
+
 func hasExactlyOnePrefixMatch(matches []gatewayv1b1.HTTPRouteMatch) bool {
 	if len(matches) != 1 || matches[0].Path == nil {
 		return false

apis/v1beta1/validation/httproute_test.go

@@ -18,11 +18,13 @@ package validation
 
 import (
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/util/validation/field"
 
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	gatewayv1b1 "sigs.k8s.io/gateway-api/apis/v1beta1"
 )
 
@@ -1140,3 +1142,65 @@ func TestValidateHTTPRouteTypeMatchesField(t *testing.T) {
 		})
 	}
 }
+
+func TestValidateHTTPTimeouts(t *testing.T) {
+	tests := []struct {
+		name     string
+		rules    []gatewayv1b1.HTTPRouteRule
+		errCount int
+	}{{
+		name:     "valid httpRoute Rules timeouts",
+		errCount: 0,
+		rules: []gatewayv1b1.HTTPRouteRule{{
+			Timeouts: &gatewayv1b1.HTTPRouteTimeouts{
+				Request: &metav1.Duration{
+					Duration: time.Duration(time.Millisecond * 1),
+				},
+			},
+		},
+		}}, {
+		name:     "valid httpRoute Rules timeout set to 0 (disabled)",
+		errCount: 0,
+		rules: []gatewayv1b1.HTTPRouteRule{{
+			Timeouts: &gatewayv1b1.HTTPRouteTimeouts{
+				Request: &metav1.Duration{
+					Duration: time.Duration(0),
+				},
+			},
+		},
+		}}, {
+		name:     "invalid httpRoute Rules timeout",
+		errCount: 1,
+		rules: []gatewayv1b1.HTTPRouteRule{{
+			Timeouts: &gatewayv1b1.HTTPRouteTimeouts{
+				Request: &metav1.Duration{
+					Duration: time.Duration(time.Microsecond * 500),
+				},
+			},
+		},
+		}}, {
+		name:     "invalid httpRoute Rules backendRequest timeout cannot be longer than request timeout",
+		errCount: 1,
+		rules: []gatewayv1b1.HTTPRouteRule{{
+			Timeouts: &gatewayv1b1.HTTPRouteTimeouts{
+				Request: &metav1.Duration{
+					Duration: time.Duration(time.Millisecond * 1),
+				},
+				BackendRequest: &metav1.Duration{
+					Duration: time.Duration(time.Millisecond * 2),
+				},
+			},
+		},
+		}},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			route := gatewayv1b1.HTTPRoute{Spec: gatewayv1b1.HTTPRouteSpec{Rules: tc.rules}}
+			errs := ValidateHTTPRoute(&route)
+			if len(errs) != tc.errCount {
+				t.Errorf("got %d errors, want %d errors: %s", len(errs), tc.errCount, errs)
+			}
+		})
+	}
+}