test ComputeBoostrapDelay, remove post-bootstrap alignment (#1028)

* refactor bootstrap delay computation into a standalone function

The computation of the bootstrap delay is now in a standalone
function, which allows us to test it in isolation.

Signed-off-by: Jakub Sztandera <[email protected]>

* add tests for bootstrap delay

Signed-off-by: Jakub Sztandera <[email protected]>

* fix: don't align bootstrap time after bootstrap

Aligning bootstrap time after bootstrap epoch shouldn't
be required and as it stands it could delay F3 startup

Signed-off-by: Jakub Sztandera <[email protected]>

---------

Signed-off-by: Jakub Sztandera <[email protected]>

Author: Kubuxu

bootstrap_delay_test.go

@@ -0,0 +1,86 @@
+package f3
+
+import (
+	"testing"
+	"time"
+
+	"github.com/filecoin-project/go-f3/ec"
+	"github.com/filecoin-project/go-f3/internal/clock"
+	"github.com/filecoin-project/go-f3/manifest"
+)
+
+var _ ec.TipSet = (*tipset)(nil)
+
+func TestComputeBootstrapDelay(t *testing.T) {
+	period := 30 * time.Second
+	bootstrapEpoch := 1000
+	m := manifest.Manifest{
+		BootstrapEpoch: int64(bootstrapEpoch),
+		EC: manifest.EcConfig{
+			Period: period,
+		},
+	}
+
+	clock := clock.NewMock()
+	genesis := time.Date(2020, time.January, 12, 01, 01, 01, 00, time.UTC)
+
+	tt := []struct {
+		name string
+		time time.Time
+		ts   tipset
+		want time.Duration
+	}{
+		{
+			name: "in sync - right before bootstrap",
+			time: genesis.Add(time.Duration(bootstrapEpoch-1) * period),
+			ts:   tipset{genesis: genesis, epoch: int64(bootstrapEpoch - 1), period: period},
+			want: period,
+		},
+		{
+			name: "in sync - right at bootstrap",
+			time: genesis.Add(time.Duration(bootstrapEpoch) * period),
+			ts:   tipset{genesis: genesis, epoch: int64(bootstrapEpoch), period: period},
+			want: 0,
+		},
+		{
+			name: "in sync - right after bootstrap",
+			time: genesis.Add(time.Duration(bootstrapEpoch+1) * period),
+			ts:   tipset{genesis: genesis, epoch: int64(bootstrapEpoch + 1), period: period},
+			want: 0,
+		},
+		{
+			name: "in sync - right before bootstrap (offset)",
+			time: genesis.Add(time.Duration(bootstrapEpoch-1)*period + 15*time.Second),
+			ts:   tipset{genesis: genesis, epoch: int64(bootstrapEpoch - 1), period: period},
+			want: 15 * time.Second,
+		},
+		{
+			name: "in sync - right after bootstrap (offset)",
+			time: genesis.Add(time.Duration(bootstrapEpoch)*period + 1*time.Second),
+			ts:   tipset{genesis: genesis, epoch: int64(bootstrapEpoch), period: period},
+			want: 0 * time.Second,
+		},
+		{
+			name: "out of sync - way after bootstrap",
+			time: genesis.Add(time.Duration(bootstrapEpoch+100)*period + 1*time.Second),
+			ts:   tipset{genesis: genesis, epoch: int64(bootstrapEpoch - 100), period: period},
+			want: 0 * time.Second,
+		},
+		{
+			name: "out of sync - way before bootstrap",
+			time: genesis.Add(time.Duration(bootstrapEpoch-30)*period + 1*time.Second),
+			ts:   tipset{genesis: genesis, epoch: int64(bootstrapEpoch - 100), period: period},
+			want: 30*period - 1*time.Second,
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.name, func(t *testing.T) {
+			clock.Set(tc.time)
+			got := computeBootstrapDelay(&tc.ts, clock, m)
+			if got != tc.want {
+				t.Errorf("computeBootstrapDelay(%s, %v, %v) = %v, want %v", &tc.ts, tc.time, period, got, tc.want)
+			}
+		})
+	}
+}

f3.go

@@ -136,34 +136,26 @@ func (m *F3) GetPowerTableByInstance(ctx context.Context, instance uint64) (gpbf
 
 // computeBootstrapDelay returns the time at which the F3 instance specified by
 // the passed manifest should be started.
-func (m *F3) computeBootstrapDelay() (time.Duration, error) {
-	ts, err := m.ec.GetHead(m.runningCtx)
-	if err != nil {
-		return 0, fmt.Errorf("failed to get the EC chain head: %w", err)
-	}
-
+func computeBootstrapDelay(ts ec.TipSet, clock clock.Clock, mfst manifest.Manifest) time.Duration {
 	currentEpoch := ts.Epoch()
-	if currentEpoch >= m.mfst.BootstrapEpoch {
-		return 0, nil
-	}
-	epochDelay := m.mfst.BootstrapEpoch - currentEpoch
-	start := ts.Timestamp().Add(time.Duration(epochDelay) * m.mfst.EC.Period)
-	delay := m.clock.Until(start)
-	// Add additional delay to skip over null epochs. That way we wait the full 900 epochs.
-	if delay <= 0 {
-		delay = m.mfst.EC.Period + delay%m.mfst.EC.Period
-	}
-	return delay, nil
+	if currentEpoch >= mfst.BootstrapEpoch {
+		return 0
+	}
+	epochDelay := mfst.BootstrapEpoch - currentEpoch
+	start := ts.Timestamp().Add(time.Duration(epochDelay) * mfst.EC.Period)
+	delay := clock.Until(start)
+	delay = max(delay, 0)
+	return delay
 }
 
 // Start the module, call Stop to exit. Canceling the past context will cancel the request to start
 // F3, it won't stop the service after it has started.
 func (m *F3) Start(startCtx context.Context) (_err error) {
-
-	initialDelay, err := m.computeBootstrapDelay()
+	ts, err := m.ec.GetHead(m.runningCtx)
 	if err != nil {
-		return fmt.Errorf("failed to compute bootstrap delay: %w", err)
+		return fmt.Errorf("failed to get the EC chain head: %w", err)
 	}
+	initialDelay := computeBootstrapDelay(ts, m.clock, m.mfst)
 
 	// Try to start immediately if there's no initial delay and pass on any start
 	// errors directly.
@@ -184,11 +176,13 @@ func (m *F3) Start(startCtx context.Context) (_err error) {
 				log.Debugw("F3 start disrupted", "cause", m.runningCtx.Err())
 				return
 			case startTime := <-startTimer.C:
-				delay, err := m.computeBootstrapDelay()
+				ts, err := m.ec.GetHead(m.runningCtx)
 				if err != nil {
-					log.Errorw("failed to compute bootstrap delay", "err", err)
+					log.Errorw("failed to get the EC chain head during startup", "err", err)
 					return
 				}
+
+				delay := computeBootstrapDelay(ts, m.clock, m.mfst)
 				if delay > 0 {
 					log.Infow("waiting for bootstrap epoch", "duration", delay.String())
 					startTimer.Reset(delay)

tipsettimestamp_test.go

@@ -1,6 +1,7 @@
 package f3
 
 import (
+	"fmt"
 	"testing"
 	"time"
 
@@ -15,7 +16,7 @@ type tipset struct {
 }
 
 func (ts *tipset) String() string {
-	panic("not implemented")
+	return fmt.Sprintf("epoch %d, timestamp %s", ts.epoch, ts.Timestamp())
 }
 
 func (ts *tipset) Key() gpbft.TipSetKey {