add support for ip_hash lb method

Author: salonichf5

internal/controller/nginx/config/http/config.go

@@ -119,11 +119,12 @@ const (
 
 // Upstream holds all configuration for an HTTP upstream.
 type Upstream struct {
-	Name      string
-	ZoneSize  string // format: 512k, 1m
-	StateFile string
-	KeepAlive UpstreamKeepAlive
-	Servers   []UpstreamServer
+	Name                string
+	ZoneSize            string // format: 512k, 1m
+	StateFile           string
+	KeepAlive           UpstreamKeepAlive
+	LoadBalancingMethod string
+	Servers             []UpstreamServer
 }
 
 // UpstreamKeepAlive holds the keepalive configuration for an HTTP upstream.

internal/controller/nginx/config/policies/upstreamsettings/processor.go

@@ -13,6 +13,8 @@ type Processor struct{}
 type UpstreamSettings struct {
 	// ZoneSize is the zone size setting.
 	ZoneSize string
+	// LoadBalancingMethod is the load balancing method setting.
+	LoadBalancingMethod string
 	// KeepAlive contains the keepalive settings.
 	KeepAlive http.UpstreamKeepAlive
 }
@@ -61,6 +63,10 @@ func processPolicies(pols []policies.Policy) UpstreamSettings {
 				upstreamSettings.KeepAlive.Timeout = string(*usp.Spec.KeepAlive.Timeout)
 			}
 		}
+
+		if usp.Spec.LoadBalancingMethod != nil {
+			upstreamSettings.LoadBalancingMethod = string(*usp.Spec.LoadBalancingMethod)
+		}
 	}
 
 	return upstreamSettings

internal/controller/nginx/config/policies/upstreamsettings/processor_test.go

@@ -37,6 +37,7 @@ func TestProcess(t *testing.T) {
 							Time:        helpers.GetPointer[ngfAPIv1alpha1.Duration]("5s"),
 							Timeout:     helpers.GetPointer[ngfAPIv1alpha1.Duration]("10s"),
 						}),
+						LoadBalancingMethod: helpers.GetPointer(ngfAPIv1alpha1.LoadBalancingTypeIPHash),
 					},
 				},
 			},
@@ -48,6 +49,24 @@ func TestProcess(t *testing.T) {
 					Time:        "5s",
 					Timeout:     "10s",
 				},
+				LoadBalancingMethod: string(ngfAPIv1alpha1.LoadBalancingTypeIPHash),
+			},
+		},
+		{
+			name: "load balancing method set",
+			policies: []policies.Policy{
+				&ngfAPIv1alpha1.UpstreamSettingsPolicy{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      "usp",
+						Namespace: "test",
+					},
+					Spec: ngfAPIv1alpha1.UpstreamSettingsPolicySpec{
+						LoadBalancingMethod: helpers.GetPointer(ngfAPIv1alpha1.LoadBalancingTypeRandomTwoLeastConnection),
+					},
+				},
+			},
+			expUpstreamSettings: UpstreamSettings{
+				LoadBalancingMethod: string(ngfAPIv1alpha1.LoadBalancingTypeRandomTwoLeastConnection),
 			},
 		},
 		{
@@ -220,6 +239,15 @@ func TestProcess(t *testing.T) {
 						}),
 					},
 				},
+				&ngfAPIv1alpha1.UpstreamSettingsPolicy{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      "usp-loadBalancingMethod",
+						Namespace: "test",
+					},
+					Spec: ngfAPIv1alpha1.UpstreamSettingsPolicySpec{
+						LoadBalancingMethod: helpers.GetPointer(ngfAPIv1alpha1.LoadBalancingTypeIPHash),
+					},
+				},
 			},
 			expUpstreamSettings: UpstreamSettings{
 				ZoneSize: "2m",
@@ -229,6 +257,7 @@ func TestProcess(t *testing.T) {
 					Time:        "5s",
 					Timeout:     "10s",
 				},
+				LoadBalancingMethod: string(ngfAPIv1alpha1.LoadBalancingTypeIPHash),
 			},
 		},
 		{

internal/controller/nginx/config/policies/upstreamsettings/validator.go

@@ -83,6 +83,10 @@ func conflicts(a, b ngfAPI.UpstreamSettingsPolicySpec) bool {
 		}
 	}
 
+	if a.LoadBalancingMethod != nil && b.LoadBalancingMethod != nil {
+		return true
+	}
+
 	return false
 }
 
@@ -103,6 +107,11 @@ func (v Validator) validateSettings(spec ngfAPI.UpstreamSettingsPolicySpec) erro
 		allErrs = append(allErrs, v.validateUpstreamKeepAlive(*spec.KeepAlive, fieldPath.Child("keepAlive"))...)
 	}
 
+	allErrs = append(
+		allErrs,
+		v.validateLoadBalancingMethod(*spec.LoadBalancingMethod, fieldPath.Child("loadBalancingMethod"))...,
+	)
+
 	return allErrs.ToAggregate()
 }
 
@@ -130,3 +139,25 @@ func (v Validator) validateUpstreamKeepAlive(
 
 	return allErrs
 }
+
+func (v Validator) validateLoadBalancingMethod(
+	method ngfAPI.LoadBalancingType,
+	fieldPath *field.Path,
+) field.ErrorList {
+	var allErrs field.ErrorList
+
+	switch method {
+	case ngfAPI.LoadBalancingTypeIPHash, ngfAPI.LoadBalancingTypeRandomTwoLeastConnection:
+	default:
+		allErrs = append(allErrs, field.NotSupported(
+			fieldPath,
+			method,
+			[]string{
+				string(ngfAPI.LoadBalancingTypeIPHash),
+				string(ngfAPI.LoadBalancingTypeRandomTwoLeastConnection),
+			},
+		))
+	}
+
+	return allErrs
+}

internal/controller/nginx/config/policies/upstreamsettings/validator_test.go

@@ -38,6 +38,7 @@ func createValidPolicy() *ngfAPI.UpstreamSettingsPolicy {
 				Timeout:     helpers.GetPointer[ngfAPI.Duration]("30s"),
 				Connections: helpers.GetPointer[int32](100),
 			},
+			LoadBalancingMethod: helpers.GetPointer(ngfAPI.LoadBalancingTypeRandomTwoLeastConnection),
 		},
 		Status: v1.PolicyStatus{},
 	}
@@ -117,6 +118,17 @@ func TestValidator_Validate(t *testing.T) {
 						"'must contain an, at most, four digit number followed by 'ms', 's', 'm', or 'h'')]"),
 			},
 		},
+		{
+			name: "invalid load balancing method",
+			policy: createModifiedPolicy(func(p *ngfAPI.UpstreamSettingsPolicy) *ngfAPI.UpstreamSettingsPolicy {
+				p.Spec.LoadBalancingMethod = helpers.GetPointer[ngfAPI.LoadBalancingType]("invalid-lb-method")
+				return p
+			}),
+			expConditions: []conditions.Condition{
+				conditions.NewPolicyInvalid("spec.loadBalancingMethod: Unsupported value: \"invalid-lb-method\": " +
+					"supported values: \"ip_hash\", \"random two least_conn\""),
+			},
+		},
 		{
 			name:          "valid",
 			policy:        createValidPolicy(),
@@ -246,6 +258,16 @@ func TestValidator_Conflicts(t *testing.T) {
 			},
 			conflicts: true,
 		},
+		{
+			name: "load balancing method conflicts",
+			polA: createValidPolicy(),
+			polB: &ngfAPI.UpstreamSettingsPolicy{
+				Spec: ngfAPI.UpstreamSettingsPolicySpec{
+					LoadBalancingMethod: helpers.GetPointer(ngfAPI.LoadBalancingTypeIPHash),
+				},
+			},
+			conflicts: true,
+		},
 	}
 
 	v := upstreamsettings.NewValidator(nil)

internal/controller/nginx/config/upstreams.go

@@ -32,6 +32,8 @@ const (
 	plusZoneSizeStream = "1m"
 	// stateDir is the directory for storing state files.
 	stateDir = "/var/lib/nginx/state"
+	// default load balancing method.
+	randomTwoLeastConnLB = "random two least_conn"
 )
 
 // keepAliveChecker takes an upstream name and returns if it has keep alive settings enabled.
@@ -185,12 +187,18 @@ func (g GeneratorImpl) createUpstream(
 		}
 	}
 
+	chosenLBMethod := randomTwoLeastConnLB
+	if upstreamPolicySettings.LoadBalancingMethod != "" {
+		chosenLBMethod = upstreamPolicySettings.LoadBalancingMethod
+	}
+
 	return http.Upstream{
-		Name:      up.Name,
-		ZoneSize:  zoneSize,
-		StateFile: stateFile,
-		Servers:   upstreamServers,
-		KeepAlive: upstreamPolicySettings.KeepAlive,
+		Name:                up.Name,
+		ZoneSize:            zoneSize,
+		StateFile:           stateFile,
+		Servers:             upstreamServers,
+		KeepAlive:           upstreamPolicySettings.KeepAlive,
+		LoadBalancingMethod: chosenLBMethod,
 	}
 }
 

internal/controller/nginx/config/upstreams_template.go

@@ -10,7 +10,9 @@ package config
 const upstreamsTemplateText = `
 {{ range $u := . }}
 upstream {{ $u.Name }} {
-    random two least_conn;
+    {{ if $u.LoadBalancingMethod -}}
+    {{ $u.LoadBalancingMethod }};
+    {{- end }}
     {{ if $u.ZoneSize -}}
     zone {{ $u.Name }} {{ $u.ZoneSize }};
     {{ end -}}