forked from travisjeffery/jocko
-
Notifications
You must be signed in to change notification settings - Fork 0
/
leader.go
121 lines (106 loc) · 2.66 KB
/
leader.go
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
package raft
import (
"net"
"time"
"github.com/travisjeffery/jocko"
)
// monitorLeadership is used to monitor if we acquire or lose our role as the
// leader in the Raft cluster.
func (b *Raft) monitorLeadership(notifyCh <-chan bool, serfEventCh <-chan *jocko.ClusterMember) {
var stopCh chan struct{}
for {
select {
case isLeader := <-notifyCh:
if isLeader {
stopCh = make(chan struct{})
go b.leaderLoop(stopCh, serfEventCh)
b.logger.Info("cluster leadership acquired")
} else if stopCh != nil {
close(stopCh)
stopCh = nil
b.logger.Info("cluster leadership lost")
}
case <-b.shutdownCh:
return
}
}
}
// revokeLeadership is invoked once we step down as leader.
// This is used to cleanup any state that may be specific to the leader.
func (b *Raft) revokeLeadership() error {
return nil
}
// leaderLoop is ran when this raft instance is the leader of the cluster and is used to
// perform cluster leadership duties.
func (b *Raft) leaderLoop(stopCh chan struct{}, serfEventCh <-chan *jocko.ClusterMember) {
defer b.revokeLeadership()
var reconcileCh <-chan *jocko.ClusterMember
establishedLeader := false
RECONCILE:
reconcileCh = nil
interval := time.After(b.reconcileInterval)
if err := b.waitForBarrier(); err != nil {
goto WAIT
}
if !establishedLeader {
if err := b.establishLeadership(stopCh); err != nil {
b.logger.Info("failed to establish leadership: %v", err)
goto WAIT
}
establishedLeader = true
}
if err := b.reconcile(); err != nil {
b.logger.Info("failed to reconcile: %v", err)
goto WAIT
}
reconcileCh = serfEventCh
WAIT:
for {
select {
case <-stopCh:
return
case <-b.shutdownCh:
return
case <-interval:
goto RECONCILE
case member := <-reconcileCh:
if b.IsLeader() {
b.reconcileMember(member)
}
}
}
}
func (b *Raft) establishLeadership(stopCh chan struct{}) error {
// start monitoring other brokers
// b.periodicDispatcher.SetEnabled(true)
// b.periodicDispatcher.Start()
return nil
}
func (b *Raft) reconcile() error {
members := b.serf.Cluster()
for _, member := range members {
if err := b.reconcileMember(member); err != nil {
return err
}
}
return nil
}
func (b *Raft) reconcileMember(member *jocko.ClusterMember) error {
// don't reconcile ourself
if member.ID == b.serf.ID() {
return nil
}
var err error
switch member.Status {
case jocko.StatusAlive:
addr := &net.TCPAddr{IP: net.ParseIP(member.IP), Port: member.RaftPort}
err = b.addPeer(addr.String())
case jocko.StatusLeft, jocko.StatusReap:
err = b.removePeer(member.IP)
}
if err != nil {
b.logger.Info("failed to reconcile member: %v: %v", member, err)
return err
}
return nil
}