multiraft

type ChangeMembershipOperation int8

type ChangeMembershipPayload struct {
	Operation ChangeMembershipOperation
	Node      uint64
}

type ClientInterface interface {
	Go(serviceMethod string, args interface{}, reply interface{}, done chan *rpc.Call) *rpc.Call
	Close() error
}

type Config struct {
	Storage   Storage
	Transport Transport
	// Ticker may be nil to use real time and TickInterval.
	Ticker Ticker

	// A new election is called if the ElectionTimeout elapses with no contact from the leader.
	// The actual ElectionTimeout is chosen randomly from the range [ElectionTimeoutMin,
	// ElectionTimeoutMax) to minimize the chances of several servers trying to become leaders
	// simultaneously. The Raft paper suggests a range of 150-300ms for local networks;
	// geographically distributed installations should use higher values to account for the
	// increased round trip time.
	ElectionTimeoutTicks   int
	HeartbeatIntervalTicks int
	TickInterval           time.Duration

	// If Strict is true, some warnings become fatal panics and additional (possibly expensive)
	// sanity checks will be done.
	Strict bool
}

type EventCommandCommitted struct {
	Command []byte
}

type EventLeaderElection struct {
	GroupID uint64
	NodeID  uint64
}

type GroupPersistentState struct {
	GroupID   uint64
	HardState raftpb.HardState
}

type LogEntry struct {
	Entry raftpb.Entry
}

type LogEntryState struct {
	Index int
	Entry LogEntry
	Error error
}

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

type MultiRaft struct {
	Config

	Events chan interface{}
	// contains filtered or unexported fields
}

type RPCInterface interface {
	SendMessage(req *SendMessageRequest, resp *SendMessageResponse) error
}

type SendMessageRequest struct {
	GroupID uint64
	Message raftpb.Message
}

type SendMessageResponse struct {
}

type ServerInterface interface {
	DoRPC(name string, req, resp interface{}) error
}

type Storage interface {

	// SetGroupState is called to update the persistent state for the given group.
	SetGroupState(groupID uint64, state *GroupPersistentState) error

	// AppendLogEntries is called to add entries to the log. The entries will always span
	// a contiguous range of indices just after the current end of the log.
	AppendLogEntries(groupID uint64, entries []*LogEntry) error
}

type Ticker interface {
	// This channel will be readable once per tick. The time value returned is unspecified;
	// the channel has this type for compatibility with time.Ticker but other implementations
	// may not return real times.
	Chan() <-chan time.Time
}

type Transport interface {
	// Listen informs the Transport of the local node's ID and callback interface.
	// The Transport should associate the given id with the server object so other Transport's
	// Connect methods can find it.
	Listen(id uint64, server ServerInterface) error

	// Stop undoes a previous Listen.
	Stop(id uint64)

	// Connect looks up a node by id and returns a stub interface to submit RPCs to it.
	Connect(id uint64) (ClientInterface, error)
}