Introduce disableCopiedCSVs flag

Author: awgreene

Diff for: pkg/controller/operators/olm/config.go

@@ -21,19 +21,19 @@ import (
 type OperatorOption func(*operatorConfig)
 
 type operatorConfig struct {
-	resyncPeriod      func() time.Duration
-	operatorNamespace string
-	watchedNamespaces []string
-	clock             utilclock.Clock
-	logger            *logrus.Logger
-	operatorClient    operatorclient.ClientInterface
-	externalClient    versioned.Interface
-	strategyResolver  install.StrategyResolverInterface
-	apiReconciler     APIIntersectionReconciler
-	apiLabeler        labeler.Labeler
-	restConfig        *rest.Config
-	configClient      configv1client.Interface
-	copiedCSVs        bool
+	resyncPeriod        func() time.Duration
+	operatorNamespace   string
+	watchedNamespaces   []string
+	clock               utilclock.Clock
+	logger              *logrus.Logger
+	operatorClient      operatorclient.ClientInterface
+	externalClient      versioned.Interface
+	strategyResolver    install.StrategyResolverInterface
+	apiReconciler       APIIntersectionReconciler
+	apiLabeler          labeler.Labeler
+	restConfig          *rest.Config
+	configClient        configv1client.Interface
+	isCopiedCSVsEnabled bool
 }
 
 func (o *operatorConfig) apply(options []OperatorOption) {
@@ -115,7 +115,7 @@ func WithLogger(logger *logrus.Logger) OperatorOption {
 
 func WithCopiedCSVs(enabled bool) OperatorOption {
 	return func(config *operatorConfig) {
-		config.copiedCSVs = enabled
+		config.isCopiedCSVsEnabled = enabled
 	}
 }
 

Diff for: pkg/controller/operators/olm/operator.go

@@ -54,6 +54,10 @@ import (
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/metrics"
 )
 
+const (
+	copiedCSVsDisabledReason = "CopiedCSVsDisabled"
+)
+
 var (
 	ErrRequirementsNotMet      = errors.New("requirements were not met")
 	ErrCRDOwnerConflict        = errors.New("conflicting CRD owner in namespace")
@@ -88,7 +92,7 @@ type Operator struct {
 	clientAttenuator      *scoped.ClientAttenuator
 	serviceAccountQuerier *scoped.UserDefinedServiceAccountQuerier
 	clientFactory         clients.Factory
-	copiedCSVs            bool
+	isCopiedCSVsEnabled   bool
 }
 
 func NewOperator(ctx context.Context, options ...OperatorOption) (*Operator, error) {
@@ -144,7 +148,7 @@ func newOperatorWithConfig(ctx context.Context, config *operatorConfig) (*Operat
 		clientAttenuator:      scoped.NewClientAttenuator(config.logger, config.restConfig, config.operatorClient),
 		serviceAccountQuerier: scoped.NewUserDefinedServiceAccountQuerier(config.logger, config.externalClient),
 		clientFactory:         clients.NewFactory(config.restConfig),
-		copiedCSVs:            config.copiedCSVs,
+		isCopiedCSVsEnabled:   config.isCopiedCSVsEnabled,
 	}
 
 	// Set up syncing for namespace-scoped resources
@@ -1246,34 +1250,109 @@ func (a *Operator) syncCopyCSV(obj interface{}) (syncError error) {
 
 	// Check if we need to do any copying / annotation for the operatorgroup
 	namespaceSet := NewNamespaceSet(operatorGroup.Status.Namespaces)
-	if a.copiedCSVs || !namespaceSet.IsAllNamespaces() {
+	if a.isCopiedCSVsEnabled || !namespaceSet.IsAllNamespaces() {
 		if err := a.ensureCSVsInNamespaces(clusterServiceVersion, operatorGroup, namespaceSet); err != nil {
 			logger.WithError(err).Info("couldn't copy CSV to target namespaces")
 			syncError = err
 		}
-	} else {
-		// Todo: What happens with multiple event triggers?
-		go a.recorder.Event(clusterServiceVersion, corev1.EventTypeWarning, "CopiedCSVsDisabled", fmt.Sprintf("CSV copying disabled for %s/%s", clusterServiceVersion.GetNamespace(), clusterServiceVersion.GetName()))
 
-		requirement, err := labels.NewRequirement(operatorsv1alpha1.CopiedLabelKey, selection.Equals, []string{clusterServiceVersion.Namespace})
-		if err != nil {
+		// If the CSV was installed in AllNamespace mode, remove any "CSV Copying Disabled" events
+		// in which the related object's name, namespace, and uid match the given CSV's.
+		if namespaceSet.IsAllNamespaces() {
+			if err := a.deleteCSVCopyingDisabledEvent(clusterServiceVersion); err != nil {
+				return err
+			}
+		}
+		return
+	}
+
+	requirement, err := labels.NewRequirement(operatorsv1alpha1.CopiedLabelKey, selection.Equals, []string{clusterServiceVersion.Namespace})
+	if err != nil {
+		return err
+	}
+
+	copiedCSVs, err := a.copiedCSVLister.List(labels.NewSelector().Add(*requirement))
+	if err != nil {
+		return err
+	}
+
+	for _, copiedCSV := range copiedCSVs {
+		err := a.client.OperatorsV1alpha1().ClusterServiceVersions(copiedCSV.Namespace).Delete(context.TODO(), copiedCSV.Name, metav1.DeleteOptions{})
+		if err != nil && !k8serrors.IsNotFound(err) {
 			return err
 		}
+	}
 
-		copiedCSVs, err := a.copiedCSVLister.List(labels.NewSelector().Add(*requirement))
-		if err != nil {
+	if err := a.createCSVCopyingDisabledEvent(clusterServiceVersion); err != nil {
+		return err
+	}
+
+	return
+}
+
+func (a *Operator) getCopiedCSVDisabledEventsForCSV(csv *operatorsv1alpha1.ClusterServiceVersion) ([]corev1.Event, error) {
+	result := []corev1.Event{}
+	if csv == nil {
+		return result, nil
+	}
+
+	events, err := a.opClient.KubernetesInterface().CoreV1().Events(csv.GetNamespace()).List(context.TODO(), metav1.ListOptions{})
+	if err != nil {
+		return nil, err
+	}
+
+	for _, event := range events.Items {
+		if event.InvolvedObject.Namespace == csv.GetNamespace() &&
+			event.InvolvedObject.Name == csv.GetName() &&
+			event.InvolvedObject.UID == csv.GetUID() &&
+			event.Reason == copiedCSVsDisabledReason {
+			result = append(result, event)
+		}
+	}
+
+	return result, nil
+}
+
+func (a *Operator) deleteCSVCopyingDisabledEvent(csv *operatorsv1alpha1.ClusterServiceVersion) error {
+	events, err := a.getCopiedCSVDisabledEventsForCSV(csv)
+	if err != nil {
+		return err
+	}
+
+	// Remove existing events.
+	return a.deleteEvents(events)
+}
+
+func (a *Operator) deleteEvents(events []corev1.Event) error {
+	for _, event := range events {
+		err := a.opClient.KubernetesInterface().EventsV1().Events(event.GetNamespace()).Delete(context.TODO(), event.GetName(), metav1.DeleteOptions{})
+		if err != nil && !k8serrors.IsNotFound(err) {
 			return err
 		}
+	}
+	return nil
+}
 
-		for _, copiedCSV := range copiedCSVs {
-			err := a.client.OperatorsV1alpha1().ClusterServiceVersions(copiedCSV.Namespace).Delete(context.TODO(), copiedCSV.Name, metav1.DeleteOptions{})
-			if err != nil && !k8serrors.IsNotFound(err) {
-				return err
-			}
+func (a *Operator) createCSVCopyingDisabledEvent(csv *operatorsv1alpha1.ClusterServiceVersion) error {
+	events, err := a.getCopiedCSVDisabledEventsForCSV(csv)
+	if err != nil {
+		return err
+	}
+
+	if len(events) == 1 {
+		return nil
+	}
+
+	// Remove existing events.
+	if len(events) > 1 {
+		if err := a.deleteEvents(events); err != nil {
+			return err
 		}
 	}
 
-	return
+	a.recorder.Eventf(csv, corev1.EventTypeWarning, copiedCSVsDisabledReason, "CSV copying disabled for %s/%s", csv.GetNamespace(), csv.GetName())
+
+	return nil
 }
 
 func (a *Operator) syncGcCsv(obj interface{}) (syncError error) {