fix(controller): Make controller logic consistent

Signed-off-by: Mathieu Cesbron <mathieu.cesbron@protonmail.com>

controllers/certificate_lifecycle_controller.go

@@ -35,28 +35,31 @@ type CertificateLifecycle struct {
 }
 
 func (s *CertificateLifecycle) Reconcile(ctx context.Context, request reconcile.Request) (reconcile.Result, error) {
-	logger := log.FromContext(ctx)
+	log := log.FromContext(ctx)
 
-	logger.Info("starting CertificateLifecycle handling")
+	log.Info("starting CertificateLifecycle handling")
 
 	secret := corev1.Secret{}
-	if err := s.client.Get(ctx, request.NamespacedName, &secret); err != nil {
-		if k8serrors.IsNotFound(err) {
-			logger.Info("resource may have been deleted, skipping")
+	err := s.client.Get(ctx, request.NamespacedName, &secret)
+	if k8serrors.IsNotFound(err) {
+		log.Info("resource have been deleted, skipping")
 
-			return reconcile.Result{}, nil
-		}
+		return reconcile.Result{}, nil
+	}
+	if err != nil {
+		log.Error(err, "cannot retrieve the required resource")
+
+		return reconcile.Result{}, err
 	}
 
 	checkType, ok := secret.GetLabels()[constants.ControllerLabelResource]
 	if !ok {
-		logger.Info("missing controller label, shouldn't happen")
+		log.Info("missing controller label, shouldn't happen")
 
 		return reconcile.Result{}, nil
 	}
 
 	var crt *x509.Certificate
-	var err error
 
 	switch checkType {
 	case "x509":
@@ -68,15 +71,15 @@ func (s *CertificateLifecycle) Reconcile(ctx context.Context, request reconcile.
 	}
 
 	if err != nil {
-		logger.Error(err, "skipping reconciliation")
+		log.Error(err, "skipping reconciliation")
 
 		return reconcile.Result{}, nil
 	}
 
 	deadline := time.Now().AddDate(0, 0, 1)
 
 	if deadline.After(crt.NotAfter) {
-		logger.Info("certificate near expiration, must be rotated")
+		log.Info("certificate near expiration, must be rotated")
 
 		s.Channel <- event.GenericEvent{Object: &kamajiv1alpha1.TenantControlPlane{
 			ObjectMeta: metav1.ObjectMeta{
@@ -85,14 +88,14 @@ func (s *CertificateLifecycle) Reconcile(ctx context.Context, request reconcile.
 			},
 		}}
 
-		logger.Info("certificate rotation triggered")
+		log.Info("certificate rotation triggered")
 
 		return reconcile.Result{}, nil
 	}
 
 	after := crt.NotAfter.Sub(deadline)
 
-	logger.Info("certificate is still valid, enqueuing back", "after", after.String())
+	log.Info("certificate is still valid, enqueuing back", "after", after.String())
 
 	return reconcile.Result{Requeue: true, RequeueAfter: after}, nil
 }

controllers/datastore_controller.go

@@ -39,12 +39,14 @@ func (r *DataStore) Reconcile(ctx context.Context, request reconcile.Request) (r
 	log := log.FromContext(ctx)
 
 	ds := &kamajiv1alpha1.DataStore{}
-	if err := r.Client.Get(ctx, request.NamespacedName, ds); err != nil {
-		if k8serrors.IsNotFound(err) {
-			return reconcile.Result{}, nil
-		}
+	err := r.Client.Get(ctx, request.NamespacedName, ds)
+	if k8serrors.IsNotFound(err) {
+		log.Info("resource have been deleted, skipping")
 
-		log.Error(err, "unable to retrieve the request")
+		return reconcile.Result{}, nil
+	}
+	if err != nil {
+		log.Error(err, "cannot retrieve the required resource")
 
 		return reconcile.Result{}, err
 	}

controllers/tenantcontrolplane_controller.go

@@ -15,7 +15,7 @@ import (
 	batchv1 "k8s.io/api/batch/v1"
 	corev1 "k8s.io/api/core/v1"
 	networkingv1 "k8s.io/api/networking/v1"
-	apimachineryerrors "k8s.io/apimachinery/pkg/api/errors"
+	k8serrors "k8s.io/apimachinery/pkg/api/errors"
 	k8stypes "k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/util/workqueue"
 	"k8s.io/utils/clock"
@@ -84,16 +84,15 @@ func (r *TenantControlPlaneReconciler) Reconcile(ctx context.Context, req ctrl.R
 	defer cancelFn()
 
 	tenantControlPlane, err := r.getTenantControlPlane(ctx, req.NamespacedName)()
-	if err != nil {
-		if apimachineryerrors.IsNotFound(err) {
-			log.Info("resource may have been deleted, skipping")
-
-			return ctrl.Result{}, nil
-		}
+	if k8serrors.IsNotFound(err) {
+		log.Info("resource have been deleted, skipping")
 
-		log.Error(err, "cannot retrieve the required instance")
+		return reconcile.Result{}, nil
+	}
+	if err != nil {
+		log.Error(err, "cannot retrieve the required resource")
 
-		return ctrl.Result{}, err
+		return reconcile.Result{}, err
 	}
 
 	releaser, err := mutex.Acquire(r.mutexSpec(tenantControlPlane))