comment out pause/catch up logic, store highest setID/round in db

noot · noot · commit 72da44e2d451 · 2021-07-27T17:26:22.000-04:00
diff --git a/dot/core/interface.go b/dot/core/interface.go
@@ -41,7 +41,6 @@ type BlockState interface {
 	GetSlotForBlock(common.Hash) (uint64, error)
 	GetFinalisedHeader(uint64, uint64) (*types.Header, error)
 	GetFinalisedHash(uint64, uint64) (common.Hash, error)
-	SetFinalisedHash(common.Hash, uint64, uint64) error
 	RegisterImportedChannel(ch chan<- *types.Block) (byte, error)
 	UnregisterImportedChannel(id byte)
 	RegisterFinalizedChannel(ch chan<- *types.FinalisationInfo) (byte, error)
diff --git a/dot/network/service.go b/dot/network/service.go
@@ -343,7 +343,7 @@ func (s *Service) sentBlockIntervalTelemetry() {
 		}
 		bestHash := best.Hash()
 
-		finalized, err := s.blockState.GetFinalisedHeader(0, 0) //nolint
+		finalized, err := s.blockState.GetHighestFinalisedHeader() //nolint
 		if err != nil {
 			continue
 		}
@@ -519,16 +519,21 @@ func (s *Service) GossipMessage(msg NotificationsMessage) {
 func (s *Service) SendMessage(to peer.ID, msg NotificationsMessage) error {
 	s.notificationsMu.Lock()
 	defer s.notificationsMu.Unlock()
+
 	for msgID, prtl := range s.notificationsProtocols {
-		if msg.Type() != msgID || prtl == nil {
+		if msg.Type() != msgID {
 			continue
 		}
+
 		hs, err := prtl.getHandshake()
 		if err != nil {
 			return err
 		}
+
 		s.sendData(to, hs, prtl, msg)
+		return nil
 	}
+
 	return errors.New("message not supported by any notifications protocol")
 }
 
diff --git a/dot/network/state.go b/dot/network/state.go
@@ -29,7 +29,7 @@ type BlockState interface {
 	BestBlockNumber() (*big.Int, error)
 	GenesisHash() common.Hash
 	HasBlockBody(common.Hash) (bool, error)
-	GetFinalisedHeader(round, setID uint64) (*types.Header, error)
+	GetHighestFinalisedHeader() (*types.Header, error)
 	GetHashByNumber(num *big.Int) (common.Hash, error)
 }
 
diff --git a/dot/network/sync.go b/dot/network/sync.go
@@ -351,7 +351,7 @@ func (q *syncQueue) benchmark() {
 		goal := atomic.LoadInt64(&q.goal)
 
 		if before.Number.Int64() >= goal {
-			finalised, err := q.s.blockState.GetFinalisedHeader(0, 0) //nolint
+			finalised, err := q.s.blockState.GetHighestFinalisedHeader() //nolint
 			if err != nil {
 				continue
 			}
@@ -767,7 +767,7 @@ func (q *syncQueue) handleBlockJustification(data []*types.BlockData) {
 }
 
 func (q *syncQueue) handleBlockData(data []*types.BlockData) {
-	finalised, err := q.s.blockState.GetFinalisedHeader(0, 0)
+	finalised, err := q.s.blockState.GetHighestFinalisedHeader()
 	if err != nil {
 		panic(err) // this should never happen
 	}
@@ -815,7 +815,7 @@ func (q *syncQueue) handleBlockDataFailure(idx int, err error, data []*types.Blo
 	logger.Warn("failed to handle block data", "failed on block", q.currStart+int64(idx), "error", err)
 
 	if errors.Is(err, chaindb.ErrKeyNotFound) || errors.Is(err, blocktree.ErrParentNotFound) {
-		finalised, err := q.s.blockState.GetFinalisedHeader(0, 0)
+		finalised, err := q.s.blockState.GetHighestFinalisedHeader()
 		if err != nil {
 			panic(err)
 		}
diff --git a/dot/state/block.go b/dot/state/block.go
@@ -123,6 +123,10 @@ func NewBlockStateFromGenesis(db chaindb.Database, header *types.Header) (*Block
 
 	bs.genesisHash = header.Hash()
 
+	if err := bs.db.Put(highestRoundAndSetIDKey, roundSetIDKey(0, 0)); err != nil {
+		return nil, err
+	}
+
 	// set the latest finalised head to the genesis header
 	if err := bs.SetFinalisedHash(bs.genesisHash, 0, 0); err != nil {
 		return nil, err
diff --git a/dot/state/block_finalisation.go b/dot/state/block_finalisation.go
@@ -17,13 +17,16 @@
 package state
 
 import (
+	"encoding/binary"
 	"fmt"
 	"math/big"
 
 	"github.com/ChainSafe/gossamer/dot/types"
 	"github.com/ChainSafe/gossamer/lib/common"
 )
 
+var highestRoundAndSetIDKey = []byte("hrs")
+
 // finalisedHashKey = FinalizedBlockHashKey + round + setID (LE encoded)
 func finalisedHashKey(round, setID uint64) []byte {
 	return append(common.FinalizedBlockHashKey, roundSetIDKey(round, setID)...)
@@ -69,8 +72,63 @@ func (bs *BlockState) GetFinalisedHash(round, setID uint64) (common.Hash, error)
 	return common.NewHash(h), nil
 }
 
+func roundSetIDNum(round, setID uint64) *big.Int {
+	buf := make([]byte, 8)
+	binary.BigEndian.PutUint64(buf, round)
+	buf2 := make([]byte, 8)
+	binary.BigEndian.PutUint64(buf2, setID)
+	return big.NewInt(0).SetBytes(append(buf, buf2...))
+}
+
+func (bs *BlockState) setHighestRoundAndSetID(round, setID uint64) error {
+	currRound, currSetID, err := bs.getHighestRoundAndSetID()
+	if err != nil {
+		return err
+	}
+
+	if roundSetIDNum(round, setID).Cmp(roundSetIDNum(currRound, currSetID)) <= 0 {
+		return nil
+	}
+
+	return bs.db.Put(highestRoundAndSetIDKey, roundSetIDKey(round, setID))
+}
+
+func (bs *BlockState) getHighestRoundAndSetID() (uint64, uint64, error) {
+	b, err := bs.db.Get(highestRoundAndSetIDKey)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	round := binary.LittleEndian.Uint64(b[:8])
+	setID := binary.LittleEndian.Uint64(b[8:16])
+	return round, setID, nil
+}
+
+func (bs *BlockState) GetHighestFinalisedHash() (common.Hash, error) {
+	round, setID, err := bs.getHighestRoundAndSetID()
+	if err != nil {
+		return common.Hash{}, err
+	}
+
+	return bs.GetFinalisedHash(round, setID)
+}
+
+// GetHighestFinalisedHeader returns the most recently finalised block header
+func (bs *BlockState) GetHighestFinalisedHeader() (*types.Header, error) {
+	h, err := bs.GetHighestFinalisedHash()
+	if err != nil {
+		return nil, err
+	}
+
+	header, err := bs.GetHeader(h)
+	if err != nil {
+		return nil, err
+	}
+
+	return header, nil
+}
+
 // SetFinalisedHash sets the latest finalised block header
-// Note that using round=0 and setID=0 would refer to the latest finalised hash
 func (bs *BlockState) SetFinalisedHash(hash common.Hash, round, setID uint64) error {
 	bs.Lock()
 	defer bs.Unlock()
@@ -114,7 +172,12 @@ func (bs *BlockState) SetFinalisedHash(hash common.Hash, round, setID uint64) er
 	}
 
 	bs.lastFinalised = hash
-	return bs.db.Put(finalisedHashKey(round, setID), hash[:])
+
+	if err := bs.db.Put(finalisedHashKey(round, setID), hash[:]); err != nil {
+		return err
+	}
+
+	return bs.setHighestRoundAndSetID(round, setID)
 }
 
 func (bs *BlockState) setFirstSlotOnFinalisation() error {
diff --git a/dot/sync/interface.go b/dot/sync/interface.go
@@ -78,7 +78,7 @@ type Verifier interface {
 
 // FinalityGadget implements justification verification functionality
 type FinalityGadget interface {
-	VerifyBlockJustification([]byte) error
+	VerifyBlockJustification(common.Hash, []byte) error
 }
 
 // BlockImportHandler is the interface for the handler of newly imported blocks
diff --git a/dot/sync/mocks/FinalityGadget.go b/dot/sync/mocks/FinalityGadget.go
diff --git a/dot/sync/mocks/finality_gadget.go b/dot/sync/mocks/finality_gadget.go
diff --git a/dot/sync/syncer.go b/dot/sync/syncer.go
@@ -366,18 +366,12 @@ func (s *Service) handleJustification(header *types.Header, justification []byte
 		return
 	}
 
-	err := s.finalityGadget.VerifyBlockJustification(justification)
+	err := s.finalityGadget.VerifyBlockJustification(header.Hash(), justification)
 	if err != nil {
 		logger.Warn("failed to verify block justification", "hash", header.Hash(), "number", header.Number, "error", err)
 		return
 	}
 
-	err = s.blockState.SetFinalisedHash(header.Hash(), 0, 0)
-	if err != nil {
-		logger.Error("failed to set finalised hash", "error", err)
-		return
-	}
-
 	err = s.blockState.SetJustification(header.Hash(), justification)
 	if err != nil {
 		logger.Error("failed tostore justification", "error", err)
diff --git a/dot/sync/test_helpers.go b/dot/sync/test_helpers.go
@@ -42,8 +42,8 @@ import (
 )
 
 // NewMockFinalityGadget create and return sync FinalityGadget interface mock
-func NewMockFinalityGadget() *syncmocks.MockFinalityGadget {
-	m := new(syncmocks.MockFinalityGadget)
+func NewMockFinalityGadget() *syncmocks.FinalityGadget {
+	m := new(syncmocks.FinalityGadget)
 	// using []uint8 instead of []byte: https://github.com/stretchr/testify/pull/969
 	m.On("VerifyBlockJustification", mock.AnythingOfType("[]uint8")).Return(nil)
 	return m
diff --git a/lib/grandpa/errors.go b/lib/grandpa/errors.go
@@ -18,10 +18,16 @@ package grandpa
 
 import (
 	"errors"
+	"fmt"
 
 	"github.com/ChainSafe/gossamer/lib/blocktree"
 )
 
+// errRoundMismatch is returned when trying to validate a vote message that isn't for the current round
+func errRoundMismatch(got, want uint64) error {
+	return fmt.Errorf("rounds do not match: got %d, want %d", got, want)
+}
+
 //nolint
 var (
 	ErrNilBlockState    = errors.New("cannot have nil BlockState")
@@ -39,9 +45,6 @@ var (
 	// ErrSetIDMismatch is returned when trying to validate a vote message with an invalid voter set ID, or when receiving a catch up message with a different set ID
 	ErrSetIDMismatch = errors.New("set IDs do not match")
 
-	// ErrRoundMismatch is returned when trying to validate a vote message that isn't for the current round
-	ErrRoundMismatch = errors.New("rounds do not match")
-
 	// ErrEquivocation is returned when trying to validate a vote for that is equivocatory
 	ErrEquivocation = errors.New("vote is equivocatory")
 
diff --git a/lib/grandpa/grandpa.go b/lib/grandpa/grandpa.go
@@ -345,7 +345,8 @@ func (s *Service) initiate() error {
 		}
 
 		if err != nil {
-			return err
+			logger.Warn("play grandpa round error", "error", err)
+			continue
 		}
 
 		if s.ctx.Err() != nil {
@@ -802,12 +803,7 @@ func (s *Service) finalise() error {
 		return err
 	}
 
-	if err = s.grandpaState.SetLatestRound(s.state.round); err != nil {
-		return err
-	}
-
-	// set latest finalised head in db
-	return s.blockState.SetFinalisedHash(bfc.Hash, 0, 0)
+	return s.grandpaState.SetLatestRound(s.state.round)
 }
 
 // createJustification collects the signed precommits received for this round and turns them into
@@ -1015,8 +1011,10 @@ func (s *Service) getPreVotedBlock() (Vote, error) {
 func (s *Service) getGrandpaGHOST() (Vote, error) {
 	threshold := s.state.threshold()
 
-	var blocks map[common.Hash]uint32
-	var err error
+	var (
+		blocks map[common.Hash]uint32
+		err    error
+	)
 
 	for {
 		blocks, err = s.getPossibleSelectedBlocks(prevote, threshold)
diff --git a/lib/grandpa/message_handler.go b/lib/grandpa/message_handler.go
diff --git a/lib/grandpa/vote_message.go b/lib/grandpa/vote_message.go

Original file line number	Diff line number	Diff line change
`@@ -343,7 +343,7 @@ func (s *Service) sentBlockIntervalTelemetry() {`
`343`	`343`	`}`
`344`	`344`	`bestHash := best.Hash()`
`345`	`345`
`346`		`- finalized, err := s.blockState.GetFinalisedHeader(0, 0) //nolint`
	`346`	`+ finalized, err := s.blockState.GetHighestFinalisedHeader() //nolint`
`347`	`347`	`if err != nil {`
`348`	`348`	`continue`
`349`	`349`	`}`
`@@ -519,16 +519,21 @@ func (s *Service) GossipMessage(msg NotificationsMessage) {`
`519`	`519`	`func (s *Service) SendMessage(to peer.ID, msg NotificationsMessage) error {`
`520`	`520`	`s.notificationsMu.Lock()`
`521`	`521`	`defer s.notificationsMu.Unlock()`
	`522`	`+`
`522`	`523`	`for msgID, prtl := range s.notificationsProtocols {`
`523`		`- if msg.Type() != msgID \|\| prtl == nil {`
	`524`	`+ if msg.Type() != msgID {`
`524`	`525`	`continue`
`525`	`526`	`}`
	`527`	`+`
`526`	`528`	`hs, err := prtl.getHandshake()`
`527`	`529`	`if err != nil {`
`528`	`530`	`return err`
`529`	`531`	`}`
	`532`	`+`
`530`	`533`	`s.sendData(to, hs, prtl, msg)`
	`534`	`+ return nil`
`531`	`535`	`}`
	`536`	`+`
`532`	`537`	`return errors.New("message not supported by any notifications protocol")`
`533`	`538`	`}`
`534`	`539`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ type BlockState interface {`
`29`	`29`	`BestBlockNumber() (*big.Int, error)`
`30`	`30`	`GenesisHash() common.Hash`
`31`	`31`	`HasBlockBody(common.Hash) (bool, error)`
`32`		`- GetFinalisedHeader(round, setID uint64) (*types.Header, error)`
	`32`	`+ GetHighestFinalisedHeader() (*types.Header, error)`
`33`	`33`	`GetHashByNumber(num *big.Int) (common.Hash, error)`
`34`	`34`	`}`
`35`	`35`
Original file line number	Diff line number	Diff line change
`@@ -351,7 +351,7 @@ func (q *syncQueue) benchmark() {`
`351`	`351`	`goal := atomic.LoadInt64(&q.goal)`
`352`	`352`
`353`	`353`	`if before.Number.Int64() >= goal {`
`354`		`- finalised, err := q.s.blockState.GetFinalisedHeader(0, 0) //nolint`
	`354`	`+ finalised, err := q.s.blockState.GetHighestFinalisedHeader() //nolint`
`355`	`355`	`if err != nil {`
`356`	`356`	`continue`
`357`	`357`	`}`
`@@ -767,7 +767,7 @@ func (q syncQueue) handleBlockJustification(data []types.BlockData) {`
`767`	`767`	`}`
`768`	`768`
`769`	`769`	`func (q syncQueue) handleBlockData(data []types.BlockData) {`
`770`		`- finalised, err := q.s.blockState.GetFinalisedHeader(0, 0)`
	`770`	`+ finalised, err := q.s.blockState.GetHighestFinalisedHeader()`
`771`	`771`	`if err != nil {`
`772`	`772`	`panic(err) // this should never happen`
`773`	`773`	`}`
`@@ -815,7 +815,7 @@ func (q syncQueue) handleBlockDataFailure(idx int, err error, data []types.Blo`
`815`	`815`	`logger.Warn("failed to handle block data", "failed on block", q.currStart+int64(idx), "error", err)`
`816`	`816`
`817`	`817`	`if errors.Is(err, chaindb.ErrKeyNotFound) \|\| errors.Is(err, blocktree.ErrParentNotFound) {`
`818`		`- finalised, err := q.s.blockState.GetFinalisedHeader(0, 0)`
	`818`	`+ finalised, err := q.s.blockState.GetHighestFinalisedHeader()`
`819`	`819`	`if err != nil {`
`820`	`820`	`panic(err)`
`821`	`821`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ type Verifier interface {`
`78`	`78`
`79`	`79`	`// FinalityGadget implements justification verification functionality`
`80`	`80`	`type FinalityGadget interface {`
`81`		`- VerifyBlockJustification([]byte) error`
	`81`	`+ VerifyBlockJustification(common.Hash, []byte) error`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`// BlockImportHandler is the interface for the handler of newly imported blocks`