以太坊源码之--P2P网络源码剖析（1）

ethereum-p2p代码分析（v1.8.24）

本篇主要按p2p的主要逻辑进行代码分析

1、开始分析主要代码

1.1 server.Start()

// Start starts running the server.
// Servers can not be re-used after stopping.
func (srv *Server) Start() (err error) {
	srv.lock.Lock()
	defer srv.lock.Unlock()
	if srv.running {
		return errors.New("server already running")
	}
	srv.running = true
	srv.log = srv.Config.Logger
	if srv.log == nil {
		srv.log = log.New()
	}
	if srv.NoDial && srv.ListenAddr == "" {
		srv.log.Warn("P2P server will be useless, neither dialing nor listening")
	}

	// static fields
	if srv.PrivateKey == nil {
		return errors.New("Server.PrivateKey must be set to a non-nil key")
	}
	if srv.newTransport == nil {
		srv.newTransport = newRLPX
	}
	if srv.Dialer == nil {
		srv.Dialer = TCPDialer{&net.Dialer{Timeout: defaultDialTimeout}}
	}
	srv.quit = make(chan struct{}) // 退出通道
	srv.addpeer = make(chan *conn) // 添加底层peer
	srv.delpeer = make(chan peerDrop) //删除peer
	srv.posthandshake = make(chan *conn) // 推送握手
	srv.addstatic = make(chan *enode.Node) //添加静态节点
	srv.removestatic = make(chan *enode.Node) //移除静态节点
	srv.addtrusted = make(chan *enode.Node) //添加信任节点
	srv.removetrusted = make(chan *enode.Node)
	srv.peerOp = make(chan peerOpFunc) //对peer做操作
	srv.peerOpDone = make(chan struct{}) // 操作完成通知通道
	// 开始创建一个本地节点
	if err := srv.setupLocalNode(); err != nil {
		return err
	}

	//-------------------------------------------------
	// 此部分进行接收内部连接   有一个新的连接来的时候与其握手后建立连接
	if srv.ListenAddr != "" {
		if err := srv.setupListening(); err != nil {
			return err
		}
	}
	//-------------------------------------------------

	//--------------------------------------------------
	//开启节点发现机制  主要用了udp和 table
	if err := srv.setupDiscovery(); err != nil {
		return err
	}
	//--------------------------------------------------

	dynPeers := srv.maxDialedConns()
	dialer := newDialState(srv.localnode.ID(), srv.StaticNodes, srv.BootstrapNodes, srv.ntab, dynPeers, srv.NetRestrict)
	srv.loopWG.Add(1)
	// 处理各个通道发来的数据  并定时跑任务 主要使用了dail.go
	go srv.run(dialer)
	return nil
}

上面是server启动时候的代码，主要做了如下几件事：

• 对server的相关变量进行初始化
• 创建本地节点
• 开启server的tcp连接服务
• 如果开启节点发现机制，那么开启节点发现机制
• 最后单独起一个协程将server的主循环运行

1.2 srv.setupLocalNode()

func (srv *Server) setupLocalNode() error {
	// Create the devp2p handshake.
    // 根据分配给服务端的私钥恢复出公钥
	pubkey := crypto.FromECDSAPub(&srv.PrivateKey.PublicKey)
    // 握手结构体初始化
	srv.ourHandshake = &protoHandshake{Version: baseProtocolVersion, Name: srv.Name, ID: pubkey[1:]}
    // 将server中支持的协议放入握手协议储存室中
	for _, p := range srv.Protocols {
		srv.ourHandshake.Caps = append(srv.ourHandshake.Caps, p.cap())
	}
    // 对协议进行排序
	sort.Sort(capsByNameAndVersion(srv.ourHandshake.Caps))
	// 创建本地数据存储目录
	// Create the local node.
	db, err := enode.OpenDB(srv.Config.NodeDatabase)
	if err != nil {
		return err
	}
	srv.nodedb = db
     // 给server.localnode填充相关属性
	srv.localnode = enode.NewLocalNode(db, srv.PrivateKey)
	srv.localnode.SetFallbackIP(net.IP{127, 0, 0, 1})
	srv.localnode.Set(capsByNameAndVersion(srv.ourHandshake.Caps))
	// TODO: check conflicts
	for _, p := range srv.Protocols {
		for _, e := range p.Attributes {
			srv.localnode.Set(e)
		}
	}
	switch srv.NAT.(type) {
	case nil:
		// No NAT interface, do nothing.
	case nat.ExtIP:
		// ExtIP doesn't block, set the IP right away.
		ip, _ := srv.NAT.ExternalIP()
		srv.localnode.SetStaticIP(ip)
	default:
		// Ask the router about the IP. This takes a while and blocks startup,
		// do it in the background.
		srv.loopWG.Add(1)
		go func() {
			defer srv.loopWG.Done()
			if ip, err := srv.NAT.ExternalIP(); err == nil {
				srv.localnode.SetStaticIP(ip)
			}
		}()
	}
	return nil
}

以上主要是p2p.server将本地节点的属性做了额外记录，方便以后处理

1.3 srv.setupListening()

func (srv *Server) setupListening() error {
	// Launch the TCP listener.
    // 开启tcp端口
	listener, err := net.Listen("tcp", srv.ListenAddr)
	if err != nil {
		return err
	}
	laddr := listener.Addr().(*net.TCPAddr)
	srv.ListenAddr = laddr.String()
	srv.listener = listener
	srv.localnode.Set(enr.TCP(laddr.Port))

	srv.loopWG.Add(1)
    // 开启主循环
	go srv.listenLoop()

	// Map the TCP listening port if NAT is configured.
	if !laddr.IP.IsLoopback() && srv.NAT != nil {
		srv.loopWG.Add(1)
		go func() {
			nat.Map(srv.NAT, srv.quit, "tcp", laddr.Port, laddr.Port, "ethereum p2p")
			srv.loopWG.Done()
		}()
	}
	return nil
}

// listenLoop runs in its own goroutine and accepts
// inbound connections.
func (srv *Server) listenLoop() {
	defer srv.loopWG.Done()
	srv.log.Debug("TCP listener up", "addr", srv.listener.Addr())
	//defaultMaxPendingPeers = 50  可以配置
	tokens := defaultMaxPendingPeers
	if srv.MaxPendingPeers > 0 {
		tokens = srv.MaxPendingPeers
	}
	// 先申请槽位 go语言里面struct{} 占用width为0
    // slots主要用来控制循环次数
	slots := make(chan struct{}, tokens)
	for i := 0; i < tokens; i++ {
		slots <- struct{}{}
	}

	for {
		// Wait for a handshake slot before accepting.
		<-slots

		var (
			fd  net.Conn
			err error
		)
		for {
             // 处理外部连接
			fd, err = srv.listener.Accept()
			if netutil.IsTemporaryError(err) {
				srv.log.Debug("Temporary read error", "err", err)
				continue
			} else if err != nil {
				srv.log.Debug("Read error", "err", err)
				return
			}
			break
		}
		// 如果节点开启了白名单验证，那么不在白名单列表的将直接被拒绝
		// Reject connections that do not match NetRestrict.
		if srv.NetRestrict != nil {
			if tcp, ok := fd.RemoteAddr().(*net.TCPAddr); ok && !srv.NetRestrict.Contains(tcp.IP) {
				srv.log.Debug("Rejected conn (not whitelisted in NetRestrict)", "addr", fd.RemoteAddr())
				fd.Close()
				slots <- struct{}{}
				continue
			}
		}

		var ip net.IP
		if tcp, ok := fd.RemoteAddr().(*net.TCPAddr); ok {
			ip = tcp.IP
		}
		//监控需求
		fd = newMeteredConn(fd, true, ip)
		srv.log.Trace("Accepted connection", "addr", fd.RemoteAddr())
		go func() {
			// 进行握手  后 将节点作为inboundConn类型添加为自己的peer
			srv.SetupConn(fd, inboundConn, nil)
			slots <- struct{}{}
		}()
	}
}

// SetupConn runs the handshakes and attempts to add the connection
// as a peer. It returns when the connection has been added as a peer
// or the handshakes have failed.
func (srv *Server) SetupConn(fd net.Conn, flags connFlag, dialDest *enode.Node) error {
    // 将要连接的节点包装为一个conn结构体
	c := &conn{fd: fd, transport: srv.newTransport(fd), flags: flags, cont: make(chan error)}
	err := srv.setupConn(c, flags, dialDest)
	if err != nil {
		c.close(err)
		srv.log.Trace("Setting up connection failed", "addr", fd.RemoteAddr(), "err", err)
	}
	return err
}

func (srv *Server) setupConn(c *conn, flags connFlag, dialDest *enode.Node) error {
	// Prevent leftover pending conns from entering the handshake.
	srv.lock.Lock()
	running := srv.running
	srv.lock.Unlock()
	if !running {
		return errServerStopped
	}
    // 如果要与远程节点进行沟通 则算出远程节点的公钥
	// If dialing, figure out the remote public key.
	var dialPubkey *ecdsa.PublicKey
	if dialDest != nil {
		dialPubkey = new(ecdsa.PublicKey)
		if err := dialDest.Load((*enode.Secp256k1)(dialPubkey)); err != nil {
			return errors.New("dial destination doesn't have a secp256k1 public key")
		}
	}
    // 开始进行加密握手，主要交换双方的公钥
	// Run the encryption handshake.
	remotePubkey, err := c.doEncHandshake(srv.PrivateKey, dialPubkey)
	if err != nil {
		srv.log.Trace("Failed RLPx handshake", "addr", c.fd.RemoteAddr(), "conn", c.flags, "err", err)
		return err
	}
	if dialDest != nil {
		// For dialed connections, check that the remote public key matches.
		if dialPubkey.X.Cmp(remotePubkey.X) != 0 || dialPubkey.Y.Cmp(remotePubkey.Y) != 0 {
			return DiscUnexpectedIdentity
		}
		c.node = dialDest
	} else {
        // 将远程节点包装为一个Node
		c.node = nodeFromConn(remotePubkey, c.fd)
	}
	if conn, ok := c.fd.(*meteredConn); ok {
		conn.handshakeDone(c.node.ID())
	}
	clog := srv.log.New("id", c.node.ID(), "addr", c.fd.RemoteAddr(), "conn", c.flags)
    // 开始进行一次检查，将c传到posthandshake通道 主要检查是否为已知节点或者节点个数超出当前限制，对静态节点和trusted节点开绿灯
	err = srv.checkpoint(c, srv.posthandshake)
	if err != nil {
		clog.Trace("Rejected peer before protocol handshake", "err", err)
		return err
	}
    // 开始执行协议握手，主要将自己和对方支持的协议进行对比
	// Run the protocol handshake
	phs, err := c.doProtoHandshake(srv.ourHandshake)
	if err != nil {
		clog.Trace("Failed proto handshake", "err", err)
		return err
	}
    // 如果当前连接的节点身份和远程交换的不服 返回错误
	if id := c.node.ID(); !bytes.Equal(crypto.Keccak256(phs.ID), id[:]) {
		clog.Trace("Wrong devp2p handshake identity", "phsid", hex.EncodeToString(phs.ID))
		return DiscUnexpectedIdentity
	}
    // 记录远程节点支持的所有交易和远程节点的名称
	c.caps, c.name = phs.Caps, phs.Name
    // 又一个检查点，将c 传入addpeer通道
	err = srv.checkpoint(c, srv.addpeer)
	if err != nil {
		clog.Trace("Rejected peer", "err", err)
		return err
	}
	// If the checks completed successfully, runPeer has now been
	// launched by run.
	clog.Trace("connection set up", "inbound", dialDest == nil)
	return nil
}

以上是p2p服务接收外部连接的部分，主要做了以下几件事情：

• 开启tcp监听端口，固定槽位，无限监听外部连接，每收到一个连接请求，开启单独的协程处理连接请求
• 与远程节点建立连接，连接期间主要做了加密握手，加密握手成功以后进行预前检查，查看是不是超出节点最大连接数、是不是已知节点等等。
• 紧接着进行协议握手，协议握手成功后执行一次检查，将此连接插入addpeer通道，尝试将此连接作为一个peer加入本节点。

接下来先分析跟dail.go相关的逻辑，主要是一些动态连接任务，动态连接任务总数为maxPeer/3个

1.4srv.run(dialer)

// server的主循环
func (srv *Server) run(dialstate dialer) {
	srv.log.Info("Started P2P networking", "self", srv.localnode.Node())
	defer srv.loopWG.Done()
	defer srv.nodedb.Close()

	var (
        //存放所有已连接的peer
		peers        = make(map[enode.ID]*Peer)
        // 统计内部连接数量
		inboundCount = 0
        // 记录trusted节点 ，主要当节点数量限制上面对trustednode有绿灯
		trusted      = make(map[enode.ID]bool, len(srv.TrustedNodes))
        // 最大活跃dail任务数为16 
		taskdone     = make(chan task, maxActiveDialTasks)
        // 正在运行中的任务
		runningTasks []task
        // 队列中的任务
		queuedTasks  []task // tasks that can't run yet
	)
	//添加trusted-nodes
	// Put trusted nodes into a map to speed up checks.
	// Trusted peers are loaded on startup or added via AddTrustedPeer RPC.
	for _, n := range srv.TrustedNodes {
		trusted[n.ID()] = true
	}
	// 从运行中的task删除task的函数定义
	// removes t from runningTasks
	delTask := func(t task) {
		for i := range runningTasks {
			if runningTasks[i] == t {
				runningTasks = append(runningTasks[:i], runningTasks[i+1:]...)
				break
			}
		}
	}

	// starts until max number of active tasks is satisfied
    // 如果运行中的任务数量小于限制，且计数器小于任务数，那么将queue中的任务拿出来执行，并返回剩余的任务
	startTasks := func(ts []task) (rest []task) {
		i := 0
		//maxActiveDialTask = 16
		for ; len(runningTasks) < maxActiveDialTasks && i < len(ts); i++ {
			t := ts[i]
			srv.log.Trace("New dial task", "task", t)
			go func() { t.Do(srv); taskdone <- t }()
			runningTasks = append(runningTasks, t)
		}
		return ts[i:]
	}
    // 定时器执行逻辑
	scheduleTasks := func() {
        //  将队列更新为运行完剩余的任务
		// Start from queue first.
		queuedTasks = append(queuedTasks[:0], startTasks(queuedTasks)...)
         // 立刻查询一次运行任务是不是小于限制，若小于限制，则创建一批新的任务，立即执行一次开始任务的操作
		// Query dialer for new tasks and start as many as possible now.
		if len(runningTasks) < maxActiveDialTasks {
			//新放进来一批任务 ，每次任务都不一样
			//nt = new task
			nt := dialstate.newTasks(len(runningTasks)+len(queuedTasks), peers, time.Now())
			queuedTasks = append(queuedTasks, startTasks(nt)...)
		}
	}
// 下面是server的主要循环，处理各种通道的事件
running:
	for {
		scheduleTasks()

		select {
         // 如果srv.quit通道发来退出server的请求，那么跳出running循环，进行清理逻辑
		case <-srv.quit:
			// The server was stopped. Run the cleanup logic.
			break running
		case n := <-srv.addstatic:
			//给静态节点都添加dialtask  经过dailtask以后如果正常他们会被放入addpeer通道
			// This channel is used by AddPeer to add to the
			// ephemeral static peer list. Add it to the dialer,
			// it will keep the node connected.
			srv.log.Trace("Adding static node", "node", n)
			dialstate.addStatic(n)
		case n := <-srv.removestatic:
             // 移除与静态节点的连接
			// This channel is used by RemovePeer to send a
			// disconnect request to a peer and begin the
			// stop keeping the node connected.
			srv.log.Trace("Removing static node", "node", n)
			dialstate.removeStatic(n)
			if p, ok := peers[n.ID()]; ok {
				p.Disconnect(DiscRequested)
			}
		case n := <-srv.addtrusted:
             //添加信任节点
			// This channel is used by AddTrustedPeer to add an enode
			// to the trusted node set.
			srv.log.Trace("Adding trusted node", "node", n)
			trusted[n.ID()] = true
			// Mark any already-connected peer as trusted
			if p, ok := peers[n.ID()]; ok {
				p.rw.set(trustedConn, true)
			}
		case n := <-srv.removetrusted:
             // 移除信任节点
			// This channel is used by RemoveTrustedPeer to remove an enode
			// from the trusted node set.
			srv.log.Trace("Removing trusted node", "node", n)
			if _, ok := trusted[n.ID()]; ok {
				delete(trusted, n.ID())
			}
			// Unmark any already-connected peer as trusted
			if p, ok := peers[n.ID()]; ok {
				p.rw.set(trustedConn, false)
			}
		case op := <-srv.peerOp:
             // 定义了一些对所有peer的操作函数，在此执行
			// This channel is used by Peers and PeerCount.
			op(peers)
			srv.peerOpDone <- struct{}{}
		case t := <-taskdone:
			//一个task完成以后 通知dailstate 更新state 并从活跃任务列表移除
			// A task got done. Tell dialstate about it so it
			// can update its state and remove it from the active
			// tasks list.
			srv.log.Trace("Dial task done", "task", t)
			dialstate.taskDone(t, time.Now())
			delTask(t)
		case c := <-srv.posthandshake:
             // 经过加密连接以后，通过检查点把连接传到这里执行一次检查
			// A connection has passed the encryption handshake so
			// the remote identity is known (but hasn't been verified yet).
			if trusted[c.node.ID()] {
				// Ensure that the trusted flag is set before checking against MaxPeers.
				c.flags |= trustedConn
			}
			// TODO: track in-progress inbound node IDs (pre-Peer) to avoid dialing them.
			select {
			case c.cont <- srv.encHandshakeChecks(peers, inboundCount, c):
			case <-srv.quit:
				break running
			}
		case c := <-srv.addpeer:
             // 当peer经过所有验证时，将被传到这里执行实际的peer添加操作
			// At this point the connection is past the protocol handshake.
			// Its capabilities are known and the remote identity is verified.
			//这个阶段已经通过协议握手，他的功能
			err := srv.protoHandshakeChecks(peers, inboundCount, c)
			//如果通过协议握手检查
			if err == nil {
				// The handshakes are done and it passed all checks.
				p := newPeer(c, srv.Protocols)
				//消息事件推送
				// If message events are enabled, pass the peerFeed
				// to the peer
				if srv.EnableMsgEvents {
					p.events = &srv.peerFeed
				}
				//对name进行截断
				name := truncateName(c.name)
				srv.log.Debug("Adding p2p peer", "name", name, "addr", c.fd.RemoteAddr(), "peers", len(peers)+1)
				//开启线程运行peer
				go srv.runPeer(p)
				//将peer添加到peers map
				peers[c.node.ID()] = p
				if p.Inbound() {
					inboundCount++
				}
			}
			// The dialer logic relies on the assumption that
			// dial tasks complete after the peer has been added or
			// discarded. Unblock the task last.
			select {
			case c.cont <- err:
			case <-srv.quit:
				break running
			}
		case pd := <-srv.delpeer:
             // 删除一个peer 
			// A peer disconnected.
			d := common.PrettyDuration(mclock.Now() - pd.created)
			pd.log.Debug("Removing p2p peer", "duration", d, "peers", len(peers)-1, "req", pd.requested, "err", pd.err)
			//从peers map里面删除peer
			delete(peers, pd.ID())
			if pd.Inbound() {
				inboundCount--
			}
		}
	}

	srv.log.Trace("P2P networking is spinning down")
	//关闭udp  table
	// Terminate discovery. If there is a running lookup it will terminate soon.
	if srv.ntab != nil {
		srv.ntab.Close()
	}
	if srv.DiscV5 != nil {
		srv.DiscV5.Close()
	}
	//和所有peer断开连接
	// Disconnect all peers.
	for _, p := range peers {
		p.Disconnect(DiscQuitting)
	}
	//待理解
	// Wait for peers to shut down. Pending connections and tasks are
	// not handled here and will terminate soon-ish because srv.quit
	// is closed.
	for len(peers) > 0 {
		p := <-srv.delpeer
		p.log.Trace("<-delpeer (spindown)", "remainingTasks", len(runningTasks))
		delete(peers, p.ID())
	}
}

以上为server的主循环，主要做了以下几件事：

• 定时执行一批任务，调用了task.Do()方法，每个任务具体做什么后面细讲
• 处理各种通道的事件

1.5 dialstate.newTasks()

在分析这部分代码之前先明确一件事，task总共有几种类型，总的task类型有三种：dailTask discoverTask waitExpireTask。这三种任务分别执行的是连接任务、节点发现任务、等待过期任务，三种任务各自实现了task接口的Do方法。task接口定义如下：

type task interface {
	Do(*Server)
}

下面开始分析newTask()方法

func (s *dialstate) newTasks(nRunning int, peers map[enode.ID]*Peer, now time.Time) []task {
	if s.start.IsZero() {
		s.start = now
	}

	var newtasks []task
	//添加dailtask
	addDial := func(flag connFlag, n *enode.Node) bool {
		if err := s.checkDial(n, peers); err != nil {
			log.Trace("Skipping dial candidate", "id", n.ID(), "addr", &net.TCPAddr{IP: n.IP(), Port: n.TCP()}, "err", err)
			return false
		}
		s.dialing[n.ID()] = flag
		newtasks = append(newtasks, &dialTask{flags: flag, dest: n})
		return true
	}
	
	// Compute number of dynamic dials necessary at this point.
	needDynDials := s.maxDynDials //maxDynDials = MaxPeers/3
    //1 、判断所有peer里是否有动态连接的 若有则总的动态连接任务计数缩小
    // 如果已经连接的peer中动态连接类型的节点数量过多，将导致needDynDials小于0  那么下面大多数逻辑就不能执行
	for _, p := range peers {
		if p.rw.is(dynDialedConn) {
			needDynDials--
		}
	}

	//2、计算正在dail中的是动态dail的任务，若有动态连接的任务，缩小动态连接任务的计数
	for _, flag := range s.dialing {
		if flag&dynDialedConn != 0 {
			needDynDials--
		}
	}
	//3、每次newTask调用时候将过期的dail任务弹出堆
	// Expire the dial history on every invocation.
	s.hist.expire(now)
	// 4、为非连接状态的静态节点创建dailtask    项目初次启动时候会给所有静态节点添加dailTask任务
	// Create dials for static nodes if they are not connected.
	for id, t := range s.static {
		err := s.checkDial(t.dest, peers)
		switch err {
		case errNotWhitelisted, errSelf:
			log.Warn("Removing static dial candidate", "id", t.dest.ID, "addr", &net.TCPAddr{IP: t.dest.IP(), Port: t.dest.TCP()}, "err", err)
			delete(s.static, t.dest.ID())
		case nil:
			s.dialing[id] = t.flags
			newtasks = append(newtasks, t)
		}
	}
	//5、如果我们的peers为空且引导节点个数大于0且动态任务剩余计数大于0且现在时间减去开始时间大于20s 则尝试联系一个bootnode节点 一般为bootnode的第一个
	// If we don't have any peers whatsoever, try to dial a random bootnode. This
	// scenario is useful for the testnet (and private networks) where the discovery
	// table might be full of mostly bad peers, making it hard to find good ones.
	if len(peers) == 0 && len(s.bootnodes) > 0 && needDynDials > 0 && now.Sub(s.start) > fallbackInterval {
         // 暂存引导节点列表第一个
		bootnode := s.bootnodes[0]
         // 将后面节点往前面移动覆盖第一个节点
		s.bootnodes = append(s.bootnodes[:0], s.bootnodes[1:]...)
         // 将第一个节点追加到引导节点列表尾部
		s.bootnodes = append(s.bootnodes, bootnode)
		// 将bootnodez作为一个dynDialedConn类型添加一为个dailtask
		if addDial(dynDialedConn, bootnode) {
			needDynDials--
		}
	}
	//6、此时我们将还剩余的动态dail位置的一半记为randomCandidates，如果计数还大于0，那么从bucket里面读取randomCandidates个节点进行dail 
    // 相当于定期拿出bucket里面的节点进行连接
	// Use random nodes from the table for half of the necessary
	// dynamic dials.
	randomCandidates := needDynDials / 2
	if randomCandidates > 0 {
        // randomNodes切片的长度为(maxPeers/3)/2
		n := s.ntab.ReadRandomNodes(s.randomNodes)
		for i := 0; i < randomCandidates && i < n; i++ {
			if addDial(dynDialedConn, s.randomNodes[i]) {
				needDynDials--
			}
		}
	}
    // 创建随机节点查找任务，将查找到的结果填充到lookupBuf
	// Create dynamic dials from random lookup results, removing tried
	// items from the result buffer.
	i := 0
	for ; i < len(s.lookupBuf) && needDynDials > 0; i++ {
		if addDial(dynDialedConn, s.lookupBuf[i]) {
			needDynDials--
		}
	}
	s.lookupBuf = s.lookupBuf[:copy(s.lookupBuf, s.lookupBuf[i:])]
	// Launch a discovery lookup if more candidates are needed.
	if len(s.lookupBuf) < needDynDials && !s.lookupRunning {
		s.lookupRunning = true
		//给lookup添加一个发现节点的任务
		newtasks = append(newtasks, &discoverTask{})
	}

	// Launch a timer to wait for the next node to expire if all
	// candidates have been tried and no task is currently active.
	// This should prevent cases where the dialer logic is not ticked
	// because there are no pending events.
	//如果nRunning为0且newTasks长度为0且历史任务列表大于0创建等待过期的任务
	if nRunning == 0 && len(newtasks) == 0 && s.hist.Len() > 0 {
		t := &waitExpireTask{s.hist.min().exp.Sub(now)}
		newtasks = append(newtasks, t)
	}
	return newtasks
}
// 额外加一段代码方便理解
// 当dailTask和discoverTask做完以后会做相应操作
func (s *dialstate) taskDone(t task, now time.Time) {
	switch t := t.(type) {
	case *dialTask:
        // 在history中添加此结果，并在dialing列表中删除已完成的任务
		s.hist.add(t.dest.ID(), now.Add(dialHistoryExpiration))
		delete(s.dialing, t.dest.ID())
	case *discoverTask:
		s.lookupRunning = false
         // 此部分将节点发现机制发现的节点存在lookupBuf中
		s.lookupBuf = append(s.lookupBuf, t.results...)
	}
}

下面先讲几个任务的Do的具体实现

dailTask的Do实现
func (t *dialTask) Do(srv *Server) {
	if t.dest.Incomplete() {
		if !t.resolve(srv) {
			return
		}
	}
	err := t.dial(srv, t.dest)
	if err != nil {
		log.Trace("Dial error", "task", t, "err", err)
		// Try resolving the ID of static nodes if dialing failed.
		if _, ok := err.(*dialError); ok && t.flags&staticDialedConn != 0 {
			if t.resolve(srv) {
				t.dial(srv, t.dest)
			}
		}
	}
}
discoverTask的Do实现
func (t *discoverTask) Do(srv *Server) {
	// newTasks generates a lookup task whenever dynamic dials are
	// necessary. Lookups need to take some time, otherwise the
	// event loop spins too fast.
	next := srv.lastLookup.Add(lookupInterval)
	if now := time.Now(); now.Before(next) {
		time.Sleep(next.Sub(now))
	}
	srv.lastLookup = time.Now()
	t.results = srv.ntab.LookupRandom()
}
waitExpireTask的Do实现
func (t waitExpireTask) Do(*Server) {
	time.Sleep(t.Duration)
}

以上主要是在server.go里面实现的代码，主要开启了tcp监听端口来接收外部连接，还定时执行三种task任务，节点发现部分下一节单独分析