mirror of
https://gitee.com/xmz7891/ykxmz.git
synced 2026-10-18 11:20:43 +00:00
修「经中转几次后永久哑掉」——「按一下没反应」的真因
== 现象 ==
用户报：
* 局域网能搜到电脑，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 矛盾；按实测改成「两种协议同时在跑（故意的）」
This commit is contained in:
xmz7891
@@ -0,0 +1,27 @@
|
||||
{
|
||||
"port": 8841,
|
||||
"server_name": "DESKTOP-RN5I625",
|
||||
"allow_run": true,
|
||||
"allow_power": true,
|
||||
"allow_screen": true,
|
||||
"start_minimized": false,
|
||||
"allow_new_pairing": true,
|
||||
"image_timeout": 0,
|
||||
"image_display": "window",
|
||||
"image_custom_width": 0,
|
||||
"image_custom_height": 0,
|
||||
"image_window_title": "",
|
||||
"tts_voice": "",
|
||||
"tts_rate": 0,
|
||||
"mp3_dir": "",
|
||||
"file_roots": "",
|
||||
"extra_apps": "",
|
||||
"extra_commands": "",
|
||||
"download_dir": "received",
|
||||
"screen_max_width": 480,
|
||||
"screen_quality": 72,
|
||||
"screen_fps": 12,
|
||||
"pairing_code": "097783",
|
||||
"pairing_created": 1791366548.4543607,
|
||||
"close_pair_after_first": true
|
||||
}
|
||||
+312
-251
@@ -1,251 +1,312 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""局域网自动发现（UDP 广播）。
|
||||
|
||||
目的：**手表端不用输 IP**。
|
||||
手表往局域网广播一个探测包，被控端收到后单播回自己的名字和端口，
|
||||
手表就能自动填好地址直接连。
|
||||
|
||||
这样也顺手解决了另一个坑：电脑换了网络、IP 变了、或者机器上有
|
||||
Tailscale / VMware 之类虚拟网卡时，用户猜不准该填哪个 IP。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import socket
|
||||
|
||||
from . import __version__ as _APP_VERSION
|
||||
import threading
|
||||
import time
|
||||
|
||||
DISCOVERY_PORT = 8766
|
||||
PROBE_MAGIC = "LANREMOTE_DISCOVER"
|
||||
REPLY_MAGIC = "LANREMOTE_REPLY"
|
||||
# 手表点「连不上？」时广播这个，电脑收到就弹出网络自检窗口
|
||||
SELFCHECK_MAGIC = "LANREMOTE_SELFCHECK"
|
||||
ACK_MAGIC = "LANREMOTE_ACK"
|
||||
PROTOCOL = 1
|
||||
|
||||
|
||||
def build_reply(name: str, tcp_port: int, version: str) -> bytes:
|
||||
payload = {
|
||||
"lanremote": REPLY_MAGIC,
|
||||
"proto": PROTOCOL,
|
||||
"name": name,
|
||||
"port": tcp_port,
|
||||
"version": version,
|
||||
}
|
||||
return json.dumps(payload, ensure_ascii=False).encode("utf-8")
|
||||
|
||||
|
||||
def build_selfcheck_ack(name: str, note: str = "") -> bytes:
|
||||
"""自检应答。
|
||||
|
||||
note 带上电脑这边的诊断结论 —— 手表拿到就直接显示，
|
||||
不需要在被控端弹窗口（用户要的是全程无窗口）。
|
||||
"""
|
||||
payload = {"lanremote": ACK_MAGIC, "name": name, "note": note}
|
||||
return json.dumps(payload, ensure_ascii=False).encode("utf-8")
|
||||
|
||||
|
||||
def build_selfcheck_request() -> bytes:
|
||||
payload = {"lanremote": SELFCHECK_MAGIC, "proto": PROTOCOL}
|
||||
return json.dumps(payload, ensure_ascii=False).encode("utf-8")
|
||||
|
||||
|
||||
def parse_selfcheck(data: bytes) -> dict | None:
|
||||
try:
|
||||
obj = json.loads(data.decode("utf-8", errors="replace"))
|
||||
except ValueError:
|
||||
return None
|
||||
if not isinstance(obj, dict):
|
||||
return None
|
||||
if obj.get("lanremote") != SELFCHECK_MAGIC:
|
||||
return None
|
||||
return obj
|
||||
|
||||
|
||||
def parse_probe(data: bytes) -> dict | None:
|
||||
try:
|
||||
obj = json.loads(data.decode("utf-8", errors="replace"))
|
||||
except ValueError:
|
||||
return None
|
||||
if not isinstance(obj, dict):
|
||||
return None
|
||||
if obj.get("lanremote") != PROBE_MAGIC:
|
||||
return None
|
||||
return obj
|
||||
|
||||
|
||||
class DiscoveryResponder:
|
||||
"""监听 UDP 探测包并回复本机地址。"""
|
||||
|
||||
def __init__(self, store, tcp_port: int, version: str = "",
|
||||
port: int = DISCOVERY_PORT, on_probe=None):
|
||||
self.store = store
|
||||
self.tcp_port = int(tcp_port)
|
||||
self.version = version or _APP_VERSION
|
||||
self.port = int(port)
|
||||
self.on_probe = on_probe # 可选回调，用于界面提示"有人在找这台电脑"
|
||||
# 收到「请打开网络自检」的请求时调用；由上层决定怎么弹窗口
|
||||
self.on_selfcheck = None
|
||||
# 最近一次自检的结论，随 ACK 回给手表
|
||||
self._selfcheck_note = ""
|
||||
self.selfcheck_requests = 0
|
||||
self._sock: socket.socket | None = None
|
||||
self._thread: threading.Thread | None = None
|
||||
self._running = False
|
||||
self.probes_answered = 0
|
||||
self.last_probe_at = 0.0
|
||||
self.last_error = ""
|
||||
|
||||
@property
|
||||
def running(self) -> bool:
|
||||
return self._running and self._thread is not None and self._thread.is_alive()
|
||||
|
||||
def start(self) -> bool:
|
||||
if self.running:
|
||||
return True
|
||||
try:
|
||||
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
# Windows 上 SO_REUSEADDR 允许第二个进程绑同一 UDP 端口，
|
||||
# 两个实例会互相抢探测包。改用独占绑定，第二个实例直接失败。
|
||||
if hasattr(socket, "SO_EXCLUSIVEADDRUSE"):
|
||||
try:
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
|
||||
except OSError:
|
||||
pass
|
||||
else:
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
||||
try:
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
|
||||
except OSError:
|
||||
pass
|
||||
sock.bind(("0.0.0.0", self.port))
|
||||
sock.settimeout(1.0)
|
||||
except OSError as exc:
|
||||
self.last_error = f"无法监听 UDP {self.port}: {exc}"
|
||||
return False
|
||||
|
||||
self._sock = sock
|
||||
self._running = True
|
||||
self._thread = threading.Thread(target=self._loop, name="discovery",
|
||||
daemon=True)
|
||||
self._thread.start()
|
||||
return True
|
||||
|
||||
def stop(self) -> None:
|
||||
self._running = False
|
||||
thread = self._thread
|
||||
if thread is not None and thread.is_alive():
|
||||
thread.join(timeout=3.0)
|
||||
self._thread = None
|
||||
if self._sock is not None:
|
||||
try:
|
||||
self._sock.close()
|
||||
except OSError:
|
||||
pass
|
||||
self._sock = None
|
||||
|
||||
def _loop(self) -> None:
|
||||
reply = build_reply(str(self.store.get("server_name", "")),
|
||||
self.tcp_port, self.version)
|
||||
while self._running:
|
||||
try:
|
||||
data, addr = self._sock.recvfrom(2048)
|
||||
except socket.timeout:
|
||||
continue
|
||||
except OSError:
|
||||
break
|
||||
|
||||
# 先看是不是「请打开网络自检」的请求
|
||||
if parse_selfcheck(data) is not None:
|
||||
self.selfcheck_requests += 1
|
||||
try:
|
||||
self._sock.sendto(
|
||||
build_selfcheck_ack(
|
||||
str(self.store.get("server_name", "")),
|
||||
self._selfcheck_note),
|
||||
addr)
|
||||
except OSError:
|
||||
pass
|
||||
if self.on_selfcheck:
|
||||
try:
|
||||
# 回调可以返回一段话，随 ACK 一起回给手表
|
||||
produced = self.on_selfcheck(addr[0])
|
||||
if isinstance(produced, str) and produced:
|
||||
self._selfcheck_note = produced[:1500]
|
||||
except Exception:
|
||||
pass
|
||||
continue
|
||||
|
||||
probe = parse_probe(data)
|
||||
if probe is None:
|
||||
continue
|
||||
|
||||
self.probes_answered += 1
|
||||
self.last_probe_at = time.time()
|
||||
# 单播回复给发起方
|
||||
try:
|
||||
self._sock.sendto(reply, addr)
|
||||
except OSError as exc:
|
||||
self.last_error = str(exc)
|
||||
continue
|
||||
|
||||
if self.on_probe:
|
||||
try:
|
||||
self.on_probe(addr[0])
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
def status(self) -> dict:
|
||||
return {
|
||||
"running": self.running,
|
||||
"port": self.port,
|
||||
"answered": self.probes_answered,
|
||||
"last_probe": self.last_probe_at,
|
||||
"selfcheck_requests": self.selfcheck_requests,
|
||||
"error": self.last_error,
|
||||
}
|
||||
|
||||
|
||||
def discover(timeout: float = 2.5, port: int = DISCOVERY_PORT,
|
||||
broadcast: str = "255.255.255.255") -> list[dict]:
|
||||
"""客户端侧：广播探测并收集回复（手表端用的是同一套逻辑）。"""
|
||||
results: list[dict] = []
|
||||
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
try:
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
|
||||
sock.settimeout(0.4)
|
||||
probe = json.dumps({"lanremote": PROBE_MAGIC, "proto": PROTOCOL}).encode()
|
||||
sock.sendto(probe, (broadcast, port))
|
||||
deadline = time.time() + timeout
|
||||
while time.time() < deadline:
|
||||
try:
|
||||
data, addr = sock.recvfrom(2048)
|
||||
except socket.timeout:
|
||||
continue
|
||||
except OSError:
|
||||
break
|
||||
try:
|
||||
obj = json.loads(data.decode("utf-8", errors="replace"))
|
||||
except ValueError:
|
||||
continue
|
||||
if obj.get("lanremote") != REPLY_MAGIC:
|
||||
continue
|
||||
results.append({
|
||||
"host": addr[0],
|
||||
"port": int(obj.get("port") or 0),
|
||||
"name": obj.get("name") or "",
|
||||
"version": obj.get("version") or "",
|
||||
})
|
||||
finally:
|
||||
sock.close()
|
||||
# 按主机去重
|
||||
seen = set()
|
||||
unique = []
|
||||
for item in results:
|
||||
if item["host"] in seen:
|
||||
continue
|
||||
seen.add(item["host"])
|
||||
unique.append(item)
|
||||
return unique
|
||||
# -*- coding: utf-8 -*-
|
||||
"""局域网自动发现（UDP 广播）。
|
||||
|
||||
目的：**手表端不用输 IP**。
|
||||
手表往局域网广播一个探测包，被控端收到后单播回自己的名字和端口，
|
||||
手表就能自动填好地址直接连。
|
||||
|
||||
这样也顺手解决了另一个坑：电脑换了网络、IP 变了、或者机器上有
|
||||
Tailscale / VMware 之类虚拟网卡时，用户猜不准该填哪个 IP。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import socket
|
||||
|
||||
from . import __version__ as _APP_VERSION
|
||||
import threading
|
||||
import time
|
||||
|
||||
DISCOVERY_PORT = 8766
|
||||
PROBE_MAGIC = "LANREMOTE_DISCOVER"
|
||||
REPLY_MAGIC = "LANREMOTE_REPLY"
|
||||
# 手表点「连不上？」时广播这个，电脑收到就弹出网络自检窗口
|
||||
SELFCHECK_MAGIC = "LANREMOTE_SELFCHECK"
|
||||
ACK_MAGIC = "LANREMOTE_ACK"
|
||||
PROTOCOL = 1
|
||||
|
||||
|
||||
def build_reply(name: str, tcp_port: int, version: str) -> bytes:
|
||||
payload = {
|
||||
"lanremote": REPLY_MAGIC,
|
||||
"proto": PROTOCOL,
|
||||
"name": name,
|
||||
"port": tcp_port,
|
||||
"version": version,
|
||||
}
|
||||
return json.dumps(payload, ensure_ascii=False).encode("utf-8")
|
||||
|
||||
|
||||
def build_selfcheck_ack(name: str, note: str = "") -> bytes:
|
||||
"""自检应答。
|
||||
|
||||
note 带上电脑这边的诊断结论 —— 手表拿到就直接显示，
|
||||
不需要在被控端弹窗口（用户要的是全程无窗口）。
|
||||
"""
|
||||
payload = {"lanremote": ACK_MAGIC, "name": name, "note": note}
|
||||
return json.dumps(payload, ensure_ascii=False).encode("utf-8")
|
||||
|
||||
|
||||
def build_selfcheck_request() -> bytes:
|
||||
payload = {"lanremote": SELFCHECK_MAGIC, "proto": PROTOCOL}
|
||||
return json.dumps(payload, ensure_ascii=False).encode("utf-8")
|
||||
|
||||
|
||||
def parse_selfcheck(data: bytes) -> dict | None:
|
||||
try:
|
||||
obj = json.loads(data.decode("utf-8", errors="replace"))
|
||||
except ValueError:
|
||||
return None
|
||||
if not isinstance(obj, dict):
|
||||
return None
|
||||
if obj.get("lanremote") != SELFCHECK_MAGIC:
|
||||
return None
|
||||
return obj
|
||||
|
||||
|
||||
def parse_probe(data: bytes) -> dict | None:
|
||||
try:
|
||||
obj = json.loads(data.decode("utf-8", errors="replace"))
|
||||
except ValueError:
|
||||
return None
|
||||
if not isinstance(obj, dict):
|
||||
return None
|
||||
if obj.get("lanremote") != PROBE_MAGIC:
|
||||
return None
|
||||
return obj
|
||||
|
||||
|
||||
class DiscoveryResponder:
|
||||
"""监听 UDP 探测包并回复本机地址。"""
|
||||
|
||||
def __init__(self, store, tcp_port: int, version: str = "",
|
||||
port: int = DISCOVERY_PORT, on_probe=None):
|
||||
self.store = store
|
||||
self.tcp_port = int(tcp_port)
|
||||
self.version = version or _APP_VERSION
|
||||
self.port = int(port)
|
||||
self.on_probe = on_probe # 可选回调，用于界面提示"有人在找这台电脑"
|
||||
# 收到「请打开网络自检」的请求时调用；由上层决定怎么弹窗口
|
||||
self.on_selfcheck = None
|
||||
# 最近一次自检的结论，随 ACK 回给手表
|
||||
self._selfcheck_note = ""
|
||||
self.selfcheck_requests = 0
|
||||
self._sock: socket.socket | None = None
|
||||
self._thread: threading.Thread | None = None
|
||||
self._running = False
|
||||
self.probes_answered = 0
|
||||
self.last_probe_at = 0.0
|
||||
self.last_error = ""
|
||||
|
||||
@property
|
||||
def running(self) -> bool:
|
||||
return self._running and self._thread is not None and self._thread.is_alive()
|
||||
|
||||
def start(self) -> bool:
|
||||
if self.running:
|
||||
return True
|
||||
try:
|
||||
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
# Windows 上 SO_REUSEADDR 允许第二个进程绑同一 UDP 端口，
|
||||
# 两个实例会互相抢探测包。改用独占绑定，第二个实例直接失败。
|
||||
if hasattr(socket, "SO_EXCLUSIVEADDRUSE"):
|
||||
try:
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
|
||||
except OSError:
|
||||
pass
|
||||
else:
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
||||
try:
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
|
||||
except OSError:
|
||||
pass
|
||||
sock.bind(("0.0.0.0", self.port))
|
||||
sock.settimeout(1.0)
|
||||
except OSError as exc:
|
||||
self.last_error = f"无法监听 UDP {self.port}: {exc}"
|
||||
return False
|
||||
|
||||
self._sock = sock
|
||||
self._running = True
|
||||
self._thread = threading.Thread(target=self._loop, name="discovery",
|
||||
daemon=True)
|
||||
self._thread.start()
|
||||
return True
|
||||
|
||||
def stop(self) -> None:
|
||||
self._running = False
|
||||
thread = self._thread
|
||||
if thread is not None and thread.is_alive():
|
||||
thread.join(timeout=3.0)
|
||||
self._thread = None
|
||||
if self._sock is not None:
|
||||
try:
|
||||
self._sock.close()
|
||||
except OSError:
|
||||
pass
|
||||
self._sock = None
|
||||
|
||||
def _loop(self) -> None:
|
||||
reply = build_reply(str(self.store.get("server_name", "")),
|
||||
self.tcp_port, self.version)
|
||||
while self._running:
|
||||
try:
|
||||
data, addr = self._sock.recvfrom(2048)
|
||||
except socket.timeout:
|
||||
continue
|
||||
except OSError:
|
||||
break
|
||||
|
||||
# 先看是不是「请打开网络自检」的请求
|
||||
if parse_selfcheck(data) is not None:
|
||||
self.selfcheck_requests += 1
|
||||
try:
|
||||
self._sock.sendto(
|
||||
build_selfcheck_ack(
|
||||
str(self.store.get("server_name", "")),
|
||||
self._selfcheck_note),
|
||||
addr)
|
||||
except OSError:
|
||||
pass
|
||||
if self.on_selfcheck:
|
||||
try:
|
||||
# 回调可以返回一段话，随 ACK 一起回给手表
|
||||
produced = self.on_selfcheck(addr[0])
|
||||
if isinstance(produced, str) and produced:
|
||||
self._selfcheck_note = produced[:1500]
|
||||
except Exception:
|
||||
pass
|
||||
continue
|
||||
|
||||
probe = parse_probe(data)
|
||||
if probe is None:
|
||||
continue
|
||||
|
||||
self.probes_answered += 1
|
||||
self.last_probe_at = time.time()
|
||||
# 单播回复给发起方
|
||||
try:
|
||||
self._sock.sendto(reply, addr)
|
||||
except OSError as exc:
|
||||
self.last_error = str(exc)
|
||||
continue
|
||||
|
||||
if self.on_probe:
|
||||
try:
|
||||
self.on_probe(addr[0])
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
def status(self) -> dict:
|
||||
return {
|
||||
"running": self.running,
|
||||
"port": self.port,
|
||||
"answered": self.probes_answered,
|
||||
"last_probe": self.last_probe_at,
|
||||
"selfcheck_requests": self.selfcheck_requests,
|
||||
"error": self.last_error,
|
||||
}
|
||||
|
||||
|
||||
def local_broadcasts() -> list[str]:
|
||||
"""本机各网段可能用到的**定向广播地址**。
|
||||
|
||||
为什么要算这个：很多路由器和安卓版本**不转发 255.255.255.255**
|
||||
（受限广播），只转发本网段的定向广播（如 192.168.10.255）。
|
||||
只发受限广播时，表现就是"搜不到电脑"。
|
||||
|
||||
纯标准库拿不到 Windows 的掩码，所以：
|
||||
* 先取本机所有局域网 IPv4
|
||||
* 对每个地址按 /24 推出 x.y.z.255
|
||||
家用/办公网绝大多数是 /24，这一招够用；剩下的靠受限广播兜底。
|
||||
"""
|
||||
out: list[str] = []
|
||||
try:
|
||||
from .server import lan_ips
|
||||
ips = lan_ips()
|
||||
except Exception: # noqa: BLE001
|
||||
ips = []
|
||||
for ip in ips:
|
||||
if ip.startswith("169.254."):
|
||||
continue # APIPA/链路本地，发了也没用
|
||||
parts = ip.split(".")
|
||||
if len(parts) != 4:
|
||||
continue
|
||||
directed = ".".join(parts[:3] + ["255"])
|
||||
if directed not in out:
|
||||
out.append(directed)
|
||||
return out
|
||||
|
||||
|
||||
# 探测包重发的时间点（秒，相对开始）。
|
||||
# UDP 广播是尽力而为，只发一次的话丢一个包就整轮搜不到。
|
||||
_PROBE_AT = (0.0, 0.35, 0.9, 1.8, 3.0)
|
||||
|
||||
|
||||
def discover(timeout: float = 2.5, port: int = DISCOVERY_PORT,
|
||||
broadcast: str = "255.255.255.255") -> list[dict]:
|
||||
"""客户端侧：广播探测并收集回复（手表端用的是同一套逻辑）。
|
||||
|
||||
会**重发多轮**并同时打受限广播和本网段定向广播 —— 原来只发一次、
|
||||
而且只发 255.255.255.255，广播一丢或路由器不转发受限广播就搜不到。
|
||||
"""
|
||||
results: list[dict] = []
|
||||
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
try:
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
|
||||
sock.settimeout(0.2)
|
||||
probe = json.dumps({"lanremote": PROBE_MAGIC,
|
||||
"proto": PROTOCOL}).encode()
|
||||
|
||||
targets: list[str] = []
|
||||
for one in (broadcast,) + tuple(local_broadcasts()):
|
||||
if one and one not in targets:
|
||||
targets.append(one)
|
||||
|
||||
start = time.time()
|
||||
deadline = start + timeout
|
||||
next_probe = 0
|
||||
|
||||
while time.time() < deadline:
|
||||
# 到点就重发一轮
|
||||
elapsed = time.time() - start
|
||||
while next_probe < len(_PROBE_AT) and elapsed >= _PROBE_AT[next_probe]:
|
||||
for target in targets:
|
||||
try:
|
||||
sock.sendto(probe, (target, port))
|
||||
except OSError:
|
||||
# 某个广播地址不可用时跳过，不影响其他目标
|
||||
pass
|
||||
next_probe += 1
|
||||
|
||||
try:
|
||||
data, addr = sock.recvfrom(2048)
|
||||
except socket.timeout:
|
||||
continue
|
||||
except OSError:
|
||||
break
|
||||
try:
|
||||
obj = json.loads(data.decode("utf-8", errors="replace"))
|
||||
except ValueError:
|
||||
continue
|
||||
if not isinstance(obj, dict):
|
||||
continue
|
||||
if obj.get("lanremote") != REPLY_MAGIC:
|
||||
continue
|
||||
results.append({
|
||||
"host": addr[0],
|
||||
"port": int(obj.get("port") or 0),
|
||||
"name": obj.get("name") or "",
|
||||
"version": obj.get("version") or "",
|
||||
})
|
||||
finally:
|
||||
sock.close()
|
||||
# 按主机去重
|
||||
seen = set()
|
||||
unique = []
|
||||
for item in results:
|
||||
if item["host"] in seen:
|
||||
continue
|
||||
seen.add(item["host"])
|
||||
unique.append(item)
|
||||
return unique
|
||||
|
||||
@@ -5,9 +5,17 @@
|
||||
而不是又起一个进程（那样端口会冲突，用户会以为坏了）。
|
||||
|
||||
做法：主实例占住一个本机回环端口；后启动的实例连上去发个 "show" 就退出。
|
||||
|
||||
端口可以用环境变量 YKXMZ_LOCK_PORT 覆盖：
|
||||
测试需要在"用户自己的实例正在跑"的同时再起一个被控端。
|
||||
不加这个口子的话，测试实例一启动就看到锁被占，直接退出
|
||||
（日志里只有一句"已有实例在运行，退出"），
|
||||
表现成"测试怎么都不登记到中转"，很难查。
|
||||
默认值不变，正常运行完全不受影响。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import socket
|
||||
import threading
|
||||
|
||||
@@ -15,9 +23,22 @@ CONTROL_PORT = 8767
|
||||
_CMD_SHOW = b"SHOW"
|
||||
|
||||
|
||||
def control_port() -> int:
|
||||
"""单实例锁用的端口（允许用环境变量覆盖，主要给测试用）。"""
|
||||
raw = str(os.environ.get("YKXMZ_LOCK_PORT") or "").strip()
|
||||
if raw:
|
||||
try:
|
||||
value = int(raw)
|
||||
if 1 <= value <= 65535:
|
||||
return value
|
||||
except ValueError:
|
||||
pass
|
||||
return CONTROL_PORT
|
||||
|
||||
|
||||
class InstanceLock:
|
||||
def __init__(self, port: int = CONTROL_PORT):
|
||||
self.port = port
|
||||
def __init__(self, port: int | None = None):
|
||||
self.port = control_port() if port is None else int(port)
|
||||
self._sock: socket.socket | None = None
|
||||
self._thread: threading.Thread | None = None
|
||||
self._running = False
|
||||
@@ -95,8 +116,10 @@ class InstanceLock:
|
||||
self._sock = None
|
||||
|
||||
|
||||
def signal_show(port: int = CONTROL_PORT, timeout: float = 2.0) -> bool:
|
||||
def signal_show(port: int | None = None, timeout: float = 2.0) -> bool:
|
||||
"""通知已在运行的实例把窗口显示出来。"""
|
||||
if port is None:
|
||||
port = control_port()
|
||||
try:
|
||||
sock = socket.create_connection(("127.0.0.1", port), timeout=timeout)
|
||||
sock.sendall(_CMD_SHOW)
|
||||
|
||||
@@ -239,6 +239,15 @@ class RelayLink:
|
||||
# 实测：每次新建 70% 可用，复用 100%。
|
||||
self._http = None
|
||||
self._http_lock = threading.RLock()
|
||||
# 缓存的那条连接现在有没有在途请求。
|
||||
# /v1/agent/poll 是长轮询，一条请求挂 180 秒 ——
|
||||
# 那段时间里这条连接**不能**被别的线程再拿去发请求，
|
||||
# 否则 HTTP/1.1 状态机直接抛 CannotSendRequest("Idle")。
|
||||
self._http_busy = False
|
||||
# 发命令专用连接。长轮询那条常年被占着，
|
||||
# 发命令不能去挤它 —— 各走各的。
|
||||
self._http_send = None
|
||||
self._send_lock = threading.RLock()
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# 对外
|
||||
@@ -310,12 +319,21 @@ class RelayLink:
|
||||
self._log(f"中转已启用：{self.url}")
|
||||
return True
|
||||
|
||||
@property
|
||||
def running(self) -> bool:
|
||||
"""中转链路现在是不是真的在跑。
|
||||
|
||||
对外给 server.enable_relay() 判断用 ——
|
||||
那边以前靠"对象建过没有"来判成功，会在没配地址时谎报。
|
||||
"""
|
||||
return bool(self._running)
|
||||
|
||||
def stop(self) -> None:
|
||||
self._running = False
|
||||
with self._socket_lock:
|
||||
if self._socket is not None:
|
||||
self._socket.close()
|
||||
self._socket = None
|
||||
self._socket = None
|
||||
if self.token:
|
||||
try:
|
||||
self._post("/v1/agent/bye", b"", {"X-Token": self.token},
|
||||
@@ -345,8 +363,12 @@ class RelayLink:
|
||||
return
|
||||
for start in range(0, len(data), 256 * 1024):
|
||||
piece = data[start:start + 256 * 1024]
|
||||
# dedicated=True：走发命令专用连接，不和长轮询挤一条。
|
||||
# 这是「按一下没反应」的修复点 —— 以前这里和长轮询共用
|
||||
# 一条 HTTP/1.1 连接，撞上状态机就抛 "Idle"，
|
||||
# 异常一路冒到 client-relay 线程外面把它打死。
|
||||
self._post("/v1/agent/send", piece, {"X-Token": self.token},
|
||||
timeout=POLL_TIMEOUT)
|
||||
timeout=POLL_TIMEOUT, dedicated=True)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# 内部
|
||||
@@ -685,10 +707,24 @@ class RelayLink:
|
||||
return http.client.HTTPConnection(host, parts.port or 80,
|
||||
timeout=POLL_TIMEOUT)
|
||||
|
||||
def _drop_http(self) -> None:
|
||||
"""把缓存的连接关掉（出错后调用，下次会重开）。"""
|
||||
def _drop_http(self, dedicated: bool = False) -> None:
|
||||
"""把缓存的连接关掉（出错后调用，下次会重开）。
|
||||
|
||||
dedicated=True 时清的是"发命令专用连接"，
|
||||
否则清长轮询用的那条。
|
||||
"""
|
||||
if dedicated:
|
||||
with self._send_lock:
|
||||
connection, self._http_send = self._http_send, None
|
||||
if connection is not None:
|
||||
try:
|
||||
connection.close()
|
||||
except Exception: # noqa: BLE001
|
||||
pass
|
||||
return
|
||||
with self._http_lock:
|
||||
connection, self._http = self._http, None
|
||||
self._http_busy = False
|
||||
if connection is not None:
|
||||
try:
|
||||
connection.close()
|
||||
@@ -696,7 +732,8 @@ class RelayLink:
|
||||
pass
|
||||
|
||||
def _post(self, path: str, body: bytes, headers: dict,
|
||||
timeout: float = POLL_TIMEOUT, want_headers: bool = False):
|
||||
timeout: float = POLL_TIMEOUT, want_headers: bool = False,
|
||||
dedicated: bool = False):
|
||||
"""POST 一个请求，**复用同一条连接**。
|
||||
|
||||
为什么要复用（真机实测）：
|
||||
@@ -716,11 +753,31 @@ class RelayLink:
|
||||
|
||||
last_error = None
|
||||
for attempt in (1, 2):
|
||||
with self._http_lock:
|
||||
connection = self._http
|
||||
# 取一条可以独占使用的连接：
|
||||
# * dedicated=True -> 发命令专用连接（自己一把锁锁全程）
|
||||
# * 普通请求 -> 缓存连接；**如果它正忙（长轮询在途）
|
||||
# 就临时开一条，用完即关**
|
||||
# 关键：锁必须盖住整个"发请求 + 读响应"周期，
|
||||
# 不能只锁"取连接"那一下 —— 否则两个线程会用同一条连接。
|
||||
if dedicated:
|
||||
self._send_lock.acquire()
|
||||
connection = self._http_send
|
||||
if connection is None:
|
||||
connection = self._open_http()
|
||||
self._http = connection
|
||||
self._http_send = connection
|
||||
temporary = False
|
||||
else:
|
||||
with self._http_lock:
|
||||
if self._http is None:
|
||||
self._http = self._open_http()
|
||||
if self._http_busy:
|
||||
# 缓存连接正被长轮询占着，临时另开一条
|
||||
connection = self._open_http()
|
||||
temporary = True
|
||||
else:
|
||||
connection = self._http
|
||||
self._http_busy = True
|
||||
temporary = False
|
||||
try:
|
||||
connection.timeout = timeout
|
||||
connection.request("POST", path, body=body, headers=send)
|
||||
@@ -749,10 +806,23 @@ class RelayLink:
|
||||
except Exception as exc: # noqa: BLE001
|
||||
# 连接层面的问题：关掉，下一轮重开
|
||||
last_error = exc
|
||||
self._drop_http()
|
||||
self._drop_http(dedicated=dedicated)
|
||||
if attempt == 2:
|
||||
break
|
||||
self._log_quiet(f"连接断了，重开一次再试（{exc}）")
|
||||
finally:
|
||||
# 无论成功失败都要把"占用"还回去，
|
||||
# 否则这条连接会被永久标记为忙，之后每次请求都另开临时连接。
|
||||
if dedicated:
|
||||
self._send_lock.release()
|
||||
elif not temporary:
|
||||
with self._http_lock:
|
||||
self._http_busy = False
|
||||
else:
|
||||
try:
|
||||
connection.close()
|
||||
except Exception: # noqa: BLE001
|
||||
pass
|
||||
|
||||
raise RelayError(f"请求失败: {last_error}")
|
||||
|
||||
|
||||
+40
-17
@@ -80,18 +80,21 @@ class Session:
|
||||
pass
|
||||
|
||||
|
||||
# 内置的中转地址。没配过就用它，这样电脑端跑起来就能连，
|
||||
# 用户一个地址都不用填。
|
||||
# 内置的中转地址：**默认留空**，由用户自己在设置里填。
|
||||
#
|
||||
# 为什么是两个并用分号隔开：
|
||||
# 随身 WiFi 和电脑经常在同一个局域网 -> 走第一个（局域网直连，
|
||||
# 几十毫秒，而且地址永远不变）
|
||||
# 电脑在外面 -> 第一个连不上，自动切第二个（Cloudflare 隧道，
|
||||
# 600 毫秒左右，地址固定 relay.xxmxxs.top）
|
||||
# 内置的中转地址：局域网优先，连不上自动切公网隧道。
|
||||
# 第一个是随身 WiFi 的固定地址（写死是因为它常在同一网段、直连最快）；
|
||||
# 它变了也没关系 —— 连上过的地址会被记住并排到最前面。
|
||||
DEFAULT_RELAY_URL = "192.168.2.156:8080;https://relay.xxmxxs.top"
|
||||
# 为什么不再内置一个：
|
||||
# 原来写死了一台随身 WiFi 的地址 + 一个公网隧道域名。问题是
|
||||
# 那台设备的 IP 会变（DHCP），写死的地址很快就过期，用户开箱
|
||||
# 就一直在连一个不存在的主机，表现成"一直转圈/连不上"。
|
||||
# 与其猜一个迟早会错的地址，不如留空 —— 局域网本身完全不受影响。
|
||||
#
|
||||
# 空字符串的含义：**只走局域网**。
|
||||
# * UDP 广播发现、TCP 直连、配对、命令下发，全都照常工作
|
||||
# * 不会去连任何中转，不报错、不卡住（RelayLink.start("") 会直接跳过）
|
||||
# * 用户想要跨网络时，在「中转设置」里填自己的地址即可
|
||||
# * 多个地址可用分号隔开，按顺序尝试，例如：
|
||||
# http://192.168.1.10:8080;https://你自己的域名
|
||||
DEFAULT_RELAY_URL = ""
|
||||
|
||||
|
||||
class RemoteServer:
|
||||
@@ -308,13 +311,19 @@ class RemoteServer:
|
||||
|
||||
target = (url or "").strip() or str(self.store.get("relay_url") or "")
|
||||
if not target.strip():
|
||||
# 没配过就用内置默认值 —— 开箱即用，用户不用填地址。
|
||||
# 局域网优先（快、稳、地址不会变），不在同一网络时自动走隧道。
|
||||
# （只是默认值，用户随时能在设置里改成别的。）
|
||||
# 没配过就用内置默认值 —— 现在是空字符串，表示"只走局域网"。
|
||||
# 这时候**什么都不做**是正确的：局域网监听已经起来了，
|
||||
# 不报错、不重试、不占用任何后台线程。
|
||||
target = DEFAULT_RELAY_URL
|
||||
self._log(f"没配过中转地址，用内置默认值：{target}")
|
||||
if not target.strip():
|
||||
self._log("没配中转地址，只走局域网"
|
||||
"（需要跨网络时在设置里填中转地址）")
|
||||
# ⚠ 这里以前是 `if self._relay is not None: return True` ——
|
||||
# 只要对象建过就报成功。而"没配中转地址"那条路也会把对象建起来
|
||||
# （start("") 返回 False），于是第二次调用会谎报中转在跑。
|
||||
# 改成看**真实运行状态**。
|
||||
if self._relay is not None:
|
||||
return True
|
||||
return bool(getattr(self._relay, "running", False))
|
||||
|
||||
self._relay = RelayLink(self.store, log=self._log,
|
||||
on_session=self.adopt_relay_socket,
|
||||
@@ -395,9 +404,23 @@ class RemoteServer:
|
||||
reply = {"ok": False, "error": f"内部错误: {exc}"}
|
||||
self._log(f"[错误] {exc}")
|
||||
if reply is not None:
|
||||
session.send(reply)
|
||||
# ⚠ 这里必须兜住**所有**异常。
|
||||
# 以前只在外层捕获 OSError，而 session.send() 在
|
||||
# 中转链路上会抛 RelayError（实测："请求失败: Idle"）——
|
||||
# 那个异常一路冒出去，把 client-relay 线程整个打死。
|
||||
# 线程一死，电脑就再也不往手表回任何东西，
|
||||
# 而 relay-link 还在长轮询、中转看着"设备在线"，
|
||||
# 用户看到的就是"连上了，按一下毫无反应"。
|
||||
# 发失败最多踢掉这个会话让手表重连，绝不能丢线程。
|
||||
try:
|
||||
session.send(reply)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
self._log(f"[错误] 回包失败，断开该会话：{exc}")
|
||||
break
|
||||
except OSError:
|
||||
pass
|
||||
except Exception as exc: # noqa: BLE001
|
||||
self._log(f"[错误] 会话循环异常退出：{exc}")
|
||||
finally:
|
||||
with self._lock:
|
||||
if session in self.sessions:
|
||||
|
||||
+20
-6
@@ -73,9 +73,9 @@ def parse_args(argv=None):
|
||||
parser.add_argument("--relay", default=None, metavar="地址",
|
||||
help="设置中转服务器地址（跨网络用）。"
|
||||
"可用分号分隔多个，按顺序尝试，例如："
|
||||
"http://192.168.2.156:8080;https://relay.xxmxxs.top"
|
||||
"http://192.168.1.10:8080;https://aaa.bbb.com"
|
||||
" —— 局域网优先，断了自动切隧道。"
|
||||
"传空字符串关闭")
|
||||
"传空字符串关闭（默认就是空，只走局域网）")
|
||||
parser.add_argument("--relay-status", action="store_true",
|
||||
help="查看中转连接状态")
|
||||
parser.add_argument("--uninstall", action="store_true",
|
||||
@@ -293,7 +293,10 @@ def cli_relay(url: str) -> int:
|
||||
try:
|
||||
from lanremote.relay import RelayLink
|
||||
link = RelayLink(store)
|
||||
if not link.start():
|
||||
# start() 的 url 是必填参数 —— 之前这里没传，
|
||||
# 被 try 兜住后打成"✗ 测试失败：missing 1 required positional
|
||||
# argument: 'url'"，用户以为是自己地址填错了。
|
||||
if not link.start(url):
|
||||
print(" 启动失败")
|
||||
wait_key()
|
||||
return 1
|
||||
@@ -322,17 +325,28 @@ def cli_relay_status() -> int:
|
||||
"""看现在的中转状态。"""
|
||||
from lanremote.relay import RelayLink
|
||||
store = Store(data_dir())
|
||||
url = str(store.get("relay_url") or "") or "192.168.2.156:8080;https://relay.xxmxxs.top"
|
||||
# 不给默认值：中转地址由用户自己填（--relay 或设置界面）。
|
||||
# 以前这里兜底了一个写死的地址，结果是「我明明没填，它却去连一个
|
||||
# 我根本不认识的服务器」，而且那个地址早过期了。
|
||||
url = str(store.get("relay_url") or "")
|
||||
attach_console()
|
||||
if not url:
|
||||
print("没有配置中转（只在局域网内可用）")
|
||||
print("要跨网络请运行：ykxmz.exe --relay https://你的中转地址")
|
||||
wait_key()
|
||||
return 0
|
||||
|
||||
# start() 的 url 是必填参数。之前这里调 link.start() 不传参，
|
||||
# 而且不在任何 try 里 —— 直接抛 TypeError 给用户看一堆堆栈。
|
||||
try:
|
||||
link = RelayLink(store)
|
||||
link.start(url)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
print("启动中转链路失败：%s" % exc)
|
||||
wait_key()
|
||||
return 1
|
||||
print(f"中转地址：{url}")
|
||||
print("正在测…")
|
||||
link = RelayLink(store)
|
||||
link.start()
|
||||
import time as _t
|
||||
for _ in range(30):
|
||||
_t.sleep(1)
|
||||
|
||||
Reference in New Issue
Block a user