perf(sender): 下载服务支持 HTTP keep-alive,消除每分块重建 TCP

Android 的并行下载在每个 Range 请求里都写了 Connection: keep-alive,
但服务端每个响应都写死 Connection: close —— 复用是单方面的,实际上
每个 16 MiB 分块都要新建一条 TCP。1 GB 是 64 次,10 GB 是 640 次。
这正是"短连接不稳定、很快断开"的直接来源。

改动
- handle_client 拆出 serve_one,在同一条连接上循环处理请求
- 按 HTTP/1.1 语义决定是否复用:客户端显式 Connection: close 或
  使用 HTTP/1.0 时才断开,否则响应回 Connection: keep-alive
- 读到 0 字节视为对端正常关闭,这是 keep-alive 下的常态而非错误,
  不再当作 "连接在请求头前关闭" 报错

测试
新增 serves_multiple_ranges_on_one_connection:在同一条 TCP 上连发三段
互不重叠的 Range,逐段校验状态行、Content-Length、Connection 头与内容
字节,最后再用一个显式 Connection: close 的请求确认服务端会正常收尾。
两个既有用例同步补上 Connection: close —— 它们只发一个请求就读到 EOF,
在 keep-alive 下会一直等下一个请求直到读超时。

cargo test 38/38。
This commit is contained in:
zhy200308
2026-08-11 21:02:01 +08:00
parent 90800b9a21
commit ae41267221
+137 -10
View File
@@ -138,14 +138,47 @@ fn handle_client(
stream.set_write_timeout(Some(Duration::from_secs(120)))?;
let cloned = stream.try_clone()?;
let mut reader = BufReader::with_capacity(32 * 1024, cloned);
// 同一条连接上循环处理请求。此前每个响应都写死 Connection: close,
// 于是并行下载的每个分块都要新建一次 TCP —— 1 GB 是 64 次,
// 10 GB 是 640 次,既慢又是"短连接频繁断开"的直接来源。
loop {
match serve_one(stream, &mut reader, file_path, file_name, size, token, events)? {
KeepAlive::Continue => {}
KeepAlive::Close => return Ok(()),
}
}
}
/// 单个请求的处理结果:是否可以在同一条连接上继续。
enum KeepAlive {
Continue,
Close,
}
fn serve_one(
stream: &mut TcpStream,
reader: &mut BufReader<TcpStream>,
file_path: &PathBuf,
file_name: &str,
size: u64,
token: &str,
events: &Sender<SenderEvent>,
) -> Result<KeepAlive> {
let mut request_line = String::new();
reader.read_line(&mut request_line)?;
// 读到 0 字节说明对端正常关闭了连接,这是 keep-alive 下的常态,不是错误
if reader.read_line(&mut request_line)? == 0 {
return Ok(KeepAlive::Close);
}
if request_line.trim().is_empty() {
return Ok(KeepAlive::Close);
}
if request_line.len() > 8192 { bail!("请求行过长") }
let mut headers = HashMap::<String, String>::new();
loop {
let mut line = String::new();
let n = reader.read_line(&mut line)?;
if n == 0 { bail!("连接在请求头前关闭") }
if n == 0 { return Ok(KeepAlive::Close) }
if line == "\r\n" || line == "\n" { break }
if line.len() > 16 * 1024 { bail!("请求头过长") }
if let Some((k, v)) = line.split_once(':') {
@@ -155,17 +188,29 @@ fn handle_client(
let mut parts = request_line.split_whitespace();
let method = parts.next().unwrap_or("");
let path = parts.next().unwrap_or("");
let version = parts.next().unwrap_or("HTTP/1.1");
// HTTP/1.1 默认复用;客户端显式要求 close 或用 1.0 时才断开
let keep_alive = version.eq_ignore_ascii_case("HTTP/1.1")
&& !headers
.get("connection")
.map(|v| v.eq_ignore_ascii_case("close"))
.unwrap_or(false);
let connection_header = if keep_alive { "keep-alive" } else { "close" };
if headers.get("x-qft-token").map(String::as_str).unwrap_or("") != token {
return write_response(stream, 403, "text/plain", b"invalid session");
write_response(stream, 403, "text/plain", b"invalid session")?;
return Ok(KeepAlive::Close);
}
let device = decode_header(headers.get("x-qft-device")).unwrap_or_else(|| "Android".to_owned());
let _ = events.send(SenderEvent::ClientConnected { device: device.clone() });
if method == "GET" && path == "/qft/ping" {
let body = json!({"ok": true, "protocol": 2, "direction": "download"}).to_string();
return write_response(stream, 200, "application/json", body.as_bytes());
write_response(stream, 200, "application/json", body.as_bytes())?;
return Ok(if keep_alive { KeepAlive::Continue } else { KeepAlive::Close });
}
if method != "GET" || path != "/qft/download" {
return write_response(stream, 404, "text/plain", b"not found");
write_response(stream, 404, "text/plain", b"not found")?;
return Ok(KeepAlive::Close);
}
let mut input = File::open(file_path)
@@ -180,12 +225,12 @@ fn handle_client(
let _ = events.send(SenderEvent::DownloadStarted { device: device.clone(), file_name: file_name.to_owned(), size });
if headers.get("range").is_none() {
write!(stream,
"HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nContent-Length: {remaining}\r\nAccept-Ranges: bytes\r\nConnection: close\r\nX-QFT-Filename: {}\r\n\r\n",
"HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nContent-Length: {remaining}\r\nAccept-Ranges: bytes\r\nConnection: {connection_header}\r\nX-QFT-Filename: {}\r\n\r\n",
URL_SAFE_NO_PAD.encode(file_name.as_bytes()),
)?;
} else {
write!(stream,
"HTTP/1.1 206 Partial Content\r\nContent-Type: application/octet-stream\r\nContent-Length: {remaining}\r\nContent-Range: bytes {offset}-{end}/{}\r\nAccept-Ranges: bytes\r\nConnection: close\r\nX-QFT-Filename: {}\r\n\r\n",
"HTTP/1.1 206 Partial Content\r\nContent-Type: application/octet-stream\r\nContent-Length: {remaining}\r\nContent-Range: bytes {offset}-{end}/{}\r\nAccept-Ranges: bytes\r\nConnection: {connection_header}\r\nX-QFT-Filename: {}\r\n\r\n",
size,
URL_SAFE_NO_PAD.encode(file_name.as_bytes()),
)?;
@@ -203,7 +248,7 @@ fn handle_client(
}
stream.flush()?;
let _ = events.send(SenderEvent::DownloadCompleted { device, file_name: file_name.to_owned() });
Ok(())
Ok(if keep_alive { KeepAlive::Continue } else { KeepAlive::Close })
}
fn write_response(stream: &mut TcpStream, code: u16, content_type: &str, body: &[u8]) -> Result<()> {
@@ -328,7 +373,7 @@ mod tests {
let mut client = TcpStream::connect(address).unwrap();
client.write_all(
b"GET /qft/download HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\n\r\n",
b"GET /qft/download HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\nConnection: close\r\n\r\n",
).unwrap();
client.flush().unwrap();
thread::sleep(Duration::from_millis(50));
@@ -346,7 +391,7 @@ mod tests {
let mut stream = TcpStream::connect(address).unwrap();
write!(
stream,
"GET /qft/download HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\n{}\r\n",
"GET /qft/download HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\nConnection: close\r\n{}\r\n",
range.map(|v| format!("Range: {v}\r\n")).unwrap_or_default(),
).unwrap();
stream.flush().unwrap();
@@ -365,3 +410,85 @@ mod tests {
bytes.windows(4).position(|v| v == b"\r\n\r\n").unwrap() + 4
}
}
#[cfg(test)]
mod keep_alive_tests {
use super::{handle_client, SenderEvent};
use std::{
fs,
io::{BufRead, BufReader, Read, Write},
net::{TcpListener, TcpStream},
sync::mpsc,
thread,
};
/// 在**同一条** TCP 上连发多个 Range 请求,全部必须成功。
///
/// 此前每个响应都写死 Connection: close,并行下载的每个分块都要
/// 重建一次 TCP —— 1 GB 64 次、10 GB 640 次,既是"短连接频繁断开"
/// 的来源,也白白付出握手与慢启动的代价。
#[test]
fn serves_multiple_ranges_on_one_connection() {
let path = std::env::temp_dir().join(format!("qft-keepalive-{}.bin", std::process::id()));
let payload: Vec<u8> = (0..4096u32).map(|i| (i % 251) as u8).collect();
fs::write(&path, &payload).unwrap();
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let address = listener.local_addr().unwrap();
let (events, _rx) = mpsc::channel::<SenderEvent>();
let served = path.clone();
let server = thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
handle_client(&mut stream, &served, "p.bin", payload.len() as u64, "tok", &events)
});
let mut stream = TcpStream::connect(address).unwrap();
let mut reader = BufReader::new(stream.try_clone().unwrap());
// 三段互不重叠的 Range,全部走同一条连接
for (start, end) in [(0u64, 1023u64), (1024, 2047), (2048, 4095)] {
write!(
stream,
"GET /qft/download HTTP/1.1\r\nHost: x\r\nX-QFT-Token: tok\r\nRange: bytes={start}-{end}\r\n\r\n"
).unwrap();
stream.flush().unwrap();
let mut status = String::new();
reader.read_line(&mut status).unwrap();
assert!(status.starts_with("HTTP/1.1 206"), "第 {start} 段状态行:{status}");
let mut length = 0usize;
let mut keep_alive = false;
loop {
let mut line = String::new();
reader.read_line(&mut line).unwrap();
if line == "\r\n" { break }
if let Some((name, value)) = line.split_once(':') {
match name.trim().to_ascii_lowercase().as_str() {
"content-length" => length = value.trim().parse().unwrap(),
"connection" => keep_alive = value.trim().eq_ignore_ascii_case("keep-alive"),
_ => {}
}
}
}
assert!(keep_alive, "响应必须声明 keep-alive,否则客户端会关掉连接");
assert_eq!(length as u64, end - start + 1, "Content-Length 应等于该段长度");
let mut body = vec![0u8; length];
reader.read_exact(&mut body).unwrap();
let expected: Vec<u8> = (start..=end).map(|i| ((i as u32) % 251) as u8).collect();
assert_eq!(body, expected, "第 {start} 段内容不符");
}
// 显式要求关闭时应断开,服务端随之正常收尾
write!(stream, "GET /qft/ping HTTP/1.1\r\nHost: x\r\nX-QFT-Token: tok\r\nConnection: close\r\n\r\n").unwrap();
stream.flush().unwrap();
let mut rest = Vec::new();
reader.read_to_end(&mut rest).unwrap();
let text = String::from_utf8_lossy(&rest);
assert!(text.contains("Connection: close"), "显式 close 时应回 close:{text}");
server.join().unwrap().unwrap();
fs::remove_file(path).unwrap();
}
}