use metav1.Condition instead of a custom Condition interface in the conditions and status updater packages

Author: Diaphteiros

docs/libs/status.md

@@ -3,34 +3,19 @@
 ## Conditions
 
 The `pkg/conditions` package helps with managing condition lists which can often be found in the status of k8s resources.
+It expects the conditions to be of the `Condition` type from the `k8s.io/apimachinery/pkg/apis/meta/v1` package.
 
-The managed condition implementation must satisfy the `Condition[T comparable]` interface:
-```go
-type Condition[T comparable] interface {
-	GetType() string
-	SetType(conType string)
-	GetStatus() T
-	SetStatus(status T)
-	GetLastTransitionTime() time.Time
-	SetLastTransitionTime(timestamp time.Time)
-	GetReason() string
-	SetReason(reason string)
-	GetMessage() string
-	SetMessage(message string)
-}
-```
-
-To manage conditions, use the `ConditionUpdater` function and pass in a constructor function for your condition implementation and the old list of conditions. The bool argument determines whether old conditions that are not updated remain in the returned list (`false`) or are removed, so that the returned list contains only the conditions that were touched (`true`).
+To manage conditions, use the `ConditionUpdater` function and pass in the old list of conditions. The bool argument determines whether old conditions that are not updated remain in the returned list (`false`) or are removed, so that the returned list contains only the conditions that were touched (`true`).
 
 ```go
-updater := conditions.ConditionUpdater(func() conditions.Condition[bool] { return &conImpl{} }, oldCons, false)
+updater := conditions.ConditionUpdater(oldCons, false)
 ```
 
 Note that the `ConditionUpdater` stores the current time upon initialization and will set each updated condition's timestamp to this value, if the status of that condition changed as a result of the update. To use a different timestamp, manually overwrite the `Now` field of the updater.
 
 Use `UpdateCondition` or `UpdateConditionFromTemplate` to update a condition:
 ```go
-updater.UpdateCondition("myCondition", true, "newReason", "newMessage")
+updater.UpdateCondition("myCondition", conditions.FromBool(true), myObj.Generation, "newReason", "newMessage")
 ```
 
 If all conditions are updated, use the `Conditions` method to generate the new list of conditions. The originally passed in list of conditions is not modified by the updater.
@@ -41,7 +26,7 @@ updatedCons, changed := updater.Conditions()
 
 For simplicity, all commands can be chained:
 ```go
-updatedCons, changed := conditions.ConditionUpdater(func() conditions.Condition[bool] { return &conImpl{} }, oldCons, false).UpdateCondition("myCondition", true, "newReason", "newMessage").Conditions()
+updatedCons, changed := conditions.ConditionUpdater(oldCons, false).UpdateCondition("myCondition", conditions.FromBool(true), myObj.Generation, "newReason", "newMessage").Conditions()
 ```
 
 ## Status Updater
@@ -68,7 +53,7 @@ type MyStatus struct {
 
 	// Conditions contains the conditions.
 	// +optional
-	Conditions []MyCondition `json:"conditions,omitempty"`
+	Conditions []metav1.Condition `json:"conditions,omitempty"`
 }
 ```
 
@@ -82,78 +67,66 @@ import (
 )
 
 // optional, using a type alias removes the need to specify the type arguments every time
-type ReconcileResult = ctrlutils.ReconcileResult[*v1alpha1.MyResource, v1alpha1.ConditionStatus]
+type ReconcileResult = ctrlutils.ReconcileResult[*v1alpha1.MyResource]
 
 // this is the method called by the controller-runtime
-func (r *GardenerMyResourceReconciler) Reconcile(ctx context.Context, req reconcile.Request) (reconcile.Result, error) {
+func (r *MyResourceReconciler) Reconcile(ctx context.Context, req reconcile.Request) (reconcile.Result, error) {
 	rr := r.reconcile(ctx, req)
 	// status update
-	return ctrlutils.NewStatusUpdaterBuilder[*v1alpha1.MyResource, v1alpha1.MyResourcePhase, v1alpha1.ConditionStatus]().
-		WithPhaseUpdateFunc(func(obj *v1alpha1.MyResource, rr ctrlutils.ReconcileResult[*v1alpha1.MyResource, v1alpha1.ConditionStatus]) (v1alpha1.MyResourcePhase, error) {
+	return ctrlutils.NewStatusUpdaterBuilder[*v1alpha1.MyResource]().
+		WithPhaseUpdateFunc(func(obj *v1alpha1.MyResource, rr ReconcileResult) (v1alpha1.MyResourcePhase, error) {
 			if rr.ReconcileError != nil {
-				return v1alpha1.PROVIDER_CONFIG_PHASE_FAILED, nil
+				return v1alpha1.MY_PHASE_FAILED, nil
 			}
 			if len(rr.Conditions) > 0 {
 				for _, con := range rr.Conditions {
 					if con.GetStatus() != v1alpha1.CONDITION_TRUE {
-						return v1alpha1.PROVIDER_CONFIG_PHASE_FAILED, nil
+						return v1alpha1.MY_PHASE_FAILED, nil
 					}
 				}
 			}
-			return v1alpha1.PROVIDER_CONFIG_PHASE_SUCCEEDED, nil
+			return v1alpha1.MY_PHASE_SUCCEEDED, nil
 		}).
-		WithConditionUpdater(func() conditions.Condition[v1alpha1.ConditionStatus] {
-			return &v1alpha1.Condition{}
-		}, true).
+		WithConditionUpdater(true).
 		Build().
 		UpdateStatus(ctx, r.PlatformCluster.Client(), rr)
 }
 
-func (r *GardenerProviderConfigReconciler) reconcile(ctx context.Context, req reconcile.Request) ReconcileResult {
+func (r *MyResourceReconciler) reconcile(ctx context.Context, req reconcile.Request) ReconcileResult {
 	// actual reconcile logic here
 }
 ```
 
-Some information regarding the example:
-- `v1alpha1.MyResource` is the resource type being reconciled in this example.
-- `v1alpha1.MyResourcePhase` is the type of the `Phase` field used in the status of `MyResource`.
-	- It must be a string-like type, e.g. `type MyResourcePhase string`.
-	- If the resource status doesn't have a `Phase` or updating it is not desired, simply set this type argument to `string`.
-- `v1alpha1.ConditionStatus` is the type of the `Status` field within the conditions. It must be `comparable`.
-	- Usually, this will either be a boolean or a string-like type.
-	- If the resource status doesn't have conditions or updating them is not desired, simply set this type argument to `bool`.
-- The conditions must be a list of a type `T`, where either `T` or `*T` implements the `conditions.Condition[ConType]` interface.
-	- `ConType` is `v1alpha1.ConditionStatus` in this example.
-
+`v1alpha1.MyResource` is the resource type being reconciled in this example.
 
 ### How to use the status updater
 
 It is recommended to move the actual reconciliation logic into a helper function (`reconcile` in the example). This makes it easier to ensure that the status updater is always called, no matter where the reconciliation exits, e.g. due to an error. This helper function should then return the `ReconcileResult` required by the status updater.
 
 First, initialize a new `StatusUpdaterBuilder`:
 ```go
-ctrlutils.NewStatusUpdaterBuilder[*v1alpha1.MyResource, v1alpha1.MyResourcePhase, v1alpha1.ConditionStatus]()
+ctrlutils.NewStatusUpdaterBuilder[*v1alpha1.MyResource]()
 ```
-It takes the type of the reconciled resource, the type of its `Phase` attribute and the type of the `Status` attribute of its conditions as type arguments.
+It takes the type of the reconciled resource as type argument.
 
 If you want to update the phase, you have to pass in a function that computes the new phase based on the the current state of the object and the returned reconcile result. Note that the function just has to return the phase, not to set it in the object. Failing to provide this function causes the updater to use a dummy implementation that sets the phase to the empty string.
 ```go
-WithPhaseUpdateFunc(func(obj *v1alpha1.MyResource, rr ctrlutils.ReconcileResult[*v1alpha1.MyResource, v1alpha1.ConditionStatus]) (v1alpha1.MyResourcePhase, error) {
+WithPhaseUpdateFunc(func(obj *v1alpha1.MyResource, rr ctrlutils.ReconcileResult[*v1alpha1.MyResource]) (v1alpha1.MyResourcePhase, error) {
 	if rr.ReconcileError != nil {
-		return v1alpha1.PROVIDER_CONFIG_PHASE_FAILED, nil
+		return v1alpha1.MY_PHASE_FAILED, nil
 	}
 	if len(rr.Conditions) > 0 {
 		for _, con := range rr.Conditions {
 			if con.GetStatus() != v1alpha1.CONDITION_TRUE {
-				return v1alpha1.PROVIDER_CONFIG_PHASE_FAILED, nil
+				return v1alpha1.MY_PHASE_FAILED, nil
 			}
 		}
 	}
-	return v1alpha1.PROVIDER_CONFIG_PHASE_SUCCEEDED, nil
+	return v1alpha1.MY_PHASE_SUCCEEDED, nil
 })
 ```
 
-If the conditions should be updated, the `WithConditionUpdater` method must be called. Similarly to the condition updater from the `conditions` package - which is used internally - it requires a constructor function that returns a new, empty instance of the controller-specific `conditions.Condition` implementation. The second argument specifies whether existing conditions that are not part of the updated conditions in the `ReconcileResult` should be removed or kept.
+If the conditions should be updated, the `WithConditionUpdater` method must be called. The argument specifies whether existing conditions that are not part of the updated conditions in the `ReconcileResult` should be removed or kept.
 
 You can then `Build()` the status updater and run `UpdateStatus()` to do the actual status update. The return values of this method are meant to be returned by the `Reconcile` function.
 

pkg/conditions/conditions.go

@@ -1,50 +1,59 @@
 package conditions
 
-import "time"
-
-// Condition represents a condition consisting of type, status, reason, message and a last transition timestamp.
-type Condition[T comparable] interface {
-	// SetStatus sets the status of the condition.
-	SetStatus(status T)
-	// GetStatus returns the status of the condition.
-	GetStatus() T
-
-	// SetType sets the type of the condition.
-	SetType(conType string)
-	// GetType returns the type of the condition.
-	GetType() string
-
-	// SetLastTransitionTime sets the timestamp of the condition.
-	SetLastTransitionTime(timestamp time.Time)
-	// GetLastTransitionTime returns the timestamp of the condition.
-	GetLastTransitionTime() time.Time
+import (
+	apimeta "k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// GetCondition is an alias for apimeta.FindStatusCondition.
+// It returns a pointer to the condition of the specified type from the given conditions slice, or nil if not found.
+func GetCondition(conditions []metav1.Condition, conditionType string) *metav1.Condition {
+	return apimeta.FindStatusCondition(conditions, conditionType)
+}
 
-	// SetReason sets the reason of the condition.
-	SetReason(reason string)
-	// GetReason returns the reason of the condition.
-	GetReason() string
+// FromBoolPointer returns the metav1.ConditionStatus that matches the given bool pointer.
+// nil = ConditionUnknown
+// true = ConditionTrue
+// false = ConditionFalse
+func FromBoolPointer(status *bool) metav1.ConditionStatus {
+	if status == nil {
+		return metav1.ConditionUnknown
+	}
+	if *status {
+		return metav1.ConditionTrue
+	}
+	return metav1.ConditionFalse
+}
 
-	// SetMessage sets the message of the condition.
-	SetMessage(message string)
-	// GetMessage returns the message of the condition.
-	GetMessage() string
+// FromBool returns the metav1.ConditionStatus that matches the given bool value.
+// true = ConditionTrue
+// false = ConditionFalse
+func FromBool(status bool) metav1.ConditionStatus {
+	return FromBoolPointer(&status)
 }
 
-// GetCondition returns a pointer to the condition for the given type, if it exists.
-// Otherwise, nil is returned.
-func GetCondition[T comparable](ccl []Condition[T], t string) Condition[T] {
-	for i := range ccl {
-		if ccl[i].GetType() == t {
-			return ccl[i]
-		}
+// ToBoolPointer is the inverse of FromBoolPointer.
+// It returns a pointer to a bool that matches the given ConditionStatus.
+// If the status is ConditionTrue, it returns a pointer to true.
+// If the status is ConditionFalse, it returns a pointer to false.
+// If the status is ConditionUnknown or any unknown value, it returns nil.
+func ToBoolPointer(status metav1.ConditionStatus) *bool {
+	var res *bool
+	switch status {
+	case metav1.ConditionTrue:
+		tmp := true
+		res = &tmp
+	case metav1.ConditionFalse:
+		tmp := false
+		res = &tmp
 	}
-	return nil
+	return res
 }
 
 // AllConditionsHaveStatus returns true if all conditions have the specified status.
-func AllConditionsHaveStatus[T comparable](status T, conditions ...Condition[T]) bool {
+func AllConditionsHaveStatus(status metav1.ConditionStatus, conditions ...metav1.Condition) bool {
 	for _, con := range conditions {
-		if con.GetStatus() != status {
+		if con.Status != status {
 			return false
 		}
 	}

pkg/conditions/updater.go

@@ -3,18 +3,17 @@ package conditions
 import (
 	"slices"
 	"strings"
-	"time"
 
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/sets"
 )
 
 // conditionUpdater is a helper struct for updating a list of Conditions.
 // Use the ConditionUpdater constructor for initializing.
-type conditionUpdater[T comparable] struct {
-	Now        time.Time
-	conditions map[string]Condition[T]
+type conditionUpdater struct {
+	Now        metav1.Time
+	conditions map[string]metav1.Condition
 	updated    sets.Set[string]
-	construct  func() Condition[T]
 	changed    bool
 }
 
@@ -30,15 +29,14 @@ type conditionUpdater[T comparable] struct {
 //
 // Usage example:
 // status.conditions = ConditionUpdater(status.conditions, true).UpdateCondition(...).UpdateCondition(...).Conditions()
-func ConditionUpdater[T comparable](construct func() Condition[T], conditions []Condition[T], removeUntouched bool) *conditionUpdater[T] {
-	res := &conditionUpdater[T]{
-		Now:        time.Now(),
-		conditions: make(map[string]Condition[T], len(conditions)),
-		construct:  construct,
+func ConditionUpdater(conditions []metav1.Condition, removeUntouched bool) *conditionUpdater {
+	res := &conditionUpdater{
+		Now:        metav1.Now(),
+		conditions: make(map[string]metav1.Condition, len(conditions)),
 		changed:    false,
 	}
 	for _, con := range conditions {
-		res.conditions[con.GetType()] = con
+		res.conditions[con.Type] = con
 	}
 	if removeUntouched {
 		res.updated = sets.New[string]()
@@ -49,21 +47,23 @@ func ConditionUpdater[T comparable](construct func() Condition[T], conditions []
 // UpdateCondition updates or creates the condition with the specified type.
 // All fields of the condition are updated with the values given in the arguments, but the condition's LastTransitionTime is only updated (with the timestamp contained in the receiver struct) if the status changed.
 // Returns the receiver for easy chaining.
-func (c *conditionUpdater[T]) UpdateCondition(conType string, status T, reason, message string) *conditionUpdater[T] {
-	con := c.construct()
-	con.SetType(conType)
-	con.SetStatus(status)
-	con.SetReason(reason)
-	con.SetMessage(message)
-	con.SetLastTransitionTime(c.Now)
+func (c *conditionUpdater) UpdateCondition(conType string, status metav1.ConditionStatus, observedGeneration int64, reason, message string) *conditionUpdater {
+	con := metav1.Condition{
+		Type:               conType,
+		Status:             status,
+		Reason:             reason,
+		Message:            message,
+		ObservedGeneration: observedGeneration,
+		LastTransitionTime: c.Now,
+	}
 	old, ok := c.conditions[conType]
-	if ok && old.GetStatus() == con.GetStatus() {
+	if ok && old.Status == con.Status {
 		// update LastTransitionTime only if status changed
-		con.SetLastTransitionTime(old.GetLastTransitionTime())
+		con.LastTransitionTime = old.LastTransitionTime
 	}
 	if !c.changed {
 		if ok {
-			c.changed = old.GetStatus() != con.GetStatus() || old.GetReason() != con.GetReason() || old.GetMessage() != con.GetMessage()
+			c.changed = old.Status != con.Status || old.Reason != con.Reason || old.Message != con.Message
 		} else {
 			c.changed = true
 		}
@@ -76,18 +76,18 @@ func (c *conditionUpdater[T]) UpdateCondition(conType string, status T, reason,
 }
 
 // UpdateConditionFromTemplate is a convenience wrapper around UpdateCondition which allows it to be called with a preconstructed ComponentCondition.
-func (c *conditionUpdater[T]) UpdateConditionFromTemplate(con Condition[T]) *conditionUpdater[T] {
-	return c.UpdateCondition(con.GetType(), con.GetStatus(), con.GetReason(), con.GetMessage())
+func (c *conditionUpdater) UpdateConditionFromTemplate(con metav1.Condition) *conditionUpdater {
+	return c.UpdateCondition(con.Type, con.Status, con.ObservedGeneration, con.Reason, con.Message)
 }
 
 // HasCondition returns true if a condition with the given type exists in the updated condition list.
-func (c *conditionUpdater[T]) HasCondition(conType string) bool {
+func (c *conditionUpdater) HasCondition(conType string) bool {
 	_, ok := c.conditions[conType]
 	return ok && (c.updated == nil || c.updated.Has(conType))
 }
 
 // RemoveCondition removes the condition with the given type from the updated condition list.
-func (c *conditionUpdater[T]) RemoveCondition(conType string) *conditionUpdater[T] {
+func (c *conditionUpdater) RemoveCondition(conType string) *conditionUpdater {
 	if !c.HasCondition(conType) {
 		return c
 	}
@@ -104,21 +104,21 @@ func (c *conditionUpdater[T]) RemoveCondition(conType string) *conditionUpdater[
 // in between the condition updater creation and this method call. Otherwise, it will potentially also contain old conditions.
 // The conditions are returned sorted by their type.
 // The second return value indicates whether the condition list has actually changed.
-func (c *conditionUpdater[T]) Conditions() ([]Condition[T], bool) {
-	res := make([]Condition[T], 0, len(c.conditions))
+func (c *conditionUpdater) Conditions() ([]metav1.Condition, bool) {
+	res := make([]metav1.Condition, 0, len(c.conditions))
 	for _, con := range c.conditions {
 		if c.updated == nil {
 			res = append(res, con)
 			continue
 		}
-		if c.updated.Has(con.GetType()) {
+		if c.updated.Has(con.Type) {
 			res = append(res, con)
 		} else {
 			c.changed = true
 		}
 	}
-	slices.SortStableFunc(res, func(a, b Condition[T]) int {
-		return strings.Compare(a.GetType(), b.GetType())
+	slices.SortStableFunc(res, func(a, b metav1.Condition) int {
+		return strings.Compare(a.Type, b.Type)
 	})
 	return res, c.changed
 }