Fix spelling of requeuing across files

killianmuldoon · killianmuldoon · commit 3970e721875b · 2023-01-30T18:36:59.000Z
diff --git a/bootstrap/kubeadm/internal/controllers/kubeadmconfig_controller.go b/bootstrap/kubeadm/internal/controllers/kubeadmconfig_controller.go
@@ -368,7 +368,7 @@ func (r *KubeadmConfigReconciler) handleClusterNotInitialized(ctx context.Contex
 
 	// if the machine has not ClusterConfiguration and InitConfiguration, requeue
 	if scope.Config.Spec.InitConfiguration == nil && scope.Config.Spec.ClusterConfiguration == nil {
-		scope.Info("Control plane is not ready, requeing joining control planes until ready.")
+		scope.Info("Control plane is not ready, requeuing joining control planes until ready.")
 		return ctrl.Result{RequeueAfter: 30 * time.Second}, nil
 	}
 
@@ -381,7 +381,7 @@ func (r *KubeadmConfigReconciler) handleClusterNotInitialized(ctx context.Contex
 	// as control plane get processed here
 	// if not the first, requeue
 	if !r.KubeadmInitLock.Lock(ctx, scope.Cluster, machine) {
-		scope.Info("A control plane is already being initialized, requeing until control plane is ready")
+		scope.Info("A control plane is already being initialized, requeuing until control plane is ready")
 		return ctrl.Result{RequeueAfter: 30 * time.Second}, nil
 	}
 
diff --git a/controlplane/kubeadm/internal/controllers/controller.go b/controlplane/kubeadm/internal/controllers/controller.go
@@ -211,7 +211,7 @@ func (r *KubeadmControlPlaneReconciler) Reconcile(ctx context.Context, req ctrl.
 		// Requeue if the reconcile failed because the ClusterCacheTracker was locked for
 		// the current cluster because of concurrent access.
 		if errors.Is(err, remote.ErrClusterLocked) {
-			log.V(5).Info("Requeueing because another worker has the lock on the ClusterCacheTracker")
+			log.V(5).Info("Requeuing because another worker has the lock on the ClusterCacheTracker")
 			return ctrl.Result{Requeue: true}, nil
 		}
 		return res, err
@@ -222,7 +222,7 @@ func (r *KubeadmControlPlaneReconciler) Reconcile(ctx context.Context, req ctrl.
 	// Requeue if the reconcile failed because the ClusterCacheTracker was locked for
 	// the current cluster because of concurrent access.
 	if errors.Is(err, remote.ErrClusterLocked) {
-		log.V(5).Info("Requeueing because another worker has the lock on the ClusterCacheTracker")
+		log.V(5).Info("Requeuing because another worker has the lock on the ClusterCacheTracker")
 		return ctrl.Result{Requeue: true}, nil
 	}
 	return res, err
diff --git a/exp/addons/internal/controllers/clusterresourceset_controller.go b/exp/addons/internal/controllers/clusterresourceset_controller.go
@@ -155,7 +155,7 @@ func (r *ClusterResourceSetReconciler) Reconcile(ctx context.Context, req ctrl.R
 			// Requeue if the reconcile failed because the ClusterCacheTracker was locked for
 			// the current cluster because of concurrent access.
 			if errors.Is(err, remote.ErrClusterLocked) {
-				log.V(5).Info("Requeueing because another worker has the lock on the ClusterCacheTracker")
+				log.V(5).Info("Requeuing because another worker has the lock on the ClusterCacheTracker")
 				return ctrl.Result{Requeue: true}, nil
 			}
 			return ctrl.Result{}, err
diff --git a/internal/controllers/machine/machine_controller.go b/internal/controllers/machine/machine_controller.go
@@ -216,7 +216,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Re
 		// Requeue if the reconcile failed because the ClusterCacheTracker was locked for
 		// the current cluster because of concurrent access.
 		if errors.Is(err, remote.ErrClusterLocked) {
-			log.V(5).Info("Requeueing because another worker has the lock on the ClusterCacheTracker")
+			log.V(5).Info("Requeuing because another worker has the lock on the ClusterCacheTracker")
 			return ctrl.Result{Requeue: true}, nil
 		}
 		return res, err
@@ -227,7 +227,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Re
 	// Requeue if the reconcile failed because the ClusterCacheTracker was locked for
 	// the current cluster because of concurrent access.
 	if errors.Is(err, remote.ErrClusterLocked) {
-		log.V(5).Info("Requeueing because another worker has the lock on the ClusterCacheTracker")
+		log.V(5).Info("Requeuing because another worker has the lock on the ClusterCacheTracker")
 		return ctrl.Result{Requeue: true}, nil
 	}
 	return res, err
diff --git a/internal/controllers/machine/machine_controller_phases.go b/internal/controllers/machine/machine_controller_phases.go
@@ -98,7 +98,7 @@ func (r *Reconciler) reconcileExternal(ctx context.Context, cluster *clusterv1.C
 	obj, err := external.Get(ctx, r.Client, ref, m.Namespace)
 	if err != nil {
 		if apierrors.IsNotFound(errors.Cause(err)) {
-			log.Info("could not find external ref, requeueing", ref.Kind, klog.KRef(m.Namespace, ref.Name))
+			log.Info("could not find external ref, requeuing", ref.Kind, klog.KRef(m.Namespace, ref.Name))
 			return external.ReconcileOutput{RequeueAfter: externalReadyWait}, nil
 		}
 		return external.ReconcileOutput{}, err
@@ -251,7 +251,7 @@ func (r *Reconciler) reconcileInfrastructure(ctx context.Context, cluster *clust
 			m.Status.FailureReason = capierrors.MachineStatusErrorPtr(capierrors.InvalidConfigurationMachineError)
 			m.Status.FailureMessage = pointer.String(fmt.Sprintf("Machine infrastructure resource %v with name %q has been deleted after being ready",
 				m.Spec.InfrastructureRef.GroupVersionKind(), m.Spec.InfrastructureRef.Name))
-			return ctrl.Result{}, errors.Errorf("could not find %v %q for Machine %q in namespace %q, requeueing", m.Spec.InfrastructureRef.GroupVersionKind().String(), m.Spec.InfrastructureRef.Name, m.Name, m.Namespace)
+			return ctrl.Result{}, errors.Errorf("could not find %v %q for Machine %q in namespace %q, requeuing", m.Spec.InfrastructureRef.GroupVersionKind().String(), m.Spec.InfrastructureRef.Name, m.Name, m.Namespace)
 		}
 		return ctrl.Result{RequeueAfter: infraReconcileResult.RequeueAfter}, nil
 	}
diff --git a/internal/controllers/machinehealthcheck/machinehealthcheck_controller.go b/internal/controllers/machinehealthcheck/machinehealthcheck_controller.go
@@ -177,7 +177,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Re
 		// Requeue if the reconcile failed because the ClusterCacheTracker was locked for
 		// the current cluster because of concurrent access.
 		if errors.Is(err, remote.ErrClusterLocked) {
-			log.V(5).Info("Requeueing because another worker has the lock on the ClusterCacheTracker")
+			log.V(5).Info("Requeuing because another worker has the lock on the ClusterCacheTracker")
 			return ctrl.Result{Requeue: true}, nil
 		}
 		log.Error(err, "Failed to reconcile MachineHealthCheck")
@@ -322,7 +322,7 @@ func (r *Reconciler) reconcile(ctx context.Context, logger logr.Logger, cluster
 
 	// handle update errors
 	if len(errList) > 0 {
-		logger.V(3).Info("Error(s) marking machine, requeueing")
+		logger.V(3).Info("Error(s) marking machine, requeuing")
 		return reconcile.Result{}, kerrors.NewAggregate(errList)
 	}
 
diff --git a/internal/controllers/machineset/machineset_controller.go b/internal/controllers/machineset/machineset_controller.go
@@ -176,7 +176,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Re
 		// Requeue if the reconcile failed because the ClusterCacheTracker was locked for
 		// the current cluster because of concurrent access.
 		if errors.Is(err, remote.ErrClusterLocked) {
-			log.V(5).Info("Requeueing because another worker has the lock on the ClusterCacheTracker")
+			log.V(5).Info("Requeuing because another worker has the lock on the ClusterCacheTracker")
 			return ctrl.Result{Requeue: true}, nil
 		}
 		log.Error(err, "Failed to reconcile MachineSet")
diff --git a/test/infrastructure/docker/exp/internal/controllers/dockermachinepool_controller.go b/test/infrastructure/docker/exp/internal/controllers/dockermachinepool_controller.go
@@ -132,7 +132,7 @@ func (r *DockerMachinePoolReconciler) Reconcile(ctx context.Context, req ctrl.Re
 	// Requeue if the reconcile failed because the ClusterCacheTracker was locked for
 	// the current cluster because of concurrent access.
 	if errors.Is(err, remote.ErrClusterLocked) {
-		log.V(5).Info("Requeueing because another worker has the lock on the ClusterCacheTracker")
+		log.V(5).Info("Requeuing because another worker has the lock on the ClusterCacheTracker")
 		return ctrl.Result{Requeue: true}, nil
 	}
 	return res, err
diff --git a/test/infrastructure/docker/internal/controllers/dockermachine_controller.go b/test/infrastructure/docker/internal/controllers/dockermachine_controller.go
@@ -171,7 +171,7 @@ func (r *DockerMachineReconciler) Reconcile(ctx context.Context, req ctrl.Reques
 	// Requeue if the reconcile failed because the ClusterCacheTracker was locked for
 	// the current cluster because of concurrent access.
 	if errors.Is(err, remote.ErrClusterLocked) {
-		log.V(5).Info("Requeueing because another worker has the lock on the ClusterCacheTracker")
+		log.V(5).Info("Requeuing because another worker has the lock on the ClusterCacheTracker")
 		return ctrl.Result{Requeue: true}, nil
 	}
 	return res, err

Original file line number	Diff line number	Diff line change
`@@ -368,7 +368,7 @@ func (r *KubeadmConfigReconciler) handleClusterNotInitialized(ctx context.Contex`
`368`	`368`
`369`	`369`	`// if the machine has not ClusterConfiguration and InitConfiguration, requeue`
`370`	`370`	`if scope.Config.Spec.InitConfiguration == nil && scope.Config.Spec.ClusterConfiguration == nil {`
`371`		`- scope.Info("Control plane is not ready, requeing joining control planes until ready.")`
	`371`	`+ scope.Info("Control plane is not ready, requeuing joining control planes until ready.")`
`372`	`372`	`return ctrl.Result{RequeueAfter: 30 * time.Second}, nil`
`373`	`373`	`}`
`374`	`374`
`@@ -381,7 +381,7 @@ func (r *KubeadmConfigReconciler) handleClusterNotInitialized(ctx context.Contex`
`381`	`381`	`// as control plane get processed here`
`382`	`382`	`// if not the first, requeue`
`383`	`383`	`if !r.KubeadmInitLock.Lock(ctx, scope.Cluster, machine) {`
`384`		`- scope.Info("A control plane is already being initialized, requeing until control plane is ready")`
	`384`	`+ scope.Info("A control plane is already being initialized, requeuing until control plane is ready")`
`385`	`385`	`return ctrl.Result{RequeueAfter: 30 * time.Second}, nil`
`386`	`386`	`}`
`387`	`387`
Original file line number	Diff line number	Diff line change
`@@ -155,7 +155,7 @@ func (r *ClusterResourceSetReconciler) Reconcile(ctx context.Context, req ctrl.R`
`155`	`155`	`// Requeue if the reconcile failed because the ClusterCacheTracker was locked for`
`156`	`156`	`// the current cluster because of concurrent access.`
`157`	`157`	`if errors.Is(err, remote.ErrClusterLocked) {`
`158`		`- log.V(5).Info("Requeueing because another worker has the lock on the ClusterCacheTracker")`
	`158`	`+ log.V(5).Info("Requeuing because another worker has the lock on the ClusterCacheTracker")`
`159`	`159`	`return ctrl.Result{Requeue: true}, nil`
`160`	`160`	`}`
`161`	`161`	`return ctrl.Result{}, err`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ func (r Reconciler) reconcileExternal(ctx context.Context, cluster clusterv1.C`
`98`	`98`	`obj, err := external.Get(ctx, r.Client, ref, m.Namespace)`
`99`	`99`	`if err != nil {`
`100`	`100`	`if apierrors.IsNotFound(errors.Cause(err)) {`
`101`		`- log.Info("could not find external ref, requeueing", ref.Kind, klog.KRef(m.Namespace, ref.Name))`
	`101`	`+ log.Info("could not find external ref, requeuing", ref.Kind, klog.KRef(m.Namespace, ref.Name))`
`102`	`102`	`return external.ReconcileOutput{RequeueAfter: externalReadyWait}, nil`
`103`	`103`	`}`
`104`	`104`	`return external.ReconcileOutput{}, err`
`@@ -251,7 +251,7 @@ func (r Reconciler) reconcileInfrastructure(ctx context.Context, cluster clust`
`251`	`251`	`m.Status.FailureReason = capierrors.MachineStatusErrorPtr(capierrors.InvalidConfigurationMachineError)`
`252`	`252`	`m.Status.FailureMessage = pointer.String(fmt.Sprintf("Machine infrastructure resource %v with name %q has been deleted after being ready",`
`253`	`253`	`m.Spec.InfrastructureRef.GroupVersionKind(), m.Spec.InfrastructureRef.Name))`
`254`		`- return ctrl.Result{}, errors.Errorf("could not find %v %q for Machine %q in namespace %q, requeueing", m.Spec.InfrastructureRef.GroupVersionKind().String(), m.Spec.InfrastructureRef.Name, m.Name, m.Namespace)`
	`254`	`+ return ctrl.Result{}, errors.Errorf("could not find %v %q for Machine %q in namespace %q, requeuing", m.Spec.InfrastructureRef.GroupVersionKind().String(), m.Spec.InfrastructureRef.Name, m.Name, m.Namespace)`
`255`	`255`	`}`
`256`	`256`	`return ctrl.Result{RequeueAfter: infraReconcileResult.RequeueAfter}, nil`
`257`	`257`	`}`
Original file line number	Diff line number	Diff line change
`@@ -176,7 +176,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Re`
`176`	`176`	`// Requeue if the reconcile failed because the ClusterCacheTracker was locked for`
`177`	`177`	`// the current cluster because of concurrent access.`
`178`	`178`	`if errors.Is(err, remote.ErrClusterLocked) {`
`179`		`- log.V(5).Info("Requeueing because another worker has the lock on the ClusterCacheTracker")`
	`179`	`+ log.V(5).Info("Requeuing because another worker has the lock on the ClusterCacheTracker")`
`180`	`180`	`return ctrl.Result{Requeue: true}, nil`
`181`	`181`	`}`
`182`	`182`	`log.Error(err, "Failed to reconcile MachineSet")`
Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ func (r *DockerMachinePoolReconciler) Reconcile(ctx context.Context, req ctrl.Re`
`132`	`132`	`// Requeue if the reconcile failed because the ClusterCacheTracker was locked for`
`133`	`133`	`// the current cluster because of concurrent access.`
`134`	`134`	`if errors.Is(err, remote.ErrClusterLocked) {`
`135`		`- log.V(5).Info("Requeueing because another worker has the lock on the ClusterCacheTracker")`
	`135`	`+ log.V(5).Info("Requeuing because another worker has the lock on the ClusterCacheTracker")`
`136`	`136`	`return ctrl.Result{Requeue: true}, nil`
`137`	`137`	`}`
`138`	`138`	`return res, err`
Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ func (r *DockerMachineReconciler) Reconcile(ctx context.Context, req ctrl.Reques`
`171`	`171`	`// Requeue if the reconcile failed because the ClusterCacheTracker was locked for`
`172`	`172`	`// the current cluster because of concurrent access.`
`173`	`173`	`if errors.Is(err, remote.ErrClusterLocked) {`
`174`		`- log.V(5).Info("Requeueing because another worker has the lock on the ClusterCacheTracker")`
	`174`	`+ log.V(5).Info("Requeuing because another worker has the lock on the ClusterCacheTracker")`
`175`	`175`	`return ctrl.Result{Requeue: true}, nil`
`176`	`176`	`}`
`177`	`177`	`return res, err`