feat: implement HostedCluster lifecycle Phase 4 - HostedCluster Status Mirroring

Author: linoyaslan

cmd/main.go

@@ -243,6 +243,9 @@ func main() {
 	// Initialize Finalizer Manager
 	finalizerManager := hostedcluster.NewFinalizerManager(mgr.GetClient())
 
+	// Initialize Status Syncer for HostedCluster status mirroring
+	statusSyncer := hostedcluster.NewStatusSyncer(mgr.GetClient())
+
 	if err := (&controller.DPFHCPBridgeReconciler{
 		Client:               mgr.GetClient(),
 		Scheme:               mgr.GetScheme(),
@@ -254,6 +257,7 @@ func main() {
 		HostedClusterManager: hostedClusterManager,
 		NodePoolManager:      nodePoolManager,
 		FinalizerManager:     finalizerManager,
+		StatusSyncer:         statusSyncer,
 	}).SetupWithManager(mgr); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "DPFHCPBridge")
 		os.Exit(1)

internal/controller/dpfhcpbridge_controller.go

@@ -19,6 +19,7 @@ package controller
 import (
 	"context"
 
+	hyperv1 "github.com/openshift/hypershift/api/hypershift/v1beta1"
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -56,6 +57,7 @@ type DPFHCPBridgeReconciler struct {
 	HostedClusterManager *hostedcluster.HostedClusterManager
 	NodePoolManager      *hostedcluster.NodePoolManager
 	FinalizerManager     *hostedcluster.FinalizerManager
+	StatusSyncer         *hostedcluster.StatusSyncer
 }
 
 const (
@@ -241,6 +243,18 @@ func (r *DPFHCPBridgeReconciler) Reconcile(ctx context.Context, req ctrl.Request
 		log.V(1).Info("Skipping HostedCluster/NodePool creation - cluster already provisioned or being deleted", "phase", cr.Status.Phase)
 	}
 
+	// Feature: HostedCluster Status Mirroring
+	// Sync status from HostedCluster to DPFHCPBridge
+	// This runs in all phases (Pending, Provisioning, Ready) to keep status up-to-date
+	// Only syncs if hostedClusterRef is set (after HostedCluster creation)
+	log.V(1).Info("Syncing status from HostedCluster")
+	if result, err := r.StatusSyncer.SyncStatusFromHostedCluster(ctx, &cr); err != nil || result.Requeue || result.RequeueAfter > 0 {
+		if err != nil {
+			log.Error(err, "Status sync failed")
+		}
+		return result, err
+	}
+
 	// Compute final phase from all conditions after features have updated them
 	r.updatePhaseFromConditions(&cr)
 
@@ -273,6 +287,11 @@ func (r *DPFHCPBridgeReconciler) SetupWithManager(mgr ctrl.Manager) error {
 			handler.EnqueueRequestsFromMapFunc(r.secretToRequests),
 			builder.WithPredicates(secretPredicate()),
 		).
+		Watches(
+			&hyperv1.HostedCluster{},
+			handler.EnqueueRequestsFromMapFunc(r.hostedClusterToRequests),
+			builder.WithPredicates(hostedClusterPredicate()),
+		).
 		Named("dpfhcpbridge").
 		Complete(r)
 }
@@ -478,6 +497,99 @@ func (r *DPFHCPBridgeReconciler) secretToRequests(ctx context.Context, obj clien
 	return requests
 }
 
+// hostedClusterPredicate filters HostedCluster events to watch for status changes
+func hostedClusterPredicate() predicate.Predicate {
+	return predicate.Funcs{
+		CreateFunc: func(e event.CreateEvent) bool {
+			// Watch creation - reconcile to set initial status
+			return true
+		},
+		UpdateFunc: func(e event.UpdateEvent) bool {
+			// Only reconcile if status changed (not spec)
+			// This prevents unnecessary reconciliations when we update the HostedCluster spec
+			oldHC, oldOK := e.ObjectOld.(*hyperv1.HostedCluster)
+			newHC, newOK := e.ObjectNew.(*hyperv1.HostedCluster)
+			if !oldOK || !newOK {
+				return false
+			}
+
+			// Compare status conditions to detect changes
+			return !conditionsEqual(oldHC.Status.Conditions, newHC.Status.Conditions)
+		},
+		DeleteFunc: func(e event.DeleteEvent) bool {
+			// Watch deletion - reconcile to handle cleanup
+			return true
+		},
+	}
+}
+
+// conditionsEqual compares two condition slices for equality
+func conditionsEqual(oldConds, newConds []metav1.Condition) bool {
+	if len(oldConds) != len(newConds) {
+		return false
+	}
+
+	// Create maps for O(n) comparison
+	oldMap := make(map[string]metav1.Condition)
+	for _, c := range oldConds {
+		oldMap[c.Type] = c
+	}
+
+	// Compare each new condition
+	for _, newCond := range newConds {
+		oldCond, exists := oldMap[newCond.Type]
+		if !exists {
+			return false
+		}
+		if oldCond.Status != newCond.Status ||
+			oldCond.Reason != newCond.Reason ||
+			oldCond.Message != newCond.Message {
+			return false
+		}
+	}
+
+	return true
+}
+
+// hostedClusterToRequests maps HostedCluster events to reconcile requests for DPFHCPBridge CRs
+// that own the HostedCluster (via labels)
+func (r *DPFHCPBridgeReconciler) hostedClusterToRequests(ctx context.Context, obj client.Object) []reconcile.Request {
+	log := logf.FromContext(ctx)
+
+	hc, ok := obj.(*hyperv1.HostedCluster)
+	if !ok {
+		log.Error(nil, "Failed to convert object to HostedCluster", "object", obj)
+		return []reconcile.Request{}
+	}
+
+	// Extract DPFHCPBridge name and namespace from labels
+	bridgeName := hc.Labels["dpfhcpbridge.provisioning.dpu.hcp.io/name"]
+	bridgeNamespace := hc.Labels["dpfhcpbridge.provisioning.dpu.hcp.io/namespace"]
+
+	if bridgeName == "" || bridgeNamespace == "" {
+		// HostedCluster not owned by DPFHCPBridge (no labels)
+		log.V(2).Info("HostedCluster not owned by DPFHCPBridge, skipping",
+			"hostedCluster", hc.Name,
+			"namespace", hc.Namespace)
+		return []reconcile.Request{}
+	}
+
+	log.V(1).Info("HostedCluster changed, reconciling owning DPFHCPBridge",
+		"hostedCluster", hc.Name,
+		"namespace", hc.Namespace,
+		"bridge", bridgeName,
+		"bridgeNamespace", bridgeNamespace)
+
+	return []reconcile.Request{
+		{
+			NamespacedName: types.NamespacedName{
+				Name:      bridgeName,
+				Namespace: bridgeNamespace,
+			},
+		},
+	}
+}
+
 // updatePhaseFromConditions computes the phase based on all conditions
 func (r *DPFHCPBridgeReconciler) updatePhaseFromConditions(cr *provisioningv1alpha1.DPFHCPBridge) {
 	// Phase 1: Check for deletion (highest priority)

internal/controller/hostedcluster/status.go

@@ -0,0 +1,154 @@
+/*
+Copyright 2025.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package hostedcluster
+
+import (
+	"context"
+	"time"
+
+	hyperv1 "github.com/openshift/hypershift/api/hypershift/v1beta1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	logf "sigs.k8s.io/controller-runtime/pkg/log"
+
+	provisioningv1alpha1 "github.com/rh-ecosystem-edge/dpf-hcp-bridge-operator/api/v1alpha1"
+)
+
+const (
+	// RequeueDelayStatusPending is the delay before rechecking HostedCluster status
+	RequeueDelayStatusPending = 10 * time.Second
+)
+
+// StatusSyncer manages status synchronization from HostedCluster to DPFHCPBridge
+type StatusSyncer struct {
+	client.Client
+}
+
+// NewStatusSyncer creates a new StatusSyncer
+func NewStatusSyncer(c client.Client) *StatusSyncer {
+	return &StatusSyncer{Client: c}
+}
+
+// SyncStatusFromHostedCluster mirrors HostedCluster status conditions to DPFHCPBridge status
+// This function:
+// - Only syncs status when hostedClusterRef is set in DPFHCPBridge status
+// - Mirrors 7 HostedCluster conditions to DPFHCPBridge conditions
+// - Handles missing HostedCluster gracefully (may be creating or deleted)
+//
+// Returns ctrl.Result and error for reconciliation flow
+func (ss *StatusSyncer) SyncStatusFromHostedCluster(ctx context.Context, cr *provisioningv1alpha1.DPFHCPBridge) (ctrl.Result, error) {
+	log := logf.FromContext(ctx)
+
+	// Only sync status if hostedClusterRef is set
+	if cr.Status.HostedClusterRef == nil {
+		log.V(1).Info("Skipping status sync - hostedClusterRef not set yet")
+		return ctrl.Result{}, nil
+	}
+
+	// Get HostedCluster
+	hc := &hyperv1.HostedCluster{}
+	hcKey := types.NamespacedName{
+		Name:      cr.Status.HostedClusterRef.Name,
+		Namespace: cr.Status.HostedClusterRef.Namespace,
+	}
+
+	if err := ss.Get(ctx, hcKey, hc); err != nil {
+		if apierrors.IsNotFound(err) {
+			// HostedCluster not found - may be creating or deleted
+			// Don't fail, just log and skip sync
+			log.V(1).Info("HostedCluster not found, skipping status sync",
+				"hostedCluster", hcKey.String())
+			return ctrl.Result{}, nil
+		}
+
+		// Handle "no matches for kind" error (CRD not installed) gracefully
+		if meta.IsNoMatchError(err) {
+			log.V(1).Info("HostedCluster CRD not installed, skipping status sync",
+				"hostedCluster", hcKey.String())
+			return ctrl.Result{}, nil
+		}
+
+		// Other errors (network, RBAC, API server issues) should be retried
+		log.Error(err, "Failed to get HostedCluster for status sync",
+			"hostedCluster", hcKey.String())
+		return ctrl.Result{}, err
+	}
+
+	// Check if HostedCluster status is populated yet
+	if hc.Status.Conditions == nil || len(hc.Status.Conditions) == 0 {
+		log.V(1).Info("HostedCluster status not yet populated, will retry",
+			"hostedCluster", hcKey.String())
+		// Requeue after a short delay to check again
+		return ctrl.Result{RequeueAfter: RequeueDelayStatusPending}, nil
+	}
+
+	log.V(1).Info("Syncing status from HostedCluster",
+		"hostedCluster", hcKey.String(),
+		"conditions", len(hc.Status.Conditions))
+
+	// Mirror conditions from HostedCluster to DPFHCPBridge
+	ss.mirrorConditions(ctx, cr, hc)
+
+	log.V(1).Info("Status sync completed successfully",
+		"hostedCluster", hcKey.String())
+
+	return ctrl.Result{}, nil
+}
+
+// mirrorConditions mirrors the 7 specific HostedCluster conditions to DPFHCPBridge
+// This simply copies the condition status, reason, and message from HostedCluster to DPFHCPBridge
+// No additional logic - just mirroring
+func (ss *StatusSyncer) mirrorConditions(ctx context.Context, cr *provisioningv1alpha1.DPFHCPBridge, hc *hyperv1.HostedCluster) {
+	log := logf.FromContext(ctx)
+
+	// Map of HostedCluster condition types to DPFHCPBridge condition types
+	// Key: HostedCluster condition type
+	// Value: DPFHCPBridge condition type
+	// Only mirror the 7 conditions specified in the DPFHCPBridge API
+	conditionMappings := map[string]string{
+		string(hyperv1.HostedClusterAvailable):         provisioningv1alpha1.HostedClusterAvailable,
+		string(hyperv1.HostedClusterProgressing):       provisioningv1alpha1.HostedClusterProgressing,
+		string(hyperv1.HostedClusterDegraded):          provisioningv1alpha1.HostedClusterDegraded,
+		string(hyperv1.ValidReleaseInfo):               provisioningv1alpha1.ValidReleaseInfo,
+		string(hyperv1.ValidReleaseImage):              provisioningv1alpha1.ValidReleaseImage,
+		string(hyperv1.IgnitionEndpointAvailable):      provisioningv1alpha1.IgnitionEndpointAvailable,
+		string(hyperv1.IgnitionServerValidReleaseInfo): provisioningv1alpha1.IgnitionServerValidReleaseInfo,
+	}
+
+	// Mirror each HostedCluster condition to DPFHCPBridge
+	for hcCondType, dpfCondType := range conditionMappings {
+		hcCond := meta.FindStatusCondition(hc.Status.Conditions, hcCondType)
+		if hcCond != nil {
+			// Found the condition, mirror it
+			meta.SetStatusCondition(&cr.Status.Conditions, metav1.Condition{
+				Type:               dpfCondType,
+				Status:             hcCond.Status,
+				Reason:             hcCond.Reason,
+				Message:            hcCond.Message,
+				ObservedGeneration: cr.Generation,
+			})
+			log.V(2).Info("Mirrored condition from HostedCluster",
+				"conditionType", dpfCondType,
+				"status", hcCond.Status,
+				"reason", hcCond.Reason)
+		}
+	}
+}