WIP

Author: petr-muller

pkg/start/start.go

@@ -189,17 +189,42 @@ func (o *Options) Run(ctx context.Context) error {
 		return err
 	}
 
+	clusterVersionConfigInformerFactory, configInformerFactory := o.prepareConfigInformerFactories(cb)
+	_, _, err = o.processInitialFeatureGate(ctx, configInformerFactory)
+	if err != nil {
+		return fmt.Errorf("error processing feature gates: %w", err)
+	}
+
+	// initialize the controllers and attempt to load the payload information
+	controllerCtx, err := o.NewControllerContext(cb, clusterVersionConfigInformerFactory, configInformerFactory)
+	if err != nil {
+		return err
+	}
+	o.leaderElection = getLeaderElectionConfig(ctx, cb.RestConfig(defaultQPS))
+	o.run(ctx, controllerCtx, lock, cb.RestConfig(defaultQPS), cb.RestConfig(highQPS))
+	return nil
+}
+
+func (o *Options) prepareConfigInformerFactories(cb *ClientBuilder) (configinformers.SharedInformerFactory, configinformers.SharedInformerFactory) {
+	client := cb.ClientOrDie("shared-informer")
+	filterByName := func(opts *metav1.ListOptions) { opts.FieldSelector = fmt.Sprintf("metadata.name=%s", o.Name) }
+	clusterVersionConfigInformerFactory := configinformers.NewSharedInformerFactoryWithOptions(client, resyncPeriod(o.ResyncInterval), configinformers.WithTweakListOptions(filterByName))
+	configInformerFactory := configinformers.NewSharedInformerFactory(client, resyncPeriod(o.ResyncInterval))
+
+	return clusterVersionConfigInformerFactory, configInformerFactory
+}
+
+// getOcpVersion peeks at the local release metadata to determine the version of OCP this CVO belongs to. This assumes
+// the CVO is executing in a container from the payload image. This does not and should not fully load whole payload
+// content, that is only loaded later once leader lease is acquired. Here we should only read as little data as possible
+// to determine the version so we can establish enabled feature gate checker for all following code.
+func (o *Options) getOcpVersion() string {
 	payloadRoot := payload.DefaultRootPath
 	if o.PayloadOverride != "" {
 		payloadRoot = payload.RootPath(o.PayloadOverride)
 	}
 
 	cvoOcpVersion := "0.0.1-snapshot"
-	// Peek at the local release metadata to determine the version of OCP this CVO belongs to. This assumes the CVO is
-	// executing in a container from the payload image. Full payload content is only read later once leader lease is
-	// acquired, and here we should only read as little data as possible to determine the version so we can establish
-	// enabled feature gate checker for all following code.
-	//
 	// We cannot refuse to start CVO if for some reason we cannot determine the OCP version on startup from the local
 	// release metadata. The only consequence is we fail to determine enabled/disabled feature gates and will have to use
 	// some defaults.
@@ -214,25 +239,60 @@ func (o *Options) Run(ctx context.Context) error {
 		klog.Infof("Determined OCP version for this CVO: %q", cvoOcpVersion)
 	}
 
-	clusterVersionConfigInformerFactory, configInformerFactory := o.prepareConfigInformerFactories(cb)
+	return cvoOcpVersion
+}
 
-	// initialize the controllers and attempt to load the payload information
-	controllerCtx, err := o.NewControllerContext(cb, clusterVersionConfigInformerFactory, configInformerFactory)
-	if err != nil {
-		return err
+func (o *Options) processInitialFeatureGate(ctx context.Context, configInformerFactory configinformers.SharedInformerFactory) (configv1.FeatureSet, *featuregates.CvoGates, error) {
+	featureGates := configInformerFactory.Config().V1().FeatureGates().Lister()
+	configInformerFactory.Start(ctx.Done())
+	configInformerFactory.WaitForCacheSync(ctx.Done())
+
+	var startingFeatureSet configv1.FeatureSet
+	var clusterFeatureGate *configv1.FeatureGate
+
+	cvoOcpVersion := o.getOcpVersion()
+	cvoGates := featuregates.DefaultCvoGates(cvoOcpVersion)
+
+	// client-go automatically retries some network blip errors on GETs for 30s by default, and we want to
+	// retry the remaining ones ourselves. If we fail longer than that, the operator won't be able to do work
+	// anyway. Return the error and crashloop.
+	//
+	// We implement the timeout with a context because the timeout in PollImmediateWithContext does not behave
+	// well when ConditionFunc takes longer time to execute, like here where the GET can be retried by client-go
+	var lastError error
+	if err := wait.PollUntilContextTimeout(context.Background(), 2*time.Second, 25*time.Second, true, func(ctx context.Context) (bool, error) {
+		gate, fgErr := featureGates.Get("cluster")
+		switch {
+		case apierrors.IsNotFound(fgErr):
+			// if we have no featuregates, then the cluster is using the default featureset, which is "".
+			// This excludes everything that could possibly depend on a different feature set.
+			startingFeatureSet = ""
+			klog.Infof("FeatureGate not found in cluster, will assume default feature set %q at startup", startingFeatureSet)
+			return true, nil
+		case fgErr != nil:
+			lastError = fgErr
+			klog.Warningf("Failed to get FeatureGate from cluster: %v", fgErr)
+			return false, nil
+		default:
+			clusterFeatureGate = gate
+			startingFeatureSet = gate.Spec.FeatureSet
+			cvoGates = featuregates.CvoGatesFromFeatureGate(clusterFeatureGate, cvoOcpVersion)
+			klog.Infof("FeatureGate found in cluster, using its feature set %q at startup", startingFeatureSet)
+			return true, nil
+		}
+	}); err != nil {
+		if lastError != nil {
+			return "", nil, lastError
+		}
+		return "", nil, err
 	}
-	o.leaderElection = getLeaderElectionConfig(ctx, cb.RestConfig(defaultQPS))
-	o.run(ctx, controllerCtx, lock, cb.RestConfig(defaultQPS), cb.RestConfig(highQPS))
-	return nil
-}
 
-func (o *Options) prepareConfigInformerFactories(cb *ClientBuilder) (configinformers.SharedInformerFactory, configinformers.SharedInformerFactory) {
-	client := cb.ClientOrDie("shared-informer")
-	filterByName := func(opts *metav1.ListOptions) { opts.FieldSelector = fmt.Sprintf("metadata.name=%s", o.Name) }
-	clusterVersionConfigInformerFactory := configinformers.NewSharedInformerFactoryWithOptions(client, resyncPeriod(o.ResyncInterval), configinformers.WithTweakListOptions(filterByName))
-	configInformerFactory := configinformers.NewSharedInformerFactory(client, resyncPeriod(o.ResyncInterval))
+	if cvoGates.UnknownVersion() {
+		klog.Warningf("CVO features for version %s could not be detected from FeatureGate; will use defaults plus special UnknownVersion feature gate", cvoOcpVersion)
+	}
+	klog.Infof("CVO features for version %s enabled at startup: %+v", cvoOcpVersion, cvoGates)
 
-	return clusterVersionConfigInformerFactory, configInformerFactory
+	return startingFeatureSet, &cvoGates, nil
 }
 
 // run launches a number of goroutines to handle manifest application,