consensus

package
v0.0.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 18, 2024 License: Apache-2.0 Imports: 53 Imported by: 0

README

Consensus

See the consensus spec for more information.

Documentation

Index

Constants

View Source 
const (
	StateChannel       = byte(0x20)
	DataChannel        = byte(0x21)
	VoteChannel        = byte(0x22)
	VoteSetBitsChannel = byte(0x23)
)
View Source 
const (
	// MetricsSubsystem is a subsystem shared by all metrics exposed by this
	// package.
	MetricsSubsystem = "consensus"
)

Variables

View Source 
var (
	ErrPeerStateHeightRegression = errors.New("error peer state height regression")
	ErrPeerStateInvalidStartTime = errors.New("error peer state invalid startTime")
)
View Source 
var (
	ErrInvalidProposalSignature   = errors.New("error invalid proposal signature")
	ErrInvalidProposalPOLRound    = errors.New("error invalid proposal POL round")
	ErrAddingVote                 = errors.New("error adding vote")
	ErrSignatureFoundInPastBlocks = errors.New("found signature from the same key")
)

Consensus sentinel errors

Functions

func CompareHRS 

func CompareHRS(h1 int64, r1 int32, s1 cstypes.RoundStepType, h2 int64, r2 int32, s2 cstypes.RoundStepType) int

func IsDataCorruptionError 

func IsDataCorruptionError(err error) bool

IsDataCorruptionError returns true if data has been corrupted inside WAL.

func MsgToProto 

func MsgToProto(msg Message) (proto.Message, error)

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 RunReplayFile 

func RunReplayFile(config cfg.BaseConfig, csConfig *cfg.ConsensusConfig, console bool)

replay the wal file

func WALGenerateNBlocks 

func WALGenerateNBlocks(t *testing.T, wr io.Writer, numBlocks int, config *cfg.Config) (err error)

WALGenerateNBlocks generates a consensus WAL. It does this by spinning up a stripped down version of node (proxy app, event bus, consensus state) with a persistent kvstore application and special consensus wal instance (byteBufferWAL) and waits until numBlocks are created. If the node fails to produce given numBlocks, it returns an error.

func WALToProto 

func WALToProto(msg WALMessage) (*cmtcons.WALMessage, error)

WALToProto takes a WAL message and return a proto walMessage and error

func WALWithNBlocks 

func WALWithNBlocks(t *testing.T, numBlocks int, config *cfg.Config) (data []byte, err error)

WALWithNBlocks returns a WAL content with numBlocks.

Types

type BaseWAL 

type BaseWAL struct {
	service.BaseService
	// contains filtered or unexported fields
}

Write ahead logger writes msgs to disk before they are processed. Can be used for crash-recovery and deterministic replay. TODO: currently the wal is overwritten during replay catchup, give it a mode so it's either reading or appending - must read to end to start appending again.

func NewWAL 

func NewWAL(walFile string, groupOptions ...func(*auto.Group)) (*BaseWAL, error)

NewWAL returns a new write-ahead logger based on `baseWAL`, which implements WAL. It's flushed and synced to disk every 2s and once when stopped.

func (*BaseWAL) FlushAndSync 

func (wal *BaseWAL) FlushAndSync() error

FlushAndSync flushes and fsync's the underlying group's data to disk. See auto#FlushAndSync

func (*BaseWAL) Group 

func (wal *BaseWAL) Group() *auto.Group

func (*BaseWAL) OnStart 

func (wal *BaseWAL) OnStart() error

func (*BaseWAL) OnStop 

func (wal *BaseWAL) OnStop()

Stop the underlying autofile group. Use Wait() to ensure it's finished shutting down before cleaning up files.

func (*BaseWAL) SearchForEndHeight 

func (wal *BaseWAL) SearchForEndHeight(
	height int64,
	options *WALSearchOptions,
) (rd io.ReadCloser, found bool, err error)

SearchForEndHeight searches for the EndHeightMessage with the given height and returns an auto.GroupReader, whenever it was found or not and an error. Group reader will be nil if found equals false.

CONTRACT: caller must close group reader.

func (*BaseWAL) SetFlushInterval 

func (wal *BaseWAL) SetFlushInterval(i time.Duration)

SetFlushInterval allows us to override the periodic flush interval for the WAL.

func (*BaseWAL) SetLogger 

func (wal *BaseWAL) SetLogger(l log.Logger)

func (*BaseWAL) Wait 

func (wal *BaseWAL) Wait()

Wait for the underlying autofile group to finish shutting down so it's safe to cleanup files.

func (*BaseWAL) Write 

func (wal *BaseWAL) Write(msg WALMessage) error

Write is called in newStep and for each receive on the peerMsgQueue and the timeoutTicker. NOTE: does not call fsync()

func (*BaseWAL) WriteSync 

func (wal *BaseWAL) WriteSync(msg WALMessage) error

WriteSync is called when we receive a msg from ourselves so that we write to disk before sending signed messages. NOTE: calls fsync()

type BlockPartMessage 

type BlockPartMessage struct {
	Height int64
	Round  int32
	Part   *types.Part
}

BlockPartMessage is sent when gossipping a piece of the proposed block.

func (*BlockPartMessage) String 

func (m *BlockPartMessage) String() string

String returns a string representation.

func (*BlockPartMessage) ValidateBasic 

func (m *BlockPartMessage) ValidateBasic() error

ValidateBasic performs basic validation.

type DataCorruptionError 

type DataCorruptionError struct {
	// contains filtered or unexported fields
}

DataCorruptionError is an error that occures if data on disk was corrupted.

func (DataCorruptionError) Cause 

func (e DataCorruptionError) Cause() error

func (DataCorruptionError) Error 

func (e DataCorruptionError) Error() string

type EndHeightMessage 

type EndHeightMessage struct {
	Height int64 `json:"height"`
}

EndHeightMessage marks the end of the given height inside WAL. @internal used by scripts/wal2json util.

type Handshaker 

type Handshaker struct {
	// contains filtered or unexported fields
}

func NewHandshaker 

func NewHandshaker(stateStore sm.Store, state sm.State,
	store sm.BlockStore, genDoc *types.GenesisDoc) *Handshaker

func (*Handshaker) Handshake 

func (h *Handshaker) Handshake(proxyApp proxy.AppConns) error

TODO: retry the handshake/replay if it fails ?

func (*Handshaker) HandshakeWithContext 

func (h *Handshaker) HandshakeWithContext(ctx context.Context, proxyApp proxy.AppConns) error

HandshakeWithContext is cancellable version of Handshake

func (*Handshaker) NBlocks 

func (h *Handshaker) NBlocks() int

NBlocks returns the number of blocks applied to the state.

func (*Handshaker) ReplayBlocks 

func (h *Handshaker) ReplayBlocks(
	state sm.State,
	appHash []byte,
	appBlockHeight int64,
	proxyApp proxy.AppConns,
) ([]byte, error)

ReplayBlocks replays all blocks since appBlockHeight and ensures the result matches the current state. Returns the final AppHash or an error.

func (*Handshaker) ReplayBlocksWithContext 

func (h *Handshaker) ReplayBlocksWithContext(
	ctx context.Context,
	state sm.State,
	appHash []byte,
	appBlockHeight int64,
	proxyApp proxy.AppConns,
) ([]byte, error)

ReplayBlocksWithContext is cancellable version of ReplayBlocks.

func (*Handshaker) SetEventBus 

func (h *Handshaker) SetEventBus(eventBus types.BlockEventPublisher)

SetEventBus - sets the event bus for publishing block related events. If not called, it defaults to types.NopEventBus.

func (*Handshaker) SetLogger 

func (h *Handshaker) SetLogger(l log.Logger)

type HasVoteMessage 

type HasVoteMessage struct {
	Height int64
	Round  int32
	Type   cmtproto.SignedMsgType
	Index  int32
}

HasVoteMessage is sent to indicate that a particular vote has been received.

func (*HasVoteMessage) String 

func (m *HasVoteMessage) String() string

String returns a string representation.

func (*HasVoteMessage) ValidateBasic 

func (m *HasVoteMessage) ValidateBasic() error

ValidateBasic performs basic validation.

type Message 

type Message interface {
	ValidateBasic() error
}

Message is a message that can be sent and received on the Reactor

func MsgFromProto 

func MsgFromProto(p proto.Message) (Message, error)

MsgFromProto takes a consensus proto message and returns the native go type

type Metrics 

type Metrics struct {
	// Height of the chain.
	Height metrics.Gauge

	// Last height signed by this validator if the node is a validator.
	ValidatorLastSignedHeight metrics.Gauge `metrics_labels:"validator_address"`

	// Number of rounds.
	Rounds metrics.Gauge

	// Histogram of round duration.
	RoundDurationSeconds metrics.Histogram `metrics_buckettype:"exprange" metrics_bucketsizes:"0.1, 100, 8"`

	// Number of validators.
	Validators metrics.Gauge
	// Total power of all validators.
	ValidatorsPower metrics.Gauge
	// Power of a validator.
	ValidatorPower metrics.Gauge `metrics_labels:"validator_address"`
	// Amount of blocks missed per validator.
	ValidatorMissedBlocks metrics.Gauge `metrics_labels:"validator_address"`
	// Number of validators who did not sign.
	MissingValidators metrics.Gauge
	// Total power of the missing validators.
	MissingValidatorsPower metrics.Gauge
	// Number of validators who tried to double sign.
	ByzantineValidators metrics.Gauge
	// Total power of the byzantine validators.
	ByzantineValidatorsPower metrics.Gauge

	// Time between this and the last block.
	BlockIntervalSeconds metrics.Histogram

	// Number of transactions.
	NumTxs metrics.Gauge
	// Size of the block.
	BlockSizeBytes metrics.Gauge
	// Total number of transactions.
	TotalTxs metrics.Gauge
	// The latest block height.
	CommittedHeight metrics.Gauge `metrics_name:"latest_block_height"`

	// Number of block parts transmitted by each peer.
	BlockParts metrics.Counter `metrics_labels:"peer_id"`

	// Number of times we received a duplicate block part
	DuplicateBlockPart metrics.Counter

	// Number of times we received a duplicate vote
	DuplicateVote metrics.Counter

	// Histogram of durations for each step in the consensus protocol.
	StepDurationSeconds metrics.Histogram `metrics_labels:"step" metrics_buckettype:"exprange" metrics_bucketsizes:"0.1, 100, 8"`

	// Number of block parts received by the node, separated by whether the part
	// was relevant to the block the node is trying to gather or not.
	BlockGossipPartsReceived metrics.Counter `metrics_labels:"matches_current"`

	// QuroumPrevoteMessageDelay is the interval in seconds between the proposal
	// timestamp and the timestamp of the earliest prevote that achieved a quorum
	// during the prevote step.
	//
	// To compute it, sum the voting power over each prevote received, in increasing
	// order of timestamp. The timestamp of the first prevote to increase the sum to
	// be above 2/3 of the total voting power of the network defines the endpoint
	// the endpoint of the interval. Subtract the proposal timestamp from this endpoint
	// to obtain the quorum delay.
	//metrics:Interval in seconds between the proposal timestamp and the timestamp of the earliest prevote that achieved a quorum.
	QuorumPrevoteDelay metrics.Gauge `metrics_labels:"proposer_address"`

	// FullPrevoteDelay is the interval in seconds between the proposal
	// timestamp and the timestamp of the latest prevote in a round where 100%
	// of the voting power on the network issued prevotes.
	//metrics:Interval in seconds between the proposal timestamp and the timestamp of the latest prevote in a round where all validators voted.
	FullPrevoteDelay metrics.Gauge `metrics_labels:"proposer_address"`

	// VoteExtensionReceiveCount is the number of vote extensions received by this
	// node. The metric is annotated by the status of the vote extension from the
	// application, either 'accepted' or 'rejected'.
	VoteExtensionReceiveCount metrics.Counter `metrics_labels:"status"`

	// ProposalReceiveCount is the total number of proposals received by this node
	// since process start.
	// The metric is annotated by the status of the proposal from the application,
	// either 'accepted' or 'rejected'.
	ProposalReceiveCount metrics.Counter `metrics_labels:"status"`

	// ProposalCreationCount is the total number of proposals created by this node
	// since process start.
	// The metric is annotated by the status of the proposal from the application,
	// either 'accepted' or 'rejected'.
	ProposalCreateCount metrics.Counter

	// RoundVotingPowerPercent is the percentage of the total voting power received
	// with a round. The value begins at 0 for each round and approaches 1.0 as
	// additional voting power is observed. The metric is labeled by vote type.
	RoundVotingPowerPercent metrics.Gauge `metrics_labels:"vote_type"`

	// LateVotes stores the number of votes that were received by this node that
	// correspond to earlier heights and rounds than this node is currently
	// in.
	LateVotes metrics.Counter `metrics_labels:"vote_type"`
	// contains filtered or unexported fields
}

Metrics contains metrics exposed by this package.

func NopMetrics 

func NopMetrics() *Metrics

func PrometheusMetrics 

func PrometheusMetrics(namespace string, labelsAndValues ...string) *Metrics

func (*Metrics) MarkLateVote 

func (m *Metrics) MarkLateVote(vt cmtproto.SignedMsgType)

func (*Metrics) MarkProposalProcessed 

func (m *Metrics) MarkProposalProcessed(accepted bool)

func (*Metrics) MarkRound 

func (m *Metrics) MarkRound(r int32, st time.Time)

func (*Metrics) MarkStep 

func (m *Metrics) MarkStep(s cstypes.RoundStepType)

func (*Metrics) MarkVoteExtensionReceived 

func (m *Metrics) MarkVoteExtensionReceived(accepted bool)

func (*Metrics) MarkVoteReceived 

func (m *Metrics) MarkVoteReceived(vt cmtproto.SignedMsgType, power, totalPower int64)

type NewRoundStepMessage 

type NewRoundStepMessage struct {
	Height                int64
	Round                 int32
	Step                  cstypes.RoundStepType
	SecondsSinceStartTime int64
	LastCommitRound       int32
}

NewRoundStepMessage is sent for every step taken in the ConsensusState. For every height/round/step transition

func (*NewRoundStepMessage) String 

func (m *NewRoundStepMessage) String() string

String returns a string representation.

func (*NewRoundStepMessage) ValidateBasic 

func (m *NewRoundStepMessage) ValidateBasic() error

ValidateBasic performs basic validation.

func (*NewRoundStepMessage) ValidateHeight 

func (m *NewRoundStepMessage) ValidateHeight(initialHeight int64) error

ValidateHeight validates the height given the chain's initial height.

type NewValidBlockMessage 

type NewValidBlockMessage struct {
	Height             int64
	Round              int32
	BlockPartSetHeader types.PartSetHeader
	BlockParts         *bits.BitArray
	IsCommit           bool
}

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.

func (*NewValidBlockMessage) String 

func (m *NewValidBlockMessage) String() string

String returns a string representation.

func (*NewValidBlockMessage) ValidateBasic 

func (m *NewValidBlockMessage) ValidateBasic() error

ValidateBasic performs basic validation.

type PeerState 

type PeerState struct {
	PRS   cstypes.PeerRoundState `json:"round_state"` // Exposed.
	Stats *peerStateStats        `json:"stats"`       // Exposed.
	// contains filtered or unexported fields
}

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.

func NewPeerState 

func NewPeerState(peer p2p.Peer) *PeerState

NewPeerState returns a new PeerState for the given Peer

func (*PeerState) ApplyHasVoteMessage 

func (ps *PeerState) ApplyHasVoteMessage(msg *HasVoteMessage)

ApplyHasVoteMessage updates the peer state for the new vote.

func (*PeerState) ApplyNewRoundStepMessage 

func (ps *PeerState) ApplyNewRoundStepMessage(msg *NewRoundStepMessage)

ApplyNewRoundStepMessage updates the peer state for the new round.

func (*PeerState) ApplyNewValidBlockMessage 

func (ps *PeerState) ApplyNewValidBlockMessage(msg *NewValidBlockMessage)

ApplyNewValidBlockMessage updates the peer state for the new valid block.

func (*PeerState) ApplyProposalPOLMessage 

func (ps *PeerState) ApplyProposalPOLMessage(msg *ProposalPOLMessage)

ApplyProposalPOLMessage updates the peer state for the new proposal POL.

func (*PeerState) ApplyVoteSetBitsMessage 

func (ps *PeerState) ApplyVoteSetBitsMessage(msg *VoteSetBitsMessage, ourVotes *bits.BitArray)

ApplyVoteSetBitsMessage updates the peer state for the bit-array of votes it claims to have for the corresponding BlockID. `ourVotes` is a BitArray of votes we have for msg.BlockID NOTE: if ourVotes is nil (e.g. msg.Height < rs.Height), we conservatively overwrite ps's votes w/ msg.Votes.

func (*PeerState) BlockPartsSent 

func (ps *PeerState) BlockPartsSent() int

BlockPartsSent returns the number of useful block parts the peer has sent us.

func (*PeerState) EnsureVoteBitArrays 

func (ps *PeerState) EnsureVoteBitArrays(height int64, numValidators int)

EnsureVoteBitArrays ensures the bit-arrays have been allocated for tracking what votes this peer has received. NOTE: It's important to make sure that numValidators actually matches what the node sees as the number of validators for height.

func (*PeerState) GetHeight 

func (ps *PeerState) GetHeight() int64

GetHeight returns an atomic snapshot of the PeerRoundState's height used by the mempool to ensure peers are caught up before broadcasting new txs

func (*PeerState) GetRoundState 

func (ps *PeerState) GetRoundState() *cstypes.PeerRoundState

GetRoundState returns an shallow copy of the PeerRoundState. There's no point in mutating it since it won't change PeerState.

func (*PeerState) InitProposalBlockParts 

func (ps *PeerState) InitProposalBlockParts(partSetHeader types.PartSetHeader)

InitProposalBlockParts initializes the peer's proposal block parts header and bit array.

func (*PeerState) MarshalJSON 

func (ps *PeerState) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaler interface.

func (*PeerState) PickSendVote 

func (ps *PeerState) PickSendVote(votes types.VoteSetReader) bool

PickSendVote picks a vote and sends it to the peer. Returns true if vote was sent.

func (*PeerState) PickVoteToSend 

func (ps *PeerState) PickVoteToSend(votes types.VoteSetReader) (vote *types.Vote, ok bool)

PickVoteToSend picks a vote to send to the peer. Returns true if a vote was picked. NOTE: `votes` must be the correct Size() for the Height().

func (*PeerState) RecordBlockPart 

func (ps *PeerState) RecordBlockPart() int

RecordBlockPart increments internal block part related statistics for this peer. It returns the total number of added block parts.

func (*PeerState) RecordVote 

func (ps *PeerState) RecordVote() int

RecordVote increments internal votes related statistics for this peer. It returns the total number of added votes.

func (*PeerState) SetHasProposal 

func (ps *PeerState) SetHasProposal(proposal *types.Proposal)

SetHasProposal sets the given proposal as known for the peer.

func (*PeerState) SetHasProposalBlockPart 

func (ps *PeerState) SetHasProposalBlockPart(height int64, round int32, index int)

SetHasProposalBlockPart sets the given block part index as known for the peer.

func (*PeerState) SetHasVote 

func (ps *PeerState) SetHasVote(vote *types.Vote)

SetHasVote sets the given vote as known by the peer

func (*PeerState) SetLogger 

func (ps *PeerState) SetLogger(logger log.Logger) *PeerState

SetLogger allows to set a logger on the peer state. Returns the peer state itself.

func (*PeerState) String 

func (ps *PeerState) String() string

String returns a string representation of the PeerState

func (*PeerState) StringIndented 

func (ps *PeerState) StringIndented(indent string) string

StringIndented returns a string representation of the PeerState

func (*PeerState) VotesSent 

func (ps *PeerState) VotesSent() int

VotesSent returns the number of blocks for which peer has been sending us votes.

type ProposalMessage 

type ProposalMessage struct {
	Proposal *types.Proposal
}

ProposalMessage is sent when a new block is proposed.

func (*ProposalMessage) String 

func (m *ProposalMessage) String() string

String returns a string representation.

func (*ProposalMessage) ValidateBasic 

func (m *ProposalMessage) ValidateBasic() error

ValidateBasic performs basic validation.

type ProposalPOLMessage 

type ProposalPOLMessage struct {
	Height           int64
	ProposalPOLRound int32
	ProposalPOL      *bits.BitArray
}

ProposalPOLMessage is sent when a previous proposal is re-proposed.

func (*ProposalPOLMessage) String 

func (m *ProposalPOLMessage) String() string

String returns a string representation.

func (*ProposalPOLMessage) ValidateBasic 

func (m *ProposalPOLMessage) ValidateBasic() error

ValidateBasic performs basic validation.

type Reactor 

type Reactor struct {
	p2p.BaseReactor // BaseService + p2p.Switch

	Metrics *Metrics
	// contains filtered or unexported fields
}

Reactor defines a reactor for the consensus service.

func NewReactor 

func NewReactor(consensusState *State, waitSync bool, options ...ReactorOption) *Reactor

NewReactor returns a new Reactor with the given consensusState.

func (*Reactor) AddPeer 

func (conR *Reactor) AddPeer(peer p2p.Peer)

AddPeer implements Reactor by spawning multiple gossiping goroutines for the peer.

func (*Reactor) GetChannels 

func (conR *Reactor) GetChannels() []*p2p.ChannelDescriptor

GetChannels implements Reactor

func (*Reactor) InitPeer 

func (conR *Reactor) InitPeer(peer p2p.Peer) p2p.Peer

InitPeer implements Reactor by creating a state for the peer.

func (*Reactor) OnStart 

func (conR *Reactor) OnStart() error

OnStart implements BaseService by subscribing to events, which later will be broadcasted to other peers and starting state if we're not in block sync.

func (*Reactor) OnStop 

func (conR *Reactor) OnStop()

OnStop implements BaseService by unsubscribing from events and stopping state.

func (*Reactor) Receive 

func (conR *Reactor) Receive(e p2p.Envelope)

Receive implements Reactor NOTE: We process these messages even when we're block_syncing. Messages affect either a peer state or the consensus state. Peer state updates can happen in parallel, but processing of proposals, block parts, and votes are ordered by the receiveRoutine NOTE: blocks on consensus state for proposals, block parts, and votes

func (*Reactor) RemovePeer 

func (conR *Reactor) RemovePeer(p2p.Peer, interface{})

RemovePeer is a noop.

func (*Reactor) SetEventBus 

func (conR *Reactor) SetEventBus(b *types.EventBus)

SetEventBus sets event bus.

func (*Reactor) String 

func (conR *Reactor) String() string

String returns a string representation of the Reactor. NOTE: For now, it is just a hard-coded string to avoid accessing unprotected shared variables. TODO: improve!

func (*Reactor) StringIndented 

func (conR *Reactor) StringIndented(indent string) string

StringIndented returns an indented string representation of the Reactor

func (*Reactor) SwitchToConsensus 

func (conR *Reactor) SwitchToConsensus(state sm.State, skipWAL bool)

SwitchToConsensus switches from block_sync mode to consensus mode. It resets the state, turns off block_sync, and starts the consensus state-machine

func (*Reactor) WaitSync 

func (conR *Reactor) WaitSync() bool

WaitSync returns whether the consensus reactor is waiting for state/block sync.

type ReactorOption 

type ReactorOption func(*Reactor)

func ReactorMetrics 

func ReactorMetrics(metrics *Metrics) ReactorOption

ReactorMetrics sets the metrics

type State 

type State struct {
	service.BaseService

	cstypes.RoundState
	// contains filtered or unexported fields
}

State handles execution of the consensus algorithm. It processes votes and proposals, and upon reaching agreement, commits blocks to the chain and executes them against the application. The internal state machine receives input from peers, the internal validator, and from a timer.

func NewState 

func NewState(
	config *cfg.ConsensusConfig,
	state sm.State,
	blockExec *sm.BlockExecutor,
	blockStore sm.BlockStore,
	txNotifier txNotifier,
	evpool evidencePool,
	options ...StateOption,
) *State

NewState returns a new State.

func (*State) AddProposalBlockPart 

func (cs *State) AddProposalBlockPart(height int64, round int32, part *types.Part, peerID p2p.ID) error

AddProposalBlockPart inputs a part of the proposal block.

func (*State) AddVote 

func (cs *State) AddVote(vote *types.Vote, peerID p2p.ID) (added bool, err error)

AddVote inputs a vote.

func (*State) GetLastHeight 

func (cs *State) GetLastHeight() int64

GetLastHeight returns the last height committed. If there were no blocks, returns 0.

func (*State) GetRoundState 

func (cs *State) GetRoundState() *cstypes.RoundState

GetRoundState returns a shallow copy of the internal consensus state.

func (*State) GetRoundStateJSON 

func (cs *State) GetRoundStateJSON() ([]byte, error)

GetRoundStateJSON returns a json of RoundState.

func (*State) GetRoundStateSimpleJSON 

func (cs *State) GetRoundStateSimpleJSON() ([]byte, error)

GetRoundStateSimpleJSON returns a json of RoundStateSimple

func (*State) GetState 

func (cs *State) GetState() sm.State

GetState returns a copy of the chain state.

func (*State) GetValidators 

func (cs *State) GetValidators() (int64, []*types.Validator)

GetValidators returns a copy of the current validators.

func (*State) LoadCommit 

func (cs *State) LoadCommit(height int64) *types.Commit

LoadCommit loads the commit for a given height.

func (*State) OnStart 

func (cs *State) OnStart() error

OnStart loads the latest state via the WAL, and starts the timeout and receive routines.

func (*State) OnStop 

func (cs *State) OnStop()

OnStop implements service.Service.

func (*State) OpenWAL 

func (cs *State) OpenWAL(walFile string) (WAL, error)

OpenWAL opens a file to log all consensus messages and timeouts for deterministic accountability.

func (*State) ReplayFile 

func (cs *State) ReplayFile(file string, console bool) error

Replay msgs in file or start the console

func (*State) SetEventBus 

func (cs *State) SetEventBus(b *types.EventBus)

SetEventBus sets event bus.

func (*State) SetLogger 

func (cs *State) SetLogger(l log.Logger)

SetLogger implements Service.

func (*State) SetPrivValidator 

func (cs *State) SetPrivValidator(priv types.PrivValidator)

SetPrivValidator sets the private validator account for signing votes. It immediately requests pubkey and caches it.

func (*State) SetProposal 

func (cs *State) SetProposal(proposal *types.Proposal, peerID p2p.ID) error

SetProposal inputs a proposal.

func (*State) SetProposalAndBlock 

func (cs *State) SetProposalAndBlock(
	proposal *types.Proposal,
	block *types.Block,
	parts *types.PartSet,
	peerID p2p.ID,
) error

SetProposalAndBlock inputs the proposal and all block parts.

func (*State) SetTimeoutTicker 

func (cs *State) SetTimeoutTicker(timeoutTicker TimeoutTicker)

SetTimeoutTicker sets the local timer. It may be useful to overwrite for testing.

func (*State) String 

func (cs *State) String() string

String returns a string.

func (*State) Wait 

func (cs *State) Wait()

Wait waits for the the main routine to return. NOTE: be sure to Stop() the event switch and drain any event channels or this may deadlock

type StateOption 

type StateOption func(*State)

StateOption sets an optional parameter on the State.

func OfflineStateSyncHeight 

func OfflineStateSyncHeight(height int64) StateOption

OfflineStateSyncHeight indicates the height at which the node statesync offline - before booting sets the metrics.

func StateMetrics 

func StateMetrics(metrics *Metrics) StateOption

StateMetrics sets the metrics.

type TimedWALMessage 

type TimedWALMessage struct {
	Time time.Time  `json:"time"`
	Msg  WALMessage `json:"msg"`
}

TimedWALMessage wraps WALMessage and adds Time for debugging purposes.

type TimeoutTicker 

type TimeoutTicker interface {
	Start() error
	Stop() error
	Chan() <-chan timeoutInfo       // on which to receive a timeout
	ScheduleTimeout(ti timeoutInfo) // reset the timer

	SetLogger(log.Logger)
}

TimeoutTicker is a timer that schedules timeouts conditional on the height/round/step in the timeoutInfo. The timeoutInfo.Duration may be non-positive.

func NewTimeoutTicker 

func NewTimeoutTicker() TimeoutTicker

NewTimeoutTicker returns a new TimeoutTicker.

type VoteMessage 

type VoteMessage struct {
	Vote *types.Vote
}

VoteMessage is sent when voting for a proposal (or lack thereof).

func (*VoteMessage) String 

func (m *VoteMessage) String() string

String returns a string representation.

func (*VoteMessage) ValidateBasic 

func (m *VoteMessage) ValidateBasic() error

ValidateBasic checks whether the vote within the message is well-formed.

type VoteSetBitsMessage 

type VoteSetBitsMessage struct {
	Height  int64
	Round   int32
	Type    cmtproto.SignedMsgType
	BlockID types.BlockID
	Votes   *bits.BitArray
}

VoteSetBitsMessage is sent to communicate the bit-array of votes seen for the BlockID.

func (*VoteSetBitsMessage) String 

func (m *VoteSetBitsMessage) String() string

String returns a string representation.

func (*VoteSetBitsMessage) ValidateBasic 

func (m *VoteSetBitsMessage) ValidateBasic() error

ValidateBasic performs basic validation.

type VoteSetMaj23Message 

type VoteSetMaj23Message struct {
	Height  int64
	Round   int32
	Type    cmtproto.SignedMsgType
	BlockID types.BlockID
}

VoteSetMaj23Message is sent to indicate that a given BlockID has seen +2/3 votes.

func (*VoteSetMaj23Message) String 

func (m *VoteSetMaj23Message) String() string

String returns a string representation.

func (*VoteSetMaj23Message) ValidateBasic 

func (m *VoteSetMaj23Message) ValidateBasic() error

ValidateBasic performs basic validation.

type WAL 

type WAL interface {
	Write(WALMessage) error
	WriteSync(WALMessage) error
	FlushAndSync() error

	SearchForEndHeight(height int64, options *WALSearchOptions) (rd io.ReadCloser, found bool, err error)

	// service methods
	Start() error
	Stop() error
	Wait()
}

WAL is an interface for any write-ahead logger.

type WALDecoder 

type WALDecoder struct {
	// contains filtered or unexported fields
}

A WALDecoder reads and decodes custom-encoded WAL messages from an input stream. See WALEncoder for the format used.

It will also compare the checksums and make sure data size is equal to the length from the header. If that is not the case, error will be returned.

func NewWALDecoder 

func NewWALDecoder(rd io.Reader) *WALDecoder

NewWALDecoder returns a new decoder that reads from rd.

func (*WALDecoder) Decode 

func (dec *WALDecoder) Decode() (*TimedWALMessage, error)

Decode reads the next custom-encoded value from its reader and returns it.

type WALEncoder 

type WALEncoder struct {
	// contains filtered or unexported fields
}

A WALEncoder writes custom-encoded WAL messages to an output stream.

Format: 4 bytes CRC sum + 4 bytes length + arbitrary-length value

func NewWALEncoder 

func NewWALEncoder(wr io.Writer) *WALEncoder

NewWALEncoder returns a new encoder that writes to wr.

func (*WALEncoder) Encode 

func (enc *WALEncoder) Encode(v *TimedWALMessage) error

Encode writes the custom encoding of v to the stream. It returns an error if the encoded size of v is greater than 1MB. Any error encountered during the write is also returned.

type WALMessage 

type WALMessage interface{}

func WALFromProto 

func WALFromProto(msg *cmtcons.WALMessage) (WALMessage, error)

WALFromProto takes a proto wal message and return a consensus walMessage and error

type WALSearchOptions 

type WALSearchOptions struct {
	// IgnoreDataCorruptionErrors set to true will result in skipping data corruption errors.
	IgnoreDataCorruptionErrors bool
}

WALSearchOptions are optional arguments to SearchForEndHeight.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.