From 2fc007843415bd7c8e4f629e378981480335cd4f Mon Sep 17 00:00:00 2001 From: "Per G. da Silva" Date: Mon, 16 Nov 2026 17:28:20 +0100 Subject: [PATCH] Remove owner-name-dependent COS cache retention Apply the reduced ClusterObjectSet cache representation uniformly, regardless of owner labels, while preserving revision discovery, completion evidence, and existing metadata handling. Patch only completedAt during Helm migration with optimistic resourceVersion locking so writes from trimmed cache reads preserve detailed status and reject concurrent updates. Add coverage for label independence, status preservation, conflicts, and subsequent reconciliation. Signed-off-by: Per G. da Silva --- cmd/operator-controller/main.go | 22 +-- cmd/operator-controller/main_test.go | 175 ++++++++++++++++++ .../operator-controller/applier/boxcutter.go | 5 +- .../applier/boxcutter_test.go | 24 ++- 4 files changed, 200 insertions(+), 26 deletions(-) diff --git a/cmd/operator-controller/main.go b/cmd/operator-controller/main.go index 7236684f99..c2582fd00b 100644 --- a/cmd/operator-controller/main.go +++ b/cmd/operator-controller/main.go @@ -593,18 +593,16 @@ func transformClusterObjectDeployment(obj any) (any, error) { func transformClusterObjectSet(obj any) (any, error) { if cos, ok := obj.(*ocv1.ClusterObjectSet); ok { - if _, hasOwnerName := cos.Labels[labels.OwnerNameKey]; !hasOwnerName { - cos.Spec = ocv1.ClusterObjectSetSpec{ - // Keep group, revision, and lifecycleState, which are used to determine - // if the latest active revision of a group is foreign to the CE. - Group: cos.Spec.Group, - Revision: cos.Spec.Revision, - LifecycleState: cos.Spec.LifecycleState, - } - cos.Status = ocv1.ClusterObjectSetStatus{ - CompletedAt: cos.Status.CompletedAt, - Conditions: cos.Status.Conditions, - } + // Retain only the fields needed for revision discovery, status reporting, + // and storage migration, regardless of labels. + cos.Spec = ocv1.ClusterObjectSetSpec{ + Group: cos.Spec.Group, + Revision: cos.Spec.Revision, + LifecycleState: cos.Spec.LifecycleState, + } + cos.Status = ocv1.ClusterObjectSetStatus{ + CompletedAt: cos.Status.CompletedAt, + Conditions: cos.Status.Conditions, } } // A per-object transform replaces DefaultTransform rather than composing diff --git a/cmd/operator-controller/main_test.go b/cmd/operator-controller/main_test.go index 4ed71cb8ce..97e247b9b1 100644 --- a/cmd/operator-controller/main_test.go +++ b/cmd/operator-controller/main_test.go @@ -1,19 +1,194 @@ package main import ( + "context" "maps" "testing" + "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" k8slabels "k8s.io/apimachinery/pkg/labels" + "k8s.io/apimachinery/pkg/runtime" "k8s.io/utils/ptr" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/client/fake" + "sigs.k8s.io/controller-runtime/pkg/client/interceptor" ocv1 "github.com/operator-framework/operator-controller/api/v1" + coscontrollers "github.com/operator-framework/operator-controller/internal/object-controller/controllers" + "github.com/operator-framework/operator-controller/internal/operator-controller/applier" "github.com/operator-framework/operator-controller/internal/shared/labels" + "github.com/operator-framework/operator-controller/internal/testutil" ) +func TestClusterObjectSetCache(t *testing.T) { + t.Parallel() + tests := []struct { + name string + cosLabels map[string]string + }{ + {name: "nil labels"}, + {name: "empty labels", cosLabels: map[string]string{}}, + {name: "unrelated label", cosLabels: map[string]string{"app": "test"}}, + {name: "empty owner-name", cosLabels: map[string]string{labels.OwnerNameKey: ""}}, + { + name: "owner labels", + cosLabels: map[string]string{ + labels.OwnerNameKey: "test-ext", + labels.OwnerKindKey: ocv1.ClusterExtensionKind, + }, + }, + { + name: "managed-by label", + cosLabels: map[string]string{labels.ManagedByKey: labels.ManagedByObjectController}, + }, + } + options := newCacheOptions("olmv1-system", true) + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + cos := &ocv1.ClusterObjectSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-ext-2", UID: "cos-uid", ResourceVersion: "123", Generation: 1, + Labels: maps.Clone(tc.cosLabels), + Annotations: map[string]string{ + "kubectl.kubernetes.io/last-applied-configuration": "large manifest", + + labels.BundleNameKey: "test-bundle", + }, + OwnerReferences: []metav1.OwnerReference{{ + APIVersion: ocv1.GroupVersion.String(), Kind: "ClusterObjectDeployment", + Name: "test-ext", UID: "cod-uid", Controller: ptr.To(true), + }}, + }, + Spec: ocv1.ClusterObjectSetSpec{ + Group: "test-ext", Revision: 2, LifecycleState: ocv1.ClusterObjectSetLifecycleStateActive, + ClusterObjectSetContent: ocv1.ClusterObjectSetContent{ + Phases: []ocv1.ClusterObjectSetPhase{{Name: "install"}}, + }, + }, + Status: ocv1.ClusterObjectSetStatus{ + CompletedAt: metav1.NewTime(time.Unix(1, 0)), + Conditions: []metav1.Condition{{ + Type: ocv1.ClusterObjectSetTypeReady, Status: metav1.ConditionTrue, + }}, + ObjectCounts: ocv1.ObjectCounts{Total: ptr.To(int64(1))}, + ObservedPhases: []ocv1.ObservedPhase{{Name: "install", Digest: "sha256:abc"}}, + }, + } + before := cos.DeepCopy() + want := &ocv1.ClusterObjectSet{ + ObjectMeta: before.ObjectMeta, + Spec: ocv1.ClusterObjectSetSpec{ + Group: "test-ext", Revision: 2, LifecycleState: ocv1.ClusterObjectSetLifecycleStateActive, + }, + Status: ocv1.ClusterObjectSetStatus{ + CompletedAt: before.Status.CompletedAt, + Conditions: before.Status.Conditions, + }, + } + delete(want.Annotations, "kubectl.kubernetes.io/last-applied-configuration") + for obj, config := range options.ByObject { + if _, ok := obj.(*ocv1.ClusterObjectSet); !ok { + continue + } + require.NotNil(t, config.Label) + assert.True(t, config.Label.Matches(k8slabels.Set(cos.Labels)), "group reads must see every COS") + require.NotNil(t, config.Transform) + actual, err := config.Transform(cos) + require.NoError(t, err) + assert.Equal(t, want, actual) + return + } + t.Fatal("COS cache configuration is missing") + }) + } +} + +func TestClusterObjectSetCacheMigrationStatus(t *testing.T) { + t.Parallel() + for _, concurrentUpdate := range []bool{false, true} { + name := "preserves uncached status" + if concurrentUpdate { + name = "conflicts with concurrent status update" + } + t.Run(name, func(t *testing.T) { + t.Parallel() + scheme := runtime.NewScheme() + require.NoError(t, ocv1.AddToScheme(scheme)) + ext := &ocv1.ClusterExtension{ + ObjectMeta: metav1.ObjectMeta{Name: "test-ext"}, + Spec: ocv1.ClusterExtensionSpec{Namespace: "test-namespace"}, + } + rev := &ocv1.ClusterObjectSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-ext-1", + Labels: map[string]string{ + labels.OwnerNameKey: ext.Name, + labels.MigratedFromHelmKey: "true", + }, + }, + Spec: ocv1.ClusterObjectSetSpec{ + Group: ext.Name, Revision: 1, LifecycleState: ocv1.ClusterObjectSetLifecycleStateActive, + }, + Status: ocv1.ClusterObjectSetStatus{ + Conditions: []metav1.Condition{{ + Type: ocv1.ClusterObjectSetTypeReady, Status: metav1.ConditionFalse, + Reason: ocv1.ClusterObjectSetReasonObjectsNotReady, + }}, + ObjectCounts: ocv1.ObjectCounts{Total: ptr.To(int64(2))}, + ObservedPhases: []ocv1.ObservedPhase{{ + Name: "install", Digest: "sha256:abc", Message: "original status", + }}, + }, + } + server := testutil.WithIndexes(t, fake.NewClientBuilder().WithScheme(scheme), coscontrollers.SetupIndexes). + WithStatusSubresource(&ocv1.ClusterObjectSet{}).WithObjects(rev).Build() + cached := interceptor.NewClient(server, interceptor.Funcs{ + Get: func(ctx context.Context, cl client.WithWatch, key client.ObjectKey, obj client.Object, opts ...client.GetOption) error { + if err := cl.Get(ctx, key, obj, opts...); err != nil { + return err + } + if concurrentUpdate { + current := &ocv1.ClusterObjectSet{} + if err := cl.Get(ctx, key, current); err != nil { + return err + } + current.Status.ObservedPhases[0].Message = "concurrent status" + if err := cl.Status().Update(ctx, current); err != nil { + return err + } + } + _, err := transformClusterObjectSet(obj) + return err + }, + }) + migrator := &applier.BoxcutterStorageMigrator{Client: cached} + err := migrator.Migrate(t.Context(), ext, nil) + actual := &ocv1.ClusterObjectSet{} + require.NoError(t, server.Get(t.Context(), client.ObjectKeyFromObject(rev), actual)) + wantStatus := *rev.Status.DeepCopy() + if concurrentUpdate { + require.Error(t, err) + assert.True(t, apierrors.IsConflict(err), "stale cache reads must conflict: %v", err) + wantStatus.ObservedPhases[0].Message = "concurrent status" + assert.Equal(t, wantStatus, actual.Status, "a conflict must not change server status") + concurrentUpdate = false + require.NoError(t, migrator.Migrate(t.Context(), ext, nil), "retry with a fresh read must succeed") + require.NoError(t, server.Get(t.Context(), client.ObjectKeyFromObject(rev), actual)) + } else { + require.NoError(t, err) + } + assert.False(t, actual.Status.CompletedAt.IsZero(), "migration must record completion") + wantStatus.CompletedAt = actual.Status.CompletedAt + assert.Equal(t, wantStatus, actual.Status, "migration must preserve all other status fields") + }) + } +} + func TestClusterObjectDeploymentCache(t *testing.T) { t.Parallel() adoptionLabels := map[string]string{ diff --git a/internal/operator-controller/applier/boxcutter.go b/internal/operator-controller/applier/boxcutter.go index 016ba58555..f02d46126a 100644 --- a/internal/operator-controller/applier/boxcutter.go +++ b/internal/operator-controller/applier/boxcutter.go @@ -421,9 +421,12 @@ func (m *BoxcutterStorageMigrator) ensureRevisionStatus(ctx context.Context, nam // represents a working installation. Record completedAt so the ClusterExtension // controller treats it as installed. The original ready time is not recoverable, // so we use the migration time. + base := rev.DeepCopy() rev.Status.CompletedAt = metav1.Now() - if err := m.Client.Status().Update(ctx, rev); err != nil { + // Cached revisions omit detailed status. Patch only completedAt so those + // fields remain intact, and retry on a later reconciliation if the read is stale. + if err := m.Client.Status().Patch(ctx, rev, client.MergeFromWithOptions(base, client.MergeFromWithOptimisticLock{})); err != nil { return fmt.Errorf("updating migrated revision status: %w", err) } diff --git a/internal/operator-controller/applier/boxcutter_test.go b/internal/operator-controller/applier/boxcutter_test.go index 8d196370e2..a47ac48a19 100644 --- a/internal/operator-controller/applier/boxcutter_test.go +++ b/internal/operator-controller/applier/boxcutter_test.go @@ -282,8 +282,8 @@ func TestBoxcutterStorageMigrator(t *testing.T) { }) var updatedObj client.Object - mockStatusWriter.EXPECT().Update(gomock.Any(), gomock.Any(), gomock.Any()). - DoAndReturn(func(ctx context.Context, obj client.Object, opts ...client.SubResourceUpdateOption) error { + mockStatusWriter.EXPECT().Patch(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()). + DoAndReturn(func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.SubResourcePatchOption) error { updatedObj = obj return nil }) @@ -376,8 +376,7 @@ func TestBoxcutterStorageMigrator(t *testing.T) { existingRev := ocv1.ClusterObjectSet{ ObjectMeta: metav1.ObjectMeta{ - Name: "test-revision", - Generation: 2, + Name: "test-revision", Generation: 2, ResourceVersion: "1", Labels: map[string]string{ labels.MigratedFromHelmKey: "true", }, @@ -403,8 +402,8 @@ func TestBoxcutterStorageMigrator(t *testing.T) { }) var updatedObj client.Object - mockStatusWriter.EXPECT().Update(gomock.Any(), gomock.Any(), gomock.Any()). - DoAndReturn(func(ctx context.Context, obj client.Object, opts ...client.SubResourceUpdateOption) error { + mockStatusWriter.EXPECT().Patch(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()). + DoAndReturn(func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.SubResourcePatchOption) error { updatedObj = obj return nil }) @@ -449,8 +448,7 @@ func TestBoxcutterStorageMigrator(t *testing.T) { // This simulates a revision whose completedAt should be set during migration. existingRev := ocv1.ClusterObjectSet{ ObjectMeta: metav1.ObjectMeta{ - Name: "test-revision", - Generation: 2, + Name: "test-revision", Generation: 2, ResourceVersion: "1", Labels: map[string]string{ labels.MigratedFromHelmKey: "true", }, @@ -476,8 +474,8 @@ func TestBoxcutterStorageMigrator(t *testing.T) { }) var updatedObj client.Object - mockStatusWriter.EXPECT().Update(gomock.Any(), gomock.Any(), gomock.Any()). - DoAndReturn(func(ctx context.Context, obj client.Object, opts ...client.SubResourceUpdateOption) error { + mockStatusWriter.EXPECT().Patch(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()). + DoAndReturn(func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.SubResourcePatchOption) error { updatedObj = obj return nil }) @@ -545,7 +543,7 @@ func TestBoxcutterStorageMigrator(t *testing.T) { return nil }) - // Status() and Update() should NOT be called for non-migrated revisions. + // Status() and Patch() should NOT be called for non-migrated revisions. // gomock will fail if any unexpected calls are made. err := sm.Migrate(t.Context(), ext, map[string]string{"my-label": "my-value"}) @@ -630,8 +628,8 @@ func TestBoxcutterStorageMigrator(t *testing.T) { }) var updatedObj client.Object - mockStatusWriter.EXPECT().Update(gomock.Any(), gomock.Any(), gomock.Any()). - DoAndReturn(func(ctx context.Context, obj client.Object, opts ...client.SubResourceUpdateOption) error { + mockStatusWriter.EXPECT().Patch(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()). + DoAndReturn(func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.SubResourcePatchOption) error { updatedObj = obj return nil })