Add configuration for custom bundle resolver backoff

A bundle resolver is susceptible to flakes in network communication. In
order to increase reliability, we can add backoff retries to mitigate
transient issues.

While it may be possible to add a generic retry functionality around
resolvers, implementation will likely be simpler if the retry
functionality is isolated to the individual resolvers. Future work is
needed to add retries to git resolver requests.

Partially addresses #8571

Signed-off-by: arewm <[email protected]>

Author: arewm

pkg/resolution/resolver/bundle/bundle.go

@@ -142,8 +142,10 @@ func retrieveImage(ctx context.Context, keychain authn.Keychain, ref string) (st
 	if err != nil {
 		return "", nil, fmt.Errorf("%s is an unparseable image reference: %w", ref, err)
 	}
+	customRetryBackoff := remote.Backoff{GetBundleResolverBackoff(ctx)}
 
-	img, err := remote.Image(imgRef, remote.WithAuthFromKeychain(keychain), remote.WithContext(ctx))
+	img, err := remote.Image(imgRef, remote.WithAuthFromKeychain(keychain), remote.WithContext(ctx),
+		remote.WithRetryBackoff(customRetryBackoff))
 	return imgRef.Context().Name(), img, err
 }
 

pkg/resolution/resolver/bundle/config.go

@@ -20,7 +20,80 @@ const (
 	// ConfigKind is the configuration field name for controlling
 	// what the layer name in the bundle image is.
 	ConfigKind = "default-kind"
-	// DefaultTimeoutKey is the configuration field name for controlling
+	// ConfigTimeoutKey is the configuration field name for controlling
 	// the maximum duration of a resolution request for a file from registry.
 	ConfigTimeoutKey = "fetch-timeout"
+	// ConfigBackoffDuration is the configuration field name for controlling
+	// the initial duration of a backoff when a bundle resolution fails
+	ConfigBackoffDuration = "backoff-duration"
+	DefaultBackoffDuration = 1.0 * time.Second
+	// ConfigBackoffFactor is the configuration field name for controlling
+	// the factor by which successive backoffs will increase when a bundle
+	// resolution fails
+	ConfigBackoffFactor = "backoff-factor"
+	DefaultBackoffFactor = 3.0
+	// ConfigBackoffJitter is the configuration field name for controlling
+	// the randomness applied to backoff durations when a bundle resolution fails
+	ConfigBackoffJitter = "backoff-jitter"
+	DefaultBackoffJitter = 0.1
+	// ConfigBackoffSteps is the configuration field name for controlling
+	// the number of attempted backoffs to retry when a bundle resolution fails
+	ConfigBackoffSteps = "backoff-steps"
+	DefaultBackoffSteps = 3
 )
+
+type BundleResolverBackoffConfig struct {
+	Duration: time.Duration
+	Factor:	  float64
+	Jitter:   float64
+	Steps:	  int
+
+}
+
+func  {
+	conf := framework.GetResolverConfigFromContext(ctx)
+}
+
+// GetResolutionTimeout returns a time.Duration for the amount of time a
+// single bundle fetch may take. This can be configured with the
+// fetch-timeout field in the bundle-resolver-config ConfigMap.
+func GetBundleResolverBackoff(ctx context.Context) (BundleResolverBackoffConfig, error) {
+	conf := framework.GetResolverConfigFromContext(ctx)
+
+	customRetryBackoff := BundleResolverBackoffConfig{
+		Duration: DefaultBackoffDuration,
+		Factor:   DefaultBackoffFactor,
+		Jitter:   DefaultBackoffJitter,
+		Steps:    DefaultBackoffSteps,
+	}
+	if v, ok := conf[ConfigBackoffDuration]; ok {
+		var err error
+		duration, err = time.ParseDuration(v)
+		if err != nil {
+			return customRetryBackoff, fmt.Errorf("error parsing backoff duration value %s: %w", v, err)
+		}
+	}
+	if v, ok := conf[ConfigBackoffFactor]; ok {
+		var err error
+		factor, err = strconv.ParseFloat(string(v, 64)
+		if err != nil {
+			return customRetryBackoff, fmt.Errorf("error parsing backoff factor value %s: %w", v, err)
+		}
+	}
+	if v, ok := conf[ConfigBackoffJitter]; ok {
+		var err error
+		factor, err = strconv.ParseFloat(string(v, 64)
+		if err != nil {
+			return customRetryBackoff, fmt.Errorf("error parsing backoff jitter value %s: %w", v, err)
+		}
+	}
+	if v, ok := conf[ConfigBackoffSteps]; ok {
+		var err error
+		factor, err = strconv.ParseInt(string(v)
+		if err != nil {
+			return customRetryBackoff, fmt.Errorf("error parsing backoff steps value %s: %w", v, err)
+		}
+	}
+
+	return customRetryBackoff, nil
+}