File: state.go

package info (click to toggle)
golang-github-hashicorp-raft 0.0~git20160317.0.3359516-1~bpo8+1
  • links: PTS, VCS
  • area: main
  • in suites: jessie-backports
  • size: 428 kB
  • sloc: makefile: 16
file content (169 lines) | stat: -rw-r--r-- 3,929 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
package raft

import (
	"sync/atomic"
)

// RaftState captures the state of a Raft node: Follower, Candidate, Leader,
// or Shutdown.
type RaftState uint32

const (
	// Follower is the initial state of a Raft node.
	Follower RaftState = iota

	// Candidate is one of the valid states of a Raft node.
	Candidate

	// Leader is one of the valid states of a Raft node.
	Leader

	// Shutdown is the terminal state of a Raft node.
	Shutdown
)

func (s RaftState) String() string {
	switch s {
	case Follower:
		return "Follower"
	case Candidate:
		return "Candidate"
	case Leader:
		return "Leader"
	case Shutdown:
		return "Shutdown"
	default:
		return "Unknown"
	}
}

// raftState is used to maintain various state variables
// and provides an interface to set/get the variables in a
// thread safe manner.
type raftState struct {
	// The current term, cache of StableStore
	currentTerm uint64

	// Cache the latest log from LogStore
	LastLogIndex uint64
	LastLogTerm  uint64

	// Highest committed log entry
	commitIndex uint64

	// Last applied log to the FSM
	lastApplied uint64

	// Cache the latest snapshot index/term
	lastSnapshotIndex uint64
	lastSnapshotTerm  uint64

	// Tracks the number of live routines
	runningRoutines int32

	// The current state
	state RaftState
}

func (r *raftState) getState() RaftState {
	stateAddr := (*uint32)(&r.state)
	return RaftState(atomic.LoadUint32(stateAddr))
}

func (r *raftState) setState(s RaftState) {
	stateAddr := (*uint32)(&r.state)
	atomic.StoreUint32(stateAddr, uint32(s))
}

func (r *raftState) getCurrentTerm() uint64 {
	return atomic.LoadUint64(&r.currentTerm)
}

func (r *raftState) setCurrentTerm(term uint64) {
	atomic.StoreUint64(&r.currentTerm, term)
}

func (r *raftState) getLastLogIndex() uint64 {
	return atomic.LoadUint64(&r.LastLogIndex)
}

func (r *raftState) setLastLogIndex(term uint64) {
	atomic.StoreUint64(&r.LastLogIndex, term)
}

func (r *raftState) getLastLogTerm() uint64 {
	return atomic.LoadUint64(&r.LastLogTerm)
}

func (r *raftState) setLastLogTerm(term uint64) {
	atomic.StoreUint64(&r.LastLogTerm, term)
}

func (r *raftState) getCommitIndex() uint64 {
	return atomic.LoadUint64(&r.commitIndex)
}

func (r *raftState) setCommitIndex(term uint64) {
	atomic.StoreUint64(&r.commitIndex, term)
}

func (r *raftState) getLastApplied() uint64 {
	return atomic.LoadUint64(&r.lastApplied)
}

func (r *raftState) setLastApplied(term uint64) {
	atomic.StoreUint64(&r.lastApplied, term)
}

func (r *raftState) getLastSnapshotIndex() uint64 {
	return atomic.LoadUint64(&r.lastSnapshotIndex)
}

func (r *raftState) setLastSnapshotIndex(term uint64) {
	atomic.StoreUint64(&r.lastSnapshotIndex, term)
}

func (r *raftState) getLastSnapshotTerm() uint64 {
	return atomic.LoadUint64(&r.lastSnapshotTerm)
}

func (r *raftState) setLastSnapshotTerm(term uint64) {
	atomic.StoreUint64(&r.lastSnapshotTerm, term)
}

func (r *raftState) incrRoutines() {
	atomic.AddInt32(&r.runningRoutines, 1)
}

func (r *raftState) decrRoutines() {
	atomic.AddInt32(&r.runningRoutines, -1)
}

func (r *raftState) getRoutines() int32 {
	return atomic.LoadInt32(&r.runningRoutines)
}

// Start a goroutine and properly handle the race between a routine
// starting and incrementing, and exiting and decrementing.
func (r *raftState) goFunc(f func()) {
	r.incrRoutines()
	go func() {
		defer r.decrRoutines()
		f()
	}()
}

// getLastIndex returns the last index in stable storage.
// Either from the last log or from the last snapshot.
func (r *raftState) getLastIndex() uint64 {
	return max(r.getLastLogIndex(), r.getLastSnapshotIndex())
}

// getLastEntry returns the last index and term in stable storage.
// Either from the last log or from the last snapshot.
func (r *raftState) getLastEntry() (uint64, uint64) {
	if r.getLastLogIndex() >= r.getLastSnapshotIndex() {
		return r.getLastLogIndex(), r.getLastLogTerm()
	}
	return r.getLastSnapshotIndex(), r.getLastSnapshotTerm()
}