Remove enableOOBLoadReport and oobReportingPeriod fields from ClientSideWeightedRoundRobin configuration, update affected tests and CRDs.

Signed-off-by: anurag.ag <[email protected]>

Author: anuragagarwal561994

api/v1alpha1/loadbalancer_types.go

@@ -148,16 +148,6 @@ type Cookie struct {
 // See Envoy proto: envoy.extensions.load_balancing_policies.client_side_weighted_round_robin.v3.ClientSideWeightedRoundRobin
 // Note: SlowStart is not supported for this policy in Envoy Gateway at this time.
 type ClientSideWeightedRoundRobin struct {
-	// Whether to enable out-of-band utilization reporting collection from the endpoints.
-	// By default, per-request utilization reporting is used.
-	// +optional
-	EnableOOBLoadReport *bool `json:"-"`
-
-	// Load reporting interval to request from the server. Used only when enableOOBLoadReport is true.
-	// Default is 10s; server may not provide reports as frequently as requested.
-	// +optional
-	OOBReportingPeriod *gwapiv1.Duration `json:"-"`
-
 	// A given endpoint must report load metrics continuously for at least this long before the endpoint weight will be used.
 	// Default is 10s.
 	// +optional

api/v1alpha1/zz_generated.deepcopy.go

@@ -346,14 +346,6 @@ func buildLoadBalancer(policy *egv1a1.ClusterSettings) (*ir.LoadBalancer, error)
 		}
 		cswrr := policy.LoadBalancer.ClientSideWeightedRoundRobin
 		if cswrr != nil {
-			if cswrr.EnableOOBLoadReport != nil {
-				lb.ClientSideWeightedRoundRobin.EnableOOBLoadReport = cswrr.EnableOOBLoadReport
-			}
-			if cswrr.OOBReportingPeriod != nil {
-				if d, err := time.ParseDuration(string(*cswrr.OOBReportingPeriod)); err == nil {
-					lb.ClientSideWeightedRoundRobin.OOBReportingPeriod = ir.MetaV1DurationPtr(d)
-				}
-			}
 			if cswrr.BlackoutPeriod != nil {
 				if d, err := time.ParseDuration(string(*cswrr.BlackoutPeriod)); err == nil {
 					lb.ClientSideWeightedRoundRobin.BlackoutPeriod = ir.MetaV1DurationPtr(d)

internal/gatewayapi/clustersettings.go

@@ -11,20 +11,18 @@ import (
 
 	"github.com/stretchr/testify/require"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/utils/ptr"
 	gwapiv1 "sigs.k8s.io/gateway-api/apis/v1"
 
 	egv1a1 "github.com/envoyproxy/gateway/api/v1alpha1"
-	"github.com/envoyproxy/gateway/internal/ir"
 )
 
 func TestBuildLoadBalancer_ClientSideWeightedRoundRobin(t *testing.T) {
 	cswrr := &egv1a1.ClientSideWeightedRoundRobin{
-		EnableOOBLoadReport:                ptrBool(true),
-		OOBReportingPeriod:                 ptrDuration("5s"),
-		BlackoutPeriod:                     ptrDuration("10s"),
-		WeightExpirationPeriod:             ptrDuration("3m"),
-		WeightUpdatePeriod:                 ptrDuration("1s"),
-		ErrorUtilizationPenalty:            ptrFloat32(1.5),
+		BlackoutPeriod:                     ptr.To(gwapiv1.Duration("10s")),
+		WeightExpirationPeriod:             ptr.To(gwapiv1.Duration("3m")),
+		WeightUpdatePeriod:                 ptr.To(gwapiv1.Duration("1s")),
+		ErrorUtilizationPenalty:            ptr.To[float32](1.5),
 		MetricNamesForComputingUtilization: []string{"named_metrics.foo", "cpu_utilization"},
 	}
 
@@ -41,22 +39,10 @@ func TestBuildLoadBalancer_ClientSideWeightedRoundRobin(t *testing.T) {
 	require.NotNil(t, lb.ClientSideWeightedRoundRobin)
 
 	got := lb.ClientSideWeightedRoundRobin
-	require.Equal(t, cswrr.EnableOOBLoadReport, got.EnableOOBLoadReport)
-	require.Equal(t, toMetaV1Duration(t, "5s"), got.OOBReportingPeriod)
-	require.Equal(t, toMetaV1Duration(t, "10s"), got.BlackoutPeriod)
-	require.Equal(t, toMetaV1Duration(t, "3m"), got.WeightExpirationPeriod)
-	require.Equal(t, toMetaV1Duration(t, "1s"), got.WeightUpdatePeriod)
+	require.Equal(t, ptr.To(metav1.Duration{Duration: 10 * time.Second}), got.BlackoutPeriod)
+	require.Equal(t, ptr.To(metav1.Duration{Duration: 3 * time.Minute}), got.WeightExpirationPeriod)
+	require.Equal(t, ptr.To(metav1.Duration{Duration: 1 * time.Second}), got.WeightUpdatePeriod)
 	require.NotNil(t, got.ErrorUtilizationPenalty)
 	require.InDelta(t, 1.5, *got.ErrorUtilizationPenalty, 0.0001)
 	require.Equal(t, []string{"named_metrics.foo", "cpu_utilization"}, got.MetricNamesForComputingUtilization)
 }
-
-func ptrBool(v bool) *bool                   { return &v }
-func ptrFloat32(v float32) *float32          { return &v }
-func ptrDuration(d string) *gwapiv1.Duration { v := gwapiv1.Duration(d); return &v }
-
-func toMetaV1Duration(t *testing.T, d string) *metav1.Duration {
-	dur, err := time.ParseDuration(d)
-	require.NoError(t, err)
-	return ir.MetaV1DurationPtr(dur)
-}

internal/gatewayapi/clustersettings_cswrr_test.go

@@ -2621,8 +2621,6 @@ type Random struct{}
 // ClientSideWeightedRoundRobin load balancer settings
 // +k8s:deepcopy-gen=true
 type ClientSideWeightedRoundRobin struct {
-	EnableOOBLoadReport                *bool            `json:"enableOOBLoadReport,omitempty" yaml:"enableOOBLoadReport,omitempty"`
-	OOBReportingPeriod                 *metav1.Duration `json:"oobReportingPeriod,omitempty" yaml:"oobReportingPeriod,omitempty"`
 	BlackoutPeriod                     *metav1.Duration `json:"blackoutPeriod,omitempty" yaml:"blackoutPeriod,omitempty"`
 	WeightExpirationPeriod             *metav1.Duration `json:"weightExpirationPeriod,omitempty" yaml:"weightExpirationPeriod,omitempty"`
 	WeightUpdatePeriod                 *metav1.Duration `json:"weightUpdatePeriod,omitempty" yaml:"weightUpdatePeriod,omitempty"`

internal/ir/xds.go

@@ -14,6 +14,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/utils/ptr"
 	gwapiv1 "sigs.k8s.io/gateway-api/apis/v1"
 
@@ -1341,7 +1342,9 @@ func TestValidateLoadBalancer(t *testing.T) {
 			name: "client side wrr set",
 			input: LoadBalancer{
 				ClientSideWeightedRoundRobin: &ClientSideWeightedRoundRobin{
-					EnableOOBLoadReport:                ptr.To(false),
+					BlackoutPeriod:                     ptr.To(metav1.Duration{Duration: 30 * time.Second}),
+					WeightExpirationPeriod:             ptr.To(metav1.Duration{Duration: 10 * time.Second}),
+					WeightUpdatePeriod:                 ptr.To(metav1.Duration{Duration: 1 * time.Second}),
 					MetricNamesForComputingUtilization: []string{"named_metrics.foo"},
 				},
 			},

internal/ir/xds_test.go

@@ -403,12 +403,6 @@ func buildXdsCluster(args *xdsClusterArgs) (*buildClusterResult, error) {
 	case args.loadBalancer.ClientSideWeightedRoundRobin != nil:
 		cswrr := &cswrrv3.ClientSideWeightedRoundRobin{}
 		if v := args.loadBalancer.ClientSideWeightedRoundRobin; v != nil {
-			if v.EnableOOBLoadReport != nil {
-				cswrr.EnableOobLoadReport = wrapperspb.Bool(*v.EnableOOBLoadReport)
-			}
-			if v.OOBReportingPeriod != nil && v.OOBReportingPeriod.Duration > 0 {
-				cswrr.OobReportingPeriod = durationpb.New(v.OOBReportingPeriod.Duration)
-			}
 			if v.BlackoutPeriod != nil && v.BlackoutPeriod.Duration > 0 {
 				cswrr.BlackoutPeriod = durationpb.New(v.BlackoutPeriod.Duration)
 			}

internal/ir/zz_generated.deepcopy.go

@@ -534,8 +534,6 @@ func TestBackendTrafficPolicyTarget(t *testing.T) {
 						LoadBalancer: &egv1a1.LoadBalancer{
 							Type: egv1a1.ClientSideWeightedRoundRobinLoadBalancerType,
 							ClientSideWeightedRoundRobin: &egv1a1.ClientSideWeightedRoundRobin{
-								EnableOOBLoadReport:                ptr.To[bool](false),
-								OOBReportingPeriod:                 ptr.To(gwapiv1.Duration("30s")),
 								BlackoutPeriod:                     ptr.To(gwapiv1.Duration("10s")),
 								WeightUpdatePeriod:                 ptr.To(gwapiv1.Duration("10s")),
 								WeightExpirationPeriod:             ptr.To(gwapiv1.Duration("10s")),