mirror of
https://gitee.com/xmz7891/ykxmz.git
synced 2026-10-18 16:00:43 +00:00
xmz7891
8880e7033d
== 现象 ==
用户报：
* 局域网能搜到电脑，IP/端口/配对码都对，连上后**没有任何反应**
* 走中转「已配对」，但点按钮没反应
局域网那一半已经修过（preferLan）。这次抓到的是**经中转**那一半，
而且比预想的严重得多。
== 证据链（插桩复现出来的）==
被控端日志里直接抛了未捕获异常，线程当场死：
Exception in thread client-relay:
server.py:407 session.send(reply)
relay.py:166 self._link.send_to_client(data)
relay.py:357 self._post("/v1/agent/send", ...)
relay.py:766 raise RelayError(f"请求失败: {last_error}")
lanremote.relay.RelayError: 请求失败: Idle
之后的状态：
* client-relay 线程没了 —— 电脑再也不往手表回任何东西
* relay-link 线程还活着、还在长轮询 —— 中转那边看着「设备在线」
* **手表看到的就是「连上了，但按一下毫无反应」**
写入仓库的测试 _tests/test_relay_local.py 一直是这个形状：
前面几项 PASS、跑到经中转发命令就卡死。之前没人深挖。
== 根因 1：一条 HTTP/1.1 连接被两个线程同时用 ==
_post() 里锁只包住「取连接」那一段：
with self._http_lock:
connection = self._http # 锁到这里就放了
try:
connection.request("POST", ...) # 锁外发请求
于是两个线程会同时用同一条 connection：
* relay-link 线程跑 /v1/agent/poll —— 长轮询，一条请求挂 180 秒
* client-relay 线程同时 POST /v1/agent/send
HTTP/1.1 一条连接同一时刻只能有一个在途请求，第二个线程一进来
就撞上 http.client 状态机，抛 CannotSendRequest("Idle")。
_post 的「重试一次」也救不了：它 _drop_http() 之后，另一个线程
手里还攥着那条旧连接对象在发，照样坏。
修法：
* **发命令用独立连接**（_post 加 dedicated 参数）。
长轮询那条常年被占着，发命令不该去挤它，各走各的。
* 两条连接各自一把锁**锁住整个「发请求 + 读响应」周期**，
不再只锁取连接那一下。
* 普通请求若发现缓存连接正忙（长轮询在途），临时另开一条用完即关。
* _drop_http(dedicated=) 区分清哪条；finally 里一定归还占用
（否则那条连接会被永久标记为忙）。
== 根因 2：回包失败会打死整个会话线程 ==
server.py 的 _client_loop 里：
if reply is not None:
session.send(reply) # <- 不在任何 try 里
...
except OSError: # <- 外层只捕获 OSError
pass
而中转链路上 send 抛的是 RelayError，直接冒出去把线程打死。
**死一次就永久哑**，代价太大。
修法：session.send() 单独兜住所有异常，失败就断开这个会话
（让手表重连），绝不让线程消失。外层也补一个兜底 except。
== 修复效果 ==
修复前：pair OK -> ping OK -> ping 卡死 -> 线程崩溃，永久哑
修复后：pair 21ms -> ping 82ms -> ping 4ms -> ping 6ms，零异常
_tests/test_relay_local.py：**之前完全卡死 -> 现在 21/21 全过**
这个测试之前一直是红的，说明「35 个阶段的回归全绿」这件事
本身就不成立过 —— 某个阶段卡住时看起来像环境问题而不是缺陷。
== 同批修掉验证阶段找到的其它问题 ==
1. **TTL 清理 + 关掉接入开关 = 设备永久锁死**（严重）
register() 用 `device_id in self.devices` 判断老设备，但超时清理
把设备从 devices 和 codes 都删了。电脑关机过夜（必然 > 6 小时）
第二天开机就会被自己的开关挡住，而且**重启也救不回来**
（清 codes 时没落盘，重启后又当孤儿清一遍，自我维系）。
管理员在页面上还看不到这台设备，不知道该放开谁。
修法：状态文件里单独存 knownDevices 设备历史，超时清理绝不动它；
register 改查这份历史；清理后补 _save()；delete_device 才真正忘记。
2. **管理页 JS 语法错误 -> 所有按钮失效**（严重）
admin.py 里 ADMIN_JS 是普通三引号字符串，我在 Python 源码里写的
`\n` 被变成真实换行，拼进 JS 就是字符串里的裸换行 ->
整段 <script> 不执行 -> 改码/删除/批量删除/全选全变幽灵按键。
元凶是我加改码功能那次提交。改成 `\\n`。
3. **--relay / --relay-status 崩溃**（严重）
RelayLink.start(url) 的 url 是必填参数，我把默认地址改空白时
run_agent.py 两处调用没跟着改。一处被 try 吞成「测试失败：missing
1 required positional argument」（用户以为地址填错了），
一处直接报栈。两处都补上 url。
4. 非法 deviceId（控制字符 / 路径分隔符）现在被拒（白名单：
字母数字 + - _ . :）
5. enable_relay() 第二次调用不再谎报成功（加 RelayLink.running 属性，
返回值反映真实运行状态；不再用「对象建过没有」判断）
6. snapshot() 清孤儿码后补 _save()，磁盘和内存不再脱节
== 局域网全面优化（task-2，另一个智能体完成）==
4 个真问题：
* **网段判断写死 /24** —— 在 /16 网络上 10.8.1.5 和 10.8.2.5
被判成不同网络，明明能直连却去走中转还费流量。
改成按网卡真实掩码比较。
* **广播只发一个包** —— 丢一个就整轮搜不到。改成 5 个时间点重发。
* **只探一个网段** —— 多网卡手表搜不到另一网段的电脑。改成全探。
* **走中转之后再也回不到局域网** —— 出门再回家永远挂中转。
新增定期回切（先便宜地 TCP ping，通了才动真格，
不破坏正在工作的中转连接）。
实测：局域网握手 2ms、50/50 = 100%、中位 0ms。
（跨网络那半之前拿不到数字，就是被上面那个线程崩溃挡住的 ——
现已修复。）
顺带：instance.py 单实例锁端口加 YKXMZ_LOCK_PORT 覆盖（默认不变）。
用户自己那台被控端正跑在这台机器上占着 8767/TCP + 8766/UDP，
是这次排查里好几个「测试怎么都不通」的根因。
== 服务端一键部署脚本（task-1，另一个智能体完成）==
relay/deploy.sh + relay/deploy-tune.sh，随服务端 zip 发布：
* 自动检查并安装 cloudflared
* 部署程序、装 4 个 systemd 服务、网络调优、配隧道、自检打公网地址
* **不传 --hostname 且没有 TUNNEL_TOKEN 时明确提示要填**，
不会静默用一个写死的域名（用户明确说过这个中转站是他自己用的，
不对外开放，绝不能把私人域名烧成默认值）
* 重跑 = 升级，已有数据/配对码/管理密码/凭据都不动
顺带修了发布包一直缺 site_shots/ 的老 bug
（package_remote.py 用 iterdir()+is_file() 收文件，目录进不去，
新机器装完官网截图全是 404）。
== 默认中转地址改成空白 ==
用户要求：软件默认不带任何中转地址，由用户自己填。
四处硬编码全部清空（server.py / MainActivity.java / run_agent.py /
relay.py 的注释和文档示例），全仓已无非注释的硬编码地址。
== 文档同步（task-5，另一个智能体完成）==
README / BEFORE-INSTALL / AFTER-INSTALL / 打包模板：
* 新增「软件里不带任何中转地址」告示，讲清跨网络要自己部署
* 修正 Android 版本（写的是 9.0/API28，实际 API 24 / Android 7.0）
* 删掉「地址已经内置好了」（现在是错的）
* AGENT_README 原来把作者自己的中转地址当成「内置地址」发给用户，已重写
* RELAY_README 原来写「两条隧道同时跑会互相争抢」，
和真机/CHANGELOG 矛盾；按实测改成「两种协议同时在跑（故意的）」
306 lines
13 KiB
Python
306 lines
13 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""局域网优化这一轮的回归测试。
|
||
|
||
覆盖四件事（每件都对应一个"原来怎么错/慢"）：
|
||
|
||
1. **网段判断不再写死 /24**
|
||
原来 `sameSubnet` 只比前三段，等于假设 /24。在 10.x/8、172.16/12
|
||
或任何 /16 网络上（校园网、部分路由器），
|
||
手表 10.8.1.5 电脑 10.8.2.5 （掩码 /16，其实同一个网络）
|
||
会被判成"不同网络" -> **明明能直连却去走中转**。
|
||
现在按网卡真实掩码比较。
|
||
|
||
2. **广播发现要重发**
|
||
原来只在 t=0 发一个 UDP 探测包，丢了就整轮搜不到。
|
||
现在按时间点重发多轮，并且同时打受限广播 + 各网段的定向广播。
|
||
|
||
3. **多网卡要都探**
|
||
原来 `localNet()` 拿到第一个 wlan 就 return，只探一个网段。
|
||
现在 `localNets()` 返回全部，搜索/扫描都覆盖。
|
||
|
||
4. **走中转之后要能自己回到局域网**
|
||
原来只在"刚经中转连上"那一刻试一次直连，之后永远挂在中转上。
|
||
现在会定期回头检查，能直连就切回来。
|
||
|
||
另外验证「默认中转地址是空白」不会把功能弄坏。
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import os
|
||
import shutil
|
||
import socket
|
||
import subprocess
|
||
import sys
|
||
import tempfile
|
||
import time
|
||
from pathlib import Path
|
||
|
||
ROOT = Path(__file__).resolve().parent.parent
|
||
sys.path.insert(0, str(ROOT / "windows"))
|
||
sys.path.insert(0, str(ROOT / "_tests"))
|
||
|
||
WATCH = ROOT / "android" / "src" / "com" / "lanremote" / "watch"
|
||
MAIN = WATCH / "MainActivity.java"
|
||
DISCOVERY_JAVA = WATCH / "Discovery.java"
|
||
CORE_JAVA = WATCH / "DiscoveryCore.java"
|
||
|
||
passed = 0
|
||
failed = 0
|
||
|
||
|
||
def check(name, ok, detail=""):
|
||
global passed, failed
|
||
if ok:
|
||
passed += 1
|
||
print(" [PASS] " + name)
|
||
else:
|
||
failed += 1
|
||
print(" [FAIL] " + name + " " + str(detail))
|
||
|
||
|
||
def main() -> int:
|
||
from lanremote import discovery
|
||
from lanremote import instance
|
||
|
||
main_src = MAIN.read_text(encoding="utf-8")
|
||
disc_src = DISCOVERY_JAVA.read_text(encoding="utf-8")
|
||
core_src = CORE_JAVA.read_text(encoding="utf-8")
|
||
|
||
# ==================================================================
|
||
print("一、网段判断按真实掩码（不再写死 /24）")
|
||
# ==================================================================
|
||
check("DiscoveryCore 有按前缀比较的方法",
|
||
"public static boolean sameSubnet(String a, String b, int prefix)"
|
||
in core_src)
|
||
check("DiscoveryCore 保留 /24 兜底实现",
|
||
"public static boolean sameSubnet24" in core_src)
|
||
check("MainActivity 有 inSameSubnet 包装",
|
||
"private boolean inSameSubnet(" in main_src)
|
||
check("hostInMySubnet 用真实网卡掩码（Discovery.localNets）",
|
||
"Discovery.localNets()" in main_src)
|
||
check("pickSameSubnet 也用真实掩码",
|
||
main_src.count("Discovery.localNets()") >= 2,
|
||
main_src.count("Discovery.localNets()"))
|
||
check("拿不到掩码时退回 /24（不写死也不放弃）",
|
||
"return sameSubnet(a, b);" in main_src)
|
||
|
||
# ==================================================================
|
||
print()
|
||
print("二、广播发现要重发 + 多网段")
|
||
# ==================================================================
|
||
check("DiscoveryCore 有重发时间表",
|
||
"PROBE_AT_MS" in core_src)
|
||
check("DiscoveryCore 有 searchMany（多广播地址）",
|
||
"public static List<Found> searchMany(" in core_src)
|
||
check("旧的 search(timeout, extra) 还在（向后兼容）",
|
||
"public static List<Found> search(int timeoutMs, String extraBroadcast)"
|
||
in core_src)
|
||
check("Discovery 有 localNets（全部网卡）",
|
||
"public static List<LocalNet> localNets()" in disc_src)
|
||
check("Discovery 有 directedBroadcasts（全部网段广播）",
|
||
"public static List<String> directedBroadcasts()" in disc_src)
|
||
check("搜索用 searchMany 而不是单发",
|
||
"DiscoveryCore.searchMany(timeoutMs, directedBroadcasts())" in disc_src)
|
||
check("子网扫描覆盖所有网段",
|
||
"for (LocalNet net : localNets())" in disc_src)
|
||
|
||
# Python 侧（被控端那边用的是同一套逻辑）
|
||
check("Python discover 也重发", len(discovery._PROBE_AT) >= 3,
|
||
discovery._PROBE_AT)
|
||
check("Python 会算本网段定向广播",
|
||
isinstance(discovery.local_broadcasts(), list))
|
||
broadcasts = discovery.local_broadcasts()
|
||
check("定向广播都是 x.y.z.255 形式",
|
||
all(b.endswith(".255") and b.count(".") == 3 for b in broadcasts),
|
||
broadcasts)
|
||
check("定向广播不包含 APIPA(169.254)",
|
||
all(not b.startswith("169.254.") for b in broadcasts), broadcasts)
|
||
|
||
# ==================================================================
|
||
print()
|
||
print("三、走中转之后能自己回到局域网")
|
||
# ==================================================================
|
||
check("有 scheduleLanRecheck", "private void scheduleLanRecheck()" in main_src)
|
||
check("有 tryLanReconnect", "private void tryLanReconnect()" in main_src)
|
||
check("回切前先做便宜的 TCP 探测（不白断中转）",
|
||
"DiscoveryCore.ping(ip, port, 2000)" in main_src)
|
||
check("没配中转时不排定时器（默认空白也不空转）",
|
||
"if (relayUrl().isEmpty())" in main_src)
|
||
check("防重入", "lanRecheckScheduled" in main_src)
|
||
check("销毁时取消回调", "removeCallbacksAndMessages(null)" in main_src)
|
||
check("失败会退避（不会疯狂重试）",
|
||
"LAN_RECHECK_MAX_MS" in main_src and "lanRecheckDelay * 2" in main_src)
|
||
# 连接成功时按"走的是哪条路"决定要不要回切
|
||
check("连上中转后排一次回切检查",
|
||
"scheduleLanRecheck();" in main_src)
|
||
check("切中转成功后也排一次",
|
||
main_src.count("scheduleLanRecheck();") >= 3,
|
||
main_src.count("scheduleLanRecheck();"))
|
||
|
||
# ==================================================================
|
||
print()
|
||
print("四、默认中转地址是空白，而且不影响局域网")
|
||
# ==================================================================
|
||
from lanremote.server import DEFAULT_RELAY_URL
|
||
check("server.py 的默认中转是空字符串", DEFAULT_RELAY_URL == "",
|
||
repr(DEFAULT_RELAY_URL))
|
||
check("MainActivity 的默认中转是空字符串",
|
||
'DEFAULT_RELAY_URL = "";' in main_src)
|
||
check("不再硬编码旧设备地址", "192.168.2.156" not in main_src)
|
||
# 旧公网域名只允许出现在注释/文档里，**不允许**作为默认值的字面量
|
||
check("没有把旧公网域名当默认值",
|
||
'DEFAULT_RELAY_URL = "https://' not in main_src)
|
||
|
||
# 单实例锁端口可以被覆盖（测试才能和用户自己的实例并存）
|
||
check("instance 有 control_port()", hasattr(instance, "control_port"))
|
||
old = os.environ.pop("YKXMZ_LOCK_PORT", None)
|
||
try:
|
||
check("不设环境变量时用默认 8767",
|
||
instance.control_port() == 8767, instance.control_port())
|
||
os.environ["YKXMZ_LOCK_PORT"] = "18099"
|
||
check("设了就用覆盖值", instance.control_port() == 18099,
|
||
instance.control_port())
|
||
os.environ["YKXMZ_LOCK_PORT"] = "not-a-port"
|
||
check("非法值退回默认", instance.control_port() == 8767,
|
||
instance.control_port())
|
||
os.environ["YKXMZ_LOCK_PORT"] = "99999"
|
||
check("超范围退回默认", instance.control_port() == 8767,
|
||
instance.control_port())
|
||
finally:
|
||
os.environ.pop("YKXMZ_LOCK_PORT", None)
|
||
if old is not None:
|
||
os.environ["YKXMZ_LOCK_PORT"] = old
|
||
|
||
# ==================================================================
|
||
print()
|
||
print("五、默认空白时：局域网这条路必须照常工作")
|
||
# ==================================================================
|
||
# 起一个"没有配中转"的真实被控端，验证：
|
||
# * 起得来、不报错、不卡
|
||
# * 局域网 TCP 能连、能配对、能执行命令
|
||
work = Path(tempfile.mkdtemp(prefix="lan_opt_"))
|
||
agent = None
|
||
try:
|
||
from lanremote.config import Store
|
||
data = work / "data"
|
||
data.mkdir(parents=True, exist_ok=True)
|
||
port = _free_port()
|
||
store = Store(data)
|
||
store.set_pairing_code("246813")
|
||
store.set("setup_done", True)
|
||
store.set("allow_new_pairing", True)
|
||
store.set("close_pair_after_first", False)
|
||
store.set("server_name", "无中转测试机")
|
||
store.set("port", port)
|
||
# 刻意**不设** relay_url，走 DEFAULT_RELAY_URL（空）
|
||
|
||
env = dict(os.environ)
|
||
env.update({"YKXMZ_DATA": str(data),
|
||
"YKXMZ_LOCK_PORT": str(_free_port()),
|
||
"PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1"})
|
||
agent = subprocess.Popen(
|
||
[sys.executable, "-u", str(ROOT / "windows" / "run_agent.py"),
|
||
"--silent", "--port", str(port)],
|
||
cwd=str(ROOT / "windows"), env=env,
|
||
stdout=open(work / "agent.log", "wb"), stderr=subprocess.STDOUT)
|
||
|
||
ready = False
|
||
deadline = time.time() + 30
|
||
while time.time() < deadline:
|
||
time.sleep(0.5)
|
||
if agent.poll() is not None:
|
||
break
|
||
try:
|
||
with socket.create_connection(("127.0.0.1", port), 1.0):
|
||
ready = True
|
||
break
|
||
except OSError:
|
||
continue
|
||
check("没配中转时被控端正常起来（局域网端口在听）", ready,
|
||
(work / "agent.log").read_text(encoding="utf-8",
|
||
errors="replace")[-300:])
|
||
|
||
if ready:
|
||
check("被控端进程没有异常退出", agent.poll() is None)
|
||
# 真走一遍协议：配对 + ping
|
||
sock = socket.create_connection(("127.0.0.1", port), 5.0)
|
||
sock.settimeout(8.0)
|
||
try:
|
||
reply = _call(sock, {"cmd": "pair", "deviceId": "lan-opt-test",
|
||
"deviceName": "测试手表",
|
||
"code": "246813"})
|
||
check("没有中转也能配对（局域网直连）",
|
||
bool(reply.get("ok")), str(reply)[:120])
|
||
token = reply.get("token", "")
|
||
check("拿到设备令牌", len(token) == 32, token)
|
||
|
||
pong = _call(sock, {"cmd": "ping"})
|
||
check("没有中转也能执行命令", bool(pong.get("ok")),
|
||
str(pong)[:120])
|
||
finally:
|
||
sock.close()
|
||
|
||
# 日志里应该明确说"只走局域网"，而不是报错或去连一个不存在的地址
|
||
time.sleep(1.0)
|
||
log = ""
|
||
try:
|
||
log = (data / "silent.log").read_text(encoding="utf-8",
|
||
errors="replace")
|
||
except OSError:
|
||
pass
|
||
check("日志里说明了只走局域网",
|
||
"只走局域网" in log, log[-200:])
|
||
check("日志里没有中转报错",
|
||
"启用中转失败" not in log and "Traceback" not in log,
|
||
log[-300:])
|
||
finally:
|
||
if agent is not None:
|
||
try:
|
||
agent.terminate()
|
||
agent.wait(timeout=6)
|
||
except Exception: # noqa: BLE001
|
||
try:
|
||
agent.kill()
|
||
except Exception: # noqa: BLE001
|
||
pass
|
||
time.sleep(0.4)
|
||
shutil.rmtree(work, ignore_errors=True)
|
||
|
||
print()
|
||
print("=" * 62)
|
||
print("通过 %d 项，失败 %d 项" % (passed, failed))
|
||
return 0 if failed == 0 else 1
|
||
|
||
|
||
def _free_port() -> int:
|
||
with socket.socket() as probe:
|
||
probe.bind(("127.0.0.1", 0))
|
||
return probe.getsockname()[1]
|
||
|
||
|
||
def _call(sock, obj, timeout=8.0):
|
||
"""发一条命令读一条回复（换行分隔 JSON）。"""
|
||
sock.settimeout(timeout)
|
||
sock.sendall((json.dumps(obj, ensure_ascii=False) + "\n").encode("utf-8"))
|
||
buf = b""
|
||
deadline = time.time() + timeout
|
||
while time.time() < deadline:
|
||
while b"\n" in buf:
|
||
line, _, buf = buf.partition(b"\n")
|
||
if not line.strip():
|
||
continue
|
||
message = json.loads(line.decode("utf-8"))
|
||
if "event" in message:
|
||
continue
|
||
return message
|
||
chunk = sock.recv(65536)
|
||
if not chunk:
|
||
raise ConnectionError("被控端关闭了连接")
|
||
buf += chunk
|
||
raise TimeoutError("等回复超时")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|