iotex-core: github.com/iotexproject/iotex-core/consensus/consensusfsm Index | Files

package consensusfsm

import "github.com/iotexproject/iotex-core/consensus/consensusfsm"

Index

Package Files

consensusevent.go context.go endorsedmessage.go fsm.go

Constants

const (

    // BackdoorEvent indicates a backdoor event type
    BackdoorEvent fsm.EventType = "E_BACKDOOR"

    // InitState refers the initial state of the consensus fsm
    InitState = sPrepare
)

Variables

var (
    // ErrEvtCast indicates the error of casting the event
    ErrEvtCast = errors.New("error when casting the event")
    // ErrMsgCast indicates the error of casting to endorsed message
    ErrMsgCast = errors.New("error when casting to endorsed message")
    // ErrEvtConvert indicates the error of converting the event from/to the proto message
    ErrEvtConvert = errors.New("error when converting the event from/to the proto message")
    // ErrEvtType represents an unexpected event type error
    ErrEvtType = errors.New("error when check the event type")
)

type Config Uses

type Config struct {
    EventChanSize                uint          `yaml:"eventChanSize"`
    UnmatchedEventTTL            time.Duration `yaml:"unmatchedEventTTL"`
    UnmatchedEventInterval       time.Duration `yaml:"unmatchedEventInterval"`
    AcceptBlockTTL               time.Duration `yaml:"acceptBlockTTL"`
    AcceptProposalEndorsementTTL time.Duration `yaml:"acceptProposalEndorsementTTL"`
    AcceptLockEndorsementTTL     time.Duration `yaml:"acceptLockEndorsementTTL"`
    CommitTTL                    time.Duration `yaml:"commitTTL"`
}

Config defines a set of time durations used in fsm and event queue size

type ConsensusEvent Uses

type ConsensusEvent struct {
    fsm.Event
    // contains filtered or unexported fields
}

ConsensusEvent defines the event used in the fsm

func NewConsensusEvent Uses

func NewConsensusEvent(
    eventType fsm.EventType,
    data interface{},
    height uint64,
    round uint32,
    creationTime time.Time,
) *ConsensusEvent

NewConsensusEvent creates a new consensus event

func (*ConsensusEvent) Data Uses

func (e *ConsensusEvent) Data() interface{}

Data returns the data of the event

func (*ConsensusEvent) Height Uses

func (e *ConsensusEvent) Height() uint64

Height is the height of the event

func (*ConsensusEvent) Round Uses

func (e *ConsensusEvent) Round() uint32

Round is the round of the event

func (*ConsensusEvent) Timestamp Uses

func (e *ConsensusEvent) Timestamp() time.Time

Timestamp is the creation time of the event

func (*ConsensusEvent) Type Uses

func (e *ConsensusEvent) Type() fsm.EventType

Type returns the event type

type ConsensusFSM Uses

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

ConsensusFSM wraps over the general purpose FSM and implements the consensus logic

func NewConsensusFSM Uses

func NewConsensusFSM(cfg Config, ctx Context, clock clock.Clock) (*ConsensusFSM, error)

NewConsensusFSM returns a new fsm

func (*ConsensusFSM) BackToPrepare Uses

func (m *ConsensusFSM) BackToPrepare(delay time.Duration) (fsm.State, error)

BackToPrepare produces an ePrepare event after delay

func (*ConsensusFSM) Calibrate Uses

func (m *ConsensusFSM) Calibrate(height uint64)

Calibrate calibrates the state if necessary

func (*ConsensusFSM) CurrentState Uses

func (m *ConsensusFSM) CurrentState() fsm.State

CurrentState returns the current state

func (*ConsensusFSM) NumPendingEvents Uses

func (m *ConsensusFSM) NumPendingEvents() int

NumPendingEvents returns the number of pending events

func (*ConsensusFSM) ProduceReceiveBlockEvent Uses

func (m *ConsensusFSM) ProduceReceiveBlockEvent(block interface{})

ProduceReceiveBlockEvent produces an eReceiveBlock event after delay

func (*ConsensusFSM) ProduceReceiveLockEndorsementEvent Uses

func (m *ConsensusFSM) ProduceReceiveLockEndorsementEvent(vote interface{})

ProduceReceiveLockEndorsementEvent produces an eReceiveLockEndorsement event right away

func (*ConsensusFSM) ProduceReceivePreCommitEndorsementEvent Uses

func (m *ConsensusFSM) ProduceReceivePreCommitEndorsementEvent(vote interface{})

ProduceReceivePreCommitEndorsementEvent produces an eReceivePreCommitEndorsement event right away

func (*ConsensusFSM) ProduceReceiveProposalEndorsementEvent Uses

func (m *ConsensusFSM) ProduceReceiveProposalEndorsementEvent(vote interface{})

ProduceReceiveProposalEndorsementEvent produces an eReceiveProposalEndorsement event right away

func (*ConsensusFSM) Start Uses

func (m *ConsensusFSM) Start(c context.Context) error

Start starts the fsm and get in initial state

func (*ConsensusFSM) Stop Uses

func (m *ConsensusFSM) Stop(_ context.Context) error

Stop stops the consensus fsm

type Context Uses

type Context interface {
    Activate(bool)
    Active() bool
    IsStaleEvent(*ConsensusEvent) bool
    IsFutureEvent(*ConsensusEvent) bool
    IsStaleUnmatchedEvent(*ConsensusEvent) bool

    Logger() *zap.Logger
    Height() uint64

    NewConsensusEvent(fsm.EventType, interface{}) *ConsensusEvent
    NewBackdoorEvt(fsm.State) *ConsensusEvent

    Broadcast(interface{})

    Prepare() error
    IsDelegate() bool
    Proposal() (interface{}, error)
    WaitUntilRoundStart() time.Duration
    PreCommitEndorsement() interface{}
    NewProposalEndorsement(interface{}) (interface{}, error)
    NewLockEndorsement(interface{}) (interface{}, error)
    NewPreCommitEndorsement(interface{}) (interface{}, error)
    Commit(interface{}) (bool, error)
}

Context defines the context of the fsm

type EndorsedMessage Uses

type EndorsedMessage interface {
    Endorsement() *endorsement.Endorsement
    Message() interface{}
}

EndorsedMessage defines a message with endorsement

Package consensusfsm imports 9 packages (graph) and is imported by 2 packages. Updated 2019-08-21. Refresh now. Tools for package owners.