Adds Conditions to MachineDeployment. In particular, it adds

`AvailableCondition` and `ReadyCondition`.

Author: Arvinderpal

api/v1alpha3/conversion.go

@@ -137,9 +137,9 @@ func (src *MachineDeployment) ConvertTo(dstRaw conversion.Hub) error {
 			dst.Spec.Strategy.RollingUpdate = &v1alpha4.MachineRollingUpdateDeployment{}
 		}
 		dst.Spec.Strategy.RollingUpdate.DeletePolicy = restored.Spec.Strategy.RollingUpdate.DeletePolicy
-
 	}
 
+	dst.Status.Conditions = restored.Status.Conditions
 	return nil
 }
 
@@ -158,6 +158,10 @@ func (dst *MachineDeployment) ConvertFrom(srcRaw conversion.Hub) error {
 	return nil
 }
 
+func Convert_v1alpha4_MachineDeploymentStatus_To_v1alpha3_MachineDeploymentStatus(in *v1alpha4.MachineDeploymentStatus, out *MachineDeploymentStatus, s apiconversion.Scope) error {
+	return autoConvert_v1alpha4_MachineDeploymentStatus_To_v1alpha3_MachineDeploymentStatus(in, out, s)
+}
+
 func (src *MachineDeploymentList) ConvertTo(dstRaw conversion.Hub) error {
 	dst := dstRaw.(*v1alpha4.MachineDeploymentList)
 

api/v1alpha3/zz_generated.conversion.go

@@ -201,3 +201,14 @@ const (
 	// from making any further remediations.
 	TooManyUnhealthyReason = "TooManyUnhealthy"
 )
+
+// Conditions and condition Reasons for  MachineDeployments
+
+const (
+	// MachineDeploymentAvailableCondition means the MachineDeployment is available, that is, at least the minimum available
+	// machines required (i.e. Spec.Replicas-MaxUnavailable) are up and running for at least minReadySeconds.
+	MachineDeploymentAvailableCondition ConditionType = "Available"
+
+	// MinimumMachinesAvailableReason reflects the minimum availability of machines for a machinedeployment.
+	MinimumMachinesAvailableReason = "MinimumMachinesAvailable"
+)

api/v1alpha4/condition_consts.go

@@ -207,6 +207,10 @@ type MachineDeploymentStatus struct {
 	// Phase represents the current phase of a MachineDeployment (ScalingUp, ScalingDown, Running, Failed, or Unknown).
 	// +optional
 	Phase string `json:"phase,omitempty"`
+
+	// Conditions defines current service state of the MachineDeployment.
+	// +optional
+	Conditions Conditions `json:"conditions,omitempty"`
 }
 
 // ANCHOR_END: MachineDeploymentStatus
@@ -283,3 +287,11 @@ type MachineDeploymentList struct {
 func init() {
 	SchemeBuilder.Register(&MachineDeployment{}, &MachineDeploymentList{})
 }
+
+func (in *MachineDeployment) GetConditions() Conditions {
+	return in.Status.Conditions
+}
+
+func (in *MachineDeployment) SetConditions(conditions Conditions) {
+	in.Status.Conditions = conditions
+}

api/v1alpha4/machinedeployment_types.go

@@ -864,6 +864,50 @@ spec:
                   minReadySeconds) targeted by this deployment.
                 format: int32
                 type: integer
+              conditions:
+                description: Conditions defines current service state of the MachineDeployment.
+                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
               observedGeneration:
                 description: The generation observed by the deployment controller.
                 format: int64

api/v1alpha4/zz_generated.deepcopy.go

@@ -31,6 +31,7 @@ import (
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1alpha4"
 	"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"
@@ -129,7 +130,12 @@ func (r *MachineDeploymentReconciler) Reconcile(ctx context.Context, req ctrl.Re
 
 	defer func() {
 		// Always attempt to patch the object and status after each reconciliation.
-		if err := patchHelper.Patch(ctx, deployment); err != nil {
+		// Patch ObservedGeneration only if the reconciliation completed successfully
+		patchOpts := []patch.Option{}
+		if reterr == nil {
+			patchOpts = append(patchOpts, patch.WithStatusObservedGeneration{})
+		}
+		if err := patchMachineDeployment(ctx, patchHelper, deployment, patchOpts...); err != nil {
 			reterr = kerrors.NewAggregate([]error{reterr, err})
 		}
 	}()
@@ -148,6 +154,24 @@ func (r *MachineDeploymentReconciler) Reconcile(ctx context.Context, req ctrl.Re
 	return result, err
 }
 
+func patchMachineDeployment(ctx context.Context, patchHelper *patch.Helper, d *clusterv1.MachineDeployment, options ...patch.Option) error {
+	// Always update the readyCondition by summarizing the state of other conditions.
+	conditions.SetSummary(d,
+		conditions.WithConditions(
+			clusterv1.MachineDeploymentAvailableCondition,
+		),
+	)
+
+	// Patch the object, ignoring conflicts on the conditions owned by this controller.
+	options = append(options,
+		patch.WithOwnedConditions{Conditions: []clusterv1.ConditionType{
+			clusterv1.ReadyCondition,
+			clusterv1.MachineDeploymentAvailableCondition,
+		}},
+	)
+	return patchHelper.Patch(ctx, d, options...)
+}
+
 func (r *MachineDeploymentReconciler) reconcile(ctx context.Context, cluster *clusterv1.Cluster, d *clusterv1.MachineDeployment) (ctrl.Result, error) {
 	log := ctrl.LoggerFrom(ctx)
 	log.V(4).Info("Reconcile MachineDeployment")

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

@@ -389,6 +389,21 @@ var _ = Describe("MachineDeployment Reconciler", func() {
 			return len(machineSets.Items)
 		}, timeout*5).Should(BeEquivalentTo(0))
 
+		By("Verifying MachineDeployment has correct Conditions")
+		Eventually(func() bool {
+			key := client.ObjectKey{Name: deployment.Name, Namespace: deployment.Namespace}
+			if err := testEnv.Get(ctx, key, deployment); err != nil {
+				return false
+			}
+			var availableCond bool
+			for _, c := range deployment.Status.Conditions {
+				if c.Type == clusterv1.MachineDeploymentAvailableCondition && c.Status == corev1.ConditionTrue {
+					availableCond = true
+				}
+			}
+			return availableCond
+		}, timeout).Should(BeTrue())
+
 		// Validate that the controller set the cluster name label in selector.
 		Expect(deployment.Status.Selector).To(ContainSubstring(testCluster.Name))
 	})

controllers/machinedeployment_controller.go

@@ -32,6 +32,7 @@ import (
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1alpha4"
 	"sigs.k8s.io/cluster-api/controllers/mdutil"
 	"sigs.k8s.io/cluster-api/util"
+	"sigs.k8s.io/cluster-api/util/conditions"
 	"sigs.k8s.io/cluster-api/util/patch"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -349,6 +350,14 @@ func (r *MachineDeploymentReconciler) scale(ctx context.Context, deployment *clu
 // syncDeploymentStatus checks if the status is up-to-date and sync it if necessary.
 func (r *MachineDeploymentReconciler) syncDeploymentStatus(allMSs []*clusterv1.MachineSet, newMS *clusterv1.MachineSet, d *clusterv1.MachineDeployment) error {
 	d.Status = calculateStatus(allMSs, newMS, d)
+
+	minReplicasNeeded := *(d.Spec.Replicas) - mdutil.MaxUnavailable(*d)
+	if d.Status.AvailableReplicas >= minReplicasNeeded {
+		// NOTE: The structure of calculateStatus() does not allow us to update the machinedeployment directly, we can only update the status obj it returns. Ideally, we should change calculateStatus() --> updateStatus() to be consistent with the rest of the code base, until then, we update conditions here.
+		conditions.MarkTrue(d, clusterv1.MachineDeploymentAvailableCondition)
+	} else {
+		conditions.MarkFalse(d, clusterv1.MachineDeploymentAvailableCondition, clusterv1.MinimumMachinesAvailableReason, clusterv1.ConditionSeverityWarning, "Minimum availability requires %d replicas, current %d available", minReplicasNeeded, d.Status.AvailableReplicas)
+	}
 	return nil
 }
 
@@ -376,6 +385,7 @@ func calculateStatus(allMSs []*clusterv1.MachineSet, newMS *clusterv1.MachineSet
 		ReadyReplicas:       mdutil.GetReadyReplicaCountForMachineSets(allMSs),
 		AvailableReplicas:   availableReplicas,
 		UnavailableReplicas: unavailableReplicas,
+		Conditions:          deployment.Status.Conditions,
 	}
 
 	if *deployment.Spec.Replicas == status.ReadyReplicas {