test no annotation

Signed-off-by: Urvashi <umohnani@redhat.com>

Author: umohnani8

pkg/controller/bootstrap/bootstrap.go

@@ -398,19 +398,18 @@ func parseManifests(filename string, r io.Reader) ([]manifest, error) {
 // createPreBuiltImageMachineConfigs creates component MachineConfigs that set osImageURL for pools
 // that have associated MachineOSConfigs with pre-built image annotations.
 // These component MCs will be automatically merged into rendered MCs by the render controller.
-// This function performs strict validation at bootstrap time and will fail if:
-// - A MachineOSConfig is missing the pre-built image annotation
-// - The pre-built image format or digest is invalid
+// This function validates pre-built images at bootstrap time and will fail if the image format is invalid.
+// MOSCs without the annotation are skipped (this can happen if bootstrap runs again after seeding).
 func createPreBuiltImageMachineConfigs(machineOSConfigs []*mcfgv1.MachineOSConfig, pools []*mcfgv1.MachineConfigPool) ([]*mcfgv1.MachineConfig, error) {
 	var preBuiltImageMCs []*mcfgv1.MachineConfig
 
-	// At bootstrap time, we require ALL MachineOSConfigs to have pre-built images
-	// This is a strict requirement for day-0 hybrid OCL support
 	for _, mosc := range machineOSConfigs {
 		preBuiltImage, hasPreBuiltImage := mosc.Annotations[buildconstants.PreBuiltImageAnnotationKey]
+
+		// Skip if annotation is not present (could be a re-run after seeding completed)
 		if !hasPreBuiltImage || preBuiltImage == "" {
-			return nil, fmt.Errorf("MachineOSConfig %s is missing required annotation %s for bootstrap pre-built image support",
-				mosc.Name, buildconstants.PreBuiltImageAnnotationKey)
+			klog.V(4).Infof("Skipping MachineOSConfig %s - no pre-built image annotation (may have already been seeded)", mosc.Name)
+			continue
 		}
 
 		poolName := mosc.Spec.MachineConfigPool.Name

pkg/controller/build/constants/constants.go

@@ -46,8 +46,6 @@ const (
 const (
 	// PreBuiltImageAnnotationKey indicates a MachineOSConfig should be seeded with a pre-built image
 	PreBuiltImageAnnotationKey = "machineconfiguration.openshift.io/pre-built-image"
-	// PreBuiltImageSeededAnnotationKey indicates that the initial synthetic MOSB has been created for this MOSC
-	PreBuiltImageSeededAnnotationKey = "machineconfiguration.openshift.io/pre-built-image-seeded"
 )
 
 // Component MachineConfig naming for pre-built images

pkg/controller/build/helpers.go

@@ -262,12 +262,6 @@ func hasPreBuiltImageAnnotation(mosc *mcfgv1.MachineOSConfig) bool {
 	return exists
 }
 
-// hasPreBuiltImageSeededAnnotation checks if a MachineOSConfig has been seeded with a pre-built image.
-func hasPreBuiltImageSeededAnnotation(mosc *mcfgv1.MachineOSConfig) bool {
-	_, exists := mosc.Annotations[constants.PreBuiltImageSeededAnnotationKey]
-	return exists
-}
-
 // getPreBuiltImage returns the pre-built image from a MachineOSConfig's annotations.
 // Returns the image string and a boolean indicating if it exists and is non-empty.
 func getPreBuiltImage(mosc *mcfgv1.MachineOSConfig) (string, bool) {
@@ -278,18 +272,29 @@ func getPreBuiltImage(mosc *mcfgv1.MachineOSConfig) (string, bool) {
 // shouldSeedWithPreBuiltImage determines if a MachineOSConfig should be seeded with a pre-built image.
 // Returns true if:
 // - The MOSC has a pre-built image annotation
-// - The MOSC has NOT been seeded yet
-// - The MOSC does NOT have a current build annotation
+// - The MOSC does NOT have a current build annotation (meaning seeding hasn't happened yet)
 func shouldSeedWithPreBuiltImage(mosc *mcfgv1.MachineOSConfig) bool {
 	return hasPreBuiltImageAnnotation(mosc) &&
-		!hasPreBuiltImageSeededAnnotation(mosc) &&
 		!hasCurrentBuildAnnotation(mosc)
 }
 
 // isPreBuiltImageAwaitingSeeding checks if a MOSC has pre-built image annotation but hasn't been seeded.
 // This is useful for skipping normal build workflows when the seeding workflow should handle it.
+// Seeding is considered complete once the currentBuild annotation is set.
 func isPreBuiltImageAwaitingSeeding(mosc *mcfgv1.MachineOSConfig) bool {
-	return hasPreBuiltImageAnnotation(mosc) && !hasPreBuiltImageSeededAnnotation(mosc)
+	return hasPreBuiltImageAnnotation(mosc) && !hasCurrentBuildAnnotation(mosc)
+}
+
+// needsPreBuiltImageAnnotationCleanup determines if a MOSC has completed seeding and
+// the pre-built image annotation can be safely removed.
+// Returns true if:
+// - The MOSC has a current build annotation (seeding is complete)
+// - The MOSC status has been populated with CurrentImagePullSpec
+// - The MOSC still has the PreBuiltImageAnnotationKey (needs cleanup)
+func needsPreBuiltImageAnnotationCleanup(mosc *mcfgv1.MachineOSConfig) bool {
+	return hasCurrentBuildAnnotation(mosc) &&
+		mosc.Status.CurrentImagePullSpec != "" &&
+		hasPreBuiltImageAnnotation(mosc)
 }
 
 // Looks at the error chain for the given error and determines if the error

pkg/controller/build/helpers_test.go

@@ -7,6 +7,7 @@ import (
 
 	mcfgv1 "github.com/openshift/api/machineconfiguration/v1"
 	"github.com/openshift/machine-config-operator/pkg/apihelpers"
+	"github.com/openshift/machine-config-operator/pkg/controller/build/constants"
 	"github.com/openshift/machine-config-operator/pkg/controller/build/fixtures"
 	ctrlcommon "github.com/openshift/machine-config-operator/pkg/controller/common"
 	"github.com/stretchr/testify/assert"
@@ -198,3 +199,83 @@ func TestIsMachineOSBuildStatusUpdateNeeded(t *testing.T) {
 		}
 	}
 }
+
+func TestNeedsPreBuiltImageAnnotationCleanup(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name            string
+		mosc            *mcfgv1.MachineOSConfig
+		expectedCleanup bool
+	}{
+		{
+			name: "needs cleanup - all conditions met",
+			mosc: &mcfgv1.MachineOSConfig{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "test",
+					Annotations: map[string]string{
+						constants.PreBuiltImageAnnotationKey:         "registry.example.com/image@sha256:abc123",
+						constants.CurrentMachineOSBuildAnnotationKey: "test-build-1",
+					},
+				},
+				Status: mcfgv1.MachineOSConfigStatus{
+					CurrentImagePullSpec: "registry.example.com/image@sha256:abc123",
+				},
+			},
+			expectedCleanup: true,
+		},
+		{
+			name: "no cleanup - missing current build annotation",
+			mosc: &mcfgv1.MachineOSConfig{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "test",
+					Annotations: map[string]string{
+						constants.PreBuiltImageAnnotationKey: "registry.example.com/image@sha256:abc123",
+					},
+				},
+				Status: mcfgv1.MachineOSConfigStatus{
+					CurrentImagePullSpec: "registry.example.com/image@sha256:abc123",
+				},
+			},
+			expectedCleanup: false,
+		},
+		{
+			name: "no cleanup - status not populated",
+			mosc: &mcfgv1.MachineOSConfig{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "test",
+					Annotations: map[string]string{
+						constants.PreBuiltImageAnnotationKey:         "registry.example.com/image@sha256:abc123",
+						constants.CurrentMachineOSBuildAnnotationKey: "test-build-1",
+					},
+				},
+				Status: mcfgv1.MachineOSConfigStatus{
+					CurrentImagePullSpec: "",
+				},
+			},
+			expectedCleanup: false,
+		},
+		{
+			name: "no cleanup - prebuilt image annotation already removed",
+			mosc: &mcfgv1.MachineOSConfig{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "test",
+					Annotations: map[string]string{
+						constants.CurrentMachineOSBuildAnnotationKey: "test-build-1",
+					},
+				},
+				Status: mcfgv1.MachineOSConfigStatus{
+					CurrentImagePullSpec: "registry.example.com/image@sha256:abc123",
+				},
+			},
+			expectedCleanup: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := needsPreBuiltImageAnnotationCleanup(tt.mosc)
+			assert.Equal(t, tt.expectedCleanup, result, "needsPreBuiltImageAnnotationCleanup() result mismatch")
+		})
+	}
+}

pkg/controller/build/reconciler.go

@@ -388,14 +388,22 @@ func (b *buildReconciler) updateMachineOSConfigStatus(ctx context.Context, mosc
 		return nil
 	}
 
-	// skip the status update if the current image pullspec equals the digest image pushspec.
-	if mosc.Status.CurrentImagePullSpec == mosb.Status.DigestedImagePushSpec {
-		klog.Infof("MachineOSConfig %q already has final image pushspec for MachineOSBuild %q", mosc.Name, mosb.Name)
+	// Check if the machineOSBuild reference matches
+	machineOSBuildRefMatches := mosc.Status.MachineOSBuild != nil && mosc.Status.MachineOSBuild.Name == mosb.Name
+
+	// skip the status update if both the current image pullspec and machineOSBuild reference are already correct.
+	if mosc.Status.CurrentImagePullSpec == mosb.Status.DigestedImagePushSpec && machineOSBuildRefMatches {
+		klog.Infof("MachineOSConfig %q already has final image pushspec and machineOSBuild reference for MachineOSBuild %q", mosc.Name, mosb.Name)
 		return nil
 	}
 
 	mosc.Status.CurrentImagePullSpec = mosb.Status.DigestedImagePushSpec
 	mosc.Status.ObservedGeneration = mosc.GetGeneration()
+	mosc.Status.MachineOSBuild = &mcfgv1.ObjectReference{
+		Name:     mosb.Name,
+		Group:    mcfgv1.SchemeGroupVersion.Group,
+		Resource: "machineosbuilds",
+	}
 
 	_, err = b.mcfgclient.MachineconfigurationV1().MachineOSConfigs().UpdateStatus(ctx, mosc, metav1.UpdateOptions{})
 	if err == nil {
@@ -1245,6 +1253,19 @@ func (b *buildReconciler) syncMachineOSConfigs(ctx context.Context) error {
 // should be created.
 func (b *buildReconciler) syncMachineOSConfig(ctx context.Context, mosc *mcfgv1.MachineOSConfig) error {
 	return b.timeObjectOperation(mosc, syncingVerb, func() error {
+		// Check if we need to clean up the pre-built image annotation after successful seeding
+		// This happens in a separate reconciliation to ensure status is persisted before removing annotation
+		if needsPreBuiltImageAnnotationCleanup(mosc) {
+			klog.Infof("MachineOSConfig %q seeding complete and status populated, removing pre-built image annotation", mosc.Name)
+			delete(mosc.Annotations, constants.PreBuiltImageAnnotationKey)
+			if _, err := b.mcfgclient.MachineconfigurationV1().MachineOSConfigs().Update(ctx, mosc, metav1.UpdateOptions{}); err != nil {
+				return fmt.Errorf("could not remove pre-built image annotation from MachineOSConfig %q: %w", mosc.Name, err)
+			}
+			klog.Infof("Successfully removed pre-built image annotation from MachineOSConfig %q", mosc.Name)
+			// Trigger another sync to handle any pending work now that annotation is removed
+			return nil
+		}
+
 		mosbs, err := b.getMachineOSBuildsForMachineOSConfig(mosc)
 		if err != nil {
 			return fmt.Errorf("could not list MachineOSBuilds for MachineOSConfig %q: %w", mosc.Name, err)
@@ -1331,8 +1352,9 @@ func (b *buildReconciler) reconcilePoolChange(ctx context.Context, mcp *mcfgv1.M
 
 	// If the MachineOSConfig has a pre-built image annotation AND hasn't been seeded yet,
 	// the seeding workflow should handle creating the synthetic build. Don't proceed with normal build workflow.
+	// Seeding is considered complete once the currentBuild annotation is set.
 	firstOptIn := mosc.Annotations[constants.CurrentMachineOSBuildAnnotationKey]
-	if hasPreBuiltImageAnnotation(mosc) && !hasPreBuiltImageSeededAnnotation(mosc) && firstOptIn == "" {
+	if hasPreBuiltImageAnnotation(mosc) && firstOptIn == "" {
 		klog.Infof("MachineOSConfig %q has pre-built image annotation but hasn't been seeded yet, skipping pool change reconciliation (seeding workflow should handle this)", mosc.Name)
 		return nil
 	}
@@ -1861,9 +1883,9 @@ func (b *buildReconciler) createSyntheticMachineOSBuild(ctx context.Context, mos
 
 // updateMachineOSConfigForSeeding updates MachineOSConfig for seeded state
 func (b *buildReconciler) updateMachineOSConfigForSeeding(ctx context.Context, mosc *mcfgv1.MachineOSConfig, mosb *mcfgv1.MachineOSBuild, imageSpec string) error {
-	// Update annotations - add both current build and seeded marker
+	// Update annotations - set current build annotation to mark seeding as complete
+	// The currentBuild annotation serves as the marker that seeding has occurred
 	metav1.SetMetaDataAnnotation(&mosc.ObjectMeta, constants.CurrentMachineOSBuildAnnotationKey, mosb.Name)
-	metav1.SetMetaDataAnnotation(&mosc.ObjectMeta, constants.PreBuiltImageSeededAnnotationKey, "true")
 
 	// Update the MachineOSConfig object
 	updatedMOSC, err := b.mcfgclient.MachineconfigurationV1().MachineOSConfigs().Update(ctx, mosc, metav1.UpdateOptions{})

pkg/controller/build/reconciler_seeding_test.go

@@ -324,11 +324,13 @@ func TestUpdateMachineOSConfigForSeeding(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			// Create test objects
+			// Create test objects with pre-built image annotation
 			mosc := &mcfgv1.MachineOSConfig{
 				ObjectMeta: metav1.ObjectMeta{
-					Name:        "layered",
-					Annotations: make(map[string]string),
+					Name: "layered",
+					Annotations: map[string]string{
+						constants.PreBuiltImageAnnotationKey: tt.imageSpec,
+					},
 				},
 				Spec: mcfgv1.MachineOSConfigSpec{
 					MachineConfigPool: mcfgv1.MachineConfigPoolReference{Name: "layered"},
@@ -353,20 +355,34 @@ func TestUpdateMachineOSConfigForSeeding(t *testing.T) {
 				t.Errorf("Unexpected error: %v", err)
 			}
 
-			// Verify annotations were set
-			if mosc.Annotations[constants.CurrentMachineOSBuildAnnotationKey] != mosb.Name {
+			// Fetch the updated MOSC from the fake client
+			updatedMOSC, err := mcfgClient.MachineconfigurationV1().MachineOSConfigs().Get(ctx, mosc.Name, metav1.GetOptions{})
+			if err != nil {
+				t.Fatalf("Failed to get updated MachineOSConfig: %v", err)
+			}
+
+			// Verify current build annotation was set (this marks seeding as complete)
+			if updatedMOSC.Annotations[constants.CurrentMachineOSBuildAnnotationKey] != mosb.Name {
 				t.Errorf("Expected current build annotation to be %q, got %q",
-					mosb.Name, mosc.Annotations[constants.CurrentMachineOSBuildAnnotationKey])
+					mosb.Name, updatedMOSC.Annotations[constants.CurrentMachineOSBuildAnnotationKey])
+			}
+
+			// IMPORTANT: Verify pre-built image annotation is NOT removed during seeding
+			// It will be removed in a separate reconciliation after status is confirmed persisted
+			if _, hasAnnotation := updatedMOSC.Annotations[constants.PreBuiltImageAnnotationKey]; !hasAnnotation {
+				t.Error("Pre-built image annotation should NOT be removed during seeding (removed in separate cleanup step)")
 			}
 
-			// Verify build annotation was set
-			if mosc.Annotations[constants.CurrentMachineOSBuildAnnotationKey] == "" {
-				t.Error("Expected current MachineOSBuild annotation to be set")
+			// Verify status has the image pullspec
+			if updatedMOSC.Status.CurrentImagePullSpec != mcfgv1.ImageDigestFormat(tt.imageSpec) {
+				t.Errorf("Expected Status.CurrentImagePullSpec to be %q, got %q",
+					tt.imageSpec, updatedMOSC.Status.CurrentImagePullSpec)
 			}
 
-			// Verify status was updated - Note: This would require the update to succeed
-			// In a real test with proper setup, we'd verify the status was updated
-			// For now, we just verify the function doesn't error
+			// Verify status has the MachineOSBuild reference
+			if updatedMOSC.Status.MachineOSBuild == nil || updatedMOSC.Status.MachineOSBuild.Name != mosb.Name {
+				t.Errorf("Expected Status.MachineOSBuild.Name to be %q", mosb.Name)
+			}
 		})
 	}
 }

pkg/operator/sync.go

@@ -2350,8 +2350,41 @@ func (optr *Operator) syncPreBuiltImageMachineConfigs() error {
 		return fmt.Errorf("failed to list MachineOSConfigs: %w", err)
 	}
 
-	// Build map of pools that should have pre-built image component MCs using common helper
-	poolsWithPreBuiltImages := ctrlcommon.BuildPoolToPreBuiltImageMap(moscs, buildconstants.PreBuiltImageAnnotationKey)
+	// Build map of pools that should have pre-built image component MCs
+	// Only use the annotation for pre-seeding/bootstrap. After seeding is complete
+	// (indicated by Seeded condition), we should not update the component MC anymore
+	// to avoid triggering new builds every time the status changes.
+	poolsWithPreBuiltImages := make(map[string]string)
+	for _, mosc := range moscs {
+		poolName := mosc.Spec.MachineConfigPool.Name
+
+		// Check if seeding is complete by looking for the Seeded condition
+		hasSeededCondition := false
+		for _, condition := range mosc.Status.Conditions {
+			if condition.Type == "Seeded" && condition.Status == metav1.ConditionTrue {
+				hasSeededCondition = true
+				break
+			}
+		}
+
+		// Only use the annotation for component MC creation/updates.
+		// Do NOT use status.currentImagePullSpec after seeding, as that would
+		// create an infinite loop: build completes → status updated → MC updated →
+		// rendered config changes → new build triggered → repeat forever.
+		var preBuiltImage string
+		if !hasSeededCondition {
+			if annotationImage, hasAnnotation := mosc.Annotations[buildconstants.PreBuiltImageAnnotationKey]; hasAnnotation && annotationImage != "" {
+				preBuiltImage = annotationImage
+				klog.V(4).Infof("MachineOSConfig %s has pre-built image %s in annotation for pool %s (pre-seeding)", mosc.Name, preBuiltImage, poolName)
+			}
+		} else {
+			klog.V(4).Infof("MachineOSConfig %s has been seeded, skipping component MC updates for pool %s to prevent build loops", mosc.Name, poolName)
+		}
+
+		if preBuiltImage != "" {
+			poolsWithPreBuiltImages[poolName] = preBuiltImage
+		}
+	}
 
 	// Get all existing pre-built image component MCs
 	allMCs, err := optr.mcLister.List(labels.Everything())