feat(annotations) support additional fields (#3121)

Add annotations for fields previously supported only in
KongIngress.

Add connect, write, and read timeout annotations to Services.

Add retries annotation to Services.

Add headers annotation to Routes. The annotation is in the form
"konghq.com/headers/example: value1,value2", where the portion of the
annoation name after "konghq.com/headers" ("example") is the
header name and the value is a CSV of header values.

Add path handling annotation to Routes.

Co-authored-by: Patryk Małek <[email protected]>

Author: rainest

CHANGELOG.md

@@ -102,6 +102,14 @@ Adding a new version? You'll need three changes:
   irrelevant secrets (e.g: service account tokens) are not stored. This change
   is made to reduce memory usage of the cache.
   [#3047](https://github.com/Kong/kubernetes-ingress-controller/pull/3047)
+- Services support annotations for connect, read, and write timeouts.
+  [#3121](https://github.com/Kong/kubernetes-ingress-controller/pull/3121)
+- Services support annotations for retries.
+  [#3121](https://github.com/Kong/kubernetes-ingress-controller/pull/3121)
+- Routes support annotations for headers.
+  [#3121](https://github.com/Kong/kubernetes-ingress-controller/pull/3121)
+- Routes support annotations for path handling.
+  [#3121](https://github.com/Kong/kubernetes-ingress-controller/pull/3121)
 
 ### Fixed
 

internal/annotations/annotations.go

@@ -56,6 +56,12 @@ const (
 	ResponseBuffering    = "/response-buffering"
 	HostAliasesKey       = "/host-aliases"
 	RegexPrefixKey       = "/regex-prefix"
+	ConnectTimeoutKey    = "/connect-timeout"
+	WriteTimeoutKey      = "/write-timeout"
+	ReadTimeoutKey       = "/read-timeout"
+	RetriesKey           = "/retries"
+	HeadersKey           = "/headers"
+	PathHandlingKey      = "/path-handling"
 
 	// GatewayClassUnmanagedAnnotationSuffix is an annotation used on a Gateway resource to
 	// indicate that the GatewayClass should be reconciled according to unmanaged
@@ -253,6 +259,70 @@ func ExtractHostAliases(anns map[string]string) ([]string, bool) {
 	return strings.Split(val, ","), true
 }
 
+// ExtractConnectTimeout extracts the connection timeout annotation value.
+func ExtractConnectTimeout(anns map[string]string) (string, bool) {
+	val, exists := anns[AnnotationPrefix+ConnectTimeoutKey]
+	if !exists {
+		return "", false
+	}
+	return val, true
+}
+
+// ExtractWriteTimeout extracts the write timeout annotation value.
+func ExtractWriteTimeout(anns map[string]string) (string, bool) {
+	val, exists := anns[AnnotationPrefix+WriteTimeoutKey]
+	if !exists {
+		return "", false
+	}
+	return val, true
+}
+
+// ExtractReadTimeout extracts the read timeout annotation value.
+func ExtractReadTimeout(anns map[string]string) (string, bool) {
+	val, exists := anns[AnnotationPrefix+ReadTimeoutKey]
+	if !exists {
+		return "", false
+	}
+	return val, true
+}
+
+// ExtractRetries extracts the retries annotation value.
+func ExtractRetries(anns map[string]string) (string, bool) {
+	val, exists := anns[AnnotationPrefix+RetriesKey]
+	if !exists {
+		return "", false
+	}
+	return val, true
+}
+
+// ExtractHeaders extracts the parsed headers annotations values. It returns a map of header names to slices of values.
+func ExtractHeaders(anns map[string]string) (map[string][]string, bool) {
+	headers := make(map[string][]string)
+	prefix := AnnotationPrefix + HeadersKey + "/"
+	for key, val := range anns {
+		if strings.HasPrefix(key, prefix) {
+			header := strings.TrimPrefix(key, prefix)
+			if len(header) == 0 || len(val) == 0 {
+				continue
+			}
+			headers[header] = strings.Split(val, ",")
+		}
+	}
+	if len(headers) == 0 {
+		return headers, false
+	}
+	return headers, true
+}
+
+// ExtractPathHandling extracts the path handling annotation value.
+func ExtractPathHandling(anns map[string]string) (string, bool) {
+	val, exists := anns[AnnotationPrefix+PathHandlingKey]
+	if !exists {
+		return "", false
+	}
+	return val, true
+}
+
 // ExtractUnmanagedGatewayClassMode extracts the value of the unmanaged gateway
 // mode annotation.
 func ExtractUnmanagedGatewayClassMode(anns map[string]string) string {

internal/annotations/annotations_test.go

@@ -21,6 +21,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	corev1 "k8s.io/api/core/v1"
 	extensions "k8s.io/api/extensions/v1beta1"
 	netv1 "k8s.io/api/networking/v1"
@@ -684,3 +685,245 @@ func TestExtractHostAliases(t *testing.T) {
 		})
 	}
 }
+
+func TestExtractConnectTimeout(t *testing.T) {
+	type args struct {
+		anns map[string]string
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{
+			name: "empty",
+			want: "",
+		},
+		{
+			name: "non-empty",
+			args: args{
+				anns: map[string]string{
+					"konghq.com/connect-timeout": "3000",
+				},
+			},
+			want: "3000",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := ExtractConnectTimeout(tt.args.anns)
+			if tt.want == "" {
+				assert.False(t, ok)
+			} else {
+				assert.True(t, ok)
+				require.Equal(t, tt.want, got)
+			}
+		})
+	}
+}
+
+func TestExtractWriteTimeout(t *testing.T) {
+	type args struct {
+		anns map[string]string
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{
+			name: "empty",
+			want: "",
+		},
+		{
+			name: "non-empty",
+			args: args{
+				anns: map[string]string{
+					"konghq.com/write-timeout": "3000",
+				},
+			},
+			want: "3000",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := ExtractWriteTimeout(tt.args.anns)
+			if tt.want == "" {
+				assert.False(t, ok)
+			} else {
+				assert.True(t, ok)
+				require.Equal(t, tt.want, got)
+			}
+		})
+	}
+}
+
+func TestExtractReadTimeout(t *testing.T) {
+	type args struct {
+		anns map[string]string
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{
+			name: "empty",
+			want: "",
+		},
+		{
+			name: "non-empty",
+			args: args{
+				anns: map[string]string{
+					"konghq.com/read-timeout": "3000",
+				},
+			},
+			want: "3000",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := ExtractReadTimeout(tt.args.anns)
+			if tt.want == "" {
+				assert.False(t, ok)
+			} else {
+				assert.True(t, ok)
+				require.Equal(t, tt.want, got)
+			}
+		})
+	}
+}
+
+func TestExtractRetries(t *testing.T) {
+	type args struct {
+		anns map[string]string
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{
+			name: "empty",
+			want: "",
+		},
+		{
+			name: "non-empty",
+			args: args{
+				anns: map[string]string{
+					"konghq.com/retries": "3000",
+				},
+			},
+			want: "3000",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := ExtractRetries(tt.args.anns)
+			if tt.want == "" {
+				assert.False(t, ok)
+			} else {
+				assert.True(t, ok)
+			}
+			if got != tt.want {
+				t.Errorf("ExtractRetries() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestExtractHeaders(t *testing.T) {
+	type args struct {
+		anns map[string]string
+	}
+	tests := []struct {
+		name string
+		args args
+		want map[string][]string
+	}{
+		{
+			name: "empty",
+			want: map[string][]string{},
+		},
+		{
+			name: "non-empty",
+			args: args{
+				anns: map[string]string{
+					"konghq.com/headers/foo": "foo",
+				},
+			},
+			want: map[string][]string{"foo": {"foo"}},
+		},
+		{
+			name: "no separator",
+			args: args{
+				anns: map[string]string{
+					"konghq.com/headersfoo": "foo",
+				},
+			},
+			want: map[string][]string{},
+		},
+		{
+			name: "no header name",
+			args: args{
+				anns: map[string]string{
+					"konghq.com/headers/": "foo",
+				},
+			},
+			want: map[string][]string{},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := ExtractHeaders(tt.args.anns)
+			if len(tt.want) == 0 {
+				assert.False(t, ok)
+			} else {
+				assert.True(t, ok)
+			}
+			for key, val := range tt.want {
+				actual, ok := got[key]
+				assert.True(t, ok)
+				assert.Equal(t, val, actual)
+			}
+		})
+	}
+}
+
+func TestExtractPathHandling(t *testing.T) {
+	type args struct {
+		anns map[string]string
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{
+			name: "empty",
+			want: "",
+		},
+		{
+			name: "non-empty",
+			args: args{
+				anns: map[string]string{
+					"konghq.com/path-handling": "v1",
+				},
+			},
+			want: "v1",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := ExtractPathHandling(tt.args.anns)
+			if tt.want == "" {
+				assert.False(t, ok)
+			} else {
+				assert.True(t, ok)
+			}
+			if got != tt.want {
+				t.Errorf("ExtractPathHandling() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

internal/dataplane/kongstate/route.go

@@ -24,7 +24,8 @@ type Route struct {
 }
 
 var (
-	validMethods = regexp.MustCompile(`\A[A-Z]+$`)
+	validMethods      = regexp.MustCompile(`\A[A-Z]+$`)
+	validPathHandling = regexp.MustCompile(`v\d`)
 
 	// hostnames are complicated. shamelessly cribbed from https://stackoverflow.com/a/18494710
 	// TODO if the Kong core adds support for wildcard SNI route match criteria, this should change.
@@ -228,6 +229,8 @@ func (r *Route) overrideByAnnotation(log logrus.FieldLogger) {
 	r.overrideRequestBuffering(log, r.Ingress.Annotations)
 	r.overrideResponseBuffering(log, r.Ingress.Annotations)
 	r.overrideHosts(log, r.Ingress.Annotations)
+	r.overrideHeaders(r.Ingress.Annotations)
+	r.overridePathHandling(log, r.Ingress.Annotations)
 }
 
 // override sets Route fields by KongIngress first, then by annotation.
@@ -405,3 +408,25 @@ func (r *Route) overrideHosts(log logrus.FieldLogger, anns map[string]string) {
 
 	r.Hosts = hosts
 }
+
+func (r *Route) overrideHeaders(anns map[string]string) {
+	headers, exists := annotations.ExtractHeaders(anns)
+	if !exists {
+		return
+	}
+	r.Headers = headers
+}
+
+func (r *Route) overridePathHandling(log logrus.FieldLogger, anns map[string]string) {
+	val, ok := annotations.ExtractPathHandling(anns)
+	if !ok {
+		return
+	}
+
+	if !validPathHandling.MatchString(val) {
+		log.WithField("kongroute", r.Name).Errorf("invalid path_handling value: %s", val)
+		return
+	}
+
+	r.PathHandling = kong.String(val)
+}