Raft in breif

 1message SnapshotMetadata {
 2	optional ConfState conf_state = 1 [(gogoproto.nullable) = false];
 3	optional uint64    index      = 2 [(gogoproto.nullable) = false];
 4	optional uint64    term       = 3 [(gogoproto.nullable) = false];
 5}
 6
 7message Snapshot {
 8	optional bytes            data     = 1;
 9	optional SnapshotMetadata metadata = 2 [(gogoproto.nullable) = false];
10}

 1type Storage interface {
 2	// TODO(tbg): split this into two interfaces, LogStorage and StateStorage.
 3	// InitialState returns the saved HardState and ConfState information.
 4	InitialState() (pb.HardState, pb.ConfState, error)
 5	// Entries returns a slice of log entries in the range [lo,hi).
 6	// MaxSize limits the total size of the log entries returned, but
 7	// Entries returns at least one entry if any.
 8	Entries(lo, hi, maxSize uint64) ([]pb.Entry, error)
 9	// Term returns the term of entry i, which must be in the range
10	// [FirstIndex()-1, LastIndex()]. The term of the entry before
11	// FirstIndex is retained for matching purposes even though the
12	// rest of that entry may not be available.
13	Term(i uint64) (uint64, error)
14	// LastIndex returns the index of the last entry in the log.
15	LastIndex() (uint64, error)
16	// FirstIndex returns the index of the first log entry that is
17	// possibly available via Entries (older entries have been incorporated
18	// into the latest Snapshot; if storage only contains the dummy entry the
19	// first log entry is not available).
20	FirstIndex() (uint64, error)
21	// Snapshot returns the most recent snapshot.
22	// If snapshot is temporarily unavailable, it should return ErrSnapshotTemporarilyUnavailable,
23	// so raft state machine could know that Storage needs some time to prepare
24	// snapshot and call Snapshot later.
25	Snapshot() (pb.Snapshot, error)
26}
27
28// MemoryStorage implements the Storage interface backed by an
29// in-memory array.
30type MemoryStorage struct {
31	// Protects access to all fields. Most methods of MemoryStorage are
32	// run on the raft goroutine, but Append() is run on an application
33	// goroutine.
34	sync.Mutex
35	hardState pb.HardState
36	snapshot  pb.Snapshot
37	// ents[i] has raft log position i+snapshot.Metadata.Index
38	ents []pb.Entry
39}

 1type raftLog struct {
 2	// storage contains all stable entries since the last snapshot.
 3	storage Storage
 4	// unstable contains all unstable entries and snapshot.
 5	// they will be saved into storage.
 6	unstable unstable
 7	// committed is the highest log position that is known to be in
 8	// stable storage on a quorum of nodes.
 9	committed uint64
10	// applied is the highest log position that the application has
11	// been instructed to apply to its state machine.
12	// Invariant: applied <= committed
13	applied uint64
14	logger Logger
15	// maxNextEntsSize is the maximum number aggregate byte size of the messages
16	// returned from calls to nextEnts.
17	maxNextEntsSize uint64
18}

 1// unstable.entries[i] has raft log position i+unstable.offset.
 2// Note that unstable.offset may be less than the highest log
 3// position in storage; this means that the next write to storage
 4// might need to truncate the log before persisting unstable.entries.
 5type unstable struct {
 6	// the incoming unstable snapshot, if any.
 7	snapshot *pb.Snapshot
 8	// all entries that have not yet been written to storage.
 9	entries []pb.Entry
10	offset  uint64
11	logger Logger
12}