isaacstates

package
v0.0.0-...-b559f02 Latest Latest
Warning

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

 Go to latest Published: Apr 30, 2024 License: GPL-3.0 Imports: 23 Imported by: 0

Documentation

Overview

Package isaacstates handles node states

Index

Constants

View Source 
const (
	StateEmpty = StateType("")
	// StateStopped indicates all processes is finished.
	StateStopped = StateType("STOPPED")
	// StateBooting indicates node checks it's state.
	StateBooting = StateType("BOOTING")
	// StateJoining indicates node is trying to join consensus.
	StateJoining = StateType("JOINING")
	// StateConsensus indicates node participates consensus with the other
	// nodes.
	StateConsensus = StateType("CONSENSUS")
	// StateSyncing indicates node is syncing block.
	StateSyncing = StateType("SYNCING")
	// StateHandover indicates node tries to replace the existing same node.
	StateHandover = StateType("HANDOVER")
	// StateBroken is used when something wrong in states.
	StateBroken = StateType("BROKEN")
)

Variables

View Source 
var (
	HandoverMessageChallengeResponseHint   = hint.MustNewHint("handover-challenge-response-message-v0.0.1")
	HandoverMessageFinishHint              = hint.MustNewHint("handover-finish-message-v0.0.1")
	HandoverMessageChallengeStagePointHint = hint.MustNewHint("handover-challenge-stagepoint-message-v0.0.1")
	HandoverMessageChallengeBlockMapHint   = hint.MustNewHint("handover-challenge-blockmap-message-v0.0.1")
	HandoverMessageDataHint                = hint.MustNewHint("handover-data-message-v0.0.1")
	HandoverMessageCancelHint              = hint.MustNewHint("handover-cancel-message-v0.0.1")
)
View Source 
var (
	ErrHandoverCanceled = util.NewIDError("handover canceled")
	ErrHandoverStopped  = util.NewIDError("handover stopped")
)
View Source 
var (
	ErrIgnoreSwitchingState = util.NewIDError("switch state, but ignored")
)
View Source 
var ErrUnpromising = util.NewIDError("unpromising broken error")
View Source 
var MissingBallotsRequestsMessageHint = hint.MustNewHint("missing-ballots-request-message-v0.0.1")

Functions

func FindMissingBallotsFromBallotboxFunc 

func FindMissingBallotsFromBallotboxFunc(
	local base.Address,
	getSuffragef isaac.GetSuffrageByBlockHeight,
	ballotbox *Ballotbox,
) func(context.Context, base.StagePoint, bool) ([]base.Address, bool, error)

func NewHandoverXFinishedFunc 

func NewHandoverXFinishedFunc(
	leftMemberlist func() error,
	addSyncSource func(base.Address, quicstream.ConnInfo) error,
) func(base.INITVoteproof, base.Address, quicstream.ConnInfo) error

func NewHandoverYCanceledFunc 

func NewHandoverYCanceledFunc(
	leftMemberlist func() error,
	removeSyncSource func(quicstream.ConnInfo) error,
) func(error, quicstream.ConnInfo)

func NewHandoverYFinishedFunc 

func NewHandoverYFinishedFunc(
	removeSyncSource func(quicstream.ConnInfo) error,
) func(base.INITVoteproof, quicstream.ConnInfo) error

func RequestMissingBallots 

func RequestMissingBallots(
	localci quicstream.ConnInfo,
	broadcastf func([]byte, string, chan struct{}) error,
) func(context.Context, base.StagePoint, []base.Address) error

func VoteSuffrageVotingFunc 

func VoteSuffrageVotingFunc(
	local base.LocalNode,
	networkID base.NetworkID,
	ballotbox *Ballotbox,
	sv *isaac.SuffrageVoting,
	getSuffragef isaac.GetSuffrageByBlockHeight,
) func(context.Context, base.StagePoint, []base.Address) (base.Voteproof, error)

Types

type AskHandoverFunc 

type AskHandoverFunc func(context.Context, quicstream.ConnInfo) (
	handoverid string, canMoveConsensus bool, _ error)

func NewAskHandoverFunc 

func NewAskHandoverFunc(
	local base.Address,
	joinMemberlist func(context.Context, quicstream.ConnInfo) error,
	sendAsk func(context.Context, base.Address, quicstream.ConnInfo) (string, bool, error),
) AskHandoverFunc

type AskHandoverReceivedFunc 

type AskHandoverReceivedFunc func(context.Context, base.Address, quicstream.ConnInfo) (
	handoverid string, canMoveConsensus bool, _ error)

func NewAskHandoverReceivedFunc 

func NewAskHandoverReceivedFunc(
	local base.Address,
	localci quicstream.ConnInfo,
	isAllowedConsensus func() bool,
	isHandoverStarted func() bool,
	isJoinedMemberlist func(quicstream.ConnInfo) (bool, error),
	currentState func() StateType,
	setNotAllowConsensus func(),
	startHandoverX func(quicstream.ConnInfo) (handoverid string, _ error),
) AskHandoverReceivedFunc

type BallotBroadcaster 

type BallotBroadcaster interface {
	Broadcast(base.Ballot) error
	Ballot(_ base.Point, _ base.Stage, isSuffrageConfirm bool) (base.Ballot, bool, error)
}

type BallotStuckResolver 

type BallotStuckResolver interface {
	NewPoint(context.Context, base.StagePoint) bool
	Voteproof() <-chan base.Voteproof
	Clean()
	Cancel(base.StagePoint)
}

type Ballotbox 

type Ballotbox struct {
	*util.ContextDaemon
	*logging.Logging
	// contains filtered or unexported fields
}

func NewBallotbox 

func NewBallotbox(
	local base.Address,
	getThreshold func() base.Threshold,
	getSuffrage isaac.GetSuffrageByBlockHeight,
) *Ballotbox

func (*Ballotbox) Count 

func (box *Ballotbox) Count() bool

func (*Ballotbox) LastPoint 

func (box *Ballotbox) LastPoint() isaac.LastPoint

func (*Ballotbox) LastVoteproof 

func (box *Ballotbox) LastVoteproof() base.Voteproof

func (*Ballotbox) MissingNodes 

func (box *Ballotbox) MissingNodes(point base.StagePoint) ([]base.Address, bool, error)

func (*Ballotbox) SetCountAfter 

func (box *Ballotbox) SetCountAfter(d time.Duration) *Ballotbox

func (*Ballotbox) SetInterval 

func (box *Ballotbox) SetInterval(d time.Duration) *Ballotbox

func (*Ballotbox) SetIsValidVoteproofFunc 

func (box *Ballotbox) SetIsValidVoteproofFunc(f func(base.Voteproof, base.Suffrage) error) *Ballotbox

func (*Ballotbox) SetLastPoint 

func (box *Ballotbox) SetLastPoint(point isaac.LastPoint) bool

func (*Ballotbox) SetLastPointFromVoteproof 

func (box *Ballotbox) SetLastPointFromVoteproof(vp base.Voteproof) bool

func (*Ballotbox) SetNewBallotFunc 

func (box *Ballotbox) SetNewBallotFunc(f func(base.Ballot)) *Ballotbox

func (*Ballotbox) SetSuffrageVoteFunc 

func (box *Ballotbox) SetSuffrageVoteFunc(f func(base.SuffrageExpelOperation) error) *Ballotbox

func (*Ballotbox) StuckVoteproof 

func (box *Ballotbox) StuckVoteproof(
	point base.StagePoint,
	expels []base.SuffrageExpelOperation,
) (vp base.Voteproof, _ error)

func (*Ballotbox) Vote 

func (box *Ballotbox) Vote(bl base.Ballot) (bool, error)

func (*Ballotbox) VoteSignFact 

func (box *Ballotbox) VoteSignFact(sf base.BallotSignFact) (bool, error)

func (*Ballotbox) Voted 

func (box *Ballotbox) Voted(point base.StagePoint, nodes []base.Address) []base.BallotSignFact

func (*Ballotbox) Voteproof 

func (box *Ballotbox) Voteproof() <-chan base.Voteproof

type BootingHandler 

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

type BootingHandlerArgs 

type BootingHandlerArgs struct {
	LastManifestFunc         func() (base.Manifest, bool, error)
	NodeInConsensusNodesFunc isaac.NodeInConsensusNodesFunc
}

func NewBootingHandlerArgs 

func NewBootingHandlerArgs() *BootingHandlerArgs

type BrokenHandler 

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

type BrokenHandlerArgs 

type BrokenHandlerArgs struct {
	LeaveMemberlistFunc func() error
	Exit                bool
}

func NewBrokenHandlerArgs 

func NewBrokenHandlerArgs() *BrokenHandlerArgs

type CheckHandoverFunc 

type CheckHandoverFunc func(context.Context, base.Address, quicstream.ConnInfo) error

func NewCheckHandoverFunc 

func NewCheckHandoverFunc(
	local base.Address,
	localci quicstream.ConnInfo,
	isAllowedConsensus func() bool,
	isHandoverStarted func() bool,
	isJoinedMemberlist func() (bool, error),
	currentState func() StateType,
) CheckHandoverFunc

type CheckHandoverXFunc 

type CheckHandoverXFunc func(context.Context) error

func NewCheckHandoverXFunc 

func NewCheckHandoverXFunc(
	isAllowedConsensus func() bool,
	isHandoverStarted func() bool,
	isJoinedMemberlist func() (bool, error),
	currentState func() StateType,
) CheckHandoverXFunc

type ConsensusHandler 

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

type ConsensusHandlerArgs 

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

func NewConsensusHandlerArgs 

func NewConsensusHandlerArgs() *ConsensusHandlerArgs

type DefaultBallotBroadcaster 

type DefaultBallotBroadcaster struct {
	*logging.Logging

	sync.Mutex
	// contains filtered or unexported fields
}

func NewDefaultBallotBroadcaster 

func NewDefaultBallotBroadcaster(
	local base.Address,
	pool isaac.BallotPool,
	broadcastFunc func(base.Ballot) error,
) *DefaultBallotBroadcaster

func (*DefaultBallotBroadcaster) Ballot 

func (bb *DefaultBallotBroadcaster) Ballot(
	point base.Point,
	stage base.Stage,
	isSuffrageConfirm bool,
) (base.Ballot, bool, error)

func (*DefaultBallotBroadcaster) Broadcast 

func (bb *DefaultBallotBroadcaster) Broadcast(bl base.Ballot) error

type DefaultBallotStuckResolver 

type DefaultBallotStuckResolver struct {
	*logging.Logging
	// contains filtered or unexported fields
}

func NewDefaultBallotStuckResolver 

func NewDefaultBallotStuckResolver(
	initialWait,
	interval, resolveAfter time.Duration,
	findMissingBallotsf func(context.Context, base.StagePoint, bool) ([]base.Address, bool, error),
	requestMissingBallotsf func(context.Context, base.StagePoint, []base.Address) error,
	voteSuffrageVotingf func(context.Context, base.StagePoint, []base.Address) (base.Voteproof, error),
) *DefaultBallotStuckResolver

func (*DefaultBallotStuckResolver) Cancel 

func (c *DefaultBallotStuckResolver) Cancel(point base.StagePoint)

func (*DefaultBallotStuckResolver) Clean 

func (c *DefaultBallotStuckResolver) Clean()

func (*DefaultBallotStuckResolver) NewPoint 

func (c *DefaultBallotStuckResolver) NewPoint(ctx context.Context, point base.StagePoint) bool

func (*DefaultBallotStuckResolver) SetLogging 

func (c *DefaultBallotStuckResolver) SetLogging(l *logging.Logging) *logging.Logging

func (*DefaultBallotStuckResolver) Voteproof 

func (c *DefaultBallotStuckResolver) Voteproof() <-chan base.Voteproof

type HandoverHandler 

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

type HandoverHandlerArgs 

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

func NewHandoverHandlerArgs 

func NewHandoverHandlerArgs() *HandoverHandlerArgs

type HandoverMessage 

type HandoverMessage interface {
	util.IsValider
	HandoverID() string
}

type HandoverMessageCancel 

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

func NewHandoverMessageCancel 

func NewHandoverMessageCancel(id string, err error) HandoverMessageCancel

func (HandoverMessageCancel) Err 

func (h HandoverMessageCancel) Err() error

func (HandoverMessageCancel) HandoverID 

func (h HandoverMessageCancel) HandoverID() string

func (HandoverMessageCancel) IsValid 

func (h HandoverMessageCancel) IsValid([]byte) error

func (HandoverMessageCancel) JSONMarshaller 

func (h HandoverMessageCancel) JSONMarshaller() baseHandoverMessageJSONMarshaler

func (HandoverMessageCancel) MarshalJSON 

func (h HandoverMessageCancel) MarshalJSON() ([]byte, error)

func (*HandoverMessageCancel) UnmarshalJSON 

func (h *HandoverMessageCancel) UnmarshalJSON(b []byte) error

type HandoverMessageChallengeBlockMap 

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

func (HandoverMessageChallengeBlockMap) BlockMap 

func (h HandoverMessageChallengeBlockMap) BlockMap() base.BlockMap

func (*HandoverMessageChallengeBlockMap) DecodeJSON 

func (h *HandoverMessageChallengeBlockMap) DecodeJSON(b []byte, enc encoder.Encoder) error

func (HandoverMessageChallengeBlockMap) HandoverID 

func (h HandoverMessageChallengeBlockMap) HandoverID() string

func (HandoverMessageChallengeBlockMap) IsValid 

func (h HandoverMessageChallengeBlockMap) IsValid(networkID []byte) error

func (HandoverMessageChallengeBlockMap) JSONMarshaller 

func (h HandoverMessageChallengeBlockMap) JSONMarshaller() baseHandoverMessageJSONMarshaler

func (HandoverMessageChallengeBlockMap) MarshalJSON 

func (h HandoverMessageChallengeBlockMap) MarshalJSON() ([]byte, error)

func (HandoverMessageChallengeBlockMap) Point 

func (h HandoverMessageChallengeBlockMap) Point() base.StagePoint

func (*HandoverMessageChallengeBlockMap) UnmarshalJSON 

func (h *HandoverMessageChallengeBlockMap) UnmarshalJSON(b []byte) error

type HandoverMessageChallengeBlockMapJSONMarshaler 

type HandoverMessageChallengeBlockMapJSONMarshaler struct {
	BlockMap base.BlockMap   `json:"blockmap"` //nolint:tagliatelle //...
	Point    base.StagePoint `json:"point"`
}

type HandoverMessageChallengeResponse 

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

func (HandoverMessageChallengeResponse) Err 

func (h HandoverMessageChallengeResponse) Err() error

func (HandoverMessageChallengeResponse) HandoverID 

func (h HandoverMessageChallengeResponse) HandoverID() string

func (HandoverMessageChallengeResponse) IsValid 

func (h HandoverMessageChallengeResponse) IsValid([]byte) error

func (HandoverMessageChallengeResponse) JSONMarshaller 

func (h HandoverMessageChallengeResponse) JSONMarshaller() baseHandoverMessageJSONMarshaler

func (HandoverMessageChallengeResponse) MarshalJSON 

func (h HandoverMessageChallengeResponse) MarshalJSON() ([]byte, error)

func (HandoverMessageChallengeResponse) OK 

func (h HandoverMessageChallengeResponse) OK() bool

func (HandoverMessageChallengeResponse) Point 

func (h HandoverMessageChallengeResponse) Point() base.StagePoint

func (*HandoverMessageChallengeResponse) UnmarshalJSON 

func (h *HandoverMessageChallengeResponse) UnmarshalJSON(b []byte) error

type HandoverMessageChallengeResponseJSONMarshaler 

type HandoverMessageChallengeResponseJSONMarshaler struct {
	Err   string          `json:"error,omitempty"` //nolint:tagliatelle //...
	Point base.StagePoint `json:"point"`
	OK    bool            `json:"ok"`
}

type HandoverMessageChallengeStagePoint 

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

func (HandoverMessageChallengeStagePoint) HandoverID 

func (h HandoverMessageChallengeStagePoint) HandoverID() string

func (HandoverMessageChallengeStagePoint) IsValid 

func (h HandoverMessageChallengeStagePoint) IsValid([]byte) error

func (HandoverMessageChallengeStagePoint) JSONMarshaller 

func (h HandoverMessageChallengeStagePoint) JSONMarshaller() baseHandoverMessageJSONMarshaler

func (HandoverMessageChallengeStagePoint) MarshalJSON 

func (h HandoverMessageChallengeStagePoint) MarshalJSON() ([]byte, error)

func (HandoverMessageChallengeStagePoint) Point 

func (h HandoverMessageChallengeStagePoint) Point() base.StagePoint

func (*HandoverMessageChallengeStagePoint) UnmarshalJSON 

func (h *HandoverMessageChallengeStagePoint) UnmarshalJSON(b []byte) error

type HandoverMessageChallengeStagePointJSONMarshaler 

type HandoverMessageChallengeStagePointJSONMarshaler struct {
	Point base.StagePoint `json:"point"`
}

type HandoverMessageData 

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

func (HandoverMessageData) Data 

func (h HandoverMessageData) Data() interface{}

func (HandoverMessageData) DataType 

func (h HandoverMessageData) DataType() HandoverMessageDataType

func (*HandoverMessageData) DecodeJSON 

func (h *HandoverMessageData) DecodeJSON(b []byte, enc encoder.Encoder) error

func (HandoverMessageData) HandoverID 

func (h HandoverMessageData) HandoverID() string

func (HandoverMessageData) IsValid 

func (h HandoverMessageData) IsValid(b []byte) error

func (HandoverMessageData) JSONMarshaller 

func (h HandoverMessageData) JSONMarshaller() baseHandoverMessageJSONMarshaler

func (HandoverMessageData) LoadINITVoteproofData 

func (h HandoverMessageData) LoadINITVoteproofData() (pr base.ProposalSignFact, ivp base.INITVoteproof, _ error)

func (HandoverMessageData) LoadVoteproofData 

func (h HandoverMessageData) LoadVoteproofData() (base.Voteproof, error)

func (HandoverMessageData) MarshalJSON 

func (h HandoverMessageData) MarshalJSON() ([]byte, error)

func (*HandoverMessageData) UnmarshalJSON 

func (h *HandoverMessageData) UnmarshalJSON(b []byte) error

type HandoverMessageDataJSONMarshaler 

type HandoverMessageDataJSONMarshaler struct {
	Data     interface{}             `json:"data"`
	DataType HandoverMessageDataType `json:"data_type"`
}

type HandoverMessageDataType 

type HandoverMessageDataType string
const (
	HandoverMessageDataTypeUnknown        HandoverMessageDataType = ""
	HandoverMessageDataTypeVoteproof      HandoverMessageDataType = "voteproof"
	HandoverMessageDataTypeINITVoteproof  HandoverMessageDataType = "init_voteproof"
	HandoverMessageDataTypeBallot         HandoverMessageDataType = "ballot"
	HandoverMessageDataTypeProposal       HandoverMessageDataType = "proposal"
	HandoverMessageDataTypeOperation      HandoverMessageDataType = "operation"
	HandoverMessageDataTypeSuffrageVoting HandoverMessageDataType = "suffrage_voting_expel_operation"
)

func (HandoverMessageDataType) IsValid 

func (d HandoverMessageDataType) IsValid([]byte) error

type HandoverMessageFinish 

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

func (*HandoverMessageFinish) DecodeJSON 

func (h *HandoverMessageFinish) DecodeJSON(b []byte, enc encoder.Encoder) error

func (HandoverMessageFinish) HandoverID 

func (h HandoverMessageFinish) HandoverID() string

func (HandoverMessageFinish) INITVoteproof 

func (h HandoverMessageFinish) INITVoteproof() base.INITVoteproof

func (HandoverMessageFinish) IsValid 

func (h HandoverMessageFinish) IsValid(networkID []byte) error

func (HandoverMessageFinish) JSONMarshaller 

func (h HandoverMessageFinish) JSONMarshaller() baseHandoverMessageJSONMarshaler

func (HandoverMessageFinish) MarshalJSON 

func (h HandoverMessageFinish) MarshalJSON() ([]byte, error)

func (HandoverMessageFinish) Proposal 

func (h HandoverMessageFinish) Proposal() base.ProposalSignFact

func (*HandoverMessageFinish) UnmarshalJSON 

func (h *HandoverMessageFinish) UnmarshalJSON(b []byte) error

type HandoverMessageFinishJSONMarshaler 

type HandoverMessageFinishJSONMarshaler struct {
	Proposal  base.ProposalSignFact `json:"proposal"`
	Voteproof base.Voteproof        `json:"voteproof"`
}

type HandoverXBroker 

type HandoverXBroker struct {
	*logging.Logging
	// contains filtered or unexported fields
}

HandoverXBroker handles handover processes of consensus node.

func NewHandoverXBroker 

func NewHandoverXBroker(
	ctx context.Context,
	args *HandoverXBrokerArgs,
	connInfo quicstream.ConnInfo,
) *HandoverXBroker

func (*HandoverXBroker) ConnInfo 

func (broker *HandoverXBroker) ConnInfo() quicstream.ConnInfo

func (*HandoverXBroker) ID 

func (broker *HandoverXBroker) ID() string

func (*HandoverXBroker) Receive 

func (broker *HandoverXBroker) Receive(i interface{}) error

func (*HandoverXBroker) SendData 

func (broker *HandoverXBroker) SendData(ctx context.Context, dataType HandoverMessageDataType, data interface{}) error

type HandoverXBrokerArgs 

type HandoverXBrokerArgs struct {
	SendMessageFunc          func(context.Context, quicstream.ConnInfo, HandoverMessage) error
	CheckIsReady             func() (bool, error)
	WhenCanceled             func(brokerID string, _ error)
	WhenFinished             func(brokerID string, _ base.INITVoteproof, y base.Address, yci quicstream.ConnInfo) error
	GetProposal              func(proposalfacthash util.Hash) (base.ProposalSignFact, bool, error)
	Local                    base.Node
	NetworkID                base.NetworkID
	MinChallengeCount        uint64
	ReadyEnd                 uint64
	CleanAfter               time.Duration
	MaxEnsureSendFailure     uint64
	RetrySendMessageInterval time.Duration
}

func NewHandoverXBrokerArgs 

func NewHandoverXBrokerArgs(local base.Node, networkID base.NetworkID) *HandoverXBrokerArgs

type HandoverYBroker 

type HandoverYBroker struct {
	*logging.Logging
	// contains filtered or unexported fields
}

HandoverYBroker handles handover processes of non-consensus node.

func NewHandoverYBroker 

func NewHandoverYBroker(
	ctx context.Context,
	args *HandoverYBrokerArgs,
	connInfo quicstream.ConnInfo,
) *HandoverYBroker

func (*HandoverYBroker) Ask 

func (broker *HandoverYBroker) Ask() (canMoveConsensus, isAsked bool, _ error)

func (*HandoverYBroker) ConnInfo 

func (broker *HandoverYBroker) ConnInfo() quicstream.ConnInfo

func (*HandoverYBroker) ID 

func (broker *HandoverYBroker) ID() string

func (*HandoverYBroker) IsAsked 

func (broker *HandoverYBroker) IsAsked() bool

func (*HandoverYBroker) Receive 

func (broker *HandoverYBroker) Receive(i interface{}) error

type HandoverYBrokerArgs 

type HandoverYBrokerArgs struct {
	SendMessageFunc func(context.Context, quicstream.ConnInfo, HandoverMessage) error
	NewDataFunc     func(HandoverMessageDataType, interface{}) error
	// WhenFinished is called when handover process is finished.
	WhenFinished func(string, base.INITVoteproof, quicstream.ConnInfo) error
	WhenCanceled func(string, error, quicstream.ConnInfo)
	SyncDataFunc func(
		context.Context, quicstream.ConnInfo, chan<- struct{}) error //revive:disable-line:nested-structs
	AskRequestFunc           AskHandoverFunc
	NetworkID                base.NetworkID
	MaxEnsureSendFailure     uint64
	RetrySendMessageInterval time.Duration
	MaxEnsureAsk             uint64
}

func NewHandoverYBrokerArgs 

func NewHandoverYBrokerArgs(networkID base.NetworkID) *HandoverYBrokerArgs

type JoiningHandler 

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

type JoiningHandlerArgs 

type JoiningHandlerArgs struct {
	LastManifestFunc    func() (base.Manifest, bool, error)
	JoinMemberlistFunc  func(context.Context, base.Suffrage) error
	LeaveMemberlistFunc func() error
	WaitFirstVoteproof  func() time.Duration
	// contains filtered or unexported fields
}

func NewJoiningHandlerArgs 

func NewJoiningHandlerArgs() *JoiningHandlerArgs

func (*JoiningHandlerArgs) IsEmptyProposal 

func (args *JoiningHandlerArgs) IsEmptyProposal(ctx context.Context, pr base.ProposalSignFact) (bool, error)

func (*JoiningHandlerArgs) IsEmptyProposalNoBlock 

func (args *JoiningHandlerArgs) IsEmptyProposalNoBlock() bool

type MissingBallotsRequestMessage 

type MissingBallotsRequestMessage struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

func NewMissingBallotsRequestsMessage 

func NewMissingBallotsRequestsMessage(
	point base.StagePoint,
	nodes []base.Address,
	ci quicstream.ConnInfo,
) MissingBallotsRequestMessage

func (MissingBallotsRequestMessage) ConnInfo 

func (m MissingBallotsRequestMessage) ConnInfo() quicstream.ConnInfo

func (*MissingBallotsRequestMessage) DecodeJSON 

func (m *MissingBallotsRequestMessage) DecodeJSON(b []byte, enc encoder.Encoder) error

func (MissingBallotsRequestMessage) IsValid 

func (m MissingBallotsRequestMessage) IsValid([]byte) error

func (MissingBallotsRequestMessage) MarshalJSON 

func (m MissingBallotsRequestMessage) MarshalJSON() ([]byte, error)

func (MissingBallotsRequestMessage) Nodes 

func (m MissingBallotsRequestMessage) Nodes() []base.Address

func (MissingBallotsRequestMessage) Point 

func (m MissingBallotsRequestMessage) Point() base.StagePoint

type NewBlockImporterFunc 

type NewBlockImporterFunc func(base.BlockMap) (isaac.BlockImporter, error)

type NewBootingHandlerType 

type NewBootingHandlerType struct {
	*BootingHandler
}

func NewNewBootingHandlerType 

func NewNewBootingHandlerType(
	networkID base.NetworkID,
	local base.LocalNode,
	args *BootingHandlerArgs,
) *NewBootingHandlerType

type NewBrokenHandlerType 

type NewBrokenHandlerType struct {
	*BrokenHandler
}

func NewNewBrokenHandlerType 

func NewNewBrokenHandlerType(
	networkID base.NetworkID,
	local base.LocalNode,
	args *BrokenHandlerArgs,
) *NewBrokenHandlerType

type NewConsensusHandlerType 

type NewConsensusHandlerType struct {
	*ConsensusHandler
}

func NewNewConsensusHandlerType 

func NewNewConsensusHandlerType(
	networkID base.NetworkID,
	local base.LocalNode,
	args *ConsensusHandlerArgs,
) *NewConsensusHandlerType

type NewHandoverHandlerType 

type NewHandoverHandlerType struct {
	*HandoverHandler
}

func NewNewHandoverHandlerType 

func NewNewHandoverHandlerType(
	networkID base.NetworkID,
	local base.LocalNode,
	args *HandoverHandlerArgs,
) *NewHandoverHandlerType

type NewHandoverXBrokerFunc 

type NewHandoverXBrokerFunc func(context.Context, quicstream.ConnInfo) (*HandoverXBroker, error)

type NewHandoverYBrokerFunc 

type NewHandoverYBrokerFunc func(context.Context, quicstream.ConnInfo) (*HandoverYBroker, error)

type NewImportBlocksFunc 

type NewImportBlocksFunc func(
	_ context.Context,
	from, to base.Height,
	batchlimit int64,
	blockMapFunc func(context.Context, base.Height) (base.BlockMap, bool, error),
) error

type NewJoiningHandlerType 

type NewJoiningHandlerType struct {
	*JoiningHandler
}

func NewNewJoiningHandlerType 

func NewNewJoiningHandlerType(
	networkID base.NetworkID,
	local base.LocalNode,
	args *JoiningHandlerArgs,
) *NewJoiningHandlerType

type NewStoppedHandlerType 

type NewStoppedHandlerType struct {
	*StoppedHandler
}

func NewNewStoppedHandlerType 

func NewNewStoppedHandlerType(
	networkID base.NetworkID,
	local base.LocalNode,
) *NewStoppedHandlerType

type NewSyncingHandlerType 

type NewSyncingHandlerType struct {
	*SyncingHandler
}

func NewNewSyncingHandlerType 

func NewNewSyncingHandlerType(
	networkID base.NetworkID,
	local base.LocalNode,
	args *SyncingHandlerArgs,
) *NewSyncingHandlerType

type StartHandoverYFunc 

type StartHandoverYFunc func(context.Context, base.Address, quicstream.ConnInfo) error

func NewStartHandoverYFunc 

func NewStartHandoverYFunc(
	local base.Address,
	localci quicstream.ConnInfo,
	isAllowedConsensus func() bool,
	isHandoverStarted func() bool,
	checkX func(context.Context, base.Address, quicstream.ConnInfo) error,
	addSyncSource func(base.Address, quicstream.ConnInfo) error,
	startHandoverY func(quicstream.ConnInfo) error,
) StartHandoverYFunc

type StateType 

type StateType string

func (StateType) IsValid 

func (s StateType) IsValid([]byte) error

func (StateType) String 

func (s StateType) String() string

type States 

type States struct {
	*logging.Logging

	*util.ContextDaemon
	// contains filtered or unexported fields
}

func NewStates 

func NewStates(networkID base.NetworkID, local base.LocalNode, args *StatesArgs) (*States, error)

func (*States) AllowedConsensus 

func (st *States) AllowedConsensus() bool

func (*States) AskMoveState 

func (st *States) AskMoveState(sctx switchContext) error

func (*States) CancelHandoverXBroker 

func (st *States) CancelHandoverXBroker() error

func (*States) CancelHandoverYBroker 

func (st *States) CancelHandoverYBroker() error

func (*States) Current 

func (st *States) Current() StateType

func (*States) HandoverXBroker 

func (st *States) HandoverXBroker() *HandoverXBroker

func (*States) HandoverYBroker 

func (st *States) HandoverYBroker() *HandoverYBroker

func (*States) Hold 

func (st *States) Hold() error

func (*States) NewHandoverXBroker 

func (st *States) NewHandoverXBroker(connInfo quicstream.ConnInfo) (handoverid string, _ error)

func (*States) NewHandoverYBroker 

func (st *States) NewHandoverYBroker(connInfo quicstream.ConnInfo) error

func (*States) SetAllowConsensus 

func (st *States) SetAllowConsensus(allow bool) bool

func (*States) SetHandler 

func (st *States) SetHandler(state StateType, h newHandler) *States

func (*States) SetLogging 

func (st *States) SetLogging(l *logging.Logging) *logging.Logging

func (*States) SetWhenStateSwitched 

func (st *States) SetWhenStateSwitched(f func(StateType))

type StatesArgs 

type StatesArgs struct {
	Ballotbox               *Ballotbox
	BallotStuckResolver     BallotStuckResolver
	LastVoteproofsHandler   *isaac.LastVoteproofsHandler
	IsInSyncSourcePoolFunc  func(base.Address) bool
	BallotBroadcaster       BallotBroadcaster
	WhenStateSwitchedFunc   func(StateType)
	IntervalBroadcastBallot func() time.Duration
	WhenNewVoteproof        func(base.Voteproof)
	NewHandoverXBroker      NewHandoverXBrokerFunc
	NewHandoverYBroker      NewHandoverYBrokerFunc
	// AllowConsensus decides to enter Consensus states. If false, States enters
	// Syncing state instead of Consensus state.
	AllowConsensus bool
}

func NewStatesArgs 

func NewStatesArgs() *StatesArgs

type StoppedHandler 

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

type SuffrageVotingFindFunc 

type SuffrageVotingFindFunc func(context.Context, base.Height, base.Suffrage) ([]base.SuffrageExpelOperation, error)

type Syncer 

type Syncer struct {
	*logging.Logging
	*util.ContextDaemon
	// contains filtered or unexported fields
}

func NewSyncer 

func NewSyncer(prev base.BlockMap, args SyncerArgs) *Syncer

func (*Syncer) Add 

func (s *Syncer) Add(height base.Height) bool

func (*Syncer) Cancel 

func (s *Syncer) Cancel() error

func (*Syncer) Done 

func (s *Syncer) Done() <-chan struct{}

func (*Syncer) Err 

func (s *Syncer) Err() error

func (*Syncer) Finished 

func (s *Syncer) Finished() <-chan base.Height

func (*Syncer) IsFinished 

func (s *Syncer) IsFinished() (base.Height, bool)

type SyncerArgs 

type SyncerArgs struct {
	LastBlockMapFunc     SyncerLastBlockMapFunc
	BlockMapFunc         isaacblock.ImportBlocksBlockMapFunc
	TempSyncPool         isaac.TempSyncPool
	WhenStoppedFunc      func() error
	RemovePrevBlockFunc  func(base.Height) (bool, error)
	NewImportBlocksFunc  NewImportBlocksFunc
	BatchLimit           int64
	LastBlockMapInterval time.Duration
	LastBlockMapTimeout  time.Duration
}

func NewSyncerArgs 

func NewSyncerArgs() SyncerArgs

type SyncerLastBlockMapFunc 

type SyncerLastBlockMapFunc func(_ context.Context, manifest util.Hash) (

	_ base.BlockMap, updated bool, _ error) // NOTE BlockMap.IsValid() should be called

type SyncingHandler 

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

type SyncingHandlerArgs 

type SyncingHandlerArgs struct {
	NodeInConsensusNodesFunc isaac.NodeInConsensusNodesFunc
	NewSyncerFunc            func(base.Height) (isaac.Syncer, error)
	WhenReachedTopFunc       func(base.Height)
	JoinMemberlistFunc       func(context.Context, base.Suffrage) error
	LeaveMemberlistFunc      func() error
	WhenNewBlockSavedFunc    func(base.Height)
	WaitStuckInterval        func() time.Duration
	WaitPreparingINITBallot  func() time.Duration
}

func NewSyncingHandlerArgs 

func NewSyncingHandlerArgs() *SyncingHandlerArgs

type SyncingSwitchContext 

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

func (SyncingSwitchContext) Error 

func (s SyncingSwitchContext) Error() string

func (SyncingSwitchContext) MarshalZerologObject 

func (s SyncingSwitchContext) MarshalZerologObject(e *zerolog.Event)

func (SyncingSwitchContext) String 

func (s SyncingSwitchContext) String() string

Source Files

View all Source files

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.