280 lines
11 KiB
Python
280 lines
11 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)
|
||
header = self.headers.get("Range")
|
||
# 老版本/别的实现可能整个忽略 Range,直接把整份文件送过来。
|
||
# 客户端必须能识别这种服务端并回落单流下载。
|
||
if STATE.get("ignore_range"):
|
||
header = None
|
||
# 与 sender.rs::parse_range 同一套语义:开区间与闭区间都接受,
|
||
# 不支持后缀 Range,越界一律拒绝。
|
||
offset, end = 0, max(size - 1, 0)
|
||
if header:
|
||
assert header.startswith("bytes="), "只支持 bytes= 形式的 Range"
|
||
start_text, _, end_text = header[len("bytes="):].partition("-")
|
||
assert start_text, "不支持后缀 Range"
|
||
offset = int(start_text)
|
||
end = int(end_text) if end_text else size - 1
|
||
assert 0 <= offset < size and offset <= end < size, "Range 越界"
|
||
remaining = 0 if size == 0 else end - offset + 1
|
||
|
||
self.send_response(206 if header else 200)
|
||
self.send_header("Content-Type", "application/octet-stream")
|
||
self.send_header("Content-Length", str(remaining))
|
||
self.send_header("Accept-Ranges", "bytes")
|
||
if header:
|
||
self.send_header("Content-Range", "bytes %d-%d/%d" % (offset, end, size))
|
||
self.send_header("X-QFT-Filename", b64url_encode(os.path.basename(path).encode("utf-8")))
|
||
# 并行下载会在一条连接上连续发多个 Range 请求,
|
||
# sender.rs 对这种请求保持 keep-alive
|
||
self.send_header("Connection", "keep-alive")
|
||
self.end_headers()
|
||
with open(path, "rb") as fh:
|
||
fh.seek(offset)
|
||
left = remaining
|
||
while left > 0:
|
||
block = fh.read(min(256 * 1024, left))
|
||
if not block:
|
||
break
|
||
self.wfile.write(block)
|
||
left -= len(block)
|
||
|
||
# -------------------------------------------------- POST
|
||
|
||
def do_POST(self):
|
||
# 配对是唯一不校验令牌的端点——它的作用正是换取令牌
|
||
if self.path == "/qft/pair":
|
||
return self._pair()
|
||
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 _pair(self):
|
||
"""receiver.rs::handle_pair:6 位十六进制秘密换会话令牌,错 5 次作废。"""
|
||
max_failures = 5
|
||
if STATE["pair_failures"] >= max_failures:
|
||
return self._json(429, {"ok": False, "error": "配对码已因多次输入错误作废"})
|
||
if self.headers.get("X-QFT-Code") != STATE["code"]:
|
||
STATE["pair_failures"] += 1
|
||
return self._json(403, {
|
||
"ok": False,
|
||
"remaining": max_failures - STATE["pair_failures"],
|
||
})
|
||
STATE["pair_failures"] = 0
|
||
return self._json(200, {"ok": True, "token": STATE["token"]})
|
||
|
||
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):
|
||
"""receiver.rs 的 UDP 线程:既回 QFTDISC2,也回不带令牌的 QFTBROWSE3。"""
|
||
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")
|
||
announce = ("QFTNODE3:" + json.dumps(
|
||
{"n": "MOCK-PC", "p": "macos", "t": http_port, "r": True},
|
||
separators=(",", ":"))).encode("utf-8")
|
||
while not stop.is_set():
|
||
try:
|
||
data, peer = sock.recvfrom(512)
|
||
except socket.timeout:
|
||
continue
|
||
except OSError:
|
||
break
|
||
if data == b"QFTBROWSE3":
|
||
sock.sendto(announce, peer)
|
||
elif 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 发现应答")
|
||
parser.add_argument("--code", default="a1b2c3", help="/qft/pair 使用的 6 位十六进制秘密")
|
||
parser.add_argument("--ignore-range", action="store_true",
|
||
help="模拟不支持分段下载的电脑端,永远返回 200 整份文件")
|
||
args = parser.parse_args()
|
||
|
||
STATE.update(token=args.token, serve=args.serve, save_dir=args.save_dir, uploads={},
|
||
code=args.code, pair_failures=0, ignore_range=args.ignore_range)
|
||
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()
|