read featuregates from the shared API value

Author: deads2k

Diff for: pkg/cmd/start/start.go

@@ -2,11 +2,17 @@ package start
 
 import (
 	"context"
+	"fmt"
+	"github.com/openshift/library-go/pkg/operator/events"
 	"math/rand"
 	"os"
 	"time"
 
+	v1 "github.com/openshift/api/config/v1"
+	configv1client "github.com/openshift/client-go/config/clientset/versioned"
+	configv1informers "github.com/openshift/client-go/config/informers/externalversions"
 	"github.com/openshift/library-go/pkg/controller/controllercmd"
+	"github.com/openshift/library-go/pkg/operator/configobserver/featuregates"
 	"github.com/openshift/library-go/pkg/serviceability"
 
 	"github.com/spf13/cobra"
@@ -113,6 +119,41 @@ func runGather(operator *controller.GatherJob, cfg *controllercmd.ControllerComm
 		protoConfig.ContentType = "application/vnd.kubernetes.protobuf"
 
 		ctx, cancel := context.WithTimeout(context.Background(), operator.Interval)
+
+		// before calling the Gather logic, this command must check the featuregate status.
+		configClient, err := configv1client.NewForConfig(clientConfig)
+		if err != nil {
+			klog.Exit("error: building client: %v", err)
+		}
+		configInformers := configv1informers.NewSharedInformerFactory(configClient, 10*time.Minute)
+
+		desiredVersion := os.Getenv("RELEASE_VERSION")
+		missingVersion := "0.0.1-snapshot"
+
+		// By default, this will exit(0) the process if the featuregates ever change to a different set of values.
+		featureGateAccessor := featuregates.NewFeatureGateAccess(
+			desiredVersion, missingVersion,
+			configInformers.Config().V1().ClusterVersions(), configInformers.Config().V1().FeatureGates(),
+			events.NewLoggingEventRecorder("insights-gather"),
+		)
+		go featureGateAccessor.Run(ctx)
+		go configInformers.Start(ctx.Done())
+
+		select {
+		case <-featureGateAccessor.InitialFeatureGatesObserved():
+			featureGates, _ := featureGateAccessor.CurrentFeatureGates()
+			klog.Infof("FeatureGates initialized: knownFeatureGates=%v", featureGates.KnownFeatures())
+		case <-time.After(1 * time.Minute):
+			klog.Errorf("timed out waiting for FeatureGate detection")
+			klog.Exit(fmt.Errorf("timed out waiting for FeatureGate detection"))
+		}
+
+		featureGates, err := featureGateAccessor.CurrentFeatureGates()
+		if err != nil {
+			klog.Exit(err)
+		}
+		operator.InsightsConfigAPIEnabled = featureGates.Enabled(v1.FeatureGateInsightsConfigAPI)
+
 		err = operator.Gather(ctx, clientConfig, protoConfig)
 		if err != nil {
 			klog.Error(err)

Diff for: pkg/controller/gather_job.go

@@ -26,6 +26,7 @@ import (
 // GatherJob is the type responsible for controlling a non-periodic Gather execution
 type GatherJob struct {
 	config.Controller
+	InsightsConfigAPIEnabled bool
 }
 
 // Gather runs a single gather and stores the generated archive, without uploading it.
@@ -51,12 +52,8 @@ func (d *GatherJob) Gather(ctx context.Context, kubeConfig, protoKubeConfig *res
 		protoKubeConfig, kubeConfig, d.Impersonate,
 	)
 
-	tpEnabled, err := isTechPreviewEnabled(ctx, configClient)
-	if err != nil {
-		klog.Error("can't read cluster feature gates: %v", err)
-	}
 	var gatherConfig v1alpha1.GatherConfig
-	if tpEnabled {
+	if d.InsightsConfigAPIEnabled {
 		insightsDataGather, err := configClient.ConfigV1alpha1().InsightsDataGathers().Get(ctx, "cluster", metav1.GetOptions{}) //nolint: govet
 		if err != nil {
 			return err

Diff for: pkg/controller/operator.go

@@ -66,6 +66,7 @@ func (s *Operator) Run(ctx context.Context, controller *controllercmd.Controller
 	if err != nil {
 		return err
 	}
+	configInformers := configv1informers.NewSharedInformerFactory(configClient, 10*time.Minute)
 
 	operatorClient, err := operatorv1client.NewForConfig(controller.KubeConfig)
 	if err != nil {
@@ -83,52 +84,45 @@ func (s *Operator) Run(ctx context.Context, controller *controllercmd.Controller
 		return err
 	}
 
-	desiredVersion := config.OperatorReleaseVersion
+	desiredVersion := os.Getenv("RELEASE_VERSION")
 	missingVersion := "0.0.1-snapshot"
 
 	// By default, this will exit(0) the process if the featuregates ever change to a different set of values.
 	featureGateAccessor := featuregates.NewFeatureGateAccess(
 		desiredVersion, missingVersion,
 		configInformers.Config().V1().ClusterVersions(), configInformers.Config().V1().FeatureGates(),
-		eventRecorder,
+		controller.EventRecorder,
 	)
 	go featureGateAccessor.Run(ctx)
-	go configInformers.Start(config.Stop)
+	go configInformers.Start(ctx.Done())
 
 	select {
 	case <-featureGateAccessor.InitialFeatureGatesObserved():
 		featureGates, _ := featureGateAccessor.CurrentFeatureGates()
-		log.Info("FeatureGates initialized", "knownFeatures", featureGates.KnownFeatures())
+		klog.Infof("FeatureGates initialized: knownFeatureGates=%v", featureGates.KnownFeatures())
 	case <-time.After(1 * time.Minute):
-		log.Error(nil, "timed out waiting for FeatureGate detection")
-		return nil, fmt.Errorf("timed out waiting for FeatureGate detection")
+		klog.Errorf("timed out waiting for FeatureGate detection")
+		return fmt.Errorf("timed out waiting for FeatureGate detection")
 	}
 
 	featureGates, err := featureGateAccessor.CurrentFeatureGates()
 	if err != nil {
-		return nil, err
+		return err
 	}
-	// example of future featuregate read and usage to set a variable to pass to a controller
-	gatewayAPIEnabled := featureGates.Enabled(configv1.FeatureGateGatewayAPI)
+	insightsConfigAPIEnabled := featureGates.Enabled(v1.FeatureGateInsightsConfigAPI)
 
 	// ensure the insight snapshot directory exists
 	if _, err = os.Stat(s.StoragePath); err != nil && os.IsNotExist(err) {
 		if err = os.MkdirAll(s.StoragePath, 0777); err != nil {
 			return fmt.Errorf("can't create --path: %v", err)
 		}
 	}
-	tpEnabled, err := isTechPreviewEnabled(ctx, configClient)
-	if err != nil {
-		klog.Error("can't read cluster feature gates: %v", err)
-	}
 	var apiConfigObserver configobserver.APIConfigObserver
-	if tpEnabled {
-		configInformers := configv1informers.NewSharedInformerFactory(configClient, 10*time.Minute)
+	if insightsConfigAPIEnabled {
 		apiConfigObserver, err = configobserver.NewAPIConfigObserver(gatherKubeConfig, controller.EventRecorder, configInformers)
 		if err != nil {
 			return err
 		}
-		configInformers.Start(ctx.Done())
 		go apiConfigObserver.Run(ctx, 1)
 	}
 
@@ -180,7 +174,7 @@ func (s *Operator) Run(ctx context.Context, controller *controllercmd.Controller
 	initialCheckTimeout := s.Controller.Interval / 24
 	initialCheckInterval := 20 * time.Second
 	baseInitialDelay := s.Controller.Interval / 12
-	err = wait.PollImmediate(initialCheckInterval, wait.Jitter(initialCheckTimeout, 0.1), isRunning(ctx, gatherKubeConfig))
+	err = wait.PollUntilContextTimeout(ctx, initialCheckInterval, wait.Jitter(initialCheckTimeout, 0.1), true, isRunning(gatherKubeConfig))
 	if err != nil {
 		initialDelay = wait.Jitter(baseInitialDelay, 0.5)
 		klog.Infof("Unable to check insights-operator pod status. Setting initial delay to %s", initialDelay)
@@ -221,8 +215,8 @@ func (s *Operator) Run(ctx context.Context, controller *controllercmd.Controller
 	return nil
 }
 
-func isRunning(ctx context.Context, kubeConfig *rest.Config) wait.ConditionFunc {
-	return func() (bool, error) {
+func isRunning(kubeConfig *rest.Config) wait.ConditionWithContextFunc {
+	return func(ctx context.Context) (bool, error) {
 		c, err := corev1client.NewForConfig(kubeConfig)
 		if err != nil {
 			return false, err
@@ -258,12 +252,3 @@ func initiateSCAController(ctx context.Context,
 	scaController := sca.New(ctx, kubeClient.CoreV1(), configObserver, insightsClient)
 	return scaController
 }
-
-// featureEnabled checks if the feature is enabled in the "cluster" FeatureGate
-func isTechPreviewEnabled(ctx context.Context, client *configv1client.Clientset) (bool, error) {
-	fg, err := client.ConfigV1().FeatureGates().Get(ctx, "cluster", metav1.GetOptions{})
-	if err != nil {
-		return false, err
-	}
-	return fg.Spec.FeatureSet == v1.TechPreviewNoUpgrade, nil
-}