sync2: ignore cycle when inverval is -1 (including initial run)

This would make it possible to easily disable the chores in the Storj micro-services, even if there is no dedicated flag for this.

Setting -1 interval for any flag would mean disabling the cycle all together.

Change-Id: I531f0bef5e208787b7643018a257a076a3385e31

Author: elek

sync2/cycle.go

@@ -9,7 +9,7 @@ import (
 	"sync/atomic"
 	"time"
 
-	monkit "github.com/spacemonkeygo/monkit/v3"
+	"github.com/spacemonkeygo/monkit/v3"
 	"golang.org/x/sync/errgroup"
 )
 
@@ -89,6 +89,9 @@ func (cycle *Cycle) Run(ctx context.Context, fn func(ctx context.Context) error)
 	cycle.initialize()
 	defer close(cycle.stopped)
 
+	if cycle.Disabled() {
+		return nil
+	}
 	currentInterval := cycle.interval
 	cycle.ticker = time.NewTicker(currentInterval)
 	defer cycle.ticker.Stop()
@@ -199,29 +202,55 @@ func (cycle *Cycle) Stop() {
 }
 
 // ChangeInterval allows to change the ticker interval after it has started.
+// interval=-1 (disabled loop) is not allowed to be changed (it will panic).
 func (cycle *Cycle) ChangeInterval(interval time.Duration) {
+	if cycle.Disabled() {
+		if interval != -1 {
+			panic("Change interval on a disabled cycle is not supported")
+		}
+		return
+	}
+	if interval == -1 {
+		panic("Cannot disable an already initialized cycle.")
+	}
 	cycle.sendControl(cycleChangeInterval{interval})
 }
 
 // Pause pauses the cycle.
 func (cycle *Cycle) Pause() {
+	if cycle.Disabled() {
+		return
+	}
 	cycle.sendControl(cyclePause{})
 }
 
 // Restart restarts the ticker from 0.
 func (cycle *Cycle) Restart() {
+	if cycle.Disabled() {
+		return
+	}
 	cycle.sendControl(cycleContinue{})
 }
 
-// Trigger ensures that the loop is done at least once.
+// Trigger ensures that the loop is done at least once. Note that it will not run if
+// the cycle is disabled.
+// TODO: Trigger should probably run the cycle even if the cycle interval is disabled.
 // If it's currently running it waits for the previous to complete and then runs.
 func (cycle *Cycle) Trigger() {
+	if cycle.Disabled() {
+		return
+	}
 	cycle.sendControl(cycleTrigger{})
 }
 
 // TriggerWait ensures that the loop is done at least once and waits for completion.
+// Note that it will not run if the cycle is disabled.
+// TODO: Trigger should probably run the cycle even if the cycle interval is disabled.
 // If it's currently running it waits for the previous to complete and then runs.
 func (cycle *Cycle) TriggerWait() {
+	if cycle.Disabled() {
+		return
+	}
 	done := make(chan struct{})
 
 	cycle.sendControl(cycleTrigger{done})
@@ -231,6 +260,11 @@ func (cycle *Cycle) TriggerWait() {
 	}
 }
 
+// Disabled means the cycle is not intended to run (interval is -1).
+func (cycle *Cycle) Disabled() bool {
+	return cycle.interval == -1
+}
+
 type cycleManualTriggerTag struct{}
 
 func withManualTrigger(ctx context.Context) context.Context {

sync2/cycle_test.go

@@ -15,6 +15,7 @@ import (
 	"golang.org/x/sync/errgroup"
 
 	"storj.io/common/sync2"
+	"storj.io/common/testcontext"
 )
 
 func TestCycle_Basic(t *testing.T) {
@@ -134,20 +135,31 @@ func TestCycle_StopCancelled(t *testing.T) {
 	require.True(t, errors.Is(err, context.Canceled))
 }
 
-func TestCycle_Run_NoInterval(t *testing.T) {
+func TestCycle_Disable(t *testing.T) {
 	t.Parallel()
 
-	cycle := &sync2.Cycle{}
+	cycle := sync2.NewCycle(-1)
+	cycle.ChangeInterval(-1)
 	require.Panics(t,
 		func() {
-			err := cycle.Run(context.Background(), func(_ context.Context) error {
-				return nil
-			})
-
-			require.NoError(t, err)
+			cycle.ChangeInterval(5 * time.Minute)
 		},
-		"Run without setting an interval should panic",
+		"changing interval of a disabled cycle should panic",
 	)
+
+	executed := false
+	cycle = sync2.NewCycle(-1)
+	err := cycle.Run(testcontext.New(t), func(ctx context.Context) error {
+		executed = true
+		return nil
+	})
+	require.NoError(t, err)
+	require.False(t, executed)
+
+	// no op for disabled cycle
+	cycle.Pause()
+	cycle.Trigger()
+	cycle.Restart()
 }
 
 func TestCycle_Stop_NotStarted(t *testing.T) {