Raft协议示意-Golang版本

说明：受b站某视频中liwenzhou讲解启发，但懒得看别人的实现，就自己搞一个

 

package main

import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)

func main() {
    wg := sync.WaitGroup{}
    wg.Add(1)

    //启动Leader
    L.Start()

    //新建节点
    now := time.Now()
    for i := 0; i < 3; i++ {
        M[i] = &Node{ID: i, Role: 0, HB: make(chan *HeartBeatMsg, 16), VoteFor: -1, ChangeAt: now}
    }
    //启动所有节点
    for _, v := range M {
        v.Start()
    }

    wg.Wait()
}

// Leader
var L = &Leader{Node: nil, Term: -1, At: time.Now()}

// 所有节点
var M = map[int]*Node{}

// 心跳内容
const (
    ASK  = "ASK"
    OK   = "OK"
    NO   = "NO"
    PING = "PING"
    PONG = "PONG"
)

// 心跳间隔
const HeartBeatInterval = time.Second * 2

// Leader 领导者
type Leader struct {
    Node *Node     //领导者节点
    Term int       //任期
    At   time.Time //任期开始时间
}

// Raft节点
type Node struct {
    ID        int
    Role      int                //角色：0跟随者、1候选者、2领导者
    HB        chan *HeartBeatMsg //收到的心跳
    VoteFor   int                //站谁
    ChangeAt  time.Time          //角色变更时间
    VoteCount int                //收到的选票数量
    VetoCount int                //收到的拒绝票数量
    LastAt    time.Time          //上次收到消息的时间
}

// 心跳报文
type HeartBeatMsg struct {
    From int       //发送方ID
    At   time.Time //发送时间
    Data string    //发送内容
}

// Leader的启动方法
func (l *Leader) Start() {
    go func() {
        for {
            //领导没事就PING
            if l.Node == nil || M == nil || len(M) == 0 {
                <-time.After(time.Second)
                continue
            }

            now := time.Now()
            for _, n := range M {
                if l.Node == n {
                    continue
                }
                fmt.Printf("leader%d send PING\n", l.Node.ID)
                n.HB <- &HeartBeatMsg{From: l.Node.ID, At: now, Data: PING}
            }
            //每隔1秒PING一次
            <-time.After(HeartBeatInterval / 2) //FIXME 不能interval-1啊啊啊

        }
    }()
}

// Node的启动方法
func (n *Node) Start() {
    go func() {
        for {
            //
            select {
            case <-time.After(HeartBeatInterval):
                fmt.Printf("Node%d got no msg in past 2 seconds\n", n.ID)
                //run for leader
                if L.Node == nil && n.VoteFor == -1 && n.Role == 0 {
                    n.Role = 1
                    n.VoteFor = n.ID
                    n.VoteCount = 1
                    d := rand.Intn(150) + 150
                    <-time.After(time.Millisecond * time.Duration(d))
                    n.ChangeAt = time.Now()
                    n.sendHeartBeat(ASK, n.ChangeAt)
                }

            case hb := <-n.HB:
                fmt.Printf("hb %d @ %d\n", hb.From, n.ID)
                n.LastAt = hb.At //这个时间，是否有必要都更新？响应的
                n.handleHeartBeat(hb)

            }

        }
    }()
}

// Node发送心跳
func (n *Node) sendHeartBeat(data string, at time.Time) {
    hb := &HeartBeatMsg{From: n.ID, At: at, Data: data}
    for _, v := range M {
        if v.ID == n.ID {
            continue
        }
        v.HB <- hb
    }
}

// Node处理心跳
func (n *Node) handleHeartBeat(hb *HeartBeatMsg) {

    switch hb.Data {
    case ASK:
        if L.Node != nil {
            fmt.Println("有领导，拒绝")
            M[hb.From].HB <- &HeartBeatMsg{From: n.ID, Data: NO}
        }
        if n.Role == 0 {
            if n.VoteFor == -1 {
                fmt.Printf("%d同意%d\n", n.ID, hb.From)
                n.VoteFor = hb.From
                M[hb.From].HB <- &HeartBeatMsg{From: n.ID, Data: OK}
            } else {
                fmt.Printf("%d已同意别人，拒绝%d\n", n.ID, hb.From)
                M[hb.From].HB <- &HeartBeatMsg{From: n.ID, Data: NO}
            }
        } //是不是要判断下候选者的时间，以决定是否同意？
        if n.Role == 1 {
            if n.ChangeAt.After(hb.At) {
                fmt.Printf("%d同意%d，并将自身变回跟随者\n", n.ID, hb.From)
                n.VoteFor = hb.From
                n.Role = 0
                M[hb.From].HB <- &HeartBeatMsg{From: n.ID, Data: OK}
            } else {
                fmt.Printf("%d不同意%d，%d更早\n", n.ID, hb.From, n.ID)
                M[hb.From].HB <- &HeartBeatMsg{From: n.ID, Data: NO}
            }
        }
    case OK:
        n.VoteCount++
    case NO:
        n.VetoCount++
    case PING:
        M[hb.From].HB <- &HeartBeatMsg{From: n.ID, Data: PONG}
    case PONG:
    }
    // 其实当选后，应该清理所有的状态
    if n.Role != 1 {
        return
    }
    //判断是否当选，或者是否失败
    if n.VetoCount+n.VoteCount == len(M) {
        now := time.Now()
        if n.VoteCount > len(M)/2 {
            n.Role = 2
            n.ChangeAt = now
            n.VoteFor = -1
            n.VetoCount = 0
            n.VoteCount = 0
            L.Node = n
            L.Term++
            L.At = now

            fmt.Println("!!!LEADER", L.Node.ID)
        } else {
            n.Role = 0
            n.ChangeAt = now
            n.VoteFor = -1
            n.VetoCount = 0
            n.VoteCount = 0
        }
    }
}

 

运行：

[Running] go run "c:\Users\Administrator\GoProjects\bilibili\raft\main.go"
Node2 got no msg in past 2 seconds
Node0 got no msg in past 2 seconds
Node1 got no msg in past 2 seconds
hb 1 @ 0
hb 0 @ 1
1不同意0，1更早
0同意1，并将自身变回跟随者
hb 1 @ 0
hb 0 @ 1
hb 1 @ 2
2同意1，并将自身变回跟随者
hb 2 @ 0
0已同意别人，拒绝2
hb 0 @ 2
2已同意别人，拒绝0
hb 2 @ 1
1不同意2，1更早
hb 2 @ 1
!!!LEADER 1
hb 2 @ 0
hb 0 @ 2
hb 1 @ 2
leader1 send PING
leader1 send PING
hb 1 @ 2
hb 2 @ 1
hb 1 @ 0
hb 0 @ 1
leader1 send PING
leader1 send PING
hb 1 @ 2
hb 2 @ 1
hb 1 @ 0
hb 0 @ 1