Merge branch 'feature/efm-recovery' of github.com:onflow/flow-go into…

… khalil/5732-adjust-blocktime-controller

cmd/consensus/main.go

@@ -717,6 +717,7 @@ func main() {
 		}).
 		Component("consensus participant", func(node *cmd.NodeConfig) (module.ReadyDoneAware, error) {
 			mutableProtocolState := protocol_state.NewMutableProtocolState(
+				node.Logger,
 				node.Storage.EpochProtocolStateEntries,
 				node.Storage.ProtocolKVStore,
 				node.State.Params(),

cmd/dynamic_startup_test.go

@@ -28,7 +28,7 @@ func getMockSnapshot(t *testing.T, epochCounter uint64, phase flow.EpochPhase) *
 
 	snapshot := new(protocolmock.Snapshot)
 	snapshot.On("Epochs").Return(epochQuery)
-	snapshot.On("Phase").Return(phase, nil)
+	snapshot.On("EpochPhase").Return(phase, nil)
 	snapshot.On("Head").Return(unittest.BlockHeaderFixture(), nil)
 
 	return snapshot

cmd/util/cmd/common/snapshot.go

@@ -83,13 +83,12 @@ func GetSnapshotAtEpochAndPhase(ctx context.Context, log zerolog.Logger, startup
 			return fmt.Errorf("failed to get the current epoch counter: %w", err)
 		}
 
-		currEpochPhase, err := snapshot.Phase()
+		currEpochPhase, err := snapshot.EpochPhase()
 		if err != nil {
 			return fmt.Errorf("failed to get the current epoch phase: %w", err)
 		}
 
-		// check if we are in or past the target epoch and phase
-		if currEpochCounter > startupEpoch || (currEpochCounter == startupEpoch && currEpochPhase >= startupEpochPhase) {
+		if shouldStartAtEpochPhase(currEpochCounter, startupEpoch, currEpochPhase, startupEpochPhase) {
 			head, err := snapshot.Head()
 			if err != nil {
 				return fmt.Errorf("could not get Dynamic Startup snapshot header: %w", err)
@@ -120,3 +119,22 @@ func GetSnapshotAtEpochAndPhase(ctx context.Context, log zerolog.Logger, startup
 
 	return snapshot, nil
 }
+
+// shouldStartAtEpochPhase determines whether Dynamic Startup should start up the node, based on a
+// target epoch/phase and a current epoch/phase.
+func shouldStartAtEpochPhase(currentEpoch, targetEpoch uint64, currentPhase, targetPhase flow.EpochPhase) bool {
+	// if the current epoch is after the target epoch, start up regardless of phase
+	if currentEpoch > targetEpoch {
+		return true
+	}
+	// if the current epoch is before the target epoch, do not start up regardless of phase
+	if currentEpoch < targetEpoch {
+		return false
+	}
+	// if the target phase is EpochPhaseFallback, only start up if the current phase exactly matches
+	if targetPhase == flow.EpochPhaseFallback {
+		return currentPhase == flow.EpochPhaseFallback
+	}
+	// for any other target phase, start up if current phase is >= target
+	return currentPhase >= targetPhase
+}

consensus/hotstuff/committees/consensus_committee.go

@@ -162,7 +162,8 @@ func NewConsensusCommittee(state protocol.State, me flow.Identifier) (*Consensus
 	epochs = append(epochs, final.Epochs().Current())
 
 	// we prepare the next epoch, if it is committed
-	phase, err := final.Phase()
+	// TODO(EFM, #5730): update phase logic if needed
+	phase, err := final.EpochPhase()
 	if err != nil {
 		return nil, fmt.Errorf("could not check epoch phase: %w", err)
 	}
@@ -183,7 +184,7 @@ func NewConsensusCommittee(state protocol.State, me flow.Identifier) (*Consensus
 	}
 
 	// if epoch fallback mode was triggered, inject the fallback epoch
-	// TODO(EFM, #6020): consider replacing with phase check when it's available
+	// TODO(EFM, #5730): consider replacing with phase check when it's available
 	if epochStateSnapshot.EpochFallbackTriggered() {
 		err = com.onEpochFallbackModeTriggered()
 		if err != nil {

consensus/hotstuff/committees/consensus_committee_test.go

@@ -66,7 +66,7 @@ func (suite *ConsensusSuite) SetupTest() {
 		func() error { return nil },
 	)
 	suite.snapshot.On("EpochProtocolState").Return(suite.epochProtocolState, nil)
-	suite.snapshot.On("Phase").Return(
+	suite.snapshot.On("EpochPhase").Return(
 		func() flow.EpochPhase { return suite.phase },
 		func() error { return nil },
 	)
@@ -624,7 +624,7 @@ func TestRemoveOldEpochs(t *testing.T) {
 	epochQuery := mocks.NewEpochQuery(t, currentEpochCounter, epoch1)
 	snapshot.On("Epochs").Return(epochQuery)
 	currentEpochPhase := flow.EpochPhaseStaking
-	snapshot.On("Phase").Return(
+	snapshot.On("EpochPhase").Return(
 		func() flow.EpochPhase { return currentEpochPhase },
 		func() error { return nil },
 	)

consensus/hotstuff/cruisectl/block_time_controller.go

@@ -175,7 +175,7 @@ func (ctl *BlockTimeController) initEpochInfo() error {
 	}
 	ctl.curEpochTargetEndTime = curEpochTargetEndTime
 
-	phase, err := finalSnapshot.Phase()
+	phase, err := finalSnapshot.EpochPhase()
 	if err != nil {
 		return fmt.Errorf("could not check snapshot phase: %w", err)
 	}

consensus/hotstuff/cruisectl/block_time_controller_test.go

@@ -93,7 +93,7 @@ func setupMocks(bs *BlockTimeControllerSuite) {
 		func() error { return nil },
 	)
 	bs.snapshot.On("EpochProtocolState").Return(&bs.epochProtocolState, nil)
-	bs.snapshot.On("Phase").Return(
+	bs.snapshot.On("EpochPhase").Return(
 		func() flow.EpochPhase { return bs.epochs.Phase() },
 		func() error { return nil })
 	bs.snapshot.On("Head").Return(unittest.BlockHeaderFixture(unittest.HeaderWithView(bs.initialView+11)), nil).Maybe()

consensus/integration/nodes_test.go

@@ -466,6 +466,7 @@ func createNode(
 	seals := stdmap.NewIncorporatedResultSeals(sealLimit)
 
 	mutableProtocolState := protocol_state.NewMutableProtocolState(
+		log,
 		protocolStateDB,
 		protocokKVStoreDB,
 		state.Params(),

engine/collection/epochmgr/engine.go

@@ -240,7 +240,7 @@ func (e *Engine) checkShouldStartPreviousEpochComponentsOnStartup(engineCtx irre
 func (e *Engine) checkShouldVoteOnStartup(finalSnapshot protocol.Snapshot) error {
 	// check the current phase on startup, in case we are in setup phase
 	// and haven't yet voted for the next root QC
-	phase, err := finalSnapshot.Phase()
+	phase, err := finalSnapshot.EpochPhase()
 	if err != nil {
 		return fmt.Errorf("could not get epoch phase for finalized snapshot: %w", err)
 	}

engine/collection/epochmgr/engine_test.go

@@ -160,7 +160,7 @@ func (suite *Suite) SetupTest() {
 	suite.snap.On("Head").Return(
 		func() *flow.Header { return suite.header },
 		func() error { return nil })
-	suite.snap.On("Phase").Return(
+	suite.snap.On("EpochPhase").Return(
 		func() flow.EpochPhase { return suite.phase },
 		func() error { return nil })
 

engine/collection/test/cluster_switchover_test.go

@@ -137,6 +137,7 @@ func NewClusterSwitchoverTestCase(t *testing.T, conf ClusterSwitchoverTestConf)
 	// take first collection node and use its storage as data source for stateMutator
 	refNode := tc.nodes[0]
 	stateMutator := protocol_state.NewMutableProtocolState(
+		refNode.Log,
 		refNode.EpochProtocolState,
 		refNode.ProtocolKVStore,
 		refNode.State.Params(),

engine/consensus/dkg/reactor_engine.go

@@ -84,7 +84,7 @@ func (e *ReactorEngine) Ready() <-chan struct{} {
 		// and fail this epoch's DKG.
 		snap := e.State.Final()
 
-		phase, err := snap.Phase()
+		phase, err := snap.EpochPhase()
 		if err != nil {
 			// unexpected storage-level error
 			// TODO use irrecoverable context

engine/consensus/dkg/reactor_engine_test.go

@@ -209,7 +209,7 @@ func (suite *ReactorEngineSuite_SetupPhase) TestRunDKG_PhaseTransition() {
 func (suite *ReactorEngineSuite_SetupPhase) TestRunDKG_StartupInSetupPhase() {
 
 	// we are in the EpochSetup phase
-	suite.snapshot.On("Phase").Return(flow.EpochPhaseSetup, nil).Once()
+	suite.snapshot.On("EpochPhase").Return(flow.EpochPhaseSetup, nil).Once()
 	// the dkg for this epoch has not been started
 	suite.dkgState.On("GetDKGStarted", suite.NextEpochCounter()).Return(false, nil).Once()
 
@@ -238,7 +238,7 @@ func (suite *ReactorEngineSuite_SetupPhase) TestRunDKG_StartupInSetupPhase() {
 func (suite *ReactorEngineSuite_SetupPhase) TestRunDKG_StartupInSetupPhase_DKGAlreadyStarted() {
 
 	// we are in the EpochSetup phase
-	suite.snapshot.On("Phase").Return(flow.EpochPhaseSetup, nil).Once()
+	suite.snapshot.On("EpochPhase").Return(flow.EpochPhaseSetup, nil).Once()
 	// the dkg for this epoch has been started
 	suite.dkgState.On("GetDKGStarted", suite.NextEpochCounter()).Return(true, nil).Once()
 
@@ -435,7 +435,7 @@ func (suite *ReactorEngineSuite_CommittedPhase) TestLocalDKGFailure() {
 func (suite *ReactorEngineSuite_CommittedPhase) TestStartupInCommittedPhase_DKGSuccess() {
 
 	// we are in the EpochSetup phase
-	suite.snap.On("Phase").Return(flow.EpochPhaseCommitted, nil).Once()
+	suite.snap.On("EpochPhase").Return(flow.EpochPhaseCommitted, nil).Once()
 	// the dkg for this epoch has been started but not ended
 	suite.dkgState.On("GetDKGStarted", suite.NextEpochCounter()).Return(true, nil).Once()
 	suite.dkgState.On("GetDKGEndState", suite.NextEpochCounter()).Return(flow.DKGEndStateUnknown, storerr.ErrNotFound).Once()
@@ -458,7 +458,7 @@ func (suite *ReactorEngineSuite_CommittedPhase) TestStartupInCommittedPhase_DKGS
 func (suite *ReactorEngineSuite_CommittedPhase) TestStartupInCommittedPhase_DKGEndStateAlreadySet() {
 
 	// we are in the EpochSetup phase
-	suite.snap.On("Phase").Return(flow.EpochPhaseCommitted, nil).Once()
+	suite.snap.On("EpochPhase").Return(flow.EpochPhaseCommitted, nil).Once()
 	// the dkg for this epoch has been started and ended
 	suite.dkgState.On("GetDKGStarted", suite.NextEpochCounter()).Return(true, nil).Once()
 	suite.dkgState.On("GetDKGEndState", suite.NextEpochCounter()).Return(flow.DKGEndStateNoKey, nil).Once()
@@ -479,7 +479,7 @@ func (suite *ReactorEngineSuite_CommittedPhase) TestStartupInCommittedPhase_DKGE
 func (suite *ReactorEngineSuite_CommittedPhase) TestStartupInCommittedPhase_InconsistentKey() {
 
 	// we are in the EpochSetup phase
-	suite.snap.On("Phase").Return(flow.EpochPhaseCommitted, nil).Once()
+	suite.snap.On("EpochPhase").Return(flow.EpochPhaseCommitted, nil).Once()
 	// the dkg for this epoch has been started but not ended
 	suite.dkgState.On("GetDKGStarted", suite.NextEpochCounter()).Return(true, nil).Once()
 	suite.dkgState.On("GetDKGEndState", suite.NextEpochCounter()).Return(flow.DKGEndStateUnknown, storerr.ErrNotFound).Once()
@@ -505,7 +505,7 @@ func (suite *ReactorEngineSuite_CommittedPhase) TestStartupInCommittedPhase_Inco
 func (suite *ReactorEngineSuite_CommittedPhase) TestStartupInCommittedPhase_MissingKey() {
 
 	// we are in the EpochSetup phase
-	suite.snap.On("Phase").Return(flow.EpochPhaseCommitted, nil).Once()
+	suite.snap.On("EpochPhase").Return(flow.EpochPhaseCommitted, nil).Once()
 	// the dkg for this epoch has been started but not ended
 	suite.dkgState.On("GetDKGStarted", suite.NextEpochCounter()).Return(true, nil).Once()
 	suite.dkgState.On("GetDKGEndState", suite.NextEpochCounter()).Return(flow.DKGEndStateUnknown, storerr.ErrNotFound).Once()

engine/verification/utils/unittest/helper.go

@@ -654,6 +654,7 @@ func bootstrapSystem(
 		identities = append(identities, verID.Identity())
 
 		mutableProtocolState := protocol_state.NewMutableProtocolState(
+			log,
 			stateFixture.Storage.EpochProtocolStateEntries,
 			stateFixture.Storage.ProtocolKVStore,
 			stateFixture.State.Params(),

integration/dkg/dkg_whiteboard_test.go

@@ -112,7 +112,7 @@ func createNode(
 	epochQuery.Add(nextEpoch)
 	snapshot := new(protocolmock.Snapshot)
 	snapshot.On("Epochs").Return(epochQuery)
-	snapshot.On("Phase").Return(flow.EpochPhaseStaking, nil)
+	snapshot.On("EpochPhase").Return(flow.EpochPhaseStaking, nil)
 	snapshot.On("Head").Return(firstBlock, nil)
 	state := new(protocolmock.ParticipantState)
 	state.On("AtBlockID", firstBlock.ID()).Return(snapshot)

integration/dkg/node.go

@@ -86,7 +86,7 @@ func (n *node) setEpochs(t *testing.T, currentSetup flow.EpochSetup, nextSetup f
 	epochQuery.Add(nextEpoch)
 	snapshot := new(protocolmock.Snapshot)
 	snapshot.On("Epochs").Return(epochQuery)
-	snapshot.On("Phase").Return(flow.EpochPhaseStaking, nil)
+	snapshot.On("EpochPhase").Return(flow.EpochPhaseStaking, nil)
 	snapshot.On("Head").Return(firstBlock, nil)
 	state := new(protocolmock.ParticipantState)
 	state.On("AtBlockID", firstBlock.ID()).Return(snapshot)

integration/epochs/epoch_qc_test.go

@@ -98,7 +98,7 @@ func (s *Suite) TestEpochQuorumCertificate() {
 		hotSigner.On("CreateVote", mock.Anything).Return(vote, nil)
 
 		snapshot := &protomock.Snapshot{}
-		snapshot.On("Phase").Return(flow.EpochPhaseSetup, nil)
+		snapshot.On("EpochPhase").Return(flow.EpochPhaseSetup, nil)
 
 		state := &protomock.State{}
 		state.On("CanonicalRootBlock").Return(rootBlock)

integration/tests/epochs/base_suite.go

@@ -141,7 +141,7 @@ func (s *BaseSuite) AwaitEpochPhase(ctx context.Context, expectedEpoch uint64, e
 
 		actualEpoch, err = snapshot.Epochs().Current().Counter()
 		require.NoError(s.T(), err)
-		actualPhase, err = snapshot.Phase()
+		actualPhase, err = snapshot.EpochPhase()
 		require.NoError(s.T(), err)
 
 		return actualEpoch == expectedEpoch && actualPhase == expectedPhase

integration/tests/epochs/dynamic_epoch_transition_suite.go

@@ -366,7 +366,7 @@ func (s *DynamicEpochTransitionSuite) AssertInEpochPhase(ctx context.Context, ex
 	require.NoError(s.T(), err)
 	actualEpoch, err := snapshot.Epochs().Current().Counter()
 	require.NoError(s.T(), err)
-	actualPhase, err := snapshot.Phase()
+	actualPhase, err := snapshot.EpochPhase()
 	require.NoError(s.T(), err)
 	require.Equal(s.T(), expectedPhase, actualPhase, "not in correct phase")
 	require.Equal(s.T(), expectedEpoch, actualEpoch, "not in correct epoch")

integration/tests/lib/util.go

@@ -238,7 +238,7 @@ func LogStatus(t *testing.T, ctx context.Context, log zerolog.Logger, client *te
 	sealed := sealingSegment.Sealed()
 	finalized := sealingSegment.Finalized()
 
-	phase, err := snapshot.Phase()
+	phase, err := snapshot.EpochPhase()
 	require.NoError(t, err)
 	epoch := snapshot.Epochs().Current()
 	counter, err := epoch.Counter()