Skip to content

PasteFerry (隔空贴): clipboard and file sync across macOS, Windows and Linux. Direct-first, end-to-end encrypted. Optional official access: no server to host. Independent self-hosting remains available.

fix(core): retry LAN discovery when it fails to start

baiyuzee39be0d70852
diff --git a/client-core/internal/transport/lan/lan.go b/client-core/internal/transport/lan/lan.go
index 26c2c1b..42e1827 100644
--- a/client-core/internal/transport/lan/lan.go
+++ b/client-core/internal/transport/lan/lan.go
@@ -51,6 +51,8 @@ const (
blockGrace = 30 * time.Second
instanceTTL = 5 * time.Minute
saveAddrEvery = 10 * time.Minute
+ // mDNS 启动失败后的重试间隔。网络刚变化时网卡可能还没拿到地址,这时启动会失败
+ discoveryRetryEvery = 5 * time.Second
// 本地网络权限的探测间隔(只有 macOS 探测):被拦着时勤一些,用户一允许就能很快撤掉提示。
// 刚被拦的宽限期里每一轮都探测:新程序启动时的拦截一解除就要重启 mDNS,见 rediscover
probeEvery = 10 * time.Minute
@@ -171,6 +173,8 @@ type Transport struct {
// pion/mdns 启动时在哪块网卡上加入组播失败,就再也不用那块网卡;
// 被拦期间启动的 mDNS 会漏掉局域网网卡,拦截解除后也不会自己恢复
rediscover bool
+ // discoveryRetry 不为零表示 mDNS 没启动起来,到这个时间再试一次
+ discoveryRetry time.Time
// reach 是各设备可达状态的副本,由叶子锁保护:peers 层会在持有自己的锁时查询它,
// 不能让它去等 t.mu(t.mu 持有期间可能回调 peers 层)
@@ -657,6 +661,7 @@ func (t *Transport) tick() {
probe := !now.Before(t.nextProbe)
rediscover := t.rediscover
t.rediscover = false
+ retryDiscovery := !t.discoveryRetry.IsZero() && !now.Before(t.discoveryRetry)
blocked := t.blockedLocked(now)
blockedChanged := blocked != t.reportedBlocked
t.reportedBlocked = blocked
@@ -733,6 +738,9 @@ func (t *Transport) tick() {
t.log.Info("系统放行了发往局域网的包,重新开始局域网发现")
t.discovery.Stop()
t.startDiscovery(ctx)
+ case retryDiscovery:
+ t.discovery.Stop()
+ t.startDiscovery(ctx)
case dayChanged || pairingExpired:
t.updateAdvert()
}
@@ -827,9 +835,24 @@ func (t *Transport) startDiscovery(ctx context.Context) {
port := t.port
text := t.advertTextLocked()
t.mu.Unlock()
- if err := t.discovery.Start(ctx, t.instance, port, text, t.found); err != nil {
- // 没有 mDNS 也能用:输入地址、地址簿里的地址照样能连
- t.log.Warn("局域网发现启动失败", "err", err)
+ err := t.discovery.Start(ctx, t.instance, port, text, t.found)
+
+ t.mu.Lock()
+ failedBefore := !t.discoveryRetry.IsZero()
+ if err != nil {
+ t.discoveryRetry = time.Now().Add(discoveryRetryEvery)
+ } else {
+ t.discoveryRetry = time.Time{}
+ }
+ t.mu.Unlock()
+ switch {
+ case err != nil && !failedBefore:
+ // 没有 mDNS 也能用:输入地址、地址簿里的地址照样能连。过一会儿再试
+ t.log.Warn("局域网发现启动失败,稍后重试", "err", err)
+ case err != nil:
+ t.log.Debug("局域网发现仍然启动失败", "err", err)
+ case failedBefore:
+ t.log.Info("局域网发现已启动")
}
}
diff --git a/client-core/internal/transport/lan/lan_test.go b/client-core/internal/transport/lan/lan_test.go
index 65e47b5..d7b77d7 100644
--- a/client-core/internal/transport/lan/lan_test.go
+++ b/client-core/internal/transport/lan/lan_test.go
@@ -458,15 +458,58 @@ func TestRediscoverAfterUnblock(t *testing.T) {
if got := d.starts.Load(); got != 1 {
t.Fatalf("启动时应当启动一次发现,实际 %d 次", got)
}
- n.t.tick()
+ time.Sleep(tickInterval + 500*time.Millisecond)
if got := d.starts.Load(); got != 1 {
t.Fatalf("没有拦截解除时不该重启发现,实际启动了 %d 次", got)
}
n.t.mu.Lock()
n.t.rediscover = true
n.t.mu.Unlock()
- n.t.tick()
+ deadline := time.Now().Add(2*tickInterval + time.Second)
+ for d.starts.Load() < 2 {
+ if time.Now().After(deadline) {
+ t.Fatal("拦截解除后没有重启发现")
+ }
+ time.Sleep(50 * time.Millisecond)
+ }
+ time.Sleep(tickInterval + 500*time.Millisecond)
if got := d.starts.Load(); got != 2 {
- t.Fatalf("拦截解除后应当重启发现,实际启动了 %d 次", got)
+ t.Fatalf("只应重启一次,实际启动了 %d 次", got)
+ }
+}
+
+// flakyDiscovery 前几次 Start 失败,像网卡刚换地址、还没拿到新地址时那样。
+type flakyDiscovery struct {
+ countingDiscovery
+ failures int32
+}
+
+func (f *flakyDiscovery) Start(ctx context.Context, name string, port int, text map[string]string, found func(Instance)) error {
+ if f.starts.Add(1) <= f.failures {
+ return errors.New("no usable interfaces found for mDNS")
+ }
+ return f.Discovery.Start(ctx, name, port, text, found)
+}
+
+// mDNS 启动失败后过一会儿重试,直到成功;成功之后不再重启。
+func TestDiscoveryRetriesAfterFailure(t *testing.T) {
+ d := &flakyDiscovery{countingDiscovery: countingDiscovery{Discovery: NewMemoryNetwork().Discovery()}, failures: 2}
+ n := newNodeWith(t, d)
+ deadline := time.Now().Add(10 * time.Second)
+ for d.starts.Load() < 3 {
+ if time.Now().After(deadline) {
+ t.Fatalf("mDNS 启动失败后没有重试到成功,只启动了 %d 次", d.starts.Load())
+ }
+ // 不等 5 秒:把重试时间提前,交给后台的 tick
+ n.t.mu.Lock()
+ if !n.t.discoveryRetry.IsZero() {
+ n.t.discoveryRetry = time.Now()
+ }
+ n.t.mu.Unlock()
+ time.Sleep(50 * time.Millisecond)
+ }
+ time.Sleep(tickInterval + 500*time.Millisecond)
+ if got := d.starts.Load(); got != 3 {
+ t.Fatalf("启动成功后不该再重启,实际启动了 %d 次", got)
}
}