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.

refactor(core): share the data-channel chunk writer

baiyuze0effea2d4a5b
diff --git a/client-core/internal/sync/engine.go b/client-core/internal/sync/engine.go
index aa0fa19..ca31c5c 100644
--- a/client-core/internal/sync/engine.go
+++ b/client-core/internal/sync/engine.go
@@ -38,15 +38,8 @@ import (
pb "github.com/baiyuze/pasteferry/proto/gen/pasteferry/v1"
)
+// 分片大小与发送缓冲的水位见 p2p.ChunkWriter。
const (
- // DataChannel 单条消息的上限。SCTP 对过大的消息支持参差,
- // 64 KiB 是各实现都稳妥的取值。
- chunkSize = 60 * 1024
- // 发送缓冲超过此值就暂停读取源文件,等它降下来再继续。
- // 没有背压的话,传大文件会把内存吃光。
- bufferHighWater = 1 << 20 // 1 MiB
- bufferLowWater = 256 << 10
-
// 预扫描的条目上限。超大目录全扫一遍会让复制动作明显卡顿,
// 超限时只报概要,进度条退化为未知总量。
maxScanEntries = 20000
@@ -506,7 +499,7 @@ func (e *Engine) pushTo(ctx context.Context, peer string, clip store.Clip) error
}
start := time.Now()
- w := newChunkWriter(dc, func(sent int64) {
+ w := p2p.NewChunkWriter(dc, func(sent int64) {
e.emitProgress(clip.ID, sent, clip.TotalSize, start)
})
diff --git a/client-core/internal/sync/chunkwriter.go b/client-core/internal/transport/p2p/chunkwriter.go
similarity index 71%
rename from client-core/internal/sync/chunkwriter.go
rename to client-core/internal/transport/p2p/chunkwriter.go
index 6f019ab..ead4b05 100644
--- a/client-core/internal/sync/chunkwriter.go
+++ b/client-core/internal/transport/p2p/chunkwriter.go
@@ -1,4 +1,4 @@
-package sync
+package p2p
import (
"context"
@@ -9,13 +9,23 @@ import (
"github.com/pion/webrtc/v4"
)
-// chunkWriter 把连续字节流切成 DataChannel 能承受的小块并施加背压。
+// 文件传输的数据流(复制同步与隔空传送共用):分片的大小与发送缓冲的水位。
+const (
+ // DataChannel 单条消息的上限。SCTP 对过大的消息支持参差,
+ // 64 KiB 是各实现都稳妥的取值。
+ ChunkSize = 60 * 1024
+ // 发送缓冲超过此值就暂停读取源文件,等它降下来再继续。
+ // 没有背压的话,传大文件会把内存吃光。
+ bufferHighWater = 1 << 20 // 1 MiB
+)
+
+// ChunkWriter 把连续字节流切成 DataChannel 能承受的小块并施加背压。
//
// 两件事缺一不可:
// 1. 分片——SCTP 对超大消息的支持在各实现间差异很大,60 KiB 是稳妥值;
// 2. 背压——不管发送缓冲直接灌数据,传大文件会把内存吃光。
// 缓冲超过高水位时暂停读取源文件,等它回落再继续。
-type chunkWriter struct {
+type ChunkWriter struct {
dc *webrtc.DataChannel
onProgress func(sent int64)
@@ -26,11 +36,12 @@ type chunkWriter struct {
err error
}
-func newChunkWriter(dc *webrtc.DataChannel, onProgress func(int64)) *chunkWriter {
- w := &chunkWriter{
+// NewChunkWriter 包住一条刚打开的数据通道。onProgress 在每发出一个分片后收到累计字节数,可以为 nil。
+func NewChunkWriter(dc *webrtc.DataChannel, onProgress func(int64)) *ChunkWriter {
+ w := &ChunkWriter{
dc: dc,
onProgress: onProgress,
- buf: make([]byte, 0, chunkSize),
+ buf: make([]byte, 0, ChunkSize),
}
dc.OnError(func(err error) {
w.mu.Lock()
@@ -40,15 +51,15 @@ func newChunkWriter(dc *webrtc.DataChannel, onProgress func(int64)) *chunkWriter
return w
}
-func (w *chunkWriter) Write(p []byte) (int, error) {
+func (w *ChunkWriter) Write(p []byte) (int, error) {
total := len(p)
for len(p) > 0 {
- space := chunkSize - len(w.buf)
+ space := ChunkSize - len(w.buf)
n := min(space, len(p))
w.buf = append(w.buf, p[:n]...)
p = p[n:]
- if len(w.buf) >= chunkSize {
+ if len(w.buf) >= ChunkSize {
if err := w.flushChunk(); err != nil {
return total - len(p), err
}
@@ -57,14 +68,14 @@ func (w *chunkWriter) Write(p []byte) (int, error) {
return total, nil
}
-func (w *chunkWriter) Flush() error {
+func (w *ChunkWriter) Flush() error {
if len(w.buf) == 0 {
return nil
}
return w.flushChunk()
}
-func (w *chunkWriter) flushChunk() error {
+func (w *ChunkWriter) flushChunk() error {
if err := w.waitForBuffer(); err != nil {
return err
}
@@ -89,7 +100,7 @@ func (w *chunkWriter) flushChunk() error {
// 若缓冲在等待方进入 Wait 之前就已降到阈值以下,回调早已发生过,
// 等待就再也等不到唤醒——传 20 MB 文件时实测会卡死在 786 KB 处。
// 2 ms 的轮询间隔对文件传输而言开销可忽略,却彻底消除了丢失唤醒。
-func (w *chunkWriter) waitForBuffer() error {
+func (w *ChunkWriter) waitForBuffer() error {
const (
pollInterval = 2 * time.Millisecond
maxWait = 2 * time.Minute
@@ -118,7 +129,7 @@ func (w *chunkWriter) waitForBuffer() error {
//
// 数据通道一关,尚未发出的数据就丢了;关闭前必须确认本地缓冲已清空。
// 排不空说明对端没在接收(连接多半已经断了),返回错误,不能当作发送成功。
-func (w *chunkWriter) WaitDrained(ctx context.Context, timeout time.Duration) error {
+func (w *ChunkWriter) WaitDrained(ctx context.Context, timeout time.Duration) error {
deadline := time.Now().Add(timeout)
for {
if w.dc.BufferedAmount() == 0 {
@@ -138,4 +149,4 @@ func (w *chunkWriter) WaitDrained(ctx context.Context, timeout time.Duration) er
}
}
-func (w *chunkWriter) Sent() int64 { return w.sent }
+func (w *ChunkWriter) Sent() int64 { return w.sent }
diff --git a/client-core/internal/transport/p2p/stream.go b/client-core/internal/transport/p2p/stream.go
index 9be5381..41f352b 100644
--- a/client-core/internal/transport/p2p/stream.go
+++ b/client-core/internal/transport/p2p/stream.go
@@ -1,6 +1,7 @@
package p2p
import (
+ "io"
"sync"
"github.com/pion/webrtc/v4"
@@ -52,6 +53,28 @@ func NewStream(dc *webrtc.DataChannel) *Stream {
// 通道在对端关闭数据流后关闭,消费者据此得知传输结束。
func (s *Stream) Chunks() <-chan []byte { return s.queue }
+// Reader 把分片拼回连续的字节流。对端关闭数据流后读到 io.EOF;
+// 消费者自己判断内容是否完整(隔空传送靠帧流末尾的 end 帧)。
+func (s *Stream) Reader() io.Reader { return &streamReader{chunks: s.queue} }
+
+type streamReader struct {
+ chunks <-chan []byte
+ buf []byte
+}
+
+func (r *streamReader) Read(p []byte) (int, error) {
+ for len(r.buf) == 0 {
+ chunk, ok := <-r.chunks
+ if !ok {
+ return 0, io.EOF
+ }
+ r.buf = chunk
+ }
+ n := copy(p, r.buf)
+ r.buf = r.buf[n:]
+ return n, nil
+}
+
func (s *Stream) Label() string { return s.dc.Label() }
func (s *Stream) ReadyState() webrtc.DataChannelState { return s.dc.ReadyState() }