剥开比原看代码02：比原启动后去哪里链接别的节点

做者：freewind

比原项目仓库：

Github地址：https://github.com/Bytom/bytom

Gitee地址：https://gitee.com/BytomBlockchain/bytom

比原启动后去哪里链接别的节点

最开始我对于这个问题一直有个疑惑：区块链是一个分布式的网络，那么一个节点启动后，它怎么知道去哪里找别的节点从而加入网络呢？

看到代码以后，我才明白，原来在代码中硬编码了一些种子地址，这样在启动的时候，能够先经过种子地址加入网络。虽然整个网络是分布式的，可是最开始仍是须要必定的中心化。

预编码内容

对于配置文件config.toml，比原的代码中硬编码了配置文件内容：

config/toml.go#L22-L45

var defaultConfigTmpl = `# This is a TOML config file.
# For more information, see https://github.com/toml-lang/toml
fast_sync = true
db_backend = "leveldb"
api_addr = "0.0.0.0:9888"
`

var mainNetConfigTmpl = `chain_id = "mainnet"
[p2p]
laddr = "tcp://0.0.0.0:46657"
seeds = "45.79.213.28:46657,198.74.61.131:46657,212.111.41.245:46657,47.100.214.154:46657,47.100.109.199:46657,47.100.105.165:46657"
`

var testNetConfigTmpl = `chain_id = "testnet"
[p2p]
laddr = "tcp://0.0.0.0:46656"
seeds = "47.96.42.1:46656,172.104.224.219:46656,45.118.132.164:46656"
`

var soloNetConfigTmpl = `chain_id = "solonet"
[p2p]
laddr = "tcp://0.0.0.0:46658"
seeds = ""
`

能够看出，对于不一样的chain_id，预设的种子是不一样的。

固然，若是咱们本身知道某些节点的地址，也能够在初始化生成config.toml后，手动修改该文件添加进去。

启动syncManager

那么，比原在代码中是使用这些种子地址并链接它们的呢？关键在于，链接的代码位于SyncManager中，因此咱们要找到启动syncManager的地方。

首先，当咱们使用bytomd node启动后，下面的函数将被调用：

cmd/bytomd/commands/run_node.go#L41

func runNode(cmd *cobra.Command, args []string) error {
    // Create & start node
    n := node.NewNode(config)
    if _, err := n.Start(); err != nil {
        // ...
    }
    // ...
}

这里调用了n.Start，其中的Start方法，来自于Node所嵌入的cmn.BaseService：

node/node.go#L39

type Node struct {
    cmn.BaseService
    // ...
}

因此n.Start对应的是下面这个方法：

vendor/github.com/tendermint/tmlibs/common/service.go#L97

func (bs *BaseService) Start() (bool, error) {
    // ...
    err := bs.impl.OnStart()
    // ...
}

在这里，因为bs.impl对应于Node，因此将继续调用Node.OnStart():

node/node.go#L169

func (n *Node) OnStart() error {
    // ...
    n.syncManager.Start()
    // ...
}

能够看到，咱们终于走到了调用了syncManager.Start()的地方。

syncManager中的处理

而后就是在syncManager内部的一些处理了。

它主要是除了从config.toml中取得种子节点外，还须要把之前链接过并保存在本地的AddressBook.json中的节点也拿出来链接，这样就算预设的种子节点失败了，也仍是有可能链接上网络（部分解决了前面提到的中心化的担心）。

syncManager.Start()对应于：

netsync/handle.go#L141

func (sm *SyncManager) Start() {
    go sm.netStart()
    // ...
}

其中sm.netStart()，对应于：

netsync/handle.go#L121

func (sm *SyncManager) netStart() error {
    // ...
    // If seeds exist, add them to the address book and dial out
    if sm.config.P2P.Seeds != "" {
        // dial out
        seeds := strings.Split(sm.config.P2P.Seeds, ",")
        if err := sm.DialSeeds(seeds); err != nil {
            return err
        }
    }
    // ...
}

其中的sm.config.P2P.Seeds就对应于config.toml中的seeds。关于这二者是怎么对应起来的，会在后面文章中详解。

紧接着，再经过sm.DialSeeds(seeds)去链接这些seed，这个方法对应的代码位于：

netsync/handle.go#L229

func (sm *SyncManager) DialSeeds(seeds []string) error {
    return sm.sw.DialSeeds(sm.addrBook, seeds)
}

实际上是是调用了sm.sw.DialSeeds，而sm.sw是指Switch。这时能够看到，有一个叫addrBook的东西参与了进来，它保存了该结点以前成功链接过的节点地址，咱们这里暂很少作讨论。

Switch.DialSeeds对应于：

p2p/switch.go#L311

func (sw *Switch) DialSeeds(addrBook *AddrBook, seeds []string) error {
    // ...
    perm := rand.Perm(len(netAddrs))
    for i := 0; i < len(perm)/2; i++ {
        j := perm[i]
        sw.dialSeed(netAddrs[j])
    }
   // ...
}

这里引入了随机数，是为了将发起链接的顺序打乱，这样可让每一个种子都得到公平的链接机会。

sw.dialSeed(netAddrs[j])对应于：

p2p/switch.go#L342

func (sw *Switch) dialSeed(addr *NetAddress) {
    peer, err := sw.DialPeerWithAddress(addr, false)
    // ...
}

sw.DialPeerWithAddress(addr, false)又对应于：

p2p/switch.go#L351

func (sw *Switch) DialPeerWithAddress(addr *NetAddress, persistent bool) (*Peer, error) {
    // ...
    log.WithField("address", addr).Info("Dialing peer")
    peer, err := newOutboundPeerWithConfig(addr, sw.reactorsByCh, sw.chDescs, sw.StopPeerForError, sw.nodePrivKey, sw.peerConfig)
    // ...
}

其中的persistent参数若是是true的话，代表这个peer比较重要，在某些状况下若是断开链接后，还会尝试重连。若是persistent为false的，就没有这个待遇。

newOutboundPeerWithConfig对应于：

p2p/peer.go#L69

func newOutboundPeerWithConfig(addr *NetAddress, reactorsByCh map[byte]Reactor, chDescs []*ChannelDescriptor, onPeerError func(*Peer, interface{}), ourNodePrivKey crypto.PrivKeyEd25519, config *PeerConfig) (*Peer, error) {
    conn, err := dial(addr, config)
    // ...
}

继续dial，加入了超时：

p2p/peer.go#L284

func dial(addr *NetAddress, config *PeerConfig) (net.Conn, error) {
    conn, err := addr.DialTimeout(config.DialTimeout * time.Second)
    if err != nil {
        return nil, err
    }
    return conn, nil
}

addr.DialTimeout对应于：

p2p/netaddress.go#L141

func (na *NetAddress) DialTimeout(timeout time.Duration) (net.Conn, error) {
    conn, err := net.DialTimeout("tcp", na.String(), timeout)
    if err != nil {
        return nil, err
    }
    return conn, nil
}

终于到了net包的调用，开始真正去链接这个种子节点了，到这里，咱们能够认为这个问题解决了。