Adds the OperatorDeprecated Condition to the status of Subscriptions when the bundle has been deprecated.

Co-authored-by: Ankita Thomas <[email protected]>
Co-authored-by: Bryce Palmer <[email protected]>

Signed-off-by: Daniel Franz <[email protected]>
Upstream-repository: operator-lifecycle-manager
Upstream-commit: b9638dcaaa14d4005b12abe63feb2055a49ca793

Author: ankitathomas

staging/operator-lifecycle-manager/go.mod

@@ -24,7 +24,7 @@ require (
 	github.com/onsi/gomega v1.27.10
 	github.com/openshift/api v3.9.0+incompatible
 	github.com/openshift/client-go v0.0.0-20220525160904-9e1acff93e4a
-	github.com/operator-framework/api v0.19.0
+	github.com/operator-framework/api v0.20.0
 	github.com/operator-framework/operator-registry v1.33.0
 	github.com/otiai10/copy v1.12.0
 	github.com/pkg/errors v0.9.1

staging/operator-lifecycle-manager/go.sum

@@ -621,8 +621,8 @@ github.com/openshift/api v0.0.0-20221021112143-4226c2167e40 h1:PxjGCA72RtsdHWToZ
 github.com/openshift/api v0.0.0-20221021112143-4226c2167e40/go.mod h1:aQ6LDasvHMvHZXqLHnX2GRmnfTWCF/iIwz8EMTTIE9A=
 github.com/openshift/client-go v0.0.0-20221019143426-16aed247da5c h1:CV76yFOTXmq9VciBR3Bve5ZWzSxdft7gaMVB3kS0rwg=
 github.com/openshift/client-go v0.0.0-20221019143426-16aed247da5c/go.mod h1:lFMO8mLHXWFzSdYvGNo8ivF9SfF6zInA8ZGw4phRnUE=
-github.com/operator-framework/api v0.19.0 h1:QU1CTJU+CufoeneA5rsNlP/uP96s8vDHWUYDFZTauzA=
-github.com/operator-framework/api v0.19.0/go.mod h1:SCCslqke6AVOJ5JM+NqNE1CHuAgJLScsL66pnPaSMXs=
+github.com/operator-framework/api v0.20.0 h1:A2YCRhr+6s0k3pRJacnwjh1Ue8BqjIGuQ2jvPg9XCB4=
+github.com/operator-framework/api v0.20.0/go.mod h1:rXPOhrQ6mMeXqCmpDgt1ALoar9ZlHL+Iy5qut9R99a4=
 github.com/operator-framework/operator-registry v1.33.0 h1:rFvYf6vLdXSUhoePhg8w1S5FHgyFraiNLXDwl47epck=
 github.com/operator-framework/operator-registry v1.33.0/go.mod h1:1V/m2m7iH/o5ROEuMxWa/yhj4ExaPGT6V/ncGS+m6Js=
 github.com/otiai10/copy v1.12.0 h1:cLMgSQnXBs1eehF0Wy/FAGsgDTDmAqFR7rQylBb1nDY=

staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go

@@ -346,6 +346,7 @@ func NewOperator(ctx context.Context, kubeconfigPath string, clock utilclock.Clo
 		subscription.WithAppendedReconcilers(subscription.ReconcilerFromLegacySyncHandler(op.syncSubscriptions, nil)),
 		subscription.WithRegistryReconcilerFactory(op.reconciler),
 		subscription.WithGlobalCatalogNamespace(op.namespace),
+		subscription.WithSourceProvider(resolverSourceProvider),
 	)
 	if err != nil {
 		return nil, err

staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/config.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler"
+	resolverCache "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/kubestate"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister"
 )
@@ -26,6 +27,7 @@ type syncerConfig struct {
 	reconcilers               kubestate.ReconcilerChain
 	registryReconcilerFactory reconciler.RegistryReconcilerFactory
 	globalCatalogNamespace    string
+	sourceProvider            resolverCache.SourceProvider
 }
 
 // SyncerOption is a configuration option for a subscription syncer.
@@ -128,6 +130,12 @@ func WithGlobalCatalogNamespace(namespace string) SyncerOption {
 	}
 }
 
+func WithSourceProvider(provider resolverCache.SourceProvider) SyncerOption {
+	return func(config *syncerConfig) {
+		config.sourceProvider = provider
+	}
+}
+
 func newInvalidConfigError(msg string) error {
 	return errors.Errorf("invalid subscription syncer config: %s", msg)
 }

staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/reconciler.go

@@ -5,8 +5,10 @@ import (
 	"errors"
 	"fmt"
 	"sort"
+	"strings"
 
 	"github.com/sirupsen/logrus"
+	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
@@ -18,8 +20,10 @@ import (
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned"
 	listers "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha1"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler"
+	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/kubestate"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/queueinformer"
+	"github.com/operator-framework/operator-registry/pkg/api"
 )
 
 // ReconcilerFromLegacySyncHandler returns a reconciler that invokes the given legacy sync handler and on delete funcs.
@@ -57,6 +61,7 @@ type catalogHealthReconciler struct {
 	catalogLister             listers.CatalogSourceLister
 	registryReconcilerFactory reconciler.RegistryReconcilerFactory
 	globalCatalogNamespace    string
+	sourceProvider            cache.SourceProvider
 }
 
 // Reconcile reconciles subscription catalog health conditions.
@@ -84,7 +89,15 @@ func (c *catalogHealthReconciler) Reconcile(ctx context.Context, in kubestate.St
 					break
 				}
 
-				next, err = s.UpdateHealth(c.now(), c.client.OperatorsV1alpha1().Subscriptions(ns), catalogHealth...)
+				var healthUpdated, deprecationUpdated bool
+				next, healthUpdated = s.UpdateHealth(c.now(), catalogHealth...)
+				deprecationUpdated, err = c.updateDeprecatedStatus(ctx, s.Subscription())
+				if err != nil {
+					return next, err
+				}
+				if healthUpdated || deprecationUpdated {
+					_, err = c.client.OperatorsV1alpha1().Subscriptions(ns).UpdateStatus(ctx, s.Subscription(), metav1.UpdateOptions{})
+				}
 			case SubscriptionExistsState:
 				if s == nil {
 					err = errors.New("nil state")
@@ -109,6 +122,119 @@ func (c *catalogHealthReconciler) Reconcile(ctx context.Context, in kubestate.St
 	return
 }
 
+// updateDeprecatedStatus adds deprecation status conditions to the subscription when present in the cache entry then
+// returns a bool value of true if any changes to the existing subscription have occurred.
+func (c *catalogHealthReconciler) updateDeprecatedStatus(ctx context.Context, sub *v1alpha1.Subscription) (bool, error) {
+	if c.sourceProvider == nil {
+		return false, nil
+	}
+
+	source, ok := c.sourceProvider.Sources(sub.Namespace)[cache.SourceKey{
+		Name:      sub.Spec.CatalogSource,
+		Namespace: sub.Namespace,
+	}]
+	if !ok {
+		return false, nil
+	}
+	snapshot, err := source.Snapshot(ctx)
+	if err != nil {
+		return false, err
+	}
+	if len(snapshot.Entries) == 0 {
+		return false, nil
+	}
+
+	changed := false
+	rollupMessages := []string{}
+	var deprecations *cache.Deprecations
+
+	found := false
+	for _, entry := range snapshot.Entries {
+		// Find the cache entry that matches this subscription
+		if entry.SourceInfo == nil || entry.Package() != sub.Spec.Package {
+			continue
+		}
+		if sub.Spec.Channel != "" && entry.Channel() != sub.Spec.Channel {
+			continue
+		}
+		if sub.Status.InstalledCSV != entry.Name {
+			continue
+		}
+		deprecations = entry.SourceInfo.Deprecations
+		found = true
+		break
+	}
+	if !found {
+		// No matching entry found
+		return false, nil
+	}
+	conditionTypes := []v1alpha1.SubscriptionConditionType{
+		v1alpha1.SubscriptionPackageDeprecated,
+		v1alpha1.SubscriptionChannelDeprecated,
+		v1alpha1.SubscriptionBundleDeprecated,
+	}
+	for _, conditionType := range conditionTypes {
+		oldCondition := sub.Status.GetCondition(conditionType)
+		var deprecation *api.Deprecation
+		if deprecations != nil {
+			switch conditionType {
+			case v1alpha1.SubscriptionPackageDeprecated:
+				deprecation = deprecations.Package
+			case v1alpha1.SubscriptionChannelDeprecated:
+				deprecation = deprecations.Channel
+			case v1alpha1.SubscriptionBundleDeprecated:
+				deprecation = deprecations.Bundle
+			}
+		}
+		if deprecation != nil {
+			if conditionType == v1alpha1.SubscriptionChannelDeprecated && sub.Spec.Channel == "" {
+				// Special case: If optional field sub.Spec.Channel is unset do not apply a channel
+				// deprecation message and remove them if any exist.
+				sub.Status.RemoveConditions(conditionType)
+				if oldCondition.Status == corev1.ConditionTrue {
+					changed = true
+				}
+				continue
+			}
+			newCondition := v1alpha1.SubscriptionCondition{
+				Type:               conditionType,
+				Message:            deprecation.Message,
+				Status:             corev1.ConditionTrue,
+				LastTransitionTime: c.now(),
+			}
+			rollupMessages = append(rollupMessages, deprecation.Message)
+			if oldCondition.Message != newCondition.Message {
+				// oldCondition's message was empty or has changed; add or update the condition
+				sub.Status.SetCondition(newCondition)
+				changed = true
+			}
+		} else if oldCondition.Status == corev1.ConditionTrue {
+			// No longer deprecated at this level; remove the condition
+			sub.Status.RemoveConditions(conditionType)
+			changed = true
+		}
+	}
+
+	if !changed {
+		// No need to update rollup condition if no other conditions have changed
+		return false, nil
+	}
+	if len(rollupMessages) > 0 {
+		rollupCondition := v1alpha1.SubscriptionCondition{
+			Type:               v1alpha1.SubscriptionDeprecated,
+			Message:            strings.Join(rollupMessages, "; "),
+			Status:             corev1.ConditionTrue,
+			LastTransitionTime: c.now(),
+		}
+		sub.Status.SetCondition(rollupCondition)
+	} else {
+		// No rollup message means no deprecation conditions were set; remove the rollup if it exists
+		sub.Status.RemoveConditions(v1alpha1.SubscriptionDeprecated)
+	}
+
+	return true, nil
+}
+
 // catalogHealth gets the health of catalogs that can affect Susbcriptions in the given namespace.
 // This means all catalogs in the given namespace, as well as any catalogs in the operator's global catalog namespace.
 func (c *catalogHealthReconciler) catalogHealth(namespace string) ([]v1alpha1.SubscriptionCatalogHealth, error) {

staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state.go

@@ -63,8 +63,9 @@ type CatalogHealthState interface {
 	isCatalogHealthState()
 
 	// UpdateHealth transitions the CatalogHealthState to another CatalogHealthState based on the given subscription catalog health.
-	// The state's underlying subscription may be updated on the cluster. If the subscription is updated, the resulting state will contain the updated version.
-	UpdateHealth(now *metav1.Time, client clientv1alpha1.SubscriptionInterface, health ...v1alpha1.SubscriptionCatalogHealth) (CatalogHealthState, error)
+	// The state's underlying subscription may be updated. If the subscription is updated, a boolean value of 'true' will be
+	// returned and the resulting state will contain the updated version.
+	UpdateHealth(now *metav1.Time, health ...v1alpha1.SubscriptionCatalogHealth) (CatalogHealthState, bool)
 }
 
 // CatalogHealthKnownState describes subscription states in which all relevant catalog health is known.
@@ -218,7 +219,7 @@ type catalogHealthState struct {
 
 func (c *catalogHealthState) isCatalogHealthState() {}
 
-func (c *catalogHealthState) UpdateHealth(now *metav1.Time, client clientv1alpha1.SubscriptionInterface, catalogHealth ...v1alpha1.SubscriptionCatalogHealth) (CatalogHealthState, error) {
+func (c *catalogHealthState) UpdateHealth(now *metav1.Time, catalogHealth ...v1alpha1.SubscriptionCatalogHealth) (CatalogHealthState, bool) {
 	in := c.Subscription()
 	out := in.DeepCopy()
 
@@ -291,24 +292,18 @@ func (c *catalogHealthState) UpdateHealth(now *metav1.Time, client clientv1alpha
 
 	if !update && cond.Equals(in.Status.GetCondition(v1alpha1.SubscriptionCatalogSourcesUnhealthy)) {
 		// Nothing to do, transition to self
-		return known, nil
+		return known, false
 	}
 
 	cond.LastTransitionTime = now
 	out.Status.LastUpdated = *now
 	out.Status.SetCondition(cond)
 	out.Status.CatalogHealth = catalogHealth
 
-	updated, err := client.UpdateStatus(context.TODO(), out, metav1.UpdateOptions{})
-	if err != nil {
-		// Error occurred, transition to self
-		return c, err
-	}
-
 	// Inject updated subscription into the state
-	known.setSubscription(updated)
+	known.setSubscription(out)
 
-	return known, nil
+	return known, true
 }
 
 func NewCatalogHealthState(s SubscriptionExistsState) CatalogHealthState {

staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state_test.go

@@ -31,7 +31,7 @@ func TestUpdateHealth(t *testing.T) {
 	type want struct {
 		transitioned CatalogHealthState
 		terminal     bool
-		err          error
+		updated      bool
 	}
 
 	tests := []struct {
@@ -73,6 +73,7 @@ func TestUpdateHealth(t *testing.T) {
 				now: &now,
 			},
 			want: want{
+				updated: true,
 				transitioned: newCatalogUnhealthyState(&v1alpha1.Subscription{
 					ObjectMeta: metav1.ObjectMeta{
 						Name:      "sub",
@@ -132,6 +133,7 @@ func TestUpdateHealth(t *testing.T) {
 				},
 			},
 			want: want{
+				updated: true,
 				transitioned: newCatalogUnhealthyState(&v1alpha1.Subscription{
 					ObjectMeta: metav1.ObjectMeta{
 						Name:      "sub",
@@ -210,6 +212,7 @@ func TestUpdateHealth(t *testing.T) {
 				},
 			},
 			want: want{
+				updated: false,
 				transitioned: newCatalogUnhealthyState(&v1alpha1.Subscription{
 					ObjectMeta: metav1.ObjectMeta{
 						Name:      "sub",
@@ -289,6 +292,7 @@ func TestUpdateHealth(t *testing.T) {
 				},
 			},
 			want: want{
+				updated: true,
 				transitioned: newCatalogHealthyState(&v1alpha1.Subscription{
 					ObjectMeta: metav1.ObjectMeta{
 						Name:      "sub",
@@ -368,6 +372,7 @@ func TestUpdateHealth(t *testing.T) {
 				},
 			},
 			want: want{
+				updated: true,
 				transitioned: newCatalogUnhealthyState(&v1alpha1.Subscription{
 					ObjectMeta: metav1.ObjectMeta{
 						Name:      "sub",
@@ -447,6 +452,7 @@ func TestUpdateHealth(t *testing.T) {
 				},
 			},
 			want: want{
+				updated: false,
 				transitioned: newCatalogHealthyState(&v1alpha1.Subscription{
 					ObjectMeta: metav1.ObjectMeta{
 						Name:      "sub",
@@ -473,19 +479,11 @@ func TestUpdateHealth(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.description, func(t *testing.T) {
-			fakeClient := tt.fields.existingObjs.fakeClientset(t).OperatorsV1alpha1().Subscriptions(tt.fields.namespace)
-			transitioned, err := tt.fields.state.UpdateHealth(tt.args.now, fakeClient, tt.args.catalogHealth...)
-			require.Equal(t, tt.want.err, err)
+			transitioned, updated := tt.fields.state.UpdateHealth(tt.args.now, tt.args.catalogHealth...)
 			require.Equal(t, tt.want.transitioned, transitioned)
-
+			require.Equal(t, tt.want.updated, updated)
 			if tt.want.transitioned != nil {
 				require.Equal(t, tt.want.terminal, transitioned.Terminal())
-
-				// Ensure the client's view of the subscription matches the typestate's
-				sub := transitioned.(SubscriptionState).Subscription()
-				clusterSub, err := fakeClient.Get(context.TODO(), sub.GetName(), metav1.GetOptions{})
-				require.NoError(t, err)
-				require.Equal(t, sub, clusterSub)
 			}
 		})
 	}

staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/syncer.go

@@ -13,6 +13,7 @@ import (
 	"github.com/operator-framework/api/pkg/operators/install"
 	"github.com/operator-framework/api/pkg/operators/v1alpha1"
 	listers "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha1"
+	resolverCache "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/kubestate"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/ownerutil"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/metrics"
@@ -34,6 +35,7 @@ type subscriptionSyncer struct {
 	installPlanLister      listers.InstallPlanLister
 	globalCatalogNamespace string
 	notify                 kubestate.NotifyFunc
+	sourceProvider         resolverCache.SourceProvider
 }
 
 // now returns the Syncer's current time.
@@ -214,6 +216,7 @@ func newSyncerWithConfig(ctx context.Context, config *syncerConfig) (kubestate.S
 		reconcilers:       config.reconcilers,
 		subscriptionCache: config.subscriptionInformer.GetIndexer(),
 		installPlanLister: config.lister.OperatorsV1alpha1().InstallPlanLister(),
+		sourceProvider:    config.sourceProvider,
 		notify: func(event kubestate.ResourceEvent) {
 			// Notify Subscriptions by enqueuing to the Subscription queue.
 			config.subscriptionQueue.Add(event)
@@ -234,6 +237,7 @@ func newSyncerWithConfig(ctx context.Context, config *syncerConfig) (kubestate.S
 			catalogLister:             config.lister.OperatorsV1alpha1().CatalogSourceLister(),
 			registryReconcilerFactory: config.registryReconcilerFactory,
 			globalCatalogNamespace:    config.globalCatalogNamespace,
+			sourceProvider:            config.sourceProvider,
 		},
 	}
 	s.reconcilers = append(defaultReconcilers, s.reconcilers...)