You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
684 lines
18 KiB
684 lines
18 KiB
package consensus
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
|
|
cstypes "github.com/tendermint/tendermint/internal/consensus/types"
|
|
"github.com/tendermint/tendermint/libs/bits"
|
|
tmjson "github.com/tendermint/tendermint/libs/json"
|
|
tmmath "github.com/tendermint/tendermint/libs/math"
|
|
tmcons "github.com/tendermint/tendermint/proto/tendermint/consensus"
|
|
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
|
|
"github.com/tendermint/tendermint/types"
|
|
)
|
|
|
|
// Message defines an interface that the consensus domain types implement. When
|
|
// a proto message is received on a consensus p2p Channel, it is wrapped and then
|
|
// converted to a Message via MsgFromProto.
|
|
type Message interface {
|
|
ValidateBasic() error
|
|
}
|
|
|
|
func init() {
|
|
tmjson.RegisterType(&NewRoundStepMessage{}, "tendermint/NewRoundStepMessage")
|
|
tmjson.RegisterType(&NewValidBlockMessage{}, "tendermint/NewValidBlockMessage")
|
|
tmjson.RegisterType(&ProposalMessage{}, "tendermint/Proposal")
|
|
tmjson.RegisterType(&ProposalPOLMessage{}, "tendermint/ProposalPOL")
|
|
tmjson.RegisterType(&BlockPartMessage{}, "tendermint/BlockPart")
|
|
tmjson.RegisterType(&VoteMessage{}, "tendermint/Vote")
|
|
tmjson.RegisterType(&HasVoteMessage{}, "tendermint/HasVote")
|
|
tmjson.RegisterType(&VoteSetMaj23Message{}, "tendermint/VoteSetMaj23")
|
|
tmjson.RegisterType(&VoteSetBitsMessage{}, "tendermint/VoteSetBits")
|
|
}
|
|
|
|
// NewRoundStepMessage is sent for every step taken in the ConsensusState.
|
|
// For every height/round/step transition
|
|
type NewRoundStepMessage struct {
|
|
Height int64
|
|
Round int32
|
|
Step cstypes.RoundStepType
|
|
SecondsSinceStartTime int64
|
|
LastCommitRound int32
|
|
}
|
|
|
|
// ValidateBasic performs basic validation.
|
|
func (m *NewRoundStepMessage) ValidateBasic() error {
|
|
if m.Height < 0 {
|
|
return errors.New("negative Height")
|
|
}
|
|
if m.Round < 0 {
|
|
return errors.New("negative Round")
|
|
}
|
|
if !m.Step.IsValid() {
|
|
return errors.New("invalid Step")
|
|
}
|
|
|
|
// NOTE: SecondsSinceStartTime may be negative
|
|
|
|
// LastCommitRound will be -1 for the initial height, but we don't know what height this is
|
|
// since it can be specified in genesis. The reactor will have to validate this via
|
|
// ValidateHeight().
|
|
if m.LastCommitRound < -1 {
|
|
return errors.New("invalid LastCommitRound (cannot be < -1)")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// ValidateHeight validates the height given the chain's initial height.
|
|
func (m *NewRoundStepMessage) ValidateHeight(initialHeight int64) error {
|
|
if m.Height < initialHeight {
|
|
return fmt.Errorf("invalid Height %v (lower than initial height %v)",
|
|
m.Height, initialHeight)
|
|
}
|
|
if m.Height == initialHeight && m.LastCommitRound != -1 {
|
|
return fmt.Errorf("invalid LastCommitRound %v (must be -1 for initial height %v)",
|
|
m.LastCommitRound, initialHeight)
|
|
}
|
|
if m.Height > initialHeight && m.LastCommitRound < 0 {
|
|
return fmt.Errorf("LastCommitRound can only be negative for initial height %v",
|
|
initialHeight)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// String returns a string representation.
|
|
func (m *NewRoundStepMessage) String() string {
|
|
return fmt.Sprintf("[NewRoundStep H:%v R:%v S:%v LCR:%v]",
|
|
m.Height, m.Round, m.Step, m.LastCommitRound)
|
|
}
|
|
|
|
// NewValidBlockMessage is sent when a validator observes a valid block B in some round r,
|
|
// i.e., there is a Proposal for block B and 2/3+ prevotes for the block B in the round r.
|
|
// In case the block is also committed, then IsCommit flag is set to true.
|
|
type NewValidBlockMessage struct {
|
|
Height int64
|
|
Round int32
|
|
BlockPartSetHeader types.PartSetHeader
|
|
BlockParts *bits.BitArray
|
|
IsCommit bool
|
|
}
|
|
|
|
// ValidateBasic performs basic validation.
|
|
func (m *NewValidBlockMessage) ValidateBasic() error {
|
|
if m.Height < 0 {
|
|
return errors.New("negative Height")
|
|
}
|
|
if m.Round < 0 {
|
|
return errors.New("negative Round")
|
|
}
|
|
if err := m.BlockPartSetHeader.ValidateBasic(); err != nil {
|
|
return fmt.Errorf("wrong BlockPartSetHeader: %w", err)
|
|
}
|
|
if m.BlockParts.Size() == 0 {
|
|
return errors.New("empty blockParts")
|
|
}
|
|
if m.BlockParts.Size() != int(m.BlockPartSetHeader.Total) {
|
|
return fmt.Errorf("blockParts bit array size %d not equal to BlockPartSetHeader.Total %d",
|
|
m.BlockParts.Size(),
|
|
m.BlockPartSetHeader.Total)
|
|
}
|
|
if m.BlockParts.Size() > int(types.MaxBlockPartsCount) {
|
|
return fmt.Errorf("blockParts bit array is too big: %d, max: %d", m.BlockParts.Size(), types.MaxBlockPartsCount)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// String returns a string representation.
|
|
func (m *NewValidBlockMessage) String() string {
|
|
return fmt.Sprintf("[ValidBlockMessage H:%v R:%v BP:%v BA:%v IsCommit:%v]",
|
|
m.Height, m.Round, m.BlockPartSetHeader, m.BlockParts, m.IsCommit)
|
|
}
|
|
|
|
// ProposalMessage is sent when a new block is proposed.
|
|
type ProposalMessage struct {
|
|
Proposal *types.Proposal
|
|
}
|
|
|
|
// ValidateBasic performs basic validation.
|
|
func (m *ProposalMessage) ValidateBasic() error {
|
|
return m.Proposal.ValidateBasic()
|
|
}
|
|
|
|
// String returns a string representation.
|
|
func (m *ProposalMessage) String() string {
|
|
return fmt.Sprintf("[Proposal %v]", m.Proposal)
|
|
}
|
|
|
|
// ProposalPOLMessage is sent when a previous proposal is re-proposed.
|
|
type ProposalPOLMessage struct {
|
|
Height int64
|
|
ProposalPOLRound int32
|
|
ProposalPOL *bits.BitArray
|
|
}
|
|
|
|
// ValidateBasic performs basic validation.
|
|
func (m *ProposalPOLMessage) ValidateBasic() error {
|
|
if m.Height < 0 {
|
|
return errors.New("negative Height")
|
|
}
|
|
if m.ProposalPOLRound < 0 {
|
|
return errors.New("negative ProposalPOLRound")
|
|
}
|
|
if m.ProposalPOL.Size() == 0 {
|
|
return errors.New("empty ProposalPOL bit array")
|
|
}
|
|
if m.ProposalPOL.Size() > types.MaxVotesCount {
|
|
return fmt.Errorf("proposalPOL bit array is too big: %d, max: %d", m.ProposalPOL.Size(), types.MaxVotesCount)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// String returns a string representation.
|
|
func (m *ProposalPOLMessage) String() string {
|
|
return fmt.Sprintf("[ProposalPOL H:%v POLR:%v POL:%v]", m.Height, m.ProposalPOLRound, m.ProposalPOL)
|
|
}
|
|
|
|
// BlockPartMessage is sent when gossipping a piece of the proposed block.
|
|
type BlockPartMessage struct {
|
|
Height int64
|
|
Round int32
|
|
Part *types.Part
|
|
}
|
|
|
|
// ValidateBasic performs basic validation.
|
|
func (m *BlockPartMessage) ValidateBasic() error {
|
|
if m.Height < 0 {
|
|
return errors.New("negative Height")
|
|
}
|
|
if m.Round < 0 {
|
|
return errors.New("negative Round")
|
|
}
|
|
if err := m.Part.ValidateBasic(); err != nil {
|
|
return fmt.Errorf("wrong Part: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// String returns a string representation.
|
|
func (m *BlockPartMessage) String() string {
|
|
return fmt.Sprintf("[BlockPart H:%v R:%v P:%v]", m.Height, m.Round, m.Part)
|
|
}
|
|
|
|
// VoteMessage is sent when voting for a proposal (or lack thereof).
|
|
type VoteMessage struct {
|
|
Vote *types.Vote
|
|
}
|
|
|
|
// ValidateBasic performs basic validation.
|
|
func (m *VoteMessage) ValidateBasic() error {
|
|
return m.Vote.ValidateBasic()
|
|
}
|
|
|
|
// String returns a string representation.
|
|
func (m *VoteMessage) String() string {
|
|
return fmt.Sprintf("[Vote %v]", m.Vote)
|
|
}
|
|
|
|
// HasVoteMessage is sent to indicate that a particular vote has been received.
|
|
type HasVoteMessage struct {
|
|
Height int64
|
|
Round int32
|
|
Type tmproto.SignedMsgType
|
|
Index int32
|
|
}
|
|
|
|
// ValidateBasic performs basic validation.
|
|
func (m *HasVoteMessage) ValidateBasic() error {
|
|
if m.Height < 0 {
|
|
return errors.New("negative Height")
|
|
}
|
|
if m.Round < 0 {
|
|
return errors.New("negative Round")
|
|
}
|
|
if !types.IsVoteTypeValid(m.Type) {
|
|
return errors.New("invalid Type")
|
|
}
|
|
if m.Index < 0 {
|
|
return errors.New("negative Index")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// String returns a string representation.
|
|
func (m *HasVoteMessage) String() string {
|
|
return fmt.Sprintf("[HasVote VI:%v V:{%v/%02d/%v}]", m.Index, m.Height, m.Round, m.Type)
|
|
}
|
|
|
|
// VoteSetMaj23Message is sent to indicate that a given BlockID has seen +2/3 votes.
|
|
type VoteSetMaj23Message struct {
|
|
Height int64
|
|
Round int32
|
|
Type tmproto.SignedMsgType
|
|
BlockID types.BlockID
|
|
}
|
|
|
|
// ValidateBasic performs basic validation.
|
|
func (m *VoteSetMaj23Message) ValidateBasic() error {
|
|
if m.Height < 0 {
|
|
return errors.New("negative Height")
|
|
}
|
|
if m.Round < 0 {
|
|
return errors.New("negative Round")
|
|
}
|
|
if !types.IsVoteTypeValid(m.Type) {
|
|
return errors.New("invalid Type")
|
|
}
|
|
if err := m.BlockID.ValidateBasic(); err != nil {
|
|
return fmt.Errorf("wrong BlockID: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// String returns a string representation.
|
|
func (m *VoteSetMaj23Message) String() string {
|
|
return fmt.Sprintf("[VSM23 %v/%02d/%v %v]", m.Height, m.Round, m.Type, m.BlockID)
|
|
}
|
|
|
|
// VoteSetBitsMessage is sent to communicate the bit-array of votes seen for the
|
|
// BlockID.
|
|
type VoteSetBitsMessage struct {
|
|
Height int64
|
|
Round int32
|
|
Type tmproto.SignedMsgType
|
|
BlockID types.BlockID
|
|
Votes *bits.BitArray
|
|
}
|
|
|
|
// ValidateBasic performs basic validation.
|
|
func (m *VoteSetBitsMessage) ValidateBasic() error {
|
|
if m.Height < 0 {
|
|
return errors.New("negative Height")
|
|
}
|
|
if !types.IsVoteTypeValid(m.Type) {
|
|
return errors.New("invalid Type")
|
|
}
|
|
if err := m.BlockID.ValidateBasic(); err != nil {
|
|
return fmt.Errorf("wrong BlockID: %w", err)
|
|
}
|
|
|
|
// NOTE: Votes.Size() can be zero if the node does not have any
|
|
if m.Votes.Size() > types.MaxVotesCount {
|
|
return fmt.Errorf("votes bit array is too big: %d, max: %d", m.Votes.Size(), types.MaxVotesCount)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// String returns a string representation.
|
|
func (m *VoteSetBitsMessage) String() string {
|
|
return fmt.Sprintf("[VSB %v/%02d/%v %v %v]", m.Height, m.Round, m.Type, m.BlockID, m.Votes)
|
|
}
|
|
|
|
// MsgToProto takes a consensus message type and returns the proto defined
|
|
// consensus message.
|
|
//
|
|
// TODO: This needs to be removed, but WALToProto depends on this.
|
|
func MsgToProto(msg Message) (*tmcons.Message, error) {
|
|
if msg == nil {
|
|
return nil, errors.New("consensus: message is nil")
|
|
}
|
|
var pb tmcons.Message
|
|
|
|
switch msg := msg.(type) {
|
|
case *NewRoundStepMessage:
|
|
pb = tmcons.Message{
|
|
Sum: &tmcons.Message_NewRoundStep{
|
|
NewRoundStep: &tmcons.NewRoundStep{
|
|
Height: msg.Height,
|
|
Round: msg.Round,
|
|
Step: uint32(msg.Step),
|
|
SecondsSinceStartTime: msg.SecondsSinceStartTime,
|
|
LastCommitRound: msg.LastCommitRound,
|
|
},
|
|
},
|
|
}
|
|
case *NewValidBlockMessage:
|
|
pbPartSetHeader := msg.BlockPartSetHeader.ToProto()
|
|
pbBits := msg.BlockParts.ToProto()
|
|
pb = tmcons.Message{
|
|
Sum: &tmcons.Message_NewValidBlock{
|
|
NewValidBlock: &tmcons.NewValidBlock{
|
|
Height: msg.Height,
|
|
Round: msg.Round,
|
|
BlockPartSetHeader: pbPartSetHeader,
|
|
BlockParts: pbBits,
|
|
IsCommit: msg.IsCommit,
|
|
},
|
|
},
|
|
}
|
|
case *ProposalMessage:
|
|
pbP := msg.Proposal.ToProto()
|
|
pb = tmcons.Message{
|
|
Sum: &tmcons.Message_Proposal{
|
|
Proposal: &tmcons.Proposal{
|
|
Proposal: *pbP,
|
|
},
|
|
},
|
|
}
|
|
case *ProposalPOLMessage:
|
|
pbBits := msg.ProposalPOL.ToProto()
|
|
pb = tmcons.Message{
|
|
Sum: &tmcons.Message_ProposalPol{
|
|
ProposalPol: &tmcons.ProposalPOL{
|
|
Height: msg.Height,
|
|
ProposalPolRound: msg.ProposalPOLRound,
|
|
ProposalPol: *pbBits,
|
|
},
|
|
},
|
|
}
|
|
case *BlockPartMessage:
|
|
parts, err := msg.Part.ToProto()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("msg to proto error: %w", err)
|
|
}
|
|
pb = tmcons.Message{
|
|
Sum: &tmcons.Message_BlockPart{
|
|
BlockPart: &tmcons.BlockPart{
|
|
Height: msg.Height,
|
|
Round: msg.Round,
|
|
Part: *parts,
|
|
},
|
|
},
|
|
}
|
|
case *VoteMessage:
|
|
vote := msg.Vote.ToProto()
|
|
pb = tmcons.Message{
|
|
Sum: &tmcons.Message_Vote{
|
|
Vote: &tmcons.Vote{
|
|
Vote: vote,
|
|
},
|
|
},
|
|
}
|
|
case *HasVoteMessage:
|
|
pb = tmcons.Message{
|
|
Sum: &tmcons.Message_HasVote{
|
|
HasVote: &tmcons.HasVote{
|
|
Height: msg.Height,
|
|
Round: msg.Round,
|
|
Type: msg.Type,
|
|
Index: msg.Index,
|
|
},
|
|
},
|
|
}
|
|
case *VoteSetMaj23Message:
|
|
bi := msg.BlockID.ToProto()
|
|
pb = tmcons.Message{
|
|
Sum: &tmcons.Message_VoteSetMaj23{
|
|
VoteSetMaj23: &tmcons.VoteSetMaj23{
|
|
Height: msg.Height,
|
|
Round: msg.Round,
|
|
Type: msg.Type,
|
|
BlockID: bi,
|
|
},
|
|
},
|
|
}
|
|
case *VoteSetBitsMessage:
|
|
bi := msg.BlockID.ToProto()
|
|
bits := msg.Votes.ToProto()
|
|
|
|
vsb := &tmcons.Message_VoteSetBits{
|
|
VoteSetBits: &tmcons.VoteSetBits{
|
|
Height: msg.Height,
|
|
Round: msg.Round,
|
|
Type: msg.Type,
|
|
BlockID: bi,
|
|
},
|
|
}
|
|
|
|
if bits != nil {
|
|
vsb.VoteSetBits.Votes = *bits
|
|
}
|
|
|
|
pb = tmcons.Message{
|
|
Sum: vsb,
|
|
}
|
|
|
|
default:
|
|
return nil, fmt.Errorf("consensus: message not recognized: %T", msg)
|
|
}
|
|
|
|
return &pb, nil
|
|
}
|
|
|
|
// MsgFromProto takes a consensus proto message and returns the native go type.
|
|
func MsgFromProto(msg *tmcons.Message) (Message, error) {
|
|
if msg == nil {
|
|
return nil, errors.New("consensus: nil message")
|
|
}
|
|
var pb Message
|
|
|
|
switch msg := msg.Sum.(type) {
|
|
case *tmcons.Message_NewRoundStep:
|
|
rs, err := tmmath.SafeConvertUint8(int64(msg.NewRoundStep.Step))
|
|
// deny message based on possible overflow
|
|
if err != nil {
|
|
return nil, fmt.Errorf("denying message due to possible overflow: %w", err)
|
|
}
|
|
pb = &NewRoundStepMessage{
|
|
Height: msg.NewRoundStep.Height,
|
|
Round: msg.NewRoundStep.Round,
|
|
Step: cstypes.RoundStepType(rs),
|
|
SecondsSinceStartTime: msg.NewRoundStep.SecondsSinceStartTime,
|
|
LastCommitRound: msg.NewRoundStep.LastCommitRound,
|
|
}
|
|
case *tmcons.Message_NewValidBlock:
|
|
pbPartSetHeader, err := types.PartSetHeaderFromProto(&msg.NewValidBlock.BlockPartSetHeader)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("parts header to proto error: %w", err)
|
|
}
|
|
|
|
pbBits := new(bits.BitArray)
|
|
err = pbBits.FromProto(msg.NewValidBlock.BlockParts)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("parts to proto error: %w", err)
|
|
}
|
|
|
|
pb = &NewValidBlockMessage{
|
|
Height: msg.NewValidBlock.Height,
|
|
Round: msg.NewValidBlock.Round,
|
|
BlockPartSetHeader: *pbPartSetHeader,
|
|
BlockParts: pbBits,
|
|
IsCommit: msg.NewValidBlock.IsCommit,
|
|
}
|
|
case *tmcons.Message_Proposal:
|
|
pbP, err := types.ProposalFromProto(&msg.Proposal.Proposal)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("proposal msg to proto error: %w", err)
|
|
}
|
|
|
|
pb = &ProposalMessage{
|
|
Proposal: pbP,
|
|
}
|
|
case *tmcons.Message_ProposalPol:
|
|
pbBits := new(bits.BitArray)
|
|
err := pbBits.FromProto(&msg.ProposalPol.ProposalPol)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("proposal PoL to proto error: %w", err)
|
|
}
|
|
pb = &ProposalPOLMessage{
|
|
Height: msg.ProposalPol.Height,
|
|
ProposalPOLRound: msg.ProposalPol.ProposalPolRound,
|
|
ProposalPOL: pbBits,
|
|
}
|
|
case *tmcons.Message_BlockPart:
|
|
parts, err := types.PartFromProto(&msg.BlockPart.Part)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("blockpart msg to proto error: %w", err)
|
|
}
|
|
pb = &BlockPartMessage{
|
|
Height: msg.BlockPart.Height,
|
|
Round: msg.BlockPart.Round,
|
|
Part: parts,
|
|
}
|
|
case *tmcons.Message_Vote:
|
|
vote, err := types.VoteFromProto(msg.Vote.Vote)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("vote msg to proto error: %w", err)
|
|
}
|
|
|
|
pb = &VoteMessage{
|
|
Vote: vote,
|
|
}
|
|
case *tmcons.Message_HasVote:
|
|
pb = &HasVoteMessage{
|
|
Height: msg.HasVote.Height,
|
|
Round: msg.HasVote.Round,
|
|
Type: msg.HasVote.Type,
|
|
Index: msg.HasVote.Index,
|
|
}
|
|
case *tmcons.Message_VoteSetMaj23:
|
|
bi, err := types.BlockIDFromProto(&msg.VoteSetMaj23.BlockID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("voteSetMaj23 msg to proto error: %w", err)
|
|
}
|
|
pb = &VoteSetMaj23Message{
|
|
Height: msg.VoteSetMaj23.Height,
|
|
Round: msg.VoteSetMaj23.Round,
|
|
Type: msg.VoteSetMaj23.Type,
|
|
BlockID: *bi,
|
|
}
|
|
case *tmcons.Message_VoteSetBits:
|
|
bi, err := types.BlockIDFromProto(&msg.VoteSetBits.BlockID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("block ID to proto error: %w", err)
|
|
}
|
|
bits := new(bits.BitArray)
|
|
err = bits.FromProto(&msg.VoteSetBits.Votes)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("votes to proto error: %w", err)
|
|
}
|
|
|
|
pb = &VoteSetBitsMessage{
|
|
Height: msg.VoteSetBits.Height,
|
|
Round: msg.VoteSetBits.Round,
|
|
Type: msg.VoteSetBits.Type,
|
|
BlockID: *bi,
|
|
Votes: bits,
|
|
}
|
|
default:
|
|
return nil, fmt.Errorf("consensus: message not recognized: %T", msg)
|
|
}
|
|
|
|
if err := pb.ValidateBasic(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return pb, nil
|
|
}
|
|
|
|
// WALToProto takes a WAL message and return a proto walMessage and error.
|
|
func WALToProto(msg WALMessage) (*tmcons.WALMessage, error) {
|
|
var pb tmcons.WALMessage
|
|
|
|
switch msg := msg.(type) {
|
|
case types.EventDataRoundState:
|
|
pb = tmcons.WALMessage{
|
|
Sum: &tmcons.WALMessage_EventDataRoundState{
|
|
EventDataRoundState: &tmproto.EventDataRoundState{
|
|
Height: msg.Height,
|
|
Round: msg.Round,
|
|
Step: msg.Step,
|
|
},
|
|
},
|
|
}
|
|
case msgInfo:
|
|
consMsg, err := MsgToProto(msg.Msg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pb = tmcons.WALMessage{
|
|
Sum: &tmcons.WALMessage_MsgInfo{
|
|
MsgInfo: &tmcons.MsgInfo{
|
|
Msg: *consMsg,
|
|
PeerID: string(msg.PeerID),
|
|
},
|
|
},
|
|
}
|
|
|
|
case timeoutInfo:
|
|
pb = tmcons.WALMessage{
|
|
Sum: &tmcons.WALMessage_TimeoutInfo{
|
|
TimeoutInfo: &tmcons.TimeoutInfo{
|
|
Duration: msg.Duration,
|
|
Height: msg.Height,
|
|
Round: msg.Round,
|
|
Step: uint32(msg.Step),
|
|
},
|
|
},
|
|
}
|
|
|
|
case EndHeightMessage:
|
|
pb = tmcons.WALMessage{
|
|
Sum: &tmcons.WALMessage_EndHeight{
|
|
EndHeight: &tmcons.EndHeight{
|
|
Height: msg.Height,
|
|
},
|
|
},
|
|
}
|
|
|
|
default:
|
|
return nil, fmt.Errorf("to proto: wal message not recognized: %T", msg)
|
|
}
|
|
|
|
return &pb, nil
|
|
}
|
|
|
|
// WALFromProto takes a proto wal message and return a consensus walMessage and
|
|
// error.
|
|
func WALFromProto(msg *tmcons.WALMessage) (WALMessage, error) {
|
|
if msg == nil {
|
|
return nil, errors.New("nil WAL message")
|
|
}
|
|
|
|
var pb WALMessage
|
|
|
|
switch msg := msg.Sum.(type) {
|
|
case *tmcons.WALMessage_EventDataRoundState:
|
|
pb = types.EventDataRoundState{
|
|
Height: msg.EventDataRoundState.Height,
|
|
Round: msg.EventDataRoundState.Round,
|
|
Step: msg.EventDataRoundState.Step,
|
|
}
|
|
|
|
case *tmcons.WALMessage_MsgInfo:
|
|
walMsg, err := MsgFromProto(&msg.MsgInfo.Msg)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("msgInfo from proto error: %w", err)
|
|
}
|
|
pb = msgInfo{
|
|
Msg: walMsg,
|
|
PeerID: types.NodeID(msg.MsgInfo.PeerID),
|
|
}
|
|
|
|
case *tmcons.WALMessage_TimeoutInfo:
|
|
tis, err := tmmath.SafeConvertUint8(int64(msg.TimeoutInfo.Step))
|
|
// deny message based on possible overflow
|
|
if err != nil {
|
|
return nil, fmt.Errorf("denying message due to possible overflow: %w", err)
|
|
}
|
|
|
|
pb = timeoutInfo{
|
|
Duration: msg.TimeoutInfo.Duration,
|
|
Height: msg.TimeoutInfo.Height,
|
|
Round: msg.TimeoutInfo.Round,
|
|
Step: cstypes.RoundStepType(tis),
|
|
}
|
|
|
|
return pb, nil
|
|
|
|
case *tmcons.WALMessage_EndHeight:
|
|
pb := EndHeightMessage{
|
|
Height: msg.EndHeight.Height,
|
|
}
|
|
|
|
return pb, nil
|
|
|
|
default:
|
|
return nil, fmt.Errorf("from proto: wal message not recognized: %T", msg)
|
|
}
|
|
|
|
return pb, nil
|
|
}
|