feat(sub): Indicate resolution conflicts on Subscription statuses

Resolution considers everything in a given namespace as a unit, so conflicts aren't
generated on a per-Subscription basis. However, as the main entry point to resolution,
users first look at the Subscription to understand resolution failures. The set of conflicts
today is written to Events with type ResolutionFailed. This PR projects resolution errors onto
all subscriptions on the namespace for any resolution failure.

Signed-off-by: Anik Bhattacharjee <[email protected]>

Author: anik120

pkg/controller/operators/catalog/operator.go

@@ -909,9 +909,22 @@ func (o *Operator) syncResolvingNamespace(obj interface{}) error {
 		// not-satisfiable error
 		if _, ok := err.(solver.NotSatisfiable); ok {
 			logger.WithError(err).Debug("resolution failed")
+			updateErr := o.setSubsResFailedCond(subs, "Constraint not satisfyable", err.Error(), true)
+			if updateErr != nil {
+				logger.WithError(updateErr).Debug("failed to update subs conditions")
+			}
 			return nil
 		}
+		updateErr := o.setSubsResFailedCond(subs, "Dependency resolution failed", err.Error(), true)
+		if updateErr != nil {
+			logger.WithError(updateErr).Debug("failed to update subs conditions")
+		}
 		return err
+	} else {
+		updateErr := o.setSubsResFailedCond(subs, "", "", false)
+		if updateErr != nil {
+			logger.WithError(updateErr).Debug("failed to update subs conditions")
+		}
 	}
 
 	// create installplan if anything updated
@@ -1189,6 +1202,55 @@ func (o *Operator) createInstallPlan(namespace string, gen int, subs []*v1alpha1
 	return reference.GetReference(res)
 }
 
+func (o *Operator) setSubsResFailedCond(subs []*v1alpha1.Subscription, reason, message string, setTrue bool) error {
+	var (
+		errs        []error
+		mu          sync.Mutex
+		wg          sync.WaitGroup
+		getOpts     = metav1.GetOptions{}
+		updateOpts  = metav1.UpdateOptions{}
+		lastUpdated = o.now()
+	)
+	for _, sub := range subs {
+		sub.Status.LastUpdated = lastUpdated
+		cond := sub.Status.GetCondition(v1alpha1.SubscriptionResolutionFailed)
+		cond.Reason = reason
+		cond.Message = message
+		if setTrue {
+			cond.Status = corev1.ConditionTrue
+		} else {
+			cond.Status = corev1.ConditionFalse
+		}
+		sub.Status.SetCondition(cond)
+
+		wg.Add(1)
+		go func(s v1alpha1.Subscription) {
+			defer wg.Done()
+
+			update := func() error {
+				// Update the status of the latest revision
+				latest, err := o.client.OperatorsV1alpha1().Subscriptions(s.GetNamespace()).Get(context.TODO(), s.GetName(), getOpts)
+				if err != nil {
+					return err
+				}
+
+				latest.Status = s.Status
+				_, err = o.client.OperatorsV1alpha1().Subscriptions(sub.Namespace).UpdateStatus(context.TODO(), latest, updateOpts)
+
+				return err
+			}
+			if err := retry.RetryOnConflict(retry.DefaultRetry, update); err != nil {
+				mu.Lock()
+				defer mu.Unlock()
+				errs = append(errs, err)
+			}
+		}(*sub)
+	}
+	wg.Wait()
+
+	return utilerrors.NewAggregate(errs)
+}
+
 type UnpackedBundleReference struct {
 	Kind                   string `json:"kind"`
 	Name                   string `json:"name"`

test/e2e/subscription_e2e_test.go

@@ -2105,6 +2105,55 @@ var _ = Describe("Subscription", func() {
 		require.NoError(GinkgoT(), err)
 	})
 
+	When("A subscription is created for an operator that requires an API that is not available", func() {
+
+		var (
+			c          operatorclient.ClientInterface
+			crc        versioned.Interface
+			teardown   func()
+			cleanup    func()
+			packages   []registry.PackageManifest
+			subName    = genName("test-subscription")
+			catSrcName = genName("test-catalog")
+		)
+
+		BeforeEach(func() {
+			c = newKubeClient()
+			crc = newCRClient()
+
+			packages = []registry.PackageManifest{
+				{
+					PackageName: "packageA",
+					Channels: []registry.PackageChannel{
+						{Name: "alpha", CurrentCSVName: "csvA"},
+					},
+					DefaultChannelName: "alpha",
+				},
+			}
+			crd := newCRD(genName("foo"))
+			csv := newCSV("csvA", testNamespace, "", semver.MustParse("1.0.0"), nil, []apiextensions.CustomResourceDefinition{crd}, nil)
+
+			_, teardown = createInternalCatalogSource(c, ctx.Ctx().OperatorClient(), catSrcName, testNamespace, packages, nil, []operatorsv1alpha1.ClusterServiceVersion{csv})
+
+			// Ensure that the catalog source is resolved before we create a subscription.
+			_, err := fetchCatalogSourceOnStatus(crc, catSrcName, testNamespace, catalogSourceRegistryPodSynced)
+			require.NoError(GinkgoT(), err)
+
+			cleanup = createSubscriptionForCatalog(crc, testNamespace, subName, catSrcName, "packageA", "alpha", "", operatorsv1alpha1.ApprovalAutomatic)
+		})
+
+		AfterEach(func() {
+			cleanup()
+			teardown()
+		})
+
+		It("the subscription has a condition in it's status that indicates the resolution error", func() {
+			_, err := fetchSubscription(crc, testNamespace, subName, subscriptionHasResolutionFailedCondChecker)
+			require.NoError(GinkgoT(), err)
+		})
+
+	})
+
 	When("an unannotated ClusterServiceVersion exists with an associated Subscription", func() {
 		var (
 			teardown func()
@@ -2488,6 +2537,20 @@ func subscriptionStateUpgradeAvailableChecker(subscription *operatorsv1alpha1.Su
 	return subscription.Status.State == operatorsv1alpha1.SubscriptionStateUpgradeAvailable
 }
 
+func subscriptionHasResolutionFailedCondChecker(subscription *operatorsv1alpha1.Subscription) bool {
+	if cond := subscription.Status.GetCondition(operatorsv1alpha1.SubscriptionResolutionFailed); cond.Status == corev1.ConditionTrue {
+		return true
+	}
+	return false
+}
+
+func subscriptionDoesNotHaveResolutionFailedCondChecker(subscription *operatorsv1alpha1.Subscription) bool {
+	if cond := subscription.Status.GetCondition(operatorsv1alpha1.SubscriptionResolutionFailed); cond.Status == corev1.ConditionTrue {
+		return false
+	}
+	return true
+}
+
 func subscriptionStateUpgradePendingChecker(subscription *operatorsv1alpha1.Subscription) bool {
 	return subscription.Status.State == operatorsv1alpha1.SubscriptionStateUpgradePending
 }