gitee.com/sy_183/go-common@v1.0.5-0.20231205030221-958cfe129b47/lifecycle.v2/retry/retry.go

package retry

import (
	"errors"
	"gitee.com/sy_183/go-common/timer"
	"math"
	"time"
)

var ErrInterrupted = errors.New("retry interrupted")

type RetryContext struct {
	Do func() error

	Interval time.Duration

	Delay func(ctx *RetryContext) time.Duration

	Interrupter chan struct{}

	MaxRetry int

	Retrievable func(ctx *RetryContext) bool

	Ignorable func(ctx *RetryContext) bool

	Error error

	Retry int
}

type Retry RetryContext

func MakeRetry(retry Retry) *RetryContext {
	c := new(RetryContext)
	*c = RetryContext(retry)
	return c
}

func (c *RetryContext) do(retryTimer *timer.Timer) bool {
	maxRetry := c.MaxRetry
	if maxRetry < 0 {
		maxRetry = math.MaxInt
	}
	// do func
	if c.Error = c.Do(); c.Error != nil {
		// check error ignorable
		if ignorable := c.Ignorable; ignorable != nil {
			if ignorable(c) {
				c.Error = nil
				return false
			}
		}
		if c.Error == ErrInterrupted {
			return false
		}

		// check retrievable
		if c.Retry >= maxRetry {
			return false
		}
		if retrievable := c.Retrievable; retrievable != nil {
			if !retrievable(c) {
				return false
			}
		}
		c.Retry++

		// get retry delay
		delay := c.Interval
		if c.Delay != nil {
			delay = c.Delay(c)
		}
		if delay <= 0 {
			delay = time.Second
		}

		retryTimer.After(delay)
		return true
	}
	return false
}

func (c *RetryContext) Todo() error {
	retryTimer := timer.NewTimer(make(chan struct{}))
	defer retryTimer.Stop()

	if retry := c.do(retryTimer); c.Error == nil {
		return nil
	} else if !retry {
		return c.Error
	}

	for {
		select {
		case <-retryTimer.C:
			if retry := c.do(retryTimer); c.Error == nil {
				return nil
			} else if !retry {
				return c.Error
			}
		case <-c.Interrupter:
			return ErrInterrupted
		}
	}
}