✨ Add rolloutAfter for RollingUpdate strategy

api/v1alpha3/conversion.go

@@ -191,6 +191,10 @@ func (src *MachineDeployment) ConvertTo(dstRaw conversion.Hub) error {
 		dst.Spec.Strategy.RollingUpdate.DeletePolicy = restored.Spec.Strategy.RollingUpdate.DeletePolicy
 	}
 
+	if restored.Spec.RolloutAfter != nil {
+		dst.Spec.RolloutAfter = restored.Spec.RolloutAfter
+	}
+
 	dst.Status.Conditions = restored.Status.Conditions
 	return nil
 }
@@ -312,3 +316,7 @@ func Convert_v1alpha3_MachineStatus_To_v1beta1_MachineStatus(in *MachineStatus,
 	// Status.version has been removed in v1beta1, thus requiring custom conversion function. the information will be dropped.
 	return autoConvert_v1alpha3_MachineStatus_To_v1beta1_MachineStatus(in, out, s)
 }
+
+func Convert_v1beta1_MachineDeploymentSpec_To_v1alpha3_MachineDeploymentSpec(in *v1beta1.MachineDeploymentSpec, out *MachineDeploymentSpec, s apiconversion.Scope) error {
+	return autoConvert_v1beta1_MachineDeploymentSpec_To_v1alpha3_MachineDeploymentSpec(in, out, s)
+}

api/v1alpha4/conversion.go

@@ -19,6 +19,7 @@ package v1alpha4
 import (
 	apiconversion "k8s.io/apimachinery/pkg/conversion"
 	"sigs.k8s.io/cluster-api/api/v1beta1"
+	utilconversion "sigs.k8s.io/cluster-api/util/conversion"
 	"sigs.k8s.io/controller-runtime/pkg/conversion"
 )
 
@@ -121,15 +122,39 @@ func (dst *MachineSetList) ConvertFrom(srcRaw conversion.Hub) error {
 func (src *MachineDeployment) ConvertTo(dstRaw conversion.Hub) error {
 	dst := dstRaw.(*v1beta1.MachineDeployment)
 
-	return Convert_v1alpha4_MachineDeployment_To_v1beta1_MachineDeployment(src, dst, nil)
+	if err := Convert_v1alpha4_MachineDeployment_To_v1beta1_MachineDeployment(src, dst, nil); err != nil {
+		return err
+	}
+
+	// Manually restore data.
+	restored := &v1beta1.MachineDeployment{}
+	if ok, err := utilconversion.UnmarshalData(src, restored); err != nil || !ok {
+		return err
+	}
+
+	if restored.Spec.RolloutAfter != nil {
+		dst.Spec.RolloutAfter = restored.Spec.RolloutAfter
+	}
+
+	return nil
 }
 
 func (dst *MachineDeployment) ConvertFrom(srcRaw conversion.Hub) error {
 	src := srcRaw.(*v1beta1.MachineDeployment)
 
-	return Convert_v1beta1_MachineDeployment_To_v1alpha4_MachineDeployment(src, dst, nil)
+	if err := Convert_v1beta1_MachineDeployment_To_v1alpha4_MachineDeployment(src, dst, nil); err != nil {
+		return err
+	}
+
+	// Preserve Hub data on down-conversion except for metadata
+	if err := utilconversion.MarshalData(src, dst); err != nil {
+		return err
+	}
+
+	return nil
 }
 
+
 func (src *MachineDeploymentList) ConvertTo(dstRaw conversion.Hub) error {
 	dst := dstRaw.(*v1beta1.MachineDeploymentList)
 
@@ -170,3 +195,7 @@ func Convert_v1alpha4_MachineStatus_To_v1beta1_MachineStatus(in *MachineStatus,
 	// Status.version has been removed in v1beta1, thus requiring custom conversion function. the information will be dropped.
 	return autoConvert_v1alpha4_MachineStatus_To_v1beta1_MachineStatus(in, out, s)
 }
+
+func Convert_v1beta1_MachineDeploymentSpec_To_v1alpha4_MachineDeploymentSpec(in *v1beta1.MachineDeploymentSpec, out *MachineDeploymentSpec, s apiconversion.Scope) error {
+	return autoConvert_v1beta1_MachineDeploymentSpec_To_v1alpha4_MachineDeploymentSpec(in, out, s)
+}

api/v1beta1/machinedeployment_types.go

@@ -57,6 +57,9 @@ const (
 	// MachineDeploymentUniqueLabel is the label applied to Machines
 	// in a MachineDeployment containing the hash of the template.
 	MachineDeploymentUniqueLabel = "machine-template-hash"
+
+	// LastRolloutAfterAnnotation is the last MachineDeployment.Spec.RolloutAfter that was met.
+	LastRolloutAfterAnnotation = "machinedeployment.clusters.x-k8s.io/lastRollout"
 )
 
 // ANCHOR: MachineDeploymentSpec
@@ -67,6 +70,13 @@ type MachineDeploymentSpec struct {
 	// +kubebuilder:validation:MinLength=1
 	ClusterName string `json:"clusterName"`
 
+	// RolloutAfter performs a rollout of the MachineDeployment
+	// the first reconciliation loop where the given time is before now().
+	// After that moment the field has no effect until it's updated with a new time.
+	// Any changes to other fields of the spec are not affected by this field and will be rolled out as normal.
+	// +optional
+	RolloutAfter *metav1.Time `json:"rolloutAfter,omitempty"`
+
 	// Number of desired machines. Defaults to 1.
 	// This is a pointer to distinguish between explicit zero and not specified.
 	// +optional

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

@@ -1051,6 +1051,14 @@ spec:
                   Defaults to 1.
                 format: int32
                 type: integer
+              rolloutAfter:
+                description: RolloutAfter performs a rollout of the MachineDeployment
+                  the first reconciliation loop where the given time is before now().
+                  After that moment the field has no effect until it's updated with
+                  a new time. Any changes to other fields of the spec are not affected
+                  by this field and will be rolled out as normal.
+                format: date-time
+                type: string
               selector:
                 description: Label selector for machines. Existing MachineSets whose
                   machines are selected by this will be the ones affected by this

controllers/internal/mdutil/util.go

@@ -24,6 +24,7 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/davecgh/go-spew/spew"
 	"github.com/go-logr/logr"
@@ -392,6 +393,7 @@ func EqualMachineTemplate(template1, template2 *clusterv1.MachineTemplateSpec) b
 }
 
 // FindNewMachineSet returns the new MS this given deployment targets (the one with the same machine template).
+// Deprecated: this does not for rolloutAfter. Use FindNewMachineSetWithRolloutAfter.
 func FindNewMachineSet(deployment *clusterv1.MachineDeployment, msList []*clusterv1.MachineSet) *clusterv1.MachineSet {
 	sort.Sort(MachineSetsByCreationTimestamp(msList))
 	for i := range msList {
@@ -403,14 +405,57 @@ func FindNewMachineSet(deployment *clusterv1.MachineDeployment, msList []*cluste
 			return msList[i]
 		}
 	}
-	// new MachineSet does not exist.
+	// New MachineSet does not exist.
 	return nil
 }
 
+// FindNewMachineSetWithRolloutAfter is as FindNewMachineSet but it also accounts for RolloutAfter.
+func FindNewMachineSetWithRolloutAfter(now *metav1.Time, deployment *clusterv1.MachineDeployment, msList []*clusterv1.MachineSet) (*clusterv1.MachineSet, error) {
+	// In rare cases, such as after cluster upgrades, Deployment may end up with
+	// having more than one new MachineSets that have the same template,
+	// see https://github.com/kubernetes/kubernetes/issues/40415
+	// We deterministically choose the oldest new MachineSet with matching template hash.
+	sort.Sort(MachineSetsByCreationTimestamp(msList))
+
+	if deployment.Spec.RolloutAfter != nil {
+		if now.After(deployment.Spec.RolloutAfter.Time) {
+			// TODO (alberto): inlining the format statement within the annotation assigment here
+			// does not set the value. Why?
+			lastRolloutAfter := deployment.Spec.RolloutAfter.Time.UTC().Format(time.RFC3339)
+			deployment.Annotations[clusterv1.LastRolloutAfterAnnotation] = lastRolloutAfter
+		}
+	}
+
+	for i := range msList {
+		if EqualMachineTemplate(&msList[i].Spec.Template, &deployment.Spec.Template) {
+			// If a rolloutAfter should happen or has already happened
+			// we pick the oldest one with creationTimestamp after rolloutAfter.
+			if lastRolloutAfter, ok := deployment.Annotations[clusterv1.LastRolloutAfterAnnotation]; ok {
+				created := msList[i].CreationTimestamp
+				t, err := time.Parse(time.RFC3339, lastRolloutAfter)
+				if err != nil {
+					return nil, err
+				}
+				if created.After(t) {
+					return msList[i], nil
+				}
+				continue
+			}
+
+			// If a rolloutAfter never took place just pick the oldest one.
+			return msList[i], nil
+		}
+	}
+
+	// New MachineSet does not exist.
+	return nil, nil
+}
+
 // FindOldMachineSets returns the old machine sets targeted by the given Deployment, with the given slice of MSes.
 // Returns two list of machine sets
 //  - the first contains all old machine sets with all non-zero replicas
 //  - the second contains all old machine sets
+// Deprecated: this does not for rolloutAfter. Use FindOldMachineSetsWithRolloutAfter.
 func FindOldMachineSets(deployment *clusterv1.MachineDeployment, msList []*clusterv1.MachineSet) ([]*clusterv1.MachineSet, []*clusterv1.MachineSet) {
 	var requiredMSs []*clusterv1.MachineSet
 	allMSs := make([]*clusterv1.MachineSet, 0, len(msList))
@@ -428,6 +473,28 @@ func FindOldMachineSets(deployment *clusterv1.MachineDeployment, msList []*clust
 	return requiredMSs, allMSs
 }
 
+// FindOldMachineSetsWithRolloutAfter is as FindOldMachineSets but also accounts for rolloutAfter.
+func FindOldMachineSetsWithRolloutAfter(now *metav1.Time, deployment *clusterv1.MachineDeployment, msList []*clusterv1.MachineSet) ([]*clusterv1.MachineSet, []*clusterv1.MachineSet, error) {
+	var requiredMSs []*clusterv1.MachineSet
+	allMSs := make([]*clusterv1.MachineSet, 0, len(msList))
+	newMS, err := FindNewMachineSetWithRolloutAfter(now, deployment, msList)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	for _, ms := range msList {
+		// Filter out new machine set
+		if newMS != nil && ms.UID == newMS.UID {
+			continue
+		}
+		allMSs = append(allMSs, ms)
+		if *(ms.Spec.Replicas) != 0 {
+			requiredMSs = append(requiredMSs, ms)
+		}
+	}
+	return requiredMSs, allMSs, nil
+}
+
 // GetReplicaCountForMachineSets returns the sum of Replicas of the given machine sets.
 func GetReplicaCountForMachineSets(machineSets []*clusterv1.MachineSet) int32 {
 	totalReplicas := int32(0)