Factor out Hypervisor compute-service enabling/disabling to own controller

api/v1/hypervisor_types.go

@@ -180,7 +180,7 @@ type HypervisorSpec struct {
 	InstallCertificate bool `json:"installCertificate"`
 
 	// +kubebuilder:optional
-	// +kubebuilder:validation:Enum:="";manual;auto;ha;termination
+	// +kubebuilder:validation:Enum:="";manual;auto;ha;no-schedule;termination
 	// Maintenance indicates whether the hypervisor is in maintenance mode.
 	Maintenance string `json:"maintenance,omitempty"`
 
@@ -213,6 +213,7 @@ const (
 	MaintenanceManual      = "manual"      // manual maintenance mode by external user
 	MaintenanceAuto        = "auto"        // automatic maintenance mode
 	MaintenanceHA          = "ha"          // high availability maintenance mode
+	MaintenanceNoSchedule  = "no-schedule" // compute service disabled, no eviction
 	MaintenanceTermination = "termination" // internal use only, when node is terminating state
 )
 

charts/openstack-hypervisor-operator/crds/kvm.cloud.sap_hypervisors.yaml

@@ -222,6 +222,7 @@ spec:
                 - manual
                 - auto
                 - ha
+                - no-schedule
                 - termination
                 type: string
               maintenanceReason:

cmd/main.go

@@ -304,7 +304,6 @@ func main() {
 		setupLog.Error(err, "unable to create controller", "controller", "Eviction")
 		os.Exit(1)
 	}
-
 	if err = (&controller.HypervisorOffboardingReconciler{
 		Client: mgr.GetClient(),
 		Scheme: mgr.GetScheme(),
@@ -313,6 +312,14 @@ func main() {
 		os.Exit(1)
 	}
 
+	if err = (&controller.HypervisorComputeServiceController{
+		Client: mgr.GetClient(),
+		Scheme: mgr.GetScheme(),
+	}).SetupWithManager(mgr); err != nil {
+		setupLog.Error(err, "unable to create controller", "controller", controller.HypervisorComputeServiceControllerName)
+		os.Exit(1)
+	}
+
 	if err = (&controller.OnboardingController{
 		Client: mgr.GetClient(),
 		Scheme: mgr.GetScheme(),

internal/controller/aggregates_controller.go

@@ -19,20 +19,24 @@ package controller
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
+	k8sacmetav1 "k8s.io/client-go/applyconfigurations/meta/v1"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/builder"
 	k8sclient "sigs.k8s.io/controller-runtime/pkg/client"
 
 	"github.com/gophercloud/gophercloud/v2"
 
 	kvmv1 "github.com/cobaltcore-dev/openstack-hypervisor-operator/api/v1"
+	apiv1 "github.com/cobaltcore-dev/openstack-hypervisor-operator/applyconfigurations/api/v1"
 	"github.com/cobaltcore-dev/openstack-hypervisor-operator/internal/openstack"
 	"github.com/cobaltcore-dev/openstack-hypervisor-operator/internal/utils"
 )
@@ -76,17 +80,32 @@ func (ac *AggregatesController) Reconcile(ctx context.Context, req ctrl.Request)
 		// Apply aggregates to OpenStack and update status
 		aggregates, err := openstack.ApplyAggregates(ctx, ac.computeClient, hv.Name, desiredAggregateNames)
 		if err != nil {
-			// Set error condition with retry on conflict
-			condition := metav1.Condition{
-				Type:    kvmv1.ConditionTypeAggregatesUpdated,
-				Status:  metav1.ConditionFalse,
-				Reason:  kvmv1.ConditionReasonFailed,
-				Message: fmt.Errorf("failed to apply aggregates: %w", err).Error(),
+			// Set error condition, preserving current aggregate ownership
+			statusCfg := apiv1.HypervisorStatus()
+			if c := meta.FindStatusCondition(hv.Status.Conditions, kvmv1.ConditionTypeAggregatesUpdated); c != nil {
+				statusCfg.WithConditions(utils.ConditionFromStatus(*c))
+			}
+			utils.SetApplyConfigurationStatusCondition(&statusCfg.Conditions,
+				*k8sacmetav1.Condition().
+					WithType(kvmv1.ConditionTypeAggregatesUpdated).
+					WithStatus(metav1.ConditionFalse).
+					WithReason(kvmv1.ConditionReasonFailed).
+					WithMessage(fmt.Errorf("failed to apply aggregates: %w", err).Error()))
+			if len(hv.Status.Aggregates) > 0 {
+				aggCfgs := make([]apiv1.AggregateApplyConfiguration, len(hv.Status.Aggregates))
+				for i, agg := range hv.Status.Aggregates {
+					a := apiv1.Aggregate().WithName(agg.Name).WithUUID(agg.UUID)
+					if len(agg.Metadata) > 0 {
+						a.WithMetadata(agg.Metadata)
+					}
+					aggCfgs[i] = *a
+				}
+				statusCfg.Aggregates = aggCfgs
 			}
 
-			if err2 := utils.PatchHypervisorStatusWithRetry(ctx, ac.Client, hv.Name, AggregatesControllerName, func(h *kvmv1.Hypervisor) {
-				meta.SetStatusCondition(&h.Status.Conditions, condition)
-			}); err2 != nil {
+			if err2 := ac.Status().Apply(ctx,
+				apiv1.Hypervisor(hv.Name).WithStatus(statusCfg),
+				k8sclient.ForceOwnership, k8sclient.FieldOwner(AggregatesControllerName)); err2 != nil {
 				return ctrl.Result{}, errors.Join(err, err2)
 			}
 			return ctrl.Result{}, err
@@ -106,15 +125,54 @@ func (ac *AggregatesController) Reconcile(ctx context.Context, req ctrl.Request)
 		return ctrl.Result{}, nil
 	}
 
-	// Patch status with retry on conflict
-	err := utils.PatchHypervisorStatusWithRetry(ctx, ac.Client, hv.Name, AggregatesControllerName, func(h *kvmv1.Hypervisor) {
-		if aggregatesChanged {
-			h.Status.Aggregates = newAggregates
+	statusCfg := apiv1.HypervisorStatus()
+	if c := meta.FindStatusCondition(hv.Status.Conditions, kvmv1.ConditionTypeAggregatesUpdated); c != nil {
+		statusCfg.WithConditions(utils.ConditionFromStatus(*c))
+	}
+	utils.SetApplyConfigurationStatusCondition(&statusCfg.Conditions,
+		*k8sacmetav1.Condition().
+			WithType(desiredCondition.Type).
+			WithStatus(desiredCondition.Status).
+			WithReason(desiredCondition.Reason).
+			WithMessage(desiredCondition.Message))
+
+	if aggregatesChanged && len(newAggregates) > 0 {
+		aggCfgs := make([]apiv1.AggregateApplyConfiguration, len(newAggregates))
+		for i, agg := range newAggregates {
+			a := apiv1.Aggregate().WithName(agg.Name).WithUUID(agg.UUID)
+			if len(agg.Metadata) > 0 {
+				a.WithMetadata(agg.Metadata)
+			}
+			aggCfgs[i] = *a
+		}
+		statusCfg.Aggregates = aggCfgs
+	}
+
+	if err := ac.Status().Apply(ctx,
+		apiv1.Hypervisor(hv.Name).WithStatus(statusCfg),
+		k8sclient.ForceOwnership, k8sclient.FieldOwner(AggregatesControllerName)); err != nil {
+		return ctrl.Result{}, err
+	}
+
+	// The Aggregates field uses omitempty in the generated apply config, so an
+	// empty slice cannot be sent via SSA. Use a targeted merge patch to clear it.
+	if aggregatesChanged && len(newAggregates) == 0 {
+		patch, err := json.Marshal(map[string]any{
+			"status": map[string]any{
+				"aggregates": []kvmv1.Aggregate{},
+			},
+		})
+		if err != nil {
+			return ctrl.Result{}, err
+		}
+		fresh := &kvmv1.Hypervisor{}
+		if err := ac.Get(ctx, k8sclient.ObjectKey{Name: hv.Name}, fresh); err != nil {
+			return ctrl.Result{}, err
 		}
-		meta.SetStatusCondition(&h.Status.Conditions, desiredCondition)
-	})
+		return ctrl.Result{}, ac.Status().Patch(ctx, fresh, k8sclient.RawPatch(types.MergePatchType, patch))
+	}
 
-	return ctrl.Result{}, err
+	return ctrl.Result{}, nil
 }
 
 // determineDesiredState returns the desired aggregates and the corresponding condition