btcd的p2p网络（1）-地址addrMgr

p2p网络从底层到上层可以分为3层，地址 连接 节点，每一层都有自己的功能
声明：文章代码和源码有不一致地方

btcd的p2p网络之地址

主要有四个结构体,两两对应

AddrManager
serializedAddrManager

KnownAddress
serializedKnownAddress

我们先看peer.json中的内容,这个就是和serializedAddrManager的内容对应的。

//peers.json

{
    "Version": 1,
    "Key": [233,19,87,131,183,155,......,231,78,82,150,10,102],
    "Addresses": [
        {
            "Addr": "109.157.120.169:8333",
            "Src": "104.172.5.90:8333",
            "Attempts": 0,
            "TimeStamp": 1514967959,
            "LastAttempt": -62135596800,
            "LastSuccess": -62135596800
        },
        ......
    ],
    "NewBuckets": [
        [
            "[2001:0:9d38:78cf:3cb1:bb2:ab6f:e8b4]:8333",
            "196.209.239.229:8333",
            ......
            "65.130.177.198:8333"
        ],
        ......
        [
            "125.227.159.115:8333",
            ......
            "alhlegtjkdmbqsvt.onion:8333",
            ......
            "79.250.188.226:8333"
        ]
    ],
    "TriedBuckets": [
        [
            "5.9.165.181:8333",
            ......
            "5.9.17.24:8333"
        ],
        [
            "95.79.50.90:8333",
            ......
            "[2a02:c207:2008:9136::1]:8333"
        ]
    ]
}

start()

start()先从peer.json中加载，然后开启一个goroutine定期进行跟踪和添加地址。

func (a *AddrManager) Start(){
    //alter stared ?
    if atomic.AddInt32(&a.started,1) != 1{
        log.Trace("AddrManager has stared")
        return
    }
    log.Trace("Starting address manager")
    // load peers we already know about from file
    // 从文件中加载peers
    a.loadPeers()

    // start the address ticker to save addresses periodically（定期）.
    a.wg.Add(1) // 在下面的goroutine中，a.wg.Done()之后，start才会结束
    go a.addressHandler()
}

我们再看a.loadPeers(),主要是调用deserializePeers,就是把peer.json中的文件反序列化。主要是把Addresses``NewBuckets``TriedBuckets,解析到AddrManager的 addrIndex addrNew addrTried

func (a *AddrManager) deserializePeers(filePath string) error {
    _, err := os.Stat(filePath)
    if os.IsNotExist(err) {
        return nil
    }
    r, err := os.Open(filePath)
    if err != nil {
        return fmt.Errorf("opening file:%v error:%v", filePath, err)
    }
    defer r.Close()

    var sam serializedAddrManager
    dec := json.NewDecoder(r)
    err = dec.Decode(&sam)
    if err != nil {
        return fmt.Errorf("error reading %s: %v", filePath, err)
    }
    // 检查版本
    if sam.Version != serialisationVersion {
        return fmt.Errorf("unknown version %v in serialized "+
            "addrmanager", sam.Version)
    }
    copy(a.key[:], sam.Key[:])
    // 先解析Addresses
    for _, v := range sam.Addresses {
        ka := new(KnownAddress)
        ka.na, err = a.DeserializeNetAddress(v.Addr)
        if err != nil {
            return fmt.Errorf("failed to deserialize netaddress "+
                "%s: %v", v.Addr, err)
        }
        ka.srcAddr, err = a.DeserializeNetAddress(v.Src)
        if err != nil {
            return fmt.Errorf("failed to deserialize netaddress "+
                "%s: %v", v.Src, err)
        }
        ka.attempts = v.Attempts
        ka.lastattempt = time.Unix(v.LastAttempt, 0)
        ka.lastsuccess = time.Unix(v.LastAttempt, 0)
        // 遍历sam.Addresses中的每一项，然后辨析成一个KnownAddress后，
        // 添加到addrManager.addrIndex,是一个map
        a.addrIndex[NetAddressKey(ka.na)] = ka
    }

    // 遍历解析Newbuckets
    for i := range sam.NewBuckets {
        for _, val := range sam.NewBuckets[i] {
            // 先看看addrIndex中有没有这个ip:port
            ka, ok := a.addrIndex[val]
            if !ok {
                return fmt.Errorf("newbucket contains %s but "+
                    "none in address list", val)
            }
            // addrIndex中已经有了
            if ka.refs == 0 {
                a.nNew ++
            }
            ka.refs ++
            a.addrNew[i][val] = ka
        }
    }
    // 遍历解析TriedBuckets
    for i := range sam.TriedBuckets {
        for _, val := range sam.TriedBuckets[i] {
            ka, ok := a.addrIndex[val]
            if !ok {
                return fmt.Errorf("Newbucket contains %s but "+
                    "none in address list", val)
            }

            ka.tried = true
            a.nTried++
            // 一个bucket到这里就成了一个数组
            a.addrTried[i].PushBack(ka)
        }
    }
    // 检查,保证一个地址要么在 NewBuckets中，要么在TriedBuckets
    for k, v := range a.addrIndex {
        if v.refs == 0 && !v.tried {
            return fmt.Errorf("address %s after serialisation "+
                "with no references", k)
        }
        if v.refs > 0 && v.tried {
            return fmt.Errorf("address %s after serialisation "+
                "which is both new and tried!", k)
        }
    }
    return nil
}

然后调用a.addressHandler()，主要逻辑就是定期保存地址

// addressHandler is the main handler for the address manager.  It must be run
// as a goroutine.
func (a *AddrManager) addressHandler() {
    dumpAddressTicker := time.NewTicker(dumpAddressInterval)
    defer dumpAddressTicker.Stop()
out:
    for {
        select {
        case <-dumpAddressTicker.C:
            a.savePeers()
        case <-a.quit:
            break out
        }
    }
    a.savePeers()
    a.wg.Done()  // start方法中已经有wg.Add(1)在等着了
    log.Trace("Address handler done")
}

a.savePeers(),大家可以查看源码

updateAddress

节点直接交换etaddr和addr消息时，就会收到addr信息，调用AddAddress()是实际上都是调用updateAddress
如果我们已经有了，就进行一些修改
如果我们没有，就添加，如果满了的话，就把老的给移除掉

NewBucket到TriedBucket

在节点获取地址，并建立peer连接成功后，会调用Good方法。就是说这个地址是好的，可以从NewBucket移到TriedBucket了。

GetAddress

这个是供外面获取地址的方法

按照50%的记录随机从NewBucket或者TriedBucket中选择。随机选择bucket后，从中随机选择地址。选择出来的地址要判断一下

randval := a.rand.Intn(large)
if float64(randval) < (factor * ka.chance() * float64(large)) {
    log.Tracef("Selected %v from new bucket",NetAddressKey(ka.na))
    return ka
}

决定是不是用这个选中地址，主要是由factor和ka.chance()决定。
facket依次递增
而ka.chance()则和这个地址的其他属性密切相关。比如上次尝试到现在间隔，失败的次数。

我们完全可以去除这个包，设置几个固定的地址，但是这几个地址不能用后，我们的节点也就没法同步了。就不是p2p了。搞这么复杂，主要还是为了防止攻击。

AddLocalAddress

// AddLocalAddress adds na to the list of known local addresses to advertise with the given priority.
// 地址会先加到AddrManager.localAddresses
func (a *AddrManager) AddLocalAddress(na *wire.NetAddress,priority AddressPriority)error{
    // TODO 判断不是是公网路由
    a.lamtx.Lock()
    defer a.lamtx.Unlock()
    // 得到特定格式的ip：端口
    key := NetAddressKey(na)
    // 判断localAddresses有没有这个ip
    la,ok := a.localAddresses[key]
    if !ok || la.score < priority{
        if ok {
            la.score = priority + 1
        }else{
            a.localAddresses[key] = &localAddress{
                na:na,
                score:priority,
            }
        }
    }
    return nil
}