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。
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 相同的目录执行:
go mod init example.com/p2p-dial-gate
go get github.com/libp2p/go-libp2p@v0.50.0
go run .预期输出(Go 的依赖下载日志不计入程序输出):
首次入队=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 表示冷却到期巡检;生产服务需用定时调度器主动唤醒候选,不能只等待发现协议再次报告,否则可能永远不重试。