raftexample示例中， raftNode.serveRaft（）方法中有一段使用的HTTP库的代码,实现如下：
func (rc *raftNode) serveRaft() {
url, err := url.Parse(rc.peers[rc.id-1])
if err != nil {
log.Fatalf("raftexample: Failed parsing URL (%v)", err)
}
//创建stoppableListener实例， stoppableListener内嵌了net.TCPListener接口，它会与http. Server配合实现对当前节点的URL地址进行监听
ln, err := newStoppableListener(url.Host, rc.httpstopc)
if err != nil {
log.Fatalf("raftexample: Failed to listen rafthttp (%v)", err)
}
err = (&http.Server{Handler: rc.transport.Handler()}).Serve(ln)//创建http.Server实例
select {
case <-rc.httpstopc:
default:
log.Fatalf("raftexample: Failed to serve rafthttp (%v)", err)
}
close(rc.httpdonec)
}这里创建了一个http.Server实例，它会通过传入的TCPListener实例监昕指定地址上的连接请求，当TCPListener实例通过Accept（）方法监昕到新连接到来时，会创建对应的net.Conn实例（可以将其理解为一个单独的网络连接）, http.Server 会为每个连接启动一个独立的后台goroutine，处理该连接上的请求。每个请求的处理逻辑封装在http.Server.Handler 中（创建http.Server实例时传入），流程如下图：
处理消息使用的Handler实例是由rafthttp.Transporter.Handler（）方法创建的， 其中为多个路径绑定了对应的Handler实例:
func (t *Transport) Handler() http.Handler {
//创建pipelineHandler、 streamHandler和snapshotHandler三个实例，这三个实例都实现了http.Server.Handler接口，具体实现在本章后面介绍rafthttp.Transport时详细分析
pipelineHandler := newPipelineHandler(t, t.Raft, t.ClusterID)
streamHandler := newStreamHandler(t, t, t.Raft, t.ID, t.ClusterID)
snapHandler := newSnapshotHandler(t, t.Raft, t.Snapshotter, t.ClusterID)
:= http.NewServeMux()
mux.Handle(RaftPrefix, pipelineHandler)
mux.Handle(RaftStreamPrefix+"/", streamHandler)
mux.Handle(RaftSnapshotPrefix, snapHandler)
mux.Handle(ProbingPrefix, probing.NewHandler())
return mux
} 这些handle是如何被调用的呢？首先是http.Server.Serve（）方法，其中通过net.Listener接收新连接，并为每个连接启动一个单独的后台goroutine来处理该连接上的请求.
在http.Server.Serve（）中首先调用ηet.Listener的Accept()函数将将net.Conn封装成http.conn，然后单独起一个goroutine处理新连接。进入http.conn.Serve（）方法，该方法会读取客户端的请求创建serverHandler实例，并调用其ServeHTTP（）方法处理请求。处理单个请求的核心就是serverHandler.ServeHTTP（）方法，该方法会将请求交给绑定的http.Server.Handler实例进行处理，需要注意的是这里serverHandler.srv字段指向的就是前面创建的http.Server实例
func (sh serverHandler) ServeHTTP(rw ResponseWr工ter, req *Request) {
//http.Server.Handler字段指向的就是前面通过Transport.Handler（）方法创建的http.ServeMux实例
handler := sh.srv.Handler
if handler == nil {//如采http.Server未初始化Handler字段，则使用默认的ServeMux实例
handler = DefaultServeMux
}
handler.ServeHTTP(rw, req) //调用http.ServeMux.ServeHTTP（）方法进行处理
}http.ServeMux.ServHttp（）方法会根据请求的具体路径，选择合适的Handler 实例处理请求，该方法的具体实现如下：
func (mux *ServeMux) ServeHTTP(w ResponseWr工ter, r *Request) {
h, := mux.Handler(r) // 根据请求路径选择对应的Handler
h.ServeHTTP(w, r) // 将请求交给Handler进行处理
}//下面是ServeMux. Handler（）方法的具体实现
func (mux *ServeMux) Handler (r *Request) (h Handler, pattern string) {
//对CONNECT请求方法的处理（略）
host : = stripHostPort(r.Host) //从请求中获取host信息
path := cleanPath(r.URL.Path) // 从请求中获取请求路径
return mux.handler(host, r .URL.Path) // 根据host信息和请求路径查找对应的Handler实例
}//下面是ServeMux.handler（）方法的具体实现
func (mux *ServeMux) handler (host, path string) (h Handler, pattern string) {
if mux.hosts { //首先根据host和path的组合查找
h, pattern= mux.match(host +path)
}
if h == nil { //只根据path查找
h, pattern ＝ mux.match(path)
}
return
}//下面是ServeMux. match（）方法的具体实现
func (mux *ServeMux) match (path string) (h Handler, pattern string) {
v, ok := mux.m[path] //如采存在精确匹配的Handler，则直接返回
if ok { return v.h, v.pattern }
for k, v := range mux.m { //查找与path匹配程度最高的Handler实例
//具体查找过程（略）
}
return
}rafthttp模块详解
通过前面介绍对raft模块的介绍我们知道，raft模块井未提供网络层的相关实现，而是将待发送的消息封装进Ready实例返回给上层模块，然后由上层模块决定如何将这些消息发送到集群中的其他节点。etcd 将网络层相关的实现独立成一个单独的模块，也就是要详细介绍的rafthttp模块。之所以独立出该模块，是为了降低raft模块与网络层实现之间的耦合，降低raft模块和rafthttp模块实现的成本，提高整个程序的可扩展性。在etcd中有多种消息类型，不同类型的消息所能携带的数据大小也不尽相同，其中快照相关消息的数据量就比较大，小至几k，大至几GB都是有可能的，而Leader节点到Follower，大至几GB都是有可能的，而Leader节点到Follower节点之间的心跳消息一般只有几十到几百个字节。因此,etcd的网络层会创建两个消息传输通道。
上面说的两个消息传输通道:Stream消息通道和Pipeline消息通道。这两种消息通道的主要区别在于： Stream消息通道维护的HTTP长连接，主要负责传输数据量较小、发送比较频繁的消息， 例如，前面介绍的MsgApp消息、MsgHeartbeat消息、MsgVote消息等；而Pipeline 消息通道在传输数据完成后会立即关闭连接，主要负责传输数据量较大、发送频率较低的消息，例如，MsgProp、MsgSnap消息等。
Stream消息通道是节点启动后，主动与集群中的其他节点建立的。每个Stream消息通道有2个关联的后台goroutine， 其中一个用于建立关联的HTTP连接，并从连接上读取数据，然后将这些读取到的数据反序列化成Message实例，传递到raft模块中进行处理。另外一个后台goroutine会读取raft模块返回的消息数据并将其序列化，最后写入Stream消息通道。前面对raftNode.serveRaft（）方法的介绍，在启动http.Server 时会通过rafthttp.Transporter.Handler（）方法为指定的URL路径添加相应的Handler实例，其中“／raft/stream/” 路径对应的Handler为此eamHandler类型，它负责处理Stream消息通道上的请求。相同的，pipelineHandler、snapshotHandler类型都有相应的路径。
1、rafthttp.Transporter接口
rafthttp.Transporter 接口，它是rafthttp包的核心接口之一，它定义了etcd网络层的核心功能，其具体定义如下：
type Transporter interface {
//初始化操作
Start() error
//创建Handler实例，并关联到指定的URL上
Handler() http.Handler
//发送消息
Send(m []raftpb.Message)
//发送快照数据
SendSnapshot(m snap.Message)
//在集群中添加一个节点时，其他节点会通过该方法添加该新加入节点的信息
AddRemote(id types.ID, urls []string)
Peer接口是当前节点对集群中其他节点的抽象表示，而结构体peer则是Peer接口的一个具体实现下面几个方法就是对Peer的操作，通过名称即可了解其含义
AddPeer(id types.ID, urls []string)
RemovePeer(id types.ID)
RemoveAllPeers()
UpdatePeer(id types.ID, urls []string)
ActiveSince(id types.ID) time.Time
ActivePeers() int
Stop()
}还有另一个需要重点介绍的接口:Raft，在前面介绍raftexample示例时，也简单提到过该接口，该接口的定义如下：
type Raft interface {
//将指定的消息实例传递到底层的etcd-raft模块进行处理
Process(ctx context.Context, m raftpb.Message) error
IsIDRemoved(id uint64) bool
//通知底层etcd-raft模块， 当前节点与指定的节点无法遥远
ReportUnreachable(id uint64)
//通知底层的etcd-raft模块，快照数据是否发送成功
ReportSnapshot(id uint64, status raft.SnapshotStatus)
}
rafthttp.Transport是rafthttp.Transporter接口具体实现,rafthttp.Transport中定义的关键字段：
ID (types.ID类型）： 当前节点自己的ID。
URLs ( types.URLs类型）： 当前节点与集群中其他节点交互时使用的Url地址。
ClusterlD ( types.ID类型）：当前节点所在的集群的ID。
Raft ( Raft类型）： Raft是一个接口，其实现的底层封装了前面介绍的etcd-raft模块，当rafthttp.Transport收到消息之后，会将其交给Raft实例进行处理。
Snapshotter ( *snap. Snapshotter类型）：Snapshotter负责管理快照文件，后面会介绍其实现。
streamRt ( http.RoundTripper类型）： Stream消息通道中使用的http. RoundTripper实例。
pipelineRt ( http.RoundTripper 类型）：Pipeline 消息通道中使用的http.RoundTripper实例
peers( map[types. ID]Peer类型）：Peer接口是当前节点对集群中其他节点的抽象表示。对于当前节点来说，集群中其他节点在本地都会有一个Peer 实例与之对应，peers 字段维护了节点ID到对应Peer实例之间的映射关系。
remotes ( map[types.ID]*remote类型）： remote 中只封装了pipeline 实例，remote主要负责发送快照数据，帮助新加入的节点快速追赶上其他节点的数据。
prober ( probing.Prober类型）：用于探测Pipeline消息通道是否可用。
func (t *Transport) Start() error {
var err error
//创建Stream消息通道使用的http.RoundTripper实例，底层实际上是创建http.Transport实例，
//这里需要读者注意一下几个参数的设置，分别是：创建连接的超时时间（根据配置指定）、读写请求的超时时间（默认Ss）和keepAl工ve时间（默认为30s)
t.streamRt, err = newStreamRoundTripper(t.TLSInfo, t.DialTimeout)
if err != nil {
return err
}
//创建Pipeline消息通道用的http.RoundTripper实例与streamRt不同的是，读写请求的起时时间设置成了永不过期
t.pipelineRt, err = NewRoundTripper(t.TLSInfo, t.DialTimeout)
if err != nil {
return err
}
t.remotes = make(map[types.ID]*remote)
t.peers = make(map[types.ID]Peer)
t.pipelineProber = probing.NewProber(t.pipelineRt)
t.streamProber = probing.NewProber(t.streamRt)
// If client didn't provide dial retry frequency, use the default
// (100ms backoff between attempts to create a new stream),
// so it doesn't bring too much overhead when retry.
if t.DialRetryFrequency == 0 {
t.DialRetryFrequency = rate.Every(100 * time.Millisecond)
}
return nil
} Transport.Handler（）方法主要负责创建Steam消息通道和Pipeline 消息通道用到的Handler实例，并注册到相应的请求路径上， 其具体实现在前面介绍过了 。
下面再来看一下Transport.AddPeer（）方法，其主要工作就是创建井启动对应节点的Peer实例，具体实现如下：
func (t *Transport) AddPeer(id types.ID, us []string) {
t.mu.Lock()
defer t.mu.Unlock()
if t.peers == nil {
panic("transport stopped")
}
if _, ok := t.peers[id]; ok {
return
}
urls, err := types.NewURLs(us)
if err != nil {
plog.Panicf("newURLs %+v should never fail: %+v", us, err)
}
fs := t.LeaderStats.Follower(id.String())
//创建指定节点对应的Peer实例，其中会相关的Stream消息通道和Pipeline消息通道
t.peers[id] = startPeer(t, urls, id, fs)
//每隔一段时间， prober会向该节点发送探测消息， 检测对端的健康状况
addPeerToProber(t.pipelineProber, id.String(), us, RoundTripperNameSnapshot, rtts)
addPeerToProber(t.streamProber, id.String(), us, RoundTripperNameRaftMessage, rtts)
plog.Infof("added peer %s", id)
}
Transport. Send（）方法负责发送指定的ra位pb.Message消息，其中首先尝试使用目标节点对应的Peer实例发送消息，如果没有找到对应的Peer实例，则尝试使用对应的remote实例发送消息。 Transport.Send（）方法的具体实现如下
func (t *Transport) Send(msgs []raftpb.Message) {
for _, m := range msgs {//遍历msgs切片中的全部J肖息
if m.To == 0 {
// ignore intentionally dropped message
continue
}
//根据raftpb.Message.To字段，获取目标节点对应的Peer实例
to := types.ID(m.To)
t.mu.RLock()
p, pok := t.peers[to]
g, rok := t.remotes[to]
t.mu.RUnlock()
if pok {
if m.Type == raftpb.MsgApp {
t.ServerStats.SendAppendReq(m.Size())
}
p.send(m)//通过peer.send（）方法完成消息的发送
continue
}
if rok {
//如采指定节点ID不存在对应的Peer实例，则尝试使用查找对应remote实例,通过remote. send（）方法完成消息的发送
g.send(m)
continue
}
plog.Debugf("ignored message %s (sent to unknown peer %s)", m.Type, to)
}
} Transport.SendSnapshot()方法负责发送指定的snap.Message 消息（其中封装了对应的MsgSnap消息实例及其他相关信息〉。该方法是通过调用peer.sendSnap（）方法完成的。
2、 Peer接口
type Peer interface {
//发送单个消息， 该方法是非阻塞的，如采出现发送失败，则会将失败信息报告给底层的Raft接口
send(m raftpb.Message)
//发送snap.Message，其他行为与上面的send（）方法类似
sendSnap(m snap.Message)
update(urls types.URLs)
attachOutgoingConn(conn *outgoingConn)
activeSince() time.Time
stop()
}
rafhttp.peer是Peer接口的具体实现，其中各字段的含义如下
id ( types.ID类型）：该peer实例对应的节点的ID。
r ( Raft类型）： Raft接口，在Raft接口实现的底层封装了etcd-raft模块。
picker ( *urlPicker类型）：每个节点可能提供了多个URL供其他节点访问， 当其中一个访问失败时，我们应该可以尝试访问另一个。 而urlPicker提供的主要功能就是在这些URL之间进行切换。
writer ( *streamWrite「类型）： 负责向Stream消息通道写入消息。
msgAppReader ( *streamReader类型）： 负责从Stream消息通道读取消息。
pipeline ( *pipeline类型）：Pipeline消息通道。
snapSender ( *snapshotSende「类型）： 负责发送快照数据。
recvc ( ehan raftpb.Message类型）：从Stream消息通道中读取到消息之后， 会通过该通道将消息交给Raft接口，然后由它返回给底层etcd-raft模块进行处理。
Prope( ehan raftpb. Message类型）：从Stream消息通道中读取到MsgProp类型的消息之后，会通过该通道将MsgProp消息交给Raft接口，然后由它返回给底层etcd-raft模块进行处理。
paused ( bool类型）：是否暂停向对应节点发送消息。
在rafthttp.peer.startPeer（）方法中完成了初始化上述字段的工作，同时也启动了关联的后台goroutine。该方法的具体实现如下
func startPeer(transport *Transport, urls types.URLs, peerID types.ID, fs *stats.FollowerStats) *peer {
plog.Infof("starting peer %s...", peerID)
defer plog.Infof("started peer %s", peerID)
status := newPeerStatus(peerID)
picker := newURLPicker(urls)
errorc := transport.ErrorC
r := transport.Raft
pipeline := &pipeline{//创建pipeine实例
peerID: peerID,
tr: transport,
picker: picker,
status: status,
followerStats: fs,
raft: r,
errorc: errorc,
}
pipeline.start()//启动pipeline
//创建Peer实例
p := &peer{
id: peerID,
r: r,
status: status,
picker: picker,
msgAppV2Writer: startStreamWriter(peerID, status, fs, r),
writer: startStreamWriter(peerID, status, fs, r),//创建并启动streamWriter
pipeline: pipeline,
snapSender: newSnapshotSender(transport, picker, peerID, status),
recvc: make(chan raftpb.Message, recvBufSize),//创建recvc远远，注意缓冲区大小
propc: make(chan raftpb.Message, maxPendingProposals),//创建propc通道，注意缓冲区大小
stopc: make(chan struct{}),
}
ctx, cancel := context.WithCancel(context.Background())
p.cancel = cancel
//启动单独的goroutine，它主妾负责将recvc通道中读取消息，该通道中的消息就是从对端节点发送过来的消息，然后将读取到的消息交给底层的Raft状态机进行处理
go func() {
for {
select {
case mm := <-p.recvc://从recvc远远中获取连接上读取到的Message,将Message交给底层Raft状态机处理
if err := r.Process(ctx, mm); err != nil {
plog.Warningf("failed to process raft message (%v)", err)
}
case <-p.stopc:
return
}
}
}()
//在底层Raft状态机处理MsgProp类型的Message时，可能会阻塞，所以启动单独的goroutine来处理
go func() {
for {
select {
case mm := <-p.propc://从propc通道中获取MsgProp类型的Message,将Message交给底层Raft状态机处理
if err := r.Process(ctx, mm); err != nil {
plog.Warningf("failed to process raft message (%v)", err)
}
case <-p.stopc:
return
}
}
}()
p.msgAppV2Reader = &streamReader{
peerID: peerID,
typ: streamTypeMsgAppV2,
tr: transport,
picker: picker,
status: status,
recvc: p.recvc,
propc: p.propc,
rl: rate.NewLimiter(transport.DialRetryFrequency, 1),
}
//创建并启动streamReader实例， 它主要负责从Stream消息遥远上读取消息
p.msgAppReader = &streamReader{
peerID: peerID,
typ: streamTypeMessage,
tr: transport,
picker: picker,
status: status,
recvc: p.recvc,
propc: p.propc,
rl: rate.NewLimiter(transport.DialRetryFrequency, 1),
}
p.msgAppV2Reader.start()
p.msgAppReader.start()
return p
}看看peer核心方法。首先是peer.send（）方法，前面分析的Transport.Send（）方法就是通过调用该方法实现消息发送功能的
func (p *peer) send(m raftpb.Message) {
p.mu.Lock()
paused := p.paused
p.mu.Unlock()
if paused {
return
}
//根据消息的类型选择合适的消息通道，peer.pick （）方法下面会详细介绍
writec, name := p.pick(m)
select {
case writec <- m://将Message写入writec通道中，发送
default:
p.r.ReportUnreachable(m.To)
if isMsgSnap(m) {
p.r.ReportSnapshot(m.To, raft.SnapshotFailure)
}
if p.status.isActive() {
plog.MergeWarningf("dropped internal raft message to %s since %s's sending buffer is full (bad/overloaded network)", p.id, name)
}
plog.Debugf("dropped %s to %s since %s's sending buffer is full", m.Type, p.id, name)
sentFailures.WithLabelValues(types.ID(m.To).String()).Inc()
}
}在peer.pick（）方法中，会根据消息的类型选择合适的消息通道并返回相应的通道供send()方法写入待发迭的消息，具体实现如下
func (p *peer) pick(m raftpb.Message) (writec chan<- raftpb.Message, picked string) {
var ok bool
//如果是MsgSnap类型的消息， 返回Pipeline消息通道对应的Channel，否则返回Stream消息通道对应的Channel，如果Stream消息通道不可用，则使用Pipeline消息通道发送所有类型的消息
if isMsgSnap(m) {
return p.pipeline.msgc, pipelineMsg
} else if writec, ok = p.msgAppV2Writer.writec(); ok && isMsgApp(m) {
return writec, streamAppV2
} else if writec, ok = p.writer.writec(); ok {
return writec, streamMsg
}
return p.pipeline.msgc, pipelineMsg
}3、streamWriter
在peer.start()方法中会创建并启动了一个sreamWriter实例。从命名上可以猜出其主要功能就是向Stream 消息通道写入消息在peer.start（）方法中是通过调用startStreamWriter（）方法初始化并启动streamWriter 实例的，其中还启动了一个后台goroutine来执行streamWriter.run（）方法。在streamWriter.run() 方法中，主要完成了下面三件事情：
(1)当其他节点主动与当前节点创建连接（即Stream消息通道底层使用的网络连接〉时，该连接实例会写入对应peer.writer.connc通道， 在streamWriter.run（）方法中会通过该通道获取该连接实例井进行绑定，之后才能开始后续的消息发送。
(2)定时发送心跳消息，该心跳消息并不是前面介绍raft模块时提到的MsgHeatbeat消息，而是为了防止底层连接超时的消息。
(3)发送除心跳消息外的其他类型的消息。
func (cw *streamWriter) run() {
var (
msgc chan raftpb.Message //指向当前streamWriter. msgc字段
heartbeatc <-chan time.Time //定时器会定时向该通道发送信号， 触发心跳消息的发送，该心跳消息与后面介绍的Raft的心跳消息有所不同，该心跳消息的主要目的是为了防止连接长时间不用断升的
t streamType //用来记录消息的版本信息
enc encoder //编码器，负责将消息序列化并写入连接的缓冲区
flusher http.Flusher //负责刷新底层连接，将数据真正发送出去
batched int //当前未Flush的消息个数
)
tickc := time.NewTicker(ConnReadTimeout / 3)//发送心跳消息的定时器
defer tickc.Stop()
unflushed := 0
plog.Infof("started streaming with peer %s (writer)", cw.peerID)
for {
select {
case <-heartbeatc: //定时器到期， 触发心跳消息
err := enc.encode(&linkHeartbeatMessage)
unflushed += linkHeartbeatMessage.Size()
if err == nil {
flusher.Flush()
batched = 0
sentBytes.WithLabelValues(cw.peerID.String()).Add(float64(unflushed))
unflushed = 0
continue
}
cw.status.deactivate(failureType{source: t.String(), action: "heartbeat"}, err.Error())
sentFailures.WithLabelValues(cw.peerID.String()).Inc()
cw.close()
plog.Warningf("lost the TCP streaming connection with peer %s (%s writer)", cw.peerID, t)
//将heartbeatc和msgc两个通道清空，后续就不会再发送心跳消息和其他类型的消息了
heartbeatc, msgc = nil, nil
case m := <-msgc:
//peer向streamWriter.msgc写入待发送的消息
err := enc.encode(&m)//将消息序列化并写入底层连接
if err == nil {
unflushed += m.Size()
if len(msgc) == 0 || batched > streamBufSize/2 {//msgc通道中的消息全部发送完成或是未Flush的消息较多，则触发Flush,否则只是递增batched变量
flusher.Flush()
sentBytes.WithLabelValues(cw.peerID.String()).Add(float64(unflushed))
unflushed = 0
batched = 0
} else {
batched++
}
continue
}
cw.status.deactivate(failureType{source: t.String(), action: "write"}, err.Error())
cw.close()
plog.Warningf("lost the TCP streaming connection with peer %s (%s writer)", cw.peerID, t)
heartbeatc, msgc = nil, nil
cw.r.ReportUnreachable(m.To)
sentFailures.WithLabelValues(cw.peerID.String()).Inc()
case conn := <-cw.connc:
//获取与当前streamWriter实例绑定的底层连接
//当其他节点主动与当前节点创建Stream消息通道时，会先通过StreamHandler的处理，
//StreamHandler会通过attach（）方法将连接写入对应peer.writer.connc通道，
//而当前的goroutine会通过该通道获取连接，然后开始发送消息
cw.mu.Lock()
closed := cw.closeUnlocked()
t = conn.t
switch conn.t {
case streamTypeMsgAppV2:
enc = newMsgAppV2Encoder(conn.Writer, cw.fs)
case streamTypeMessage:
//将http.ResponseWriter封装成messageEncoder，上层调用通过messageEncoder实例完成消息发送
enc = &messageEncoder{w: conn.Writer}
default:
plog.Panicf("unhandled stream type %s", conn.t)
}
flusher = conn.Flusher //记录底层连接对应的Flusher
unflushed = 0
cw.status.activate() //peerStatus.activeit直为true
cw.closer = conn.Closer //记录底层连接对应的Flusher
cw.working = true //标识当前streamWriter正在运行
cw.mu.Unlock()
if closed {
plog.Warningf("closed an existing TCP streaming connection with peer %s (%s writer)", cw.peerID, t)
}
plog.Infof("established a TCP streaming connection with peer %s (%s writer)", cw.peerID, t)
heartbeatc, msgc = tickc.C, cw.msgc //更新heartbeatc和msgc两个远远，自此之后，才能发送消息
case <-cw.stopc:
if cw.close() {
plog.Infof("closed the TCP streaming connection with peer %s (%s writer)", cw.peerID, t)
}
plog.Infof("stopped streaming with peer %s (writer)", cw.peerID)
close(cw.done)
return
}
}
}stream Writer中另一个需要读者了解的方法是attach（）方法，该方法会接收outgoingConn实例井写入streamWriter.connc通道中，peer.attachOutgoingConn（）方法就是通过调用该方法实现的。在后面介绍的streamHandler中，也就是通过调用peer.attachOutgoingConn（）方法将底层网络连接传递到streamWriter中的。 streamWriter.attach（）方法和peer.attachOutgoingConn（）方法的具体实现如下:
func (p *peer) attachOutgoingConn(conn *outgoingConn) {
var ok bool
switch conn.t {
case streamTypeMsgAppV2:
ok = p.msgAppV2Writer.attach(conn)
case streamTypeMessage://这里只关注最新版本的实现，将conn实例交给streamWriter处理
ok = p.writer.attach(conn)
default:
plog.Panicf("unhandled stream type %s", conn.t)
}
if !ok {
conn.Close()
}
}
func (cw *streamWriter) attach(conn *outgoingConn) bool {
select {
case cw.connc <- conn://将conn实例写入strearnWriter.connc通过中
return true
case <-cw.done:
return false
}
}4、streamReader
在peer.start（）方法中，除了创建前面介绍的steamWriter，还创建井启动了一个sreamReader实例。 从该结构体的命名和前面对streamWriter 的介绍， 可以猜出其主要功能是从Stream通道中读取消息
peerlD (types. ID类型）：对应节点的ID。
typ ( streamType类型）：关联的底层连接使用的协议版本信息。
tr （寸「anspo同类型）： 关联的rafthttp.Transport实例。
picker ( *urlPicker类型）：用于获取对端节点的可用的URL。
recvc ( ehan<- Message 类型）：在前面介绍的peer.startPeer（）方法中提到， 创建streamReader 实例时是使用peer.recvc 通道初始化该宇段的，其中还会启动一个后台goroutine 从peer.recvc 通道中读取消息。在下面分析中会看到，从对端节点发送来的非MsgProp类型的消息会首先由streamReader 写入recvc通道中， 然后由peer.start()启动的后台goroutine读取出来， 交由底层的raft模块进行处理。
prope ( ehan<-raftpb.Message类型）：该通道与上面介绍的recvc通道类似，只不过其中接收的是MsgProp类型的消息。
paused ( bool类型）：是否暂停读取数据。
在streamReader.start（）方法中会启动一个单独的后台goroutine来执行streamReader.run（）方法，与streamWriter类似，它也是streamReader的核心。
func (cr *streamReader) run() {
t := cr.typ
plog.Infof("started streaming with peer %s (%s reader)", cr.peerID, t)
for {
rc, err := cr.dial(t)//向对端节点发送一个GET请求， 主要负责与对端节点建立连接
if err != nil {
if err != errUnsupportedStreamType {
cr.status.deactivate(failureType{source: t.String(), action: "dial"}, err.Error())
}
} else {
cr.status.activate()
plog.Infof("established a TCP streaming connection with peer %s (%s reader)", cr.peerID, cr.typ)
err = cr.decodeLoop(rc, t)//如采未出现异常，则开始读取对端返回的消息，并将读取到的消息写入streamReader.recvc中
plog.Warningf("lost the TCP streaming connection with peer %s (%s reader)", cr.peerID, cr.typ)
switch {
// all data is read out
case err == io.EOF:
// connection is closed by the remote
case transport.IsClosedConnError(err):
default:
cr.status.deactivate(failureType{source: t.String(), action: "read"}, err.Error())
}
}
// Wait for a while before new dial attempt
err = cr.rl.Wait(cr.ctx)
if cr.ctx.Err() != nil {
plog.Infof("stopped streaming with peer %s (%s reader)", cr.peerID, t)
close(cr.done)
return
}
if err != nil {
plog.Errorf("streaming with peer %s (%s reader) rate limiter error: %v", cr.peerID, t, err)
}
}
}
//decodeLoop（）方法是streamReader中的核心方法，它会从底层的网络连接读取数据并进行反序列化， 之后将得到的消息实例写入recvc通道（或prope通道）中， 等待Peer进行处理， 其具体实现如下：
func (cr *streamReader) decodeLoop(rc io.ReadCloser, t streamType) error {
var dec decoder
cr.mu.Lock()
switch t {
case streamTypeMsgAppV2:
dec = newMsgAppV2Decoder(rc, cr.tr.ID, cr.peerID)
case streamTypeMessage:
dec = &messageDecoder{r: rc}//messageDeeoder主要负责从连接中读取数据
default:
plog.Panicf("unhandled stream type %s", t)
}
select {
case <-cr.ctx.Done():
cr.mu.Unlock()
if err := rc.Close(); err != nil {
return err
}
return io.EOF
default:
cr.closer = rc
}
cr.mu.Unlock()
for {
m, err := dec.decode()//从底层连接中读取数据，并反序列化成raftpb.Message实例
if err != nil {
cr.mu.Lock()
cr.close()
cr.mu.Unlock()
return err
}
receivedBytes.WithLabelValues(types.ID(m.From).String()).Add(float64(m.Size()))
cr.mu.Lock()
paused := cr.paused
cr.mu.Unlock()
if paused {
continue
}
if isLinkHeartbeatMessage(&m) {
// raft is not interested in link layer
// heartbeat message, so we should ignore
// it.
continue
}
//根据读取到的消息类型，选择对应通道进行写入
recvc := cr.recvc
if m.Type == raftpb.MsgProp {
recvc = cr.propc
}
select {
case recvc <- m://将消息写入对应的远远中，之后会交给底层的Raft状态机进行处理
default: //recvc通过满了之后，只能丢弃消息，并打印日志（
if cr.status.isActive() {
plog.MergeWarningf("dropped internal raft message from %s since receiving buffer is full (overloaded network)", types.ID(m.From))
}
plog.Debugf("dropped %s from %s since receiving buffer is full", m.Type, types.ID(m.From))
recvFailures.WithLabelValues(types.ID(m.From).String()).Inc()
}
}
}5、pipelineHandler实例
在前面介绍的ra的ttp.Transport.Handler（）方法中， 会创建多个Handler实例并与指定的URL路径关联，我们重点关注其中的pipelineHandler和streamHandler两个Handler的具体实现
在前面分析的pipeline.handle（）方法和pipeline.post（）方法中，我们只看到了创建连接和发送请求的逻辑，这里介绍在对端节点的pipelineHandler 中是如何读取快照消息的。下面先来看一下pipelineHandler中各个字段的含义。
tr ( Transporter类型）： 当前pipeline实例关联的rafthttp.Transport实例。
r ( Raft类型）： 底层的Raft实例。
cid (types.ID类型）： 当前集群的ID。
正如前面介绍的那样， 在pipelineHandler中实现了http.Server.Handler接口的ServeHTTP()方法，也是其处理请求的核心方法。pipelineHandler.ServerHTTP（）方法通过读取对端节点发来的请求得到相应的消息实例， 然后将其交给底层的raft模块进行处理， 该方法的具体大致实现如下：
正如前面介绍的那样， 在pipelineHandler中实现了http.Server.Handler接口的ServeHTTP()方法，也是其处理请求的核心方法。pipelineHandler.ServerHTTP（）方法通过读取对端节点发来的请求得到相应的消息实例， 然后将其交给底层的raft模块进行处理， 该方法的具体大致实现如下：
func (h *pipelineHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
//首先进行一系列的检查，例如· 检查请求的Method是否为POST， 检测集群ID是否合法，等等（
if r.Method != "POST" {
w.Header().Set("Allow", "POST")
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
return
}
w.Header().Set("X-Etcd-Cluster-ID", h.cid.String())
if err := checkClusterCompatibilityFromHeader(r.Header, h.cid); err != nil {
http.Error(w, err.Error(), http.StatusPreconditionFailed)
return
}
addRemoteFromRequest(h.tr, r)
//限制每次从底层连接读取的字节数上线，默认是64KB，因为快照数据可能非常大，为了防止读取超时，
//只能每次读取一部分数据到缓冲区中，最后将全部数据拼接起来，得到完整的快照数据
limitedr := pioutil.NewLimitedBufferReader(r.Body, connReadLimitByte)
b, err := ioutil.ReadAll(limitedr)//读取HTTP请求的Body的全部内容
if err != nil {
plog.Errorf("failed to read raft message (%v)", err)
http.Error(w, "error reading raft message", http.StatusBadRequest)
recvFailures.WithLabelValues(r.RemoteAddr).Inc()
return
}
//反序列化得到raftpb.Message实例
var m raftpb.Message
if err := m.Unmarshal(b); err != nil {
plog.Errorf("failed to unmarshal raft message (%v)", err)
http.Error(w, "error unmarshaling raft message", http.StatusBadRequest)
recvFailures.WithLabelValues(r.RemoteAddr).Inc()
return
}
receivedBytes.WithLabelValues(types.ID(m.From).String()).Add(float64(len(b)))
//将读取到的消息实例交给成层的Raft状态机进行处理，
if err := h.r.Process(context.TODO(), m); err != nil {
switch v := err.(type) {
case writerToResponse:
v.WriteTo(w)
default:
plog.Warningf("failed to process raft message (%v)", err)
http.Error(w, "error processing raft message", http.StatusInternalServerError)
w.(http.Flusher).Flush()
// disconnect the http stream
panic(err)
}
return
}
// Write StatusNoContent header after the message has been processed by
// raft, which facilitates the client to report MsgSnap status.
w.WriteHeader(http.StatusNoContent)//向对端节点返回合适的状态码， 表示请求已经被处理
}在前面分析streamWriter 时介绍了向对端消息发送的基本逻辑，在分析streamReader时，我们大致了解了建立连接和读取对端消息的过程。这里主要介绍streamHandler， 它主要负责在接收到对端的网络连接之后，将其与对应的streamWriter实例进行关联。这样， streamWriter 就可以开始向对端节点发送消息了。下面来分析streamHandler中各个字段的含义。
tr ( *Transp。同类型）： 关联的rafthttp.Transport实例。
peerGetter ( peerGetter类型）：peerGetter接口中的Get()方法会根据指定的节点ID获取对应的peer实例。
r ( Raft类型）：底层的Raft实例。
id ( types.ID类型）： 当前节点的ID。
cid (types.ID类型）： 当前集群的ID
6、streamHandler
在前面分析streamWriter 时介绍了向对端消息发送的基本逻辑，在分析streamReader时，我们大致了解了建立连接和读取对端消息的过程。这里主要介绍streamHandler， 它主要负责在接收到对端的网络连接之后，将其与对应的streamWriter实例进行关联。这样， streamWriter 就可以开始向对端节点发送消息了。下面来分析streamHandler中各个字段的含义。
tr ( *Transp。同类型）： 关联的rafthttp.Transport实例。
peerGetter ( peerGetter类型）：peerGetter接口中的Get()方法会根据指定的节点ID获取对应的peer实例。
r ( Raft类型）：底层的Raft实例。
id ( types.ID类型）： 当前节点的ID。
cid (types.ID类型）： 当前集群的ID。
//streamHandler的核心也是ServeHTTP（）方法
func (h *streamHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
//检测请求Method是否为GET，检测集群的ID
if r.Method != "GET" {
w.Header().Set("Allow", "GET")
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
return
}
w.Header().Set("X-Server-Version", version.Version)
w.Header().Set("X-Etcd-Cluster-ID", h.cid.String())
if err := checkClusterCompatibilityFromHeader(r.Header, h.cid); err != nil {
http.Error(w, err.Error(), http.StatusPreconditionFailed)
return
}
var t streamType
switch path.Dir(r.URL.Path) {//确定使用的协议版
case streamTypeMsgAppV2.endpoint():
t = streamTypeMsgAppV2
case streamTypeMessage.endpoint():
t = streamTypeMessage
default:
plog.Debugf("ignored unexpected streaming request path %s", r.URL.Path)
http.Error(w, "invalid path", http.StatusNotFound)
return
}
fromStr := path.Base(r.URL.Path)//获取对揣节点的ID，异常处理
from, err := types.IDFromString(fromStr)
if err != nil {
plog.Errorf("failed to parse from %s into ID (%v)", fromStr, err)
http.Error(w, "invalid from", http.StatusNotFound)
return
}
if h.r.IsIDRemoved(uint64(from)) {
plog.Warningf("rejected the stream from peer %s since it was removed", from)
http.Error(w, "removed member", http.StatusGone)
return
}
p := h.peerGetter.Get(from)//根据对端节点ID获取对应的Peer实例
if p == nil {
if urls := r.Header.Get("X-PeerURLs"); urls != "" {
h.tr.AddRemote(from, strings.Split(urls, ","))
}
plog.Errorf("failed to find member %s in cluster %s", from, h.cid)
http.Error(w, "error sender not found", http.StatusNotFound)
return
}
wto := h.id.String()//获取当前节点的ID
if gto := r.Header.Get("X-Raft-To"); gto != wto {
plog.Errorf("streaming request ignored (ID mismatch got %s want %s)", gto, wto)
http.Error(w, "to field mismatch", http.StatusPreconditionFailed)
return
}
w.WriteHeader(http.StatusOK)//返回200状态码
w.(http.Flusher).Flush()//调用Flush（）方法将响应数据发送到对端节点
c := newCloseNotifier()
conn := &outgoingConn{ //创建outgoingConn实例
t: t,
Writer: w,
Flusher: w.(http.Flusher),
Closer: c,
}
//将outgoingConn实例与对应的streamWriter实例绑定，peer.attachOutgoingConn （）方法在前面attach部分已经介绍过
p.attachOutgoingConn(conn)
<-c.closeNotify()
}