Files
QFT/ios/CoreTests/MockPCServer.py
T
zhy200308 376ffba96e feat(desktop): 跨平台桌面端 + 电脑↔电脑互传(v0.5.0-m1)
对应 V05_EXECUTION_PLAN 的 P1。核心改动是把「PC 只能当服务端」
这个写死的角色拆开——此前 TcpStream::connect 只出现在测试里,
桌面端根本无法主动连接另一台桌面端,PC↔PC 因此完全不可用。

跨平台
- windows/ → desktop/,crate 更名 qft-desktop
- 新增 platform.rs 收敛全部平台差异:配置目录(LOCALAPPDATA /
  Application Support / XDG)、下载目录(含 Linux 本地化的 ~/下载)、
  设备名、Direct AP 能力。约定:其余模块不得再出现 #[cfg(target_os)]
- direct_ap.rs 的 Context 导入按平台条件化,非 Windows 上不再告警
- macOS 上已实测编译并链接出可执行文件(65 MB Mach-O arm64),
  这是本仓库首次在非 Windows 平台构建成功

电脑 ↔ 电脑
- 新增 client.rs:桌面端发起侧。手写 HTTP,不引入客户端依赖——
  服务端本来就是手写的,两边同一套解析更容易与 Android/iOS 对齐。
  含并发分块上传(自适应 4/8/16 MiB、最多 8 worker)与 Range 断点续传
- 新增 discovery.rs:UDP 广播 QFTBROWSE3 浏览局域网节点。
  既有的 QFTDISC2 是「已知令牌找机器」,用于扫码之后;
  PC 没有摄像头,必须先能列出附近有谁
- receiver.rs 新增 POST /qft/pair:用 6 位配对码换会话令牌。
  这是唯一不校验令牌的端点。6 位仅约 20 bit 熵,配严格失败计数兜底——
  错 5 次即作废,需重启接收;比较用定长实现,不做短路返回
- 新增「电脑 ↔ 电脑」界面:接收方显示配对码与本机地址;
  发送方搜索/手动输入地址 → 输码连接 → 多选文件 → 带进度发送

验证(macOS,Rust 1.97.1)
- cargo check 0 错误,cargo test 17/17 通过
- 新增端到端用例:真实起接收服务 → 配对(含错误码必须被拒)→
  9 MB 跨多分块并发上传 → 校验落盘内容逐字节一致且 SHA-256 与
  接收端返回值相同。这就是 PC↔PC 的完整链路
- 11 项 Python 自检全部通过

顺带修复
- single_channel_guard_selftest 长期为红:它断言
  DEFAULT_CHUNK_SIZE = 450,而代码早已改为 320。改名前即存在,
  已用 git stash 验证与本次无关。改为范围检查(128~4096)并在
  PASS 信息里打印实际值,既挡住"退回多通道小块"又不会因调参误报

已知限制
- UDP 广播只覆盖同一广播域。跨网段或 AP 隔离的 Wi-Fi 上搜索不到,
  需手动输入对方 IP(界面已说明)。mDNS 留待后续
- 本阶段仍走 v2 明文 HTTP,加密随 QFT-Stream v3 一起做(见 P2)
2026-08-11 16:36:33 +08:00

242 lines
8.7 KiB
Python

#!/usr/bin/env python3
"""按 desktop/src/{sender,receiver}.rs 的线上语义实现的假电脑端。
存在的意义:Swift 客户端的线格式必须和 Rust 端逐字节一致,
而 Rust 端在这台机器上编译不了。这个 mock 把两端的契约固定下来,
任何一边改了 header 名、路径或 JSON 字段,集成测试都会红。
用法:
python3 MockPCServer.py --token <session> --serve <文件> --save-dir <目录> --port 0
启动后在 stdout 打印一行 `READY <port>`,供测试脚本读取。
"""
import argparse
import base64
import hashlib
import json
import os
import socket
import sys
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
STATE = {}
def b64url_decode(text):
padding = "=" * (-len(text) % 4)
return base64.urlsafe_b64decode(text + padding)
def b64url_encode(data):
return base64.urlsafe_b64encode(data).decode("ascii").rstrip("=")
class Handler(BaseHTTPRequestHandler):
protocol_version = "HTTP/1.1"
def log_message(self, *_args):
pass
# -------------------------------------------------- 工具
def _json(self, code, payload):
body = json.dumps(payload).encode("utf-8")
self.send_response(code)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.send_header("Connection", "close")
self.end_headers()
self.wfile.write(body)
def _authorized(self):
if self.headers.get("X-QFT-Token") != STATE["token"]:
self.send_response(403)
self.send_header("Content-Length", "0")
self.send_header("Connection", "close")
self.end_headers()
return False
# 设备名必须是 base64url,解不出来说明客户端编码错了
device = self.headers.get("X-QFT-Device")
if device is not None:
b64url_decode(device).decode("utf-8")
return True
# -------------------------------------------------- GET
def do_GET(self):
if not self._authorized():
return
if self.path == "/qft/ping":
return self._json(200, {"ok": True, "protocol": 2, "parallel": True})
if self.path == "/qft/download":
return self._download()
return self._json(404, {"ok": False})
def _download(self):
path = STATE["serve"]
size = os.path.getsize(path)
offset = 0
header = self.headers.get("Range")
if header:
assert header.startswith("bytes="), "只支持 bytes= 形式的 Range"
assert header.endswith("-"), "sender.rs 只支持单段开区间 Range"
offset = int(header[len("bytes="):-1])
assert 0 <= offset < size, "Range 越界"
remaining = size - offset
self.send_response(206 if offset else 200)
self.send_header("Content-Type", "application/octet-stream")
self.send_header("Content-Length", str(remaining))
self.send_header("Accept-Ranges", "bytes")
if offset:
self.send_header("Content-Range", "bytes %d-%d/%d" % (offset, size - 1, size))
self.send_header("X-QFT-Filename", b64url_encode(os.path.basename(path).encode("utf-8")))
self.send_header("Connection", "close")
self.end_headers()
with open(path, "rb") as fh:
fh.seek(offset)
while True:
block = fh.read(256 * 1024)
if not block:
break
self.wfile.write(block)
# -------------------------------------------------- POST
def do_POST(self):
if not self._authorized():
return
if self.path == "/qft/upload/init":
return self._upload_init()
if self.path.startswith("/qft/upload/chunk/"):
return self._upload_chunk()
if self.path.startswith("/qft/upload/finish/"):
return self._upload_finish()
return self._json(404, {"ok": False})
def _upload_init(self):
name = b64url_decode(self.headers["X-QFT-Filename"]).decode("utf-8")
size = int(self.headers["X-QFT-Size"])
chunk_size = int(self.headers.get("X-QFT-Chunk-Size", 8 * 1024 * 1024))
chunk_size = max(1024 * 1024, min(16 * 1024 * 1024, chunk_size))
total = 0 if size == 0 else (size + chunk_size - 1) // chunk_size
upload_id = base64.urlsafe_b64encode(os.urandom(9)).decode("ascii").rstrip("=")
part = os.path.join(STATE["save_dir"], "%s.%s.qftpart" % (name, upload_id))
with open(part, "wb") as fh:
fh.truncate(size)
STATE["uploads"][upload_id] = {
"name": name, "size": size, "chunk_size": chunk_size,
"total": total, "part": part, "received": [False] * total,
"lock": threading.Lock(),
}
return self._json(200, {"ok": True, "upload_id": upload_id,
"chunk_size": chunk_size, "total_chunks": total})
def _upload_chunk(self):
suffix = self.path[len("/qft/upload/chunk/"):]
upload_id, _, index_text = suffix.partition("/")
index = int(index_text)
session = STATE["uploads"].get(upload_id)
if session is None:
return self._json(500, {"ok": False, "error": "unknown upload"})
length = int(self.headers["Content-Length"])
offset = index * session["chunk_size"]
expected = min(session["chunk_size"], session["size"] - offset)
assert length == expected, "chunk 长度不匹配:%d != %d" % (length, expected)
body = b""
while len(body) < length:
block = self.rfile.read(length - len(body))
if not block:
break
body += block
assert len(body) == length, "chunk 体不完整"
with session["lock"]:
if session["received"][index]:
return self._json(200, {"ok": True, "duplicate": True})
with open(session["part"], "r+b") as fh:
fh.seek(offset)
fh.write(body)
session["received"][index] = True
return self._json(200, {"ok": True})
def _upload_finish(self):
upload_id = self.path[len("/qft/upload/finish/"):]
session = STATE["uploads"].get(upload_id)
if session is None:
return self._json(500, {"ok": False, "error": "unknown upload"})
missing = session["received"].count(False)
if missing:
return self._json(409, {"ok": False, "missing": missing})
digest = hashlib.sha256()
with open(session["part"], "rb") as fh:
while True:
block = fh.read(1024 * 1024)
if not block:
break
digest.update(block)
final = os.path.join(STATE["save_dir"], session["name"])
os.replace(session["part"], final)
del STATE["uploads"][upload_id]
return self._json(200, {"ok": True, "sha256": digest.hexdigest(), "size": session["size"]})
def udp_responder(token, http_port, stop):
"""QFTDISC2:<token> → QFTHERE2:<token>:<port>,对应 sender.rs 的发现线程。"""
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
sock.bind(("0.0.0.0", 39392))
except OSError:
return
sock.settimeout(0.25)
expected = ("QFTDISC2:%s" % token).encode("ascii")
reply = ("QFTHERE2:%s:%d" % (token, http_port)).encode("ascii")
while not stop.is_set():
try:
data, peer = sock.recvfrom(512)
except socket.timeout:
continue
except OSError:
break
if data == expected:
sock.sendto(reply, peer)
sock.close()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--token", required=True)
parser.add_argument("--serve", required=True, help="供 /qft/download 下发的文件")
parser.add_argument("--save-dir", required=True, help="接收上传的目录")
parser.add_argument("--port", type=int, default=0)
parser.add_argument("--udp", action="store_true", help="同时启动 UDP 发现应答")
args = parser.parse_args()
STATE.update(token=args.token, serve=args.serve, save_dir=args.save_dir, uploads={})
os.makedirs(args.save_dir, exist_ok=True)
server = ThreadingHTTPServer(("127.0.0.1", args.port), Handler)
port = server.server_address[1]
stop = threading.Event()
if args.udp:
threading.Thread(target=udp_responder, args=(args.token, port, stop), daemon=True).start()
print("READY %d" % port, flush=True)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
finally:
stop.set()
if __name__ == "__main__":
main()