consensusfsm

Documentation

Index

• Constants
• Variables
• type Config
• type ConsensusEvent
  • func NewConsensusEvent(eventType fsm.EventType, data interface{}, height uint64, round uint32, ...) *ConsensusEvent
  • func (e *ConsensusEvent) Data() interface{}
  • func (e *ConsensusEvent) Height() uint64
  • func (e *ConsensusEvent) Round() uint32
  • func (e *ConsensusEvent) Timestamp() time.Time
  • func (e *ConsensusEvent) Type() fsm.EventType
• type ConsensusFSM
  • func NewConsensusFSM(cfg Config, ctx Context, clock clock.Clock) (*ConsensusFSM, error)
  • func (m *ConsensusFSM) BackToPrepare(delay time.Duration) (fsm.State, error)
  • func (m *ConsensusFSM) Calibrate(height uint64)
  • func (m *ConsensusFSM) CurrentState() fsm.State
  • func (m *ConsensusFSM) NumPendingEvents() int
  • func (m *ConsensusFSM) ProduceReceiveBlockEvent(block interface{})
  • func (m *ConsensusFSM) ProduceReceiveLockEndorsementEvent(vote interface{})
  • func (m *ConsensusFSM) ProduceReceivePreCommitEndorsementEvent(vote interface{})
  • func (m *ConsensusFSM) ProduceReceiveProposalEndorsementEvent(vote interface{})
  • func (m *ConsensusFSM) Start(c context.Context) error
  • func (m *ConsensusFSM) Stop(_ context.Context) error
• type Context
• type EndorsedMessage

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")
)

Types

type Config

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

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

ConsensusEvent defines the event used in the fsm

func NewConsensusEvent

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

NewConsensusEvent creates a new consensus event

func (*ConsensusEvent) Data

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

Data returns the data of the event

func (*ConsensusEvent) Height

func (e *ConsensusEvent) Height() uint64

Height is the height of the event

func (*ConsensusEvent) Round

func (e *ConsensusEvent) Round() uint32

Round is the round of the event

func (*ConsensusEvent) Timestamp

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

Timestamp is the creation time of the event

func (*ConsensusEvent) Type

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

Type returns the event type

type ConsensusFSM

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

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

func NewConsensusFSM

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

NewConsensusFSM returns a new fsm

func (*ConsensusFSM) BackToPrepare

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

BackToPrepare produces an ePrepare event after delay

func (*ConsensusFSM) Calibrate

func (m *ConsensusFSM) Calibrate(height uint64)

Calibrate calibrates the state if necessary

func (*ConsensusFSM) CurrentState

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

CurrentState returns the current state

func (*ConsensusFSM) NumPendingEvents

func (m *ConsensusFSM) NumPendingEvents() int

NumPendingEvents returns the number of pending events

func (*ConsensusFSM) ProduceReceiveBlockEvent

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

ProduceReceiveBlockEvent produces an eReceiveBlock event after delay

func (*ConsensusFSM) ProduceReceiveLockEndorsementEvent

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

ProduceReceiveLockEndorsementEvent produces an eReceiveLockEndorsement event right away

func (*ConsensusFSM) ProduceReceivePreCommitEndorsementEvent

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

ProduceReceivePreCommitEndorsementEvent produces an eReceivePreCommitEndorsement event right away

func (*ConsensusFSM) ProduceReceiveProposalEndorsementEvent

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

ProduceReceiveProposalEndorsementEvent produces an eReceiveProposalEndorsement event right away

func (*ConsensusFSM) Start

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

Start starts the fsm and get in initial state

func (*ConsensusFSM) Stop

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

Stop stops the consensus fsm

type Context

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() (bool, interface{}, bool, bool, interface{}, time.Duration, error)
	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

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

EndorsedMessage defines a message with endorsement