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.

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.go
index 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 bool
root context.Context
cancel 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)) (*Client
return 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, e
return 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.Time
for {
+ force := false
select {
case <-ctx.Done():
return
+ case <-c.kick:
+ force = true
case <-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.go
index 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.go
index 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()
}