add retriable errors

There is a new error type (types.RetriableError) which can be used anywhere in the reconciler logic
(in particular in hooks and generators) to wrap other occuring errors; optionally a retry delay can be
set on that error object; such errors will then be caught late in the reconciler flow, immediately before
returning to controller-runtime. Basically, no error (but nil) will be returned to controller-runtime,
and a RequeueAfter with the desired delay will be set instead in the response. This bypasses the
(sometimes unwanted) default backoff done by controller-runtime, and leads to a li:wqnear retry behaviour.
In addition, components can implement two new interfaces component.RequeueConfiguration and
component.RetryConfiguration, in order to override the default requeue interval (10m) and the default
retry interval, which applies to retriable errors which do not specify a delay (default is the value
of requeue interval).

Author: cbarbian-sap

pkg/component/component.go

@@ -65,6 +65,28 @@ func assertImpersonationConfiguration[T Component](component T) (ImpersonationCo
 	return nil, false
 }
 
+// Check if given component or its spec implements RequeueConfiguration (and return it).
+func assertRequeueConfiguration[T Component](component T) (RequeueConfiguration, bool) {
+	if requeueConfiguration, ok := Component(component).(RequeueConfiguration); ok {
+		return requeueConfiguration, true
+	}
+	if requeueConfiguration, ok := getSpec(component).(RequeueConfiguration); ok {
+		return requeueConfiguration, true
+	}
+	return nil, false
+}
+
+// Check if given component or its spec implements RetryConfiguration (and return it).
+func assertRetryConfiguration[T Component](component T) (RetryConfiguration, bool) {
+	if retryConfiguration, ok := Component(component).(RetryConfiguration); ok {
+		return retryConfiguration, true
+	}
+	if retryConfiguration, ok := getSpec(component).(RetryConfiguration); ok {
+		return retryConfiguration, true
+	}
+	return nil, false
+}
+
 // Implement the PlacementConfiguration interface.
 func (s *PlacementSpec) GetDeploymentNamespace() string {
 	return s.Namespace

pkg/component/reconcile.go

@@ -133,6 +133,22 @@ func (r *Reconciler[T]) Reconcile(ctx context.Context, req ctrl.Request) (result
 	status := component.GetStatus()
 	savedStatus := status.DeepCopy()
 
+	// requeue/retry interval
+	requeueInterval := time.Duration(0)
+	if requeueConfiguration, ok := assertRequeueConfiguration(component); ok {
+		requeueInterval = requeueConfiguration.GetRequeueInterval()
+	}
+	if requeueInterval == 0 {
+		requeueInterval = 10 * time.Minute
+	}
+	retryInterval := time.Duration(0)
+	if retryConfiguration, ok := assertRetryConfiguration(component); ok {
+		retryInterval = retryConfiguration.GetRetryInterval()
+	}
+	if retryInterval == 0 {
+		retryInterval = requeueInterval
+	}
+
 	// always attempt to update the status
 	skipStatusUpdate := false
 	defer func() {
@@ -150,6 +166,15 @@ func (r *Reconciler[T]) Reconcile(ctx context.Context, req ctrl.Request) (result
 		} else {
 			r.client.EventRecorder().Event(component, corev1.EventTypeNormal, reason, message)
 		}
+		retriableError := &types.RetriableError{}
+		if errors.As(err, retriableError) {
+			retryAfter := retriableError.RetryAfter()
+			if retryAfter == nil || *retryAfter == 0 {
+				retryAfter = &retryInterval
+			}
+			result = ctrl.Result{RequeueAfter: *retryAfter}
+			err = nil
+		}
 		if skipStatusUpdate {
 			return
 		}
@@ -219,7 +244,7 @@ func (r *Reconciler[T]) Reconcile(ctx context.Context, req ctrl.Request) (result
 			status.SetState(StateReady, readyConditionReasonReady, "Dependent resources successfully reconciled")
 			status.AppliedGeneration = component.GetGeneration()
 			status.LastAppliedAt = &now
-			return ctrl.Result{RequeueAfter: 10 * time.Minute}, nil
+			return ctrl.Result{RequeueAfter: requeueInterval}, nil
 		} else {
 			log.V(1).Info("not all dependent resources successfully reconciled")
 			status.SetState(StateProcessing, readyConditionReasonProcessing, "Reconcilation of dependent resources triggered; waiting until all dependent resources are ready")

pkg/component/reference.go

@@ -16,6 +16,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	"github.com/sap/component-operator-runtime/internal/walk"
+	"github.com/sap/component-operator-runtime/pkg/types"
 )
 
 // +kubebuilder:object:generate=true
@@ -30,7 +31,7 @@ type ConfigMapReference struct {
 func (r *ConfigMapReference) load(ctx context.Context, client client.Client, namespace string) error {
 	configMap := &corev1.ConfigMap{}
 	if err := client.Get(ctx, apitypes.NamespacedName{Namespace: namespace, Name: r.Name}, configMap); err != nil {
-		return err
+		return types.NewRetriableError(err, nil)
 	}
 	r.data = configMap.Data
 	return nil
@@ -55,14 +56,14 @@ type ConfigMapKeyReference struct {
 func (r *ConfigMapKeyReference) load(ctx context.Context, client client.Client, namespace string, fallbackKeys ...string) error {
 	configMap := &corev1.ConfigMap{}
 	if err := client.Get(ctx, apitypes.NamespacedName{Namespace: namespace, Name: r.Name}, configMap); err != nil {
-		return err
+		return types.NewRetriableError(err, nil)
 	}
 	if r.Key != "" {
 		if value, ok := configMap.Data[r.Key]; ok {
 			r.value = value
 			return nil
 		} else {
-			return fmt.Errorf("key %s not found in configmap %s/%s", r.Key, namespace, r.Name)
+			return types.NewRetriableError(fmt.Errorf("key %s not found in configmap %s/%s", r.Key, namespace, r.Name), nil)
 		}
 	} else {
 		for _, key := range fallbackKeys {
@@ -71,7 +72,7 @@ func (r *ConfigMapKeyReference) load(ctx context.Context, client client.Client,
 				return nil
 			}
 		}
-		return fmt.Errorf("no matching key found in configmap %s/%s", namespace, r.Name)
+		return types.NewRetriableError(fmt.Errorf("no matching key found in configmap %s/%s", namespace, r.Name), nil)
 	}
 }
 
@@ -92,7 +93,7 @@ type SecretReference struct {
 func (r *SecretReference) load(ctx context.Context, client client.Client, namespace string) error {
 	secret := &corev1.Secret{}
 	if err := client.Get(ctx, apitypes.NamespacedName{Namespace: namespace, Name: r.Name}, secret); err != nil {
-		return err
+		return types.NewRetriableError(err, nil)
 	}
 	r.data = secret.Data
 	return nil
@@ -117,14 +118,14 @@ type SecretKeyReference struct {
 func (r *SecretKeyReference) load(ctx context.Context, client client.Client, namespace string, fallbackKeys ...string) error {
 	secret := &corev1.Secret{}
 	if err := client.Get(ctx, apitypes.NamespacedName{Namespace: namespace, Name: r.Name}, secret); err != nil {
-		return err
+		return types.NewRetriableError(err, nil)
 	}
 	if r.Key != "" {
 		if value, ok := secret.Data[r.Key]; ok {
 			r.value = value
 			return nil
 		} else {
-			return fmt.Errorf("key %s not found in secret %s/%s", r.Key, namespace, r.Name)
+			return types.NewRetriableError(fmt.Errorf("key %s not found in secret %s/%s", r.Key, namespace, r.Name), nil)
 		}
 	} else {
 		for _, key := range fallbackKeys {
@@ -133,7 +134,7 @@ func (r *SecretKeyReference) load(ctx context.Context, client client.Client, nam
 				return nil
 			}
 		}
-		return fmt.Errorf("no matching key found in secret %s/%s", namespace, r.Name)
+		return types.NewRetriableError(fmt.Errorf("no matching key found in secret %s/%s", namespace, r.Name), nil)
 	}
 }
 

pkg/component/types.go

@@ -6,6 +6,8 @@ SPDX-License-Identifier: Apache-2.0
 package component
 
 import (
+	"time"
+
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
@@ -58,6 +60,20 @@ type ImpersonationConfiguration interface {
 	GetImpersonationGroups() []string
 }
 
+// The RequeueConfiguration interface is meant to be implemented by components (or their spec) which offer
+// tweaking the requeue interval (by default, it would be 10 minutes).
+type RequeueConfiguration interface {
+	// Get requeue interval. Should be greater than 1 minute.
+	GetRequeueInterval() time.Duration
+}
+
+// The RetryConfiguration interface is meant to be implemented by components (or their spec) which offer
+// tweaking the retry interval (by default, it would be the value of the requeue interval).
+type RetryConfiguration interface {
+	// Get retry interval. Should be greater than 1 minute.
+	GetRetryInterval() time.Duration
+}
+
 // +kubebuilder:object:generate=true
 
 // Legacy placement spec. Components may include this into their spec.

pkg/types/errors.go

@@ -0,0 +1,33 @@
+/*
+SPDX-FileCopyrightText: 2023 SAP SE or an SAP affiliate company and component-operator-runtime contributors
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package types
+
+import "time"
+
+type RetriableError struct {
+	err        error
+	retryAfter *time.Duration
+}
+
+func NewRetriableError(err error, retryAfter *time.Duration) RetriableError {
+	return RetriableError{err: err, retryAfter: retryAfter}
+}
+
+func (e RetriableError) Error() string {
+	return e.err.Error()
+}
+
+func (e RetriableError) Unwrap() error {
+	return e.err
+}
+
+func (e RetriableError) Cause() error {
+	return e.err
+}
+
+func (e RetriableError) RetryAfter() *time.Duration {
+	return e.retryAfter
+}