配置文件

etcd配置文件位于/etc/etcd/etcd.conf,该配置文件一共有5个section

具体配置采集可以见另一个文章《Etcd集群配置和使用》

初次看到配置文件，都会有一个疑问，为什么在members已经设置了监听服务地址，为什么在cluster还要再次设置一次广播地址呢？

原因：etcd主要的通信协议主要是http协议，对于http协议中所周知它是B/S结构，而非C/S结构，只能一端主动给另一端发消息而反过来则不可。所以对于集群来说，双方必须都要知道对方具体监听地址。

服务监听

我们都知道，建立socket服务端一共有5个基本步骤（C语言）：
1、创建socket套接字
2、bind地址及端口
3、listen监听服务4
4、accept接收客户端连接
5、启动新线程为客户端服务。
正所谓万变不离其宗，到了etcd中（etcd使用默认golang http模块）也是这些步骤，只不过是被封装了一下（语法糖）

启动流程见《Etcd源码分析：启动篇》

listener

当进入embed/etcd.go里面的StartEtcd()函数的时候

      //为peer创建listener，socket三部曲只到了第二个步骤
    if e.Peers, err = startPeerListeners(cfg); err != nil {
        return e, err
    }
      //为client创建listener，socket三部曲只到了第二个步骤
    if e.sctxs, err = startClientListeners(cfg); err != nil {
        return e, err
    }

在创建了listener之后，开始创建EtcdServer

      //创建EtcdServer并且创建raftNode并运行raftNode
    if e.Server, err = etcdserver.NewServer(srvcfg); err != nil {
        return e, err
    }

    // buffer channel so goroutines on closed connections won't wait forever
    e.errc = make(chan error, len(e.Peers)+len(e.Clients)+2*len(e.sctxs))

······
    e.Server.Start()

    if err = e.servePeers(); err != nil {
        return e, err
    }
    if err = e.serveClients(); err != nil {
        return e, err
    }
    if err = e.serveMetrics(); err != nil {
        return e, err
    }

    serving = true

Listener有两个分别为：peer listener和client listener，两者大同小异，这里拿peer listener做为分析对象。

func startPeerListeners(cfg *Config) (peers []*peerListener, err error) {
······
    peers = make([]*peerListener, len(cfg.LPUrls))
······
    for i, u := range cfg.LPUrls {   //循环遍历多个peer url
        if u.Scheme == "http" {
            if !cfg.PeerTLSInfo.Empty() {
                plog.Warningf("The scheme of peer url %s is HTTP while peer key/cert files are presented. Ignored peer key/cert files.", u.String())
            }
            if cfg.PeerTLSInfo.ClientCertAuth {
                plog.Warningf("The scheme of peer url %s is HTTP while client cert auth (--peer-client-cert-auth) is enabled. Ignored client cert auth for this url.", u.String())
            }
        }
        // 构造peerListener对象 监听2380 作为服务端模式
        peers[i] = &peerListener{close: func(context.Context) error { return nil }}
        
        //调用接口，创建listener对象，返回来之后，socket套接字已经完成listener监听流程
        peers[i].Listener, err = rafthttp.NewListener(u, &cfg.PeerTLSInfo)
        if err != nil {
            return nil, err
        }
        // once serve, overwrite with 'http.Server.Shutdown'
        peers[i].close = func(context.Context) error {
            return peers[i].Listener.Close()
        }
        plog.Info("listening for peers on ", u.String())
    }
    return peers, nil
}

下面调用关系为

startPeerListeners()  [embed/etcd.go]  
-> rafthttp.NewListener()  [rafthttp/util.go]
    -> transport.NewTimeoutListener()  [pkg/transport/timeout_listener.go]
        -> newListener()  [pkg/transport/listener.go]
            -> net.Listen()  [golang net库函数]

服务监听

服务端socket需要调用Accept方法，我们来看一下serve方法。方法serve大致内容为：将每个服务放到gorouting中，也就是启动一个协程来监听服务。

先看看servePeers()

func (e *Etcd) servePeers() (err error) {
    ph := etcdhttp.NewPeerHandler(e.Server)
    var peerTLScfg *tls.Config
    if !e.cfg.PeerTLSInfo.Empty() {
        if peerTLScfg, err = e.cfg.PeerTLSInfo.ServerConfig(); err != nil {
            return err
        }
    }

    for _, p := range e.Peers {
        gs := v3rpc.Server(e.Server, peerTLScfg)
        m := cmux.New(p.Listener)
        go gs.Serve(m.Match(cmux.HTTP2()))
        srv := &http.Server{
            Handler:     grpcHandlerFunc(gs, ph),
            ReadTimeout: 5 * time.Minute,
            ErrorLog:    defaultLog.New(ioutil.Discard, "", 0), // do not log user error
        }
        go srv.Serve(m.Match(cmux.Any()))
        p.serve = func() error { return m.Serve() }
        p.close = func(ctx context.Context) error {
            // gracefully shutdown http.Server
            // close open listeners, idle connections
            // until context cancel or time-out
            stopServers(ctx, &servers{secure: peerTLScfg != nil, grpc: gs, http: srv})
            return nil
        }
    }

    // start peer servers in a goroutine
    for _, pl := range e.Peers {
        go func(l *peerListener) {
            e.errHandler(l.serve())
        }(pl)
    }
    return nil
}

1、生成http.hander 用于处理peer请求；
2、在for循环里面，起一些goroutine，调用Server()函数来接受Listener传入的连接。

我们来看看NewPeerHandler()

func newPeerHandler(cluster api.Cluster, raftHandler http.Handler, leaseHandler http.Handler) http.Handler {
    mh := &peerMembersHandler{
        cluster: cluster,
    }

 //将url和业务层handler注册到servemux中，也就是每一个url请求都会有其对应的handler进行处理
     //初始化一个Serve Multiplexer结构
      mux := http.NewServeMux()
    mux.HandleFunc("/", http.NotFound)
    mux.Handle(rafthttp.RaftPrefix, raftHandler)
    mux.Handle(rafthttp.RaftPrefix+"/", raftHandler) 
    mux.Handle(peerMembersPrefix, mh)  //处理请求/members handler是mh，即peerMembersHandler
    if leaseHandler != nil {
        mux.Handle(leasehttp.LeasePrefix, leaseHandler)
        mux.Handle(leasehttp.LeaseInternalPrefix, leaseHandler)
    }
    mux.HandleFunc(versionPath, versionHandler(cluster, serveVersion))
    return mux
}

应用层业务逻辑需要自己注册url和handler，这样才能保证每个http request都能够被处理。而每个handler都必须要实现对应接口ServeHTTP，例如peerMembersHandler，实现的ServeHTTP接口是用于返回集群成员列表

那么此处只是完成注册，那么在什么地方会调用此处handler？

答案是在ServeHTTP()里面