Rename enabledFeatureGates to enabledCVOFeatureGates

Author: JoelSpeed

pkg/cvo/cvo.go

@@ -180,19 +180,22 @@ type Operator struct {
 	// to select the manifests that will be applied in the cluster. The starting value cannot be changed in the executing
 	// CVO but the featurechangestopper controller will detect a feature set change in the cluster and shutdown the CVO.
 	// Enforcing featuresets is a standard GA CVO behavior that supports the feature gating functionality across the whole
-	// cluster, as opposed to the enabledFeatureGates which controls what gated behaviors of CVO itself are enabled by
+	// cluster, as opposed to the enabledCVOFeatureGates which controls what gated behaviors of CVO itself are enabled by
 	// the cluster feature gates.
 	// See: https://github.com/openshift/enhancements/blob/master/enhancements/update/cvo-techpreview-manifests.md
 	requiredFeatureSet configv1.FeatureSet
 
-	// enabledFeatureGates is the checker for what gated CVO behaviors are enabled or disabled by specific cluster-level
+	// enabledCVOFeatureGates is the checker for what gated CVO behaviors are enabled or disabled by specific cluster-level
 	// feature gates. It allows multiplexing the cluster-level feature gates to more granular CVO-level gates. Similarly
-	// to the requiredFeatureSet, the enabledFeatureGates cannot be changed in the executing CVO but the
+	// to the requiredFeatureSet, the enabledCVOFeatureGates cannot be changed in the executing CVO but the
 	// featurechangestopper controller will detect when cluster feature gate config changes and shutdown the CVO.
-	enabledFeatureGates featuregates.CvoGateChecker
+	enabledCVOFeatureGates featuregates.CvoGateChecker
 
 	// featureGatesMutex protects access to enabledManifestFeatureGates
-	featureGatesMutex           sync.RWMutex
+	featureGatesMutex sync.RWMutex
+	// enabledManifestFeatureGates is the set of feature gates that are currently enabled for the manifests that are applied to the cluster.
+	// This is the full set of enabled feature gates extracted from the FeatureGate object.
+	// We use this set as a filter to determine which of the manifests from the payload should or should not be applied to the cluster.
 	enabledManifestFeatureGates sets.Set[string]
 
 	clusterProfile string
@@ -267,7 +270,7 @@ func New(
 		injectClusterIdIntoPromQL: injectClusterIdIntoPromQL,
 
 		requiredFeatureSet:          featureSet,
-		enabledFeatureGates:         cvoGates,
+		enabledCVOFeatureGates:      cvoGates,
 		enabledManifestFeatureGates: startingEnabledManifestFeatureGates,
 
 		alwaysEnableCapabilities: alwaysEnableCapabilities,
@@ -1159,18 +1162,18 @@ func (optr *Operator) extractEnabledGates(featureGate *configv1.FeatureGate) set
 	currentVersion := optr.currentVersion().Version
 	if currentVersion == "" {
 		klog.Warningf("Payload has not been initialized yet, using the operator version %s", optr.enabledCVOFeatureGates.DesiredVersion())
-		currentVersion = optr.enabledFeatureGates.DesiredVersion()
+		currentVersion = optr.enabledCVOFeatureGates.DesiredVersion()
 	}
 
 	return featuregates.ExtractEnabledGates(featureGate, currentVersion)
 }
 
 // shouldReconcileCVOConfiguration returns whether the CVO should reconcile its configuration using the API server.
 //
-// enabledFeatureGates must be initialized before the function is called.
+// enabledCVOFeatureGates must be initialized before the function is called.
 func (optr *Operator) shouldReconcileCVOConfiguration() bool {
 	// The relevant CRD and CR are not applied in HyperShift, which configures the CVO via a configuration file
-	return optr.enabledFeatureGates.CVOConfiguration() && !optr.hypershift
+	return optr.enabledCVOFeatureGates.CVOConfiguration() && !optr.hypershift
 }
 
 // shouldReconcileAcceptRisks returns whether the CVO should reconcile spec.desiredUpdate.acceptRisks and populate the

pkg/cvo/cvo_featuregates_test.go

@@ -76,7 +76,7 @@ func TestOperator_extractEnabledGates(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			optr := &Operator{
 				release: tt.release,
-				enabledFeatureGates: fakeRiFlags{
+				enabledCVOFeatureGates: fakeRiFlags{
 					desiredVersion: tt.release.Version,
 				},
 			}
@@ -150,7 +150,7 @@ func TestOperator_updateEnabledFeatureGates(t *testing.T) {
 			optr := &Operator{
 				enabledManifestFeatureGates: sets.New[string]("oldgate"),
 				release:                     configv1.Release{Version: "4.14.0"},
-				enabledFeatureGates: fakeRiFlags{
+				enabledCVOFeatureGates: fakeRiFlags{
 					desiredVersion: "4.14.0",
 				},
 			}

pkg/cvo/cvo_scenarios_test.go

@@ -115,15 +115,15 @@ func setupCVOTest(payloadDir string) (*Operator, map[string]apiruntime.Object, *
 	}
 
 	o := &Operator{
-		namespace:           "test",
-		name:                "version",
-		queue:               workqueue.NewTypedRateLimitingQueueWithConfig[any](workqueue.DefaultTypedControllerRateLimiter[any](), workqueue.TypedRateLimitingQueueConfig[any]{Name: "cvo-loop-test"}),
-		client:              client,
-		enabledFeatureGates: featuregates.DefaultCvoGates("version"),
-		cvLister:            &clientCVLister{client: client},
-		exclude:             "exclude-test",
-		eventRecorder:       record.NewFakeRecorder(100),
-		clusterProfile:      payload.DefaultClusterProfile,
+		namespace:              "test",
+		name:                   "version",
+		queue:                  workqueue.NewTypedRateLimitingQueueWithConfig[any](workqueue.DefaultTypedControllerRateLimiter[any](), workqueue.TypedRateLimitingQueueConfig[any]{Name: "cvo-loop-test"}),
+		client:                 client,
+		enabledCVOFeatureGates: featuregates.DefaultCvoGates("version"),
+		cvLister:               &clientCVLister{client: client},
+		exclude:                "exclude-test",
+		eventRecorder:          record.NewFakeRecorder(100),
+		clusterProfile:         payload.DefaultClusterProfile,
 	}
 
 	dynamicScheme := apiruntime.NewScheme()

pkg/cvo/cvo_test.go

@@ -2275,7 +2275,7 @@ func TestOperator_sync(t *testing.T) {
 				optr.configSync = &fakeSyncRecorder{Returns: expectStatus}
 			}
 			optr.eventRecorder = record.NewFakeRecorder(100)
-			optr.enabledFeatureGates = featuregates.DefaultCvoGates("version")
+			optr.enabledCVOFeatureGates = featuregates.DefaultCvoGates("version")
 
 			ctx := context.Background()
 			err := optr.sync(ctx, optr.queueKey())

pkg/cvo/featuregate_integration_test.go

@@ -164,7 +164,7 @@ func TestFeatureGateEventHandling(t *testing.T) {
 	// Create a simple operator with feature gate management capabilities
 	optr := &Operator{
 		release: configv1.Release{Version: "4.14.0"},
-		enabledFeatureGates: fakeRiFlags{
+		enabledCVOFeatureGates: fakeRiFlags{
 			desiredVersion: "4.14.0",
 		},
 	}

pkg/cvo/status.go

@@ -164,7 +164,7 @@ func (optr *Operator) syncStatus(ctx context.Context, original, config *configv1
 
 	cvUpdated := false
 	// update the config with the latest available updates
-	if updated := optr.getAvailableUpdates().NeedsUpdate(config, optr.enabledFeatureGates.StatusReleaseArchitecture()); updated != nil {
+	if updated := optr.getAvailableUpdates().NeedsUpdate(config, optr.enabledCVOFeatureGates.StatusReleaseArchitecture()); updated != nil {
 		cvUpdated = true
 		config = updated
 	}
@@ -177,7 +177,7 @@ func (optr *Operator) syncStatus(ctx context.Context, original, config *configv1
 		original = config.DeepCopy()
 	}
 
-	updateClusterVersionStatus(&config.Status, status, optr.release, optr.getAvailableUpdates, optr.enabledFeatureGates, validationErrs, optr.shouldReconcileAcceptRisks)
+	updateClusterVersionStatus(&config.Status, status, optr.release, optr.getAvailableUpdates, optr.enabledCVOFeatureGates, validationErrs, optr.shouldReconcileAcceptRisks)
 
 	if klog.V(6).Enabled() {
 		klog.Infof("Apply config: %s", cmp.Diff(original, config))