diff --git a/README.md b/README.md index 0f750f0..1c52c1a 100644 --- a/README.md +++ b/README.md @@ -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 启动,不要直接跑裸二进制 diff --git a/desktop/Cargo.lock b/desktop/Cargo.lock index b839dcc..3826589 100644 --- a/desktop/Cargo.lock +++ b/desktop/Cargo.lock @@ -2587,7 +2587,7 @@ checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea" [[package]] name = "qft-desktop" -version = "0.5.0-m1" +version = "0.4.8" dependencies = [ "anyhow", "base64", diff --git a/desktop/Cargo.toml b/desktop/Cargo.toml index faf4f76..b5a7a6d 100644 --- a/desktop/Cargo.toml +++ b/desktop/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "qft-desktop" -version = "0.5.0-m1" +version = "0.4.8" edition = "2024" rust-version = "1.95" diff --git a/desktop/src/client.rs b/desktop/src/client.rs index d2766a2..1986a39 100644 --- a/desktop/src/client.rs +++ b/desktop/src/client.rs @@ -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 { + 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 { 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 = 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 { + 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); + } +} diff --git a/desktop/src/main.rs b/desktop/src/main.rs index 97fd90f..a5f490a 100644 --- a/desktop/src/main.rs +++ b/desktop/src/main.rs @@ -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 { @@ -330,7 +330,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; } @@ -1170,7 +1170,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, "我要发送");