pkg/cvo/availableupdates: Cache original upstream updates

We've been mixing in alerts since 3b365d0 (OTA-1813: Populate risks
from alerts, 2026-02-27, #1329).  But when the alerts get resolved, we
want the cluster to notice quickly.

With this change, we keep the original upstream data isolated in new
properties, so an evaluation round will be able to clear out resolved
alerts, even if needFreshFetch is false because available updates were
recently retrieved.

Author: wking

pkg/cvo/availableupdates.go

@@ -153,11 +153,13 @@ func (optr *Operator) syncAvailableUpdates(ctx context.Context, config *configv1
 				condition.Reason == "ResponseInvalid"))
 		if !responseFailed || (responseFailed && !preserveCacheOnFailure) {
 			optrAvailableUpdates.Current = current
-			optrAvailableUpdates.Updates = updates
-			optrAvailableUpdates.ConditionalUpdates = conditionalUpdates
+			optrAvailableUpdates.upstreamUpdates = updates
+			optrAvailableUpdates.upstreamConditionalUpdates = conditionalUpdates
 		}
 	}
 
+	optrAvailableUpdates.Updates = deepCopyReleases(optrAvailableUpdates.upstreamUpdates)
+	optrAvailableUpdates.ConditionalUpdates = deepCopyConditionalUpdates(optrAvailableUpdates.upstreamConditionalUpdates)
 	optrAvailableUpdates.AcceptRisks = acceptRisks
 	optrAvailableUpdates.ShouldReconcileAcceptRisks = optr.shouldReconcileAcceptRisks
 	optrAvailableUpdates.risks = optr.risks
@@ -205,10 +207,12 @@ type availableUpdates struct {
 	//   slice was empty.
 	LastSyncOrConfigChange time.Time
 
-	Current            configv1.Release
-	Updates            []configv1.Release
-	ConditionalUpdates []configv1.ConditionalUpdate
-	ConditionRegistry  clusterconditions.ConditionRegistry
+	Current                    configv1.Release
+	Updates                    []configv1.Release
+	upstreamUpdates            []configv1.Release
+	ConditionalUpdates         []configv1.ConditionalUpdate
+	upstreamConditionalUpdates []configv1.ConditionalUpdate
+	ConditionRegistry          clusterconditions.ConditionRegistry
 
 	Condition configv1.ClusterOperatorStatusCondition
 
@@ -332,22 +336,46 @@ func (optr *Operator) getAvailableUpdates() *availableUpdates {
 	}
 
 	if optr.availableUpdates.Updates != nil {
-		u.Updates = make([]configv1.Release, 0, len(optr.availableUpdates.Updates))
-		for _, update := range optr.availableUpdates.Updates {
-			u.Updates = append(u.Updates, *update.DeepCopy())
-		}
+		u.Updates = deepCopyReleases(optr.availableUpdates.Updates)
+	}
+
+	if optr.availableUpdates.upstreamUpdates != nil {
+		u.upstreamUpdates = deepCopyReleases(optr.availableUpdates.upstreamUpdates)
 	}
 
 	if optr.availableUpdates.ConditionalUpdates != nil {
-		u.ConditionalUpdates = make([]configv1.ConditionalUpdate, 0, len(optr.availableUpdates.ConditionalUpdates))
-		for _, conditionalUpdate := range optr.availableUpdates.ConditionalUpdates {
-			u.ConditionalUpdates = append(u.ConditionalUpdates, *conditionalUpdate.DeepCopy())
-		}
+		u.ConditionalUpdates = deepCopyConditionalUpdates(optr.availableUpdates.ConditionalUpdates)
+	}
+
+	if optr.availableUpdates.upstreamConditionalUpdates != nil {
+		u.upstreamConditionalUpdates = deepCopyConditionalUpdates(optr.availableUpdates.upstreamConditionalUpdates)
 	}
 
 	return u
 }
 
+func deepCopyReleases(releases []configv1.Release) []configv1.Release {
+	if releases == nil {
+		return nil
+	}
+	c := make([]configv1.Release, 0, len(releases))
+	for _, update := range releases {
+		c = append(c, *update.DeepCopy())
+	}
+	return c
+}
+
+func deepCopyConditionalUpdates(updates []configv1.ConditionalUpdate) []configv1.ConditionalUpdate {
+	if updates == nil {
+		return nil
+	}
+	c := make([]configv1.ConditionalUpdate, 0, len(updates))
+	for _, update := range updates {
+		c = append(c, *update.DeepCopy())
+	}
+	return c
+}
+
 func loadRiskConditions(ctx context.Context, risks []string, riskVersions map[string]riskWithVersion, conditionRegistry clusterconditions.ConditionRegistry) map[string][]metav1.Condition {
 	riskConditions := map[string][]metav1.Condition{}
 	for _, riskName := range risks {

pkg/cvo/availableupdates_test.go

@@ -213,6 +213,7 @@ var cvFixture = &configv1.ClusterVersion{
 }
 
 var availableUpdatesCmpOpts = []cmp.Option{
+	cmpopts.IgnoreUnexported(availableUpdates{}),
 	cmpopts.IgnoreFields(availableUpdates{}, "ShouldReconcileAcceptRisks"),
 	cmpopts.IgnoreTypes(time.Time{}),
 	cmpopts.IgnoreInterfaces(struct {

pkg/cvo/cvo_test.go

@@ -16,7 +16,6 @@ import (
 
 	"github.com/davecgh/go-spew/spew"
 	"github.com/google/go-cmp/cmp"
-	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/google/uuid"
 
 	appsv1 "k8s.io/api/apps/v1"
@@ -2783,7 +2782,7 @@ func TestOperator_availableUpdatesSync(t *testing.T) {
 				}
 			}
 
-			if diff := cmp.Diff(tt.wantUpdates, optr.availableUpdates, cmpopts.IgnoreFields(availableUpdates{}, "ShouldReconcileAcceptRisks", "risks")); diff != "" {
+			if diff := cmp.Diff(tt.wantUpdates, optr.availableUpdates, availableUpdatesCmpOpts...); diff != "" {
 				t.Fatalf("unexpected: %s", diff)
 			}
 			if (optr.queue.Len() > 0) != (optr.availableUpdates != nil) {