butubb
79cdf61ed2
一、指纹匹配自动认领（可选，默认关）
- 发现设置新增「指纹匹配自动认领」勾选（app_meta: discovery_auto_claim，默认 0）
- 打开后：扫描发现某设备指纹与池中已有记录一致（同一台换了 IP）→ 自动迁移记录到新地址
并同步分组/任务引用，零点击；关闭时维持"识别自动 + 人工点一次确认"
- 默认关的原因：认领会改写分组/任务引用（数据结构变动），交人工确认更稳妥
- 扫描结果与状态行会显示本轮自动认领了几台
二、设备名称在界面上呈现（凡选择/展示设备处都显示名称）
- 新增前端 helper `devText(name, serial)`（base.js）：有名称→「名称 · serial」
- 监控页设备表：名称加粗为主、地址作副行（未命名显示橙色提醒）；任务概况的覆盖设备
chip 也优先显示名称（tooltip 保留完整地址）
- AI 控制台：目标设备下拉、实时画面设备下拉、目标/运行中提示都带名称（serial→name 映射）
- 任务编辑器「指定设备」下拉、分组编辑的设备勾选列表：带名称
- 后端 `/api/devices` 新增 `items`（[{serial,name,model}]，`devices` 保持兼容）；
`/api/agent/devices` 增加 `name` 字段
- MCP `de_list_devices` 返回 `name`，并在工具说明与 Agent 系统提示里要求"汇报用名称、
调工具用 serial"
文档：API.md（items/name/auto_claim + §6.2.1 名称呈现表）、MCP.md（工具返回）
自测（全通过）：自动认领端到端（开开关→扫描→自动迁址 + 名称保留 + 分组/任务引用同步 +
待连接池清理 + 开关默认关且可持久化）；名称显示浏览器验证（监控页/覆盖设备 chip/AI 目标与
观看下拉/任务编辑器/分组弹窗/发现设置开关）；设备指纹与人工认领回归
480 lines
20 KiB
Python
480 lines
20 KiB
Python
"""设备自动发现：扫描网段中开放 adb 5555 的设备 → 待连接池（pending）。
|
||
|
||
流程：socket 并发探测 5555（标准库，不碰 adb）→ 剔除已在设备池的 serial →
|
||
串行 adb 验证（adb_connect_light，内部全局锁）→ 用 `adb devices` 的
|
||
state=="device" 过滤（排除 unauthorized/offline，connect 输出不可信）→
|
||
写入 pending_device 表。**扫描只验证、不自动连接入池**——用户在前端确认后
|
||
才调 device_pool.add_device + adb_connect（见 web/devices_api.py）。
|
||
|
||
安全红线：绝不 kill-server / 绝不 disconnect（与全项目一致）。
|
||
|
||
配置存 app_meta KV 表（discovery_enabled/subnets/interval/port），定时线程
|
||
每轮重读，开关/周期/网段改动即时生效无需重启。
|
||
"""
|
||
import ipaddress
|
||
import json
|
||
import socket
|
||
import threading
|
||
from concurrent.futures import ThreadPoolExecutor
|
||
from datetime import datetime
|
||
|
||
from config import (USB_ADB_HOST,
|
||
DISCOVERY_PORT, DISCOVERY_SUBNETS, DISCOVERY_INTERVAL)
|
||
from core.adb_helper import _adb, adb_connect_light
|
||
from core.logger import get_logger
|
||
from core.models import db, Device, PendingDevice
|
||
|
||
_log = get_logger("core.disc")
|
||
|
||
# 扫描配置键（app_meta）
|
||
_K_ENABLED = "discovery_enabled"
|
||
_K_SUBNETS = "discovery_subnets"
|
||
_K_INTERVAL = "discovery_interval"
|
||
_K_PORT = "discovery_port"
|
||
# 指纹匹配时是否自动认领（默认关：认领会改写分组/任务引用，默认交人工确认）
|
||
_K_AUTO_CLAIM = "discovery_auto_claim"
|
||
|
||
# 单网段主机数上限（防误配 /8 之类），超过截断并告警
|
||
_MAX_HOSTS_PER_SUBNET = 1024
|
||
# socket 探测并发数与单 IP 超时
|
||
_PROBE_WORKERS = 64
|
||
_PROBE_TIMEOUT = 0.4
|
||
|
||
_app = None
|
||
_scan_lock = threading.Lock() # 定时/手动扫描互斥
|
||
_stop_event = threading.Event() # shutdown 用
|
||
_scanning = False # 状态快照（API/前端）
|
||
_last_scan = None # (时间串, 开放数, 可连数, 新增数)
|
||
_last_error = ""
|
||
|
||
|
||
def _ctx():
|
||
"""后台线程访问 db 时自行推 app context（仿 device_pool._ctx）。"""
|
||
return _app.app_context() if _app else None
|
||
|
||
|
||
def _fmt(ts=None):
|
||
return (ts or datetime.now()).strftime("%Y-%m-%d %H:%M")
|
||
|
||
|
||
# ================== 配置读写 ==================
|
||
def get_settings():
|
||
"""读发现配置（app_meta，缺键用 config 默认值补齐）。"""
|
||
with _ctx():
|
||
def _get(key, default):
|
||
v = db.session.execute(
|
||
db.text("SELECT value FROM app_meta WHERE key=:k"), {"k": key}).scalar()
|
||
return v if v is not None else default
|
||
try:
|
||
subnets = json.loads(_get(_K_SUBNETS, "[]")) or DISCOVERY_SUBNETS
|
||
except Exception:
|
||
subnets = DISCOVERY_SUBNETS
|
||
return {
|
||
"enabled": _get(_K_ENABLED, "1") == "1", # 默认开启
|
||
"subnets": subnets,
|
||
"interval": int(_get(_K_INTERVAL, str(DISCOVERY_INTERVAL)) or DISCOVERY_INTERVAL),
|
||
"port": int(_get(_K_PORT, str(DISCOVERY_PORT)) or DISCOVERY_PORT),
|
||
"auto_claim": _get(_K_AUTO_CLAIM, "0") == "1", # 默认关
|
||
}
|
||
|
||
|
||
def save_settings(enabled=None, subnets=None, interval=None, port=None, auto_claim=None):
|
||
"""写发现配置（部分字段更新）。subnets 逐项校验 CIDR，非法返回 (False, 原因)。"""
|
||
if subnets is not None:
|
||
clean = []
|
||
for s in subnets:
|
||
s = (s or "").strip()
|
||
if not s:
|
||
continue
|
||
try:
|
||
ipaddress.ip_network(s, strict=False)
|
||
except ValueError:
|
||
return False, f"网段格式错误: {s}"
|
||
clean.append(s)
|
||
subnets = clean
|
||
try:
|
||
if interval is not None and (int(interval) < 10 or int(interval) > 3600):
|
||
return False, "扫描周期需在 10-3600 秒之间"
|
||
if port is not None and (int(port) < 1 or int(port) > 65535):
|
||
return False, "端口不合法"
|
||
except (TypeError, ValueError):
|
||
return False, "参数不合法"
|
||
with _ctx():
|
||
def _put(key, value):
|
||
db.session.execute(
|
||
db.text("INSERT OR REPLACE INTO app_meta(key,value) VALUES(:k,:v)"),
|
||
{"k": key, "v": str(value)})
|
||
if enabled is not None:
|
||
_put(_K_ENABLED, "1" if enabled else "0")
|
||
if subnets is not None:
|
||
_put(_K_SUBNETS, json.dumps(subnets))
|
||
if interval is not None:
|
||
_put(_K_INTERVAL, str(int(interval)))
|
||
if port is not None:
|
||
_put(_K_PORT, str(int(port)))
|
||
if auto_claim is not None:
|
||
_put(_K_AUTO_CLAIM, "1" if auto_claim else "0")
|
||
db.session.commit()
|
||
return True, "已保存"
|
||
|
||
|
||
# ================== 网段展开与端口探测 ==================
|
||
def _local_ips():
|
||
"""本机自身 IP 集合（尽力而为）：扫描时排除，避免探测到自己的 5555。
|
||
|
||
优先 `hostname -I`（Linux/macOS 支持，一行空格分隔多 IP）；不支持/失败的
|
||
平台退回 socket.getaddrinfo 枚举。关键：外部命令必须用 bytes 收——Windows
|
||
上 git-bash 的 coreutils hostname 不支持 -I，会把 GBK 报错写进 stderr，
|
||
text=True 在 subprocess 后台读线程里 utf-8 严格解码会直接炸线程（主线程
|
||
try/except 接不住异步线程异常）。
|
||
"""
|
||
import subprocess
|
||
ips = set()
|
||
try:
|
||
r = subprocess.run(["hostname", "-I"], capture_output=True, timeout=3)
|
||
if r.returncode == 0:
|
||
ips.update(p for p in
|
||
r.stdout.decode("utf-8", errors="ignore").split() if p)
|
||
except Exception:
|
||
pass
|
||
if not ips: # 兜底：主机名解析出的接口 IPv4
|
||
try:
|
||
for info in socket.getaddrinfo(socket.gethostname(), None):
|
||
ip = info[4][0]
|
||
if ":" not in ip:
|
||
ips.add(ip)
|
||
except Exception:
|
||
pass
|
||
return ips
|
||
|
||
|
||
def _expand_subnets(subnets, max_hosts=_MAX_HOSTS_PER_SUBNET):
|
||
"""CIDR 列表 → IP 列表。排除 220 自身（USB_ADB_HOST）与本机 IP；
|
||
非法网段跳过记日志；单网段超过 max_hosts 截断并告警。"""
|
||
self_ips = {USB_ADB_HOST} | _local_ips()
|
||
ips = []
|
||
for cidr in subnets:
|
||
try:
|
||
net = ipaddress.ip_network((cidr or "").strip(), strict=False)
|
||
except ValueError:
|
||
_log.warning(f"发现: 跳过非法网段 {cidr}")
|
||
continue
|
||
hosts = [str(h) for h in net.hosts()
|
||
if str(h) not in self_ips]
|
||
if len(hosts) > max_hosts:
|
||
_log.warning(f"发现: 网段 {cidr} 主机数 {len(hosts)} 超过上限，截断前 {max_hosts}")
|
||
hosts = hosts[:max_hosts]
|
||
ips.extend(hosts)
|
||
return ips
|
||
|
||
|
||
def _probe_port(ip, port, timeout=_PROBE_TIMEOUT):
|
||
"""单 IP 端口探测（标准库 socket，超时/拒绝/不可达一律 False）。"""
|
||
try:
|
||
with socket.create_connection((ip, port), timeout=timeout):
|
||
return True
|
||
except Exception:
|
||
return False
|
||
|
||
|
||
def _probe_open(ips, port, workers=_PROBE_WORKERS):
|
||
"""并发探测，返回开放端口的主机列表。"""
|
||
if not ips:
|
||
return []
|
||
with ThreadPoolExecutor(max_workers=workers) as ex:
|
||
results = list(ex.map(lambda ip: (ip, _probe_port(ip, port)), ips))
|
||
return [ip for ip, ok in results if ok]
|
||
|
||
|
||
# ================== adb devices 解析 ==================
|
||
def _parse_adb_devices(out):
|
||
"""解析 `adb devices` 输出 → state=="device" 的 serial 集合。
|
||
|
||
只看 connect 输出不可靠（未授权设备也返回 connected），必须用 state 过滤。
|
||
"""
|
||
devices = set()
|
||
for line in (out or "").splitlines()[1:]:
|
||
parts = line.split()
|
||
if len(parts) >= 2 and parts[0] and not parts[0].startswith("*"):
|
||
if parts[1] == "device":
|
||
devices.add(parts[0])
|
||
return devices
|
||
|
||
|
||
# ================== 自动认领（可选） ==================
|
||
def _auto_claim(fps):
|
||
"""指纹命中池中已有设备 → 自动认领：迁移记录到新地址并同步分组/任务引用。
|
||
|
||
仅在设置 discovery_auto_claim 打开时由扫描线程调用（默认关）。
|
||
返回 [(old_serial, new_serial, name), ...]。
|
||
"""
|
||
from core import device_pool
|
||
done = []
|
||
for serial, fp in (fps or {}).items():
|
||
if not fp:
|
||
continue
|
||
try:
|
||
info = device_pool.find_by_fingerprint(fp)
|
||
if not info or info.get("serial") == serial:
|
||
continue # 没匹配到，或本来就是这条（无需迁移）
|
||
old, name = device_pool.claim_device(serial, fp)
|
||
if not old:
|
||
continue
|
||
PendingDevice.query.filter_by(serial=serial).delete()
|
||
db.session.commit()
|
||
done.append((old, serial, name or info.get("name") or ""))
|
||
_log.info(f"自动认领: 『{name or info.get('name') or old}』{old} → {serial}")
|
||
except Exception as e:
|
||
db.session.rollback()
|
||
_log.warning(f"自动认领 {serial} 失败: {e}")
|
||
return done
|
||
|
||
|
||
# ================== 扫描 ==================
|
||
def scan_once(manual=False):
|
||
"""执行一轮扫描。返回 (ok, result_dict)；后台线程/API 调用。"""
|
||
global _scanning, _last_scan, _last_error
|
||
if not _scan_lock.acquire(blocking=False):
|
||
return False, {"error": "扫描进行中"}
|
||
_scanning = True
|
||
try:
|
||
settings = get_settings()
|
||
port = settings["port"]
|
||
subnets = settings["subnets"]
|
||
if not subnets:
|
||
_last_error = "未配置扫描网段"
|
||
return True, {"found": 0, "verified": 0, "new": 0, "error": _last_error}
|
||
|
||
# 1. socket 并发探测（不碰 adb，把几百台缩小到开放端口量级）
|
||
open_ips = _probe_open(_expand_subnets(subnets), port)
|
||
candidates = {f"{ip}:{port}" for ip in open_ips}
|
||
|
||
with _ctx():
|
||
# 2. 剔除已在正式设备池的 serial
|
||
configured = set(device_pool_list_configured())
|
||
candidates -= configured
|
||
|
||
# 3. 串行 adb 验证：已连接的直接跳过（零成本），其余 adb_connect_light
|
||
already = _parse_adb_devices(_adb("devices"))
|
||
for serial in candidates - already:
|
||
adb_connect_light(serial) # 内部全局锁串行；失败无妨，下面按 state 过滤
|
||
|
||
# 4. state==device 过滤（排除 unauthorized/offline）
|
||
verified = _parse_adb_devices(_adb("devices")) & candidates
|
||
|
||
# 5. 写 pending：新 → 插入；已有 → 更新 last_seen（顺带刷新指纹）
|
||
# 指纹用于认出"这台其实是设备池里某台设备换了 IP"，见 list_pending 的 match
|
||
now = _fmt()
|
||
existing = {p.serial for p in PendingDevice.query.all()}
|
||
added = 0
|
||
from core import device_pool
|
||
fps = {}
|
||
for serial in verified:
|
||
source = "tailscale" if serial.split(":")[0].startswith("100.") else "lan"
|
||
try:
|
||
fp = device_pool.read_fingerprint(serial, timeout=4)
|
||
except Exception:
|
||
fp = ""
|
||
fps[serial] = fp
|
||
if serial in existing:
|
||
PendingDevice.query.filter_by(serial=serial).update(
|
||
{"last_seen": now, "fingerprint": fp})
|
||
else:
|
||
db.session.add(PendingDevice(serial=serial, source=source,
|
||
first_seen=now, last_seen=now,
|
||
fingerprint=fp))
|
||
added += 1
|
||
db.session.commit()
|
||
# 5.5 自动认领（可选，默认关）：指纹命中池中已有设备 → 直接把记录迁到新地址。
|
||
# 默认关是因为认领会改写分组/任务引用（数据结构变动），交人工点一下更稳妥；
|
||
# 打开后零点击完成，见 doc/API.md §6。
|
||
claimed = _auto_claim(fps) if settings.get("auto_claim") else []
|
||
# 6. 正式池断联设备自动重连：adb connect 会因 WiFi 波动/设备重启/
|
||
# adb 服务重启而断开——扫描线程每轮顺带重试（幂等轻量，内部
|
||
# 全局锁串行），连上即恢复在线，无需人工干预。pending 池是给
|
||
# 「未授权新设备」的，正式池设备断联不进 pending，而是自动重连。
|
||
back = _reconnect_offline(configured)
|
||
_log.info(f"发现: 探测开放 {len(open_ips)} 台，可连 {len(verified)} 台，"
|
||
f"新增待连接 {added} 台"
|
||
+ (f"，自动重连恢复 {len(back)} 台 {back}" if back else "")
|
||
+ (f"，自动认领 {len(claimed)} 台 {[c[0] + '→' + c[1] for c in claimed]}"
|
||
if claimed else ""))
|
||
_last_scan = (now, len(open_ips), len(verified), added)
|
||
_last_error = ""
|
||
return True, {"found": len(open_ips), "verified": len(verified),
|
||
"new": added, "claimed": len(claimed)}
|
||
except Exception as e:
|
||
_log.warning(f"发现扫描异常: {e}")
|
||
_last_error = str(e)[:200]
|
||
return False, {"error": _last_error}
|
||
finally:
|
||
_scanning = False
|
||
_scan_lock.release()
|
||
|
||
|
||
def device_pool_list_configured():
|
||
"""设备池已配置 serial（延迟 import 避免循环依赖）。"""
|
||
from core import device_pool
|
||
return device_pool.list_configured()
|
||
|
||
|
||
# ================== 正式池断联设备：自动重连 ==================
|
||
def _reconnect_offline(configured):
|
||
"""对正式池中断联的网络设备逐个 adb 重连，返回恢复的 serial 列表。
|
||
|
||
只重连网络设备（IP:5555；USB 设备插着就在，无需 connect）。
|
||
幂等轻量：内部 adb 全局锁串行，失败静默（下轮扫描再试）。
|
||
"""
|
||
online_now = _parse_adb_devices(_adb("devices"))
|
||
targets = [s for s in (configured or [])
|
||
if ":" in s and s not in online_now]
|
||
if not targets:
|
||
return []
|
||
for serial in targets:
|
||
adb_connect_light(serial)
|
||
online_after = _parse_adb_devices(_adb("devices"))
|
||
return [s for s in targets if s in online_after]
|
||
|
||
|
||
def list_pool_offline():
|
||
"""正式设备池中断联的设备（serial + 型号 + 备注名），面板展示用。
|
||
|
||
断联设备仍是正式池成员（不删除、不进 pending）——pending 是给未授权
|
||
新设备的；它们由扫描线程每轮自动重连，也可前端手动立即重连。
|
||
"""
|
||
online = _parse_adb_devices(_adb("devices"))
|
||
with _ctx():
|
||
rows = [d.to_dict() for d in Device.query.filter_by(enabled=True)
|
||
.order_by(Device.serial).all()]
|
||
return [{"serial": r["serial"], "model": r.get("model") or "",
|
||
"name": r.get("name") or ""}
|
||
for r in rows if r["serial"] not in online]
|
||
|
||
|
||
# ================== 定时扫描线程 ==================
|
||
def _discovery_loop():
|
||
"""定时扫描 daemon 线程。每轮重读配置（开关/周期即时生效）。
|
||
|
||
启动先 sleep 15s 避让 web_server 预连接线程（两者都抢 adb 全局锁）。
|
||
等待用 30s 切片（_stop_event.wait），关停/改周期 ≤30s 生效。
|
||
"""
|
||
try:
|
||
_stop_event.wait(15)
|
||
while not _stop_event.is_set():
|
||
try:
|
||
settings = get_settings()
|
||
if settings["enabled"]:
|
||
scan_once()
|
||
except Exception as e:
|
||
_log.warning(f"发现定时扫描异常: {e}")
|
||
wait_s = max(10, settings.get("interval", 60))
|
||
waited = 0
|
||
while waited < wait_s and not _stop_event.is_set():
|
||
_stop_event.wait(min(30, wait_s - waited))
|
||
waited += min(30, wait_s - waited)
|
||
except Exception:
|
||
pass
|
||
|
||
|
||
def init_app(app):
|
||
"""web_server 启动时调用：绑 app + 起定时扫描 daemon 线程。"""
|
||
global _app
|
||
_app = app
|
||
_stop_event.clear()
|
||
t = threading.Thread(target=_discovery_loop, name="device-discovery", daemon=True)
|
||
t.start()
|
||
_log.info("设备自动发现线程已启动（默认 60s 扫描一次）")
|
||
|
||
|
||
def shutdown():
|
||
"""优雅退出：置 stop_event，等待中的循环在切片边界退出。"""
|
||
_stop_event.set()
|
||
|
||
|
||
# ================== 对外查询与确认 ==================
|
||
def get_status():
|
||
"""API 状态快照：配置 + 扫描状态 + 最近一轮结果 + 待连接数量。"""
|
||
settings = get_settings()
|
||
with _ctx():
|
||
pending = PendingDevice.query.count()
|
||
return {
|
||
"enabled": settings["enabled"],
|
||
"subnets": settings["subnets"],
|
||
"interval": settings["interval"],
|
||
"port": settings["port"],
|
||
"auto_claim": settings["auto_claim"],
|
||
"scanning": _scanning,
|
||
"last_scan": _last_scan[0] if _last_scan else "",
|
||
"last_result": ({"found": _last_scan[1], "verified": _last_scan[2],
|
||
"new": _last_scan[3]} if _last_scan else None),
|
||
"last_error": _last_error,
|
||
"pending_count": pending,
|
||
}
|
||
|
||
|
||
def list_pending():
|
||
"""待连接列表：只返回当前在线的设备（离线候选不可确认，不展示）。
|
||
|
||
后端直接过滤（2026-09-04）：不依赖前端 JS 版本，任何客户端都拿不到
|
||
离线条目；设备恢复在线后扫描自动更新 last_seen 并重新出现在列表。
|
||
"""
|
||
online = _parse_adb_devices(_adb("devices"))
|
||
with _ctx():
|
||
rows = [p.to_dict() for p in PendingDevice.query.order_by(
|
||
PendingDevice.first_seen.desc()).all()]
|
||
out = []
|
||
for r in rows:
|
||
if r["serial"] not in online:
|
||
continue
|
||
r["online"] = True
|
||
# 指纹匹配：这台其实就是设备池里某台设备换了地址（前端据此提示"认领"）
|
||
r["match"] = None
|
||
if r.get("fingerprint"):
|
||
try:
|
||
from core import device_pool
|
||
m = device_pool.find_by_fingerprint(r["fingerprint"])
|
||
if m and m["serial"] != r["serial"]:
|
||
r["match"] = {"serial": m["serial"], "name": m.get("name") or ""}
|
||
except Exception:
|
||
pass
|
||
out.append(r)
|
||
return out
|
||
|
||
|
||
def confirm_pending(serial, name="", fingerprint=""):
|
||
"""确认连接：pending 行 → 正式设备池（add_device upsert）→ 删 pending。
|
||
|
||
先按指纹尝试**认领**：同一台物理设备换了地址时，把池中旧记录迁到新 serial，
|
||
并同步分组/任务里的引用（名称等信息全部保留），而不是新增一条。
|
||
|
||
返回 (ok, msg, is_new)。adb_connect + 采型号/指纹由调用方（API 层后台线程）做。
|
||
"""
|
||
with _ctx():
|
||
row = PendingDevice.query.get(serial)
|
||
if not row:
|
||
return False, "设备不在待连接列表", False
|
||
from core import device_pool
|
||
fp = (fingerprint or row.fingerprint or "").strip()
|
||
claimed_old, claimed_name = device_pool.claim_device(serial, fp)
|
||
if claimed_old:
|
||
device_pool.add_device(serial, name=claimed_name or name, fingerprint=fp)
|
||
PendingDevice.query.filter_by(serial=serial).delete()
|
||
db.session.commit()
|
||
return True, (f"已认领为『{claimed_name or claimed_old}』"
|
||
f"（原地址 {claimed_old}，分组/任务的引用已同步）"), False
|
||
is_new = device_pool.add_device(serial, name=name or "", fingerprint=fp)
|
||
PendingDevice.query.filter_by(serial=serial).delete()
|
||
db.session.commit()
|
||
return True, "已加入设备池" + ("" if is_new else "（已存在，信息已更新）"), is_new
|
||
|
||
|
||
def ignore_pending(serial):
|
||
"""忽略：删除 pending 行（下轮扫描可能再次发现）。"""
|
||
with _ctx():
|
||
row = PendingDevice.query.get(serial)
|
||
if not row:
|
||
return False, "设备不在待连接列表"
|
||
PendingDevice.query.filter_by(serial=serial).delete()
|
||
db.session.commit()
|
||
return True, "已忽略"
|