IOTEX-2 Support time based rotation on proposing a block (iotexproject#65)

Author: zjshen14

config/config.go

@@ -115,14 +115,14 @@ var (
 				EventChanSize:          10000,
 				NumDelegates:           21,
 				EnableDummyBlock:       true,
+				TimeBasedRotation:      false,
 			},
 			BlockCreationInterval: 10 * time.Second,
 		},
 		BlockSync: BlockSync{
 			Interval:   10 * time.Second,
 			BufferSize: 16,
 		},
-
 		Dispatcher: Dispatcher{
 			EventChanSize: 10000,
 		},
@@ -236,6 +236,7 @@ type (
 		EventChanSize          uint          `yaml:"eventChanSize"`
 		NumDelegates           uint          `yaml:"numDelegates"`
 		EnableDummyBlock       bool          `yaml:"enableDummyBlock"`
+		TimeBasedRotation      bool          `yaml:"timeBasedRotation"`
 	}
 
 	// Dispatcher is the dispatcher config
@@ -416,26 +417,31 @@ func ValidateConsensusScheme(cfg *Config) error {
 // ValidateDispatcher validates the dispatcher configs
 func ValidateDispatcher(cfg *Config) error {
 	if cfg.Dispatcher.EventChanSize <= 0 {
-		return errors.Wrapf(ErrInvalidCfg, "dispatcher event chan size should be greater than 0")
+		return errors.Wrap(ErrInvalidCfg, "dispatcher event chan size should be greater than 0")
 	}
 	return nil
 }
 
 // ValidateRollDPoS validates the roll-DPoS configs
 func ValidateRollDPoS(cfg *Config) error {
 	if cfg.Consensus.Scheme == RollDPoSScheme && cfg.Consensus.RollDPoS.EventChanSize <= 0 {
-		return errors.Wrapf(ErrInvalidCfg, "roll-DPoS event chan size should be greater than 0")
+		return errors.Wrap(ErrInvalidCfg, "roll-DPoS event chan size should be greater than 0")
 	}
 	if cfg.Consensus.Scheme == RollDPoSScheme && cfg.Consensus.RollDPoS.NumDelegates <= 0 {
-		return errors.Wrapf(ErrInvalidCfg, "roll-DPoS event delegate number should be greater than 0")
+		return errors.Wrap(ErrInvalidCfg, "roll-DPoS event delegate number should be greater than 0")
+	}
+	if cfg.Consensus.Scheme == RollDPoSScheme &&
+		cfg.Consensus.RollDPoS.EnableDummyBlock &&
+		cfg.Consensus.RollDPoS.TimeBasedRotation {
+		return errors.Wrap(ErrInvalidCfg, "roll-DPoS should enable dummy block when doing time based rotation")
 	}
 	return nil
 }
 
 // ValidateExplorer validates the explorer configs
 func ValidateExplorer(cfg *Config) error {
 	if cfg.Explorer.Enabled && cfg.Explorer.TpsWindow <= 0 {
-		return errors.Wrapf(ErrInvalidCfg, "tps window is not a positive integer when the explorer is enabled")
+		return errors.Wrap(ErrInvalidCfg, "tps window is not a positive integer when the explorer is enabled")
 	}
 	return nil
 }

config/config_test.go

@@ -287,6 +287,17 @@ func TestValidateRollDPoS(t *testing.T) {
 		t,
 		strings.Contains(err.Error(), "roll-DPoS event delegate number should be greater than 0"),
 	)
+
+	cfg.Consensus.RollDPoS.NumDelegates = 1
+	cfg.Consensus.RollDPoS.EnableDummyBlock = true
+	cfg.Consensus.RollDPoS.TimeBasedRotation = true
+	err = ValidateRollDPoS(&cfg)
+	require.NotNil(t, err)
+	require.Equal(t, ErrInvalidCfg, errors.Cause(err))
+	require.True(
+		t,
+		strings.Contains(err.Error(), "roll-DPoS should enable dummy block when doing time based rotation"),
+	)
 }
 
 func TestValidateNetwork(t *testing.T) {

consensus/scheme/rolldpos/fsm.go

@@ -273,7 +273,7 @@ func (m *cFSM) Start(c context.Context) error {
 				src := m.fsm.CurrentState()
 				if err := m.fsm.Handle(evt); err != nil {
 					if errors.Cause(err) == fsm.ErrTransitionNotFound {
-						if time.Since(evt.timestamp()) <= m.ctx.cfg.UnmatchedEventTTL {
+						if m.ctx.clock.Now().Sub(evt.timestamp()) <= m.ctx.cfg.UnmatchedEventTTL {
 							m.produce(evt, m.ctx.cfg.UnmatchedEventInterval)
 							logger.Debug().
 								Str("src", string(src)).
@@ -320,7 +320,7 @@ func (m *cFSM) produce(evt iConsensusEvt, delay time.Duration) {
 		go func() {
 			select {
 			case <-m.close:
-			case <-time.After(delay):
+			case <-m.ctx.clock.After(delay):
 				m.evtq <- evt
 			}
 			m.wg.Done()
@@ -457,9 +457,22 @@ func (m *cFSM) handleProposeBlockEvt(evt fsm.Event) (fsm.State, error) {
 		if !ok {
 			return sInvalid, errors.Wrap(ErrEvtCast, "the event is not a proposeBlkEvt")
 		}
-		// If the block is self proposed, skip validation
-		if proposeBlkEvt.proposer != m.ctx.addr.RawAddress {
-			blkHash := proposeBlkEvt.block.HashBlock()
+		proposer, err := m.ctx.calcProposer(proposeBlkEvt.block.Height(), m.ctx.epoch.delegates)
+		if err != nil {
+			return sInvalid, errors.Wrap(err, "error when calculating the proposer")
+		}
+		blkHash := proposeBlkEvt.block.HashBlock()
+		if proposeBlkEvt.proposer != proposer {
+			logger.Error().
+				Str("proposer", proposeBlkEvt.proposer).
+				Str("actualProposer", proposer).
+				Uint64("block", proposeBlkEvt.block.Height()).
+				Str("hash", hex.EncodeToString(blkHash[:])).
+				Err(err).
+				Msg("error when validating the block proposer")
+			validated = false
+		} else if proposeBlkEvt.proposer != m.ctx.addr.RawAddress {
+			// If the block is self proposed, skip validation
 			if err := m.ctx.chain.ValidateBlock(proposeBlkEvt.block); err != nil {
 				logger.Error().
 					Str("proposer", proposeBlkEvt.proposer).
@@ -688,7 +701,7 @@ func (m *cFSM) produceStartRoundEvt() error {
 	)
 	// If we have the cached last block, we get the timestamp from it
 	if m.ctx.round.block != nil {
-		duration = time.Since(m.ctx.round.block.Header.Timestamp())
+		duration = m.ctx.clock.Now().Sub(m.ctx.round.block.Header.Timestamp())
 	} else if duration, err = m.ctx.calcDurationSinceLastBlock(); err != nil {
 		// Otherwise, we read it from blockchain
 		return errors.Wrap(err, "error when computing the duration since last block time")