refactor: move to a switch/case statement

Author: sethp-nr

controllers/kubeadmconfig_controller.go

@@ -140,8 +140,23 @@ func (r *KubeadmConfigReconciler) Reconcile(req ctrl.Request) (_ ctrl.Result, re
 		return ctrl.Result{}, err
 	}
 
+	// Initialize the patch helper
+	patchHelper, err := patch.NewHelper(config, r)
+	if err != nil {
+		return ctrl.Result{}, err
+	}
+	// Attempt to Patch the KubeadmConfig object and status after each reconciliation if no error occurs.
+	defer func() {
+		if rerr == nil {
+			if rerr = patchHelper.Patch(ctx, config); rerr != nil {
+				log.Error(rerr, "failed to patch config")
+			}
+		}
+	}()
+
+	switch {
 	// If we've already embedded a time-limited join token into a config, but are still waiting for the token to be used, refresh it
-	if config.Status.Ready {
+	case config.Status.Ready:
 		token := config.Spec.JoinConfiguration.Discovery.BootstrapToken.Token
 
 		// gets the remote secret interface client for the current cluster
@@ -157,29 +172,11 @@ func (r *KubeadmConfigReconciler) Reconcile(req ctrl.Request) (_ ctrl.Result, re
 			return ctrl.Result{}, errors.Wrapf(err, "failed to refresh bootstrap token")
 		}
 		return ctrl.Result{}, nil
-	}
-
 	// Wait patiently for the infrastructure to be ready
-	if !cluster.Status.InfrastructureReady {
+	case !cluster.Status.InfrastructureReady:
 		log.Info("Infrastructure is not ready, waiting until ready.")
 		return ctrl.Result{}, nil
-	}
-
-	// Initialize the patch helper
-	patchHelper, err := patch.NewHelper(config, r)
-	if err != nil {
-		return ctrl.Result{}, err
-	}
-	// Attempt to Patch the KubeadmConfig object and status after each reconciliation if no error occurs.
-	defer func() {
-		if rerr == nil {
-			if rerr = patchHelper.Patch(ctx, config); rerr != nil {
-				log.Error(rerr, "failed to patch config")
-			}
-		}
-	}()
-
-	if !cluster.Status.ControlPlaneInitialized {
+	case !cluster.Status.ControlPlaneInitialized:
 		// if it's NOT a control plane machine, requeue
 		if !util.IsControlPlaneMachine(machine) {
 			log.Info(fmt.Sprintf("Machine is not a control plane. If it should be a control plane, add `%s: true` as a label to the Machine", clusterv1.MachineControlPlaneLabelName))
@@ -271,102 +268,102 @@ func (r *KubeadmConfigReconciler) Reconcile(req ctrl.Request) (_ ctrl.Result, re
 		config.Status.Ready = true
 
 		return ctrl.Result{}, nil
-	}
-
 	// Every other case it's a join scenario
-	// Nb. in this case ClusterConfiguration and JoinConfiguration should not be defined by users, but in case of misconfigurations, CABPK simply ignore them
+	default:
+		// Nb. in this case ClusterConfiguration and JoinConfiguration should not be defined by users, but in case of misconfigurations, CABPK simply ignore them
 
-	// Unlock any locks that might have been set during init process
-	r.KubeadmInitLock.Unlock(ctx, cluster)
+		// Unlock any locks that might have been set during init process
+		r.KubeadmInitLock.Unlock(ctx, cluster)
 
-	if config.Spec.JoinConfiguration == nil {
-		return ctrl.Result{}, errors.New("Control plane already exists for the cluster, only KubeadmConfig objects with JoinConfiguration are allowed")
-	}
+		if config.Spec.JoinConfiguration == nil {
+			return ctrl.Result{}, errors.New("Control plane already exists for the cluster, only KubeadmConfig objects with JoinConfiguration are allowed")
+		}
 
-	certificates := internalcluster.NewCertificates()
-	if err := certificates.Lookup(ctx, r.Client, cluster); err != nil {
-		log.Error(err, "unable to lookup cluster certificates")
-		return ctrl.Result{}, err
-	}
-	if err := certificates.EnsureAllExist(); err != nil {
-		return ctrl.Result{}, err
-	}
+		certificates := internalcluster.NewCertificates()
+		if err := certificates.Lookup(ctx, r.Client, cluster); err != nil {
+			log.Error(err, "unable to lookup cluster certificates")
+			return ctrl.Result{}, err
+		}
+		if err := certificates.EnsureAllExist(); err != nil {
+			return ctrl.Result{}, err
+		}
 
-	hashes, err := certificates.GetByPurpose(secret.ClusterCA).Hashes()
-	if err != nil {
-		log.Error(err, "Unable to generate Cluster CA certificate hashes")
-		return ctrl.Result{}, err
-	}
-	// TODO: move this into reconcile.Discovery so that defaults for the Discovery are all in the same place
-	if config.Spec.JoinConfiguration.Discovery.BootstrapToken == nil {
-		config.Spec.JoinConfiguration.Discovery.BootstrapToken = &kubeadmv1beta1.BootstrapTokenDiscovery{}
-	}
-	config.Spec.JoinConfiguration.Discovery.BootstrapToken.CACertHashes = hashes
+		hashes, err := certificates.GetByPurpose(secret.ClusterCA).Hashes()
+		if err != nil {
+			log.Error(err, "Unable to generate Cluster CA certificate hashes")
+			return ctrl.Result{}, err
+		}
+		// TODO: move this into reconcile.Discovery so that defaults for the Discovery are all in the same place
+		if config.Spec.JoinConfiguration.Discovery.BootstrapToken == nil {
+			config.Spec.JoinConfiguration.Discovery.BootstrapToken = &kubeadmv1beta1.BootstrapTokenDiscovery{}
+		}
+		config.Spec.JoinConfiguration.Discovery.BootstrapToken.CACertHashes = hashes
 
-	// ensure that joinConfiguration.Discovery is properly set for joining node on the current cluster
-	if err := r.reconcileDiscovery(cluster, config); err != nil {
-		if requeueErr, ok := errors.Cause(err).(capierrors.HasRequeueAfterError); ok {
-			log.Info(err.Error())
-			return ctrl.Result{RequeueAfter: requeueErr.GetRequeueAfter()}, nil
+		// ensure that joinConfiguration.Discovery is properly set for joining node on the current cluster
+		if err := r.reconcileDiscovery(cluster, config); err != nil {
+			if requeueErr, ok := errors.Cause(err).(capierrors.HasRequeueAfterError); ok {
+				log.Info(err.Error())
+				return ctrl.Result{RequeueAfter: requeueErr.GetRequeueAfter()}, nil
+			}
+			return ctrl.Result{}, err
 		}
-		return ctrl.Result{}, err
-	}
 
-	joindata, err := kubeadmv1beta1.ConfigurationToYAML(config.Spec.JoinConfiguration)
-	if err != nil {
-		log.Error(err, "failed to marshal join configuration")
-		return ctrl.Result{}, err
-	}
+		joindata, err := kubeadmv1beta1.ConfigurationToYAML(config.Spec.JoinConfiguration)
+		if err != nil {
+			log.Error(err, "failed to marshal join configuration")
+			return ctrl.Result{}, err
+		}
+
+		// it's a control plane join
+		if util.IsControlPlaneMachine(machine) {
+			if config.Spec.JoinConfiguration.ControlPlane == nil {
+				return ctrl.Result{}, errors.New("Machine is a ControlPlane, but JoinConfiguration.ControlPlane is not set in the KubeadmConfig object")
+			}
+
+			cloudJoinData, err := cloudinit.NewJoinControlPlane(&cloudinit.ControlPlaneJoinInput{
+				JoinConfiguration: joindata,
+				Certificates:      certificates,
+				BaseUserData: cloudinit.BaseUserData{
+					AdditionalFiles:     config.Spec.Files,
+					NTP:                 config.Spec.NTP,
+					PreKubeadmCommands:  config.Spec.PreKubeadmCommands,
+					PostKubeadmCommands: config.Spec.PostKubeadmCommands,
+					Users:               config.Spec.Users,
+				},
+			})
+			if err != nil {
+				log.Error(err, "failed to create a control plane join configuration")
+				return ctrl.Result{}, err
+			}
 
-	// it's a control plane join
-	if util.IsControlPlaneMachine(machine) {
-		if config.Spec.JoinConfiguration.ControlPlane == nil {
-			return ctrl.Result{}, errors.New("Machine is a ControlPlane, but JoinConfiguration.ControlPlane is not set in the KubeadmConfig object")
+			config.Status.BootstrapData = cloudJoinData
+			config.Status.Ready = true
+			return ctrl.Result{}, nil
 		}
 
-		cloudJoinData, err := cloudinit.NewJoinControlPlane(&cloudinit.ControlPlaneJoinInput{
-			JoinConfiguration: joindata,
-			Certificates:      certificates,
+		// otherwise it is a node
+		if config.Spec.JoinConfiguration.ControlPlane != nil {
+			return ctrl.Result{}, errors.New("Machine is a Worker, but JoinConfiguration.ControlPlane is set in the KubeadmConfig object")
+		}
+
+		cloudJoinData, err := cloudinit.NewNode(&cloudinit.NodeInput{
 			BaseUserData: cloudinit.BaseUserData{
 				AdditionalFiles:     config.Spec.Files,
 				NTP:                 config.Spec.NTP,
 				PreKubeadmCommands:  config.Spec.PreKubeadmCommands,
 				PostKubeadmCommands: config.Spec.PostKubeadmCommands,
 				Users:               config.Spec.Users,
 			},
+			JoinConfiguration: joindata,
 		})
 		if err != nil {
-			log.Error(err, "failed to create a control plane join configuration")
+			log.Error(err, "failed to create a worker join configuration")
 			return ctrl.Result{}, err
 		}
-
 		config.Status.BootstrapData = cloudJoinData
 		config.Status.Ready = true
 		return ctrl.Result{}, nil
 	}
-
-	// otherwise it is a node
-	if config.Spec.JoinConfiguration.ControlPlane != nil {
-		return ctrl.Result{}, errors.New("Machine is a Worker, but JoinConfiguration.ControlPlane is set in the KubeadmConfig object")
-	}
-
-	cloudJoinData, err := cloudinit.NewNode(&cloudinit.NodeInput{
-		BaseUserData: cloudinit.BaseUserData{
-			AdditionalFiles:     config.Spec.Files,
-			NTP:                 config.Spec.NTP,
-			PreKubeadmCommands:  config.Spec.PreKubeadmCommands,
-			PostKubeadmCommands: config.Spec.PostKubeadmCommands,
-			Users:               config.Spec.Users,
-		},
-		JoinConfiguration: joindata,
-	})
-	if err != nil {
-		log.Error(err, "failed to create a worker join configuration")
-		return ctrl.Result{}, err
-	}
-	config.Status.BootstrapData = cloudJoinData
-	config.Status.Ready = true
-	return ctrl.Result{}, nil
 }
 
 // ClusterToKubeadmConfigs is a handler.ToRequestsFunc to be used to enqeue