P2P 与分布式存储 / 系统课时

发现候选节点后如何控制拨号

发现候选节点后如何控制拨号

发现协议可能在一秒内重复报告几十个 Peer ID。如果收到事件就直接连接,节点会向已连接目标重复拨号,并对不可达地址持续重试。这里用 Go libp2p 做一个有界拨号闸门:先筛候选,再限制并发和速率,失败后按节点退避。

学习目标

  • 按 Peer ID 去重,过滤自身、已连接节点和无地址候选。
  • 用有限队列、并发上限与拨号超时抑制连接风暴。
  • 实现失败退避,并通过本机节点验证连接和重试行为。

候选地址先筛选再排队

发现得到的 peer.AddrInfo 包含节点 ID 与一组 Multiaddr;它表示“可尝试的地址”,不是连接已成功。先按 Peer ID 合并发现事件,再检查自身 ID、地址数量、连接状态与退避截止时间。对同一个 Peer ID,无论收到多少个地址,同一时刻只允许一项排队或拨号任务。

检查项 处理规则
ID == host.ID() 丢弃自身
len(Addrs) == 0 暂不拨号,等待补充地址
network.Connected 或 network.Limited 已有连接,不新建拨号任务
已排队或正在拨号 不重复入队
未到 retryAt 跳过,待冷却结束后再调度

地址不可达与节点拒绝连接不一定等价:同一个 Peer ID 可能同时发布 TCP、QUIC 和中继地址,Host.Connect 可以尝试其可用地址。不要因为一个地址失败就永久拉黑整个节点。来自不可信发现源的回环地址、内网地址与异常长度地址列表还应按网络范围和访问策略过滤;局域网 mDNS 则可以允许内网地址。

从发现事件到连接状态

闸门维护 Queued、Dialing、Connected 和 CoolingDown 四种操作状态。发现事件通过筛选才入队;工作线程发起 Host.Connect(ctx, info);成功移除失败计数,失败记录下一次允许时间。断线后可重新进入待拨号状态。

候选节点去重、排队、拨号与失败退避状态图

本机实验将队列容量设为 8、工作线程数设为 2、拨号速率设为每秒 5 次、单次超时设为 3s。退避从 1s 起,每次失败翻倍,基准值最多 8s,再增加 0%~20% 的随机抖动。生产环境应按 RTT、NAT 穿透耗时和连接预算调整超时,不能直接把演示参数当作通用默认值。

用 Go libp2p 实现有界拨号闸门

下面使用 Go 1.26 和 github.com/libp2p/go-libp2p v0.50.0。创建空目录后,将源码保存为 main.go。实验建立两个可互连的本机 Host,另创建并关闭一个 Host 作为不可达候选;发现事件用 submit 模拟,不依赖 DHT 或 mDNS。

go
package main

import (
    "context"
    "fmt"
    "log"
    "math/rand"
    "sync"
    "time"

    libp2p "github.com/libp2p/go-libp2p"
    "github.com/libp2p/go-libp2p/core/host"
    "github.com/libp2p/go-libp2p/core/network"
    "github.com/libp2p/go-libp2p/core/peer"
)

type dialGate struct {
    h host.Host
    queue chan peer.AddrInfo
    tick *time.Ticker
    mu sync.Mutex
    pending map[peer.ID]bool
    failures map[peer.ID]int
    retryAt map[peer.ID]time.Time
    wg sync.WaitGroup
}

func newGate(h host.Host) *dialGate {
    g := &dialGate{
        h: h, queue: make(chan peer.AddrInfo, 8),
        tick: time.NewTicker(200 * time.Millisecond),
        pending: make(map[peer.ID]bool),
        failures: make(map[peer.ID]int),
        retryAt: make(map[peer.ID]time.Time),
    }
    // 固定工作池,不为每条发现事件创建无限数量的协程。
    for i := 0; i < 2; i++ { go g.worker() }
    return g
}

func connected(h host.Host, id peer.ID) bool {
    s := h.Network().Connectedness(id)
    return s == network.Connected || s == network.Limited
}

func (g *dialGate) submit(info peer.AddrInfo) bool {
    if info.ID == "" || info.ID == g.h.ID() || len(info.Addrs) == 0 || connected(g.h, info.ID) {
        return false
    }
    g.mu.Lock()
    defer g.mu.Unlock()
    if g.pending[info.ID] || time.Now().Before(g.retryAt[info.ID]) { return false }
    g.pending[info.ID] = true
    g.wg.Add(1)
    select {
    case g.queue <- info:
        return true
    default:
        // 队列满时撤销占位;后续巡检可再次投递。
        delete(g.pending, info.ID)
        g.wg.Done()
        return false
    }
}

func (g *dialGate) worker() {
    for info := range g.queue {
        <-g.tick.C // 两名工作线程共用令牌,合计最多每秒5次。
        if connected(g.h, info.ID) {
            g.mu.Lock()
            delete(g.pending, info.ID)
            g.mu.Unlock()
            g.wg.Done()
            continue
        }
        ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
        err := g.h.Connect(ctx, info)
        cancel()

        g.mu.Lock()
        delete(g.pending, info.ID)
        if err == nil {
            delete(g.failures, info.ID)
            delete(g.retryAt, info.ID)
        } else {
            n := g.failures[info.ID] + 1
            g.failures[info.ID] = n
            base := time.Second * time.Duration(1<<min(n-1, 3))
            jitter := time.Duration(rand.Int63n(int64(base/5) + 1))
            g.retryAt[info.ID] = time.Now().Add(base + jitter)
        }
        g.mu.Unlock()
        g.wg.Done()
    }
}

func main() {
    makeHost := func() host.Host {
        h, err := libp2p.New(libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0"))
        if err != nil { log.Fatal(err) }
        return h
    }
    a, b, unreachable := makeHost(), makeHost(), makeHost()
    defer a.Close()
    defer b.Close()
    bad := peer.AddrInfo{ID: unreachable.ID(), Addrs: unreachable.Addrs()}
    if err := unreachable.Close(); err != nil { log.Fatal(err) }

    gate := newGate(a)
    defer gate.tick.Stop()
    defer close(gate.queue)
    good := peer.AddrInfo{ID: b.ID(), Addrs: b.Addrs()}
    first := gate.submit(good)
    duplicate := gate.submit(good)
    failedCandidate := gate.submit(bad)
    gate.wg.Wait()
    duringBackoff := gate.submit(bad)
    // 第一轮退避在1~1.2秒之间,模拟到期后的巡检。
    time.Sleep(1300 * time.Millisecond)
    afterBackoff := gate.submit(bad)
    gate.wg.Wait()
    fmt.Printf("首次入队=%t 重复入队=%t\n", first, duplicate)
    fmt.Printf("可用节点已连接=%t 不可达候选已入队=%t\n", connected(a, b.ID()), failedCandidate)
    fmt.Printf("退避期入队=%t 到期重新入队=%t\n", duringBackoff, afterBackoff)
}

在与 main.go 相同的目录执行:

bash
go mod init example.com/p2p-dial-gate
go get github.com/libp2p/go-libp2p@v0.50.0
go run .

预期输出(Go 的依赖下载日志不计入程序输出):

text
首次入队=true 重复入队=false
可用节点已连接=true 不可达候选已入队=true
退避期入队=false 到期重新入队=true

监听端口由系统动态分配,每次运行可能不同。代码使用 127.0.0.1,仅验证本机拨号路径;跨公网时还要处理 NAT、中继与真实可达地址。submit 返回 true 只代表成功入队,连接是否成功应读取网络连接状态或拨号结果。

上线前检查边界

用同一个 Peer ID 连续触发 100 次发现事件,队列中应最多保留一条未完成任务;同时发现 100 个不同 Peer ID 时,队列最多等待 8 条,最多 2 条执行拨号。失败计数按 Peer ID 维护,不能让地址轮换绕开冷却时间。

验证时重点记录 discovered、enqueued、dial_started、dial_failed、dial_succeeded、backoff_skipped、queue_dropped 计数,并分别检查“没有地址”“连接已存在”“队列已满”“拨号超时”四类路径。演示程序通过再次调用 submit 表示冷却到期巡检;生产服务需用定时调度器主动唤醒候选,不能只等待发现协议再次报告,否则可能永远不重试。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

发现候选节点后如何控制拨号

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通