rafted

package module
v0.0.0-...-65b1d8a Latest Latest
Warning

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

 Go to latest Published: Oct 8, 2014 License: BSD-3-Clause Imports: 14 Imported by: 0

README

rafted

rafted is a Golang library that implements the Raft distributed consensus protocol.

Raft is an understandable consensus protocol which reaches distributed consistency by using replicated logs and state machines among a cluster of nodes.

For more details on Raft, please refer to the paper In Search of an Understandable Consensus Algorithm and Raft Consensus homepage.

Another Raft Implementation

There is a list of Raft implemetations on the Raft Consensus homepage, where you could find dozens of Raft implementations written in various programming languages.

At the moment when this project is created, there is at least 5 implementations written in Golang. Among them these two projects are much better written and maintained:

  1. go-raft
  2. hashicorp-raft

After taking a close look into these existing raft implementation projects, we find some issues as the followings. It is not easy to modify these existing projects to meet our needs. And then we decide to give a shot for a new implementation.

1. Not Full Feature

The existing implemenations don't provide all features described in Raft paper. These features include

  1. Leader Election, Log Replication
  2. Membership Change
  3. Log Compaction

Most of them implement 1 and 3, with partial 2 or without 2. hashicorp-raft support add/remove only single node in cluster once in a time. We need the features fully functional due to our occasions. Membership Change support on adding/removing multiple nodes is useful to simply the procedure of tablet group changing on our storage service.

2. No Pluggable Network Layer

etcd is an distributed key value store to maintain cluster configurations, which is powered by CoreOS. It use the go-raft library as backend to ensure the distributed consistency.

After running some test with etcd on a three node cluster in our typical network enviroment, we find the system throughput are at the level of 1000s, which are consitent with the etcd official benchmark(etcd Overview: "Benchmarked 1000s of writes/s per instance"). That throughput is not good enough on our occasions. go-raft uses HTTP as network protocol, which are concerned when we consider tuning the performance.

hashicorp-raft has its network layer implemented in TCP socket, while it doesn't have any similar existing project for usage so we don't run the test.

Raft is a distributed consensus algorithm, which involves a lot of network interactions. Change in network layer could affect its throughput and timeliness of response. To achieve high performance and short-time responsiveness we need a pluggable network layer, to fine-tune the system by using different network protocols, message serializations and message sending policies.

3. Lack of State Machine

The core of Raft is the nodes of a cluster parade in a time-to-time synchronized pace. During this process, each node goes through various states, e.g. follower, candidate, leader, snapshotting, log-compating, recovering from remote snapshot and so on. And various actions should be taken on the transfer of states. A good pattern to express state and state transfer in software is State Machine.

Both go-raft and hashicorp-raft use nested if-else/switch to implement the states and the actions around states, which is not the best method. In some degree, nested if-else/switch weakens the code on simplicity and understandability. It's not easy to modify or extand states or actions, along with an intuitional concept of its correctness.

Here I would like to introduce a method called Hierarchical State Machine(HSM) to describe states and actions for Raft nodes. HSM is a good pattern to express State Machine. It has some major advantages over the traditional methods(such as nested if-else/switch, state table, state pattern in OOP):

  1. It supports nested states and behavior inheritance
  2. It provides entry and exit actions for state
  3. It uses class hierarchy to express state hierarchy. Easy to write and understand.

I port HSM into Golang and make it a separate project for code reusage. Please refer to go-hsm for more infos.

Project Status

This library is under development and far from complete. It would be broken sometimes during the edit-break-fix circles. I would like to stablize the main framework as soon as possible. Any advice or suggestion would be appreciated.

Documentation

Index

Constants

View Source 
const (
	HSMTypeLocal hsm.HSMType = hsm.HSMTypeStd + 1 + iota
	HSMTypePeer
	HSMTypeLeaderMemberChange
)
View Source 
const (
	StateLocalID                         = "local"
	StateFollowerID                      = "follower"
	StateSnapshotRecoveryID              = "snapshot_recovery"
	StateFollowerMemberChangeID          = "follower_member_change"
	StateFollowerOldNewConfigSeenID      = "follower_old_new_config_seen"
	StateFollowerOldNewConfigCommittedID = "follower_old_new_config_committed"
	StateFollowerNewConfigSeenID         = "follower_new_config_seen"
	StateNeedPeersID                     = "need_peers"
	StateCandidateID                     = "candidate"
	StateLeaderID                        = "leader"
	StateUnsyncID                        = "unsync"
	StateSyncID                          = "sync"
	StatePersistErrorID                  = "persist_error"
)
View Source 
const (
	StatePeerID             = "peer"
	StateDeactivatedPeerID  = "deactivated_peer"
	StateActivatedPeerID    = "activated_peer"
	StateCandidatePeerID    = "candidate_peer"
	StateLeaderPeerID       = "leader_peer"
	StateStandardModePeerID = "standard_mode_peer"
	StateSnapshotModePeerID = "snapshot_mode_peer"
	StatePipelineModePeerID = "pipeline_mode_peer"
	StatePersistErrorPeerID = "persist_error_peer"
)
View Source 
const (
	StateLeaderMemberChangeID            = "leader_member_change"
	StateLeaderMemberChangeDeactivatedID = "leader_member_change_deactivated"
	StateLeaderMemberChangeActivatedID   = "leader_member_change_activated"
	StateLeaderNotInMemberChangeID       = "leader_not_in_member_change"
	StateLeaderInMemberChangeID          = "leader_in_member_change"
	StateLeaderMemberChangePhase1ID      = "leader_member_change_phase1"
	StateLeaderMemberChangePhase2ID      = "leader_member_change_phase2"
)

Variables

View Source 
var (
	Success             error = nil
	Failure                   = errors.New("failure")
	Timeout                   = errors.New("timeout")
	LeaderUnsync              = errors.New("leader unsync")
	LeaderUnknown             = errors.New("leader Unknown")
	InMemberChange            = errors.New("in member change")
	PersistError              = errors.New("persist error")
	InvalidResponseType       = errors.New("invalid response type")
)

Functions

func AddrSliceToMap 

func AddrSliceToMap(
	addrSlice *ps.ServerAddressSlice) map[*ps.ServerAddress]Peer

func AddrsString 

func AddrsString(addrs []*ps.ServerAddress) []string

func DispatchInconsistantError 

func DispatchInconsistantError(localHSM *LocalHSM) error

func DispatchPushConfigError 

func DispatchPushConfigError(localHSM *LocalHSM, logIndex uint64) error

func EntriesInfo 

func EntriesInfo(entries []*ps.LogEntry) []string

func GetPeers 

func GetPeers(
	localAddr *ps.ServerAddress, conf *ps.Config) *ps.ServerAddressSlice

func MapSetMinus 

func MapSetMinus(
	s1 map[*ps.ServerAddress]Peer,
	s2 map[*ps.ServerAddress]Peer) []*ps.ServerAddress

MapSetMinus calculates the difference of two map, and returns the result of s1 - s2.

func Max 

func Max(a, b uint64) uint64

Max returns the maximum.

func Min 

func Min(a, b uint64) uint64

Min returns the minimum.

func ParallelClose 

func ParallelClose(closers []io.Closer)

func ParallelDo 

func ParallelDo(todo []func())

func RandomLessDuration 

func RandomLessDuration(d time.Duration, maxJitter float32) time.Duration

func TimeExpire 

func TimeExpire(lastTime time.Time, timeout time.Duration) bool

Types

type ActivatedPeerState 

type ActivatedPeerState struct {
	*LogStateHead
}

func NewActivatedPeerState 

func NewActivatedPeerState(super hsm.State, logger logging.Logger) *ActivatedPeerState

func (*ActivatedPeerState) Entry 

func (self *ActivatedPeerState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*ActivatedPeerState) Exit 

func (self *ActivatedPeerState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*ActivatedPeerState) Handle 

func (self *ActivatedPeerState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*ActivatedPeerState) ID 

func (*ActivatedPeerState) ID() string

func (*ActivatedPeerState) Init 

func (self *ActivatedPeerState) Init(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

type Applier 

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

func NewApplier 

func NewApplier(
	log ps.Log,
	stateMachine ps.StateMachine,
	dispatcher func(event hsm.Event),
	notifier *Notifier,
	logger logging.Logger) *Applier

func (*Applier) ApplyCommitted 

func (self *Applier) ApplyCommitted()

func (*Applier) ApplyInflightLog 

func (self *Applier) ApplyInflightLog(entry *InflightEntry)

func (*Applier) ApplyLogEntry 

func (self *Applier) ApplyLogEntry(
	entry *ps.LogEntry) (result []byte, err error)

func (*Applier) ApplyLogsUpto 

func (self *Applier) ApplyLogsUpto(index uint64)

func (*Applier) Close 

func (self *Applier) Close()

func (*Applier) FollowerCommitUpTo 

func (self *Applier) FollowerCommitUpTo(logIndex uint64)

func (*Applier) LeaderCommit 

func (self *Applier) LeaderCommit(entry *InflightEntry)

func (*Applier) Start 

func (self *Applier) Start()

type Backend 

type Backend interface {
	Send(event ev.RequestEvent)
	io.Closer
	Notifiable
}

type CandidatePeerState 

type CandidatePeerState struct {
	*LogStateHead
}

func NewCandidatePeerState 

func NewCandidatePeerState(super hsm.State, logger logging.Logger) *CandidatePeerState

func (*CandidatePeerState) Entry 

func (self *CandidatePeerState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*CandidatePeerState) Exit 

func (self *CandidatePeerState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*CandidatePeerState) Handle 

func (self *CandidatePeerState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*CandidatePeerState) ID 

func (*CandidatePeerState) ID() string

func (*CandidatePeerState) Init 

func (self *CandidatePeerState) Init(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

type CandidateState 

type CandidateState struct {
	*LogStateHead
	// contains filtered or unexported fields
}

func NewCandidateState 

func NewCandidateState(
	super hsm.State,
	electionTimeout time.Duration,
	maxTimeoutJitter float32,
	logger logging.Logger) *CandidateState

func (*CandidateState) Entry 

func (self *CandidateState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*CandidateState) Exit 

func (self *CandidateState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*CandidateState) Handle 

func (self *CandidateState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*CandidateState) ID 

func (*CandidateState) ID() string

func (*CandidateState) LastElectionTime 

func (self *CandidateState) LastElectionTime() time.Time

func (*CandidateState) StartElection 

func (self *CandidateState) StartElection(localHSM *LocalHSM)

func (*CandidateState) UpdateLastElectionTime 

func (self *CandidateState) UpdateLastElectionTime()

type Client 

type Client interface {
	Append(data []byte) (result []byte, err error)
	ReadOnly(data []byte) (result []byte, err error)
	GetConfig() (conf *ps.Config, err error)
	ChangeConfig(conf *ps.Config) error
	io.Closer
}

type ClientEventListener 

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

ClientEventListener is a a helper class for listening client response in independent go routine.

func NewClientEventListener 

func NewClientEventListener() *ClientEventListener

func (*ClientEventListener) GetChan 

func (self *ClientEventListener) GetChan() chan ev.Event

func (*ClientEventListener) Start 

func (self *ClientEventListener) Start(fn func(ev.Event))

func (*ClientEventListener) Stop 

func (self *ClientEventListener) Stop()

type CommitCondition 

type CommitCondition interface {
	AddVote(ps.MultiAddr) error
	IsCommitted() bool
}

type Configuration 

type Configuration struct {
	HeartbeatTimeout                time.Duration
	ElectionTimeout                 time.Duration
	ElectionTimeoutThresholdPersent float64
	MaxTimeoutJitter                float32
	PersistErrorNotifyTimeout       time.Duration
	MaxAppendEntriesSize            uint64
	MaxSnapshotChunkSize            uint64
	CommClientTimeout               time.Duration
	CommServerTimeout               time.Duration
	CommPoolSize                    int
	ClientTimeout                   time.Duration
	RPCServerAuth                   *cm.RPCAuth
	RPCClientAuth                   *cm.RPCAuth
}

func DefaultConfiguration 

func DefaultConfiguration() *Configuration

type DeactivatedPeerState 

type DeactivatedPeerState struct {
	*LogStateHead
}

func NewDeactivatedPeerState 

func NewDeactivatedPeerState(
	super hsm.State, logger logging.Logger) *DeactivatedPeerState

func (*DeactivatedPeerState) Entry 

func (self *DeactivatedPeerState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*DeactivatedPeerState) Exit 

func (self *DeactivatedPeerState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*DeactivatedPeerState) Handle 

func (self *DeactivatedPeerState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*DeactivatedPeerState) ID 

func (*DeactivatedPeerState) ID() string

func (*DeactivatedPeerState) Init 

func (self *DeactivatedPeerState) Init(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

type EventChannel 

type EventChannel interface {
	Send(hsm.Event)
	Recv() hsm.Event
	Close()
}

The general interface of event channel.

type FollowerMemberChangeState 

type FollowerMemberChangeState struct {
	*LogStateHead
}

func NewFollowerMemberChangeState 

func NewFollowerMemberChangeState(
	super hsm.State, logger logging.Logger) *FollowerMemberChangeState

func (*FollowerMemberChangeState) Entry 

func (self *FollowerMemberChangeState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerMemberChangeState) Exit 

func (self *FollowerMemberChangeState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerMemberChangeState) Handle 

func (self *FollowerMemberChangeState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerMemberChangeState) ID 

func (*FollowerMemberChangeState) ID() string

type FollowerNewConfigSeenState 

type FollowerNewConfigSeenState struct {
	*LogStateHead
}

func NewFollowerNewConfigSeenState 

func NewFollowerNewConfigSeenState(
	super hsm.State, logger logging.Logger) *FollowerNewConfigSeenState

func (*FollowerNewConfigSeenState) Entry 

func (self *FollowerNewConfigSeenState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerNewConfigSeenState) Exit 

func (self *FollowerNewConfigSeenState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerNewConfigSeenState) Handle 

func (self *FollowerNewConfigSeenState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerNewConfigSeenState) ID 

func (*FollowerNewConfigSeenState) ID() string

type FollowerOldNewConfigCommittedState 

type FollowerOldNewConfigCommittedState struct {
	*LogStateHead
}

func NewFollowerOldNewConfigCommittedState 

func NewFollowerOldNewConfigCommittedState(
	super hsm.State,
	logger logging.Logger) *FollowerOldNewConfigCommittedState

func (*FollowerOldNewConfigCommittedState) Entry 

func (self *FollowerOldNewConfigCommittedState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerOldNewConfigCommittedState) Exit 

func (self *FollowerOldNewConfigCommittedState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerOldNewConfigCommittedState) Handle 

func (self *FollowerOldNewConfigCommittedState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerOldNewConfigCommittedState) ID 

func (*FollowerOldNewConfigCommittedState) ID() string

type FollowerOldNewConfigSeenState 

type FollowerOldNewConfigSeenState struct {
	*LogStateHead
}

func NewFollowerOldNewConfigSeenState 

func NewFollowerOldNewConfigSeenState(
	super hsm.State, logger logging.Logger) *FollowerOldNewConfigSeenState

func (*FollowerOldNewConfigSeenState) Entry 

func (self *FollowerOldNewConfigSeenState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerOldNewConfigSeenState) Exit 

func (self *FollowerOldNewConfigSeenState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerOldNewConfigSeenState) Handle 

func (self *FollowerOldNewConfigSeenState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerOldNewConfigSeenState) ID 

func (*FollowerOldNewConfigSeenState) ID() string

type FollowerState 

type FollowerState struct {
	*LogStateHead
	// contains filtered or unexported fields
}

func NewFollowerState 

func NewFollowerState(
	super hsm.State,
	electionTimeout time.Duration,
	electionTimeoutThresholdPersent float64,
	maxTimeoutJitter float32,
	logger logging.Logger) *FollowerState

func (*FollowerState) Entry 

func (self *FollowerState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerState) Exit 

func (self *FollowerState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerState) Handle 

func (self *FollowerState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*FollowerState) HandleAppendEntriesRequest 

func (self *FollowerState) HandleAppendEntriesRequest(
	localHSM *LocalHSM,
	request *ev.AppendEntriesRequest,
	lastLogIndex uint64) *ev.AppendEntriesResponse

func (*FollowerState) HandleRequestVoteRequest 

func (self *FollowerState) HandleRequestVoteRequest(
	localHSM *LocalHSM,
	request *ev.RequestVoteRequest) *ev.RequestVoteResponse

func (*FollowerState) ID 

func (*FollowerState) ID() string

func (*FollowerState) LastContactTime 

func (self *FollowerState) LastContactTime() time.Time

func (*FollowerState) UpdateLastContact 

func (self *FollowerState) UpdateLastContact(localHSM *LocalHSM)

func (*FollowerState) UpdateLastContactTime 

func (self *FollowerState) UpdateLastContactTime()

type HSMBackend 

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

func NewHSMBackend 

func NewHSMBackend(
	config *Configuration,
	localAddr *ps.ServerAddress,
	bindAddr *ps.ServerAddress,
	configManager ps.ConfigManager,
	stateMachine ps.StateMachine,
	log ps.Log,
	logger logging.Logger) (*HSMBackend, error)

func (*HSMBackend) Close 

func (self *HSMBackend) Close() error

func (*HSMBackend) GetNotifyChan 

func (self *HSMBackend) GetNotifyChan() <-chan ev.NotifyEvent

func (*HSMBackend) Send 

func (self *HSMBackend) Send(event ev.RequestEvent)

type InavaliableResponseHandler 

type InavaliableResponseHandler func(ev.Event, ev.RequestEvent) ([]byte, error)

type Inflight 

type Inflight struct {
	MaxIndex           uint64
	ToCommitEntries    []*InflightEntry
	CommittedEntries   []*InflightEntry
	ServerMatchIndexes map[ps.MultiAddr]uint64

	sync.Mutex
}

func NewInflight 

func NewInflight(conf *ps.Config) *Inflight

func (*Inflight) Add 

func (self *Inflight) Add(request *InflightRequest) error

func (*Inflight) AddAll 

func (self *Inflight) AddAll(toCommits []*InflightEntry) error

func (*Inflight) ChangeMember 

func (self *Inflight) ChangeMember(conf *ps.Config)

func (*Inflight) GetCommitted 

func (self *Inflight) GetCommitted() []*InflightEntry

func (*Inflight) Init 

func (self *Inflight) Init()

func (*Inflight) Replicate 

func (self *Inflight) Replicate(
	addr ps.MultiAddr, newMatchIndex uint64) (bool, error)

type InflightEntry 

type InflightEntry struct {
	Request   *InflightRequest
	Condition CommitCondition
}

func NewInflightEntry 

func NewInflightEntry(request *InflightRequest) *InflightEntry

type InflightRequest 

type InflightRequest struct {
	LogEntry   *ps.LogEntry
	ResultChan chan ev.Event
}

type LeaderInMemberChangeState 

type LeaderInMemberChangeState struct {
	*LogStateHead
}

func NewLeaderInMemberChangeState 

func NewLeaderInMemberChangeState(
	super hsm.State, logger logging.Logger) *LeaderInMemberChangeState

func (*LeaderInMemberChangeState) Entry 

func (self *LeaderInMemberChangeState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderInMemberChangeState) Exit 

func (self *LeaderInMemberChangeState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderInMemberChangeState) Handle 

func (self *LeaderInMemberChangeState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderInMemberChangeState) ID 

func (*LeaderInMemberChangeState) ID() string

func (*LeaderInMemberChangeState) Init 

func (self *LeaderInMemberChangeState) Init(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

type LeaderMemberChangeActivatedState 

type LeaderMemberChangeActivatedState struct {
	*LogStateHead
}

func NewLeaderMemberChangeActivatedState 

func NewLeaderMemberChangeActivatedState(
	super hsm.State, logger logging.Logger) *LeaderMemberChangeActivatedState

func (*LeaderMemberChangeActivatedState) Entry 

func (self *LeaderMemberChangeActivatedState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangeActivatedState) Exit 

func (self *LeaderMemberChangeActivatedState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangeActivatedState) Handle 

func (self *LeaderMemberChangeActivatedState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangeActivatedState) ID 

func (*LeaderMemberChangeActivatedState) ID() string

func (*LeaderMemberChangeActivatedState) Init 

func (self *LeaderMemberChangeActivatedState) Init(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

type LeaderMemberChangeDeactivatedState 

type LeaderMemberChangeDeactivatedState struct {
	*LogStateHead
}

func NewLeaderMemberChangeDeactivatedState 

func NewLeaderMemberChangeDeactivatedState(
	super hsm.State, logger logging.Logger) *LeaderMemberChangeDeactivatedState

func (*LeaderMemberChangeDeactivatedState) Entry 

func (self *LeaderMemberChangeDeactivatedState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangeDeactivatedState) Exit 

func (self *LeaderMemberChangeDeactivatedState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangeDeactivatedState) Handle 

func (self *LeaderMemberChangeDeactivatedState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangeDeactivatedState) ID 

func (*LeaderMemberChangeDeactivatedState) ID() string

type LeaderMemberChangeHSM 

type LeaderMemberChangeHSM struct {
	*hsm.StdHSM

	LeaderState *LeaderState
	LocalHSM    *LocalHSM
}

func NewLeaderMemberChangeHSM 

func NewLeaderMemberChangeHSM(
	top hsm.State, initial hsm.State) *LeaderMemberChangeHSM

func SetupLeaderMemberChangeHSM 

func SetupLeaderMemberChangeHSM(logger logging.Logger) *LeaderMemberChangeHSM

func (*LeaderMemberChangeHSM) Dispatch 

func (self *LeaderMemberChangeHSM) Dispatch(event hsm.Event)

func (*LeaderMemberChangeHSM) Init 

func (self *LeaderMemberChangeHSM) Init()

func (*LeaderMemberChangeHSM) QTran 

func (self *LeaderMemberChangeHSM) QTran(targetStateID string)

func (*LeaderMemberChangeHSM) QTranOnEvent 

func (self *LeaderMemberChangeHSM) QTranOnEvent(
	targetStateID string, event hsm.Event)

func (*LeaderMemberChangeHSM) SetLeaderState 

func (self *LeaderMemberChangeHSM) SetLeaderState(leaderState *LeaderState)

func (*LeaderMemberChangeHSM) SetLocalHSM 

func (self *LeaderMemberChangeHSM) SetLocalHSM(localHSM *LocalHSM)

type LeaderMemberChangePhase1State 

type LeaderMemberChangePhase1State struct {
	*LogStateHead
}

func NewLeaderMemberChangePhase1State 

func NewLeaderMemberChangePhase1State(
	super hsm.State, logger logging.Logger) *LeaderMemberChangePhase1State

func (*LeaderMemberChangePhase1State) Entry 

func (self *LeaderMemberChangePhase1State) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangePhase1State) Exit 

func (self *LeaderMemberChangePhase1State) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangePhase1State) Handle 

func (self *LeaderMemberChangePhase1State) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangePhase1State) ID 

func (*LeaderMemberChangePhase1State) ID() string

type LeaderMemberChangePhase2State 

type LeaderMemberChangePhase2State struct {
	*LogStateHead
}

func NewLeaderMemberChangePhase2State 

func NewLeaderMemberChangePhase2State(
	super hsm.State, logger logging.Logger) *LeaderMemberChangePhase2State

func (*LeaderMemberChangePhase2State) Entry 

func (self *LeaderMemberChangePhase2State) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangePhase2State) Exit 

func (self *LeaderMemberChangePhase2State) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangePhase2State) Handle 

func (self *LeaderMemberChangePhase2State) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangePhase2State) ID 

func (*LeaderMemberChangePhase2State) ID() string

type LeaderMemberChangeState 

type LeaderMemberChangeState struct {
	*LogStateHead
}

func NewLeaderMemberChangeState 

func NewLeaderMemberChangeState(
	super hsm.State, logger logging.Logger) *LeaderMemberChangeState

func (*LeaderMemberChangeState) Entry 

func (self *LeaderMemberChangeState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangeState) Exit 

func (self *LeaderMemberChangeState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangeState) Handle 

func (self *LeaderMemberChangeState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderMemberChangeState) ID 

func (*LeaderMemberChangeState) ID() string

func (*LeaderMemberChangeState) Init 

func (self *LeaderMemberChangeState) Init(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

type LeaderNotInMemberChangeState 

type LeaderNotInMemberChangeState struct {
	*LogStateHead
}

func NewLeaderNotInMemberChangeState 

func NewLeaderNotInMemberChangeState(
	super hsm.State, logger logging.Logger) *LeaderNotInMemberChangeState

func (*LeaderNotInMemberChangeState) Entry 

func (self *LeaderNotInMemberChangeState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderNotInMemberChangeState) Exit 

func (self *LeaderNotInMemberChangeState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderNotInMemberChangeState) Handle 

func (self *LeaderNotInMemberChangeState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderNotInMemberChangeState) ID 

func (*LeaderNotInMemberChangeState) ID() string

type LeaderPeerState 

type LeaderPeerState struct {
	*LogStateHead
	// contains filtered or unexported fields
}

func NewLeaderPeerState 

func NewLeaderPeerState(
	super hsm.State,
	heartbeatTimeout time.Duration,
	maxTimeoutJitter float32,
	logger logging.Logger) *LeaderPeerState

func (*LeaderPeerState) Entry 

func (self *LeaderPeerState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderPeerState) Exit 

func (self *LeaderPeerState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderPeerState) GetIndexInfo 

func (self *LeaderPeerState) GetIndexInfo() (uint64, uint64)

func (*LeaderPeerState) GetMatchIndexUpdated 

func (self *LeaderPeerState) GetMatchIndexUpdated() bool

func (*LeaderPeerState) GetTerm 

func (self *LeaderPeerState) GetTerm() uint64

func (*LeaderPeerState) Handle 

func (self *LeaderPeerState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderPeerState) HandleAppendEntriesResponse 

func (self *LeaderPeerState) HandleAppendEntriesResponse(local Local, peerHSM *PeerHSM, response *ev.AppendEntriesResponse)

func (*LeaderPeerState) ID 

func (*LeaderPeerState) ID() string

func (*LeaderPeerState) LastContactTime 

func (self *LeaderPeerState) LastContactTime() time.Time

func (*LeaderPeerState) SetMatchIndex 

func (self *LeaderPeerState) SetMatchIndex(index uint64)

func (*LeaderPeerState) SetMatchIndexUpdated 

func (self *LeaderPeerState) SetMatchIndexUpdated(v bool)

func (*LeaderPeerState) SetTerm 

func (self *LeaderPeerState) SetTerm(term uint64)

func (*LeaderPeerState) UpdateLastContact 

func (self *LeaderPeerState) UpdateLastContact()

func (*LeaderPeerState) UpdateLastContactTime 

func (self *LeaderPeerState) UpdateLastContactTime()

type LeaderState 

type LeaderState struct {
	*LogStateHead

	MemberChangeHSM *LeaderMemberChangeHSM
	Inflight        *Inflight
	// contains filtered or unexported fields
}

func NewLeaderState 

func NewLeaderState(super hsm.State, logger logging.Logger) *LeaderState

func (*LeaderState) CommitInflightEntries 

func (self *LeaderState) CommitInflightEntries(
	localHSM *LocalHSM, entries []*InflightEntry) error

func (*LeaderState) Entry 

func (self *LeaderState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderState) Exit 

func (self *LeaderState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderState) Handle 

func (self *LeaderState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderState) HandleClientRequest 

func (self *LeaderState) HandleClientRequest(
	localHSM *LocalHSM, requestData []byte, resultChan chan ev.Event)

func (*LeaderState) ID 

func (*LeaderState) ID() string

func (*LeaderState) Init 

func (self *LeaderState) Init(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LeaderState) StartFlight 

func (self *LeaderState) StartFlight(
	localHSM *LocalHSM,
	logType ps.LogType,
	logData []byte,
	resultChan chan ev.Event) error

type Local 

type Local interface {
	Send(event hsm.Event)
	SendPrior(event hsm.Event)
	io.Closer

	QueryState() string
	GetCurrentTerm() uint64
	GetLocalAddr() *ps.ServerAddress
	GetVotedFor() *ps.ServerAddress
	GetLeader() *ps.ServerAddress

	Log() ps.Log
	StateMachine() ps.StateMachine
	ConfigManager() ps.ConfigManager
	Notifier() *Notifier

	SetPeers(peers Peers)
}

func NewLocalManager 

func NewLocalManager(
	config *Configuration,
	localAddr *ps.ServerAddress,
	log ps.Log,
	stateMachine ps.StateMachine,
	configManager ps.ConfigManager,
	logger logging.Logger) (Local, error)

type LocalHSM 

type LocalHSM struct {
	*hsm.StdHSM

	logging.Logger
	// contains filtered or unexported fields
}

func NewLocalHSM 

func NewLocalHSM(
	top hsm.State,
	initial hsm.State,
	localAddr *ps.ServerAddress,
	configManager ps.ConfigManager,
	stateMachine ps.StateMachine,
	log ps.Log,
	logger logging.Logger) (*LocalHSM, error)

func (*LocalHSM) CommitInflightLog 

func (self *LocalHSM) CommitInflightLog(entry *InflightEntry) error

func (*LocalHSM) CommitLogsUpTo 

func (self *LocalHSM) CommitLogsUpTo(index uint64) error

func (*LocalHSM) ConfigManager 

func (self *LocalHSM) ConfigManager() ps.ConfigManager

func (*LocalHSM) Dispatch 

func (self *LocalHSM) Dispatch(event hsm.Event)

func (*LocalHSM) GetCurrentTerm 

func (self *LocalHSM) GetCurrentTerm() uint64

func (*LocalHSM) GetLeader 

func (self *LocalHSM) GetLeader() *ps.ServerAddress

func (*LocalHSM) GetLocalAddr 

func (self *LocalHSM) GetLocalAddr() *ps.ServerAddress

func (*LocalHSM) GetMemberChangeStatus 

func (self *LocalHSM) GetMemberChangeStatus() MemberChangeStatusType

func (*LocalHSM) GetVotedFor 

func (self *LocalHSM) GetVotedFor() *ps.ServerAddress

func (*LocalHSM) Init 

func (self *LocalHSM) Init()

func (*LocalHSM) Log 

func (self *LocalHSM) Log() ps.Log

func (*LocalHSM) Notifier 

func (self *LocalHSM) Notifier() *Notifier

func (*LocalHSM) Peers 

func (self *LocalHSM) Peers() Peers

func (*LocalHSM) QTran 

func (self *LocalHSM) QTran(targetStateID string)

func (*LocalHSM) QTranOnEvent 

func (self *LocalHSM) QTranOnEvent(targetStateID string, event hsm.Event)

func (*LocalHSM) SelfDispatch 

func (self *LocalHSM) SelfDispatch(event hsm.Event)

func (*LocalHSM) SendMemberChangeNotify 

func (self *LocalHSM) SendMemberChangeNotify() error

func (*LocalHSM) SetApplier 

func (self *LocalHSM) SetApplier(applier *Applier)

func (*LocalHSM) SetCurrentTerm 

func (self *LocalHSM) SetCurrentTerm(term uint64)

func (*LocalHSM) SetCurrentTermWithNotify 

func (self *LocalHSM) SetCurrentTermWithNotify(term uint64)

func (*LocalHSM) SetLeader 

func (self *LocalHSM) SetLeader(leader *ps.ServerAddress)

func (*LocalHSM) SetLeaderWithNotify 

func (self *LocalHSM) SetLeaderWithNotify(leader *ps.ServerAddress)

func (*LocalHSM) SetLocalAddr 

func (self *LocalHSM) SetLocalAddr(addr *ps.ServerAddress)

func (*LocalHSM) SetMemberChangeStatus 

func (self *LocalHSM) SetMemberChangeStatus(status MemberChangeStatusType)

func (*LocalHSM) SetPeers 

func (self *LocalHSM) SetPeers(peers Peers)

func (*LocalHSM) SetVotedFor 

func (self *LocalHSM) SetVotedFor(votedFor *ps.ServerAddress)

func (*LocalHSM) StateMachine 

func (self *LocalHSM) StateMachine() ps.StateMachine

func (*LocalHSM) Terminate 

func (self *LocalHSM) Terminate()

type LocalManager 

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

func (*LocalManager) Close 

func (self *LocalManager) Close() error

func (*LocalManager) ConfigManager 

func (self *LocalManager) ConfigManager() ps.ConfigManager

func (*LocalManager) GetCurrentTerm 

func (self *LocalManager) GetCurrentTerm() uint64

func (*LocalManager) GetLeader 

func (self *LocalManager) GetLeader() *ps.ServerAddress

func (*LocalManager) GetLocalAddr 

func (self *LocalManager) GetLocalAddr() *ps.ServerAddress

func (*LocalManager) GetVotedFor 

func (self *LocalManager) GetVotedFor() *ps.ServerAddress

func (*LocalManager) Log 

func (self *LocalManager) Log() ps.Log

func (*LocalManager) Notifier 

func (self *LocalManager) Notifier() *Notifier

func (*LocalManager) QueryState 

func (self *LocalManager) QueryState() string

func (*LocalManager) Send 

func (self *LocalManager) Send(event hsm.Event)

func (*LocalManager) SendPrior 

func (self *LocalManager) SendPrior(event hsm.Event)

func (*LocalManager) SetPeers 

func (self *LocalManager) SetPeers(peers Peers)

func (*LocalManager) StateMachine 

func (self *LocalManager) StateMachine() ps.StateMachine

type LocalState 

type LocalState struct {
	*LogStateHead
}

func NewLocalState 

func NewLocalState(super hsm.State, logger logging.Logger) *LocalState

func (*LocalState) Entry 

func (self *LocalState) Entry(sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LocalState) Exit 

func (self *LocalState) Exit(sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LocalState) Handle 

func (self *LocalState) Handle(sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*LocalState) ID 

func (*LocalState) ID() string

func (*LocalState) Init 

func (self *LocalState) Init(sm hsm.HSM, event hsm.Event) (state hsm.State)

type LogState 

type LogState interface {
	hsm.State
	logging.Logger
}

type LogStateHead 

type LogStateHead struct {
	*hsm.StateHead
	logging.Logger
}

func NewLogStateHead 

func NewLogStateHead(super hsm.State, logger logging.Logger) *LogStateHead

type MajorityCommitCondition 

type MajorityCommitCondition struct {
	VoteStatus   map[ps.MultiAddr]bool
	VoteCount    uint32
	MajoritySize uint32
}

func NewMajorityCommitCondition 

func NewMajorityCommitCondition(
	addrSlice *ps.ServerAddressSlice) *MajorityCommitCondition

func (*MajorityCommitCondition) AddVote 

func (self *MajorityCommitCondition) AddVote(addr ps.MultiAddr) error

func (*MajorityCommitCondition) IsCommitted 

func (self *MajorityCommitCondition) IsCommitted() bool

func (*MajorityCommitCondition) IsInCluster 

func (self *MajorityCommitCondition) IsInCluster(addr ps.MultiAddr) bool

type MemberChangeCommitCondition 

type MemberChangeCommitCondition struct {
	OldServersCommitCondition *MajorityCommitCondition
	NewServersCommitCondition *MajorityCommitCondition
}

func NewMemberChangeCommitCondition 

func NewMemberChangeCommitCondition(
	conf *ps.Config) *MemberChangeCommitCondition

func (*MemberChangeCommitCondition) AddVote 

func (self *MemberChangeCommitCondition) AddVote(addr ps.MultiAddr) error

func (*MemberChangeCommitCondition) IsCommitted 

func (self *MemberChangeCommitCondition) IsCommitted() bool

type MemberChangeStatusType 

type MemberChangeStatusType uint8
const (
	MemberChangeStatusNotSet MemberChangeStatusType = iota
	NotInMemeberChange
	OldNewConfigSeen
	OldNewConfigCommitted
	NewConfigSeen
	NewConfigCommitted
)

func InitMemberChangeStatus 

func InitMemberChangeStatus(
	configManager ps.ConfigManager,
	log ps.Log) (MemberChangeStatusType, error)

type NeedPeersState 

type NeedPeersState struct {
	*LogStateHead
}

func NewNeedPeersState 

func NewNeedPeersState(super hsm.State, logger logging.Logger) *NeedPeersState

func (*NeedPeersState) Entry 

func (self *NeedPeersState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*NeedPeersState) Exit 

func (self *NeedPeersState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*NeedPeersState) Handle 

func (self *NeedPeersState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*NeedPeersState) ID 

func (*NeedPeersState) ID() string

type Node 

type Node interface {
	Client
	Notifiable
}

type Notifiable 

type Notifiable interface {
	GetNotifyChan() <-chan ev.NotifyEvent
}

type NotifiableHSM 

type NotifiableHSM interface {
	hsm.HSM
	GetNotifyChan() <-chan ev.NotifyEvent
}

type Notifier 

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

Notifier is use to signal notify to the outside of this module.

func NewNotifier 

func NewNotifier() *Notifier

func (*Notifier) Close 

func (self *Notifier) Close()

func (*Notifier) GetNotifyChan 

func (self *Notifier) GetNotifyChan() <-chan ev.NotifyEvent

func (*Notifier) Notify 

func (self *Notifier) Notify(event ev.NotifyEvent)

func (*Notifier) Start 

func (self *Notifier) Start()

type Peer 

type Peer interface {
	Send(Event hsm.Event)
	SendPrior(event hsm.Event)
	Close()

	QueryState() string
}

func NewPeerMan 

func NewPeerMan(
	config *Configuration,
	addr *ps.ServerAddress,
	client cm.Client,
	local Local,
	logger logging.Logger) Peer

type PeerHSM 

type PeerHSM struct {
	*hsm.StdHSM
	// contains filtered or unexported fields
}

func NewPeerHSM 

func NewPeerHSM(
	top hsm.State,
	initial hsm.State,
	addr *ps.ServerAddress,
	client cm.Client,
	local Local) *PeerHSM

func (*PeerHSM) Addr 

func (self *PeerHSM) Addr() *ps.ServerAddress

func (*PeerHSM) Client 

func (self *PeerHSM) Client() cm.Client

func (*PeerHSM) Dispatch 

func (self *PeerHSM) Dispatch(event hsm.Event)

func (*PeerHSM) EventHandler 

func (self *PeerHSM) EventHandler() cm.EventHandler

func (*PeerHSM) Init 

func (self *PeerHSM) Init()

func (*PeerHSM) Local 

func (self *PeerHSM) Local() Local

func (*PeerHSM) QTran 

func (self *PeerHSM) QTran(targetStateID string)

func (*PeerHSM) SelfDispatch 

func (self *PeerHSM) SelfDispatch(event hsm.Event)

func (*PeerHSM) Terminate 

func (self *PeerHSM) Terminate()

type PeerMan 

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

func (*PeerMan) Close 

func (self *PeerMan) Close()

func (*PeerMan) QueryState 

func (self *PeerMan) QueryState() string

func (*PeerMan) Send 

func (self *PeerMan) Send(event hsm.Event)

func (*PeerMan) SendPrior 

func (self *PeerMan) SendPrior(event hsm.Event)

type PeerManager 

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

func NewPeerManager 

func NewPeerManager(
	config *Configuration,
	client cm.Client,
	local Local,
	getLoggerForPeer func(ps.MultiAddr) logging.Logger,
	logger logging.Logger) *PeerManager

func (*PeerManager) AddPeers 

func (self *PeerManager) AddPeers(peerAddrSlice *ps.ServerAddressSlice)

func (*PeerManager) Broadcast 

func (self *PeerManager) Broadcast(event hsm.Event)

func (*PeerManager) Close 

func (self *PeerManager) Close() error

func (*PeerManager) RemovePeers 

func (self *PeerManager) RemovePeers(peerAddrSlice *ps.ServerAddressSlice)

type PeerState 

type PeerState struct {
	*LogStateHead
}

func NewPeerState 

func NewPeerState(super hsm.State, logger logging.Logger) *PeerState

func (*PeerState) Entry 

func (self *PeerState) Entry(sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*PeerState) Exit 

func (self *PeerState) Exit(sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*PeerState) Handle 

func (self *PeerState) Handle(sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*PeerState) ID 

func (*PeerState) ID() string

func (*PeerState) Init 

func (self *PeerState) Init(sm hsm.HSM, event hsm.Event) (state hsm.State)

type Peers 

type Peers interface {
	Broadcast(event hsm.Event)
	AddPeers(peerAddrSlice *ps.ServerAddressSlice)
	RemovePeers(peerAddrSlice *ps.ServerAddressSlice)
	io.Closer
}

type PersistErrorPeerState 

type PersistErrorPeerState struct {
	*LogStateHead
}

func NewPersistErrorPeerState 

func NewPersistErrorPeerState(
	super hsm.State, logger logging.Logger) *PersistErrorPeerState

func (*PersistErrorPeerState) Entry 

func (self *PersistErrorPeerState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*PersistErrorPeerState) Exit 

func (self *PersistErrorPeerState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*PersistErrorPeerState) Handle 

func (self *PersistErrorPeerState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*PersistErrorPeerState) ID 

func (*PersistErrorPeerState) ID() string

type PersistErrorState 

type PersistErrorState struct {
	*LogStateHead
	// contains filtered or unexported fields
}

func NewPersistErrorState 

func NewPersistErrorState(
	super hsm.State,
	persistErrorNotifyTimeout time.Duration,
	logger logging.Logger) *PersistErrorState

func (*PersistErrorState) Entry 

func (self *PersistErrorState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*PersistErrorState) Exit 

func (self *PersistErrorState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*PersistErrorState) Handle 

func (self *PersistErrorState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*PersistErrorState) ID 

func (*PersistErrorState) ID() string

type PipelineModePeerState 

type PipelineModePeerState struct {
	*LogStateHead
}

func NewPipelineModePeerState 

func NewPipelineModePeerState(
	super hsm.State, logger logging.Logger) *PipelineModePeerState

func (*PipelineModePeerState) Entry 

func (self *PipelineModePeerState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*PipelineModePeerState) Exit 

func (self *PipelineModePeerState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*PipelineModePeerState) Handle 

func (self *PipelineModePeerState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*PipelineModePeerState) ID 

func (*PipelineModePeerState) ID() string

type RaftNode 

type RaftNode struct {
	*RedirectClient
	// contains filtered or unexported fields
}

func NewRaftNode 

func NewRaftNode(backend *HSMBackend, client *RedirectClient) *RaftNode

func (*RaftNode) Close 

func (self *RaftNode) Close() error

func (*RaftNode) GetNotifyChan 

func (self *RaftNode) GetNotifyChan() <-chan ev.NotifyEvent

type RandomTicker 

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

func NewRandomTicker 

func NewRandomTicker(timeout time.Duration, maxJitter float32) *RandomTicker

func (*RandomTicker) Reset 

func (self *RandomTicker) Reset()

func (*RandomTicker) Start 

func (self *RandomTicker) Start(fn func())

func (*RandomTicker) Stop 

func (self *RandomTicker) Stop()

type RedirectClient 

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

func NewRedirectClient 

func NewRedirectClient(
	timeout time.Duration,
	retry rt.Retry,
	redirectRetry rt.Retry,
	backend Backend,
	client cm.Client,
	server cm.Server,
	logger logging.Logger) *RedirectClient

func (*RedirectClient) Append 

func (self *RedirectClient) Append(data []byte) (result []byte, err error)

func (*RedirectClient) ChangeConfig 

func (self *RedirectClient) ChangeConfig(conf *ps.Config) error

func (*RedirectClient) Close 

func (self *RedirectClient) Close() error

func (*RedirectClient) GetConfig 

func (self *RedirectClient) GetConfig() (conf *ps.Config, err error)

func (*RedirectClient) ReadOnly 

func (self *RedirectClient) ReadOnly(data []byte) (result []byte, err error)

func (*RedirectClient) Start 

func (self *RedirectClient) Start() error

type RedirectResponseHandler 

type RedirectResponseHandler func(
	*ev.LeaderRedirectResponseEvent, ev.RequestEvent) (ev.Event, error)

type ReliableEventChannel 

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

ReliableEventChannel is an unlimited size channel for non-blocking event sending/receiving.

func NewReliableEventChannel 

func NewReliableEventChannel() *ReliableEventChannel

func (*ReliableEventChannel) Close 

func (self *ReliableEventChannel) Close()

func (*ReliableEventChannel) GetInChan 

func (self *ReliableEventChannel) GetInChan() chan<- hsm.Event

func (*ReliableEventChannel) GetOutChan 

func (self *ReliableEventChannel) GetOutChan() <-chan hsm.Event

func (*ReliableEventChannel) Recv 

func (self *ReliableEventChannel) Recv() hsm.Event

func (*ReliableEventChannel) Send 

func (self *ReliableEventChannel) Send(event hsm.Event)

func (*ReliableEventChannel) Start 

func (self *ReliableEventChannel) Start()

type ReliableInflightEntryChannel 

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

func NewReliableInflightEntryChannel 

func NewReliableInflightEntryChannel() *ReliableInflightEntryChannel

func (*ReliableInflightEntryChannel) Close 

func (self *ReliableInflightEntryChannel) Close()

func (*ReliableInflightEntryChannel) GetInChan 

func (self *ReliableInflightEntryChannel) GetInChan() chan<- *InflightEntry

func (*ReliableInflightEntryChannel) GetOutChan 

func (self *ReliableInflightEntryChannel) GetOutChan() <-chan *InflightEntry

func (*ReliableInflightEntryChannel) Recv 

func (self *ReliableInflightEntryChannel) Recv() *InflightEntry

func (*ReliableInflightEntryChannel) Send 

func (self *ReliableInflightEntryChannel) Send(entry *InflightEntry)

func (*ReliableInflightEntryChannel) Start 

func (self *ReliableInflightEntryChannel) Start()

type ReliableUint64Channel 

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

ReliableUint64Channel is an unlimited size channel for non-blocking sending/receiving

func NewReliableUint64Channel 

func NewReliableUint64Channel() *ReliableUint64Channel

func (*ReliableUint64Channel) Close 

func (self *ReliableUint64Channel) Close()

func (*ReliableUint64Channel) GetInChan 

func (self *ReliableUint64Channel) GetInChan() chan<- uint64

func (*ReliableUint64Channel) GetOutChan 

func (self *ReliableUint64Channel) GetOutChan() <-chan uint64

func (*ReliableUint64Channel) Recv 

func (self *ReliableUint64Channel) Recv() uint64

func (*ReliableUint64Channel) Send 

func (self *ReliableUint64Channel) Send(in uint64)

func (*ReliableUint64Channel) Start 

func (self *ReliableUint64Channel) Start()

type SelfDispatchHSM 

type SelfDispatchHSM interface {
	hsm.HSM
	SelfDispatch(event hsm.Event)
}

type SimpleClient 

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

func NewSimpleClient 

func NewSimpleClient(
	backend Backend, timeout time.Duration, retry rt.Retry) *SimpleClient

func (*SimpleClient) Append 

func (self *SimpleClient) Append(data []byte) (result []byte, err error)

func (*SimpleClient) ChangeConfig 

func (self *SimpleClient) ChangeConfig(conf *ps.Config) error

func (*SimpleClient) Close 

func (self *SimpleClient) Close() error

func (*SimpleClient) GetConfig 

func (self *SimpleClient) GetConfig() (conf *ps.Config, err error)

func (*SimpleClient) ReadOnly 

func (self *SimpleClient) ReadOnly(data []byte) (result []byte, err error)

type SimpleTicker 

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

func NewSimpleTicker 

func NewSimpleTicker(timeout time.Duration) *SimpleTicker

func (*SimpleTicker) Reset 

func (self *SimpleTicker) Reset()

func (*SimpleTicker) Start 

func (self *SimpleTicker) Start(fn func())

func (*SimpleTicker) Stop 

func (self *SimpleTicker) Stop()

type SnapshotInfo 

type SnapshotInfo struct {
	Leader            *ps.ServerAddress
	Conf              *ps.Config
	LastIncludedTerm  uint64
	LastIncludedIndex uint64
	Size              uint64
	Offset            uint64
}

type SnapshotModePeerState 

type SnapshotModePeerState struct {
	*LogStateHead
	// contains filtered or unexported fields
}

func NewSnapshotModePeerState 

func NewSnapshotModePeerState(
	super hsm.State,
	maxSnapshotChunkSize uint64,
	logger logging.Logger) *SnapshotModePeerState

func (*SnapshotModePeerState) Entry 

func (self *SnapshotModePeerState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*SnapshotModePeerState) Exit 

func (self *SnapshotModePeerState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*SnapshotModePeerState) Handle 

func (self *SnapshotModePeerState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*SnapshotModePeerState) ID 

func (*SnapshotModePeerState) ID() string

func (*SnapshotModePeerState) SendNextChunk 

func (self *SnapshotModePeerState) SendNextChunk(
	peerHSM *PeerHSM, term uint64, leader *ps.ServerAddress) error

func (*SnapshotModePeerState) SetupRequest 

func (self *SnapshotModePeerState) SetupRequest(
	term uint64, leader *ps.ServerAddress) hsm.Event

type SnapshotRecoveryState 

type SnapshotRecoveryState struct {
	*LogStateHead
	// contains filtered or unexported fields
}

func NewSnapshotRecoveryState 

func NewSnapshotRecoveryState(
	super hsm.State, logger logging.Logger) *SnapshotRecoveryState

func (*SnapshotRecoveryState) Entry 

func (self *SnapshotRecoveryState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*SnapshotRecoveryState) Exit 

func (self *SnapshotRecoveryState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*SnapshotRecoveryState) Handle 

func (self *SnapshotRecoveryState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*SnapshotRecoveryState) ID 

func (*SnapshotRecoveryState) ID() string

type StandardModePeerState 

type StandardModePeerState struct {
	*LogStateHead
	// contains filtered or unexported fields
}

func NewStandardModePeerState 

func NewStandardModePeerState(
	super hsm.State,
	maxAppendEntriesSize uint64,
	logger logging.Logger) *StandardModePeerState

func (*StandardModePeerState) Entry 

func (self *StandardModePeerState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*StandardModePeerState) Exit 

func (self *StandardModePeerState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*StandardModePeerState) Handle 

func (self *StandardModePeerState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*StandardModePeerState) ID 

func (*StandardModePeerState) ID() string

func (*StandardModePeerState) SetupNextAppendEntriesRequestEvent 

func (self *StandardModePeerState) SetupNextAppendEntriesRequestEvent(
	local Local,
	prevLogTerm uint64,
	prevLogIndex uint64,
	fromIndex uint64) hsm.Event

func (*StandardModePeerState) SetupReplicating 

func (self *StandardModePeerState) SetupReplicating(
	peerHSM *PeerHSM) (event hsm.Event)

type SyncState 

type SyncState struct {
	*LogStateHead
}

func NewSyncState 

func NewSyncState(super hsm.State, logger logging.Logger) *SyncState

func (*SyncState) Entry 

func (self *SyncState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*SyncState) Exit 

func (self *SyncState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*SyncState) Handle 

func (self *SyncState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*SyncState) ID 

func (*SyncState) ID() string

type TerminableHSM 

type TerminableHSM interface {
	hsm.HSM
	Terminate()
}

type Ticker 

type Ticker interface {
	Start(fn func())
	Reset()
	Stop()
}

type UnsyncState 

type UnsyncState struct {
	*LogStateHead
	// contains filtered or unexported fields
}

func NewUnsyncState 

func NewUnsyncState(super hsm.State, logger logging.Logger) *UnsyncState

func (*UnsyncState) Entry 

func (self *UnsyncState) Entry(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*UnsyncState) Exit 

func (self *UnsyncState) Exit(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*UnsyncState) Handle 

func (self *UnsyncState) Handle(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*UnsyncState) ID 

func (*UnsyncState) ID() string

func (*UnsyncState) Init 

func (self *UnsyncState) Init(
	sm hsm.HSM, event hsm.Event) (state hsm.State)

func (*UnsyncState) StartSync 

func (self *UnsyncState) StartSync(localHSM *LocalHSM) error

func (*UnsyncState) StartSyncSafe 

func (self *UnsyncState) StartSyncSafe(localHSM *LocalHSM)

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.