backoff/fibonacci/fibonacci.go

package fibonacci

import (
	"backoff/utilities"
	"context"
	"fmt"
	"time"
)

var (
	DefaultMultiplier = time.Nanosecond
)

type FibonacciBackoff struct {
	Iteration       int64
	MaxIteration    int64 // allows a lower limit than the default len(TheFibonacciSequence)
	PauseMultiplier time.Duration
	Jitter          time.Duration
	MaxPause        time.Duration
	foundMax        int64 // stores the last successful Iteration. factors in MaxPause and MaxIteration.
}

// resets Iteration and foundMax - presumes users might
// also change the PauseMultiplier so we rediscover
// foundMax.
func (f *FibonacciBackoff) Reset() {
	f.Iteration = 0
	f.foundMax = 0
}

func (f *FibonacciBackoff) Next() time.Duration {
	multiplier := f.PauseMultiplier
	if multiplier <= 0 {
		multiplier = DefaultMultiplier
	}
	pause := time.Duration(Fibonacci(f.Iteration))
	if product, overflows := utilities.ProductWouldOverflowInt64(pause.Nanoseconds(), multiplier.Nanoseconds()); overflows {
		// cowardly refusal to overflow - return time.Duration(math.MaxInt64)
		// we can't calculate jitter, because that could overflow.
		// realistically, this should never happen, we're talking about almost 300 years.
		f.foundMax = f.Iteration - 1
		f.Iteration = f.foundMax
		pause = time.Duration(Fibonacci(f.Iteration)) * multiplier
	} else if f.MaxPause > 0 && time.Duration(product) > f.MaxPause {
		f.foundMax = f.Iteration
		pause = f.MaxPause
	} else {
		pause = time.Duration(product)
	}

	// increment f.Iteration if appropriate
	maxIteration := int64(len(TheFibonacciSequence) + 1)
	if f.MaxIteration > 0 {
		maxIteration = f.MaxIteration
	}
	if f.foundMax == 0 {
		if f.Iteration+1 <= maxIteration {
			f.Iteration++
		} else {
			f.foundMax = f.Iteration
		}
	} else {
		f.Iteration = f.foundMax
	}

	// apply jitter if requested
	if pause > 0 && f.Jitter > 0 {
		pause = utilities.ApplyJitter(pause, f.Jitter)
	}

	return pause
}

func (f *FibonacciBackoff) After(ctx context.Context) <-chan time.Time {
	pause := f.Next()
	results := make(chan time.Time, 1)
	go func() {
		defer close(results)
		select {
		case t := <-time.After(pause):
			results <- t
		case <-ctx.Done():
			results <- time.Now()
		}
	}()
	return results
}

func Fibonacci(n int64) int64 {
	switch {
	case n >= int64(len(TheFibonacciSequence)):
		panic(fmt.Sprintf("invalid input: %d overflows int64\n",
			n))
	default:
		return TheFibonacciSequence[n]
	}
}

var TheFibonacciSequence = [93]int64{
	0, 1, 1, 2, 3, 5, 8, 13, 21, 34,
	55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181,
	6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229,
	832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986,
	102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049,
	12586269025, 20365011074, 32951280099, 53316291173, 86267571272, 139583862445, 225851433717, 365435296162, 591286729879, 956722026041,
	1548008755920, 2504730781961, 4052739537881, 6557470319842, 10610209857723, 17167680177565, 27777890035288, 44945570212853, 72723460248141, 117669030460994,
	190392490709135, 308061521170129, 498454011879264, 806515533049393, 1304969544928657, 2111485077978050, 3416454622906707, 5527939700884757, 8944394323791464, 14472334024676221,
	23416728348467685, 37889062373143906, 61305790721611591, 99194853094755497, 160500643816367088, 259695496911122585, 420196140727489673, 679891637638612258, 1100087778366101931, 1779979416004714189,
	2880067194370816120, 4660046610375530309, 7540113804746346429,
}