Add conditions to the Machine object

Author: fabriziopandini

api/v1alpha2/conversion.go

@@ -118,6 +118,7 @@ func (src *Machine) ConvertTo(dstRaw conversion.Hub) error {
 	}
 	restoreMachineSpec(&restored.Spec, &dst.Spec)
 	dst.Status.ObservedGeneration = restored.Status.ObservedGeneration
+	dst.Status.Conditions = restored.Status.Conditions
 
 	return nil
 }

api/v1alpha2/zz_generated.conversion.go

@@ -25,3 +25,34 @@ const (
 )
 
 // ANCHOR_END: CommonConditions
+
+// Conditions and condition Reasons for the Machine object
+
+// MachineConditionsCount defines the total number of conditions on the Machine object.
+const MachineConditionsCount = 2
+
+const (
+	// BootstrapReadyCondition reports a summary of current status of the bootstrap object defined for this machine.
+	// This condition is mirrored from the Ready condition in the bootstrap ref object, and
+	// the absence of this condition might signal problems in the reconcile external loops or the fact that
+	// the bootstrap provider does not not implements the Ready condition yet.
+	BootstrapReadyCondition ConditionType = "BootstrapReady"
+
+	// WaitingForDataSecretFallbackReason (Severity=Info) documents a machine waiting for the bootstrap data secret
+	// to be available.
+	// NOTE: This reason is used only as a fallback when the bootstrap object is not reporting its own ready condition.
+	WaitingForDataSecretFallbackReason = "WaitingForDataSecret"
+)
+
+const (
+	// InfrastructureReadyCondition reports a summary of current status of the infrastructure object defined for this machine.
+	// This condition is mirrored from the Ready condition in the infrastructure ref object, and
+	// the absence of this condition might signal problems in the reconcile external loops or the fact that
+	// the infrastructure provider does not not implements the Ready condition yet.
+	InfrastructureReadyCondition ConditionType = "InfrastructureReady"
+
+	// WaitingForInfrastructureFallbackReason (Severity=Info) documents a machine waiting for the machine infrastructure
+	// to be available.
+	// NOTE: This reason is used only as a fallback when the infrastructure object is not reporting its own ready condition.
+	WaitingForInfrastructureFallbackReason = "WaitingForInfrastructure"
+)

api/v1alpha3/condition_consts.go

@@ -159,6 +159,10 @@ type MachineStatus struct {
 	// ObservedGeneration is the latest generation observed by the controller.
 	// +optional
 	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
+
+	// Conditions defines current service state of the Machine.
+	// +optional
+	Conditions Conditions `json:"conditions,omitempty"`
 }
 
 // ANCHOR_END: MachineStatus
@@ -231,6 +235,14 @@ type Machine struct {
 	Status MachineStatus `json:"status,omitempty"`
 }
 
+func (m *Machine) GetConditions() Conditions {
+	return m.Status.Conditions
+}
+
+func (m *Machine) SetConditions(conditions Conditions) {
+	m.Status.Conditions = conditions
+}
+
 // +kubebuilder:object:root=true
 
 // MachineList contains a list of Machine

api/v1alpha3/machine_types.go

@@ -560,6 +560,50 @@ spec:
               bootstrapReady:
                 description: BootstrapReady is the state of the bootstrap provider.
                 type: boolean
+              conditions:
+                description: Conditions defines current service state of the Machine.
+                items:
+                  description: Condition defines an observation of a Cluster API resource
+                    operational state.
+                  properties:
+                    lastTransitionTime:
+                      description: Last time the condition transitioned from one status
+                        to another. This should be when the underlying condition changed.
+                        If that is not known, then using the time when the API field
+                        changed is acceptable.
+                      format: date-time
+                      type: string
+                    message:
+                      description: A human readable message indicating details about
+                        the transition. This field may be empty.
+                      type: string
+                    reason:
+                      description: The reason for the condition's last transition
+                        in CamelCase. The specific API may choose whether or not this
+                        field is considered a guaranteed API. This field may not be
+                        empty.
+                      type: string
+                    severity:
+                      description: Severity provides an explicit classification of
+                        Reason code, so the users or machines can immediately understand
+                        the current situation and act accordingly. The Severity field
+                        MUST be set only when Status=False.
+                      type: string
+                    status:
+                      description: Status of the condition, one of True, False, Unknown.
+                      type: string
+                    type:
+                      description: Type of condition in CamelCase or in foo.example.com/CamelCase.
+                        Many .condition.type values are consistent across resources
+                        like Available, but because arbitrary conditions can be useful
+                        (see .node.status.conditions), the ability to deconflict is
+                        important.
+                      type: string
+                  required:
+                  - status
+                  - type
+                  type: object
+                type: array
               failureMessage:
                 description: "FailureMessage will be set in the event that there is
                   a terminal problem reconciling the Machine and will contain a more

api/v1alpha3/zz_generated.deepcopy.go

@@ -43,6 +43,7 @@ import (
 	kubedrain "sigs.k8s.io/cluster-api/third_party/kubernetes-drain"
 	"sigs.k8s.io/cluster-api/util"
 	"sigs.k8s.io/cluster-api/util/annotations"
+	"sigs.k8s.io/cluster-api/util/conditions"
 	"sigs.k8s.io/cluster-api/util/patch"
 	"sigs.k8s.io/cluster-api/util/predicates"
 	ctrl "sigs.k8s.io/controller-runtime"
@@ -166,6 +167,13 @@ func (r *MachineReconciler) Reconcile(req ctrl.Request) (_ ctrl.Result, reterr e
 	}
 
 	defer func() {
+		// always update the readyCondition with the summary of the machine conditions.
+		conditions.SetSummary(m,
+			// we want to surface infrastructure problems as firsts, then the others.
+			conditions.WithConditionOrder(clusterv1.InfrastructureReadyCondition),
+			conditions.WithStepCounter(clusterv1.MachineConditionsCount),
+		)
+
 		r.reconcilePhase(ctx, m)
 		r.reconcileMetrics(ctx, m)
 

config/crd/bases/cluster.x-k8s.io_machines.yaml

@@ -29,6 +29,7 @@ import (
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/utils/pointer"
 	"sigs.k8s.io/cluster-api/util/annotations"
+	"sigs.k8s.io/cluster-api/util/conditions"
 	utilconversion "sigs.k8s.io/cluster-api/util/conversion"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 	"sigs.k8s.io/controller-runtime/pkg/handler"
@@ -172,12 +173,6 @@ func (r *MachineReconciler) reconcileBootstrap(ctx context.Context, cluster *clu
 	}
 	bootstrapConfig := externalResult.Result
 
-	// If the bootstrap data is populated, set ready and return.
-	if m.Spec.Bootstrap.DataSecretName != nil {
-		m.Status.BootstrapReady = true
-		return nil
-	}
-
 	// If the bootstrap config is being deleted, return early.
 	if !bootstrapConfig.GetDeletionTimestamp().IsZero() {
 		return nil
@@ -187,7 +182,22 @@ func (r *MachineReconciler) reconcileBootstrap(ctx context.Context, cluster *clu
 	ready, err := external.IsReady(bootstrapConfig)
 	if err != nil {
 		return err
-	} else if !ready {
+	}
+
+	// Report a summary of current status of the bootstrap object defined for this machine.
+	conditions.SetMirrorCondition(m, clusterv1.BootstrapReadyCondition,
+		conditions.UnstructuredGetter(bootstrapConfig),
+		conditions.WithFallbackValue(ready, clusterv1.WaitingForDataSecretFallbackReason, clusterv1.ConditionSeverityInfo, ""),
+	)
+
+	// If the bootstrap data is populated, set ready and return.
+	if m.Spec.Bootstrap.DataSecretName != nil {
+		m.Status.BootstrapReady = true
+		return nil
+	}
+
+	// If the bootstrap provider is not ready, requeue.
+	if !ready {
 		return errors.Wrapf(&capierrors.RequeueAfterError{RequeueAfter: externalReadyWait},
 			"Bootstrap provider for Machine %q in namespace %q is not ready, requeuing", m.Name, m.Namespace)
 	}
@@ -236,6 +246,14 @@ func (r *MachineReconciler) reconcileInfrastructure(ctx context.Context, cluster
 		return err
 	}
 	m.Status.InfrastructureReady = ready
+
+	// Report a summary of current status of the infrastructure object defined for this machine.
+	conditions.SetMirrorCondition(m, clusterv1.InfrastructureReadyCondition,
+		conditions.UnstructuredGetter(infraConfig),
+		conditions.WithFallbackValue(ready, clusterv1.WaitingForInfrastructureFallbackReason, clusterv1.ConditionSeverityInfo, ""),
+	)
+
+	// If the infrastructure provider is not ready, return early.
 	if !ready {
 		return errors.Wrapf(&capierrors.RequeueAfterError{RequeueAfter: externalReadyWait},
 			"Infrastructure provider for Machine %q in namespace %q is not ready, requeuing", m.Name, m.Namespace,

controllers/machine_controller.go

@@ -137,11 +137,47 @@ func Summary(from Getter, options ...MergeOption) *clusterv1.Condition {
 	return merge(conditionsInScope, clusterv1.ReadyCondition, mergeOpt)
 }
 
+// mirrorOptions allows to set options for the mirror operation.
+type mirrorOptions struct {
+	fallbackTo       *bool
+	fallbackReason   string
+	fallbackSeverity clusterv1.ConditionSeverity
+	fallbackMessage  string
+}
+
+// MirrorOptions defines an option for mirroring conditions.
+type MirrorOptions func(*mirrorOptions)
+
+// WithFallbackValue specify a fallback value to use in case the mirrored condition does not exists;
+// in case the fallbackValue is false, given values for reason, severity and message will be used.
+func WithFallbackValue(fallbackValue bool, reason string, severity clusterv1.ConditionSeverity, message string) MirrorOptions {
+	return func(c *mirrorOptions) {
+		c.fallbackTo = &fallbackValue
+		c.fallbackReason = reason
+		c.fallbackSeverity = severity
+		c.fallbackMessage = message
+	}
+}
+
 // Mirror mirrors the Ready condition from a dependent object into the target condition;
 // if the Ready condition does not exists in the source object, no target conditions is generated.
-func Mirror(from Getter, targetCondition clusterv1.ConditionType) *clusterv1.Condition {
+func Mirror(from Getter, targetCondition clusterv1.ConditionType, options ...MirrorOptions) *clusterv1.Condition {
+	mirrorOpt := &mirrorOptions{}
+	for _, o := range options {
+		o(mirrorOpt)
+	}
+
 	condition := Get(from, clusterv1.ReadyCondition)
 
+	if mirrorOpt.fallbackTo != nil && condition == nil {
+		switch *mirrorOpt.fallbackTo {
+		case true:
+			condition = TrueCondition(targetCondition)
+		case false:
+			condition = FalseCondition(targetCondition, mirrorOpt.fallbackReason, mirrorOpt.fallbackSeverity, mirrorOpt.fallbackMessage)
+		}
+	}
+
 	if condition != nil {
 		condition.Type = targetCondition
 	}

controllers/machine_controller_phases.go

@@ -120,8 +120,8 @@ func SetSummary(to Setter, options ...MergeOption) {
 
 // SetMirrorCondition creates a new condition by mirroring the the Ready condition from a dependent object;
 // if the Ready condition does not exists in the source object, no target conditions is generated.
-func SetMirrorCondition(to Setter, targetCondition clusterv1.ConditionType, from Getter) {
-	Set(to, Mirror(from, targetCondition))
+func SetMirrorCondition(to Setter, targetCondition clusterv1.ConditionType, from Getter, options ...MirrorOptions) {
+	Set(to, Mirror(from, targetCondition, options...))
 }
 
 // SetAggregateCondition creates a new condition with the aggregation of all the the Ready condition