chore!: add arg to retry.ExponentialBackoff option

Author: ezdac

rolling-shutter/collator/epochhandling.go

@@ -140,7 +140,7 @@ func (c *collator) sendDecryptionTriggers(ctx context.Context) error {
 		err := c.p2p.SendMessage(ctx,
 			msg,
 			retry.Interval(time.Second),
-			retry.ExponentialBackoff(),
+			retry.ExponentialBackoff(nil),
 			retry.NumberOfRetries(3),
 			retry.LogIdentifier(msg.LogInfo()),
 		)

rolling-shutter/medley/retry/options.go

@@ -1,6 +1,7 @@
 package retry
 
 import (
+	"errors"
 	"time"
 
 	"github.com/benbjohnson/clock"
@@ -13,51 +14,64 @@ import (
 // `-1` is a special value that results in
 // infinite retries.
 func NumberOfRetries(n int) Option {
-	return func(r *retrier) {
+	return func(r *retrier) error {
 		r.numRetries = n
 		if n == -1 {
 			r.infiniteRetries = true
 		}
+		return nil
 	}
 }
 
 func MaxInterval(t time.Duration) Option {
-	return func(r *retrier) {
+	return func(r *retrier) error {
 		r.maxInterval = t
+		return nil
 	}
 }
 
 func Interval(t time.Duration) Option {
-	return func(r *retrier) {
+	return func(r *retrier) error {
 		r.interval = t
+		return nil
 	}
 }
 
 func StopOnErrors(e ...error) Option {
-	return func(r *retrier) {
+	return func(r *retrier) error {
 		r.cancelingErrors = e
+		return nil
 	}
 }
 
-func ExponentialBackoff() Option {
-	return func(r *retrier) {
-		// for now just use a fixed value
-		r.multiplier = 1.5
+func ExponentialBackoff(multiplier *float64) Option {
+	return func(r *retrier) error {
+		if multiplier == nil {
+			r.multiplier = 1.5
+			return nil
+		}
+		r.multiplier = *multiplier
+		if r.multiplier <= 1.0 {
+			return errors.New("can't use value <=1.0 as exponential multiplier")
+		}
+		return nil
 	}
 }
 
 func LogIdentifier(s string) Option {
 	id := uuid.NewString()
-	return func(r *retrier) {
+	return func(r *retrier) error {
 		r.zlogContext = r.zlogContext.Str("id", id+":"+s)
+		return nil
 	}
 }
 
 // UseClock injects a different `clock.Clock`
 // implementation than the default `time`
 // wrapper. Mainly used for mocking.
 func UseClock(c clock.Clock) Option {
-	return func(r *retrier) {
+	return func(r *retrier) error {
 		r.clock = c
+		return nil
 	}
 }

rolling-shutter/medley/retry/retry.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/benbjohnson/clock"
+	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 
@@ -38,10 +39,14 @@ func newRetrier() *retrier {
 	}
 }
 
-func (r *retrier) option(opts []Option) {
+func (r *retrier) applyOptions(opts []Option) error {
 	for _, opt := range opts {
-		opt(r)
+		err := opt(r)
+		if err != nil {
+			return err
+		}
 	}
+	return nil
 }
 
 func (r *retrier) iterator(next <-chan time.Time) <-chan time.Time {
@@ -74,15 +79,20 @@ func (r *retrier) iterator(next <-chan time.Time) <-chan time.Time {
 }
 
 type (
-	Option                   func(*retrier)
+	Option                   func(*retrier) error
 	RetriableFunction[T any] func(ctx context.Context) (T, error)
 )
 
 // FunctionCall calls the given function multiple times until it doesn't return an error
 // or one of any optional, user-defined specific errors is returned.
 func FunctionCall[T any](ctx context.Context, fn RetriableFunction[T], opts ...Option) (T, error) {
+	var err error
+	var null T
+
 	retrier := newRetrier()
-	retrier.option(opts)
+	if err := retrier.applyOptions(opts); err != nil {
+		return null, errors.Wrap(err, "apply options")
+	}
 	funcName := introspection.GetFuncName(4)
 	retrier.zlogContext = retrier.zlogContext.Str("funcName", funcName)
 	logger := retrier.zlogContext.Logger()
@@ -91,9 +101,6 @@ func FunctionCall[T any](ctx context.Context, fn RetriableFunction[T], opts ...O
 
 	retry := retrier.iterator(next)
 
-	var err error
-	var null T
-
 	callCount := 0
 
 	for {

rolling-shutter/medley/retry/retry_test.go

@@ -63,7 +63,7 @@ var testFlagTable = []testFlags{
 		[]Option{
 			Interval(baseInterval),
 			NumberOfRetries(5),
-			ExponentialBackoff(),
+			ExponentialBackoff(nil),
 		},
 		errDefault,
 		[]time.Duration{
@@ -83,7 +83,7 @@ var testFlagTable = []testFlags{
 			MaxInterval(
 				multDuration(baseInterval, math.Pow(1.5, 2)),
 			),
-			ExponentialBackoff(),
+			ExponentialBackoff(nil),
 		},
 		errDefault,
 		[]time.Duration{

rolling-shutter/p2p/bootstrap.go

@@ -82,12 +82,14 @@ func bootstrap(
 		// A bootstrap node is not required to connect to other bootstrap nodes.
 		// If however we did configure a list of bootstrap nodes,
 		// we should try a long time to connect to at least one other bootstrapper first.
+		backoffMult := float64(1.01)
 		_, err := retry.FunctionCall(
 			ctx,
 			f,
-			retry.MaxInterval(5*time.Hour),
+			retry.MaxInterval(1*time.Minute),
 			retry.StopOnErrors(errInsufficientBootstrpConfigured),
-			retry.Interval(2*time.Minute))
+			retry.Interval(2*time.Second),
+			retry.ExponentialBackoff(&backoffMult))
 		if err != nil {
 			log.Error().Err(err).
 				Msg("failed to bootstrap, continuing without peer connections.")
@@ -96,9 +98,8 @@ func bootstrap(
 		_, err := retry.FunctionCall(
 			ctx,
 			f,
-			retry.MaxInterval(5*time.Minute),
 			retry.StopOnErrors(errInsufficientBootstrpConfigured),
-			retry.Interval(30*time.Second))
+			retry.Interval(2*time.Second))
 		if err != nil {
 			// For normal peers, after trying some time it is reasonable to halt.
 			// If we don't get an initial connection to a bootsrap node,