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.
Dart airdrop-alternativeclipboardclipboard-sharingclipboard-synccopy-pastecross-platformend-to-end-encryptionfile-syncfile-transferfluttergolanglinuxmacosnat-traversalp2pself-hostedtailscaleuniversal-clipboardwebrtcwindows
feat(core): fetch the official allowance without waiting for relay
baiyuzed7314fce9411
diff --git a/client-core/internal/gateway/client.go b/client-core/internal/gateway/client.goindex 290b17c..4d409fd 100644--- a/client-core/internal/gateway/client.go+++ b/client-core/internal/gateway/client.go@@ -29,8 +29,16 @@ type Client struct {enabled boolroot context.Contextcancel context.CancelFunc+ kick chan struct{}}+// Without relay sessions the allowance only changes through policy, so it is+// refreshed less often than while relaying.+const (+ relayUsageInterval = 15 * time.Second+ idleUsageInterval = 60 * time.Second+)+func (c *Client) ReportError(err error) {u := c.Usage()var ge *Error@@ -55,7 +63,7 @@ func NewClient(id *identity.Identity, base string, onUsage func(Usage)) (*Clientreturn nil, errors.New("gateway requires HTTPS")}root, cancel := context.WithCancel(context.Background())- return &Client{id: id, base: strings.TrimRight(base, "/"), http: &http.Client{Timeout: 15 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return errors.New("gateway redirects are not allowed") }}, access: map[string]Access{}, peers: map[string]string{}, conns: map[*packetConn]bool{}, onUsage: onUsage, enabled: true, root: root, cancel: cancel}, nil+ return &Client{id: id, base: strings.TrimRight(base, "/"), http: &http.Client{Timeout: 15 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return errors.New("gateway redirects are not allowed") }}, access: map[string]Access{}, peers: map[string]string{}, conns: map[*packetConn]bool{}, onUsage: onUsage, enabled: true, root: root, cancel: cancel, kick: make(chan struct{}, 1)}, nil}func (c *Client) SetEnabled(enabled bool) {@@ -67,8 +75,21 @@ func (c *Client) SetEnabled(enabled bool) {if !c.enabled {c.root, c.cancel = context.WithCancel(context.Background())c.enabled = true+ // Figures from an earlier enabled period may be from another day.+ c.last = Usage{}}c.mu.Unlock()+ c.RefreshUsage()+}++// RefreshUsage asks Run to query the owner allowance now instead of waiting+// for the next interval. The query carries no machine digest and requests no+// relay, so it is safe right after enabling or reconnecting.+func (c *Client) RefreshUsage() {+ select {+ case c.kick <- struct{}{}:+ default:+ }}func (c *Client) request(ctx context.Context, method, path, token string, body, out any) error {c.mu.Lock()@@ -174,60 +195,78 @@ func (c *Client) Authorize(ctx context.Context, peer, session string) (Access, ereturn a, nil}func (c *Client) Run(ctx context.Context) {- ticker := time.NewTicker(15 * time.Second)+ ticker := time.NewTicker(relayUsageInterval)defer ticker.Stop()defer c.Close()+ c.RefreshUsage()+ var lastOwner time.Timefor {+ force := falseselect {case <-ctx.Done():return+ case <-c.kick:+ force = truecase <-ticker.C:- c.mu.Lock()- owner := c.usageAccess- sessions := make(map[string]Access, len(c.access))- peers := make(map[string]string, len(c.peers))- for k, v := range c.access {- sessions[k] = v- peers[k] = c.peers[k]- }- c.mu.Unlock()- if len(sessions) == 0 && owner.Token != "" {- var err error- if time.Now().Unix() >= owner.ExpiresAt-120 {+ }+ c.mu.Lock()+ enabled := c.enabled+ owner := c.usageAccess+ sessions := make(map[string]Access, len(c.access))+ peers := make(map[string]string, len(c.peers))+ for k, v := range c.access {+ sessions[k] = v+ peers[k] = c.peers[k]+ }+ c.mu.Unlock()+ if !enabled {+ continue+ }+ if len(sessions) == 0 && (force || time.Since(lastOwner) >= idleUsageInterval) {+ lastOwner = time.Now()+ var err error+ if owner.Token == "" || time.Now().Unix() >= owner.ExpiresAt-120 {+ err = c.refreshUsage(ctx)+ } else {+ var u Usage+ err = c.request(ctx, "GET", "usage", owner.Token, nil, &u)+ var ge *Error+ if errors.As(err, &ge) && ge.Code == "unauthorized" {+ // The gateway keeps tokens in memory; after it restarts+ // a still-unexpired token is unknown there.err = c.refreshUsage(ctx)- } else {- var u Usage- err = c.request(ctx, "GET", "usage", owner.Token, nil, &u)- if err == nil {- c.update(u)- }- }- if err != nil {- c.ReportError(err)+ } else if err == nil {+ c.update(u)}}- for session, a := range sessions {- var err error- if time.Now().Unix() >= a.ExpiresAt-120 {- _, err = c.Authorize(ctx, peers[session], session)- } else {- var u Usage- err = c.request(ctx, "GET", "usage", a.Token, nil, &u)- if err == nil {- c.update(u)- }- }- if err != nil {- u := c.Usage()- u.Available = false- u.Reason = "service_unavailable"- var ge *Error- if errors.As(err, &ge) {- u.Reason = ge.Code- }+ if err != nil {+ c.ReportError(err)+ }+ }+ if force {+ continue+ }+ for session, a := range sessions {+ var err error+ if time.Now().Unix() >= a.ExpiresAt-120 {+ _, err = c.Authorize(ctx, peers[session], session)+ } else {+ var u Usage+ err = c.request(ctx, "GET", "usage", a.Token, nil, &u)+ if err == nil {c.update(u)}}+ if err != nil {+ u := c.Usage()+ u.Available = false+ u.Reason = "service_unavailable"+ var ge *Error+ if errors.As(err, &ge) {+ u.Reason = ge.Code+ }+ c.update(u)+ }}}}diff --git a/client-core/internal/gateway/gateway_test.go b/client-core/internal/gateway/gateway_test.goindex 43a1eeb..630378c 100644--- a/client-core/internal/gateway/gateway_test.go+++ b/client-core/internal/gateway/gateway_test.go@@ -5,6 +5,7 @@ import ("crypto/ed25519""crypto/sha256""database/sql"+ "encoding/json""fmt""net""net/http"@@ -253,3 +254,80 @@ func TestDisablingCancelsTunnelHandshake(t *testing.T) {t.Fatal("disabling did not cancel handshake")}}++func TestRunFetchesOwnerUsageWithoutRelay(t *testing.T) {+ var authorizes, usages atomic.Int32+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ now := time.Now().Unix()+ usage := Usage{Available: true, Limit: 100_000_000, Remaining: 100_000_000, ResetAt: now + 3600, UpdatedAt: now}+ switch r.URL.Path {+ case "/gateway/v1/challenge":+ _ = json.NewEncoder(w).Encode(map[string]string{"nonce": "n"})+ case "/gateway/v1/authorize":+ var p Proof+ _ = json.NewDecoder(r.Body).Decode(&p)+ if p.Purpose != "usage" || p.MachineDigest != "" || p.PeerID != "" || p.SessionID != "" {+ t.Errorf("owner query sent relay or machine fields: %+v", p)+ }+ n := authorizes.Add(1)+ _ = json.NewEncoder(w).Encode(Access{Token: fmt.Sprint("owner-", n), ExpiresAt: now + 900, Usage: usage})+ case "/gateway/v1/usage":+ // The first poll simulates a restarted gateway that lost its tokens.+ if usages.Add(1) == 1 {+ w.WriteHeader(401)+ _ = json.NewEncoder(w).Encode(map[string]string{"code": "unauthorized"})+ return+ }+ _ = json.NewEncoder(w).Encode(usage)+ default:+ t.Errorf("unexpected request %s", r.URL.Path)+ w.WriteHeader(404)+ }+ }))+ defer server.Close()+ got := make(chan Usage, 16)+ c, err := NewClient(identity.FromSeed(make([]byte, 32)), server.URL, func(u Usage) { got <- u })+ if err != nil {+ t.Fatal(err)+ }+ ctx, cancel := context.WithCancel(context.Background())+ defer cancel()+ go c.Run(ctx)+ wait := func(what string) Usage {+ t.Helper()+ select {+ case u := <-got:+ return u+ case <-time.After(3 * time.Second):+ t.Fatalf("%s: no usage before the polling interval", what)+ return Usage{}+ }+ }+ // Enabled at start: the allowance is fetched at once, not after 15/60 s.+ if u := wait("start"); u.Limit != 100_000_000 || u.Remaining != 100_000_000 || u.UpdatedAt == 0 {+ t.Fatalf("start usage: %+v", u)+ }+ // A reconnect refresh with an unknown token re-authorizes instead of+ // reporting the gateway as unavailable for the rest of the token's life.+ c.RefreshUsage()+ if u := wait("refresh"); !u.Available || u.Reason != "" {+ t.Fatalf("refresh usage: %+v", u)+ }+ if authorizes.Load() != 2 || usages.Load() != 1 {+ t.Fatalf("authorize=%d usage=%d", authorizes.Load(), usages.Load())+ }+ // Disabled mode makes no official request, even when asked to refresh.+ c.SetEnabled(false)+ before := authorizes.Load() + usages.Load()+ c.RefreshUsage()+ time.Sleep(200 * time.Millisecond)+ if authorizes.Load()+usages.Load() != before {+ t.Fatal("disabled gateway refreshed usage")+ }+ // Re-enabling clears old figures and fetches again.+ c.SetEnabled(true)+ if c.Usage().UpdatedAt != 0 {+ t.Fatal("re-enabling kept usage from the disabled period")+ }+ wait("re-enable")+}diff --git a/client-core/internal/peers/manager.go b/client-core/internal/peers/manager.goindex 3ed4f34..cc1f856 100644--- a/client-core/internal/peers/manager.go+++ b/client-core/internal/peers/manager.go@@ -395,6 +395,8 @@ func (m *Manager) deviceInfo() (name, platform string, paired []string) {func (m *Manager) handleConnected() {m.log.Info("信令已连接", "url", m.client.URL())+ // 网络恢复后马上刷新官方额度;没开官方服务时网关客户端会忽略+ m.gateway.RefreshUsage()m.notifyAll()m.notifyStatus()}