Fieldowner: add some missing Patch Fieldowners, break long lines

notandy · notandy · commit 34b1d176bea1 · 2025-12-17T14:10:54.000-05:00
diff --git a/internal/controller/aggregates_controller.go b/internal/controller/aggregates_controller.go
@@ -122,7 +122,8 @@ func (ac *AggregatesController) Reconcile(ctx context.Context, req ctrl.Request)
 		Reason:  kvmv1.ConditionReasonSucceeded,
 		Message: "Aggregates updated successfully",
 	})
-	return ctrl.Result{}, ac.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(AggregatesControllerName))
+	return ctrl.Result{}, ac.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base,
+		k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(AggregatesControllerName))
 }
 
 // setErrorCondition sets the error condition on the Hypervisor status, returns error if update fails
@@ -136,7 +137,8 @@ func (ac *AggregatesController) setErrorCondition(ctx context.Context, hv *kvmv1
 
 	base := hv.DeepCopy()
 	if meta.SetStatusCondition(&hv.Status.Conditions, condition) {
-		if err := ac.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(AggregatesControllerName)); err != nil {
+		if err := ac.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base,
+			k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(AggregatesControllerName)); err != nil {
 			return err
 		}
 	}
diff --git a/internal/controller/decomission_controller.go b/internal/controller/decomission_controller.go
@@ -179,7 +179,8 @@ func (r *NodeDecommissionReconciler) removeFinalizer(ctx context.Context, node *
 
 	nodeBase := node.DeepCopy()
 	controllerutil.RemoveFinalizer(node, decommissionFinalizerName)
-	err := r.Patch(ctx, node, k8sclient.MergeFromWithOptions(nodeBase, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(DecommissionControllerName))
+	err := r.Patch(ctx, node, k8sclient.MergeFromWithOptions(nodeBase,
+		k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(DecommissionControllerName))
 	return ctrl.Result{}, err
 }
 
@@ -191,7 +192,8 @@ func (r *NodeDecommissionReconciler) setDecommissioningCondition(ctx context.Con
 		Reason:  "Decommissioning",
 		Message: message,
 	})
-	if err := r.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(DecommissionControllerName)); err != nil {
+	if err := r.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base,
+		k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(DecommissionControllerName)); err != nil {
 		return ctrl.Result{}, fmt.Errorf("cannot update hypervisor status due to %w", err)
 	}
 	return ctrl.Result{}, nil
diff --git a/internal/controller/eviction_controller.go b/internal/controller/eviction_controller.go
@@ -154,7 +154,8 @@ func (r *EvictionReconciler) handleRunning(ctx context.Context, eviction *kvmv1.
 }
 
 func (r *EvictionReconciler) updateStatus(ctx context.Context, eviction, base *kvmv1.Eviction) error {
-	return r.Status().Patch(ctx, eviction, client.MergeFromWithOptions(base, client.MergeFromWithOptimisticLock{}), client.FieldOwner(EvictionControllerName))
+	return r.Status().Patch(ctx, eviction, client.MergeFromWithOptions(base,
+		client.MergeFromWithOptimisticLock{}), client.FieldOwner(EvictionControllerName))
 }
 
 func (r *EvictionReconciler) handlePreflight(ctx context.Context, eviction *kvmv1.Eviction) (ctrl.Result, error) {
diff --git a/internal/controller/hypervisor_controller.go b/internal/controller/hypervisor_controller.go
@@ -127,24 +127,27 @@ func (hv *HypervisorController) Reconcile(ctx context.Context, req ctrl.Request)
 		}
 
 		if !equality.Semantic.DeepEqual(hypervisor, base) {
-			return ctrl.Result{}, hv.Status().Patch(ctx, hypervisor, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(HypervisorControllerName))
+			return ctrl.Result{}, hv.Status().Patch(ctx, hypervisor, k8sclient.MergeFromWithOptions(base,
+				k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(HypervisorControllerName))
 		}
 
 		syncLabelsAndAnnotations(nodeLabels, hypervisor, node)
 		if equality.Semantic.DeepEqual(hypervisor, base) {
 			return ctrl.Result{}, nil
 		}
 
-		return ctrl.Result{}, hv.Patch(ctx, hypervisor, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(HypervisorControllerName))
+		return ctrl.Result{}, hv.Patch(ctx, hypervisor, k8sclient.MergeFromWithOptions(base,
+			k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(HypervisorControllerName))
 	}
 
 	syncLabelsAndAnnotations(nodeLabels, hypervisor, node)
 
-	if err := controllerutil.SetOwnerReference(node, hypervisor, hv.Scheme, controllerutil.WithBlockOwnerDeletion(true)); err != nil {
+	if err := controllerutil.SetOwnerReference(node, hypervisor, hv.Scheme,
+		controllerutil.WithBlockOwnerDeletion(true)); err != nil {
 		return ctrl.Result{}, fmt.Errorf("failed setting controller reference: %w", err)
 	}
 
-	if err := hv.Create(ctx, hypervisor); err != nil {
+	if err := hv.Create(ctx, hypervisor, k8sclient.FieldOwner(HypervisorControllerName)); err != nil {
 		return ctrl.Result{}, err
 	}
 
diff --git a/internal/controller/hypervisor_maintenance_controller.go b/internal/controller/hypervisor_maintenance_controller.go
@@ -86,7 +86,8 @@ func (hec *HypervisorMaintenanceController) Reconcile(ctx context.Context, req c
 		return ctrl.Result{}, nil
 	}
 
-	return ctrl.Result{}, hec.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(old, k8sclient.MergeFromWithOptimisticLock{}))
+	return ctrl.Result{}, hec.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(old,
+		k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(MaintenanceControllerName))
 }
 
 func (hec *HypervisorMaintenanceController) reconcileComputeService(ctx context.Context, hv *kvmv1.Hypervisor) error {
diff --git a/internal/controller/hypervisor_taint_controller.go b/internal/controller/hypervisor_taint_controller.go
@@ -84,7 +84,8 @@ func (r *HypervisorTaintController) Reconcile(ctx context.Context, req ctrl.Requ
 		return ctrl.Result{}, nil
 	}
 
-	return ctrl.Result{}, r.Status().Patch(ctx, hypervisor, k8sclient.MergeFromWithOptions(before, k8sclient.MergeFromWithOptimisticLock{}))
+	return ctrl.Result{}, r.Status().Patch(ctx, hypervisor, k8sclient.MergeFromWithOptions(before,
+		k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(HypervisorTaintControllerName))
 }
 
 func (r *HypervisorTaintController) SetupWithManager(mgr ctrl.Manager) error {
diff --git a/internal/controller/onboarding_controller.go b/internal/controller/onboarding_controller.go
@@ -286,7 +286,9 @@ func (r *OnboardingController) smokeTest(ctx context.Context, hv *kvmv1.Hypervis
 
 		return ctrl.Result{RequeueAfter: defaultWaitTime}, nil
 	case "ACTIVE":
-		consoleOutput, err := servers.ShowConsoleOutput(ctx, r.testComputeClient, server.ID, servers.ShowConsoleOutputOpts{Length: 11}).Extract()
+		consoleOutput, err := servers.
+			ShowConsoleOutput(ctx, r.testComputeClient, server.ID, servers.ShowConsoleOutputOpts{Length: 11}).
+			Extract()
 		if err != nil {
 			base := hv.DeepCopy()
 			meta.SetStatusCondition(&hv.Status.Conditions, metav1.Condition{
@@ -605,7 +607,8 @@ func (r *OnboardingController) findTestFlavor(ctx context.Context) (string, erro
 }
 
 func (r *OnboardingController) patchStatus(ctx context.Context, hv, base *kvmv1.Hypervisor) error {
-	return r.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(OnboardingControllerName))
+	return r.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base,
+		k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(OnboardingControllerName))
 }
 
 // SetupWithManager sets up the controller with the Manager.
diff --git a/internal/controller/traits_controller.go b/internal/controller/traits_controller.go
@@ -96,7 +96,8 @@ func (tc *TraitsController) Reconcile(ctx context.Context, req ctrl.Request) (ct
 		base := hv.DeepCopy()
 		if meta.SetStatusCondition(&hv.Status.Conditions,
 			getTraitCondition(err, "Failed to get current traits from placement")) {
-			err = errors.Join(tc.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(TraitsControllerName)))
+			err = errors.Join(tc.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base,
+				k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(TraitsControllerName)))
 		}
 		return ctrl.Result{}, err
 	}
@@ -128,7 +129,8 @@ func (tc *TraitsController) Reconcile(ctx context.Context, req ctrl.Request) (ct
 			base := hv.DeepCopy()
 			if meta.SetStatusCondition(&hv.Status.Conditions,
 				getTraitCondition(err, "Failed to update traits in placement")) {
-				err = errors.Join(tc.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(TraitsControllerName)))
+				err = errors.Join(tc.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base,
+					k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(TraitsControllerName)))
 			}
 			return ctrl.Result{}, err
 		}
@@ -138,7 +140,8 @@ func (tc *TraitsController) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	// update status unconditionally, since we want always to propagate the current traits
 	hv.Status.Traits = targetTraits
 	meta.SetStatusCondition(&hv.Status.Conditions, getTraitCondition(nil, "Traits successfully updated"))
-	return ctrl.Result{}, tc.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(TraitsControllerName))
+	return ctrl.Result{}, tc.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base,
+		k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(TraitsControllerName))
 }
 
 // getTraitCondition creates a Condition object for trait updates

Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,8 @@ func (ac *AggregatesController) Reconcile(ctx context.Context, req ctrl.Request)`
`122`	`122`	`Reason: kvmv1.ConditionReasonSucceeded,`
`123`	`123`	`Message: "Aggregates updated successfully",`
`124`	`124`	`})`
`125`		`- return ctrl.Result{}, ac.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(AggregatesControllerName))`
	`125`	`+ return ctrl.Result{}, ac.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base,`
	`126`	`+ k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(AggregatesControllerName))`
`126`	`127`	`}`
`127`	`128`
`128`	`129`	`// setErrorCondition sets the error condition on the Hypervisor status, returns error if update fails`
`@@ -136,7 +137,8 @@ func (ac AggregatesController) setErrorCondition(ctx context.Context, hv kvmv1`
`136`	`137`
`137`	`138`	`base := hv.DeepCopy()`
`138`	`139`	`if meta.SetStatusCondition(&hv.Status.Conditions, condition) {`
`139`		`- if err := ac.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(AggregatesControllerName)); err != nil {`
	`140`	`+ if err := ac.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base,`
	`141`	`+ k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(AggregatesControllerName)); err != nil {`
`140`	`142`	`return err`
`141`	`143`	`}`
`142`	`144`	`}`
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,8 @@ func (r EvictionReconciler) handleRunning(ctx context.Context, eviction kvmv1.`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`func (r EvictionReconciler) updateStatus(ctx context.Context, eviction, base kvmv1.Eviction) error {`
`157`		`- return r.Status().Patch(ctx, eviction, client.MergeFromWithOptions(base, client.MergeFromWithOptimisticLock{}), client.FieldOwner(EvictionControllerName))`
	`157`	`+ return r.Status().Patch(ctx, eviction, client.MergeFromWithOptions(base,`
	`158`	`+ client.MergeFromWithOptimisticLock{}), client.FieldOwner(EvictionControllerName))`
`158`	`159`	`}`
`159`	`160`
`160`	`161`	`func (r EvictionReconciler) handlePreflight(ctx context.Context, eviction kvmv1.Eviction) (ctrl.Result, error) {`
Original file line number	Diff line number	Diff line change
`@@ -127,24 +127,27 @@ func (hv *HypervisorController) Reconcile(ctx context.Context, req ctrl.Request)`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`if !equality.Semantic.DeepEqual(hypervisor, base) {`
`130`		`- return ctrl.Result{}, hv.Status().Patch(ctx, hypervisor, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(HypervisorControllerName))`
	`130`	`+ return ctrl.Result{}, hv.Status().Patch(ctx, hypervisor, k8sclient.MergeFromWithOptions(base,`
	`131`	`+ k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(HypervisorControllerName))`
`131`	`132`	`}`
`132`	`133`
`133`	`134`	`syncLabelsAndAnnotations(nodeLabels, hypervisor, node)`
`134`	`135`	`if equality.Semantic.DeepEqual(hypervisor, base) {`
`135`	`136`	`return ctrl.Result{}, nil`
`136`	`137`	`}`
`137`	`138`
`138`		`- return ctrl.Result{}, hv.Patch(ctx, hypervisor, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(HypervisorControllerName))`
	`139`	`+ return ctrl.Result{}, hv.Patch(ctx, hypervisor, k8sclient.MergeFromWithOptions(base,`
	`140`	`+ k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(HypervisorControllerName))`
`139`	`141`	`}`
`140`	`142`
`141`	`143`	`syncLabelsAndAnnotations(nodeLabels, hypervisor, node)`
`142`	`144`
`143`		`- if err := controllerutil.SetOwnerReference(node, hypervisor, hv.Scheme, controllerutil.WithBlockOwnerDeletion(true)); err != nil {`
	`145`	`+ if err := controllerutil.SetOwnerReference(node, hypervisor, hv.Scheme,`
	`146`	`+ controllerutil.WithBlockOwnerDeletion(true)); err != nil {`
`144`	`147`	`return ctrl.Result{}, fmt.Errorf("failed setting controller reference: %w", err)`
`145`	`148`	`}`
`146`	`149`
`147`		`- if err := hv.Create(ctx, hypervisor); err != nil {`
	`150`	`+ if err := hv.Create(ctx, hypervisor, k8sclient.FieldOwner(HypervisorControllerName)); err != nil {`
`148`	`151`	`return ctrl.Result{}, err`
`149`	`152`	`}`
`150`	`153`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,8 @@ func (hec *HypervisorMaintenanceController) Reconcile(ctx context.Context, req c`
`86`	`86`	`return ctrl.Result{}, nil`
`87`	`87`	`}`
`88`	`88`
`89`		`- return ctrl.Result{}, hec.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(old, k8sclient.MergeFromWithOptimisticLock{}))`
	`89`	`+ return ctrl.Result{}, hec.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(old,`
	`90`	`+ k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(MaintenanceControllerName))`
`90`	`91`	`}`
`91`	`92`
`92`	`93`	`func (hec HypervisorMaintenanceController) reconcileComputeService(ctx context.Context, hv kvmv1.Hypervisor) error {`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,8 @@ func (r *HypervisorTaintController) Reconcile(ctx context.Context, req ctrl.Requ`
`84`	`84`	`return ctrl.Result{}, nil`
`85`	`85`	`}`
`86`	`86`
`87`		`- return ctrl.Result{}, r.Status().Patch(ctx, hypervisor, k8sclient.MergeFromWithOptions(before, k8sclient.MergeFromWithOptimisticLock{}))`
	`87`	`+ return ctrl.Result{}, r.Status().Patch(ctx, hypervisor, k8sclient.MergeFromWithOptions(before,`
	`88`	`+ k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(HypervisorTaintControllerName))`
`88`	`89`	`}`
`89`	`90`
`90`	`91`	`func (r *HypervisorTaintController) SetupWithManager(mgr ctrl.Manager) error {`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,8 @@ func (tc *TraitsController) Reconcile(ctx context.Context, req ctrl.Request) (ct`
`96`	`96`	`base := hv.DeepCopy()`
`97`	`97`	`if meta.SetStatusCondition(&hv.Status.Conditions,`
`98`	`98`	`getTraitCondition(err, "Failed to get current traits from placement")) {`
`99`		`- err = errors.Join(tc.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(TraitsControllerName)))`
	`99`	`+ err = errors.Join(tc.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base,`
	`100`	`+ k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(TraitsControllerName)))`
`100`	`101`	`}`
`101`	`102`	`return ctrl.Result{}, err`
`102`	`103`	`}`
`@@ -128,7 +129,8 @@ func (tc *TraitsController) Reconcile(ctx context.Context, req ctrl.Request) (ct`
`128`	`129`	`base := hv.DeepCopy()`
`129`	`130`	`if meta.SetStatusCondition(&hv.Status.Conditions,`
`130`	`131`	`getTraitCondition(err, "Failed to update traits in placement")) {`
`131`		`- err = errors.Join(tc.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(TraitsControllerName)))`
	`132`	`+ err = errors.Join(tc.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base,`
	`133`	`+ k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(TraitsControllerName)))`
`132`	`134`	`}`
`133`	`135`	`return ctrl.Result{}, err`
`134`	`136`	`}`
`@@ -138,7 +140,8 @@ func (tc *TraitsController) Reconcile(ctx context.Context, req ctrl.Request) (ct`
`138`	`140`	`// update status unconditionally, since we want always to propagate the current traits`
`139`	`141`	`hv.Status.Traits = targetTraits`
`140`	`142`	`meta.SetStatusCondition(&hv.Status.Conditions, getTraitCondition(nil, "Traits successfully updated"))`
`141`		`- return ctrl.Result{}, tc.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base, k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(TraitsControllerName))`
	`143`	`+ return ctrl.Result{}, tc.Status().Patch(ctx, hv, k8sclient.MergeFromWithOptions(base,`
	`144`	`+ k8sclient.MergeFromWithOptimisticLock{}), k8sclient.FieldOwner(TraitsControllerName))`
`142`	`145`	`}`
`143`	`146`
`144`	`147`	`// getTraitCondition creates a Condition object for trait updates`