feat: retryWithData and without, generic pointer for return type, infinite retries

Author: MarcosNicolau

core/connection.go

@@ -19,18 +19,49 @@ func (e PermanentError) Is(err error) bool {
 	return ok
 }
 
+// Same as Retry only that the functionToRetry can return a value upon correct execution
+func RetryWithData[T any](functionToRetry func() (*T, error), minDelay uint64, factor float64, maxTries uint64) (*T, error) {
+	i := 0
+	f := func() (*T, error) {
+		val, err := functionToRetry()
+		i++
+		if perm, ok := err.(PermanentError); err != nil && ok {
+			return nil, backoff.Permanent(perm.Inner)
+		}
+		return val, err
+	}
+
+	randomOption := backoff.WithRandomizationFactor(0)
+
+	initialRetryOption := backoff.WithInitialInterval(time.Millisecond * time.Duration(minDelay))
+	multiplierOption := backoff.WithMultiplier(factor)
+	expBackoff := backoff.NewExponentialBackOff(randomOption, multiplierOption, initialRetryOption)
+	var maxRetriesBackoff backoff.BackOff
+
+	if maxTries > 0 {
+		maxRetriesBackoff = backoff.WithMaxRetries(expBackoff, maxTries)
+	} else {
+		maxRetriesBackoff = expBackoff
+	}
+
+	return backoff.RetryWithData(f, maxRetriesBackoff)
+}
+
 // Retries a given function in an exponential backoff manner.
-// It will retry calling the function while it returns an error, until the max retries
+// It will retry calling the function while it returns an error, until the max retries.
+// If maxTries == 0 then the retry function will run indefinitely until success
 // from the configuration are reached, or until a `PermanentError` is returned.
 // The function to be retried should return `PermanentError` when the condition for stop retrying
 // is met.
-func Retry(functionToRetry func() (interface{}, error), minDelay uint64, factor float64, maxTries uint64) (interface{}, error) {
-	f := func() (interface{}, error) {
-		val, err := functionToRetry()
+func Retry(functionToRetry func() error, minDelay uint64, factor float64, maxTries uint64) error {
+	i := 0
+	f := func() error {
+		err := functionToRetry()
+		i++
 		if perm, ok := err.(PermanentError); err != nil && ok {
-			return nil, backoff.Permanent(perm.Inner)
+			return backoff.Permanent(perm.Inner)
 		}
-		return val, err
+		return err
 	}
 
 	randomOption := backoff.WithRandomizationFactor(0)
@@ -40,5 +71,5 @@ func Retry(functionToRetry func() (interface{}, error), minDelay uint64, factor
 	expBackoff := backoff.NewExponentialBackOff(randomOption, multiplierOption, initialRetryOption)
 	maxRetriesBackoff := backoff.WithMaxRetries(expBackoff, maxTries)
 
-	return backoff.RetryWithData(f, maxRetriesBackoff)
+	return backoff.Retry(f, maxRetriesBackoff)
 }

core/connection_test.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/yetanotherco/aligned_layer/core"
+	connection "github.com/yetanotherco/aligned_layer/core"
 )
 
 func DummyFunction(x uint64) (uint64, error) {
@@ -17,12 +17,26 @@ func DummyFunction(x uint64) (uint64, error) {
 	return x, nil
 }
 
-func TestRetry(t *testing.T) {
-	function := func() (interface{}, error) { return DummyFunction(43) }
-	data, err := connection.Retry(function, 1000, 2, 3)
+func TestRetryWithData(t *testing.T) {
+	function := func() (*uint64, error) {
+		x, err := DummyFunction(43)
+		return &x, err
+	}
+	data, err := connection.RetryWithData(function, 1000, 2, 3)
 	if err != nil {
 		t.Errorf("Retry error!: %s", err)
 	} else {
 		fmt.Printf("DATA: %d\n", data)
 	}
 }
+
+func TestRetry(t *testing.T) {
+	function := func() error {
+		_, err := DummyFunction(43)
+		return err
+	}
+	err := connection.Retry(function, 1000, 2, 3)
+	if err != nil {
+		t.Errorf("Retry error!: %s", err)
+	}
+}