feat: add retry mechanism

Author: morilog

README.md

@@ -0,0 +1,105 @@
+# Retry
+Retry is a golang pure package implements the `retry-pattern` to retry failures until certain attempts in certain time.
+
+## Installation
+At first you need to download the library using `go get`
+```bash
+$ go get -u github.com/morilog/go-retry
+```
+
+Or just use it on your package by importing this:
+```golang
+import "github.com/morilog/retry"
+```
+And download it with `go mod`
+```bash
+$ go mod tidy
+```
+
+## Quick Start
+Assume you have a function that calls an external api:
+
+```golang
+func getSomeExternalData(url string) error {
+    // your business logic goes here
+}
+```
+It might be failed during network errors or any other external errors. With `retry` you can retry your logic until maximum number of attempts exceeded.
+```golang
+package main
+
+import "github.com/morilog/retry"
+
+func main() {
+    ctx := context.Background()
+
+    // As default
+    // It retries 10 times with increased 100ms delay
+    err := retry.Retry(ctx, func() error {
+        return getSomeExternalData("https://example.com")
+    }, retry.Delay(time.Second))
+
+    if err != nil {
+        log.Fatal(err)
+    }
+}
+```
+
+## Options
+### retry.Delay(delay time.Duration)
+To set minimum delay duration between each retry.
+> Default: 100ms
+### retry.DelayFactor(factor int)
+To set number that multiplies to delay to increase delay time by increasing attempts.
+The delay for each retry calculated by this formula:
+```
+    AttemptDelay = Attempt * DelayFactor * Delay
+```
+> Default: 1
+### retry.MaxAttempts(attempts uint8)
+Sets maximum number of attempts to handle the operation
+
+> Default: 10
+### retry.StopRetryIf(fn StopRetryIfFunc)
+Sometimes you need to cancel the retry mechanism when your operation returns some specific error. To achieve to this purpose, You can use this option.
+> Default: `<not set>`
+
+For example i stop the retry when an `SomeError` occurred:
+```golang
+err := retry.Retry(ctx, func() error {
+    return getSomeExternalData("https://example.com")
+},
+    retry.Delay(time.Second),
+    retry.StopRetryIf(func(ctx context.Context, err error) bool {
+        if _, ok := err.(*SomeError); ok {
+            return true
+        }
+
+        return false
+    }),
+)
+
+if err != nil {
+    log.Fatal(err)
+}
+```
+### retry.OnRetry(fn OnRetryFunc)
+Sometimes you need to know retry is on which attempt to do something like logging
+> Default: `<not set>`
+
+For example:
+```golang
+err := retry.Retry(ctx, func() error {
+    return getSomeExternalData("https://example.com")
+},
+    retry.Delay(time.Second),
+    retry.StopRetryIf(func(ctx context.Context, attempt int) error {
+        logrus.Printf("The function retries for %d times.\n", attempt)
+        return nil
+    }),
+)
+
+if err != nil {
+    log.Fatal(err)
+}
+```

go.mod

@@ -0,0 +1,3 @@
+module github.com/morilog/retry
+
+go 1.18

retry.go

@@ -0,0 +1,119 @@
+package retry
+
+import (
+	"context"
+	"time"
+)
+
+// Default Delay func options
+const (
+	DefaultAttempts    uint8 = 10
+	DefaultDelay             = time.Millisecond * 100
+	DefaultDelayFactor       = 1
+)
+
+type config struct {
+	maxAttempts uint8
+	delay       time.Duration
+	delayFactor int
+	stopRetryIf StopRetryIfFunc
+	onRetry     OnRetryFunc
+}
+
+// Option is a function type for
+// manipulating Retry configs
+type Option func(*config)
+
+// MaxAttempts is an option to set maximum attempts number
+// It could be a integer number between 0-255
+// Default is 10
+func MaxAttempts(attempts uint8) Option {
+	return func(c *config) {
+		c.maxAttempts = attempts
+	}
+}
+
+// Delay is an option to set minimum delay between each retries
+// Default is 100ms
+func Delay(delay time.Duration) Option {
+	return func(c *config) {
+		c.delay = delay
+	}
+}
+
+// DelayFactor is an option to set increase of delay
+// duration on each retries
+// Actual delay calculated by: (delay * delayFactor * attemptNumber)
+// Default is 1
+func DelayFactor(factor int) Option {
+	return func(c *config) {
+		c.delayFactor = factor
+	}
+}
+
+// StopRetryIfFunc is a function type to set conditions
+// To stop continuing the retry mechanism
+type StopRetryIfFunc func(ctx context.Context, err error) bool
+
+// StopRetryIf is an option to set StopRetryIfFunc
+func StopRetryIf(fn StopRetryIfFunc) Option {
+	return func(c *config) {
+		c.stopRetryIf = fn
+	}
+}
+
+// OnRetryFunc is a function type to set some
+// functionality to retry function
+// It stops retry mechanism when error was not nil
+type OnRetryFunc func(ctx context.Context, attempt int) error
+
+// OnRetry is an option to set OnRetryFunc
+func OnRetry(fn OnRetryFunc) Option {
+	return func(c *config) {
+		c.onRetry = fn
+	}
+}
+
+// Retry tries to handle the operation func
+// It tries until maxAttempts exceeded
+// At the end of retries returns error from operation func
+func Retry(ctx context.Context, operation func() error, opts ...Option) error {
+	cfg := &config{
+		maxAttempts: DefaultAttempts,
+		delay:       DefaultDelay,
+		delayFactor: DefaultDelayFactor,
+	}
+
+	for _, opt := range opts {
+		opt(cfg)
+	}
+
+	var err error
+	for attempt := 0; attempt < int(cfg.maxAttempts); attempt++ {
+		err = operation()
+		if err == nil {
+			return nil
+		}
+
+		if cfg.stopRetryIf != nil {
+			if cfg.stopRetryIf(ctx, err) {
+				break
+			}
+		}
+
+		if cfg.onRetry != nil {
+			if err := cfg.onRetry(ctx, attempt+1); err != nil {
+				return err
+			}
+		}
+
+		select {
+		case <-ctx.Done():
+			return err
+		case <-time.After(cfg.delay * time.Duration(attempt*cfg.delayFactor)):
+			continue
+		}
+	}
+
+	return err
+}