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): recover startup connections and show setup progress

baiyuze167798f78208
diff --git a/client-core/internal/peers/connection_test.go b/client-core/internal/peers/connection_test.go
new file mode 100644
index 0000000..3845280
--- /dev/null
+++ b/client-core/internal/peers/connection_test.go
@@ -0,0 +1,206 @@
+package peers
+
+import (
+ "context"
+ "crypto/ed25519"
+ "errors"
+ "fmt"
+ "path/filepath"
+ "sync/atomic"
+ "testing"
+ "time"
+
+ "github.com/baiyuze/pasteferry/client-core/internal/identity"
+ "github.com/baiyuze/pasteferry/client-core/internal/store"
+ "github.com/baiyuze/pasteferry/client-core/internal/transport/lan"
+ "github.com/baiyuze/pasteferry/client-core/internal/transport/p2p"
+ "github.com/baiyuze/pasteferry/client-core/internal/transport/signed"
+ pb "github.com/baiyuze/pasteferry/proto/gen/pasteferry/v1"
+)
+
+// 已成为好友的一端仍会回复丢失的确认,但不能把对方的回执再无限回复。
+func TestFriendConfirmationDoesNotEcho(t *testing.T) {
+ network := lan.NewMemoryNetwork()
+ a := newDevice(t, "a", network, lanOnly())
+ id, err := identity.LoadOrCreate(filepath.Join(t.TempDir(), "identity.json"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ a.m.mu.Lock()
+ a.m.contacts[id.DeviceID] = store.Contact{ID: id.DeviceID, PublicKey: id.PublicKey}
+ a.m.mu.Unlock()
+ var confirmations atomic.Int32
+ var remote *lan.Transport
+ confirm := func() {
+ msg, err := signed.Sign(id, a.id(), &pb.SignalMessage{Payload: &pb.SignalMessage_FriendConfirm{
+ FriendConfirm: &pb.FriendConfirm{Accepted: true},
+ }})
+ if err == nil {
+ _ = remote.Send(a.id(), msg)
+ }
+ }
+ remote = lan.New(lan.Options{
+ Identity: id, Port: -1, Discovery: network.Discovery(),
+ Peers: func() []string { return []string{a.id()} },
+ Verifier: signed.NewVerifier(id.DeviceID, func(peer string) ed25519.PublicKey {
+ if peer == a.id() {
+ return a.m.identity.PublicKey
+ }
+ return nil
+ }),
+ OnSignal: func(_ string, msg *pb.SignalMessage) {
+ if msg.GetFriendConfirm().GetAccepted() {
+ confirmations.Add(1)
+ confirm() // 模拟对端收到确认后发回确认的旧行为。
+ }
+ },
+ })
+ if err := remote.Start(); err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(remote.Stop)
+ waitLANUp(t, a)
+ a.m.lan.Remember(id.DeviceID, []string{fmt.Sprintf("127.0.0.1:%d", remote.Port())})
+ remote.Remember(a.id(), []string{fmt.Sprintf("127.0.0.1:%d", a.m.lan.Port())})
+ waitFor(t, "双向局域网可达", func() bool {
+ return a.m.lan.Reachable(id.DeviceID) && remote.Reachable(a.id())
+ })
+ confirm()
+ waitFor(t, "收到确认回复", func() bool { return confirmations.Load() > 0 })
+ time.Sleep(300 * time.Millisecond)
+ if got := confirmations.Load(); got != 1 {
+ t.Fatalf("确认回执循环了 %d 次", got)
+ }
+ // 对端可能丢失了第一次回复;它稍后重试时仍然能得到确认。
+ time.Sleep(time.Second)
+ confirm()
+ waitFor(t, "重试确认得到回复", func() bool { return confirmations.Load() > 1 })
+ time.Sleep(300 * time.Millisecond)
+ if got := confirmations.Load(); got != 2 {
+ t.Fatalf("重试后确认回执循环了 %d 次", got)
+ }
+}
+
+func TestFriendConnectionRecovery(t *testing.T) {
+ for _, trigger := range []string{"manual", "patrol", "restart", "presence", "lan"} {
+ t.Run(trigger, func(t *testing.T) {
+ network := lan.NewMemoryNetwork()
+ a, events := newFriendDevice(t, "a", network, lanOnly())
+ b, _ := newFriendDevice(t, "b", network, lanOnly())
+ waitLANUp(t, a, b)
+ addFriends(t, a, b, events)
+ waitDirect(t, a, b)
+ // 只让应答方触发恢复,验证它能请发起方重新发 offer。
+ if a.id() < b.id() {
+ a, b = b, a
+ }
+ a.m.P2P().Disconnect(b.id())
+ b.m.P2P().Disconnect(a.id())
+ a.m.touch(b.id())
+ switch trigger {
+ case "manual":
+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ defer cancel()
+ kind, err := a.m.Reconnect(ctx, b.id())
+ if err != nil || kind != pb.ConnectionKind_CONNECTION_KIND_DIRECT {
+ t.Fatalf("好友重新连接: kind=%v err=%v", kind, err)
+ }
+ case "patrol":
+ a.m.connectPending(context.Background())
+ case "restart":
+ a.m.handlePeerRestarted(b.id())
+ case "presence":
+ a.m.handlePresence(b.id(), true)
+ case "lan":
+ a.m.handleLANReachable(b.id(), true)
+ }
+ waitDirect(t, a, b)
+
+ // 有意空闲断开的好友不能被巡检反复拉起。
+ a.m.P2P().Disconnect(b.id())
+ b.m.P2P().Disconnect(a.id())
+ a.m.mu.Lock()
+ a.m.lastUse[b.id()] = time.Now().Add(-2 * friendIdle)
+ a.m.mu.Unlock()
+ a.m.connectPending(context.Background())
+ time.Sleep(100 * time.Millisecond)
+ if got := a.m.P2P().State(b.id()); got != p2p.StateOffline {
+ t.Fatalf("空闲好友被巡检重新连上: %v", got)
+ }
+ })
+ }
+}
+
+func TestReconnectRejectsUnknownDevice(t *testing.T) {
+ a := newDevice(t, "a", nil, lanOnly())
+ if _, err := a.m.Reconnect(context.Background(), "unknown"); !errors.Is(err, ErrNotPaired) {
+ t.Fatalf("不应连接陌生的设备 ID: %v", err)
+ }
+}
+
+func TestFeaturesAcrossConnectionTransitions(t *testing.T) {
+ for _, role := range []string{RoleSelf, RoleFriend} {
+ t.Run(role, func(t *testing.T) {
+ cfg := lanOnly()
+ cfg.LANDisabled = true
+ a := newDevice(t, "a", nil, cfg)
+ const id = "peer"
+ a.m.mu.Lock()
+ if role == RoleSelf {
+ d := store.Device{ID: id, Name: id, Platform: "windows", PublicKey: make([]byte, 32)}
+ if err := a.m.store.PutDevice(d); err != nil {
+ t.Fatal(err)
+ }
+ a.m.known[id] = d
+ } else {
+ a.m.contacts[id] = store.Contact{ID: id, Platform: "windows", PublicKey: make([]byte, 32)}
+ }
+ a.m.serverOnline[id] = true
+ a.m.mu.Unlock()
+ snapshot := func() (known, receives bool) {
+ if role == RoleSelf {
+ d := peerDevice(t, a, id)
+ return d.GetFeaturesKnown(), d.GetReceivesFiles()
+ }
+ f, _ := a.m.Friend(id)
+ return f.GetFeaturesKnown(), f.GetReceivesFiles()
+ }
+
+ a.m.handleP2PState(id, p2p.StateConnecting)
+ firstEpoch := a.m.connectionEpoch[id]
+ // 远端消息可早于本地的就绪回调到达。
+ a.m.updatePeerFeatures(id, &pb.PeerFeatures{Features: []string{FeatureSendFiles, FeatureSendAsk}, AppVersion: "2.8.1"})
+ a.m.handleP2PState(id, p2p.StateDirect)
+ a.m.checkLegacy(id, firstEpoch)
+ if known, receives := snapshot(); !known || !receives {
+ t.Fatal("早到的现代版本声明被就绪回调清除了")
+ }
+
+ a.m.handleP2PState(id, p2p.StateOffline)
+ a.m.handleP2PState(id, p2p.StateConnecting)
+ a.m.handleP2PState(id, p2p.StateDirect)
+ a.m.checkLegacy(id, firstEpoch)
+ if _, receives := snapshot(); !receives {
+ t.Fatal("上一轮连接的计时器影响了新连接")
+ }
+ // 本轮真的一直没有声明,才会判定旧版本。
+ a.m.checkLegacy(id, a.m.connectionEpoch[id])
+ if known, receives := snapshot(); !known || receives {
+ t.Fatal("未识别出已连通但不声明功能的旧版本")
+ }
+ a.m.handleP2PState(id, p2p.StateOffline)
+ a.m.handleP2PState(id, p2p.StateConnecting)
+ if known, _ := snapshot(); known {
+ t.Fatal("重新连接期间仍沿用了旧版本判定")
+ }
+
+ // 显式声明不支持之后,下一轮连接也要重新确认。
+ a.m.updatePeerFeatures(id, &pb.PeerFeatures{AppVersion: "2.4.0"})
+ a.m.handleP2PState(id, p2p.StateDirect)
+ a.m.handleP2PState(id, p2p.StateOffline)
+ if known, _ := snapshot(); known {
+ t.Fatal("断线后仍把旧的负面声明当作当前能力")
+ }
+ })
+ }
+}
diff --git a/client-core/internal/peers/friends.go b/client-core/internal/peers/friends.go
index 493bef9..440a711 100644
--- a/client-core/internal/peers/friends.go
+++ b/client-core/internal/peers/friends.go
@@ -676,6 +676,11 @@ func (m *Manager) handleFriendConfirm(from string, c *pb.FriendConfirm) {
}
}
_, isFriend := m.contacts[from]
+ reply := p == nil && isFriend && c.GetAccepted() &&
+ !connected(m.conn[from]) && time.Since(m.confirmReplyAt[from]) >= time.Second
+ if reply {
+ m.confirmReplyAt[from] = time.Now()
+ }
if p != nil {
if c.GetAccepted() {
p.peerDecision = 1
@@ -685,8 +690,8 @@ func (m *Manager) handleFriendConfirm(from string, c *pb.FriendConfirm) {
}
m.mu.Unlock()
switch {
- case p == nil && isFriend && c.GetAccepted():
- // 本端已经成为好友了,对方还没收到本端的确认
+ case reply:
+ // 对方可能还没收到本端的确认;连通前短时间内只回一次,连通后停止,避免回执循环。
go m.sendConfirm(from, true, 1)
case p != nil && !c.GetAccepted():
m.log.Info("对方没有添加好友", "peer", from)
@@ -898,6 +903,7 @@ func (m *Manager) RemoveFriend(ctx context.Context, id string) error {
c, ok := m.contacts[id]
if ok {
delete(m.contacts, id)
+ delete(m.confirmReplyAt, id)
delete(m.features, id)
m.notices[id] = c.PublicKey
}
@@ -977,6 +983,7 @@ func (m *Manager) handleFriendRemove(from string, r *pb.FriendRemove) {
_, isFriend := m.contacts[from]
if isFriend {
delete(m.contacts, from)
+ delete(m.confirmReplyAt, from)
delete(m.features, from)
}
m.mu.Unlock()
diff --git a/client-core/internal/peers/manager.go b/client-core/internal/peers/manager.go
index e8748b2..b3b524a 100644
--- a/client-core/internal/peers/manager.go
+++ b/client-core/internal/peers/manager.go
@@ -111,6 +111,8 @@ type Manager struct {
// declared 记下本次连接里对端是否发过声明;legacy 是连上 legacyWait 后仍没声明、判定为旧版本的设备
declared map[string]bool
legacy map[string]bool
+ // connectionEpoch 让上一轮连接的延迟检查不能影响刚重建的连接。
+ connectionEpoch map[string]uint64
// appVersion 是本机的版本号,随功能声明发给对端
appVersion string
// sendFiles 报告本机有没有隔空传送,见 Options.SendFiles
@@ -120,6 +122,8 @@ type Manager struct {
// 好友(对方的一台电脑),见 friends.go
contacts map[string]store.Contact
+ // 已成为好友后回复确认的时间;避免两端把确认回执互相无限回发。
+ confirmReplyAt map[string]time.Time
// 「所有人」模式下认识的陌生设备,只在内存里
strangers map[string]store.Contact
// 删除了好友、还没告诉对方的:设备 ID → 对方公钥(验对方回执的签名)
@@ -222,9 +226,11 @@ func NewManager(opts Options) (*Manager, error) {
peerVersion: make(map[string]string),
declared: make(map[string]bool),
legacy: make(map[string]bool),
+ connectionEpoch: make(map[string]uint64),
appVersion: opts.AppVersion,
sendFiles: opts.SendFiles,
contacts: make(map[string]store.Contact),
+ confirmReplyAt: make(map[string]time.Time),
strangers: make(map[string]store.Contact),
notices: make(map[string][]byte),
lastUse: make(map[string]time.Time),
@@ -437,16 +443,26 @@ func (m *Manager) reconnectLoop(ctx context.Context) {
func (m *Manager) connectPending(ctx context.Context) {
m.mu.RLock()
var candidates []string
+ now := time.Now()
for id := range m.known {
if m.isOnlineLocked(id) && m.p2p.State(id) == p2p.StateOffline {
candidates = append(candidates, id)
}
}
+ for _, others := range []map[string]store.Contact{m.contacts, m.strangers} {
+ for id := range others {
+ // 失败的握手、刚断掉的连接继续重试;已经空闲断开的好友不常连。
+ if m.isOnlineLocked(id) && m.p2p.State(id) == p2p.StateOffline &&
+ (now.Sub(m.lastUse[id]) < friendIdle || (m.inUse != nil && m.inUse(id))) {
+ candidates = append(candidates, id)
+ }
+ }
+ }
m.mu.RUnlock()
for _, id := range candidates {
connectCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
- if err := m.p2p.Connect(connectCtx, id); err != nil {
+ if err := m.p2p.RetryDirect(connectCtx, id); err != nil {
m.log.Debug("重连失败,稍后重试", "device", id, "err", err)
}
cancel()
@@ -547,6 +563,7 @@ func (m *Manager) updatePeerFeatures(id string, f *pb.PeerFeatures) {
sort.Strings(names)
m.mu.Lock()
role := m.roleLocked(id)
+ reply := role != "" && !m.declared[id] && !m.noFeatures
if role != "" {
m.features[id] = set
m.peerVersion[id] = version
@@ -575,26 +592,42 @@ func (m *Manager) updatePeerFeatures(id string, f *pb.PeerFeatures) {
m.notify(d)
}
m.notifyFriend(id)
+ // 首次收到声明时回一份,补救本端声明早到或切换连接时的丢失。
+ if reply {
+ _ = m.p2p.Send(id, m.featuresFor(role))
+ }
}
// checkLegacy 在连上 legacyWait 之后检查对端发过功能声明没有:
// 还连着却一直没发,说明是不认识声明的旧版本。
-func (m *Manager) checkLegacy(id string) {
+func (m *Manager) checkLegacy(id string, epoch uint64) {
m.mu.Lock()
- ok := m.roleLocked(id) != ""
- isLegacy := ok && connected(m.conn[id]) && !m.declared[id]
+ role := m.roleLocked(id)
+ isLegacy := role != "" && m.connectionEpoch[id] == epoch && connected(m.conn[id]) && !m.declared[id]
+ c := m.contacts[id]
if isLegacy {
m.legacy[id] = true
// 上次存下的声明不再可信(对方装回了旧版本)
delete(m.features, id)
delete(m.peerVersion, id)
+ if role == RoleFriend {
+ c.Features, c.AppVersion = nil, ""
+ m.contacts[id] = c
+ }
}
m.mu.Unlock()
if !isLegacy {
return
}
- if err := m.store.SetDeviceFeatures(id, nil, ""); err != nil {
- m.log.Warn("清除对端功能声明失败", "device", id, "err", err)
+ switch role {
+ case RoleSelf:
+ if err := m.store.SetDeviceFeatures(id, nil, ""); err != nil {
+ m.log.Warn("清除对端功能声明失败", "device", id, "err", err)
+ }
+ case RoleFriend:
+ if err := m.store.PutContact(c); err != nil {
+ m.log.Warn("清除好友功能声明失败", "device", id, "err", err)
+ }
}
if d, ok := m.device(id); ok {
m.notify(d)
@@ -635,6 +668,14 @@ func (m *Manager) HasFeature(deviceID, feature string) bool {
return m.features[deviceID][feature]
}
+// FeaturesKnown 报告是否已经知道对端的功能;尚未声明与明确不支持是两种状态。
+func (m *Manager) FeaturesKnown(deviceID string) bool {
+ m.mu.RLock()
+ defer m.mu.RUnlock()
+ _, declared := m.features[deviceID]
+ return declared || m.legacy[deviceID]
+}
+
// ConnState 返回与某台设备的 P2P 连接状态。
func (m *Manager) ConnState(deviceID string) p2p.ConnState { return m.p2p.State(deviceID) }
@@ -786,12 +827,14 @@ func (m *Manager) handlePeerRestarted(deviceID string) {
// connectIfOffline 在对端上线时建立 P2P 通道,这样真正要传数据时已经就绪。
// 谁发起由 p2p.Manager 内部按 device_id 字典序决定,这里无脑调用即可。
func (m *Manager) connectIfOffline(deviceID string) {
- m.mu.RLock()
- _, paired := m.known[deviceID]
- m.mu.RUnlock()
- if !paired {
+ role := m.Role(deviceID)
+ if role == "" {
return
}
+ if role != RoleSelf {
+ // 上线或重启后交换一次名片与功能声明,并为失败的握手保留重试窗口。
+ m.touch(deviceID)
+ }
go func() {
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
@@ -801,7 +844,7 @@ func (m *Manager) connectIfOffline(deviceID string) {
if m.p2p.State(deviceID) != p2p.StateOffline {
return
}
- if err := m.p2p.Connect(ctx, deviceID); err != nil {
+ if err := m.p2p.RetryDirect(ctx, deviceID); err != nil {
m.log.Warn("建立 P2P 连接失败", "device", deviceID, "err", err)
}
}()
@@ -906,8 +949,20 @@ func (m *Manager) handleP2PState(deviceID string, state p2p.ConnState) {
prev := m.conn[deviceID]
m.conn[deviceID] = state
role := m.roleLocked(deviceID)
+ if state != prev && (state == p2p.StateOffline || state == p2p.StateConnecting) {
+ m.connectionEpoch[deviceID]++
+ delete(m.declared, deviceID)
+ delete(m.legacy, deviceID)
+ // 连接恢复前,旧的「不能接收」不再作为更新依据;已知能接收的声明仍可用于排队发送。
+ f := m.features[deviceID]
+ if !ReceivesSendFiles(f, m.platformLocked(deviceID)) || (role != RoleSelf && !f[FeatureSendAsk]) {
+ delete(m.features, deviceID)
+ delete(m.peerVersion, deviceID)
+ }
+ }
+ epoch := m.connectionEpoch[deviceID]
if connected(state) && !connected(prev) {
- m.declared[deviceID] = false
+ // 功能声明可能早于这个就绪回调到达,不能在这里把它重置。
m.lastUse[deviceID] = time.Now()
}
m.mu.Unlock()
@@ -921,7 +976,7 @@ func (m *Manager) handleP2PState(deviceID string, state p2p.ConnState) {
if !m.noFeatures {
_ = m.p2p.Send(deviceID, m.featuresFor(role))
}
- time.AfterFunc(legacyWait, func() { m.checkLegacy(deviceID) })
+ time.AfterFunc(legacyWait, func() { m.checkLegacy(deviceID, epoch) })
}
m.log.Info("P2P 连接状态", "device", deviceID, "state", state)
@@ -1518,12 +1573,13 @@ const reconnectWait = 15 * time.Second
// (局域网里打招呼、信令服务器断着的马上重连),找到就发起连接;走中转的马上再试一次直连,
// 打不通照旧走中转。直连了就立即返回,否则最多等 reconnectWait,返回那时的连接状态。
func (m *Manager) Reconnect(ctx context.Context, deviceID string) (pb.ConnectionKind, error) {
- m.mu.RLock()
- _, ok := m.known[deviceID]
- m.mu.RUnlock()
- if !ok {
+ role := m.Role(deviceID)
+ if role == "" {
return pb.ConnectionKind_CONNECTION_KIND_UNSPECIFIED, ErrNotPaired
}
+ if role != RoleSelf {
+ m.touch(deviceID)
+ }
if m.p2p.State(deviceID) == p2p.StateDirect {
return pb.ConnectionKind_CONNECTION_KIND_DIRECT, nil
}
diff --git a/client-core/internal/peers/manager_test.go b/client-core/internal/peers/manager_test.go
index 52713e8..3cc5be4 100644
--- a/client-core/internal/peers/manager_test.go
+++ b/client-core/internal/peers/manager_test.go
@@ -535,7 +535,7 @@ func TestFeaturesUnknownWhileNotConnected(t *testing.T) {
a.m.known[peer.ID] = peer
a.m.serverOnline[peer.ID] = true
a.m.mu.Unlock()
- a.m.checkLegacy(peer.ID)
+ a.m.checkLegacy(peer.ID, 0)
dev := peerDevice(t, a, peer.ID)
if !dev.GetOnline() || dev.GetFeaturesKnown() || dev.GetReceivesFiles() {
t.Fatalf("没连上就判定了功能: %v", dev)
diff --git a/client-core/internal/rpc/send.go b/client-core/internal/rpc/send.go
index fc8c21e..7522b25 100644
--- a/client-core/internal/rpc/send.go
+++ b/client-core/internal/rpc/send.go
@@ -41,7 +41,7 @@ func transferError(err error) error {
return status.Error(codes.InvalidArgument, err.Error())
case errors.Is(err, send.ErrNotFound), errors.Is(err, send.ErrUnknownDevice):
return status.Error(codes.NotFound, err.Error())
- case errors.Is(err, send.ErrOffline), errors.Is(err, send.ErrUnsupported), errors.Is(err, send.ErrPeerDisabled),
+ case errors.Is(err, send.ErrOffline), errors.Is(err, send.ErrConnecting), errors.Is(err, send.ErrUnsupported), errors.Is(err, send.ErrPeerDisabled),
errors.Is(err, send.ErrNeedRelayConsent), errors.Is(err, send.ErrNotResumable):
return status.Error(codes.FailedPrecondition, err.Error())
}
diff --git a/client-core/internal/rpc/send_test.go b/client-core/internal/rpc/send_test.go
new file mode 100644
index 0000000..197e247
--- /dev/null
+++ b/client-core/internal/rpc/send_test.go
@@ -0,0 +1,16 @@
+package rpc
+
+import (
+ "testing"
+
+ "github.com/baiyuze/pasteferry/client-core/internal/send"
+ "google.golang.org/grpc/codes"
+ "google.golang.org/grpc/status"
+)
+
+func TestConnectingTransferError(t *testing.T) {
+ s := status.Convert(transferError(send.ErrConnecting))
+ if s.Code() != codes.FailedPrecondition || s.Message() != "connecting" {
+ t.Fatalf("连接中不能变成不支持或内部错误: %v", s)
+ }
+}
diff --git a/client-core/internal/send/outgoing.go b/client-core/internal/send/outgoing.go
index 05e79bd..884dfbe 100644
--- a/client-core/internal/send/outgoing.go
+++ b/client-core/internal/send/outgoing.go
@@ -53,6 +53,11 @@ func (e *Engine) SendFiles(deviceID string, paths []string, allowRelay bool, not
return nil, ErrUnknownDevice
case !p.Online:
return nil, ErrOffline
+ case p.Connecting && (!p.Supported || other && !p.Ask):
+ if e.opts.Connect != nil {
+ go e.opts.Connect(deviceID)
+ }
+ return nil, ErrConnecting
case !p.Supported, other && !p.Ask:
// 旧版本收到会直接接收,绕过对方用户的确认,所以不发
return nil, ErrUnsupported
diff --git a/client-core/internal/send/send.go b/client-core/internal/send/send.go
index afdc4ef..bf816dd 100644
--- a/client-core/internal/send/send.go
+++ b/client-core/internal/send/send.go
@@ -32,6 +32,7 @@ import (
var (
ErrUnknownDevice = errors.New("unknown_device")
ErrOffline = errors.New("offline")
+ ErrConnecting = errors.New("connecting")
ErrUnsupported = errors.New("unsupported")
ErrPeerDisabled = errors.New("disabled")
ErrNeedRelayConsent = errors.New("relay")
@@ -89,12 +90,13 @@ type Peer struct {
// Role 是对方的角色:store.RoleSelf / RoleFriend / RoleStranger
Role string
// Ask 表示对方能等它的用户接受(声明了 send_files_ask_v1)。发给好友、陌生设备时必须有
- Ask bool
- Online bool
- Connected bool // P2P 连接已建立
- Relayed bool // 连接经中转
- Supported bool // 对方声明能接收隔空传送
- Disabled bool // 对方关闭了接收
+ Ask bool
+ Online bool
+ Connected bool // P2P 连接已建立
+ Connecting bool // 尚未连通或尚未确认接收能力,不能据此提示版本过旧
+ Relayed bool // 连接经中转
+ Supported bool // 对方声明能接收隔空传送
+ Disabled bool // 对方关闭了接收
}
// NoticeKind 是要发给用户的系统通知。
diff --git a/client-core/internal/send/send_test.go b/client-core/internal/send/send_test.go
index 88a54be..9d14192 100644
--- a/client-core/internal/send/send_test.go
+++ b/client-core/internal/send/send_test.go
@@ -576,7 +576,8 @@ func TestRefusesPeersThatCannotReceive(t *testing.T) {
want error
}{
{"旧版本", func() {}, ErrUnsupported},
- {"关闭了接收", func() { peer.Supported, peer.Disabled = true, true }, ErrPeerDisabled},
+ {"还没连上", func() { peer.Connecting = true }, ErrConnecting},
+ {"关闭了接收", func() { peer.Connecting = false; peer.Supported, peer.Disabled = true, true }, ErrPeerDisabled},
{"离线", func() { peer.Disabled, peer.Online = false, false }, ErrOffline},
{"没配对", func() { peer.Known = false }, ErrUnknownDevice},
}
diff --git a/client-core/internal/sendpeer/peer.go b/client-core/internal/sendpeer/peer.go
index b1e3ac4..c3acbe2 100644
--- a/client-core/internal/sendpeer/peer.go
+++ b/client-core/internal/sendpeer/peer.go
@@ -23,7 +23,8 @@ func Peer(peerMgr *peers.Manager, deviceID string) send.Peer {
return send.Peer{
Known: true, Name: d.GetName(), Online: d.GetOnline(), Role: peers.RoleSelf,
Connected: connected, Relayed: relayed,
- Supported: d.GetReceivesFiles(), Disabled: d.GetReceiveDisabled(),
+ Connecting: !connected || !d.GetFeaturesKnown(),
+ Supported: d.GetReceivesFiles(), Disabled: d.GetReceiveDisabled(),
Ask: peerMgr.HasFeature(deviceID, peers.FeatureSendAsk),
}
}
@@ -37,7 +38,8 @@ func Peer(peerMgr *peers.Manager, deviceID string) send.Peer {
return send.Peer{
Known: true, Name: name, Online: fr.GetOnline(), Role: peers.RoleFriend,
Connected: connected, Relayed: relayed,
- Supported: fr.GetReceivesFiles() || fr.GetReceiveDisabled(), Disabled: fr.GetReceiveDisabled(),
+ Connecting: !connected || !fr.GetFeaturesKnown(),
+ Supported: fr.GetReceivesFiles() || fr.GetReceiveDisabled(), Disabled: fr.GetReceiveDisabled(),
Ask: peerMgr.HasFeature(deviceID, peers.FeatureSendAsk),
}
}
@@ -46,9 +48,10 @@ func Peer(peerMgr *peers.Manager, deviceID string) send.Peer {
return send.Peer{
Known: true, Name: st.GetDisplayName(), Online: true, Role: peers.RoleStranger,
Connected: connected, Relayed: relayed,
- Supported: peerMgr.HasFeature(deviceID, peers.FeatureSendFiles) || peerMgr.HasFeature(deviceID, peers.FeatureSendFilesOff),
- Disabled: peerMgr.HasFeature(deviceID, peers.FeatureSendFilesOff),
- Ask: peerMgr.HasFeature(deviceID, peers.FeatureSendAsk),
+ Connecting: !connected || !peerMgr.FeaturesKnown(deviceID),
+ Supported: peerMgr.HasFeature(deviceID, peers.FeatureSendFiles) || peerMgr.HasFeature(deviceID, peers.FeatureSendFilesOff),
+ Disabled: peerMgr.HasFeature(deviceID, peers.FeatureSendFilesOff),
+ Ask: peerMgr.HasFeature(deviceID, peers.FeatureSendAsk),
}
}
}
diff --git a/client-core/internal/transport/lan/lan.go b/client-core/internal/transport/lan/lan.go
index 60362c2..169d609 100644
--- a/client-core/internal/transport/lan/lan.go
+++ b/client-core/internal/transport/lan/lan.go
@@ -900,7 +900,17 @@ func (t *Transport) updateAdvert() {
text := t.advertTextLocked()
t.mu.Unlock()
if err := t.discovery.Update(text); err != nil {
- t.log.Debug("更新局域网广播失败", "err", err)
+ // Windows 更新广播会先注销旧记录,重新注册暂时失败后就完全不可见。
+ // 与启动失败一样重试,不能一直等到下一次换网或重启软件。
+ t.mu.Lock()
+ first := t.running && t.discoveryRetry.IsZero()
+ if first {
+ t.discoveryRetry = time.Now().Add(discoveryRetryEvery)
+ }
+ t.mu.Unlock()
+ if first {
+ t.log.Warn("更新局域网广播失败,稍后重试", "err", err)
+ }
}
}
diff --git a/client-core/internal/transport/lan/startup_test.go b/client-core/internal/transport/lan/startup_test.go
new file mode 100644
index 0000000..b45a2ff
--- /dev/null
+++ b/client-core/internal/transport/lan/startup_test.go
@@ -0,0 +1,47 @@
+package lan
+
+import (
+ "errors"
+ "sync/atomic"
+ "testing"
+ "time"
+)
+
+type lostAdvertDiscovery struct {
+ countingDiscovery
+ updates atomic.Int32
+}
+
+func (d *lostAdvertDiscovery) Update(text map[string]string) error {
+ if d.updates.Add(1) == 1 {
+ // Windows replaces DNS-SD records by unregistering first. If the
+ // subsequent registration fails, the previous advert is also gone.
+ d.Discovery.Stop()
+ return errors.New("temporary DNS-SD registration failure")
+ }
+ return d.Discovery.Update(text)
+}
+
+func TestDiscoveryRecoversAfterAdvertUpdateFailure(t *testing.T) {
+ network := NewMemoryNetwork()
+ d := &lostAdvertDiscovery{countingDiscovery: countingDiscovery{Discovery: network.Discovery()}}
+ n := newNodeWith(t, d)
+ observer := newNode(t, network)
+ n.t.ShowEveryone("new Windows PC", "windows")
+ deadline := time.Now().Add(4 * time.Second)
+ for {
+ if found := observer.t.Strangers(); len(found) == 1 && found[0].Name == "new Windows PC" {
+ return
+ }
+ if time.Now().After(deadline) {
+ t.Fatal("device remained undiscoverable after a temporary advert update failure")
+ }
+ // Advance an existing retry deadline without waiting for its backoff.
+ n.t.mu.Lock()
+ if !n.t.discoveryRetry.IsZero() {
+ n.t.discoveryRetry = time.Now()
+ }
+ n.t.mu.Unlock()
+ time.Sleep(20 * time.Millisecond)
+ }
+}
diff --git a/client-core/internal/transport/p2p/peer.go b/client-core/internal/transport/p2p/peer.go
index f9eae6a..c0c7ffe 100644
--- a/client-core/internal/transport/p2p/peer.go
+++ b/client-core/internal/transport/p2p/peer.go
@@ -292,15 +292,19 @@ func (p *Peer) setState(s ConnState) {
p.mu.Unlock()
if changed {
- p.log.Debug("连接状态变化", "state", s)
- if p.onState != nil {
- p.onState(s)
- }
+ p.notifyState(s)
+ }
+}
+
+func (p *Peer) notifyState(s ConnState) {
+ p.log.Debug("连接状态变化", "state", s)
+ if p.onState != nil {
+ p.onState(s)
}
}
// Connect 主动发起连接。已在连接中或已连通时直接返回。
-func (p *Peer) Connect(ctx context.Context) error {
+func (p *Peer) Connect(ctx context.Context) (err error) {
// 必须在同一个临界区里完成"检查 + 占位"。
//
// 否则两个 goroutine(配对确认与上线通知常常同时触发)都会看到
@@ -325,6 +329,13 @@ func (p *Peer) Connect(ctx context.Context) error {
if err != nil {
return err
}
+ defer func() {
+ if err != nil {
+ // CreateOffer 等准备步骤也可能遇到暂时的网络错误。
+ // 此时还没有握手超时计时器,留下 pc 会让以后每次 Connect 都跳过。
+ p.closeConnection(pc)
+ }
+ }()
// 发起方创建控制通道;应答方靠 OnDataChannel 拿到它
ordered := true
@@ -363,7 +374,6 @@ func (p *Peer) Connect(ctx context.Context) error {
if err := p.sendSignal(ctx, offerMessage(offer, false)); err != nil {
// offer 根本没发出去(信令无路可走),对方不可能应答:立即复位。
// 通道一恢复上层就能重试,不必等握手超时
- p.Close()
return err
}
// 初次握手由发起方等:应答方先公布出口地址,发起方先往那边发包
@@ -567,7 +577,7 @@ func (p *Peer) HandleSignal(ctx context.Context, msg *pb.SignalMessage) error {
}
}
-func (p *Peer) handleOffer(ctx context.Context, offer *pb.SdpOffer) error {
+func (p *Peer) handleOffer(ctx context.Context, offer *pb.SdpOffer) (err error) {
p.mu.Lock()
pc := p.pc
polite := p.polite
@@ -588,6 +598,11 @@ func (p *Peer) handleOffer(ctx context.Context, offer *pb.SdpOffer) error {
making = false
}
p.mu.Unlock()
+ defer func() {
+ if err != nil && !restart && pc != nil {
+ p.closeConnection(pc)
+ }
+ }()
p.holdCandidates()
defer p.releaseCandidates()
@@ -833,7 +848,7 @@ func (p *Peer) newPeerConnection() (*webrtc.PeerConnection, error) {
// 留着的话 Connect 以为连接还在、不会重建;控制通道看上去仍是打开的,
// 发出的消息石沉大海
p.log.Warn("连接已失效,关闭以便重连", "state", s)
- p.Close()
+ p.closeConnection(pc)
case webrtc.PeerConnectionStateDisconnected:
// 断开可能是暂时的(网络抖动),pion 会继续检测,恢复不了时转为失败
p.setState(StateOffline)
@@ -1161,10 +1176,24 @@ func (p *Peer) OpenStream(label string) (*webrtc.DataChannel, error) {
}
func (p *Peer) Close() {
+ p.closeConnection(nil)
+}
+
+// closeConnection 只清理本次握手的连接;迟到的错误不能关闭随后建立的新连接。
+// pc 为空时无条件关闭(用户主动断开)。
+func (p *Peer) closeConnection(pc *webrtc.PeerConnection) {
p.mu.Lock()
+ if pc != nil && p.pc != pc {
+ p.mu.Unlock()
+ return
+ }
+ changed := p.state != StateOffline
p.closeLocked()
+ p.state = StateOffline
p.mu.Unlock()
- p.setState(StateOffline)
+ if changed {
+ p.notifyState(StateOffline)
+ }
}
func (p *Peer) closeLocked() {
diff --git a/client-core/internal/transport/p2p/startup_test.go b/client-core/internal/transport/p2p/startup_test.go
new file mode 100644
index 0000000..0aaa057
--- /dev/null
+++ b/client-core/internal/transport/p2p/startup_test.go
@@ -0,0 +1,70 @@
+package p2p
+
+import (
+ "context"
+ "errors"
+ "sync/atomic"
+ "testing"
+ "time"
+
+ "github.com/pion/transport/v5"
+ "github.com/pion/transport/v5/stdnet"
+
+ pb "github.com/baiyuze/pasteferry/proto/gen/pasteferry/v1"
+)
+
+var errNetworkStarting = errors.New("network interfaces are not ready")
+
+type startingNet struct {
+ transport.Net
+ ready atomic.Bool
+}
+
+func (n *startingNet) Interfaces() ([]*transport.Interface, error) {
+ if !n.ready.Load() {
+ return nil, errNetworkStarting
+ }
+ return n.Net.Interfaces()
+}
+
+// An interface enumeration failure during CreateOffer must not leave an
+// offline PeerConnection that makes every later Connect silently do nothing.
+func TestConnectRecoversFromStartupNetworkError(t *testing.T) {
+ network, err := stdnet.NewNet()
+ if err != nil {
+ t.Fatal(err)
+ }
+ n := &startingNet{Net: network}
+ bus := &signalBus{targets: map[string]*Manager{}}
+ alice := newTestNode(t, bus, "alice")
+ bob := newTestNode(t, bus, "bob")
+ p, err := NewPeer(PeerOptions{
+ SelfID: "alice", DeviceID: "bob", Net: n,
+ SendSignal: func(ctx context.Context, msg *pb.SignalMessage) error {
+ return bus.send("alice")(ctx, "bob", msg)
+ },
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ alice.m.mu.Lock()
+ alice.m.peers["bob"] = p
+ alice.m.mu.Unlock()
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+ defer cancel()
+ if err := alice.m.RetryDirect(ctx, "bob"); !errors.Is(err, errNetworkStarting) {
+ t.Fatalf("initial Connect = %v, want temporary network error", err)
+ }
+ n.ready.Store(true)
+ if err := alice.m.RetryDirect(ctx, "bob"); err != nil {
+ t.Fatalf("Connect after network recovery: %v", err)
+ }
+ waitState(t, alice, "bob", StateDirect, 10*time.Second)
+ waitState(t, bob, "alice", StateDirect, 10*time.Second)
+ if err := alice.m.Send("bob", &pb.PeerMessage{
+ Payload: &pb.PeerMessage_Fetch{Fetch: &pb.PeerFetch{ClipId: "startup-recovery"}},
+ }); err != nil {
+ t.Fatal(err)
+ }
+ expectMessage(t, bob, "startup-recovery")
+}
diff --git a/client-core/internal/transport/signaling/client.go b/client-core/internal/transport/signaling/client.go
index 83e2666..cc436e0 100644
--- a/client-core/internal/transport/signaling/client.go
+++ b/client-core/internal/transport/signaling/client.go
@@ -62,6 +62,9 @@ type Client struct {
conn *websocket.Conn
url string
connected bool
+ // cancelSession 也覆盖拨号与握手阶段,此时 conn 还没有发布。
+ cancelSession context.CancelFunc
+ urlVersion uint64
// urlChanged 在地址变化(或 Redial)时唤醒正在等待的 Run,立即连接
urlChanged chan struct{}
}
@@ -106,13 +109,18 @@ func New(opts Options) *Client {
// 当前连接会被断开,以便立即切换;地址为空表示不用服务器。
func (c *Client) SetURL(url string) {
c.mu.Lock()
- changed := c.url != url
+ if c.url == url {
+ c.mu.Unlock()
+ return
+ }
c.url = url
+ c.urlVersion++
conn := c.conn
+ cancel := c.cancelSession
c.mu.Unlock()
- if !changed {
- return
+ if cancel != nil {
+ cancel()
}
if conn != nil {
conn.Close(websocket.StatusNormalClosure, "切换服务器")
@@ -194,10 +202,21 @@ func (c *Client) Run(ctx context.Context) {
// session 完成一次完整的连接生命周期。established 表示握手成功过。
func (c *Client) session(ctx context.Context) (established bool, err error) {
- url := c.URL()
+ c.mu.Lock()
+ url, version := c.url, c.urlVersion
if url == "" {
+ c.mu.Unlock()
return false, errors.New("未配置信令服务器地址")
}
+ ctx, cancelSession := context.WithCancel(ctx)
+ c.cancelSession = cancelSession
+ c.mu.Unlock()
+ defer func() {
+ cancelSession()
+ c.mu.Lock()
+ c.cancelSession = nil
+ c.mu.Unlock()
+ }()
dialCtx, cancel := context.WithTimeout(ctx, dialTimeout)
var dialOpts *websocket.DialOptions
@@ -217,6 +236,10 @@ func (c *Client) session(ctx context.Context) (established bool, err error) {
}
c.mu.Lock()
+ if c.urlVersion != version || ctx.Err() != nil {
+ c.mu.Unlock()
+ return false, context.Canceled
+ }
c.conn = conn
c.connected = true
c.mu.Unlock()
diff --git a/client-core/internal/transport/signaling/startup_test.go b/client-core/internal/transport/signaling/startup_test.go
new file mode 100644
index 0000000..cf4fbae
--- /dev/null
+++ b/client-core/internal/transport/signaling/startup_test.go
@@ -0,0 +1,99 @@
+package signaling_test
+
+import (
+ "context"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/coder/websocket"
+ "google.golang.org/protobuf/proto"
+
+ pb "github.com/baiyuze/pasteferry/proto/gen/pasteferry/v1"
+)
+
+// Changing network mode while the initial handshake is pending must cancel
+// that handshake. Otherwise it can keep the client on the old server forever.
+func TestChangeServerDuringStartupHandshake(t *testing.T) {
+ for _, disable := range []bool{false, true} {
+ name := "switch"
+ if disable {
+ name = "disable"
+ }
+ t.Run(name, func(t *testing.T) {
+ accepted := make(chan struct{})
+ closed := make(chan struct{})
+ releaseHello := make(chan struct{})
+ oldServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ conn, err := websocket.Accept(w, r, nil)
+ if err != nil {
+ return
+ }
+ defer conn.CloseNow()
+ defer close(closed)
+ close(accepted)
+ <-releaseHello
+ hello, _ := proto.Marshal(&pb.ServerEnvelope{Payload: &pb.ServerEnvelope_Hello{Hello: &pb.ServerHello{Challenge: []byte("startup")}}})
+ if err := conn.Write(r.Context(), websocket.MessageBinary, hello); err != nil {
+ return
+ }
+ for {
+ if _, _, err := conn.Read(r.Context()); err != nil {
+ return
+ }
+ }
+ }))
+ defer oldServer.Close()
+ url := "ws" + strings.TrimPrefix(oldServer.URL, "http")
+ p := newPeer(t, "startup", url)
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+ stopped := make(chan struct{})
+ go func() {
+ defer close(stopped)
+ p.client.Run(ctx)
+ }()
+ select {
+ case <-accepted:
+ case <-time.After(3 * time.Second):
+ close(releaseHello)
+ t.Fatal("initial WebSocket was not opened")
+ }
+ newURL := ""
+ if !disable {
+ newURL = startServer(t)
+ }
+ p.client.SetURL(newURL)
+ close(releaseHello)
+ select {
+ case <-closed:
+ case <-time.After(3 * time.Second):
+ cancel()
+ t.Fatal("startup handshake stayed on the old server after SetURL")
+ }
+ if disable {
+ if p.client.Connected() {
+ t.Fatal("server connection remained active in LAN-only mode")
+ }
+ } else {
+ waitConnected(t, p)
+ if err := p.client.CreatePairingCode(ctx); err != nil {
+ t.Fatal(err)
+ }
+ select {
+ case <-p.codes:
+ case <-time.After(3 * time.Second):
+ t.Fatal("new server did not receive the pairing request")
+ }
+ }
+ cancel()
+ select {
+ case <-stopped:
+ case <-time.After(3 * time.Second):
+ t.Fatal("client did not stop")
+ }
+ })
+ }
+}
diff --git a/ui/lib/app_state.dart b/ui/lib/app_state.dart
index 57206bb..d248260 100644
--- a/ui/lib/app_state.dart
+++ b/ui/lib/app_state.dart
@@ -21,6 +21,7 @@ typedef PairingCode = ({String code, List<String> addresses});
/// 隔空传送发不出去的原因,后台服务把它写在错误消息里(见 rpc/send.go)。
enum SendFailure {
offline,
+ connecting,
unsupported,
disabled,
needRelayConsent,
@@ -50,15 +51,19 @@ enum PairingFailure {
/// 所有与 daemon 的交互都经过这里:页面只读状态、调方法,不直接碰 gRPC。
/// 这样断线重连、事件合并这些琐事集中在一处,页面代码保持干净。
class AppState extends ChangeNotifier implements RecordDetails {
- AppState({BackgroundService? service, QuickPasteService? quickPasteService})
+ AppState({BackgroundService? service, QuickPasteService? quickPasteService,
+ Future<DaemonConnection> Function()? connectDaemon})
: service = service ?? BackgroundService(),
- quickPasteService = quickPasteService ?? QuickPasteService();
+ quickPasteService = quickPasteService ?? QuickPasteService(),
+ _connectDaemon = connectDaemon ?? DaemonConnection.connect;
final BackgroundService service;
/// Mac 上快捷粘贴窗口的 LaunchAgent,见 quick_paste_service.dart
final QuickPasteService quickPasteService;
+ final Future<DaemonConnection> Function() _connectDaemon;
+
DaemonConnection? _conn;
StreamSubscription<Event>? _events;
Timer? _retry;
@@ -371,7 +376,15 @@ class AppState extends ChangeNotifier implements RecordDetails {
// ─────────────────────────── 连接 ───────────────────────────
- Future<void> connect() => _connectionWork = _connect();
+ Future<void> connect() {
+ final pending = _connectionWork;
+ if (pending != null) return pending;
+ final work = _connect();
+ _connectionWork = work;
+ return work.whenComplete(() {
+ if (identical(_connectionWork, work)) _connectionWork = null;
+ });
+ }
Future<void> _connect() async {
if (_quitting) return;
@@ -380,18 +393,24 @@ class AppState extends ChangeNotifier implements RecordDetails {
await _replaceLegacyService();
try {
- final conn = await DaemonConnection.connect();
+ final conn = await _connectDaemon();
_conn = conn;
- // 首屏需要的数据一次取齐,避免界面分几次闪烁
- final results = await Future.wait([
+ // 配置先到就先显示设置;历史记录或状态查询迟迟不回不能把设置页堵住。
+ final results = await Future.wait<Object>([
conn.client.listHistory(ListHistoryRequest(limit: 200)),
- conn.client.getConfig(Empty()),
+ conn.client.getConfig(Empty()).then((cfg) {
+ if (!_quitting && identical(_conn, conn)) {
+ _config = cfg;
+ notifyListeners();
+ }
+ return cfg;
+ }),
conn.client.getStatus(Empty()),
conn.client.listHistory(
ListHistoryRequest(limit: 500, favorites: true),
),
- ]);
+ ], eagerError: true);
_records
..clear()
@@ -400,7 +419,6 @@ class AppState extends ChangeNotifier implements RecordDetails {
await conn.close();
return;
}
- _config = results[1] as Config;
_status = results[2] as Status;
// 旧版后台服务不认识 favorites,会把复制记录原样返回:只收下真的收藏
_favorites
@@ -408,13 +426,14 @@ class AppState extends ChangeNotifier implements RecordDetails {
..addAll(
(results[3] as ListHistoryResponse).records.where((r) => r.favorite),
);
- await _loadQuickPasteStatus();
-
- await _loadDevices();
- await _loadFriends();
- await _loadWebShare();
- await _loadTransfers();
- await refreshNotificationStatus();
+ await Future.wait([
+ _loadQuickPasteStatus(),
+ _loadDevices(),
+ _loadFriends(),
+ _loadWebShare(),
+ _loadTransfers(),
+ refreshNotificationStatus(),
+ ], eagerError: true);
_events = conn.client
.subscribe(SubscribeRequest())
@@ -472,7 +491,7 @@ class AppState extends ChangeNotifier implements RecordDetails {
Future<void> _refreshServiceState() async {
try {
- _serviceState = await service.state();
+ _serviceState = await service.state().timeout(const Duration(seconds: 5));
} catch (_) {
_serviceState = null;
}
@@ -626,7 +645,8 @@ class AppState extends ChangeNotifier implements RecordDetails {
if (conn == null) return;
try {
_webShare = await conn.client.getWebShare(Empty());
- } on GrpcError {
+ } on GrpcError catch (e) {
+ if (e.code != StatusCode.unimplemented) rethrow;
_webShare = null; // 旧版后台服务没有手机网页传输
}
}
@@ -666,7 +686,8 @@ class AppState extends ChangeNotifier implements RecordDetails {
]);
_friends = (results[0] as ListFriendsResponse).friends;
_profile = results[1] as Profile;
- } on GrpcError {
+ } on GrpcError catch (e) {
+ if (e.code != StatusCode.unimplemented) rethrow;
// 旧版后台服务没有好友
_friends = const [];
_profile = null;
@@ -675,6 +696,7 @@ class AppState extends ChangeNotifier implements RecordDetails {
void _scheduleRetry(String message) {
if (_quitting) return;
+ _retry?.cancel();
_events?.cancel();
_events = null;
_conn?.close();
@@ -865,7 +887,8 @@ class AppState extends ChangeNotifier implements RecordDetails {
_transfers
..clear()
..addAll(resp.transfers);
- } on GrpcError {
+ } on GrpcError catch (e) {
+ if (e.code != StatusCode.unimplemented) rethrow;
// 更新期间连上的可能还是不认识隔空传送的旧版后台服务
_transfers.clear();
}
@@ -1196,7 +1219,8 @@ class AppState extends ChangeNotifier implements RecordDetails {
/// [language] 是更新日志的语言,见 [settingFromLocale]。
Future<UpdateInfo> checkForUpdate(String language) =>
- _client.checkForUpdate(CheckForUpdateRequest(language: language));
+ _client.checkForUpdate(CheckForUpdateRequest(language: language),
+ options: CallOptions(timeout: const Duration(seconds: 30)));
/// 下载并校验新版本。取消订阅即停止下载。
Stream<UpdateProgress> downloadUpdate(String version) =>
@@ -1297,7 +1321,8 @@ class AppState extends ChangeNotifier implements RecordDetails {
if (conn == null) return;
try {
_quickPaste = await conn.client.getQuickPasteStatus(Empty());
- } on GrpcError {
+ } on GrpcError catch (e) {
+ if (e.code != StatusCode.unimplemented) rethrow;
_quickPaste = null; // 旧版后台服务没有快捷窗口
}
}
@@ -1452,6 +1477,7 @@ class AppState extends ChangeNotifier implements RecordDetails {
if (e is! GrpcError) return SendFailure.other;
return switch ((e.message ?? '').split(':').first.trim()) {
'offline' => SendFailure.offline,
+ 'connecting' => SendFailure.connecting,
'unsupported' => SendFailure.unsupported,
'disabled' => SendFailure.disabled,
'relay' => SendFailure.needRelayConsent,
diff --git a/ui/lib/daemon_client.dart b/ui/lib/daemon_client.dart
index 6160892..0f81061 100644
--- a/ui/lib/daemon_client.dart
+++ b/ui/lib/daemon_client.dart
@@ -88,7 +88,10 @@ class DaemonConnection {
final DaemonServiceClient client;
final DaemonEndpoint endpoint;
- static Future<DaemonConnection> connect({String? dataDir}) async {
+ static Future<DaemonConnection> connect({
+ String? dataDir,
+ Duration requestTimeout = const Duration(seconds: 15),
+ }) async {
final ep = await DaemonEndpoint.read(dataDir);
final channel = ClientChannel(
'127.0.0.1',
@@ -102,9 +105,33 @@ class DaemonConnection {
final client = DaemonServiceClient(
channel,
options: CallOptions(metadata: {'x-pasteferry-token': ep.token}),
+ interceptors: [_RequestDeadline(requestTimeout)],
);
return DaemonConnection._(channel, client, ep);
}
Future<void> close() => _channel.shutdown();
}
+
+/// 本机连接建立后,单次请求也必须有期限。事件订阅和下载等流式请求保持长连接。
+class _RequestDeadline extends ClientInterceptor {
+ _RequestDeadline(this.timeout);
+
+ final Duration timeout;
+
+ @override
+ ResponseFuture<R> interceptUnary<Q, R>(
+ ClientMethod<Q, R> method,
+ Q request,
+ CallOptions options,
+ ClientUnaryInvoker<Q, R> invoker,
+ ) {
+ return invoker(
+ method,
+ request,
+ options.timeout == null
+ ? options.mergedWith(CallOptions(timeout: timeout))
+ : options,
+ );
+ }
+}
diff --git a/ui/lib/pages/send_page.dart b/ui/lib/pages/send_page.dart
index 017e392..caf6bff 100644
--- a/ui/lib/pages/send_page.dart
+++ b/ui/lib/pages/send_page.dart
@@ -504,7 +504,11 @@ class _SendPageState extends State<SendPage> with SingleTickerProviderStateMixin
/// 在线、但还不知道对方能不能收文件(还没连上、没收到它的功能声明)。
/// 这时不能说对方要更新:点它就先去连
- bool _connecting(Device d) => d.online && !d.featuresKnown && !d.receivesFiles;
+ bool _connecting(Device d) => d.online && (
+ d.connection == ConnectionKind.CONNECTION_KIND_UNSPECIFIED ||
+ !d.receivesFiles && (!d.featuresKnown ||
+ d.connection != ConnectionKind.CONNECTION_KIND_DIRECT &&
+ d.connection != ConnectionKind.CONNECTION_KIND_RELAY));
void _connect(AppState state, Device d) {
state.reconnect(d.id).catchError((_) => ConnectionKind.CONNECTION_KIND_UNSPECIFIED);
@@ -531,7 +535,7 @@ class _SendPageState extends State<SendPage> with SingleTickerProviderStateMixin
final enabled = _canSend(d);
// 名字下面平时不写字,只在发送中、刚送达、或者发不了的时候写一行
String? note;
- if (!enabled) {
+ if (_connecting(d) || !enabled) {
note = _statusOf(context, state, d);
} else if (sending != null && sending.status == 'active' && sending.totalBytes > 0) {
note = '${(sending.doneBytes.toInt() * 100 / sending.totalBytes.toInt()).floor()}%';
@@ -539,7 +543,7 @@ class _SendPageState extends State<SendPage> with SingleTickerProviderStateMixin
note = '✓ ${l.sendDelivered}';
}
// 头像右下角的小圆点是连接方式:绿色局域网,蓝色直连,橙色中转
- final dot = !enabled
+ final dot = !enabled || _connecting(d)
? null
: d.connection == ConnectionKind.CONNECTION_KIND_RELAY
? p.warning
diff --git a/ui/lib/pages/settings_page.dart b/ui/lib/pages/settings_page.dart
index b61de62..eecf5f7 100644
--- a/ui/lib/pages/settings_page.dart
+++ b/ui/lib/pages/settings_page.dart
@@ -70,6 +70,21 @@ class _SettingsPageState extends State<SettingsPage> {
final cfg = state.config;
if (cfg == null) {
+ if (state.link == LinkState.offline) {
+ return Center(
+ child: Column(
+ mainAxisSize: MainAxisSize.min,
+ children: [
+ Text(context.l10n.errUnavailable),
+ const SizedBox(height: Insets.md),
+ OutlinedButton(
+ onPressed: state.connect,
+ child: Text(context.l10n.retry),
+ ),
+ ],
+ ),
+ );
+ }
return const Center(child: CircularProgressIndicator(strokeWidth: 2.5));
}
_syncControllers(cfg);
diff --git a/ui/lib/widgets/friends_dialog.dart b/ui/lib/widgets/friends_dialog.dart
index 62f6daa..ec1e57b 100644
--- a/ui/lib/widgets/friends_dialog.dart
+++ b/ui/lib/widgets/friends_dialog.dart
@@ -32,7 +32,12 @@ String friendStatus(AppLocalizations l, AppState state, Friend f) {
_ => l.offline,
};
}
- if (!f.featuresKnown && !f.receivesFiles) return l.reconnecting;
+ if (f.connection == ConnectionKind.CONNECTION_KIND_UNSPECIFIED ||
+ !f.receivesFiles && (!f.featuresKnown ||
+ f.connection != ConnectionKind.CONNECTION_KIND_DIRECT &&
+ f.connection != ConnectionKind.CONNECTION_KIND_RELAY)) {
+ return l.reconnecting;
+ }
if (f.receiveDisabled) return l.sendNotReceiving;
if (!f.receivesFiles) return l.sendNeedsUpdate;
return switch (f.connection) {
@@ -267,7 +272,9 @@ Future<void> openFriendSend(BuildContext context, Friend f) async {
showToast(context, l.sendErrOffline(f.displayName), error: true);
return;
}
- if (!f.featuresKnown && !f.receivesFiles) {
+ if (f.connection != ConnectionKind.CONNECTION_KIND_DIRECT &&
+ f.connection != ConnectionKind.CONNECTION_KIND_RELAY ||
+ !f.featuresKnown && !f.receivesFiles) {
unawaited(AppScope.read(context).reconnect(f.id).catchError((_) => ConnectionKind.CONNECTION_KIND_UNSPECIFIED));
}
await showFriendSendDialog(context, SendTarget.friend(f));
diff --git a/ui/lib/widgets/send_dialog.dart b/ui/lib/widgets/send_dialog.dart
index 388a999..69ba92a 100644
--- a/ui/lib/widgets/send_dialog.dart
+++ b/ui/lib/widgets/send_dialog.dart
@@ -52,6 +52,8 @@ Future<Transfer?> sendFilesById(BuildContext context, String id, String name, Li
continue;
case SendFailure.offline:
showToast(context, l.sendErrOffline(name), error: true);
+ case SendFailure.connecting:
+ showToast(context, l.sendConnectingTip(name));
case SendFailure.unsupported:
showToast(context, l.sendNeedsUpdateTip(name), error: true);
case SendFailure.disabled:
diff --git a/ui/test/daemon_connection_test.dart b/ui/test/daemon_connection_test.dart
new file mode 100644
index 0000000..1678898
--- /dev/null
+++ b/ui/test/daemon_connection_test.dart
@@ -0,0 +1,177 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:grpc/grpc.dart';
+import 'package:pasteferry_ui/app_state.dart';
+import 'package:pasteferry_ui/background_service.dart';
+import 'package:pasteferry_ui/daemon_client.dart';
+import 'package:pasteferry_ui/gen/pasteferry/v1/daemon.pbgrpc.dart';
+
+class _Service implements BackgroundService {
+ @override
+ bool get available => false;
+ @override
+ Future<ServiceState> state() async => ServiceState.running;
+ @override
+ dynamic noSuchMethod(Invocation invocation) =>
+ throw StateError('$invocation');
+}
+
+class _Daemon extends DaemonServiceBase {
+ final statusStarted = Completer<void>();
+ final statusResult = Completer<Status>();
+ final events = StreamController<Event>.broadcast();
+
+ @override
+ Future<Config> getConfig(ServiceCall call, Empty request) async =>
+ Config(language: 'zh-Hans', deviceName: 'Windows');
+
+ @override
+ Future<Config> updateConfig(ServiceCall call, Config request) async =>
+ request;
+
+ @override
+ Future<Status> getStatus(ServiceCall call, Empty request) {
+ if (!statusStarted.isCompleted) statusStarted.complete();
+ return statusResult.future;
+ }
+
+ @override
+ Future<ListHistoryResponse> listHistory(
+ ServiceCall call,
+ ListHistoryRequest request,
+ ) async => ListHistoryResponse();
+
+ @override
+ Future<ListDevicesResponse> listDevices(
+ ServiceCall call,
+ Empty request,
+ ) async => ListDevicesResponse(self: Device(id: 'self'));
+
+ @override
+ Stream<Event> subscribe(ServiceCall call, SubscribeRequest request) =>
+ events.stream;
+
+ @override
+ dynamic noSuchMethod(Invocation invocation) =>
+ throw const GrpcError.unimplemented();
+}
+
+void main() {
+ late _Daemon daemon;
+ late Server server;
+ late Directory dir;
+
+ setUp(() async {
+ daemon = _Daemon();
+ server = Server.create(services: [daemon]);
+ await server.serve(address: InternetAddress.loopbackIPv4, port: 0);
+ dir = await Directory.systemTemp.createTemp('pasteferry-connection-');
+ await File(
+ '${dir.path}/daemon.json',
+ ).writeAsString(jsonEncode({'port': server.port, 'token': 'test'}));
+ });
+
+ tearDown(() async {
+ if (!daemon.statusResult.isCompleted) {
+ daemon.statusResult.complete(Status());
+ }
+ await daemon.events.close();
+ await server.shutdown();
+ await dir.delete(recursive: true);
+ });
+
+ Future<DaemonConnection> connect({
+ Duration requestTimeout = const Duration(seconds: 2),
+ }) => DaemonConnection.connect(
+ dataDir: dir.path,
+ requestTimeout: requestTimeout,
+ );
+
+ test(
+ 'settings config appears while status is stalled; timeout permits reconnect',
+ () async {
+ final state = AppState(service: _Service(), connectDaemon: () => connect());
+ addTearDown(state.dispose);
+ final configReady = Completer<void>();
+ state.addListener(() {
+ if (state.config != null && !configReady.isCompleted) {
+ configReady.complete();
+ }
+ });
+ final first = state.connect();
+ await configReady.future.timeout(const Duration(seconds: 10));
+ expect(state.config?.deviceName, 'Windows');
+ expect(daemon.statusResult.isCompleted, isFalse);
+ await first.timeout(const Duration(seconds: 10));
+ expect(state.link, LinkState.offline);
+
+ daemon.statusResult.complete(Status(deviceId: 'self'));
+ await state.connect().timeout(const Duration(seconds: 10));
+ expect(state.link, LinkState.online);
+ expect(state.config?.deviceName, 'Windows');
+ },
+ );
+
+ test('unary calls time out but event streams stay open', () async {
+ final conn = await connect(requestTimeout: const Duration(milliseconds: 300));
+ addTearDown(conn.close);
+ final subscription = conn.client.subscribe(SubscribeRequest());
+ final event = subscription.first;
+ await expectLater(
+ conn.client.getStatus(Empty()),
+ throwsA(
+ isA<GrpcError>().having(
+ (e) => e.code,
+ 'code',
+ StatusCode.deadlineExceeded,
+ ),
+ ),
+ );
+ daemon.events.add(
+ Event(statusChanged: Status(deviceId: 'still-subscribed')),
+ );
+ expect(
+ (await event.timeout(const Duration(seconds: 10))).statusChanged.deviceId,
+ 'still-subscribed',
+ );
+ });
+
+ test(
+ 'settings edited during startup are retained when status arrives',
+ () async {
+ final state = AppState(service: _Service(), connectDaemon: () => connect());
+ addTearDown(state.dispose);
+ final configReady = Completer<void>();
+ state.addListener(() {
+ if (state.config != null && !configReady.isCompleted) {
+ configReady.complete();
+ }
+ });
+ final startup = state.connect();
+ await configReady.future.timeout(const Duration(seconds: 10));
+ await state.updateConfig(
+ state.config!.deepCopy()..deviceName = 'Renamed',
+ );
+ daemon.statusResult.complete(Status(deviceId: 'self'));
+ await startup.timeout(const Duration(seconds: 10));
+ expect(state.link, LinkState.online);
+ expect(state.config?.deviceName, 'Renamed');
+ },
+ );
+
+ test('explicit deadlines override the default timeout', () async {
+ final conn = await connect(requestTimeout: const Duration(milliseconds: 300));
+ addTearDown(conn.close);
+ final response = conn.client.getStatus(
+ Empty(),
+ options: CallOptions(timeout: const Duration(seconds: 2)),
+ );
+ await daemon.statusStarted.future;
+ await Future<void>.delayed(const Duration(milliseconds: 450));
+ daemon.statusResult.complete(Status(deviceId: 'completed'));
+ expect((await response).deviceId, 'completed');
+ });
+}
diff --git a/ui/test/send_connection_test.dart b/ui/test/send_connection_test.dart
new file mode 100644
index 0000000..a22cb24
--- /dev/null
+++ b/ui/test/send_connection_test.dart
@@ -0,0 +1,52 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:grpc/grpc.dart';
+import 'package:pasteferry_ui/app_state.dart';
+import 'package:pasteferry_ui/gen/pasteferry/v1/daemon.pb.dart';
+import 'package:pasteferry_ui/i18n.dart';
+import 'package:pasteferry_ui/main.dart';
+import 'package:pasteferry_ui/widgets/friends_dialog.dart';
+import 'package:pasteferry_ui/widgets/send_dialog.dart';
+
+class _ConnectingSend extends AppState {
+ @override
+ Future<Transfer> sendFiles(
+ String deviceId,
+ List<String> paths, {
+ bool allowRelay = false,
+ String note = '',
+ }) async {
+ throw const GrpcError.failedPrecondition('connecting');
+ }
+}
+
+void main() {
+ testWidgets('连接中的发送提示正在连接,不提示更新', (tester) async {
+ final state = _ConnectingSend()
+ ..debugSeed(
+ status: Status(),
+ config: Config(),
+ self: Device(id: 'self'),
+ );
+ await tester.pumpWidget(PasteFerryApp(state: state));
+ final context = tester.element(find.byType(Shell));
+ final l = context.l10n;
+ await sendFilesById(context, 'friend', 'Windows', ['/tmp/file.txt']);
+ await tester.pump();
+ expect(find.text(l.sendConnectingTip('Windows')), findsOneWidget);
+ expect(find.text(l.sendNeedsUpdateTip('Windows')), findsNothing);
+ await tester.pump(const Duration(seconds: 4));
+ });
+
+ test('好友重连期间优先显示连接状态,连通后才显示能力限制', () {
+ final state = AppState();
+ addTearDown(state.dispose);
+ final f = Friend(
+ online: true,
+ featuresKnown: true,
+ connection: ConnectionKind.CONNECTION_KIND_OFFLINE,
+ );
+ expect(friendStatus(appL10n, state, f), appL10n.reconnecting);
+ f.connection = ConnectionKind.CONNECTION_KIND_DIRECT;
+ expect(friendStatus(appL10n, state, f), appL10n.sendNeedsUpdate);
+ });
+}
diff --git a/ui/test/send_page_test.dart b/ui/test/send_page_test.dart
index 4562396..3d6e63f 100644
--- a/ui/test/send_page_test.dart
+++ b/ui/test/send_page_test.dart
@@ -87,14 +87,18 @@ void main() {
peers: [
// 在线(服务器或局域网报告)但还没连上、没收到功能声明
Device(id: 'new', name: 'Linux 台式机', platform: 'linux', online: true),
+ // 重连时旧的负面能力记录不能显示成版本不兼容。
+ Device(id: 'retry', name: 'Reconnecting PC', platform: 'windows', online: true,
+ connection: ConnectionKind.CONNECTION_KIND_OFFLINE, featuresKnown: true, lanReachable: true),
// 连上以后一直没声明,判定为旧版本
Device(id: 'old', name: 'Old PC', platform: 'windows', online: true,
connection: ConnectionKind.CONNECTION_KIND_DIRECT, featuresKnown: true),
],
);
final l = await open(tester, state);
- expect(find.text(l.reconnecting), findsOneWidget);
+ expect(find.text(l.reconnecting), findsNWidgets(2));
expect(find.byTooltip(l.sendConnectingTip('Linux 台式机')), findsOneWidget);
+ expect(find.byTooltip(l.sendConnectingTip('Reconnecting PC')), findsOneWidget);
expect(find.text(l.sendNeedsUpdate), findsOneWidget);
expect(find.byTooltip(l.sendNeedsUpdateTip('Old PC')), findsOneWidget);
});
diff --git a/ui/test/settings_page_test.dart b/ui/test/settings_page_test.dart
index f0ba396..9e4ad19 100644
--- a/ui/test/settings_page_test.dart
+++ b/ui/test/settings_page_test.dart
@@ -1,3 +1,4 @@
+import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pasteferry_ui/app_state.dart';
@@ -6,7 +7,28 @@ import 'package:pasteferry_ui/main.dart';
AppState _state() => AppState()..debugSeed(status: Status(), config: Config(), self: Device(id: 'self'));
+class _UnavailableSettings extends AppState {
+ int retries = 0;
+ @override
+ Config? get config => null;
+ @override
+ LinkState get link => LinkState.offline;
+ @override
+ Future<void> connect() async { retries++; }
+}
+
void main() {
+ testWidgets('设置加载失败显示重试入口,停止无限转圈', (tester) async {
+ final state = _UnavailableSettings();
+ await tester.pumpWidget(PasteFerryApp(state: state));
+ await tester.tap(find.text('设置').first);
+ await tester.pumpAndSettle();
+ expect(find.text('无法连接后台服务'), findsOneWidget);
+ expect(find.byType(CircularProgressIndicator), findsNothing);
+ await tester.tap(find.text('重试'));
+ expect(state.retries, 1);
+ });
+
testWidgets('设置首页列出各类,点进去是二级页,能返回', (tester) async {
await tester.pumpWidget(PasteFerryApp(state: _state()));
await tester.tap(find.text('设置').first);