raft

type ApplyCommand struct {
	*Future
	// contains filtered or unexported fields
}

type ChannelTransport struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

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

type ClientInterface interface {
	Apply(cmd []byte, timeout time.Duration) FutureInterface
	AddNonVoter(id ServerId, addr ServerAddress, prevIndex uint64, timeout time.Duration) FutureInterface
	AddVoter(id ServerId, addr ServerAddress, prevIndex uint64, timeout time.Duration) FutureInterface
}

type Config struct {

	// A follower receive no communication over a period of time.
	ElectionTimeout time.Duration

	HeartbeatInterval time.Duration

	LocalId ServerId

	SnapshotThreshold uint64
	SnapshotInterval  time.Duration

	MaxLogEntriesAfterSnapshot uint64
}

type Configuration struct {
	Servers []Server
}

type ConfigurationChangeFuture struct {
	*Future
	// contains filtered or unexported fields
}

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

type FutureInterface interface {
	Error() error
	Result() interface{}
	Fail(err error)
	Complete(result interface{})
	Failed() bool
	Succeeded() bool
}

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

type LogInterface interface {
	GetEntry(index uint64) (*raftpb.Entry, error)
	DeleteRange(from uint64, to uint64) error
	AppendEntries(entry []*raftpb.Entry) error
	LastIndex() (uint64, error)
	FirstIndex() (uint64, error)
}

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

type MemoryStateMachine struct {
	StateMachineSnapshot
	// contains filtered or unexported fields
}

type MemoryStorage struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type NetTransport struct {
}

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

type RPC struct {
	Request    interface{}
	ResponseCh chan RPCResponse
}

type RPCResponse struct {
	Err  error
	Data interface{}
}

type Raft struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type Replication struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type Server struct {

	// Network address
	Address ServerAddress

	// Identifier
	ID ServerId

	Suffrage Suffrage
}

type ServerAddress string

type ServerId string

type ServerInterface interface {
	ApplyChannel() chan *ApplyCommand
	ConfigurationChangeChannel() chan *ConfigurationChangeFuture
	Done() chan struct{}
}

type Snapshot struct {
	ID            string        `json:"id"`
	LastIndex     uint64        `json:"lastIndex"`
	LastTerm      uint64        `json:"lastTerm"`
	Configuration Configuration `json:"configuration"`
}

type SnapshotStoreInterface interface {
	Save(lastIndex, lastTerm uint64, configuration Configuration) (*Snapshot, error)

	List() ([]*Snapshot, error)

	Open(id string) (*Snapshot, error)
}

type State string

type StateMachineInterface interface {
	Apply(entry *raftpb.Entry)
	Snapshot() (*StateMachineSnapshot, error)
	Recover(snapshot *Snapshot) error
}

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

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

type StorageInterface interface {
	LogInterface
	SetUint64(key []byte, val uint64) error

	GetUint64(key []byte) (uint64, error)

	Set(key []byte, val []byte) error

	Get(key []byte) ([]byte, error)
}

type Suffrage string

type TransportInterface interface {
	SendAppendEntries(server Server, request *raftpb.AppendEntriesRequest) (*raftpb.AppendEntriesReply, error)
	SendRequestVote(server Server, request *raftpb.RequestVoteRequest) (*raftpb.RequestVoteReply, error)
	LocalAddr() ServerAddress
	Consumer() <-chan *RPC
}