ETCD源码阅读（二）

DAY1 ：阅读raftexample：etcd/contrib/raftexample

raftexample 包括三个组件：一个基于 raft 的kv store、一个 REST API Server、一个基于 etcd raft 实现的 Raft Node。其中Raft Node也拥有一个Http server，用于与peer节点进行通信。REST API Server则是这个Raft Node的client。

kv store 是一个k-v map，它保存了所有 committed 的键值。Raft Node 和REST API Server通过该kv store进行通信。数据更新通过kv store发送到 Raft Node。存储库在 Raft Node 回复更新 committed 后，更新内部的k-v map。

REST API Server 通过访问kv store来展示当前的 raft 共识状况。GET 命令用于在kv store中查找键并返回值（如果有）。键值 PUT 命令向kv store发出更新proposal。

Raft Node与其集群peer一起参与共识。当 REST API Server器提交proposal时，Raft Node将这个proposal传输给其同伴。当raft集群达成共识时，Raft Node通过commit channel发布所有committed的proposal。对于 raftexample这个例子来说，这个channel的消费者是kv store。

go build -o raftexample

启动单节点

./raftexample --id 1 --cluster http://127.0.0.1:12379 --port 12380

id是指这个RAFT节点的id索引，--cluster后面是所有的peer列表，使用逗号分隔，port是k-v存储server的地址

store a value ("hello") to a key ("my-key"):

curl -L http://127.0.0.1:12380/my-key -XPUT -d hello

retrieve the stored key:

curl -L http://127.0.0.1:12380/my-key

多节点集群以及配置变更

启动一个三节点集群，配置信息参看Procfile

goreman start

使用一个POST请求，告知集群，一个ID为4的节点可以加入集群

curl -L http://127.0.0.1:12380/4 -XPOST -d http://127.0.0.1:42379

启动这个ID为4的节点，并附上--join标签

raftexample --id 4 --cluster http://127.0.0.1:12379,http://127.0.0.1:22379,http://127.0.0.1:32379,http://127.0.0.1:42379 --port 42380 --join

通过一个DELETE请求，可以删除一个节点

curl -L http://127.0.0.1:12380/3 -XDELETE

阅读RAFTEXAMPLE的main函数

// etcd/contrib/raftexample/main.go
package main
 
import (
	"flag"
	"strings"
 
	"go.etcd.io/etcd/raft/v3/raftpb"
)
 
func main() {
	cluster := flag.String("cluster", "http://127.0.0.1:9021", "comma separated cluster peers")
	id := flag.Int("id", 1, "node ID")
	kvport := flag.Int("port", 9121, "key-value server port")
	join := flag.Bool("join", false, "join an existing cluster")
	flag.Parse()
 
	proposeC := make(chan string)
	defer close(proposeC)
	confChangeC := make(chan raftpb.ConfChange)
	defer close(confChangeC)
 
	// raft provides a commit stream for the proposals from the http api
	var kvs *kvstore
	getSnapshot := func() ([]byte, error) { return kvs.getSnapshot() }
 
    // newRaftNode initiates a raft instance and returns a committed log entry
    // channel and error channel. Proposals for log updates are sent over the
    // provided the proposal channel. All log entries are replayed over the
    // commit channel, followed by a nil message (to indicate the channel is
    // current), then new log entries. To shutdown, close proposeC and read errorC.
	commitC, errorC, snapshotterReady := newRaftNode(*id, strings.Split(*cluster, ","), *join, getSnapshot, proposeC, confChangeC)
 
	kvs = newKVStore(<-snapshotterReady, proposeC, commitC, errorC)
 
	// the key-value http handler will propose updates to raft
	serveHttpKVAPI(kvs, *kvport, confChangeC, errorC)
}

1. 创建了两个通道 proposeC 和 confChangeC，分别用来传递 Proposal 和 raft 配置变更信息，并设置了 defer 关键字以确保这两个channel会被关闭。

2. 创建了一个名为 kvs 的指向 kvstore 结构体的指针，并定义了 getSnapshot 函数，该函数用于获取快照。

3. 通过 newRaftNode 函数创建了一个 raft 节点，该节点与集群中的其他节点通信。将 proposeC 和 confChangeC 通道传递给 newRaftNode 函数，以便将来可以通过HTTP API向 raft 节点提交更新建议和配置变更请求。返回的 commitC 和 errorC 通道接收已提交的更新和错误信息。

4. 通过 raft 节点的 snapshotterReady 通道，传递一个snap.Snapshotter指针给 kvs 结构体，使得 kvs 结构体能够接收到快照并进行恢复。

5. 使用新创建的 kvs 结构体、kvport 端口、confChangeC 和 errorC 通道启动了一个 HTTP 服务器，该服务器用于接收 key-value 更新的请求，同时将这些请求转发到 raft 节点进行处理。

上面这段代码中使用到了以下几个channel：

• proposeC：这个channel会作为参数传给RaftNode，KVStore通过这个channel发送新的Proposal给RaftNode
• commitC：这个channel由RaftNode创建，作为返回值，又在KVStore初始化的时候被一个独立的Goroutine进行处理。因为只有RaftNode可以决定一个Proposal是否被commit，而committed的Proposal才会被写入KVStore。

  // read commits from raft into kvStore map until error
  go s.readCommits(commitC, errorC)

• confChangeC：这个channel同样作为参数传给RaftNode，Http API Server通过这个channel将配置变更的信息发送给RaftNode
• snapshotterReady：根据 contrib/raftexample/raft.go中定义的newRaftNode函数, 创建RaftNode时会根据Node ID创建一个目录：/raftexample-id-snap。 完成设置后，启动一个Goroutine来执行startRaft()函数

      rc.snapshotter = snap.New(zap.NewExample(), rc.snapdir)
      // signal replay has finished
      rc.snapshotterReady <- rc.snapshotter

  这样，newKVStore函数就可以从channel中读到snapshot（如果存在）
• errorC：由KVStore、HTTP API Server、RaftNode共享，一旦出现错误，都会log.Fatal()

针对newRaftNode, kvstore, serveHttpAPI这几个关键代码，我们逐一进行分析。

newRaftNode：

这个函数主要就是进行配置设置，最后用一个goroutine来启动raft节点，所以我们直接看这段代码就行。

func (rc *raftNode) startRaft() {
	if !fileutil.Exist(rc.snapdir) {
		if err := os.Mkdir(rc.snapdir, 0750); err != nil {
			log.Fatalf("raftexample: cannot create
				 dir for snapshot (%v)", err)
		}
	}
	rc.snapshotter = snap.New(zap.NewExample(), rc.snapdir)
 
	oldwal := wal.Exist(rc.waldir)
	rc.wal = rc.replayWAL()
 
	// signal replay has finished
	rc.snapshotterReady <- rc.snapshotter
 
	rpeers := make([]raft.Peer, len(rc.peers))
	for i := range rpeers {
		rpeers[i] = raft.Peer{ID: uint64(i + 1)}
	}
	c := &raft.Config{
		ID:                        uint64(rc.id),
		ElectionTick:              10,
		HeartbeatTick:             1,
		Storage:                   rc.raftStorage,
		MaxSizePerMsg:             1024 * 1024,
		MaxInflightMsgs:           256,
		MaxUncommittedEntriesSize: 1 << 30,
	}
 
	if oldwal || rc.join {
		rc.node = raft.RestartNode(c)
	} else {
		rc.node = raft.StartNode(c, rpeers)
	}
 
	rc.transport = &rafthttp.Transport{
		Logger:      rc.logger,
		ID:          types.ID(rc.id),
		ClusterID:   0x1000,
		Raft:        rc,
		ServerStats: stats.NewServerStats("", ""),
		LeaderStats: stats.NewLeaderStats(zap.NewExample(), 
			strconv.Itoa(rc.id)),
		ErrorC:      make(chan error),
	}
 
	rc.transport.Start()
	for i := range rc.peers {
		if i+1 != rc.id {
			rc.transport.AddPeer(types.ID(i+1), []string{rc.peers[i]})
		}
	}
 
	go rc.serveRaft()
	go rc.serveChannels()
}

1. 先检查快照、重放预写日志，使Raft节点恢复到之前的状态。
2. 根据传递进来的 peers 数组构造出 raft.Peer 列表 rpeers，然后创建一个 Raft config对象 c，包括节点的 ID、选举周期、心跳周期、存储、最大消息大小等等
3. 如果存在预写日志或者需要加入一个现有集群（join==true），就会调用raft.RestartNode，不然就启动一个新的Raft节点raft.StartNode
4. 接着，创建一个 HTTP 传输对象 rafthttp.Transport，用于处理 Raft 节点之间的通信。然后，调用 rc.transport.Start 方法启动，并添加peer节点。
5. 最后，启动两个goroutine，用于处理RaftNode的事件请求与channel读写。

go rc.serveRaft()
go rc.serveChannels()

serveRaft()

func (rc *raftNode) serveRaft() {
	url, err := url.Parse(rc.peers[rc.id-1])
	if err != nil {
		log.Fatalf("raftexample: Failed parsing URL (%v)", err)
	}
 
	ln, err := newStoppableListener(url.Host, rc.httpstopc)
	if err != nil {
		log.Fatalf("raftexample: Failed to listen rafthttp (%v)", err)
	}
	// Transport implements Transporter interface. 
	// It provides the functionality to send raft messages to peers, 
	// and receive raft messages from peers. 
	// User should call Handler method to get a handler 
	// to serve requests received from peerURLs. 
	// User needs to call Start before calling other functions, 
	// and call Stop when the Transport is no longer used.
	err = (&http.Server{Handler: rc.transport.Handler()}).Serve(ln)
	select {
	case <-rc.httpstopc:
	default:
		log.Fatalf("raftexample: Failed to serve rafthttp (%v)", err)
	}
	close(rc.httpdonec)
}

1. 在 serveRaft 函数中，首先通过id解析 rc.peers，得到当前节点的地址，Parse出一个URL对象。然后创建一个带由stop channel的 listener 对象，并将其与 http.Server 绑定。通过调用 http.Server 的 Serve 方法来开始在监听地址上提供服务。直到出错才会返回一个err。

2. 当从 httpstopc 接收到停止服务的信号时，该方法会结束，然后关闭 httpdonec 以通知所有其他goroutine，http server已经完成shutdown。这里的写法非常有意思，我们来具体分析一下

	err = (&http.Server{Handler: rc.transport.Handler()}).Serve(ln)
	select {
	case <-rc.httpstopc:
	default:
		log.Fatalf("raftexample: Failed to serve rafthttp (%v)", err)
	}
	close(rc.httpdonec)
	// httpstopc：signals http server to shutdown
	// httpdonec：signals http server shutdown complete

第一行只有当http server发生错误才会返回，然后执行select语句。

如果在执行select语句前，httpstopc这个channel已经被关闭，就会跳过default语句，直接关闭httpdonec这个channel。

如果httpstopc没有被关闭，并且读到了什么东西（意味着有别的goroutine在往里面写，具体看下面的serveChannels分析），也会跳过default语句，直接关闭httpdonec这个channel。

如果httpstopc没有任何响应，那么会执行default分支，输出log表明是因为http server发生错误导致的异常，然后退出程序。