diff --git a/CHANGELOG.md b/CHANGELOG.md index 2c1503598..9de1aa295 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,28 +1,20 @@ # Changelog -## Roadmap +## 0.19.3 (May 14th, 2018) -BREAKING CHANGES: -- Better support for injecting randomness -- Upgrade consensus for more real-time use of evidence +FEATURES -FEATURES: -- Use the chain as its own CA for nodes and validators -- Tooling to run multiple blockchains/apps, possibly in a single process -- State syncing (without transaction replay) -- Add authentication and rate-limitting to the RPC +- [rpc] New `/consensus_state` returns just the votes seen at the current height -IMPROVEMENTS: -- Improve subtleties around mempool caching and logic -- Consensus optimizations: - - cache block parts for faster agreement after round changes - - propagate block parts rarest first -- Better testing of the consensus state machine (ie. use a DSL) -- Auto compiled serialization/deserialization code instead of go-wire reflection +IMPROVEMENTS -BUG FIXES: -- Graceful handling/recovery for apps that have non-determinism or fail to halt -- Graceful handling/recovery for violations of safety, or liveness +- [rpc] Add stringified votes and fraction of power voted to `/dump_consensus_state` +- [rpc] Add PeerStateStats to `/dump_consensus_state` + +BUG FIXES + +- [cmd] Set GenesisTime during `tendermint init` +- [consensus] fix ValidBlock rules ## 0.19.2 (April 30th, 2018) diff --git a/DOCKER/Dockerfile.testing b/DOCKER/Dockerfile.testing new file mode 100644 index 000000000..3e281dce6 --- /dev/null +++ b/DOCKER/Dockerfile.testing @@ -0,0 +1,18 @@ +FROM golang:1.10.1 + + +# Grab deps (jq, hexdump, xxd, killall) +RUN apt-get update && \ + apt-get install -y --no-install-recommends \ + jq bsdmainutils vim-common psmisc netcat + +# Add testing deps for curl +RUN echo 'deb http://httpredir.debian.org/debian testing main non-free contrib' >> /etc/apt/sources.list && \ + apt-get update && \ + apt-get install -y --no-install-recommends curl + +VOLUME /go + +EXPOSE 46656 +EXPOSE 46657 + diff --git a/DOCKER/Makefile b/DOCKER/Makefile index 10c972502..32510ebbb 100644 --- a/DOCKER/Makefile +++ b/DOCKER/Makefile @@ -7,6 +7,9 @@ push: build_develop: docker build -t "tendermint/tendermint:develop" -f Dockerfile.develop . +build_testing: + docker build --tag tendermint/testing -f ./Dockerfile.testing . + push_develop: docker push "tendermint/tendermint:develop" diff --git a/Gopkg.lock b/Gopkg.lock index cfb6f6c0b..8280148c9 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -254,8 +254,8 @@ [[projects]] name = "github.com/tendermint/go-amino" packages = ["."] - revision = "3668c02a8feace009f80754a5e5a8541e5d7b996" - version = "0.9.8" + revision = "ed62928576cfcaf887209dc96142cd79cdfff389" + version = "0.9.9" [[projects]] name = "github.com/tendermint/go-crypto" @@ -285,8 +285,8 @@ "pubsub/query", "test" ] - revision = "d94e312673e16a11ea55d742cefb3e331228f898" - version = "v0.8.2" + revision = "cc5f287c4798ffe88c04d02df219ecb6932080fd" + version = "v0.8.3-rc0" [[projects]] branch = "master" @@ -301,7 +301,7 @@ "ripemd160", "salsa20/salsa" ] - revision = "b49d69b5da943f7ef3c9cf91c8777c1f78a0cc3c" + revision = "b0697eccbea9adec5b7ba8008f4c33d98d733388" [[projects]] branch = "master" @@ -384,6 +384,6 @@ [solve-meta] analyzer-name = "dep" analyzer-version = 1 - inputs-digest = "94cb2543199b0f4b6e9ac0e5b6469bdb77391da1c9f79f5b9792d7af936008ff" + inputs-digest = "52a0dcbebdf8714612444914cfce59a3af8c47c4453a2d43c4ccc5ff1a91d8ea" solver-name = "gps-cdcl" solver-version = 1 diff --git a/Gopkg.toml b/Gopkg.toml index 4bf45ecd8..741979774 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -79,11 +79,11 @@ [[constraint]] name = "github.com/tendermint/go-amino" - version = "~0.9.7" + version = "0.9.9" -[[constraint]] +[[override]] name = "github.com/tendermint/tmlibs" - version = "~0.8.2-rc0" + version = "~0.8.3-rc0" [[constraint]] name = "google.golang.org/grpc" diff --git a/benchmarks/codec_test.go b/benchmarks/codec_test.go index d8e4bc82c..9acafce71 100644 --- a/benchmarks/codec_test.go +++ b/benchmarks/codec_test.go @@ -32,7 +32,7 @@ func BenchmarkEncodeStatusWire(b *testing.B) { LatestBlockTime: time.Unix(0, 1234), }, ValidatorInfo: ctypes.ValidatorInfo{ - PubKey: nodeKey.PubKey(), + PubKey: nodeKey.PubKey(), }, } b.StartTimer() diff --git a/cmd/tendermint/commands/init.go b/cmd/tendermint/commands/init.go index 32559fa5c..430a6c7c9 100644 --- a/cmd/tendermint/commands/init.go +++ b/cmd/tendermint/commands/init.go @@ -1,6 +1,8 @@ package commands import ( + "time" + "github.com/spf13/cobra" cfg "github.com/tendermint/tendermint/config" @@ -50,7 +52,8 @@ func initFilesWithConfig(config *cfg.Config) error { logger.Info("Found genesis file", "path", genFile) } else { genDoc := types.GenesisDoc{ - ChainID: cmn.Fmt("test-chain-%v", cmn.RandStr(6)), + ChainID: cmn.Fmt("test-chain-%v", cmn.RandStr(6)), + GenesisTime: time.Now(), } genDoc.Validators = []types.GenesisValidator{{ PubKey: pv.GetPubKey(), diff --git a/cmd/tendermint/commands/show_node_id.go b/cmd/tendermint/commands/show_node_id.go index 1d94933ef..02ab1a9bb 100644 --- a/cmd/tendermint/commands/show_node_id.go +++ b/cmd/tendermint/commands/show_node_id.go @@ -6,7 +6,6 @@ import ( "github.com/spf13/cobra" "github.com/tendermint/tendermint/p2p" - ) // ShowNodeIDCmd dumps node's ID to the standard output. diff --git a/cmd/tendermint/commands/show_validator.go b/cmd/tendermint/commands/show_validator.go index 6ead4bada..b354683b4 100644 --- a/cmd/tendermint/commands/show_validator.go +++ b/cmd/tendermint/commands/show_validator.go @@ -2,6 +2,7 @@ package commands import ( "fmt" + "github.com/spf13/cobra" privval "github.com/tendermint/tendermint/types/priv_validator" diff --git a/consensus/reactor.go b/consensus/reactor.go index 385e8d867..9535108c7 100644 --- a/consensus/reactor.go +++ b/consensus/reactor.go @@ -210,7 +210,7 @@ func (conR *ConsensusReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) return } // Peer claims to have a maj23 for some BlockID at H,R,S, - err := votes.SetPeerMaj23(msg.Round, msg.Type, ps.Peer.ID(), msg.BlockID) + err := votes.SetPeerMaj23(msg.Round, msg.Type, ps.peer.ID(), msg.BlockID) if err != nil { conR.Switch.StopPeerForError(src, err) return @@ -696,20 +696,37 @@ func (conR *ConsensusReactor) gossipVotesForHeight(logger log.Logger, rs *cstype return true } } + // If there are POL prevotes to send... + if prs.Step <= cstypes.RoundStepPropose && prs.Round != -1 && prs.Round <= rs.Round && prs.ProposalPOLRound != -1 { + if polPrevotes := rs.Votes.Prevotes(prs.ProposalPOLRound); polPrevotes != nil { + if ps.PickSendVote(polPrevotes) { + logger.Debug("Picked rs.Prevotes(prs.ProposalPOLRound) to send", + "round", prs.ProposalPOLRound) + return true + } + } + } // If there are prevotes to send... - if prs.Step <= cstypes.RoundStepPrevote && prs.Round != -1 && prs.Round <= rs.Round { + if prs.Step <= cstypes.RoundStepPrevoteWait && prs.Round != -1 && prs.Round <= rs.Round { if ps.PickSendVote(rs.Votes.Prevotes(prs.Round)) { logger.Debug("Picked rs.Prevotes(prs.Round) to send", "round", prs.Round) return true } } // If there are precommits to send... - if prs.Step <= cstypes.RoundStepPrecommit && prs.Round != -1 && prs.Round <= rs.Round { + if prs.Step <= cstypes.RoundStepPrecommitWait && prs.Round != -1 && prs.Round <= rs.Round { if ps.PickSendVote(rs.Votes.Precommits(prs.Round)) { logger.Debug("Picked rs.Precommits(prs.Round) to send", "round", prs.Round) return true } } + // If there are prevotes to send...Needed because of validBlock mechanism + if prs.Round != -1 && prs.Round <= rs.Round { + if ps.PickSendVote(rs.Votes.Prevotes(prs.Round)) { + logger.Debug("Picked rs.Prevotes(prs.Round) to send", "round", prs.Round) + return true + } + } // If there are POLPrevotes to send... if prs.ProposalPOLRound != -1 { if polPrevotes := rs.Votes.Prevotes(prs.ProposalPOLRound); polPrevotes != nil { @@ -720,6 +737,7 @@ func (conR *ConsensusReactor) gossipVotesForHeight(logger log.Logger, rs *cstype } } } + return false } @@ -840,41 +858,42 @@ var ( // PeerState contains the known state of a peer, including its connection and // threadsafe access to its PeerRoundState. +// NOTE: THIS GETS DUMPED WITH rpc/core/consensus.go. +// Be mindful of what you Expose. type PeerState struct { - Peer p2p.Peer + peer p2p.Peer logger log.Logger - mtx sync.Mutex - cstypes.PeerRoundState - - stats *peerStateStats + mtx sync.Mutex `json:"-"` // NOTE: Modify below using setters, never directly. + PRS cstypes.PeerRoundState `json:"round_state"` // Exposed. + Stats *peerStateStats `json:"stats"` // Exposed. } // peerStateStats holds internal statistics for a peer. type peerStateStats struct { - lastVoteHeight int64 - votes int - - lastBlockPartHeight int64 - blockParts int + LastVoteHeight int64 `json:"last_vote_height"` + Votes int `json:"votes"` + LastBlockPartHeight int64 `json:"last_block_part_height"` + BlockParts int `json:"block_parts"` } func (pss peerStateStats) String() string { - return fmt.Sprintf("peerStateStats{votes: %d, blockParts: %d}", pss.votes, pss.blockParts) + return fmt.Sprintf("peerStateStats{lvh: %d, votes: %d, lbph: %d, blockParts: %d}", + pss.LastVoteHeight, pss.Votes, pss.LastBlockPartHeight, pss.BlockParts) } // NewPeerState returns a new PeerState for the given Peer func NewPeerState(peer p2p.Peer) *PeerState { return &PeerState{ - Peer: peer, + peer: peer, logger: log.NewNopLogger(), - PeerRoundState: cstypes.PeerRoundState{ + PRS: cstypes.PeerRoundState{ Round: -1, ProposalPOLRound: -1, LastCommitRound: -1, CatchupCommitRound: -1, }, - stats: &peerStateStats{}, + Stats: &peerStateStats{}, } } @@ -891,16 +910,16 @@ func (ps *PeerState) GetRoundState() *cstypes.PeerRoundState { ps.mtx.Lock() defer ps.mtx.Unlock() - prs := ps.PeerRoundState // copy + prs := ps.PRS // copy return &prs } -// GetRoundStateJSON returns a json of PeerRoundState, marshalled using go-amino. -func (ps *PeerState) GetRoundStateJSON() ([]byte, error) { +// ToJSON returns a json of PeerState, marshalled using go-amino. +func (ps *PeerState) ToJSON() ([]byte, error) { ps.mtx.Lock() defer ps.mtx.Unlock() - return cdc.MarshalJSON(ps.PeerRoundState) + return cdc.MarshalJSON(ps) } // GetHeight returns an atomic snapshot of the PeerRoundState's height @@ -908,7 +927,7 @@ func (ps *PeerState) GetRoundStateJSON() ([]byte, error) { func (ps *PeerState) GetHeight() int64 { ps.mtx.Lock() defer ps.mtx.Unlock() - return ps.PeerRoundState.Height + return ps.PRS.Height } // SetHasProposal sets the given proposal as known for the peer. @@ -916,18 +935,18 @@ func (ps *PeerState) SetHasProposal(proposal *types.Proposal) { ps.mtx.Lock() defer ps.mtx.Unlock() - if ps.Height != proposal.Height || ps.Round != proposal.Round { + if ps.PRS.Height != proposal.Height || ps.PRS.Round != proposal.Round { return } - if ps.Proposal { + if ps.PRS.Proposal { return } - ps.Proposal = true - ps.ProposalBlockPartsHeader = proposal.BlockPartsHeader - ps.ProposalBlockParts = cmn.NewBitArray(proposal.BlockPartsHeader.Total) - ps.ProposalPOLRound = proposal.POLRound - ps.ProposalPOL = nil // Nil until ProposalPOLMessage received. + ps.PRS.Proposal = true + ps.PRS.ProposalBlockPartsHeader = proposal.BlockPartsHeader + ps.PRS.ProposalBlockParts = cmn.NewBitArray(proposal.BlockPartsHeader.Total) + ps.PRS.ProposalPOLRound = proposal.POLRound + ps.PRS.ProposalPOL = nil // Nil until ProposalPOLMessage received. } // InitProposalBlockParts initializes the peer's proposal block parts header and bit array. @@ -935,12 +954,12 @@ func (ps *PeerState) InitProposalBlockParts(partsHeader types.PartSetHeader) { ps.mtx.Lock() defer ps.mtx.Unlock() - if ps.ProposalBlockParts != nil { + if ps.PRS.ProposalBlockParts != nil { return } - ps.ProposalBlockPartsHeader = partsHeader - ps.ProposalBlockParts = cmn.NewBitArray(partsHeader.Total) + ps.PRS.ProposalBlockPartsHeader = partsHeader + ps.PRS.ProposalBlockParts = cmn.NewBitArray(partsHeader.Total) } // SetHasProposalBlockPart sets the given block part index as known for the peer. @@ -948,11 +967,11 @@ func (ps *PeerState) SetHasProposalBlockPart(height int64, round int, index int) ps.mtx.Lock() defer ps.mtx.Unlock() - if ps.Height != height || ps.Round != round { + if ps.PRS.Height != height || ps.PRS.Round != round { return } - ps.ProposalBlockParts.SetIndex(index, true) + ps.PRS.ProposalBlockParts.SetIndex(index, true) } // PickSendVote picks a vote and sends it to the peer. @@ -961,7 +980,7 @@ func (ps *PeerState) PickSendVote(votes types.VoteSetReader) bool { if vote, ok := ps.PickVoteToSend(votes); ok { msg := &VoteMessage{vote} ps.logger.Debug("Sending vote message", "ps", ps, "vote", vote) - return ps.Peer.Send(VoteChannel, cdc.MustMarshalBinaryBare(msg)) + return ps.peer.Send(VoteChannel, cdc.MustMarshalBinaryBare(msg)) } return false } @@ -1001,40 +1020,40 @@ func (ps *PeerState) getVoteBitArray(height int64, round int, type_ byte) *cmn.B return nil } - if ps.Height == height { - if ps.Round == round { + if ps.PRS.Height == height { + if ps.PRS.Round == round { switch type_ { case types.VoteTypePrevote: - return ps.Prevotes + return ps.PRS.Prevotes case types.VoteTypePrecommit: - return ps.Precommits + return ps.PRS.Precommits } } - if ps.CatchupCommitRound == round { + if ps.PRS.CatchupCommitRound == round { switch type_ { case types.VoteTypePrevote: return nil case types.VoteTypePrecommit: - return ps.CatchupCommit + return ps.PRS.CatchupCommit } } - if ps.ProposalPOLRound == round { + if ps.PRS.ProposalPOLRound == round { switch type_ { case types.VoteTypePrevote: - return ps.ProposalPOL + return ps.PRS.ProposalPOL case types.VoteTypePrecommit: return nil } } return nil } - if ps.Height == height+1 { - if ps.LastCommitRound == round { + if ps.PRS.Height == height+1 { + if ps.PRS.LastCommitRound == round { switch type_ { case types.VoteTypePrevote: return nil case types.VoteTypePrecommit: - return ps.LastCommit + return ps.PRS.LastCommit } } return nil @@ -1044,7 +1063,7 @@ func (ps *PeerState) getVoteBitArray(height int64, round int, type_ byte) *cmn.B // 'round': A round for which we have a +2/3 commit. func (ps *PeerState) ensureCatchupCommitRound(height int64, round int, numValidators int) { - if ps.Height != height { + if ps.PRS.Height != height { return } /* @@ -1054,14 +1073,14 @@ func (ps *PeerState) ensureCatchupCommitRound(height int64, round int, numValida cmn.PanicSanity(cmn.Fmt("Conflicting CatchupCommitRound. Height: %v, Orig: %v, New: %v", height, ps.CatchupCommitRound, round)) } */ - if ps.CatchupCommitRound == round { + if ps.PRS.CatchupCommitRound == round { return // Nothing to do! } - ps.CatchupCommitRound = round - if round == ps.Round { - ps.CatchupCommit = ps.Precommits + ps.PRS.CatchupCommitRound = round + if round == ps.PRS.Round { + ps.PRS.CatchupCommit = ps.PRS.Precommits } else { - ps.CatchupCommit = cmn.NewBitArray(numValidators) + ps.PRS.CatchupCommit = cmn.NewBitArray(numValidators) } } @@ -1076,22 +1095,22 @@ func (ps *PeerState) EnsureVoteBitArrays(height int64, numValidators int) { } func (ps *PeerState) ensureVoteBitArrays(height int64, numValidators int) { - if ps.Height == height { - if ps.Prevotes == nil { - ps.Prevotes = cmn.NewBitArray(numValidators) + if ps.PRS.Height == height { + if ps.PRS.Prevotes == nil { + ps.PRS.Prevotes = cmn.NewBitArray(numValidators) } - if ps.Precommits == nil { - ps.Precommits = cmn.NewBitArray(numValidators) + if ps.PRS.Precommits == nil { + ps.PRS.Precommits = cmn.NewBitArray(numValidators) } - if ps.CatchupCommit == nil { - ps.CatchupCommit = cmn.NewBitArray(numValidators) + if ps.PRS.CatchupCommit == nil { + ps.PRS.CatchupCommit = cmn.NewBitArray(numValidators) } - if ps.ProposalPOL == nil { - ps.ProposalPOL = cmn.NewBitArray(numValidators) + if ps.PRS.ProposalPOL == nil { + ps.PRS.ProposalPOL = cmn.NewBitArray(numValidators) } - } else if ps.Height == height+1 { - if ps.LastCommit == nil { - ps.LastCommit = cmn.NewBitArray(numValidators) + } else if ps.PRS.Height == height+1 { + if ps.PRS.LastCommit == nil { + ps.PRS.LastCommit = cmn.NewBitArray(numValidators) } } } @@ -1103,12 +1122,12 @@ func (ps *PeerState) RecordVote(vote *types.Vote) int { ps.mtx.Lock() defer ps.mtx.Unlock() - if ps.stats.lastVoteHeight >= vote.Height { - return ps.stats.votes + if ps.Stats.LastVoteHeight >= vote.Height { + return ps.Stats.Votes } - ps.stats.lastVoteHeight = vote.Height - ps.stats.votes++ - return ps.stats.votes + ps.Stats.LastVoteHeight = vote.Height + ps.Stats.Votes++ + return ps.Stats.Votes } // VotesSent returns the number of blocks for which peer has been sending us @@ -1117,7 +1136,7 @@ func (ps *PeerState) VotesSent() int { ps.mtx.Lock() defer ps.mtx.Unlock() - return ps.stats.votes + return ps.Stats.Votes } // RecordBlockPart updates internal statistics for this peer by recording the @@ -1128,13 +1147,13 @@ func (ps *PeerState) RecordBlockPart(bp *BlockPartMessage) int { ps.mtx.Lock() defer ps.mtx.Unlock() - if ps.stats.lastBlockPartHeight >= bp.Height { - return ps.stats.blockParts + if ps.Stats.LastBlockPartHeight >= bp.Height { + return ps.Stats.BlockParts } - ps.stats.lastBlockPartHeight = bp.Height - ps.stats.blockParts++ - return ps.stats.blockParts + ps.Stats.LastBlockPartHeight = bp.Height + ps.Stats.BlockParts++ + return ps.Stats.BlockParts } // BlockPartsSent returns the number of blocks for which peer has been sending @@ -1143,7 +1162,7 @@ func (ps *PeerState) BlockPartsSent() int { ps.mtx.Lock() defer ps.mtx.Unlock() - return ps.stats.blockParts + return ps.Stats.BlockParts } // SetHasVote sets the given vote as known by the peer @@ -1155,7 +1174,7 @@ func (ps *PeerState) SetHasVote(vote *types.Vote) { } func (ps *PeerState) setHasVote(height int64, round int, type_ byte, index int) { - logger := ps.logger.With("peerH/R", cmn.Fmt("%d/%d", ps.Height, ps.Round), "H/R", cmn.Fmt("%d/%d", height, round)) + logger := ps.logger.With("peerH/R", cmn.Fmt("%d/%d", ps.PRS.Height, ps.PRS.Round), "H/R", cmn.Fmt("%d/%d", height, round)) logger.Debug("setHasVote", "type", type_, "index", index) // NOTE: some may be nil BitArrays -> no side effects. @@ -1171,51 +1190,51 @@ func (ps *PeerState) ApplyNewRoundStepMessage(msg *NewRoundStepMessage) { defer ps.mtx.Unlock() // Ignore duplicates or decreases - if CompareHRS(msg.Height, msg.Round, msg.Step, ps.Height, ps.Round, ps.Step) <= 0 { + if CompareHRS(msg.Height, msg.Round, msg.Step, ps.PRS.Height, ps.PRS.Round, ps.PRS.Step) <= 0 { return } // Just remember these values. - psHeight := ps.Height - psRound := ps.Round - //psStep := ps.Step - psCatchupCommitRound := ps.CatchupCommitRound - psCatchupCommit := ps.CatchupCommit + psHeight := ps.PRS.Height + psRound := ps.PRS.Round + //psStep := ps.PRS.Step + psCatchupCommitRound := ps.PRS.CatchupCommitRound + psCatchupCommit := ps.PRS.CatchupCommit startTime := time.Now().Add(-1 * time.Duration(msg.SecondsSinceStartTime) * time.Second) - ps.Height = msg.Height - ps.Round = msg.Round - ps.Step = msg.Step - ps.StartTime = startTime + ps.PRS.Height = msg.Height + ps.PRS.Round = msg.Round + ps.PRS.Step = msg.Step + ps.PRS.StartTime = startTime if psHeight != msg.Height || psRound != msg.Round { - ps.Proposal = false - ps.ProposalBlockPartsHeader = types.PartSetHeader{} - ps.ProposalBlockParts = nil - ps.ProposalPOLRound = -1 - ps.ProposalPOL = nil + ps.PRS.Proposal = false + ps.PRS.ProposalBlockPartsHeader = types.PartSetHeader{} + ps.PRS.ProposalBlockParts = nil + ps.PRS.ProposalPOLRound = -1 + ps.PRS.ProposalPOL = nil // We'll update the BitArray capacity later. - ps.Prevotes = nil - ps.Precommits = nil + ps.PRS.Prevotes = nil + ps.PRS.Precommits = nil } if psHeight == msg.Height && psRound != msg.Round && msg.Round == psCatchupCommitRound { // Peer caught up to CatchupCommitRound. // Preserve psCatchupCommit! // NOTE: We prefer to use prs.Precommits if // pr.Round matches pr.CatchupCommitRound. - ps.Precommits = psCatchupCommit + ps.PRS.Precommits = psCatchupCommit } if psHeight != msg.Height { // Shift Precommits to LastCommit. if psHeight+1 == msg.Height && psRound == msg.LastCommitRound { - ps.LastCommitRound = msg.LastCommitRound - ps.LastCommit = ps.Precommits + ps.PRS.LastCommitRound = msg.LastCommitRound + ps.PRS.LastCommit = ps.PRS.Precommits } else { - ps.LastCommitRound = msg.LastCommitRound - ps.LastCommit = nil + ps.PRS.LastCommitRound = msg.LastCommitRound + ps.PRS.LastCommit = nil } // We'll update the BitArray capacity later. - ps.CatchupCommitRound = -1 - ps.CatchupCommit = nil + ps.PRS.CatchupCommitRound = -1 + ps.PRS.CatchupCommit = nil } } @@ -1224,12 +1243,12 @@ func (ps *PeerState) ApplyCommitStepMessage(msg *CommitStepMessage) { ps.mtx.Lock() defer ps.mtx.Unlock() - if ps.Height != msg.Height { + if ps.PRS.Height != msg.Height { return } - ps.ProposalBlockPartsHeader = msg.BlockPartsHeader - ps.ProposalBlockParts = msg.BlockParts + ps.PRS.ProposalBlockPartsHeader = msg.BlockPartsHeader + ps.PRS.ProposalBlockParts = msg.BlockParts } // ApplyProposalPOLMessage updates the peer state for the new proposal POL. @@ -1237,16 +1256,16 @@ func (ps *PeerState) ApplyProposalPOLMessage(msg *ProposalPOLMessage) { ps.mtx.Lock() defer ps.mtx.Unlock() - if ps.Height != msg.Height { + if ps.PRS.Height != msg.Height { return } - if ps.ProposalPOLRound != msg.ProposalPOLRound { + if ps.PRS.ProposalPOLRound != msg.ProposalPOLRound { return } - // TODO: Merge onto existing ps.ProposalPOL? + // TODO: Merge onto existing ps.PRS.ProposalPOL? // We might have sent some prevotes in the meantime. - ps.ProposalPOL = msg.ProposalPOL + ps.PRS.ProposalPOL = msg.ProposalPOL } // ApplyHasVoteMessage updates the peer state for the new vote. @@ -1254,7 +1273,7 @@ func (ps *PeerState) ApplyHasVoteMessage(msg *HasVoteMessage) { ps.mtx.Lock() defer ps.mtx.Unlock() - if ps.Height != msg.Height { + if ps.PRS.Height != msg.Height { return } @@ -1292,13 +1311,13 @@ func (ps *PeerState) StringIndented(indent string) string { ps.mtx.Lock() defer ps.mtx.Unlock() return fmt.Sprintf(`PeerState{ -%s Key %v -%s PRS %v -%s Stats %v +%s Key %v +%s RoundState %v +%s Stats %v %s}`, - indent, ps.Peer.ID(), - indent, ps.PeerRoundState.StringIndented(indent+" "), - indent, ps.stats, + indent, ps.peer.ID(), + indent, ps.PRS.StringIndented(indent+" "), + indent, ps.Stats, indent) } diff --git a/consensus/state.go b/consensus/state.go index 40b8f16d5..bee7efa2e 100644 --- a/consensus/state.go +++ b/consensus/state.go @@ -185,6 +185,14 @@ func (cs *ConsensusState) GetRoundStateJSON() ([]byte, error) { return cdc.MarshalJSON(cs.RoundState) } +// GetRoundStateSimpleJSON returns a json of RoundStateSimple, marshalled using go-amino. +func (cs *ConsensusState) GetRoundStateSimpleJSON() ([]byte, error) { + cs.mtx.Lock() + defer cs.mtx.Unlock() + + return cdc.MarshalJSON(cs.RoundState.RoundStateSimple()) +} + // GetValidators returns a copy of the current validators. func (cs *ConsensusState) GetValidators() (int64, []*types.Validator) { cs.mtx.Lock() @@ -993,7 +1001,7 @@ func (cs *ConsensusState) enterPrecommit(height int64, round int) { // check for a polka blockID, ok := cs.Votes.Prevotes(round).TwoThirdsMajority() - // If we don't have a polka, we must precommit nil + // If we don't have a polka, we must precommit nil. if !ok { if cs.LockedBlock != nil { cs.Logger.Info("enterPrecommit: No +2/3 prevotes during enterPrecommit while we're locked. Precommitting nil") @@ -1004,10 +1012,10 @@ func (cs *ConsensusState) enterPrecommit(height int64, round int) { return } - // At this point +2/3 prevoted for a particular block or nil + // At this point +2/3 prevoted for a particular block or nil. cs.eventBus.PublishEventPolka(cs.RoundStateEvent()) - // the latest POLRound should be this round + // the latest POLRound should be this round. polRound, _ := cs.Votes.POLInfo() if polRound < round { cmn.PanicSanity(cmn.Fmt("This POLRound should be %v but got %", round, polRound)) @@ -1279,6 +1287,7 @@ func (cs *ConsensusState) defaultSetProposal(proposal *types.Proposal) error { cs.Proposal = proposal cs.ProposalBlockParts = types.NewPartSetFromHeader(proposal.BlockPartsHeader) + cs.Logger.Info("Received proposal", "proposal", proposal) return nil } @@ -1307,6 +1316,23 @@ func (cs *ConsensusState) addProposalBlockPart(height int64, part *types.Part, v } // NOTE: it's possible to receive complete proposal blocks for future rounds without having the proposal cs.Logger.Info("Received complete proposal block", "height", cs.ProposalBlock.Height, "hash", cs.ProposalBlock.Hash()) + + // Update Valid* if we can. + prevotes := cs.Votes.Prevotes(cs.Round) + blockID, hasTwoThirds := prevotes.TwoThirdsMajority() + if hasTwoThirds && !blockID.IsZero() && (cs.ValidRound < cs.Round) { + if cs.ProposalBlock.HashesTo(blockID.Hash) { + cs.ValidRound = cs.Round + cs.ValidBlock = cs.ProposalBlock + cs.ValidBlockParts = cs.ProposalBlockParts + } + // TODO: In case there is +2/3 majority in Prevotes set for some + // block and cs.ProposalBlock contains different block, either + // proposer is faulty or voting power of faulty processes is more + // than 1/3. We should trigger in the future accountability + // procedure at this point. + } + if cs.Step == cstypes.RoundStepPropose && cs.isProposalComplete() { // Move onto the next step cs.enterPrevote(height, cs.Round) @@ -1397,33 +1423,43 @@ func (cs *ConsensusState) addVote(vote *types.Vote, peerID p2p.ID) (added bool, case types.VoteTypePrevote: prevotes := cs.Votes.Prevotes(vote.Round) cs.Logger.Info("Added to prevote", "vote", vote, "prevotes", prevotes.StringShort()) - blockID, ok := prevotes.TwoThirdsMajority() - // First, unlock if prevotes is a valid POL. - // >> lockRound < POLRound <= unlockOrChangeLockRound (see spec) - // NOTE: If (lockRound < POLRound) but !(POLRound <= unlockOrChangeLockRound), - // we'll still enterNewRound(H,vote.R) and enterPrecommit(H,vote.R) to process it - // there. - if (cs.LockedBlock != nil) && (cs.LockedRound < vote.Round) && (vote.Round <= cs.Round) { - if ok && !cs.LockedBlock.HashesTo(blockID.Hash) { + + // If +2/3 prevotes for a block or nil for *any* round: + if blockID, ok := prevotes.TwoThirdsMajority(); ok { + + // There was a polka! + // If we're locked but this is a recent polka, unlock. + // If it matches our ProposalBlock, update the ValidBlock + + // Unlock if `cs.LockedRound < vote.Round <= cs.Round` + // NOTE: If vote.Round > cs.Round, we'll deal with it when we get to vote.Round + if (cs.LockedBlock != nil) && + (cs.LockedRound < vote.Round) && + (vote.Round <= cs.Round) && + !cs.LockedBlock.HashesTo(blockID.Hash) { + cs.Logger.Info("Unlocking because of POL.", "lockedRound", cs.LockedRound, "POLRound", vote.Round) cs.LockedRound = 0 cs.LockedBlock = nil cs.LockedBlockParts = nil cs.eventBus.PublishEventUnlock(cs.RoundStateEvent()) } - } - // Update ValidBlock - if ok && !blockID.IsZero() && !cs.ValidBlock.HashesTo(blockID.Hash) && vote.Round > cs.ValidRound { - // update valid value - if cs.ProposalBlock.HashesTo(blockID.Hash) { + + // Update Valid* if we can. + // NOTE: our proposal block may be nil or not what received a polka.. + // TODO: we may want to still update the ValidBlock and obtain it via gossipping + if !blockID.IsZero() && + (cs.ValidRound < vote.Round) && + (vote.Round <= cs.Round) && + cs.ProposalBlock.HashesTo(blockID.Hash) { + cs.ValidRound = vote.Round cs.ValidBlock = cs.ProposalBlock cs.ValidBlockParts = cs.ProposalBlockParts } - //TODO: We might want to update ValidBlock also in case we don't have that block yet, - // and obtain the required block using gossiping } + // If +2/3 prevotes for *anything* for this or future round: if cs.Round <= vote.Round && prevotes.HasTwoThirdsAny() { // Round-skip over to PrevoteWait or goto Precommit. cs.enterNewRound(height, vote.Round) // if the vote is ahead of us @@ -1439,6 +1475,7 @@ func (cs *ConsensusState) addVote(vote *types.Vote, peerID p2p.ID) (added bool, cs.enterPrevote(height, cs.Round) } } + case types.VoteTypePrecommit: precommits := cs.Votes.Precommits(vote.Round) cs.Logger.Info("Added to precommit", "vote", vote, "precommits", precommits.StringShort()) diff --git a/consensus/types/height_vote_set.go b/consensus/types/height_vote_set.go index f65f365b8..3c9867940 100644 --- a/consensus/types/height_vote_set.go +++ b/consensus/types/height_vote_set.go @@ -174,6 +174,26 @@ func (hvs *HeightVoteSet) getVoteSet(round int, type_ byte) *types.VoteSet { } } +// If a peer claims that it has 2/3 majority for given blockKey, call this. +// NOTE: if there are too many peers, or too much peer churn, +// this can cause memory issues. +// TODO: implement ability to remove peers too +func (hvs *HeightVoteSet) SetPeerMaj23(round int, type_ byte, peerID p2p.ID, blockID types.BlockID) error { + hvs.mtx.Lock() + defer hvs.mtx.Unlock() + if !types.IsVoteTypeValid(type_) { + return fmt.Errorf("SetPeerMaj23: Invalid vote type %v", type_) + } + voteSet := hvs.getVoteSet(round, type_) + if voteSet == nil { + return nil // something we don't know about yet + } + return voteSet.SetPeerMaj23(types.P2PID(peerID), blockID) +} + +//--------------------------------------------------------- +// string and json + func (hvs *HeightVoteSet) String() string { return hvs.StringIndented("") } @@ -207,43 +227,35 @@ func (hvs *HeightVoteSet) StringIndented(indent string) string { indent) } -type roundVoteBitArrays struct { - Round int `json:"round"` - Prevotes *cmn.BitArray `json:"prevotes"` - Precommits *cmn.BitArray `json:"precommits"` -} - func (hvs *HeightVoteSet) MarshalJSON() ([]byte, error) { hvs.mtx.Lock() defer hvs.mtx.Unlock() + + allVotes := hvs.toAllRoundVotes() + return cdc.MarshalJSON(allVotes) +} + +func (hvs *HeightVoteSet) toAllRoundVotes() []roundVotes { totalRounds := hvs.round + 1 - roundsVotes := make([]roundVoteBitArrays, totalRounds) + allVotes := make([]roundVotes, totalRounds) // rounds 0 ~ hvs.round inclusive for round := 0; round < totalRounds; round++ { - roundsVotes[round] = roundVoteBitArrays{ - Round: round, - Prevotes: hvs.roundVoteSets[round].Prevotes.BitArray(), - Precommits: hvs.roundVoteSets[round].Precommits.BitArray(), + allVotes[round] = roundVotes{ + Round: round, + Prevotes: hvs.roundVoteSets[round].Prevotes.VoteStrings(), + PrevotesBitArray: hvs.roundVoteSets[round].Prevotes.BitArrayString(), + Precommits: hvs.roundVoteSets[round].Precommits.VoteStrings(), + PrecommitsBitArray: hvs.roundVoteSets[round].Precommits.BitArrayString(), } } // TODO: all other peer catchup rounds - - return cdc.MarshalJSON(roundsVotes) + return allVotes } -// If a peer claims that it has 2/3 majority for given blockKey, call this. -// NOTE: if there are too many peers, or too much peer churn, -// this can cause memory issues. -// TODO: implement ability to remove peers too -func (hvs *HeightVoteSet) SetPeerMaj23(round int, type_ byte, peerID p2p.ID, blockID types.BlockID) error { - hvs.mtx.Lock() - defer hvs.mtx.Unlock() - if !types.IsVoteTypeValid(type_) { - return fmt.Errorf("SetPeerMaj23: Invalid vote type %v", type_) - } - voteSet := hvs.getVoteSet(round, type_) - if voteSet == nil { - return nil // something we don't know about yet - } - return voteSet.SetPeerMaj23(types.P2PID(peerID), blockID) +type roundVotes struct { + Round int `json:"round"` + Prevotes []string `json:"prevotes"` + PrevotesBitArray string `json:"prevotes_bit_array"` + Precommits []string `json:"precommits"` + PrecommitsBitArray string `json:"precommits_bit_array"` } diff --git a/consensus/types/round_state.go b/consensus/types/round_state.go index 65c40781e..14da1f149 100644 --- a/consensus/types/round_state.go +++ b/consensus/types/round_state.go @@ -1,10 +1,12 @@ package types import ( + "encoding/json" "fmt" "time" "github.com/tendermint/tendermint/types" + cmn "github.com/tendermint/tmlibs/common" ) //----------------------------------------------------------------------------- @@ -68,15 +70,41 @@ type RoundState struct { LockedRound int `json:"locked_round"` LockedBlock *types.Block `json:"locked_block"` LockedBlockParts *types.PartSet `json:"locked_block_parts"` - ValidRound int `json:"valid_round"` - ValidBlock *types.Block `json:"valid_block"` - ValidBlockParts *types.PartSet `json:"valid_block_parts"` + ValidRound int `json:"valid_round"` // Last known round with POL for non-nil valid block. + ValidBlock *types.Block `json:"valid_block"` // Last known block of POL mentioned above. + ValidBlockParts *types.PartSet `json:"valid_block_parts"` // Last known block parts of POL metnioned above. Votes *HeightVoteSet `json:"votes"` CommitRound int `json:"commit_round"` // LastCommit *types.VoteSet `json:"last_commit"` // Last precommits at Height-1 LastValidators *types.ValidatorSet `json:"last_validators"` } +// Compressed version of the RoundState for use in RPC +type RoundStateSimple struct { + HeightRoundStep string `json:"height/round/step"` + StartTime time.Time `json:"start_time"` + ProposalBlockHash cmn.HexBytes `json:"proposal_block_hash"` + LockedBlockHash cmn.HexBytes `json:"locked_block_hash"` + ValidBlockHash cmn.HexBytes `json:"valid_block_hash"` + Votes json.RawMessage `json:"height_vote_set"` +} + +// Compress the RoundState to RoundStateSimple +func (rs *RoundState) RoundStateSimple() RoundStateSimple { + votesJSON, err := rs.Votes.MarshalJSON() + if err != nil { + panic(err) + } + return RoundStateSimple{ + HeightRoundStep: fmt.Sprintf("%d/%d/%d", rs.Height, rs.Round, rs.Step), + StartTime: rs.StartTime, + ProposalBlockHash: rs.ProposalBlock.Hash(), + LockedBlockHash: rs.LockedBlock.Hash(), + ValidBlockHash: rs.ValidBlock.Hash(), + Votes: votesJSON, + } +} + // RoundStateEvent returns the H/R/S of the RoundState as an event. func (rs *RoundState) RoundStateEvent() types.EventDataRoundState { // XXX: copy the RoundState diff --git a/docs/using-tendermint.rst b/docs/using-tendermint.rst index bc5d73859..394a7f3ed 100644 --- a/docs/using-tendermint.rst +++ b/docs/using-tendermint.rst @@ -456,5 +456,5 @@ Upgrading The Tendermint development cycle includes a lot of breaking changes. Upgrading from an old version to a new version usually means throwing away the chain data. Try out -the `tm-migrate `__ tool written by @hxqlh if +the `tm-migrate `__ tool written by `@hxzqlh `__ if you are keen to preserve the state of your chain when upgrading to newer versions. diff --git a/p2p/node_info.go b/p2p/node_info.go index 985142aa2..60383bc5e 100644 --- a/p2p/node_info.go +++ b/p2p/node_info.go @@ -2,9 +2,8 @@ package p2p import ( "fmt" - "strings" - cmn "github.com/tendermint/tmlibs/common" + "strings" ) const ( @@ -31,7 +30,7 @@ type NodeInfo struct { Version string `json:"version"` // major.minor.revision Channels cmn.HexBytes `json:"channels"` // channels this node knows about - // Sanitize + // ASCIIText fields Moniker string `json:"moniker"` // arbitrary moniker Other []string `json:"other"` // other application specific data } @@ -42,11 +41,28 @@ type NodeInfo struct { // if the ListenAddr is malformed, or if the ListenAddr is a host name // that can not be resolved to some IP. // TODO: constraints for Moniker/Other? Or is that for the UI ? +// JAE: It needs to be done on the client, but to prevent ambiguous +// unicode characters, maybe it's worth sanitizing it here. +// In the future we might want to validate these, once we have a +// name-resolution system up. +// International clients could then use punycode (or we could use +// url-encoding), and we just need to be careful with how we handle that in our +// clients. (e.g. off by default). func (info NodeInfo) Validate() error { if len(info.Channels) > maxNumChannels { return fmt.Errorf("info.Channels is too long (%v). Max is %v", len(info.Channels), maxNumChannels) } + // Sanitize ASCII text fields. + if !cmn.IsASCIIText(info.Moniker) || cmn.ASCIITrim(info.Moniker) == "" { + return fmt.Errorf("info.Moniker must be valid non-empty ASCII text without tabs, but got %v.", info.Moniker) + } + for i, s := range info.Other { + if !cmn.IsASCIIText(s) || cmn.ASCIITrim(s) == "" { + return fmt.Errorf("info.Other[%v] must be valid non-empty ASCII text without tabs, but got %v.", i, s) + } + } + channels := make(map[byte]struct{}) for _, ch := range info.Channels { _, ok := channels[ch] diff --git a/rpc/client/helpers_test.go b/rpc/client/helpers_test.go index d5c31ddaf..8b843fcdb 100644 --- a/rpc/client/helpers_test.go +++ b/rpc/client/helpers_test.go @@ -32,7 +32,7 @@ func TestWaitForHeight(t *testing.T) { // now set current block height to 10 m.Call = mock.Call{ - Response: &ctypes.ResultStatus{SyncInfo: ctypes.SyncInfo{LatestBlockHeight: 10} }, + Response: &ctypes.ResultStatus{SyncInfo: ctypes.SyncInfo{LatestBlockHeight: 10}}, } // we will not wait for more than 10 blocks diff --git a/rpc/client/httpclient.go b/rpc/client/httpclient.go index 83207eb7b..89a1293af 100644 --- a/rpc/client/httpclient.go +++ b/rpc/client/httpclient.go @@ -126,6 +126,15 @@ func (c *HTTP) DumpConsensusState() (*ctypes.ResultDumpConsensusState, error) { return result, nil } +func (c *HTTP) ConsensusState() (*ctypes.ResultConsensusState, error) { + result := new(ctypes.ResultConsensusState) + _, err := c.rpc.Call("consensus_state", map[string]interface{}{}, result) + if err != nil { + return nil, errors.Wrap(err, "ConsensusState") + } + return result, nil +} + func (c *HTTP) Health() (*ctypes.ResultHealth, error) { result := new(ctypes.ResultHealth) _, err := c.rpc.Call("health", map[string]interface{}{}, result) diff --git a/rpc/client/interface.go b/rpc/client/interface.go index 7a065291e..0cc9333ef 100644 --- a/rpc/client/interface.go +++ b/rpc/client/interface.go @@ -1,5 +1,7 @@ +package client + /* -package client provides a general purpose interface (Client) for connecting +The client package provides a general purpose interface (Client) for connecting to a tendermint node, as well as higher-level functionality. The main implementation for production code is client.HTTP, which @@ -17,7 +19,6 @@ for maximum flexibility and testability, and two implementations, this package also provides helper functions that work on any Client implementation. */ -package client import ( ctypes "github.com/tendermint/tendermint/rpc/core/types" @@ -29,13 +30,13 @@ import ( // affects the ABCI app. In many cases this will be all we want, // so we can accept an interface which is easier to mock type ABCIClient interface { - // reading from abci app + // Reading from abci app ABCIInfo() (*ctypes.ResultABCIInfo, error) ABCIQuery(path string, data cmn.HexBytes) (*ctypes.ResultABCIQuery, error) ABCIQueryWithOptions(path string, data cmn.HexBytes, opts ABCIQueryOptions) (*ctypes.ResultABCIQuery, error) - // writing to abci app + // Writing to abci app BroadcastTxCommit(tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) BroadcastTxAsync(tx types.Tx) (*ctypes.ResultBroadcastTx, error) BroadcastTxSync(tx types.Tx) (*ctypes.ResultBroadcastTx, error) @@ -59,7 +60,7 @@ type HistoryClient interface { } type StatusClient interface { - // general chain info + // General chain info Status() (*ctypes.ResultStatus, error) } @@ -83,6 +84,7 @@ type Client interface { type NetworkClient interface { NetInfo() (*ctypes.ResultNetInfo, error) DumpConsensusState() (*ctypes.ResultDumpConsensusState, error) + ConsensusState() (*ctypes.ResultConsensusState, error) Health() (*ctypes.ResultHealth, error) } diff --git a/rpc/client/localclient.go b/rpc/client/localclient.go index 7e2f8fedc..0c47de830 100644 --- a/rpc/client/localclient.go +++ b/rpc/client/localclient.go @@ -84,6 +84,10 @@ func (Local) DumpConsensusState() (*ctypes.ResultDumpConsensusState, error) { return core.DumpConsensusState() } +func (Local) ConsensusState() (*ctypes.ResultConsensusState, error) { + return core.ConsensusState() +} + func (Local) Health() (*ctypes.ResultHealth, error) { return core.Health() } diff --git a/rpc/client/rpc_test.go b/rpc/client/rpc_test.go index bfdc707f4..eb25b94ee 100644 --- a/rpc/client/rpc_test.go +++ b/rpc/client/rpc_test.go @@ -74,7 +74,18 @@ func TestDumpConsensusState(t *testing.T) { cons, err := nc.DumpConsensusState() require.Nil(t, err, "%d: %+v", i, err) assert.NotEmpty(t, cons.RoundState) - assert.Empty(t, cons.PeerRoundStates) + assert.Empty(t, cons.Peers) + } +} + +func TestConsensusState(t *testing.T) { + for i, c := range GetClients() { + // FIXME: fix server so it doesn't panic on invalid input + nc, ok := c.(client.NetworkClient) + require.True(t, ok, "%d", i) + cons, err := nc.ConsensusState() + require.Nil(t, err, "%d: %+v", i, err) + assert.NotEmpty(t, cons.RoundState) } } diff --git a/rpc/core/consensus.go b/rpc/core/consensus.go index 98b0699d0..68e25c1e6 100644 --- a/rpc/core/consensus.go +++ b/rpc/core/consensus.go @@ -20,7 +20,7 @@ import ( // state, err := client.Validators() // ``` // -// > The above command returns JSON structured like this: +// The above command returns JSON structured like this: // // ```json // { @@ -58,6 +58,7 @@ func Validators(heightPtr *int64) (*ctypes.ResultValidators, error) { } // DumpConsensusState dumps consensus state. +// UNSTABLE // // ```shell // curl 'localhost:46657/dump_consensus_state' @@ -68,131 +69,193 @@ func Validators(heightPtr *int64) (*ctypes.ResultValidators, error) { // state, err := client.DumpConsensusState() // ``` // -// > The above command returns JSON structured like this: +// The above command returns JSON structured like this: // // ```json -//{ -// "jsonrpc": "2.0", -// "id": "", -// "result": { -// "round_state": { -// "height": 138, -// "round": 0, -// "step": 1, -// "start_time": "2018-04-27T23:16:34.472087096-04:00", -// "commit_time": "2018-04-27T23:16:33.472087096-04:00", -// "validators": { -// "validators": [ -// { -// "address": "5875562FF0FFDECC895C20E32FC14988952E99E7", -// "pub_key": { -// "type": "AC26791624DE60", -// "value": "PpDJRUrLG2RgFqYYjawfn/AcAgacSXpLFrmfYYQnuzE=" -// }, -// "voting_power": 10, -// "accum": 0 -// } -// ], -// "proposer": { -// "address": "5875562FF0FFDECC895C20E32FC14988952E99E7", -// "pub_key": { -// "type": "AC26791624DE60", -// "value": "PpDJRUrLG2RgFqYYjawfn/AcAgacSXpLFrmfYYQnuzE=" -// }, -// "voting_power": 10, -// "accum": 0 -// } -// }, -// "proposal": null, -// "proposal_block": null, -// "proposal_block_parts": null, -// "locked_round": 0, -// "locked_block": null, -// "locked_block_parts": null, -// "valid_round": 0, -// "valid_block": null, -// "valid_block_parts": null, -// "votes": [ -// { -// "round": 0, -// "prevotes": "_", -// "precommits": "_" -// } -// ], -// "commit_round": -1, -// "last_commit": { -// "votes": [ -// "Vote{0:5875562FF0FF 137/00/2(Precommit) 5701C93659EA /ED3588D7AF29.../ @ 2018-04-28T03:16:33.469Z}" -// ], -// "votes_bit_array": "x", -// "peer_maj_23s": {} -// }, -// "last_validators": { -// "validators": [ -// { -// "address": "5875562FF0FFDECC895C20E32FC14988952E99E7", -// "pub_key": { -// "type": "AC26791624DE60", -// "value": "PpDJRUrLG2RgFqYYjawfn/AcAgacSXpLFrmfYYQnuzE=" -// }, -// "voting_power": 10, -// "accum": 0 -// } -// ], -// "proposer": { -// "address": "5875562FF0FFDECC895C20E32FC14988952E99E7", -// "pub_key": { -// "type": "AC26791624DE60", -// "value": "PpDJRUrLG2RgFqYYjawfn/AcAgacSXpLFrmfYYQnuzE=" -// }, -// "voting_power": 10, -// "accum": 0 -// } -// } -// }, -// "peer_round_states": { -// "d4bf26bfa5e390b94d98106ab858abf64db26d48": { -// "Height": 136, -// "Round": 0, -// "Step": 1, -// "StartTime": "2018-04-27T23:16:33.841163812-04:00", -// "Proposal": false, -// "ProposalBlockPartsHeader": { -// "total": 1, -// "hash": "E27F2D13298F7CB14090EE60CD9AB214D2F5161F" -// }, -// "ProposalBlockParts": "x", -// "ProposalPOLRound": -1, -// "ProposalPOL": "_", -// "Prevotes": "_", -// "Precommits": "x", -// "LastCommitRound": 0, -// "LastCommit": null, -// "CatchupCommitRound": 0, -// "CatchupCommit": "_" -// } -// } -// } -//} +// { +// "jsonrpc": "2.0", +// "id": "", +// "result": { +// "round_state": { +// "height": 7185, +// "round": 0, +// "step": 1, +// "start_time": "2018-05-12T13:57:28.440293621-07:00", +// "commit_time": "2018-05-12T13:57:27.440293621-07:00", +// "validators": { +// "validators": [ +// { +// "address": "B5B3D40BE53982AD294EF99FF5A34C0C3E5A3244", +// "pub_key": { +// "type": "AC26791624DE60", +// "value": "SBctdhRBcXtBgdI/8a/alTsUhGXqGs9k5ylV1u5iKHg=" +// }, +// "voting_power": 10, +// "accum": 0 +// } +// ], +// "proposer": { +// "address": "B5B3D40BE53982AD294EF99FF5A34C0C3E5A3244", +// "pub_key": { +// "type": "AC26791624DE60", +// "value": "SBctdhRBcXtBgdI/8a/alTsUhGXqGs9k5ylV1u5iKHg=" +// }, +// "voting_power": 10, +// "accum": 0 +// } +// }, +// "proposal": null, +// "proposal_block": null, +// "proposal_block_parts": null, +// "locked_round": 0, +// "locked_block": null, +// "locked_block_parts": null, +// "valid_round": 0, +// "valid_block": null, +// "valid_block_parts": null, +// "votes": [ +// { +// "round": 0, +// "prevotes": "_", +// "precommits": "_" +// } +// ], +// "commit_round": -1, +// "last_commit": { +// "votes": [ +// "Vote{0:B5B3D40BE539 7184/00/2(Precommit) 14F946FA7EF0 /702B1B1A602A.../ @ 2018-05-12T20:57:27.342Z}" +// ], +// "votes_bit_array": "x", +// "peer_maj_23s": {} +// }, +// "last_validators": { +// "validators": [ +// { +// "address": "B5B3D40BE53982AD294EF99FF5A34C0C3E5A3244", +// "pub_key": { +// "type": "AC26791624DE60", +// "value": "SBctdhRBcXtBgdI/8a/alTsUhGXqGs9k5ylV1u5iKHg=" +// }, +// "voting_power": 10, +// "accum": 0 +// } +// ], +// "proposer": { +// "address": "B5B3D40BE53982AD294EF99FF5A34C0C3E5A3244", +// "pub_key": { +// "type": "AC26791624DE60", +// "value": "SBctdhRBcXtBgdI/8a/alTsUhGXqGs9k5ylV1u5iKHg=" +// }, +// "voting_power": 10, +// "accum": 0 +// } +// } +// }, +// "peers": [ +// { +// "node_address": "30ad1854af22506383c3f0e57fb3c7f90984c5e8@172.16.63.221:46656", +// "peer_state": { +// "round_state": { +// "height": 7185, +// "round": 0, +// "step": 1, +// "start_time": "2018-05-12T13:57:27.438039872-07:00", +// "proposal": false, +// "proposal_block_parts_header": { +// "total": 0, +// "hash": "" +// }, +// "proposal_block_parts": null, +// "proposal_pol_round": -1, +// "proposal_pol": "_", +// "prevotes": "_", +// "precommits": "_", +// "last_commit_round": 0, +// "last_commit": "x", +// "catchup_commit_round": -1, +// "catchup_commit": "_" +// }, +// "stats": { +// "last_vote_height": 7184, +// "votes": 255, +// "last_block_part_height": 7184, +// "block_parts": 255 +// } +// } +// } +// ] +// } +// } // ``` -// UNSTABLE func DumpConsensusState() (*ctypes.ResultDumpConsensusState, error) { + // Get Peer consensus states. peers := p2pSwitch.Peers().List() - peerRoundStates := make([]ctypes.PeerRoundState, len(peers)) + peerStates := make([]ctypes.PeerStateInfo, len(peers)) for i, peer := range peers { peerState := peer.Get(types.PeerStateKey).(*cm.PeerState) - peerRoundState, err := peerState.GetRoundStateJSON() + peerStateJSON, err := peerState.ToJSON() if err != nil { return nil, err } - peerRoundStates[i] = ctypes.PeerRoundState{ - NodeAddress: p2p.IDAddressString(peer.ID(), peer.NodeInfo().ListenAddr), - PeerRoundState: peerRoundState, + peerStates[i] = ctypes.PeerStateInfo{ + // Peer basic info. + NodeAddress: p2p.IDAddressString(peer.ID(), peer.NodeInfo().ListenAddr), + // Peer consensus state. + PeerState: peerStateJSON, } } + // Get self round state. roundState, err := consensusState.GetRoundStateJSON() if err != nil { return nil, err } - return &ctypes.ResultDumpConsensusState{roundState, peerRoundStates}, nil + return &ctypes.ResultDumpConsensusState{roundState, peerStates}, nil +} + +// ConsensusState returns a concise summary of the consensus state. +// UNSTABLE +// +// ```shell +// curl 'localhost:46657/consensus_state' +// ``` +// +// ```go +// client := client.NewHTTP("tcp://0.0.0.0:46657", "/websocket") +// state, err := client.ConsensusState() +// ``` +// +// The above command returns JSON structured like this: +// +// ```json +//{ +// "jsonrpc": "2.0", +// "id": "", +// "result": { +// "round_state": { +// "height/round/step": "9336/0/1", +// "start_time": "2018-05-14T10:25:45.72595357-04:00", +// "proposal_block_hash": "", +// "locked_block_hash": "", +// "valid_block_hash": "", +// "height_vote_set": [ +// { +// "round": 0, +// "prevotes": [ +// "nil-Vote" +// ], +// "prevotes_bit_array": "BA{1:_} 0/10 = 0.00", +// "precommits": [ +// "nil-Vote" +// ], +// "precommits_bit_array": "BA{1:_} 0/10 = 0.00" +// } +// ] +// } +// } +//} +//``` +func ConsensusState() (*ctypes.ResultConsensusState, error) { + // Get self round state. + bz, err := consensusState.GetRoundStateSimpleJSON() + return &ctypes.ResultConsensusState{bz}, err } diff --git a/rpc/core/pipe.go b/rpc/core/pipe.go index 0bbead943..e93ba2f80 100644 --- a/rpc/core/pipe.go +++ b/rpc/core/pipe.go @@ -23,6 +23,7 @@ type Consensus interface { GetState() sm.State GetValidators() (int64, []*types.Validator) GetRoundStateJSON() ([]byte, error) + GetRoundStateSimpleJSON() ([]byte, error) } type P2P interface { diff --git a/rpc/core/routes.go b/rpc/core/routes.go index be3881c36..bf90d6fbd 100644 --- a/rpc/core/routes.go +++ b/rpc/core/routes.go @@ -25,6 +25,7 @@ var Routes = map[string]*rpc.RPCFunc{ "tx_search": rpc.NewRPCFunc(TxSearch, "query,prove"), "validators": rpc.NewRPCFunc(Validators, "height"), "dump_consensus_state": rpc.NewRPCFunc(DumpConsensusState, ""), + "consensus_state": rpc.NewRPCFunc(ConsensusState, ""), "unconfirmed_txs": rpc.NewRPCFunc(UnconfirmedTxs, ""), "num_unconfirmed_txs": rpc.NewRPCFunc(NumUnconfirmedTxs, ""), diff --git a/rpc/core/types/responses.go b/rpc/core/types/responses.go index 1df7038ae..18c545453 100644 --- a/rpc/core/types/responses.go +++ b/rpc/core/types/responses.go @@ -128,17 +128,21 @@ type ResultValidators struct { } // Info about the consensus state. -// Unstable +// UNSTABLE type ResultDumpConsensusState struct { - RoundState json.RawMessage `json:"round_state"` - PeerRoundStates []PeerRoundState `json:"peer_round_states"` + RoundState json.RawMessage `json:"round_state"` + Peers []PeerStateInfo `json:"peers"` } -// Raw JSON for the PeerRoundState -// Unstable -type PeerRoundState struct { - NodeAddress string `json:"node_address"` - PeerRoundState json.RawMessage `json:"peer_round_state"` +// UNSTABLE +type PeerStateInfo struct { + NodeAddress string `json:"node_address"` + PeerState json.RawMessage `json:"peer_state"` +} + +// UNSTABLE +type ResultConsensusState struct { + RoundState json.RawMessage `json:"round_state"` } // CheckTx result diff --git a/test/persist/test_failure_indices.sh b/test/persist/test_failure_indices.sh index dd630e1b7..f97cd718e 100644 --- a/test/persist/test_failure_indices.sh +++ b/test/persist/test_failure_indices.sh @@ -82,7 +82,7 @@ for failIndex in $(seq $failsStart $failsEnd); do echo "* Test FailIndex $failIndex" # test failure at failIndex - bash ./test/utils/txs.sh "localhost:46657" & + bash $(dirname $0)/txs.sh "localhost:46657" & start_procs 1 "$failIndex" # tendermint should already have exited when it hits the fail index diff --git a/test/utils/txs.sh b/test/persist/txs.sh similarity index 100% rename from test/utils/txs.sh rename to test/persist/txs.sh diff --git a/types/block.go b/types/block.go index 9cfef1f94..3004672c8 100644 --- a/types/block.go +++ b/types/block.go @@ -124,7 +124,7 @@ func (b *Block) MakePartSet(partSize int) *PartSet { } // HashesTo is a convenience function that checks if a block hashes to the given argument. -// A nil block never hashes to anything, and nothing hashes to a nil hash. +// Returns false if the block is nil or the hash is empty. func (b *Block) HashesTo(hash []byte) bool { if len(hash) == 0 { return false diff --git a/types/genesis_test.go b/types/genesis_test.go index 17ebf1cfc..bed4b90f5 100644 --- a/types/genesis_test.go +++ b/types/genesis_test.go @@ -1,9 +1,10 @@ package types import ( + "testing" + "github.com/stretchr/testify/assert" "github.com/tendermint/go-crypto" - "testing" ) func TestGenesisBad(t *testing.T) { diff --git a/types/vote_set.go b/types/vote_set.go index c5c72d435..a60d95daf 100644 --- a/types/vote_set.go +++ b/types/vote_set.go @@ -404,8 +404,8 @@ func (voteSet *VoteSet) HasAll() bool { return voteSet.sum == voteSet.valSet.TotalVotingPower() } -// Returns either a blockhash (or nil) that received +2/3 majority. -// If there exists no such majority, returns (nil, PartSetHeader{}, false). +// If there was a +2/3 majority for blockID, return blockID and true. +// Else, return the empty BlockID{} and false. func (voteSet *VoteSet) TwoThirdsMajority() (blockID BlockID, ok bool) { if voteSet == nil { return BlockID{}, false @@ -418,6 +418,9 @@ func (voteSet *VoteSet) TwoThirdsMajority() (blockID BlockID, ok bool) { return BlockID{}, false } +//-------------------------------------------------------------------------------- +// Strings and JSON + func (voteSet *VoteSet) String() string { if voteSet == nil { return "nil-VoteSet" @@ -454,6 +457,45 @@ func (voteSet *VoteSet) StringIndented(indent string) string { func (voteSet *VoteSet) MarshalJSON() ([]byte, error) { voteSet.mtx.Lock() defer voteSet.mtx.Unlock() + return cdc.MarshalJSON(VoteSetJSON{ + voteSet.voteStrings(), + voteSet.bitArrayString(), + voteSet.peerMaj23s, + }) +} + +// More human readable JSON of the vote set +// NOTE: insufficient for unmarshalling from (compressed votes) +// TODO: make the peerMaj23s nicer to read (eg just the block hash) +type VoteSetJSON struct { + Votes []string `json:"votes"` + VotesBitArray string `json:"votes_bit_array"` + PeerMaj23s map[P2PID]BlockID `json:"peer_maj_23s"` +} + +// Return the bit-array of votes including +// the fraction of power that has voted like: +// "BA{29:xx__x__x_x___x__x_______xxx__} 856/1304 = 0.66" +func (voteSet *VoteSet) BitArrayString() string { + voteSet.mtx.Lock() + defer voteSet.mtx.Unlock() + return voteSet.bitArrayString() +} + +func (voteSet *VoteSet) bitArrayString() string { + bAString := voteSet.votesBitArray.String() + voted, total, fracVoted := voteSet.sumTotalFrac() + return fmt.Sprintf("%s %d/%d = %.2f", bAString, voted, total, fracVoted) +} + +// Returns a list of votes compressed to more readable strings. +func (voteSet *VoteSet) VoteStrings() []string { + voteSet.mtx.Lock() + defer voteSet.mtx.Unlock() + return voteSet.voteStrings() +} + +func (voteSet *VoteSet) voteStrings() []string { voteStrings := make([]string, len(voteSet.votes)) for i, vote := range voteSet.votes { if vote == nil { @@ -462,13 +504,7 @@ func (voteSet *VoteSet) MarshalJSON() ([]byte, error) { voteStrings[i] = vote.String() } } - return cdc.MarshalJSON(struct { - Votes []string `json:"votes"` - VotesBitArray *cmn.BitArray `json:"votes_bit_array"` - PeerMaj23s map[P2PID]BlockID `json:"peer_maj_23s"` - }{ - voteStrings, voteSet.votesBitArray, voteSet.peerMaj23s, - }) + return voteStrings } func (voteSet *VoteSet) StringShort() string { @@ -477,8 +513,16 @@ func (voteSet *VoteSet) StringShort() string { } voteSet.mtx.Lock() defer voteSet.mtx.Unlock() - return fmt.Sprintf(`VoteSet{H:%v R:%v T:%v +2/3:%v %v %v}`, - voteSet.height, voteSet.round, voteSet.type_, voteSet.maj23, voteSet.votesBitArray, voteSet.peerMaj23s) + _, _, frac := voteSet.sumTotalFrac() + return fmt.Sprintf(`VoteSet{H:%v R:%v T:%v +2/3:%v(%v) %v %v}`, + voteSet.height, voteSet.round, voteSet.type_, voteSet.maj23, frac, voteSet.votesBitArray, voteSet.peerMaj23s) +} + +// return the power voted, the total, and the fraction +func (voteSet *VoteSet) sumTotalFrac() (int64, int64, float64) { + voted, total := voteSet.sum, voteSet.valSet.TotalVotingPower() + fracVoted := float64(voted) / float64(total) + return voted, total, fracVoted } //-------------------------------------------------------------------------------- diff --git a/version/version.go b/version/version.go index 1a2c64962..c7d1d03a0 100644 --- a/version/version.go +++ b/version/version.go @@ -4,13 +4,13 @@ package version const ( Maj = "0" Min = "19" - Fix = "2" + Fix = "3" ) var ( // Version is the current version of Tendermint // Must be a string because scripts like dist.sh read this file. - Version = "0.19.2" + Version = "0.19.3" // GitCommit is the current HEAD set using ldflags. GitCommit string