Fix rolling upgrade logic and separate eksa version upgrade logic

Signed-off-by: Rahul Ganesh <rahulgab@amazon.com>
aws · Oct 3, 2023 · 1bc8079 · 1bc8079
1 parent 78f9999
commit 1bc8079
Show file tree

Hide file tree

Showing 3 changed files with 58 additions and 44 deletions.
diff --git a/pkg/providers/tinkerbell/assert.go b/pkg/providers/tinkerbell/assert.go
@@ -300,10 +300,12 @@ func (v *ValidatableTinkerbellClusterSpec) WorkerNodeHardwareGroups() []WorkerNo
 	return workerNodeGroupConfigs
 }
 
+// ClusterK8sVersion retrieves the Kubernetes version set at the cluster level.
 func (v *ValidatableTinkerbellClusterSpec) ClusterK8sVersion() *v1alpha1.KubernetesVersion {
 	return &v.Cluster.Spec.KubernetesVersion
 }
 
+// WorkerNodeGroupK8sVersion returns each worker node group with its associated Kubernetes version.
 func (v *ValidatableTinkerbellClusterSpec) WorkerNodeGroupK8sVersion() map[string]*v1alpha1.KubernetesVersion {
 	return WorkerNodeGroupWithK8sVersion(v.ClusterSpec.Spec)
 }
@@ -332,10 +334,12 @@ func (v *ValidatableTinkerbellCAPI) WorkerNodeHardwareGroups() []WorkerNodeHardw
 	return workerNodeHardwareList
 }
 
+// ClusterK8sVersion returns the Kubernetes version in major.minor format for a ValidatableTinkerbellCAPI.
 func (v *ValidatableTinkerbellCAPI) ClusterK8sVersion() *v1alpha1.KubernetesVersion {
 	return v.extractK8sVersion(v.KubeadmControlPlane.Spec.Version)
 }
 
+// WorkerNodeGroupK8sVersion returns each worker node group mapped to Kubernetes version in major.minor format for a ValidatableTinkerbellCAPI.
 func (v *ValidatableTinkerbellCAPI) WorkerNodeGroupK8sVersion() map[string]*v1alpha1.KubernetesVersion {
 	WNGK8sversion := make(map[string]*v1alpha1.KubernetesVersion)
 	for _, wng := range v.WorkerGroups {
@@ -428,7 +432,7 @@ func AssertionsForScaleUpDown(catalogue *hardware.Catalogue, current Validatable
 
 // ExtraHardwareAvailableAssertionForRollingUpgrade asserts that catalogue has sufficient hardware to
 // support the ClusterSpec during an rolling upgrade workflow.
-func ExtraHardwareAvailableAssertionForRollingUpgrade(catalogue *hardware.Catalogue, current ValidatableCluster) ClusterSpecAssertion {
+func ExtraHardwareAvailableAssertionForRollingUpgrade(catalogue *hardware.Catalogue, current ValidatableCluster, eksaVersionUpgrade bool) ClusterSpecAssertion {
 	return func(spec *ClusterSpec) error {
 		// Without Hardware selectors we get undesirable behavior so ensure we have them for
 		// all MachineConfigs.
@@ -440,40 +444,14 @@ func ExtraHardwareAvailableAssertionForRollingUpgrade(catalogue *hardware.Catalo
 		// will account for the same selector being specified on different groups.
 		requirements := minimumHardwareRequirements{}
 
-		maxSurge := 1
-		if spec.Cluster.Spec.KubernetesVersion != *current.ClusterK8sVersion() {
-			if spec.Cluster.Spec.ControlPlaneConfiguration.UpgradeRolloutStrategy != nil {
-				maxSurge = spec.Cluster.Spec.ControlPlaneConfiguration.UpgradeRolloutStrategy.RollingUpdate.MaxSurge
-			}
-			err := requirements.Add(
-				spec.ControlPlaneMachineConfig().Spec.HardwareSelector,
-				maxSurge,
-			)
-			if err != nil {
-				return fmt.Errorf("for rolling upgrade, %v", err)
+		if spec.Cluster.Spec.KubernetesVersion != *current.ClusterK8sVersion() || eksaVersionUpgrade {
+			if err := ensureCPHardwareAvailability(spec, current, requirements); err != nil {
+				return err
 			}
 		}
-		// for WNGref, k8sversion := range current.WorkerNodeGroupK8sVersion() {
-		// 	wng := spec.MachineConfigs[WNGref]
-		// 	maxSurge = 1
-		// 	wng.UpgradeRolloutStrategy
-		// }
-		currentWNGK8sversion := current.WorkerNodeGroupK8sVersion()
-		desiredWNGK8sVersion := WorkerNodeGroupWithK8sVersion(spec.Spec)
-		for _, nodeGroup := range spec.WorkerNodeGroupConfigurations() {
-			maxSurge = 1
-			if currentWNGK8sversion[nodeGroup.Name] != desiredWNGK8sVersion[nodeGroup.Name] {
-				if nodeGroup.UpgradeRolloutStrategy != nil {
-					maxSurge = nodeGroup.UpgradeRolloutStrategy.RollingUpdate.MaxSurge
-				}
-				err := requirements.Add(
-					spec.WorkerNodeGroupMachineConfig(nodeGroup).Spec.HardwareSelector,
-					maxSurge,
-				)
-				if err != nil {
-					return fmt.Errorf("for rolling upgrade, %v", err)
-				}
-			}
+
+		if err := ensureWorkerHardwareAvailability(spec, current, requirements, eksaVersionUpgrade); err != nil {
+			return err
 		}
 
 		if spec.HasExternalEtcd() {
@@ -487,6 +465,43 @@ func ExtraHardwareAvailableAssertionForRollingUpgrade(catalogue *hardware.Catalo
 	}
 }
 
+func ensureCPHardwareAvailability(spec *ClusterSpec, current ValidatableCluster, hwReq minimumHardwareRequirements) error {
+	maxSurge := 1
+
+	if spec.Cluster.Spec.ControlPlaneConfiguration.UpgradeRolloutStrategy != nil {
+		maxSurge = spec.Cluster.Spec.ControlPlaneConfiguration.UpgradeRolloutStrategy.RollingUpdate.MaxSurge
+	}
+	err := hwReq.Add(
+		spec.ControlPlaneMachineConfig().Spec.HardwareSelector,
+		maxSurge,
+	)
+	if err != nil {
+		return fmt.Errorf("for rolling upgrade, %v", err)
+	}
+	return nil
+}
+
+func ensureWorkerHardwareAvailability(spec *ClusterSpec, current ValidatableCluster, hwReq minimumHardwareRequirements, eksaVersionUpgrade bool) error {
+	currentWNGK8sversion := current.WorkerNodeGroupK8sVersion()
+	desiredWNGK8sVersion := WorkerNodeGroupWithK8sVersion(spec.Spec)
+	for _, nodeGroup := range spec.WorkerNodeGroupConfigurations() {
+		maxSurge := 1
+		if currentWNGK8sversion[nodeGroup.Name] != desiredWNGK8sVersion[nodeGroup.Name] || eksaVersionUpgrade {
+			if nodeGroup.UpgradeRolloutStrategy != nil {
+				maxSurge = nodeGroup.UpgradeRolloutStrategy.RollingUpdate.MaxSurge
+			}
+			err := hwReq.Add(
+				spec.WorkerNodeGroupMachineConfig(nodeGroup).Spec.HardwareSelector,
+				maxSurge,
+			)
+			if err != nil {
+				return fmt.Errorf("for rolling upgrade, %v", err)
+			}
+		}
+	}
+	return nil
+}
+
 // ensureHardwareSelectorsSpecified ensures each machine config present in spec has a hardware
 // selector.
 func ensureHardwareSelectorsSpecified(spec *ClusterSpec) error {

diff --git a/pkg/providers/tinkerbell/reconciler/reconciler.go b/pkg/providers/tinkerbell/reconciler/reconciler.go
@@ -371,7 +371,8 @@ func (r *Reconciler) ValidateHardware(ctx context.Context, log logr.Logger, tink
 		if err != nil {
 			return controller.Result{}, err
 		}
-		v.Register(tinkerbell.ExtraHardwareAvailableAssertionForRollingUpgrade(kubeReader.GetCatalogue(), validatableCAPI))
+		// eksa version upgrade cannot be triggered from controller, so set it to false.
+		v.Register(tinkerbell.ExtraHardwareAvailableAssertionForRollingUpgrade(kubeReader.GetCatalogue(), validatableCAPI, false))
 	case NewClusterOperation:
 		v.Register(tinkerbell.MinimumHardwareAvailableAssertionForCreate(kubeReader.GetCatalogue()))
 	case NoChange:

diff --git a/pkg/providers/tinkerbell/upgrade.go b/pkg/providers/tinkerbell/upgrade.go
@@ -145,18 +145,13 @@ func (p *Provider) validateAvailableHardwareForUpgrade(ctx context.Context, curr
 	clusterSpecValidator := NewClusterSpecValidator(
 		HardwareSatisfiesOnlyOneSelectorAssertion(p.catalogue),
 	)
-
-	// if currentSpec.Cluster.Spec.KubernetesVersion != newClusterSpec.Cluster.Spec.KubernetesVersion ||
-	// 	currentSpec.Bundles.Spec.Number != newClusterSpec.Bundles.Spec.Number {
-	// 	clusterSpecValidator.Register(ExtraHardwareAvailableAssertionForRollingUpgrade(p.catalogue))
-	// 	rollingUpgrade = true
-	// }
+	eksaVersionUpgrade := p.isEksaVersionUpgrade(currentSpec, newClusterSpec)
 
 	currentTinkerbellSpec := NewClusterSpec(currentSpec, currentSpec.TinkerbellMachineConfigs, currentSpec.TinkerbellDatacenter)
 	rollingUpgrade := p.isRollingUpgrade(currentSpec, newClusterSpec)
 	currentCluster := &ValidatableTinkerbellClusterSpec{currentTinkerbellSpec}
 	if rollingUpgrade {
-		clusterSpecValidator.Register(ExtraHardwareAvailableAssertionForRollingUpgrade(p.catalogue, currentCluster))
+		clusterSpecValidator.Register(ExtraHardwareAvailableAssertionForRollingUpgrade(p.catalogue, currentCluster, eksaVersionUpgrade))
 	}
 	clusterSpecValidator.Register(AssertionsForScaleUpDown(p.catalogue, currentCluster, rollingUpgrade))
 
@@ -375,16 +370,19 @@ func (p *Provider) isScaleUpDown(oldCluster *v1alpha1.Cluster, newCluster *v1alp
 	return false
 }
 
+func (p *Provider) isEksaVersionUpgrade(currentSpec, newClusterSpec *cluster.Spec) bool {
+	return currentSpec.Bundles.Spec.Number != newClusterSpec.Bundles.Spec.Number
+}
+
 func (p *Provider) isRollingUpgrade(currentSpec, newClusterSpec *cluster.Spec) bool {
-	if currentSpec.Cluster.Spec.KubernetesVersion != newClusterSpec.Cluster.Spec.KubernetesVersion ||
-		currentSpec.Bundles.Spec.Number != newClusterSpec.Bundles.Spec.Number {
+	if currentSpec.Cluster.Spec.KubernetesVersion != newClusterSpec.Cluster.Spec.KubernetesVersion {
 		return true
 	}
 	currentWNGSwithK8sVersion := WorkerNodeGroupWithK8sVersion(currentSpec)
 	desiredWNGwithK8sVersion := WorkerNodeGroupWithK8sVersion(newClusterSpec)
 	for wngName, K8sVersion := range desiredWNGwithK8sVersion {
 		currentWngK8sVersion, ok := currentWNGSwithK8sVersion[wngName]
-		if ok && currentWngK8sVersion != K8sVersion {
+		if ok && (*currentWngK8sVersion != *K8sVersion) {
 			return true
 		}
 	}