Flag for inverting task failure status (#20)

Author: joshdk

.golangci.yml

@@ -3,6 +3,7 @@ linters:
   disable:
     - gomnd
     - lll
+    - maligned
     - wsl
 
 issues:

README.md

@@ -125,6 +125,16 @@ The `-backoff` flag is used with `-sleep`, and will double the time delay betwee
 > $ retry -sleep=15s -backoff wget https://example.com
 > ```
 
+### Invert status
+
+The `-invert` flag is used to flip a task's failure status. Successful task runs will become failures, and vice versa. Useful for when you want to retry a command until it fails.
+
+> Run `curl https://example.com/health`, a maximum of 20 times, until it becomes unresponsive.
+>
+> ```bash
+> $ retry -attempts=20 -invert curl https://example.com/health
+> ```
+
 ### Random jitter
 
 The `-jitter` flag adds a random time range to the sleep duration. Jitter added on top of exponential backoff.

main.go

@@ -31,6 +31,7 @@ func main() {
 	flag.IntVar(&flags.Attempts, "attempts", 3, "maximum number of attempts")
 	flag.BoolVar(&flags.Backoff, "backoff", false, "use exponential backoff when sleeping")
 	flag.IntVar(&flags.Consecutive, "consecutive", 0, "required number of back to back successes")
+	flag.BoolVar(&flags.Invert, "invert", false, "wait for task to fail rather than succeed")
 	flag.DurationVar(&flags.Jitter, "jitter", 0, "time range randomly added to sleep")
 	flag.DurationVar(&flags.TotalTime, "max-time", time.Minute, "maximum total time")
 	flag.BoolVar(&flags.quiet, "quiet", false, "silence all output")

retry/retry.go

@@ -36,6 +36,10 @@ type Spec struct {
 	// row in order for the task to be considered successful overall.
 	Consecutive int
 
+	// Invert is used to indicate that the task success status should be
+	//reversed. Failed tasks count as successful, and vice versa.
+	Invert bool
+
 	// Jitter is the duration range to randomly add to the Sleep time.
 	//  Sleep + [0, Jitter)
 	Jitter time.Duration
@@ -70,7 +74,7 @@ func Retry(spec Spec, task Task) error {
 		case <-ctxMaxTime.Done():
 			return ErrExceededTime
 		case err := <-runnerChan(ctxMaxTask, task):
-			if err != nil {
+			if err != nil != spec.Invert {
 				// Task failed, so drop the number of consecutive successful
 				// runs back down to zero.
 				consecutive = 0

retry/retry_test.go

@@ -45,6 +45,36 @@ func TestRetry(t *testing.T) {
 			failed:   true,
 			duration: 0,
 		},
+		{
+			title: "succeed invert",
+			task:  ExecTask{Name: "false"},
+			spec: Spec{
+				Consecutive: 3,
+				Invert:      true,
+			},
+			results: []result{
+				{elapsed: 0, failed: true},
+				{elapsed: 0, failed: true},
+				{elapsed: 0, failed: true},
+			},
+			failed:   false,
+			duration: 0,
+		},
+		{
+			title: "fail invert",
+			task:  ExecTask{Name: "true"},
+			spec: Spec{
+				Attempts: 3,
+				Invert:   true,
+			},
+			results: []result{
+				{elapsed: 0, failed: false},
+				{elapsed: 0, failed: false},
+				{elapsed: 0, failed: false},
+			},
+			failed:   true,
+			duration: 0,
+		},
 		{
 			title: "succeed slow with task time",
 			task:  ExecTask{Name: "sleep", Args: []string{"2"}},