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): resume interrupted sends after an early reconnect

baiyuzecc84d025fe25
diff --git a/client-core/internal/send/outgoing.go b/client-core/internal/send/outgoing.go
index f07c8dc..6d50c92 100644
--- a/client-core/internal/send/outgoing.go
+++ b/client-core/internal/send/outgoing.go
@@ -172,12 +172,21 @@ func (e *Engine) kick(deviceID string) {
// runDevice 按先后顺序一批一批地发给一台设备。连接断了就停下,等 PeerReady 再来。
func (e *Engine) runDevice(deviceID string) {
+ // 重连可能早于旧尝试的应答超时:PeerReady 看不到稍后才标为中断的批次。
+ // 每批补试一次;持续失败仍等下一次重连或用户点「继续」,不循环重发。
+ var retried string
for e.ctx.Err() == nil {
t, ok := e.nextQueued(deviceID)
if !ok || !e.opts.Peer(deviceID).Connected {
break
}
e.runOutgoing(t)
+ if retried != t.ID {
+ if cur, err := e.opts.Store.GetTransfer(t.ID); err == nil && cur.Status == store.TransferInterrupted && e.opts.Peer(deviceID).Connected {
+ retried = t.ID
+ e.retryInterrupted(cur)
+ }
+ }
}
e.mu.Lock()
delete(e.workers, deviceID)
@@ -188,6 +197,23 @@ func (e *Engine) runDevice(deviceID string) {
}
}
+// retryInterrupted 给对方重启留一点时间,等待期间的取消、手动继续和退出优先。
+func (e *Engine) retryInterrupted(t store.Transfer) {
+ timer := time.NewTimer(3 * time.Second)
+ defer timer.Stop()
+ select {
+ case <-e.ctx.Done():
+ return
+ case <-timer.C:
+ }
+ cur, err := e.opts.Store.GetTransfer(t.ID)
+ if err != nil || cur.Status != store.TransferInterrupted || cur.Attempt != t.Attempt || !e.opts.Peer(t.DeviceID).Connected {
+ return
+ }
+ cur.Status, cur.Error = store.TransferQueued, ""
+ e.save(cur)
+}
+
func (e *Engine) nextQueued(deviceID string) (store.Transfer, bool) {
list, err := e.opts.Store.UnfinishedTransfers()
if err != nil {
diff --git a/client-core/internal/send/send_test.go b/client-core/internal/send/send_test.go
index da52141..a662ede 100644
--- a/client-core/internal/send/send_test.go
+++ b/client-core/internal/send/send_test.go
@@ -32,6 +32,7 @@ type side struct {
answers []*pb.SendAnswer
blockOut bool // 模拟连接断了:控制消息发不出去
dropResult bool // 模拟「已收到」的结果在路上丢了
+ dropOffers int // 模拟请求落在对方重启前的旧连接里
}
func (s *side) config() config.Config {
@@ -128,6 +129,11 @@ func (p *pair) newSide(t *testing.T, id, peer string) *side {
}
if o := msg.GetSendOffer(); o != nil {
s.offers = append(s.offers, o)
+ if s.dropOffers > 0 {
+ s.dropOffers--
+ s.mu.Unlock()
+ return nil
+ }
}
s.mu.Unlock()
if blocked {
@@ -264,6 +270,88 @@ func TestSendFilesAndFolder(t *testing.T) {
}
}
+// 重连通知到达时还在等旧连接的应答;之后超时也应自动继续。
+func TestResumeWhenReconnectPrecedesAnswerTimeout(t *testing.T) {
+ for _, lan := range []bool{false, true} {
+ t.Run(map[bool]string{false: "datachannel", true: "tcp"}[lan], func(t *testing.T) {
+ p := newPair(t)
+ if lan {
+ useLAN(t, p, false)
+ }
+ p.a.eng.opts.AnswerTimeout = 300 * time.Millisecond
+ p.a.mu.Lock()
+ p.a.dropOffers = 1
+ p.a.mu.Unlock()
+ path := filepath.Join(t.TempDir(), "restart.bin")
+ data := randomBytes(t, 1<<20)
+ writeFile(t, path, data)
+ tr, err := p.a.eng.SendFiles("bob", []string{path}, false)
+ if err != nil {
+ t.Fatal(err)
+ }
+ waitFor(t, 5*time.Second, func() bool {
+ p.a.mu.Lock()
+ defer p.a.mu.Unlock()
+ return len(p.a.offers) == 1
+ })
+ p.a.eng.PeerReady("bob")
+ waitStatus(t, p.a, tr.GetId(), store.TransferDone)
+ waitStatus(t, p.b, tr.GetId(), store.TransferDone)
+ sameFile(t, data, filepath.Join(p.b.recvDir, "restart.bin"))
+ p.a.mu.Lock()
+ defer p.a.mu.Unlock()
+ if len(p.a.offers) != 3 || !p.a.offers[1].GetResume() || p.a.offers[2].GetResume() {
+ t.Fatalf("应先续传,对方没有记录时才从头发:%v", p.a.offers)
+ }
+ })
+ }
+}
+
+func TestConnectedRetryStopsAfterOneAttempt(t *testing.T) {
+ p := newPair(t)
+ p.a.mu.Lock()
+ p.a.blockOut = true
+ p.a.mu.Unlock()
+ path := filepath.Join(t.TempDir(), "retry.txt")
+ writeFile(t, path, []byte("retry"))
+ tr, err := p.a.eng.SendFiles("bob", []string{path}, false)
+ if err != nil {
+ t.Fatal(err)
+ }
+ waitFor(t, 10*time.Second, func() bool {
+ got, err := p.a.db.GetTransfer(tr.GetId())
+ return err == nil && got.Status == store.TransferInterrupted && got.Attempt == 2
+ })
+ time.Sleep(3500 * time.Millisecond)
+ p.a.mu.Lock()
+ defer p.a.mu.Unlock()
+ if len(p.a.offers) != 2 {
+ t.Fatalf("持续失败不应循环重试:%d", len(p.a.offers))
+ }
+}
+
+func TestCancelDuringConnectedRetry(t *testing.T) {
+ p := newPair(t)
+ p.a.mu.Lock()
+ p.a.blockOut = true
+ p.a.mu.Unlock()
+ path := filepath.Join(t.TempDir(), "cancel.txt")
+ writeFile(t, path, []byte("cancel"))
+ tr, err := p.a.eng.SendFiles("bob", []string{path}, false)
+ if err != nil {
+ t.Fatal(err)
+ }
+ waitStatus(t, p.a, tr.GetId(), store.TransferInterrupted)
+ if err := p.a.eng.Cancel(tr.GetId()); err != nil {
+ t.Fatal(err)
+ }
+ time.Sleep(3500 * time.Millisecond)
+ got := waitStatus(t, p.a, tr.GetId(), store.TransferCancelled)
+ if got.Attempt != 1 {
+ t.Fatalf("取消后不应再发:%d", got.Attempt)
+ }
+}
+
func TestResumeAfterInterruption(t *testing.T) {
p := newPair(t)
src := t.TempDir()
diff --git a/design/send-files-lan-tcp.md b/design/send-files-lan-tcp.md
index 6dd662f..0fc52f3 100644
--- a/design/send-files-lan-tcp.md
+++ b/design/send-files-lan-tcp.md
@@ -147,4 +147,4 @@
- 重连后 candidate 对里的本端地址是 127.0.0.1,快速通道没开起来。改为按路由取本机地址(第 2 节)。
- 文件收完但结果丢了时会重发一份(第 5 节)。
-已知问题(2.5.0 就有,与快速通道无关,没有改):发送请求恰好发在对方重启的那一刻、落进了已经断掉的旧连接时,几秒后两边重新连上,这时这一批还在等应答;30 秒后它被标为中断,但已经连着了,不会再自动续传,要手动点「继续」或等下次重连。
+发送请求恰好落进对方重启前的旧连接时,重连通知可能早于应答超时,导致这一批稍后停在「已中断」。2.5.1 已修复:发送工作者发现中断时仍连接着,会等待 3 秒补试一次;持续失败则等下次重连或手动继续,避免循环重试。等待期间取消、手动继续和后台退出优先。TCP 与原数据通道都通过回归测试。