Merge pull request #11320 from fabriziopandini/update-v1beta2-status-kcp-controller

✨ Add more v1beta2 conditions to KCP

Author: k8s-ci-robot

api/v1beta1/machineset_types.go

@@ -132,7 +132,7 @@ const (
 	MachineSetMachinesReadyV1Beta2Condition = MachinesReadyV1Beta2Condition
 
 	// MachineSetMachinesReadyNoReplicasV1Beta2Reason surfaces when no machines exist for the MachineSet.
-	MachineSetMachinesReadyNoReplicasV1Beta2Reason = "NoReplicas"
+	MachineSetMachinesReadyNoReplicasV1Beta2Reason = NoReplicasV1Beta2Reason
 
 	// MachineSetMachinesReadyInternalErrorV1Beta2Reason surfaces unexpected failures when listing machines
 	// or aggregating machine's conditions.
@@ -146,7 +146,7 @@ const (
 	MachineSetMachinesUpToDateV1Beta2Condition = MachinesUpToDateV1Beta2Condition
 
 	// MachineSetMachinesUpToDateNoReplicasV1Beta2Reason surfaces when no machines exist for the MachineSet.
-	MachineSetMachinesUpToDateNoReplicasV1Beta2Reason = "NoReplicas"
+	MachineSetMachinesUpToDateNoReplicasV1Beta2Reason = NoReplicasV1Beta2Reason
 
 	// MachineSetMachinesUpToDateInternalErrorV1Beta2Reason surfaces unexpected failures when listing machines
 	// or aggregating status.

api/v1beta1/v1beta2_condition_consts.go

@@ -102,6 +102,17 @@ const (
 	// NotScalingDownV1Beta2Reason surfaces when an object is not scaling down.
 	NotScalingDownV1Beta2Reason = "NotScalingDown"
 
+	// RemediatingV1Beta2Reason surfaces when an object owns at least one machine with HealthCheckSucceeded
+	// set to false and with the OwnerRemediated condition set to false by the MachineHealthCheck controller.
+	RemediatingV1Beta2Reason = "Remediating"
+
+	// NotRemediatingV1Beta2Reason surfaces when an object does not own any machines marked as not healthy
+	// by the MachineHealthCheck controller.
+	NotRemediatingV1Beta2Reason = "NotRemediating"
+
+	// NoReplicasV1Beta2Reason surfaces when an object that manage replicas does not have any.
+	NoReplicasV1Beta2Reason = "NoReplicas"
+
 	// WaitingForReplicasSetV1Beta2Reason surfaces when the replica field of an object is not set.
 	WaitingForReplicasSetV1Beta2Reason = "WaitingForReplicasSet"
 

controlplane/kubeadm/api/v1beta1/v1beta2_condition_consts.go

@@ -96,30 +96,74 @@ const (
 	// Please note this will include also APIServerPodHealthy, ControllerManagerPodHealthy, SchedulerPodHealthy conditions.
 	// If not using an external etcd also EtcdPodHealthy, EtcdMemberHealthy conditions are included.
 	KubeadmControlPlaneMachinesReadyV1Beta2Condition = clusterv1.MachinesReadyV1Beta2Condition
+
+	// KubeadmControlPlaneMachinesReadyNoReplicasV1Beta2Reason surfaces when no machines exist for the KubeadmControlPlane.
+	KubeadmControlPlaneMachinesReadyNoReplicasV1Beta2Reason = clusterv1.NoReplicasV1Beta2Reason
+
+	// KubeadmControlPlaneMachinesReadyInternalErrorV1Beta2Reason surfaces unexpected failures when computing the MachinesReady condition.
+	KubeadmControlPlaneMachinesReadyInternalErrorV1Beta2Reason = clusterv1.InternalErrorV1Beta2Reason
 )
 
 // KubeadmControlPlane's MachinesUpToDate condition and corresponding reasons that will be used in v1Beta2 API version.
 const (
 	// KubeadmControlPlaneMachinesUpToDateV1Beta2Condition surfaces details of controlled machines not up to date, if any.
 	KubeadmControlPlaneMachinesUpToDateV1Beta2Condition = clusterv1.MachinesUpToDateV1Beta2Condition
+
+	// KubeadmControlPlaneMachinesUpToDateNoReplicasV1Beta2Reason surfaces when no machines exist for the KubeadmControlPlane.
+	KubeadmControlPlaneMachinesUpToDateNoReplicasV1Beta2Reason = clusterv1.NoReplicasV1Beta2Reason
+
+	// KubeadmControlPlaneMachinesUpToDateInternalErrorV1Beta2Reason surfaces unexpected failures when computing the MachinesUpToDate condition.
+	KubeadmControlPlaneMachinesUpToDateInternalErrorV1Beta2Reason = clusterv1.InternalErrorV1Beta2Reason
 )
 
 // KubeadmControlPlane's ScalingUp condition and corresponding reasons that will be used in v1Beta2 API version.
 const (
-	// KubeadmControlPlaneScalingUpV1Beta2Condition is true if available replicas < desired replicas.
+	// KubeadmControlPlaneScalingUpV1Beta2Condition is true if actual replicas < desired replicas.
 	KubeadmControlPlaneScalingUpV1Beta2Condition = clusterv1.ScalingUpV1Beta2Condition
+
+	// KubeadmControlPlaneScalingUpV1Beta2Reason surfaces when actual replicas < desired replicas.
+	KubeadmControlPlaneScalingUpV1Beta2Reason = clusterv1.ScalingUpV1Beta2Reason
+
+	// KubeadmControlPlaneNotScalingUpV1Beta2Reason surfaces when actual replicas >= desired replicas.
+	KubeadmControlPlaneNotScalingUpV1Beta2Reason = clusterv1.NotScalingUpV1Beta2Reason
+
+	// KubeadmControlPlaneScalingUpWaitingForReplicasSetV1Beta2Reason surfaces when the .spec.replicas
+	// field of the KubeadmControlPlane is not set.
+	KubeadmControlPlaneScalingUpWaitingForReplicasSetV1Beta2Reason = clusterv1.WaitingForReplicasSetV1Beta2Reason
 )
 
 // KubeadmControlPlane's ScalingDown condition and corresponding reasons that will be used in v1Beta2 API version.
 const (
-	// KubeadmControlPlaneScalingDownV1Beta2Condition is true if replicas > desired replicas.
+	// KubeadmControlPlaneScalingDownV1Beta2Condition is true if actual replicas > desired replicas.
 	KubeadmControlPlaneScalingDownV1Beta2Condition = clusterv1.ScalingDownV1Beta2Condition
+
+	// KubeadmControlPlaneScalingDownV1Beta2Reason surfaces when actual replicas > desired replicas.
+	KubeadmControlPlaneScalingDownV1Beta2Reason = clusterv1.ScalingDownV1Beta2Reason
+
+	// KubeadmControlPlaneNotScalingDownV1Beta2Reason surfaces when actual replicas <= desired replicas.
+	KubeadmControlPlaneNotScalingDownV1Beta2Reason = clusterv1.NotScalingDownV1Beta2Reason
+
+	// KubeadmControlPlaneScalingDownWaitingForReplicasSetV1Beta2Reason surfaces when the .spec.replicas
+	// field of the KubeadmControlPlane is not set.
+	KubeadmControlPlaneScalingDownWaitingForReplicasSetV1Beta2Reason = clusterv1.WaitingForReplicasSetV1Beta2Reason
 )
 
 // KubeadmControlPlane's Remediating condition and corresponding reasons that will be used in v1Beta2 API version.
 const (
 	// KubeadmControlPlaneRemediatingV1Beta2Condition surfaces details about ongoing remediation of the controlled machines, if any.
+	// Note: KubeadmControlPlane only remediates machines with HealthCheckSucceeded set to false and with the OwnerRemediated condition set to false.
 	KubeadmControlPlaneRemediatingV1Beta2Condition = clusterv1.RemediatingV1Beta2Condition
+
+	// KubeadmControlPlaneRemediatingV1Beta2Reason surfaces when kcp has at least one machine with HealthCheckSucceeded set to false
+	// and with the OwnerRemediated condition set to false.
+	KubeadmControlPlaneRemediatingV1Beta2Reason = clusterv1.RemediatingV1Beta2Reason
+
+	// KubeadmControlPlaneNotRemediatingV1Beta2Reason surfaces when kcp does not have any machine with HealthCheckSucceeded set to false
+	// and with the OwnerRemediated condition set to false.
+	KubeadmControlPlaneNotRemediatingV1Beta2Reason = clusterv1.NotRemediatingV1Beta2Reason
+
+	// KubeadmControlPlaneRemediatingInternalErrorV1Beta2Reason surfaces unexpected failures when computing the Remediating condition.
+	KubeadmControlPlaneRemediatingInternalErrorV1Beta2Reason = clusterv1.InternalErrorV1Beta2Reason
 )
 
 // Reasons that will be used for the OwnerRemediated condition set by MachineHealthCheck on KubeadmControlPlane controlled machines
@@ -201,7 +245,7 @@ const (
 // EtcdMemberHealthy condition and corresponding reasons that will be used for KubeadmControlPlane controlled machines in v1Beta2 API version.
 const (
 	// KubeadmControlPlaneMachineEtcdMemberHealthyV1Beta2Condition surfaces the status of the etcd member hosted on a KubeadmControlPlane controlled machine.
-	KubeadmControlPlaneMachineEtcdMemberHealthyV1Beta2Condition = "Healthy"
+	KubeadmControlPlaneMachineEtcdMemberHealthyV1Beta2Condition = "EtcdMemberHealthy"
 
 	// KubeadmControlPlaneMachineEtcdMemberNotHealthyV1Beta2Reason surfaces when the etcd member hosted on a KubeadmControlPlane controlled machine is not healthy.
 	KubeadmControlPlaneMachineEtcdMemberNotHealthyV1Beta2Reason = "NotHealthy"

controlplane/kubeadm/internal/control_plane.go

@@ -47,6 +47,12 @@ type ControlPlane struct {
 	// reconciliationTime is the time of the current reconciliation, and should be used for all "now" calculations
 	reconciliationTime metav1.Time
 
+	// InfraMachineTemplateIsNotFound is true if getting the infra machine template object failed with an NotFound err
+	InfraMachineTemplateIsNotFound bool
+
+	// PreflightChecks contains description about pre flight check results blocking machines creation or deletion.
+	PreflightCheckResults PreflightCheckResults
+
 	// TODO: we should see if we can combine these with the Machine objects so we don't have all these separate lookups
 	// See discussion on https://github.com/kubernetes-sigs/cluster-api/pull/3405
 	KubeadmConfigs map[string]*bootstrapv1.KubeadmConfig
@@ -56,6 +62,16 @@ type ControlPlane struct {
 	workloadCluster   WorkloadCluster
 }
 
+// PreflightCheckResults contains description about pre flight check results blocking machines creation or deletion.
+type PreflightCheckResults struct {
+	// HasDeletingMachine reports true if preflight check detected a deleting machine.
+	HasDeletingMachine bool
+	// ControlPlaneComponentsNotHealthy reports true if preflight check detected that the control plane components are not fully healthy.
+	ControlPlaneComponentsNotHealthy bool
+	// EtcdClusterNotHealthy reports true if preflight check detected that the etcd cluster is not fully healthy.
+	EtcdClusterNotHealthy bool
+}
+
 // NewControlPlane returns an instantiated ControlPlane.
 func NewControlPlane(ctx context.Context, managementCluster ManagementCluster, client client.Client, cluster *clusterv1.Cluster, kcp *controlplanev1.KubeadmControlPlane, ownedMachines collections.Machines) (*ControlPlane, error) {
 	infraObjects, err := getInfraResources(ctx, client, ownedMachines)
@@ -260,24 +276,25 @@ func (c *ControlPlane) UnhealthyMachinesWithUnhealthyControlPlaneComponents(mach
 	return machines.Filter(collections.HasUnhealthyControlPlaneComponents(c.IsEtcdManaged()))
 }
 
-// UnhealthyMachinesByMachineHealthCheck returns the list of control plane machines marked as unhealthy by Machine Health Check.
-func (c *ControlPlane) UnhealthyMachinesByMachineHealthCheck() collections.Machines {
-	return c.Machines.Filter(collections.HasUnhealthyCondition)
+// UnhealthyMachines returns the list of control plane machines marked as unhealthy by MHC, no matter
+// if they are set to be remediated by KCP or not.
+func (c *ControlPlane) UnhealthyMachines() collections.Machines {
+	return c.Machines.Filter(collections.IsUnhealthy)
 }
 
-// HealthyMachinesByMachineHealthCheck returns the list of control plane machines not marked as unhealthy by Machine Health Check.
-func (c *ControlPlane) HealthyMachinesByMachineHealthCheck() collections.Machines {
-	return c.Machines.Filter(collections.Not(collections.HasUnhealthyCondition))
+// HealthyMachines returns the list of control plane machines marked as healthy by MHC (or not targeted by any MHC instance).
+func (c *ControlPlane) HealthyMachines() collections.Machines {
+	return c.Machines.Filter(collections.Not(collections.IsUnhealthy))
 }
 
-// HasUnhealthyMachineByMachineHealthCheck returns true if any machine in the control plane is marked as unhealthy by Machine Health Check.
-func (c *ControlPlane) HasUnhealthyMachineByMachineHealthCheck() bool {
-	return len(c.UnhealthyMachinesByMachineHealthCheck()) > 0
+// MachinesToBeRemediatedByKCP returns the list of control plane machines to be remediated by KCP.
+func (c *ControlPlane) MachinesToBeRemediatedByKCP() collections.Machines {
+	return c.Machines.Filter(collections.IsUnhealthyAndOwnerRemediated)
 }
 
 // HasHealthyMachineStillProvisioning returns true if any healthy machine in the control plane is still in the process of being provisioned.
 func (c *ControlPlane) HasHealthyMachineStillProvisioning() bool {
-	return len(c.HealthyMachinesByMachineHealthCheck().Filter(collections.Not(collections.HasNode()))) > 0
+	return len(c.HealthyMachines().Filter(collections.Not(collections.HasNode()))) > 0
 }
 
 // PatchMachines patches all the machines conditions.

controlplane/kubeadm/internal/control_plane_test.go

@@ -63,45 +63,66 @@ func TestControlPlane(t *testing.T) {
 	})
 }
 
-func TestHasUnhealthyMachine(t *testing.T) {
+func TestHasMachinesToBeRemediated(t *testing.T) {
 	// healthy machine (without MachineHealthCheckSucceded condition)
-	healthyMachine1 := &clusterv1.Machine{ObjectMeta: metav1.ObjectMeta{Name: "healthyMachine1"}}
+	healthyMachineNotProvisioned := &clusterv1.Machine{ObjectMeta: metav1.ObjectMeta{Name: "healthyMachine1"}}
 	// healthy machine (with MachineHealthCheckSucceded == true)
-	healthyMachine2 := &clusterv1.Machine{ObjectMeta: metav1.ObjectMeta{Name: "healthyMachine2"}}
-	conditions.MarkTrue(healthyMachine2, clusterv1.MachineHealthCheckSucceededCondition)
+	healthyMachineProvisioned := &clusterv1.Machine{ObjectMeta: metav1.ObjectMeta{Name: "healthyMachine2"}, Status: clusterv1.MachineStatus{NodeRef: &corev1.ObjectReference{Kind: "Node", Name: "node1"}}}
+	conditions.MarkTrue(healthyMachineProvisioned, clusterv1.MachineHealthCheckSucceededCondition)
 	// unhealthy machine NOT eligible for KCP remediation (with MachineHealthCheckSucceded == False, but without MachineOwnerRemediated condition)
-	unhealthyMachineNOTOwnerRemediated := &clusterv1.Machine{ObjectMeta: metav1.ObjectMeta{Name: "unhealthyMachineNOTOwnerRemediated"}}
+	unhealthyMachineNOTOwnerRemediated := &clusterv1.Machine{ObjectMeta: metav1.ObjectMeta{Name: "unhealthyMachineNOTOwnerRemediated"}, Status: clusterv1.MachineStatus{NodeRef: &corev1.ObjectReference{Kind: "Node", Name: "node2"}}}
 	conditions.MarkFalse(unhealthyMachineNOTOwnerRemediated, clusterv1.MachineHealthCheckSucceededCondition, clusterv1.MachineHasFailureReason, clusterv1.ConditionSeverityWarning, "Something is wrong")
 	// unhealthy machine eligible for KCP remediation (with MachineHealthCheckSucceded == False, with MachineOwnerRemediated condition)
-	unhealthyMachineOwnerRemediated := &clusterv1.Machine{ObjectMeta: metav1.ObjectMeta{Name: "unhealthyMachineOwnerRemediated"}}
+	unhealthyMachineOwnerRemediated := &clusterv1.Machine{ObjectMeta: metav1.ObjectMeta{Name: "unhealthyMachineOwnerRemediated"}, Status: clusterv1.MachineStatus{NodeRef: &corev1.ObjectReference{Kind: "Node", Name: "node3"}}}
 	conditions.MarkFalse(unhealthyMachineOwnerRemediated, clusterv1.MachineHealthCheckSucceededCondition, clusterv1.MachineHasFailureReason, clusterv1.ConditionSeverityWarning, "Something is wrong")
 	conditions.MarkFalse(unhealthyMachineOwnerRemediated, clusterv1.MachineOwnerRemediatedCondition, clusterv1.WaitingForRemediationReason, clusterv1.ConditionSeverityWarning, "KCP should remediate this issue")
 
 	t.Run("One unhealthy machine to be remediated by KCP", func(t *testing.T) {
 		c := ControlPlane{
 			Machines: collections.FromMachines(
-				healthyMachine1,                    // healthy machine, should be ignored
-				healthyMachine2,                    // healthy machine, should be ignored (the MachineHealthCheckSucceededCondition is true)
+				healthyMachineNotProvisioned,       // healthy machine, should be ignored
+				healthyMachineProvisioned,          // healthy machine, should be ignored (the MachineHealthCheckSucceededCondition is true)
 				unhealthyMachineNOTOwnerRemediated, // unhealthy machine, but KCP should not remediate it, should be ignored.
 				unhealthyMachineOwnerRemediated,
 			),
 		}
 
 		g := NewWithT(t)
-		g.Expect(c.HasUnhealthyMachineByMachineHealthCheck()).To(BeTrue())
+		g.Expect(c.MachinesToBeRemediatedByKCP()).To(ConsistOf(unhealthyMachineOwnerRemediated))
+		g.Expect(c.UnhealthyMachines()).To(ConsistOf(unhealthyMachineOwnerRemediated, unhealthyMachineNOTOwnerRemediated))
+		g.Expect(c.HealthyMachines()).To(ConsistOf(healthyMachineNotProvisioned, healthyMachineProvisioned))
+		g.Expect(c.HasHealthyMachineStillProvisioning()).To(BeTrue())
 	})
 
 	t.Run("No unhealthy machine to be remediated by KCP", func(t *testing.T) {
 		c := ControlPlane{
 			Machines: collections.FromMachines(
-				healthyMachine1,                    // healthy machine, should be ignored
-				healthyMachine2,                    // healthy machine, should be ignored (the MachineHealthCheckSucceededCondition is true)
+				healthyMachineNotProvisioned,       // healthy machine, should be ignored
+				healthyMachineProvisioned,          // healthy machine, should be ignored (the MachineHealthCheckSucceededCondition is true)
 				unhealthyMachineNOTOwnerRemediated, // unhealthy machine, but KCP should not remediate it, should be ignored.
 			),
 		}
 
 		g := NewWithT(t)
-		g.Expect(c.HasUnhealthyMachineByMachineHealthCheck()).To(BeFalse())
+		g.Expect(c.MachinesToBeRemediatedByKCP()).To(BeEmpty())
+		g.Expect(c.UnhealthyMachines()).To(ConsistOf(unhealthyMachineNOTOwnerRemediated))
+		g.Expect(c.HealthyMachines()).To(ConsistOf(healthyMachineNotProvisioned, healthyMachineProvisioned))
+		g.Expect(c.HasHealthyMachineStillProvisioning()).To(BeTrue())
+	})
+
+	t.Run("No unhealthy machine to be remediated by KCP", func(t *testing.T) {
+		c := ControlPlane{
+			Machines: collections.FromMachines(
+				healthyMachineProvisioned,          // healthy machine, should be ignored (the MachineHealthCheckSucceededCondition is true)
+				unhealthyMachineNOTOwnerRemediated, // unhealthy machine, but KCP should not remediate it, should be ignored.
+			),
+		}
+
+		g := NewWithT(t)
+		g.Expect(c.MachinesToBeRemediatedByKCP()).To(BeEmpty())
+		g.Expect(c.UnhealthyMachines()).To(ConsistOf(unhealthyMachineNOTOwnerRemediated))
+		g.Expect(c.HealthyMachines()).To(ConsistOf(healthyMachineProvisioned))
+		g.Expect(c.HasHealthyMachineStillProvisioning()).To(BeFalse())
 	})
 }