rename all KCP mentions to RKE2ControlPlane. Fix conversion tests

Author: MaxFedotov

controlplane/api/v1alpha1/conversion.go

@@ -57,6 +57,10 @@ func (src *RKE2ControlPlane) ConvertTo(dstRaw conversion.Hub) error {
 		dst.Spec.AgentConfig.PodSecurityAdmissionConfigFile = restored.Spec.AgentConfig.PodSecurityAdmissionConfigFile
 	}
 
+	if restored.Spec.RemediationStrategy != nil {
+		dst.Spec.RemediationStrategy = restored.Spec.RemediationStrategy
+	}
+
 	dst.Spec.ServerConfig.EmbeddedRegistry = restored.Spec.ServerConfig.EmbeddedRegistry
 	dst.Spec.MachineTemplate = restored.Spec.MachineTemplate
 	dst.Status = restored.Status

controlplane/api/v1beta1/rke2controlplane_types.go

@@ -468,14 +468,14 @@ type RemediationStrategy struct {
 	// +optional
 	MaxRetry *int32 `json:"maxRetry,omitempty"`
 
-	// retryPeriod is the duration that KCP should wait before remediating a machine being created as a replacement
+	// retryPeriod is the duration that RKE2ControlPlane should wait before remediating a machine being created as a replacement
 	// for an unhealthy machine (a retry).
 	//
 	// If not set, a retry will happen immediately.
 	// +optional
 	RetryPeriod metav1.Duration `json:"retryPeriod,omitempty"`
 
-	// minHealthyPeriod defines the duration after which KCP will consider any failure to a machine unrelated
+	// minHealthyPeriod defines the duration after which RKE2ControlPlane will consider any failure to a machine unrelated
 	// from the previous one. In this case the remediation is not considered a retry anymore, and thus the retry
 	// counter restarts from 0. For example, assuming MinHealthyPeriod is set to 1h (default)
 	//

controlplane/config/crd/bases/controlplane.cluster.x-k8s.io_rke2controlplanes.yaml

@@ -1977,8 +1977,8 @@ spec:
                     type: integer
                   minHealthyPeriod:
                     description: "minHealthyPeriod defines the duration after which
-                      KCP will consider any failure to a machine unrelated\nfrom the
-                      previous one. In this case the remediation is not considered
+                      RKE2ControlPlane will consider any failure to a machine unrelated\nfrom
+                      the previous one. In this case the remediation is not considered
                       a retry anymore, and thus the retry\ncounter restarts from 0.
                       For example, assuming MinHealthyPeriod is set to 1h (default)\n\n\tM1
                       become unhealthy; remediation happens, and M1-1 is created as
@@ -1994,7 +1994,7 @@ spec:
                     type: string
                   retryPeriod:
                     description: |-
-                      retryPeriod is the duration that KCP should wait before remediating a machine being created as a replacement
+                      retryPeriod is the duration that RKE2ControlPlane should wait before remediating a machine being created as a replacement
                       for an unhealthy machine (a retry).
 
                       If not set, a retry will happen immediately.

controlplane/config/crd/bases/controlplane.cluster.x-k8s.io_rke2controlplanetemplates.yaml

@@ -821,25 +821,26 @@ spec:
                             type: integer
                           minHealthyPeriod:
                             description: "minHealthyPeriod defines the duration after
-                              which KCP will consider any failure to a machine unrelated\nfrom
-                              the previous one. In this case the remediation is not
-                              considered a retry anymore, and thus the retry\ncounter
-                              restarts from 0. For example, assuming MinHealthyPeriod
-                              is set to 1h (default)\n\n\tM1 become unhealthy; remediation
-                              happens, and M1-1 is created as a replacement.\n\tIf
-                              M1-1 (replacement of M1) has problems within the 1hr
-                              after the creation, also\n\tthis machine will be remediated
-                              and this operation is considered a retry - a problem
-                              related\n\tto the original issue happened to M1 -.\n\n\tIf
-                              instead the problem on M1-1 is happening after MinHealthyPeriod
-                              expired, e.g. four days after\n\tm1-1 has been created
-                              as a remediation of M1, the problem on M1-1 is considered
-                              unrelated to\n\tthe original issue happened to M1.\n\nIf
-                              not set, this value is defaulted to 1h."
+                              which RKE2ControlPlane will consider any failure to
+                              a machine unrelated\nfrom the previous one. In this
+                              case the remediation is not considered a retry anymore,
+                              and thus the retry\ncounter restarts from 0. For example,
+                              assuming MinHealthyPeriod is set to 1h (default)\n\n\tM1
+                              become unhealthy; remediation happens, and M1-1 is created
+                              as a replacement.\n\tIf M1-1 (replacement of M1) has
+                              problems within the 1hr after the creation, also\n\tthis
+                              machine will be remediated and this operation is considered
+                              a retry - a problem related\n\tto the original issue
+                              happened to M1 -.\n\n\tIf instead the problem on M1-1
+                              is happening after MinHealthyPeriod expired, e.g. four
+                              days after\n\tm1-1 has been created as a remediation
+                              of M1, the problem on M1-1 is considered unrelated to\n\tthe
+                              original issue happened to M1.\n\nIf not set, this value
+                              is defaulted to 1h."
                             type: string
                           retryPeriod:
                             description: |-
-                              retryPeriod is the duration that KCP should wait before remediating a machine being created as a replacement
+                              retryPeriod is the duration that RKE2ControlPlane should wait before remediating a machine being created as a replacement
                               for an unhealthy machine (a retry).
 
                               If not set, a retry will happen immediately.

controlplane/internal/controllers/remediation.go

@@ -92,7 +92,7 @@ func (r *RKE2ControlPlaneReconciler) reconcileUnhealthyMachines(ctx context.Cont
 	// and `MachineOwnerRemediated` is false, indicating that this controller is responsible for performing remediation.
 	machinesToBeRemediated := controlPlane.MachinesToBeRemediatedByRCP()
 
-	// If there are no machines to remediated, return so KCP can proceed with other operations (ctrl.Result nil).
+	// If there are no machines to remediated, return so RKE2ControlPlane can proceed with other operations (ctrl.Result nil).
 	if len(machinesToBeRemediated) == 0 {
 		return ctrl.Result{}, nil
 	}
@@ -120,8 +120,8 @@ func (r *RKE2ControlPlaneReconciler) reconcileUnhealthyMachines(ctx context.Cont
 	// is not being deleted to avoid unnecessary logs if no further remediation should be done.
 	if v, ok := controlPlane.RCP.Annotations[controlplanev1.RemediationInProgressAnnotation]; ok {
 		// Check if the annotation is stale; this might happen in case there is a crash in the controller in between
-		// when a new Machine is created and the annotation is eventually removed from KCP via defer patch at the end
-		// of KCP reconcile.
+		// when a new Machine is created and the annotation is eventually removed from RKE2ControlPlane via defer patch at the end
+		// of RKE2ControlPlane reconcile.
 		remediationData, err := RemediationDataFromAnnotation(v)
 		if err != nil {
 			return ctrl.Result{}, err
@@ -168,9 +168,9 @@ func (r *RKE2ControlPlaneReconciler) reconcileUnhealthyMachines(ctx context.Cont
 	// Before starting remediation, run preflight checks in order to verify it is safe to remediate.
 	// If any of the following checks fails, we'll surface the reason in the MachineOwnerRemediated condition.
 
-	// Check if KCP is allowed to remediate considering retry limits:
+	// Check if RKE2ControlPlane is allowed to remediate considering retry limits:
 	// - Remediation cannot happen because retryPeriod is not yet expired.
-	// - KCP already reached MaxRetries limit.
+	// - RKE2ControlPlane already reached MaxRetries limit.
 	remediationInProgressData, canRemediate, err := r.checkRetryLimits(log, machineToBeRemediated, controlPlane, reconciliationTime)
 	if err != nil {
 		return ctrl.Result{}, err
@@ -181,7 +181,7 @@ func (r *RKE2ControlPlaneReconciler) reconcileUnhealthyMachines(ctx context.Cont
 		return ctrl.Result{}, nil
 	}
 
-	// Executes checks that apply only if the control plane is already initialized; in this case KCP can
+	// Executes checks that apply only if the control plane is already initialized; in this case RKE2ControlPlane can
 	// remediate only if it can safely assume that the operation preserves the operation state of the
 	// existing cluster (or at least it doesn't make it worse).
 	if controlPlane.RCP.Status.Initialized {
@@ -203,7 +203,7 @@ func (r *RKE2ControlPlaneReconciler) reconcileUnhealthyMachines(ctx context.Cont
 		}
 
 		// The cluster MUST NOT have healthy machines still being provisioned.
-		// This rule prevents KCP taking actions while the cluster is in a transitional state.
+		// This rule prevents RKE2ControlPlane taking actions while the cluster is in a transitional state.
 		if controlPlane.HasHealthyMachineStillProvisioning() {
 			log.Info("A control plane machine needs remediation, but there are other control-plane machines being provisioned. Skipping remediation")
 			conditions.MarkFalse(
@@ -217,7 +217,7 @@ func (r *RKE2ControlPlaneReconciler) reconcileUnhealthyMachines(ctx context.Cont
 			return ctrl.Result{}, nil
 		}
 
-		// The cluster MUST have no machines with a deletion timestamp. This rule prevents KCP taking actions while the cluster is in a transitional state.
+		// The cluster MUST have no machines with a deletion timestamp. This rule prevents RKE2ControlPlane taking actions while the cluster is in a transitional state.
 		if controlPlane.HasDeletingMachine() {
 			log.Info("A control plane machine needs remediation, but there are other control-plane machines being deleted. Skipping remediation")
 			conditions.MarkFalse(
@@ -231,7 +231,7 @@ func (r *RKE2ControlPlaneReconciler) reconcileUnhealthyMachines(ctx context.Cont
 			return ctrl.Result{}, nil
 		}
 
-		// Remediation MUST preserve etcd quorum. This rule ensures that KCP will not remove a member that would result in etcd
+		// Remediation MUST preserve etcd quorum. This rule ensures that RKE2ControlPlane will not remove a member that would result in etcd
 		// losing a majority of members and thus become unable to field new requests.
 		if controlPlane.IsEtcdManaged() {
 			canSafelyRemediate, err := r.canSafelyRemoveEtcdMember(ctx, controlPlane, machineToBeRemediated)
@@ -433,9 +433,9 @@ func pickMachineToBeRemediatedByConditionState(i, j *clusterv1.Machine, t cluste
 	return nil
 }
 
-// checkRetryLimits checks if KCP is allowed to remediate considering retry limits:
+// checkRetryLimits checks if RKE2ControlPlane is allowed to remediate considering retry limits:
 // - Remediation cannot happen because retryPeriod is not yet expired.
-// - KCP already reached the maximum number of retries for a machine.
+// - RKE2ControlPlane already reached the maximum number of retries for a machine.
 // NOTE: Counting the number of retries is required In order to prevent infinite remediation e.g. in case the
 // first Control Plane machine is failing due to quota issue.
 func (r *RKE2ControlPlaneReconciler) checkRetryLimits(
@@ -489,7 +489,7 @@ func (r *RKE2ControlPlaneReconciler) checkRetryLimits(
 	}
 
 	// Once we get here we already know that there was a last remediation for the Machine.
-	// If the current remediation is happening before minHealthyPeriod is expired, then KCP considers this
+	// If the current remediation is happening before minHealthyPeriod is expired, then RKE2ControlPlane considers this
 	// as a remediation for the same previously unhealthy machine.
 	// NOTE: If someone/something changes the RemediationForAnnotation on Machines (e.g. changes the Timestamp),
 	// this could potentially lead to executing more retries than expected, but this is considered acceptable in such a case.
@@ -624,9 +624,9 @@ func (r *RKE2ControlPlaneReconciler) canSafelyRemoveEtcdMember(ctx context.Conte
 		}
 
 		// If an etcd member does not have a corresponding machine it is not possible to retrieve etcd member health,
-		// so KCP is assuming the worst scenario and considering the member unhealthy.
+		// so RKE2ControlPlane is assuming the worst scenario and considering the member unhealthy.
 		//
-		// NOTE: This should not happen given that KCP is running reconcileEtcdMembers before calling this method.
+		// NOTE: This should not happen given that RKE2ControlPlane is running reconcileEtcdMembers before calling this method.
 		if machine == nil {
 			log.Info("An etcd member does not have a corresponding machine, assuming this member is unhealthy", "memberName", etcdMember)
 			targetUnhealthyMembers++
@@ -663,7 +663,7 @@ func (r *RKE2ControlPlaneReconciler) canSafelyRemoveEtcdMember(ctx context.Conte
 	return canSafelyRemediate, nil
 }
 
-// RemediationData struct is used to keep track of information stored in the RemediationInProgressAnnotation in KCP
+// RemediationData struct is used to keep track of information stored in the RemediationInProgressAnnotation in RKE2ControlPlane
 // during remediation and then into the RemediationForAnnotation on the replacement machine once it is created.
 type RemediationData struct {
 	// machine is the machine name of the latest machine being remediated.