Use TransformFunc

Unit tests not updated

Signed-off-by: Todd Short <[email protected]>

Author: tmshort

pkg/controller/operators/catalog/operator.go

@@ -230,38 +230,53 @@ func NewOperator(ctx context.Context, kubeconfigPath string, clock utilclock.Clo
 
 	// Fields are pruned from local copies of the objects managed
 	// by this informer in order to reduce cached size.
-	prunedCSVInformer := cache.NewSharedIndexInformer(
-		pruning.NewListerWatcher(op.client, metav1.NamespaceAll,
+	prunedCSVInformer := cache.NewSharedIndexInformerWithOptions(
+		pruning.NewListerWatcher(
+			op.client,
+			metav1.NamespaceAll,
 			func(options *metav1.ListOptions) {
 				options.LabelSelector = fmt.Sprintf("!%s", v1alpha1.CopiedLabelKey)
 			},
-			pruning.PrunerFunc(func(csv *v1alpha1.ClusterServiceVersion) {
-				*csv = v1alpha1.ClusterServiceVersion{
-					TypeMeta: csv.TypeMeta,
-					ObjectMeta: metav1.ObjectMeta{
-						Name:        csv.Name,
-						Namespace:   csv.Namespace,
-						Labels:      csv.Labels,
-						Annotations: csv.Annotations,
-					},
-					Spec: v1alpha1.ClusterServiceVersionSpec{
-						CustomResourceDefinitions: csv.Spec.CustomResourceDefinitions,
-						APIServiceDefinitions:     csv.Spec.APIServiceDefinitions,
-						Replaces:                  csv.Spec.Replaces,
-						Version:                   csv.Spec.Version,
-					},
-					Status: v1alpha1.ClusterServiceVersionStatus{
-						Phase:  csv.Status.Phase,
-						Reason: csv.Status.Reason,
-					},
-				}
-			})),
+		),
 		&v1alpha1.ClusterServiceVersion{},
-		resyncPeriod(),
-		cache.Indexers{
-			cache.NamespaceIndex: cache.MetaNamespaceIndexFunc,
+		cache.SharedIndexInformerOptions{
+			ResyncPeriod: resyncPeriod(),
+			Indexers: cache.Indexers{
+				cache.NamespaceIndex: cache.MetaNamespaceIndexFunc,
+			},
 		},
 	)
+
+	// Transformed the CSV to be just the necessary data
+	prunedCSVTransformFunc := func(i interface{}) (interface{}, error) {
+		if csv, ok := i.(*v1alpha1.ClusterServiceVersion); ok {
+			*csv = v1alpha1.ClusterServiceVersion{
+				TypeMeta: csv.TypeMeta,
+				ObjectMeta: metav1.ObjectMeta{
+					Name:        csv.Name,
+					Namespace:   csv.Namespace,
+					Labels:      csv.Labels,
+					Annotations: csv.Annotations,
+				},
+				Spec: v1alpha1.ClusterServiceVersionSpec{
+					CustomResourceDefinitions: csv.Spec.CustomResourceDefinitions,
+					APIServiceDefinitions:     csv.Spec.APIServiceDefinitions,
+					Replaces:                  csv.Spec.Replaces,
+					Version:                   csv.Spec.Version,
+				},
+				Status: v1alpha1.ClusterServiceVersionStatus{
+					Phase:  csv.Status.Phase,
+					Reason: csv.Status.Reason,
+				},
+			}
+			return csv, nil
+		}
+		return nil, fmt.Errorf("Unable to convert input to CSV")
+	}
+
+	if err := prunedCSVInformer.SetTransform(prunedCSVTransformFunc); err != nil {
+		return nil, err
+	}
 	csvLister := operatorsv1alpha1listers.NewClusterServiceVersionLister(prunedCSVInformer.GetIndexer())
 	op.lister.OperatorsV1alpha1().RegisterClusterServiceVersionLister(metav1.NamespaceAll, csvLister)
 	if err := op.RegisterInformer(prunedCSVInformer); err != nil {

pkg/controller/operators/internal/pruning/listerwatcher.go

@@ -8,45 +8,18 @@ import (
 	"k8s.io/apimachinery/pkg/watch"
 	"k8s.io/client-go/tools/cache"
 
-	"github.com/operator-framework/api/pkg/operators/v1alpha1"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned"
 )
 
-type Pruner interface {
-	Prune(*v1alpha1.ClusterServiceVersion)
-}
-
-type PrunerFunc func(*v1alpha1.ClusterServiceVersion)
-
-func (f PrunerFunc) Prune(csv *v1alpha1.ClusterServiceVersion) {
-	f(csv)
-}
-
-func NewListerWatcher(client versioned.Interface, namespace string, override func(*metav1.ListOptions), p Pruner) cache.ListerWatcher {
+func NewListerWatcher(client versioned.Interface, namespace string, override func(*metav1.ListOptions)) cache.ListerWatcher {
 	return &cache.ListWatch{
 		ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
 			override(&options)
-			list, err := client.OperatorsV1alpha1().ClusterServiceVersions(namespace).List(context.TODO(), options)
-			if err != nil {
-				return list, err
-			}
-			for i := range list.Items {
-				p.Prune(&list.Items[i])
-			}
-			return list, nil
+			return client.OperatorsV1alpha1().ClusterServiceVersions(namespace).List(context.TODO(), options)
 		},
 		WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
 			override(&options)
-			w, err := client.OperatorsV1alpha1().ClusterServiceVersions(namespace).Watch(context.TODO(), options)
-			if err != nil {
-				return w, err
-			}
-			return watch.Filter(w, watch.FilterFunc(func(e watch.Event) (watch.Event, bool) {
-				if csv, ok := e.Object.(*v1alpha1.ClusterServiceVersion); ok {
-					p.Prune(csv)
-				}
-				return e, true
-			})), nil
+			return client.OperatorsV1alpha1().ClusterServiceVersions(namespace).Watch(context.TODO(), options)
 		},
 	}
 }

pkg/controller/operators/olm/operator.go

@@ -43,8 +43,10 @@ import (
 
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/informers/externalversions"
+	operatorsv1alpha1listers "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha1"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/certs"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install"
+	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/internal/pruning"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/labeller"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/overrides"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/plugins"
@@ -63,6 +65,14 @@ import (
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/metrics"
 )
 
+const (
+	// These annotation keys are intentionally invalid -- all writes
+	// to copied CSVs are regenerated from the corresponding non-copied CSV,
+	// so it should never be transmitted back to the API server.
+	copyCSVStatusHash = "$copyhash-status"
+	copyCSVSpecHash   = "$copyhash-spec"
+)
+
 var (
 	ErrRequirementsNotMet      = errors.New("requirements were not met")
 	ErrCRDOwnerConflict        = errors.New("conflicting CRD owner in namespace")
@@ -82,7 +92,7 @@ type Operator struct {
 	client                       versioned.Interface
 	lister                       operatorlister.OperatorLister
 	protectedCopiedCSVNamespaces map[string]struct{}
-	copiedCSVLister              metadatalister.Lister
+	copiedCSVLister              operatorsv1alpha1listers.ClusterServiceVersionLister
 	ogQueueSet                   *queueinformer.ResourceQueueSet
 	csvQueueSet                  *queueinformer.ResourceQueueSet
 	olmConfigQueue               workqueue.TypedRateLimitingInterface[types.NamespacedName]
@@ -294,20 +304,54 @@ func newOperatorWithConfig(ctx context.Context, config *operatorConfig) (*Operat
 			return nil, err
 		}
 
-		// A separate informer solely for CSV copies. Object metadata requests are used
+		// A separate informer solely for CSV copies. Fields
+		// are pruned from local copies of the objects managed
 		// by this informer in order to reduce cached size.
-		gvr := v1alpha1.SchemeGroupVersion.WithResource("clusterserviceversions")
-		copiedCSVInformer := metadatainformer.NewFilteredMetadataInformer(
-			config.metadataClient,
-			gvr,
-			namespace,
-			config.resyncPeriod(),
-			cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-			func(options *metav1.ListOptions) {
-				options.LabelSelector = v1alpha1.CopiedLabelKey
+		copiedCSVInformer := cache.NewSharedIndexInformerWithOptions(
+			pruning.NewListerWatcher(
+				op.client,
+				namespace,
+				func(opts *metav1.ListOptions) {
+					opts.LabelSelector = v1alpha1.CopiedLabelKey
+				},
+			),
+			&v1alpha1.ClusterServiceVersion{},
+			cache.SharedIndexInformerOptions{
+				ResyncPeriod: config.resyncPeriod(),
+				Indexers:     cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
 			},
-		).Informer()
-		op.copiedCSVLister = metadatalister.New(copiedCSVInformer.GetIndexer(), gvr)
+		)
+
+		// Transform the copied CSV to be just the Metadata
+		// However, because we have the full copied CSV, we can calculate
+		// a hash over the full CSV to store as an annotation
+		copiedCSVTransformFunc := func(i interface{}) (interface{}, error) {
+			if csv, ok := i.(*v1alpha1.ClusterServiceVersion); ok {
+				specHash, statusHash, err := copyableCSVHash(csv)
+				if err != nil {
+					return nil, err
+				}
+				*csv = v1alpha1.ClusterServiceVersion{
+					TypeMeta:   csv.TypeMeta,
+					ObjectMeta: csv.ObjectMeta,
+					Spec:       v1alpha1.ClusterServiceVersionSpec{},
+					Status:     v1alpha1.ClusterServiceVersionStatus{},
+				}
+				if csv.Annotations == nil {
+					csv.Annotations = make(map[string]string, 2)
+				}
+				// fake CSV hashes for tracking purposes only
+				csv.Annotations[copyCSVSpecHash] = specHash
+				csv.Annotations[copyCSVStatusHash] = statusHash
+				return csv, nil
+			}
+			return nil, fmt.Errorf("Unable to convert input to CSV")
+		}
+
+		if err := copiedCSVInformer.SetTransform(copiedCSVTransformFunc); err != nil {
+			return nil, err
+		}
+		op.copiedCSVLister = operatorsv1alpha1listers.NewClusterServiceVersionLister(copiedCSVInformer.GetIndexer())
 		informersByNamespace[namespace].CopiedCSVInformer = copiedCSVInformer
 		informersByNamespace[namespace].CopiedCSVLister = op.copiedCSVLister