Apply basereconciler api changes

controllers/apicast_controller.go

@@ -30,7 +30,6 @@ import (
 	autoscalingv2 "k8s.io/api/autoscaling/v2"
 	corev1 "k8s.io/api/core/v1"
 	policyv1 "k8s.io/api/policy/v1"
-	"k8s.io/apimachinery/pkg/types"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 )
@@ -59,10 +58,9 @@ func (r *ApicastReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	ctx = log.IntoContext(ctx, logger)
 
 	instance := &saasv1alpha1.Apicast{}
-	key := types.NamespacedName{Name: req.Name, Namespace: req.Namespace}
-	result, err := r.GetInstance(ctx, key, instance, nil, nil)
-	if result != nil || err != nil {
-		return *result, err
+	result := r.GetInstance(ctx, req, instance, nil, nil)
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	// Apply defaults for reconcile but do not store them in the API
@@ -87,10 +85,9 @@ func (r *ApicastReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	}
 	resources = append(resources, production...)
 
-	err = r.ReconcileOwnedResources(ctx, instance, resources)
-	if err != nil {
-		logger.Error(err, "unable to update owned resources")
-		return ctrl.Result{}, err
+	result = r.ReconcileOwnedResources(ctx, instance, resources)
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	return ctrl.Result{}, nil

controllers/autossl_controller.go

@@ -30,7 +30,6 @@ import (
 	autoscalingv2 "k8s.io/api/autoscaling/v2"
 	corev1 "k8s.io/api/core/v1"
 	policyv1 "k8s.io/api/policy/v1"
-	"k8s.io/apimachinery/pkg/types"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 )
@@ -58,10 +57,9 @@ func (r *AutoSSLReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	ctx = log.IntoContext(ctx, logger)
 
 	instance := &saasv1alpha1.AutoSSL{}
-	key := types.NamespacedName{Name: req.Name, Namespace: req.Namespace}
-	result, err := r.GetInstance(ctx, key, instance, nil, nil)
-	if result != nil || err != nil {
-		return *result, err
+	result := r.GetInstance(ctx, req, instance, nil, nil)
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	// Apply defaults for reconcile but do not store them in the API
@@ -88,10 +86,9 @@ func (r *AutoSSLReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	}
 	resources = append(resources, workload...)
 
-	err = r.ReconcileOwnedResources(ctx, instance, resources)
-	if err != nil {
-		logger.Error(err, "unable to update owned resources")
-		return ctrl.Result{}, err
+	result = r.ReconcileOwnedResources(ctx, instance, resources)
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	return ctrl.Result{}, nil

controllers/backend_controller.go

@@ -32,7 +32,6 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	policyv1 "k8s.io/api/policy/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/types"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 	"sigs.k8s.io/controller-runtime/pkg/source"
@@ -64,10 +63,9 @@ func (r *BackendReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	ctx = log.IntoContext(ctx, logger)
 
 	instance := &saasv1alpha1.Backend{}
-	key := types.NamespacedName{Name: req.Name, Namespace: req.Namespace}
-	result, err := r.GetInstance(ctx, key, instance, nil, nil)
-	if result != nil || err != nil {
-		return *result, err
+	result := r.GetInstance(ctx, req, instance, nil, nil)
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	// Apply defaults for reconcile but do not store them in the API
@@ -103,10 +101,9 @@ func (r *BackendReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	resources = append(resources, cron_resources...)
 
 	// Reconcile all resources
-	err = r.ReconcileOwnedResources(ctx, instance, resources)
-	if err != nil {
-		logger.Error(err, "unable to reconcile owned resources")
-		return ctrl.Result{}, err
+	result = r.ReconcileOwnedResources(ctx, instance, resources)
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	return ctrl.Result{}, nil

controllers/corsproxy_controller.go

@@ -32,7 +32,6 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	policyv1 "k8s.io/api/policy/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/types"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 	"sigs.k8s.io/controller-runtime/pkg/source"
@@ -63,10 +62,9 @@ func (r *CORSProxyReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	ctx = log.IntoContext(ctx, logger)
 
 	instance := &saasv1alpha1.CORSProxy{}
-	key := types.NamespacedName{Name: req.Name, Namespace: req.Namespace}
-	result, err := r.GetInstance(ctx, key, instance, nil, nil)
-	if result != nil || err != nil {
-		return *result, err
+	result := r.GetInstance(ctx, req, instance, nil, nil)
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	// Apply defaults for reconcile but do not store them in the API
@@ -89,10 +87,9 @@ func (r *CORSProxyReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	}
 	resources = append(resources, workload...)
 
-	err = r.ReconcileOwnedResources(ctx, instance, resources)
-	if err != nil {
-		logger.Error(err, "unable to reconcile owned resources")
-		return ctrl.Result{}, err
+	result = r.ReconcileOwnedResources(ctx, instance, resources)
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	return ctrl.Result{}, nil

controllers/echoapi_controller.go

@@ -30,7 +30,6 @@ import (
 	autoscalingv2 "k8s.io/api/autoscaling/v2"
 	corev1 "k8s.io/api/core/v1"
 	policyv1 "k8s.io/api/policy/v1"
-	"k8s.io/apimachinery/pkg/types"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 )
@@ -58,10 +57,9 @@ func (r *EchoAPIReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	ctx = log.IntoContext(ctx, logger)
 
 	instance := &saasv1alpha1.EchoAPI{}
-	key := types.NamespacedName{Name: req.Name, Namespace: req.Namespace}
-	result, err := r.GetInstance(ctx, key, instance, nil, nil)
-	if result != nil || err != nil {
-		return *result, err
+	result := r.GetInstance(ctx, req, instance, nil, nil)
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	// Apply defaults for reconcile but do not store them in the API
@@ -78,10 +76,9 @@ func (r *EchoAPIReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 		return ctrl.Result{}, err
 	}
 
-	err = r.ReconcileOwnedResources(ctx, instance, resources)
-	if err != nil {
-		logger.Error(err, "unable to update owned resources")
-		return ctrl.Result{}, err
+	result = r.ReconcileOwnedResources(ctx, instance, resources)
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	return ctrl.Result{}, nil

controllers/mappingservice_controller.go

@@ -32,7 +32,6 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	policyv1 "k8s.io/api/policy/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/types"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 	"sigs.k8s.io/controller-runtime/pkg/source"
@@ -63,10 +62,9 @@ func (r *MappingServiceReconciler) Reconcile(ctx context.Context, req ctrl.Reque
 	ctx = log.IntoContext(ctx, logger)
 
 	instance := &saasv1alpha1.MappingService{}
-	key := types.NamespacedName{Name: req.Name, Namespace: req.Namespace}
-	result, err := r.GetInstance(ctx, key, instance, nil, nil)
-	if result != nil || err != nil {
-		return *result, err
+	result := r.GetInstance(ctx, req, instance, nil, nil)
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	// Apply defaults for reconcile but do not store them in the API
@@ -89,10 +87,9 @@ func (r *MappingServiceReconciler) Reconcile(ctx context.Context, req ctrl.Reque
 	}
 	resources = append(resources, workload...)
 
-	err = r.ReconcileOwnedResources(ctx, instance, resources)
-	if err != nil {
-		logger.Error(err, "unable to reconcile owned resources")
-		return ctrl.Result{}, err
+	result = r.ReconcileOwnedResources(ctx, instance, resources)
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	return ctrl.Result{}, nil

controllers/redisshard_controller.go

@@ -21,7 +21,7 @@ import (
 	"fmt"
 	"time"
 
-	basereconciler "github.com/3scale-ops/basereconciler/reconciler"
+	"github.com/3scale-ops/basereconciler/reconciler"
 	saasv1alpha1 "github.com/3scale/saas-operator/api/v1alpha1"
 	"github.com/3scale/saas-operator/pkg/generators/redisshard"
 	"github.com/3scale/saas-operator/pkg/redis/client"
@@ -38,7 +38,7 @@ import (
 
 // RedisShardReconciler reconciles a RedisShard object
 type RedisShardReconciler struct {
-	basereconciler.Reconciler
+	*reconciler.Reconciler
 	Log  logr.Logger
 	Pool *redis.ServerPool
 }
@@ -57,10 +57,9 @@ func (r *RedisShardReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 	ctx = log.IntoContext(ctx, logger)
 
 	instance := &saasv1alpha1.RedisShard{}
-	key := types.NamespacedName{Name: req.Name, Namespace: req.Namespace}
-	result, err := r.GetInstance(ctx, key, instance, nil, nil)
-	if result != nil || err != nil {
-		return *result, err
+	result := r.GetInstance(ctx, req, instance, nil, nil)
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	// Apply defaults for reconcile but do not store them in the API
@@ -72,19 +71,18 @@ func (r *RedisShardReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 		instance.Spec,
 	)
 
-	if err := r.ReconcileOwnedResources(ctx, instance, gen.Resources()); err != nil {
-		logger.Error(err, "unable to update owned resources")
-		return ctrl.Result{}, err
+	result = r.ReconcileOwnedResources(ctx, instance, gen.Resources())
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
-	shard, result, err := r.setRedisRoles(ctx, types.NamespacedName{Name: req.Name, Namespace: req.Namespace},
+	shard, result := r.setRedisRoles(ctx, types.NamespacedName{Name: req.Name, Namespace: req.Namespace},
 		*instance.Spec.MasterIndex, *instance.Spec.SlaveCount+1, gen.ServiceName(), logger)
-
-	if result != nil || err != nil {
-		return *result, err
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
-	if err = r.updateStatus(ctx, shard, instance, logger); err != nil {
+	if err := r.updateStatus(ctx, shard, instance, logger); err != nil {
 		return ctrl.Result{}, err
 	}
 
@@ -101,7 +99,8 @@ func (r *RedisShardReconciler) SetupWithManager(mgr ctrl.Manager) error {
 		Complete(r)
 }
 
-func (r *RedisShardReconciler) setRedisRoles(ctx context.Context, key types.NamespacedName, masterIndex, replicas int32, serviceName string, log logr.Logger) (*sharded.Shard, *ctrl.Result, error) {
+func (r *RedisShardReconciler) setRedisRoles(ctx context.Context, key types.NamespacedName,
+	masterIndex, replicas int32, serviceName string, log logr.Logger) (*sharded.Shard, reconciler.Result) {
 
 	var masterHostPort string
 	redisURLs := make(map[string]string, replicas)
@@ -110,11 +109,12 @@ func (r *RedisShardReconciler) setRedisRoles(ctx context.Context, key types.Name
 		key := types.NamespacedName{Name: fmt.Sprintf("%s-%d", serviceName, i), Namespace: key.Namespace}
 		err := r.Client.Get(ctx, key, pod)
 		if err != nil {
-			return &sharded.Shard{Name: key.Name}, &ctrl.Result{}, err
+			return &sharded.Shard{Name: key.Name}, reconciler.Result{Error: err}
 		}
 		if pod.Status.PodIP == "" {
 			log.Info("waiting for pod IP to be allocated")
-			return &sharded.Shard{Name: key.Name}, &ctrl.Result{RequeueAfter: 5 * time.Second}, nil
+			// return &sharded.Shard{Name: key.Name}, &ctrl.Result{RequeueAfter: 5 * time.Second}, nil
+			return &sharded.Shard{Name: key.Name}, reconciler.Result{Requeue: true, RequeueAfter: 5 * time.Second}
 		}
 
 		redisURLs[fmt.Sprintf("%s-%d", serviceName, i)] = fmt.Sprintf("redis://%s:%d", pod.Status.PodIP, 6379)
@@ -125,16 +125,16 @@ func (r *RedisShardReconciler) setRedisRoles(ctx context.Context, key types.Name
 
 	shard, err := sharded.NewShardFromTopology(key.Name, redisURLs, r.Pool)
 	if err != nil {
-		return shard, &ctrl.Result{}, err
+		return shard, reconciler.Result{Error: err}
 	}
 
 	_, err = shard.Init(ctx, masterHostPort)
 	if err != nil {
 		log.Info("waiting for redis shard init")
-		return shard, &ctrl.Result{Requeue: true, RequeueAfter: 10 * time.Second}, nil
+		return shard, reconciler.Result{Requeue: true, RequeueAfter: 10 * time.Second}
 	}
 
-	return shard, nil, nil
+	return shard, reconciler.Result{}
 }
 
 func (r *RedisShardReconciler) updateStatus(ctx context.Context, shard *sharded.Shard, instance *saasv1alpha1.RedisShard, log logr.Logger) error {

controllers/sentinel_controller.go

@@ -21,7 +21,7 @@ import (
 	"errors"
 	"time"
 
-	basereconciler "github.com/3scale-ops/basereconciler/reconciler"
+	"github.com/3scale-ops/basereconciler/reconciler"
 	saasv1alpha1 "github.com/3scale/saas-operator/api/v1alpha1"
 	"github.com/3scale/saas-operator/pkg/generators/sentinel"
 	"github.com/3scale/saas-operator/pkg/reconcilers/threads"
@@ -36,7 +36,6 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	policyv1 "k8s.io/api/policy/v1"
 	"k8s.io/apimachinery/pkg/api/equality"
-	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/util/workqueue"
 	"k8s.io/utils/pointer"
 	ctrl "sigs.k8s.io/controller-runtime"
@@ -49,7 +48,7 @@ import (
 
 // SentinelReconciler reconciles a Sentinel object
 type SentinelReconciler struct {
-	basereconciler.Reconciler
+	*reconciler.Reconciler
 	Log            logr.Logger
 	SentinelEvents threads.Manager
 	Metrics        threads.Manager
@@ -72,14 +71,13 @@ func (r *SentinelReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 	ctx = log.IntoContext(ctx, logger)
 
 	instance := &saasv1alpha1.Sentinel{}
-	key := types.NamespacedName{Name: req.Name, Namespace: req.Namespace}
-	result, err := r.GetInstance(ctx,
-		key,
-		instance,
+	result := r.GetInstance(ctx, req, instance,
 		pointer.String(saasv1alpha1.Finalizer),
-		[]func(){r.SentinelEvents.CleanupThreads(instance), r.Metrics.CleanupThreads(instance)})
-	if result != nil || err != nil {
-		return *result, err
+		r.SentinelEvents.CleanupThreads(instance),
+		r.Metrics.CleanupThreads(instance),
+	)
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	// Apply defaults for reconcile but do not store them in the API
@@ -91,9 +89,9 @@ func (r *SentinelReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 		instance.Spec,
 	)
 
-	if err := r.ReconcileOwnedResources(ctx, instance, gen.Resources()); err != nil {
-		logger.Error(err, "unable to update owned resources")
-		return ctrl.Result{}, err
+	result = r.ReconcileOwnedResources(ctx, instance, gen.Resources())
+	if result.IsReturnAndRequeue() {
+		return result.Values()
 	}
 
 	clustermap, err := gen.ClusterTopology(ctx)