quick and dirty

Author: awgreene

cmd/olm/manager.go

@@ -91,6 +91,19 @@ func Manager(ctx context.Context, debug bool) (ctrl.Manager, error) {
 		return nil, err
 	}
 
+	olmConfigReconciler, err := operators.NewOLMConfigReconcilerReconciler(
+		mgr.GetClient(),
+		ctrl.Log.WithName("controllers").WithName("olmconfig"),
+		mgr.GetScheme(),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	if err = olmConfigReconciler.SetupWithManager(mgr); err != nil {
+		return nil, err
+	}
+
 	if feature.Gate.Enabled(feature.OperatorLifecycleManagerV1) {
 		// Setup a new controller to reconcile Operators
 		operatorReconciler, err := operators.NewOperatorReconciler(

pkg/controller/operators/olmconfig_controller.go

@@ -0,0 +1,199 @@
+package operators
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/go-logr/logr"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/selection"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/builder"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/event"
+	"sigs.k8s.io/controller-runtime/pkg/predicate"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+
+	operatorsv1 "github.com/operator-framework/api/pkg/operators/v1"
+	"github.com/operator-framework/api/pkg/operators/v1alpha1"
+	operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1"
+	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm"
+)
+
+// OLMConfigReconciler reconciles an OperatorCondition object.
+type OLMConfigReconciler struct {
+	client.Client
+	log logr.Logger
+}
+
+// +kubebuilder:rbac:groups=operators.coreos.com,resources=olmconfig,verbs=get;list;update;patch;delete
+// +kubebuilder:rbac:groups=operators.coreos.com,resources=olmconfig/status,verbs=update;patch
+
+// SetupWithManager adds the OLMConfigReconciler reconciler to the given controller manager.
+func (r *OLMConfigReconciler) SetupWithManager(mgr ctrl.Manager) error {
+	p := predicate.Funcs{
+		CreateFunc: func(e event.CreateEvent) bool {
+			if e.Object.GetName() != "cluster" {
+				return false
+			}
+			return true
+		},
+		DeleteFunc: func(e event.DeleteEvent) bool {
+			if e.Object.GetName() != "cluster" {
+				return false
+			}
+			return true
+		},
+		UpdateFunc: func(e event.UpdateEvent) bool {
+			if e.ObjectOld.GetName() != "cluster" {
+				return false
+			}
+			return true
+		},
+		GenericFunc: func(e event.GenericEvent) bool {
+			if e.Object.GetName() != "cluster" {
+				return false
+			}
+			return true
+		},
+	}
+
+	return ctrl.NewControllerManagedBy(mgr).
+		For(&operatorsv1.OLMConfig{}, builder.WithPredicates(p)).
+		Complete(r)
+}
+
+// NewOLMConfigReconcilerReconciler constructs and returns an OLMConfigReconciler.
+// As a side effect, the given scheme has operator discovery types added to it.
+func NewOLMConfigReconcilerReconciler(cli client.Client, log logr.Logger, scheme *runtime.Scheme) (*OLMConfigReconciler, error) {
+	// Add watched types to scheme.
+	if err := AddToScheme(scheme); err != nil {
+		return nil, err
+	}
+
+	return &OLMConfigReconciler{
+		Client: cli,
+		log:    log,
+	}, nil
+}
+
+// Implement reconcile.Reconciler so the controller can reconcile objects
+var _ reconcile.Reconciler = &OLMConfigReconciler{}
+
+func (r *OLMConfigReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
+	// Set up a convenient log object so we don't have to type request over and over again
+	log := r.log.WithValues("request", req)
+	log.V(2).Info("reconciling olmconfig %s/%s", req.Namespace, req.Name)
+
+	olmConfig := &operatorsv1.OLMConfig{}
+	err := r.Client.Get(context.TODO(), req.NamespacedName, olmConfig)
+	if err != nil {
+		log.V(1).Error(err, "Unable to find olmConfig %s", req.Name)
+		return ctrl.Result{}, err
+	}
+
+	// Update the condition spec if it has changed
+	needsUpdate := false
+	if ok := updateOrAddCondition(olmConfig, enableCopiedCSVsCondition(olmConfig)); ok {
+		r.log.Info("Copying CSVs status has changed, updating status")
+		needsUpdate = true
+
+		// ping all cluster scoped csvs.
+		operatorGroups := &operatorsv1.OperatorGroupList{}
+		if err := r.Client.List(ctx, operatorGroups, &client.ListOptions{Namespace: ""}); err != nil {
+			return ctrl.Result{}, err
+		}
+
+		for _, operatorGroup := range operatorGroups.Items {
+			namespaceSet := olm.NewNamespaceSet(operatorGroup.Status.Namespaces)
+			if !namespaceSet.IsAllNamespaces() {
+				r.log.Info(fmt.Sprintf("operatorGroup %s/%s is not allNamespace mode, skipping", operatorGroup.GetNamespace(), operatorGroup.GetName()))
+				continue
+			}
+			r.log.Info(fmt.Sprintf("operatorGroup %s/%s is allNamespace mode, processing", operatorGroup.GetNamespace(), operatorGroup.GetName()))
+
+			requirement, err := labels.NewRequirement(v1alpha1.CopiedLabelKey, selection.DoesNotExist, []string{})
+			if err != nil {
+				return ctrl.Result{}, err
+			}
+
+			labels := labels.NewSelector().Add(*requirement)
+
+			csvs := &operatorsv1alpha1.ClusterServiceVersionList{}
+			err = r.Client.List(ctx, csvs, &client.ListOptions{
+				LabelSelector: labels,
+				Namespace:     operatorGroup.GetNamespace(),
+			})
+			if err != nil {
+				return ctrl.Result{}, err
+			}
+
+			for _, csv := range csvs.Items {
+				if csv.GetAnnotations() == nil {
+					csv.Annotations = map[string]string{}
+				}
+				copiedAnnoationKey := "olm.operators.io/enableCopiedCSVs"
+				if csv.GetAnnotations()[copiedAnnoationKey] == strconv.FormatBool(*olmConfig.Spec.Features.EnableCopiedCSVs) {
+					continue
+				}
+				csv.Annotations[copiedAnnoationKey] = strconv.FormatBool(*olmConfig.Spec.Features.EnableCopiedCSVs)
+				if err := r.Client.Update(ctx, &csv); err != nil {
+					return ctrl.Result{}, err
+				}
+			}
+
+		}
+
+	}
+
+	if needsUpdate {
+		if err := r.Client.Status().Update(ctx, olmConfig); err != nil {
+			return ctrl.Result{Requeue: true}, err
+		}
+	}
+
+	r.log.Info("No update needed")
+	return ctrl.Result{}, nil
+}
+
+func enableCopiedCSVsCondition(olmConfig *operatorsv1.OLMConfig) metav1.Condition {
+	condition := metav1.Condition{
+		Reason:             "EnableCopiedCSVs",
+		LastTransitionTime: metav1.Now(),
+		ObservedGeneration: olmConfig.GetGeneration(),
+		Type:               "ready",
+	}
+
+	if olmConfig.CopiedCSVsAreEnabled() {
+		condition.Message = "OLM will create Copied CSVs for cluster scoped operators"
+		condition.Status = metav1.ConditionTrue
+	} else {
+		condition.Message = "OLM will not create Copied CSVs for cluster scoped operators"
+		condition.Status = metav1.ConditionFalse
+	}
+	return condition
+}
+
+func conditionsAreEqual(a, b metav1.Condition) bool {
+	return a.Reason == b.Reason &&
+		a.ObservedGeneration == b.ObservedGeneration &&
+		a.Message == b.Message &&
+		a.Status == b.Status
+}
+
+func updateOrAddCondition(olmConfig *operatorsv1.OLMConfig, condition metav1.Condition) bool {
+	for i, c := range olmConfig.Status.Conditions {
+		if c.Reason == condition.Reason {
+			if conditionsAreEqual(c, condition) {
+				return false
+			}
+			olmConfig.Status.Conditions[i] = condition
+			return true
+		}
+	}
+	olmConfig.Status.Conditions = append(olmConfig.Status.Conditions, condition)
+	return true
+}