retry.Do doesn't preserve context values when calling action. Here is an example:

ctx := context.WithValue(context.Background(), "asdf", 3)
action := func(ctx context.Context) error {
	log.Println(ctx.Value("asdf")) // Doesn't print 3
	return nil
}

retry.Do(ctx, action)

Does it make sense to change retry.Do to preserve context values?

I'm struggling to follow the examples in the README because I can't relate them to the package actual implementation:

1. breaker.BreakBySignal as long as the other breakers don't implement the strategy.Breaker interface (the Err() method is missing). This is also a problem in the implementation, that is backing me from using this breaker

2. The function (second parameter of retry.Do) must accept a context as parameter. This is not reflected in the documentation

go get -u github.com/kamilsk/retry/v4
package github.com/kamilsk/retry/v4: cannot find package "github.com/kamilsk/retry/v4" in any of:
...

If action panic then the done channel is never closed and it hangs forever.

https://github.com/kamilsk/retry/blob/272c5373f544785efa4a1fd557aadfe505469695/retry.go#L42

cmd/retry/main.go:116:14:warning: error return value not checked (spin.Color("red")) (errcheck)
cmd/retry/main.go:117:37:warning: error return value not checked (color.New(color.FgYellow).Fprintf(stderr, "#%d attempt at %s... \n", attempt+1, time.Now().Sub(start))) (errcheck)
cmd/retry/main.go:119::warning: Subprocess launching with variable.,HIGH,HIGH (gas)
cmd/retry/main.go:67:34:warning: error return value not checked (color.New(color.FgRed).Fprintf(app.Stderr, format, err)) (errcheck)
cmd/retry/main.go:88:39:warning: error return value not checked (color.New(color.FgYellow).Fprintln(stderr, "notify component is not ready yet")) (errcheck)
cmd/retry/main.go:90:18:warning: error return value not checked (report.Execute(app.Stdout, struct {) (errcheck)
cmd/retry/parser_test.go:13::warning: cyclomatic complexity 11 of function Test_parse() is high (> 10) (gocyclo)

the concept:

func Whitelist(errors ...error) Strategy {
	whitelist := classifier.WhitelistClassifier(errors)
	return func(attempt uint, err error) bool {
		return whitelist.Classify(err) == classifier.Retry
	}
}

$ go get bitbucket.org/kamilsk/retry
package bitbucket.org/kamilsk/retry: code in directory $GOPATH/src/bitbucket.org/kamilsk/retry expects import "github.com/kamilsk/retry"

blocked by https://github.com/kamilsk/retrier/issues/30

origin: https://github.com/Rican7/retry/blob/272ad122d6e5ce1be757544007cf8bcd1c9c9ab0/strategy/strategy.go#L25-L29

what if:

var resp *http.Response

action := func(...) error { fill resp }

if err := retry.Do(action, strategy.Limit(0)); err != nil {
    return err
}

json.NewEncoder(resp.Body).Encode() <- nil pointer, because resp is nil, action didn't run

In v4 it is possible to use "infinite" context to call inside an action

	err = retry.Try(
		breaker.BreakByTimeout(10*time.Second),
		func(uint) error {
			statuses, err = s.dwhClient.V1Status(ctx, source)
			return err
		},
		strategy.Limit(10),
		strategy.Wait(time.Millisecond*10, time.Millisecond*100, time.Millisecond*1000),
	)
	return

The problem is that if the client doesn't have read/conn timeout the V1Status can block goroutine for a long time.

// A Breaker carries a cancellation signal to break an action execution.
//
// It is a subset of context.Context and github.com/kamilsk/breaker.Breaker.
type Breaker interface {
	// Done returns a channel that's closed when a cancellation signal occurred.
	Done() <-chan struct{}

	Error() error
}

The main problem is that ctx is not interrupted by func retry.

Possible solution without breaking changes:

func TryContext(
	ctx context.Context,
	action func(ctx context.Context, attempt uint) error,
	strategies ...func(attempt uint, err error) bool,
) error {
	ctx, cancel := context.WithCancel(ctx)
	err := retry(ctx, currying(ctx, action), strategies...)
	cancel() // or defer it
	return err
}

Also, I have to delete

	if (breaker == nil || breaker.Done() == nil) && len(strategies) == 0 {
		return action(0)
	}

1. move the repo to octolab org
2. fork the repo
3. use https://tip.golang.org/ref/mod#go-mod-file-module-deprecation
4. write documentation
5. update awesome list
6. archive the repo

https://github.com/kamilsk/retry/blob/19175c70a27be2f7fda74b27ec2b8551fec29e5f/strategy/strategy.go#L102-L144

TODO:

• [ ] find bad case usage from goreleaser

• https://pkg.go.dev/github.com/kamilsk/retry/v4?tab=importedby
  • [ ] https://github.com/tmaiaroto/aegis, v4.1.0 -> v5.0.0
  • [x] ~https://github.com/goreleaser/goreleaser, v4.7.2 -> v5.0.0~