Merge pull request #23 from thschue/main

feat: clean up configmaps

Author: thschue

Dockerfile

@@ -16,6 +16,7 @@ COPY main.go main.go
 COPY apis/ apis/
 COPY webhooks/ webhooks/
 COPY controllers/ controllers/
+COPY pkg/ pkg/
 
 # Build
 RUN CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -a -o manager main.go

config/manager/manager.yaml

@@ -31,7 +31,8 @@ spec:
         - /manager
         args:
         - --leader-elect
-        image: controller:latest
+        imagePullPolicy: Always
+        image: controller:main
         name: manager
         securityContext:
           allowPrivilegeEscalation: false

controllers/featureflagconfiguration_controller.go

@@ -19,6 +19,7 @@ package controllers
 import (
 	"context"
 	"github.com/go-logr/logr"
+	"github.com/open-feature/open-feature-operator/pkg/utils"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/client-go/tools/record"
@@ -83,15 +84,15 @@ func (r *FeatureFlagConfigurationReconciler) Reconcile(ctx context.Context, req
 		// The object is not being deleted, so if it does not have our finalizer,
 		// then lets add the finalizer and update the object. This is equivalent
 		// registering our finalizer.
-		if !ContainsString(ffconf.GetFinalizers(), finalizerName) {
+		if !utils.ContainsString(ffconf.GetFinalizers(), finalizerName) {
 			controllerutil.AddFinalizer(ffconf, finalizerName)
 			if err := r.Update(ctx, ffconf); err != nil {
 				return r.finishReconcile(err, false)
 			}
 		}
 	} else {
 		// The object is being deleted
-		if ContainsString(ffconf.GetFinalizers(), finalizerName) {
+		if utils.ContainsString(ffconf.GetFinalizers(), finalizerName) {
 			controllerutil.RemoveFinalizer(ffconf, finalizerName)
 			if err := r.Update(ctx, ffconf); err != nil {
 				return ctrl.Result{}, err
@@ -116,8 +117,23 @@ func (r *FeatureFlagConfigurationReconciler) Reconcile(ctx context.Context, req
 		}
 	}
 
-	// Update ConfigMaps
 	for _, cm := range ffConfigMapList {
+		// Append OwnerReference if not set
+		if !r.featureFlagResourceIsOwner(ffconf, cm) {
+			r.Log.Info("Setting owner reference for " + cm.Name)
+			cm.OwnerReferences = append(cm.OwnerReferences, utils.GetFfReference(ffconf))
+			err := r.Client.Update(ctx, &cm)
+			if err != nil {
+				return r.finishReconcile(err, true)
+			}
+		} else if len(cm.OwnerReferences) == 1 {
+			// Delete ConfigMap if the Controller is the only reference
+			r.Log.Info("Deleting configmap " + cm.Name)
+			err := r.Client.Delete(ctx, &cm)
+			return r.finishReconcile(err, true)
+		}
+		// Update ConfigMap Spec
+		r.Log.Info("Updating ConfigMap Spec " + cm.Name)
 		cm.Data = map[string]string{
 			"config.yaml": ffconf.Spec.FeatureFlagSpec,
 		}
@@ -126,6 +142,7 @@ func (r *FeatureFlagConfigurationReconciler) Reconcile(ctx context.Context, req
 			return r.finishReconcile(err, true)
 		}
 	}
+
 	return r.finishReconcile(nil, false)
 }
 
@@ -137,15 +154,6 @@ func (r *FeatureFlagConfigurationReconciler) SetupWithManager(mgr ctrl.Manager)
 		Complete(r)
 }
 
-func ContainsString(slice []string, s string) bool {
-	for _, item := range slice {
-		if item == s {
-			return true
-		}
-	}
-	return false
-}
-
 func (r *FeatureFlagConfigurationReconciler) finishReconcile(err error, requeueImmediate bool) (ctrl.Result, error) {
 	if err != nil {
 		interval := reconcileErrorInterval
@@ -162,3 +170,12 @@ func (r *FeatureFlagConfigurationReconciler) finishReconcile(err error, requeueI
 	r.Log.Info("Finished Reconciling " + crdName)
 	return ctrl.Result{Requeue: true, RequeueAfter: interval}, nil
 }
+
+func (r *FeatureFlagConfigurationReconciler) featureFlagResourceIsOwner(ff *configv1alpha1.FeatureFlagConfiguration, cm corev1.ConfigMap) bool {
+	for _, cmOwner := range cm.OwnerReferences {
+		if cmOwner.UID == utils.GetFfReference(ff).UID {
+			return true
+		}
+	}
+	return false
+}

go.mod

@@ -73,4 +73,4 @@ require (
 	sigs.k8s.io/json v0.0.0-20211020170558-c049b76a60c6 // indirect
 	sigs.k8s.io/structured-merge-diff/v4 v4.2.0 // indirect
 	sigs.k8s.io/yaml v1.3.0 // indirect
-)
+)

pkg/utils/utils.go

@@ -0,0 +1,35 @@
+package utils
+
+import (
+	configv1alpha1 "github.com/open-feature/open-feature-operator/apis/core/v1alpha1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func TrueVal() *bool {
+	b := true
+	return &b
+}
+
+func FalseVal() *bool {
+	b := false
+	return &b
+}
+
+func ContainsString(slice []string, s string) bool {
+	for _, item := range slice {
+		if item == s {
+			return true
+		}
+	}
+	return false
+}
+
+func GetFfReference(ff *configv1alpha1.FeatureFlagConfiguration) metav1.OwnerReference {
+	return metav1.OwnerReference{
+		APIVersion: ff.APIVersion,
+		Kind:       ff.Kind,
+		Name:       ff.Name,
+		UID:        ff.UID,
+		Controller: TrueVal(),
+	}
+}

webhooks/mutating_admission_webhook.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"github.com/go-logr/logr"
 	configv1alpha1 "github.com/open-feature/open-feature-operator/apis/core/v1alpha1"
+	"github.com/open-feature/open-feature-operator/pkg/utils"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -28,7 +29,6 @@ type PodMutator struct {
 
 // PodMutator adds an annotation to every incoming pods.
 func (m *PodMutator) Handle(ctx context.Context, req admission.Request) admission.Response {
-
 	pod := &corev1.Pod{}
 	err := m.decoder.Decode(req, pod)
 	if err != nil {
@@ -57,24 +57,25 @@ func (m *PodMutator) Handle(ctx context.Context, req admission.Request) admissio
 	// Check for ConfigMap and create it if it doesn't exist
 	cm := corev1.ConfigMap{}
 	if err := m.Client.Get(ctx, client.ObjectKey{Name: val, Namespace: req.Namespace}, &cm); errors.IsNotFound(err) {
-		err := m.CreateConfigMap(ctx, val, req.Namespace, pod)
+		err := m.createConfigMap(ctx, val, req.Namespace, pod)
 		if err != nil {
 			m.Log.V(1).Info(fmt.Sprintf("failed to create config map %s error: %s", val, err.Error()))
 			return admission.Errored(http.StatusInternalServerError, err)
 		}
 	}
 
-	if !CheckOwnerReference(pod, cm) {
+	// Add owner reference of the pod's owner
+	if !podOwnerIsOwner(pod, cm) {
 		reference := pod.OwnerReferences[0]
-		reference.Controller = m.falseVal()
+		reference.Controller = utils.FalseVal()
 		cm.OwnerReferences = append(cm.OwnerReferences, reference)
 		err := m.Client.Update(ctx, &cm)
 		if err != nil {
 			m.Log.V(1).Info(fmt.Sprintf("failed to update owner reference for %s error: %s", val, err.Error()))
 		}
 	}
 
-	marshaledPod, err := m.InjectSidecar(pod, val)
+	marshaledPod, err := m.injectSidecar(pod, val)
 	if err != nil {
 		return admission.Errored(http.StatusInternalServerError, err)
 	}
@@ -91,50 +92,53 @@ func (m *PodMutator) InjectDecoder(d *admission.Decoder) error {
 	return nil
 }
 
-func CheckOwnerReference(pod *corev1.Pod, cm corev1.ConfigMap) bool {
+func podOwnerIsOwner(pod *corev1.Pod, cm corev1.ConfigMap) bool {
 	for _, cmOwner := range cm.OwnerReferences {
 		for _, podOwner := range pod.OwnerReferences {
-			if cmOwner == podOwner {
+			if cmOwner.UID == podOwner.UID {
 				return true
 			}
 		}
 	}
 	return false
 }
 
-func (m *PodMutator) CreateConfigMap(ctx context.Context, name string, namespace string, pod *corev1.Pod) error {
+func (m *PodMutator) createConfigMap(ctx context.Context, name string, namespace string, pod *corev1.Pod) error {
 	m.Log.V(1).Info(fmt.Sprintf("Creating configmap %s", name))
-	reference := pod.OwnerReferences[0]
-	reference.Controller = m.falseVal()
+	references := []metav1.OwnerReference{
+		pod.OwnerReferences[0],
+	}
+	references[0].Controller = utils.FalseVal()
+	ff := m.getFeatureFlag(ctx, name, namespace)
+	if ff.Name != "" {
+		references = append(references, utils.GetFfReference(&ff))
+	}
 
-	spec := m.GetFeatureFlagSpec(ctx, name, namespace)
 	cm := corev1.ConfigMap{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      name,
 			Namespace: namespace,
 			Annotations: map[string]string{
 				"openfeature.dev/featureflagconfiguration": name,
 			},
-			OwnerReferences: []metav1.OwnerReference{
-				reference,
-			},
+			OwnerReferences: references,
 		},
 		Data: map[string]string{
-			"config.yaml": spec.FeatureFlagSpec,
+			"config.yaml": ff.Spec.FeatureFlagSpec,
 		},
 	}
 	return m.Client.Create(ctx, &cm)
 }
 
-func (m *PodMutator) GetFeatureFlagSpec(ctx context.Context, name string, namespace string) configv1alpha1.FeatureFlagConfigurationSpec {
+func (m *PodMutator) getFeatureFlag(ctx context.Context, name string, namespace string) configv1alpha1.FeatureFlagConfiguration {
 	ffConfig := configv1alpha1.FeatureFlagConfiguration{}
 	if err := m.Client.Get(ctx, client.ObjectKey{Name: name, Namespace: namespace}, &ffConfig); errors.IsNotFound(err) {
-		return configv1alpha1.FeatureFlagConfigurationSpec{}
+		return configv1alpha1.FeatureFlagConfiguration{}
 	}
-	return ffConfig.Spec
+	return ffConfig
 }
 
-func (m *PodMutator) InjectSidecar(pod *corev1.Pod, configMap string) ([]byte, error) {
+func (m *PodMutator) injectSidecar(pod *corev1.Pod, configMap string) ([]byte, error) {
 	m.Log.V(1).Info(fmt.Sprintf("Creating sidecar for pod %s/%s", pod.Namespace, pod.Name))
 	// Inject the agent
 	pod.Spec.Volumes = append(pod.Spec.Volumes, corev1.Volume{
@@ -162,8 +166,3 @@ func (m *PodMutator) InjectSidecar(pod *corev1.Pod, configMap string) ([]byte, e
 	})
 	return json.Marshal(pod)
 }
-
-func (m *PodMutator) falseVal() *bool {
-	b := false
-	return &b
-}