feature-gates: adding initial structure

This commit introduces the `FeatureGates` struct in the operator's
configuration, enabling a flexible and controlled approach to feature
rollout. The `FeatureGates` configMap allows for the enabling or disabling
of specific features, with a default behaviour based on each feature's
maturity level.

For each new feature, developers need to modify the "default" struct,
just in case users don't have to set their desired behaviour. User's
choice will override default values.

I'm trying to use a simple approach here where we could change
promote/depromote a feature by just changing the comments and the
default values.

Fixes: #KATA-2677

Signed-off-by: Beraldo Leal <[email protected]>

Author: beraldoleal

Dockerfile

@@ -15,6 +15,7 @@ COPY main.go main.go
 COPY api api/
 COPY config config/
 COPY controllers controllers/
+COPY internal internal/
 
 RUN go mod download
 # needed for docker build but not for local builds

bundle-custom.Dockerfile

@@ -10,6 +10,7 @@ COPY go.sum go.sum
 COPY api api/
 COPY config config/
 COPY controllers controllers/
+COPY internal internal/
 
 RUN go mod download
 # needed for docker build but not for local builds

config/samples/featuregates.yaml

@@ -0,0 +1,22 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: osc-feature-gates
+  namespace: openshift-sandboxed-containers-operator
+data:
+  # timeTravel allows navigating through cluster states across time.
+  # It is useful for scenarios where you want to view historical data or
+  # predict future states based on current trends. Default is "false".
+  # timeTravel: "false"
+
+  # quantumEntanglementSync enables instant state consistency across clusters
+  # using principles of quantum mechanics. This advanced feature ensures
+  # data is synchronized across different locations without traditional
+  # network latency. Default is "false".
+  # quantumEntanglementSync: "false"
+
+  # autoHealingWithAI employs artificial intelligence to automatically
+  # detect and resolve cluster issues. It leverages machine learning algorithms
+  # to predict potential problems before they occur, ensuring high availability.
+  # Default is "true".
+  # autoHealingWithAI: "true"

controllers/openshift_controller.go

@@ -35,6 +35,7 @@ import (
 	mcfgv1 "github.com/openshift/machine-config-operator/pkg/apis/machineconfiguration.openshift.io/v1"
 	mcfgconsts "github.com/openshift/machine-config-operator/pkg/daemon/constants"
 	kataconfigurationv1 "github.com/openshift/sandboxed-containers-operator/api/v1"
+	"github.com/openshift/sandboxed-containers-operator/internal/featuregates"
 	corev1 "k8s.io/api/core/v1"
 	nodeapi "k8s.io/api/node/v1"
 	k8serrors "k8s.io/apimachinery/pkg/api/errors"
@@ -59,7 +60,8 @@ type KataConfigOpenShiftReconciler struct {
 	Log    logr.Logger
 	Scheme *runtime.Scheme
 
-	kataConfig *kataconfigurationv1.KataConfig
+	kataConfig   *kataconfigurationv1.KataConfig
+	FeatureGates *featuregates.FeatureGates
 }
 
 const (
@@ -120,6 +122,10 @@ func (r *KataConfigOpenShiftReconciler) Reconcile(ctx context.Context, req ctrl.
 		return ctrl.Result{}, err
 	}
 
+	if r.FeatureGates.IsEnabled(ctx, "timeTravel") {
+		r.Log.Info("TimeTravel feature is enabled. Performing feature-specific logic...")
+	}
+
 	return func() (ctrl.Result, error) {
 
 		// k8s resource correctness checking on creation/modification
@@ -1329,6 +1335,45 @@ func logMcpChange(log logr.Logger, statusOld, statusNew mcfgv1.MachineConfigPool
 	}
 }
 
+type ConfigMapEventHandler struct {
+	reconciler *KataConfigOpenShiftReconciler
+}
+
+func (eh *ConfigMapEventHandler) isConfigMapRelevant(configMap *corev1.ConfigMap) bool {
+	if eh.reconciler == nil || eh.reconciler.FeatureGates == nil {
+		return false
+	}
+	relevantNamespace := configMap.Namespace == eh.reconciler.FeatureGates.Namespace
+	relevantName := configMap.Name == eh.reconciler.FeatureGates.ConfigMapName
+	return relevantNamespace && relevantName
+}
+
+func (eh *ConfigMapEventHandler) Create(ctx context.Context, evt event.CreateEvent, queue workqueue.RateLimitingInterface) {
+	configMap, ok := evt.Object.(*corev1.ConfigMap)
+	if !ok || !eh.isConfigMapRelevant(configMap) {
+		return
+	}
+	queue.Add(eh.reconciler.makeReconcileRequest())
+}
+
+func (eh *ConfigMapEventHandler) Update(ctx context.Context, evt event.UpdateEvent, queue workqueue.RateLimitingInterface) {
+	configMap, ok := evt.ObjectNew.(*corev1.ConfigMap)
+	if !ok || !eh.isConfigMapRelevant(configMap) {
+		return
+	}
+}
+
+func (eh *ConfigMapEventHandler) Delete(ctx context.Context, evt event.DeleteEvent, queue workqueue.RateLimitingInterface) {
+	configMap, ok := evt.Object.(*corev1.ConfigMap)
+	if !ok || !eh.isConfigMapRelevant(configMap) {
+		return
+	}
+	queue.Add(eh.reconciler.makeReconcileRequest())
+}
+
+func (eh *ConfigMapEventHandler) Generic(ctx context.Context, evt event.GenericEvent, queue workqueue.RateLimitingInterface) {
+}
+
 type McpEventHandler struct {
 	reconciler *KataConfigOpenShiftReconciler
 }
@@ -1572,7 +1617,10 @@ func (r *KataConfigOpenShiftReconciler) SetupWithManager(mgr ctrl.Manager) error
 		Watches(
 			&corev1.Node{},
 			&NodeEventHandler{r}).
-		Complete(r)
+		Watches(
+			&corev1.ConfigMap{},
+			&ConfigMapEventHandler{r},
+		).Complete(r)
 }
 
 func (r *KataConfigOpenShiftReconciler) getNodes() (*corev1.NodeList, error) {

internal/featuregates/featuregates.go

@@ -0,0 +1,44 @@
+package featuregates
+
+import (
+	"context"
+	corev1 "k8s.io/api/core/v1"
+	"log"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+type FeatureGates struct {
+	Client        client.Client
+	Namespace     string
+	ConfigMapName string
+}
+
+var DefaultFeatureGates = map[string]bool{
+	"timeTravel":              false,
+	"quantumEntanglementSync": false,
+	"autoHealingWithAI":       true,
+}
+
+func (fg *FeatureGates) IsEnabled(ctx context.Context, feature string) bool {
+	if fg == nil {
+		return false
+	}
+	cfgMap := &corev1.ConfigMap{}
+	err := fg.Client.Get(ctx,
+		client.ObjectKey{Name: fg.ConfigMapName, Namespace: fg.Namespace},
+		cfgMap)
+
+	if err != nil {
+		log.Printf("Error fetching feature gates: %v", err)
+	} else {
+		if value, exists := cfgMap.Data[feature]; exists {
+			return value == "true"
+		}
+	}
+
+	defaultValue, exists := DefaultFeatureGates[feature]
+	if exists {
+		return defaultValue
+	}
+	return false
+}

main.go

@@ -54,6 +54,7 @@ import (
 
 	kataconfigurationv1 "github.com/openshift/sandboxed-containers-operator/api/v1"
 	"github.com/openshift/sandboxed-containers-operator/controllers"
+	"github.com/openshift/sandboxed-containers-operator/internal/featuregates"
 	// +kubebuilder:scaffold:imports
 )
 
@@ -142,6 +143,11 @@ func main() {
 			Client: mgr.GetClient(),
 			Log:    ctrl.Log.WithName("controllers").WithName("KataConfig"),
 			Scheme: mgr.GetScheme(),
+			FeatureGates: &featuregates.FeatureGates{
+				Client:        mgr.GetClient(),
+				Namespace:     OperatorNamespace,
+				ConfigMapName: "osc-feature-gates",
+			},
 		}).SetupWithManager(mgr); err != nil {
 			setupLog.Error(err, "unable to create KataConfig controller for OpenShift cluster", "controller", "KataConfig")
 			os.Exit(1)