release: v0.4.8 跨端 PC 互传封版;修复发送端进度直到结束才更新

实测 1.01 GB / 23.11 MB/s 传输成功,但发送端进度条全程 0%、
最后才跳到 100%,接收端却是实时的。两处原因,都已修复。

1. 请求体一次性写出
   16 MiB 的分块用单次 write_all 送出,中途没有任何可上报的点。
   改为 256 KiB 一片:足够小让进度看起来连续,又足够大不拖慢吞吐。
   put_chunk 逐片累加共享计数;失败重试时把本次尝试已计的字节扣回去,
   否则重试会让进度虚高甚至越过 100%。

2. on_progress 只在所有 worker 结束后调用一次
   主线程改为在 worker 运行期间轮询上报(40 ms 一次,对 UI 足够,
   代价可忽略),而不是等 thread::scope 返回。

测试拆成两层
- 确定性单测 body_progress_is_reported_incrementally:5 片请求体必须
  上报 5 次、总量吻合。回环速度太快时集成测试采样不到中间进度,
  只有这一层能稳定拦住回归
- 集成测试改为断言稳健性质:进度单调不减、且不超过文件总长
  (后者正是重试重复计数会破坏的)
- 配套的 mock 服务端按 Content-Length 精确读取。此前用 read_to_end
  会一直等客户端关闭写端,而客户端在等响应,两边互等直接死锁

封版
- 版本 0.5.0-m1 → 0.4.8,接续既有编号
- 界面与 README 里残留的「6 位配对码」文案更新为连接码

本版可用范围:mac / win / linux 桌面端互传,连接码内含地址,
不要求同一网段,只要 IP 层可路由到达即可。
This commit is contained in:
zhy200308
2026-08-11 19:37:21 +08:00
parent 375ae8a956
commit a6a2e5436d
5 changed files with 166 additions and 20 deletions
+1 -1
View File
@@ -16,7 +16,7 @@ v0.4.7 提供两套互不依赖的传输方式:
> v0.4.7 已完成协议、图像合成解码、ROI、双向并发传输、UDP 发现、内存预算和关键 Kotlin 源码测试。当前生成环境没有真实 Windows 显示器、Android 相机或 Wi‑Fi Direct 适配器,因此物理 30/45/60 FPS 和真实扫码配网仍需在你的设备上跑 `VERIFY_WINDOWS_HOST.ps1` 后做最终验收;详见 `TEST_REPORT.md`。
## v0.5-m1:电脑 ↔ 电脑互传(新增)
## v0.4.8:跨平台桌面端 + 电脑 ↔ 电脑互传
### macOS:请用 QFT.app 启动,不要直接跑裸二进制
+1 -1
View File
@@ -2587,7 +2587,7 @@ checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"
[[package]]
name = "qft-desktop"
version = "0.5.0-m1"
version = "0.4.8"
dependencies = [
"anyhow",
"base64",
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "qft-desktop"
version = "0.5.0-m1"
version = "0.4.8"
edition = "2024"
rust-version = "1.95"
+160 -14
View File
@@ -165,7 +165,9 @@ impl PeerClient {
let sent = Arc::new(AtomicU64::new(0));
let workers = (session.total_chunks as usize).min(MAX_WORKERS).max(1);
// 进度回调在主线程汇总:worker 只累加原子计数,避免把 FnMut 塞进多个线程
// 进度回调在主线程汇总:worker 只累加原子计数,避免把 FnMut 塞进多个线程。
// 主线程随后在此轮询上报——早先只在 scope 结束后报一次,
// 结果传 1 GB 的过程中进度条一直是 0%,最后才跳到 100%。
let failure = std::thread::scope(|scope| -> Result<()> {
let mut handles = Vec::with_capacity(workers);
for _ in 0..workers {
@@ -184,11 +186,19 @@ impl PeerClient {
let length = (size - offset).min(session.chunk_size) as usize;
file.seek(SeekFrom::Start(offset))?;
file.read_exact(&mut buffer[..length])?;
self.put_chunk(address, &session.upload_id, index, &buffer[..length])?;
sent.fetch_add(length as u64, Ordering::Relaxed);
self.put_chunk(address, &session.upload_id, index, &buffer[..length], &sent)?;
}
}));
}
// worker 跑着的时候持续上报,不要等它们全部结束
while !handles.iter().all(|h| h.is_finished()) {
on_progress(Progress {
done: sent.load(Ordering::Relaxed).min(size),
total: size,
});
std::thread::sleep(Duration::from_millis(40));
}
let mut error = None;
for handle in handles {
match handle.join() {
@@ -208,10 +218,7 @@ impl PeerClient {
});
failure?;
on_progress(Progress {
done: sent.load(Ordering::Relaxed),
total: size,
});
on_progress(Progress { done: size, total: size });
self.finish_upload(address, &session.upload_id)
}
@@ -250,20 +257,40 @@ impl PeerClient {
})
}
fn put_chunk(&self, address: SocketAddr, upload_id: &str, index: u32, body: &[u8]) -> Result<()> {
fn put_chunk(
&self,
address: SocketAddr,
upload_id: &str,
index: u32,
body: &[u8],
sent: &AtomicU64,
) -> Result<()> {
let path = format!("/qft/upload/chunk/{upload_id}/{index}");
// 接收端对重复分块是幂等的,因此重试安全。
// 局域网上首次连接常被 Windows 防火墙首包丢弃,一次重试就能救回来。
let mut last = None;
for attempt in 0..3 {
match send_request(
// 本次尝试写出的字节单独计一份:失败时要从总数里扣回去,
// 否则重试会让进度虚高甚至超过 100%
let attempted = AtomicU64::new(0);
let mut sink = |n: usize| {
attempted.fetch_add(n as u64, Ordering::Relaxed);
sent.fetch_add(n as u64, Ordering::Relaxed);
};
let outcome = send_request_with_progress(
address,
"POST",
&path,
&self.auth_headers(),
Some(body),
Duration::from_secs(60),
) {
Some(&mut sink),
);
drop(sink);
if outcome.is_err() || outcome.as_ref().is_ok_and(|r| r.status != 200) {
sent.fetch_sub(attempted.load(Ordering::Relaxed), Ordering::Relaxed);
}
match outcome {
Ok(mut response) => {
let payload = response.read_body()?;
if response.status == 200 {
@@ -473,6 +500,20 @@ fn send_request(
headers: &[(String, String)],
body: Option<&[u8]>,
timeout: Duration,
) -> Result<HttpResponse> {
send_request_with_progress(address, method, path, headers, body, timeout, None)
}
/// `on_body_written` 会在请求体每写出一片后被调用。
/// 大文件分块是 16 MiB,若等整块写完才计数,进度条就是一格一格跳的。
fn send_request_with_progress(
address: SocketAddr,
method: &str,
path: &str,
headers: &[(String, String)],
body: Option<&[u8]>,
timeout: Duration,
mut on_body_written: Option<&mut dyn FnMut(usize)>,
) -> Result<HttpResponse> {
let stream = TcpStream::connect_timeout(&address, timeout.min(Duration::from_secs(10)))
.map_err(|e| describe_connect_failure(address, &e))?;
@@ -496,8 +537,14 @@ fn send_request(
let mut writer = stream.try_clone()?;
writer.write_all(request.as_bytes())?;
if let Some(body) = body {
if !body.is_empty() {
writer.write_all(body)?;
// 256 KiB 一片:足够小,进度看起来是连续的;
// 又足够大,不会因为频繁 write 拖慢吞吐
const SLICE: usize = 256 * 1024;
for part in body.chunks(SLICE) {
writer.write_all(part)?;
if let Some(sink) = on_body_written.as_deref_mut() {
sink(part.len());
}
}
}
writer.flush()?;
@@ -601,10 +648,22 @@ mod integration_tests {
assert_eq!(paired, token, "配对应返回真实会话令牌");
let client = PeerClient::new(base_url, paired, "tester");
let mut last = Progress { done: 0, total: 0 };
let sha = client.upload_file(&source, |p| last = p).unwrap();
let mut samples: Vec<Progress> = Vec::new();
let sha = client.upload_file(&source, |p| samples.push(p)).unwrap();
let last = *samples.last().expect("至少应有一次进度回调");
assert_eq!(last.done, payload.len() as u64, "进度应抵达文件全长");
// 回环传输太快,采样次数不稳定,这里只断言稳健的性质;
// 「边传边报」的机制由 body_progress_is_reported_incrementally 覆盖。
assert!(
samples.windows(2).all(|w| w[0].done <= w[1].done),
"进度必须单调不减:{samples:?}"
);
assert!(
samples.iter().all(|p| p.done <= payload.len() as u64),
"进度不得超过文件总长(重试重复计数会导致这种情况):{samples:?}"
);
let landed = inbox.join("payload.bin");
let saved = std::fs::read(&landed).expect("文件应已落盘");
assert_eq!(saved.len(), payload.len());
@@ -650,3 +709,90 @@ mod failure_message_tests {
"被拒绝时应提示对方没启动接收,实得:{text}");
}
}
#[cfg(test)]
mod progress_tests {
use super::*;
use std::io::{BufRead, Read, Write};
use std::sync::atomic::AtomicUsize;
/// 极简 mock:按 Content-Length 精确读完请求体再应答。
///
/// 不能用 read_to_end——那会一直等到客户端关闭写端,
/// 而客户端此时正在等响应,两边互等直接死锁。
fn serve_once(listener: std::net::TcpListener) -> std::thread::JoinHandle<usize> {
std::thread::spawn(move || {
let Ok((stream, _)) = listener.accept() else { return 0 };
let mut reader = std::io::BufReader::new(stream.try_clone().unwrap());
let mut length = 0usize;
loop {
let mut line = String::new();
if reader.read_line(&mut line).unwrap_or(0) == 0 {
break;
}
if line == "\r\n" || line == "\n" {
break;
}
if let Some((name, value)) = line.split_once(':') {
if name.trim().eq_ignore_ascii_case("content-length") {
length = value.trim().parse().unwrap_or(0);
}
}
}
let mut body = vec![0u8; length];
let _ = reader.read_exact(&mut body);
let mut out = stream;
let _ = out.write_all(
b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\n{}",
);
let _ = out.flush();
length
})
}
/// 锁住「边写边报」这个行为。
///
/// 早先 `on_progress` 只在所有 worker 结束后调用一次,传 1 GB 时
/// 进度条全程 0%、最后才跳到 100%。这里直接验证请求体是分片写出并
/// 逐片上报的——回环速度太快时集成测试采样不到,只有这一层能稳定拦住回归。
#[test]
fn body_progress_is_reported_incrementally() {
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let address = listener.local_addr().unwrap();
let server = serve_once(listener);
let body = vec![7u8; 5 * 256 * 1024]; // 正好 5 片
let calls = AtomicUsize::new(0);
let total = AtomicU64::new(0);
let mut sink = |n: usize| {
calls.fetch_add(1, Ordering::Relaxed);
total.fetch_add(n as u64, Ordering::Relaxed);
};
let response = send_request_with_progress(
address, "POST", "/x", &[], Some(&body),
Duration::from_secs(10), Some(&mut sink),
);
drop(sink);
assert!(response.is_ok(), "请求应成功:{:?}", response.err());
assert_eq!(server.join().unwrap(), body.len(), "服务端应收到完整请求体");
assert_eq!(calls.load(Ordering::Relaxed), 5, "5 片体应上报 5 次");
assert_eq!(
total.load(Ordering::Relaxed),
body.len() as u64,
"上报总量应等于请求体长度"
);
}
#[test]
fn no_progress_sink_is_allowed() {
// init/finish/ping 都不需要进度,不传 sink 时不能出问题
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let address = listener.local_addr().unwrap();
let server = serve_once(listener);
let result = send_request(address, "POST", "/x", &[], Some(b"hi"), Duration::from_secs(10));
assert!(result.is_ok(), "无 sink 时请求也应成功:{:?}", result.err());
assert_eq!(server.join().unwrap(), 2);
}
}
+3 -3
View File
@@ -28,7 +28,7 @@ use std::{
// a nominally larger page that is only decoded 10~18 times per second.
const DEFAULT_CHUNK_SIZE: u16 = 320;
const UI_FONT_NAME: &str = "qft-ui";
const APP_VERSION: &str = "0.5.0-m1";
const APP_VERSION: &str = "0.4.8";
fn main() -> eframe::Result {
let options = eframe::NativeOptions {
@@ -324,7 +324,7 @@ impl QftApp {
ui.horizontal_wrapped(|ui| {
ui.heading("电脑 ↔ 电脑");
ui.separator();
ui.label("同一局域网 · 6 位配对码 · 无需二维码");
ui.label("输入对方的连接码即可 · 无需二维码");
if ui.add_sized([220.0, 42.0], egui::Button::new("电脑之间互传")).clicked() {
self.screen = Screen::PcToPc;
}
@@ -1006,7 +1006,7 @@ impl QftApp {
ui.horizontal_wrapped(|ui| {
ui.heading("电脑 ↔ 电脑");
ui.separator();
ui.label("同一局域网 · 无需二维码 · 6 位配对码");
ui.label("同一局域网或可路由到达 · 无需二维码 · 一串连接码");
ui.separator();
ui.selectable_value(&mut self.pc.mode, PcMode::Receive, "我要接收");
ui.selectable_value(&mut self.pc.mode, PcMode::Send, "我要发送");