# -*- coding: utf-8 -*- import os import signal import subprocess import threading import time from concurrent.futures import ThreadPoolExecutor, as_completed, TimeoutError from pathlib import Path from typing import Dict, Optional, List import random import socket import http.client import psutil import hashlib # 保留扩展 import platform import tidevice import wda from tidevice import Usbmux, ConnectionType from tidevice._device import BaseDevice from Entity.DeviceModel import DeviceModel from Entity.Variables import WdaAppBundleId, wdaFunctionPort, wdaScreenPort from Module.FlaskSubprocessManager import FlaskSubprocessManager from Module.IOSActivator import IOSActivator from Utils.LogManager import LogManager def _monotonic() -> float: """统一用 monotonic 计时，避免系统时钟跳变影响定时/退避。""" return time.monotonic() class DeviceInfo: # --- 时序参数（支持环境变量覆盖） --- REMOVE_GRACE_SEC = float(os.getenv("REMOVE_GRACE_SEC", "8.0")) # 设备离线宽限期 ADD_STABLE_SEC = float(os.getenv("ADD_STABLE_SEC", "2.5")) # 设备上线稳定期 ORPHAN_COOLDOWN = float(os.getenv("ORPHAN_COOLDOWN", "8.0")) # 拓扑变更后暂停孤儿清理 HEAL_INTERVAL = float(os.getenv("HEAL_INTERVAL", "5.0")) # 健康巡检间隔 # 端口策略（支持环境变量覆盖） PORT_RAND_LOW_1 = int(os.getenv("PORT_RAND_LOW_1", "9111")) PORT_RAND_HIGH_1 = int(os.getenv("PORT_RAND_HIGH_1", "9499")) PORT_RAND_LOW_2 = int(os.getenv("PORT_RAND_LOW_2", "20000")) PORT_RAND_HIGH_2 = int(os.getenv("PORT_RAND_HIGH_2", "48000")) PORT_SCAN_START = int(os.getenv("PORT_SCAN_START", "49152")) PORT_SCAN_LIMIT = int(os.getenv("PORT_SCAN_LIMIT", "10000")) # 自愈退避 BACKOFF_MAX_SEC = float(os.getenv("BACKOFF_MAX_SEC", "15.0")) BACKOFF_MIN_SEC = float(os.getenv("BACKOFF_MIN_SEC", "1.5")) BACKOFF_GROWTH = float(os.getenv("BACKOFF_GROWTH", "1.7")) # WDA Ready 等待（HTTP 轮询方式，不触发 xctest） WDA_READY_TIMEOUT = float(os.getenv("WDA_READY_TIMEOUT", "35.0")) def __init__(self): # 自增端口游标仅作兜底扫描使用 self._port = 9110 self._models: Dict[str, DeviceModel] = {} self._procs: Dict[str, subprocess.Popen] = {} self._manager = FlaskSubprocessManager.get_instance() self._iproxy_path = self._find_iproxy() self._pool = ThreadPoolExecutor(max_workers=6) self._last_heal_check_ts = 0.0 self._heal_backoff: Dict[str, float] = {} # udid -> next_allowed_ts # 并发保护 & 状态表 self._lock = threading.RLock() self._port_by_udid: Dict[str, int] = {} # UDID -> 当前使用的本地端口 self._pid_by_udid: Dict[str, int] = {} # UDID -> iproxy PID # 抗抖 self._last_seen: Dict[str, float] = {} # udid -> ts self._first_seen: Dict[str, float] = {} # udid -> ts(首次在线) self._last_topology_change_ts = 0.0 # 短缓存：设备信任、WDA运行态（仅作节流） self._trusted_cache: Dict[str, float] = {} # udid -> expire_ts self._wda_ok_cache: Dict[str, float] = {} # udid -> expire_ts LogManager.info("DeviceInfo init 完成；日志已启用", udid="system") # ---------------- 主循环 ---------------- def listen(self): method = "listen" LogManager.method_info("进入主循环", method, udid="system") orphan_gc_tick = 0 while True: now = _monotonic() try: usb = Usbmux().device_list() online_now = {d.udid for d in usb if d.conn_type == ConnectionType.USB} except Exception as e: LogManager.warning(f"[device_list] 异常：{e}", udid="system") time.sleep(1) continue # 记录“看到”的时间戳 for u in online_now: if u not in self._first_seen: self._first_seen[u] = now LogManager.method_info("first seen", method, udid=u) self._last_seen[u] = now with self._lock: known = set(self._models.keys()) # 真正移除（连续缺席超过宽限期） for udid in list(known): last = self._last_seen.get(udid, 0.0) if udid not in online_now and (now - last) >= self.REMOVE_GRACE_SEC: LogManager.info(f"设备判定离线（超过宽限期 {self.REMOVE_GRACE_SEC}s），last_seen={last}", udid=udid) self._remove_device(udid) self._last_topology_change_ts = now # 真正新增（连续在线超过稳定期） new_candidates = [u for u in online_now if u not in known] to_add = [u for u in new_candidates if (now - self._first_seen.get(u, now)) >= self.ADD_STABLE_SEC] if to_add: LogManager.info(f"新增设备稳定上线：{to_add}", udid="system") futures = {self._pool.submit(self._add_device, u): u for u in to_add} try: for f in as_completed(futures, timeout=45): try: f.result() self._last_topology_change_ts = _monotonic() except Exception as e: LogManager.error(f"异步连接失败：{e}", udid="system") except TimeoutError: for fut, u in futures.items(): if not fut.done(): fut.cancel() LogManager.method_warning("新增设备任务超时已取消", method, udid=u) # 定期健康检查 + 自愈 self._check_and_heal_tunnels(interval=self.HEAL_INTERVAL) # 周期性孤儿清理（拓扑变更冷却之后） orphan_gc_tick += 1 if orphan_gc_tick >= 10: orphan_gc_tick = 0 if (_monotonic() - self._last_topology_change_ts) >= self.ORPHAN_COOLDOWN: self._cleanup_orphan_iproxy() time.sleep(1) # ---------------- 新增设备 ---------------- def _add_device(self, udid: str): method = "_add_device" LogManager.method_info("开始新增设备", method, udid=udid) if not self._trusted(udid): LogManager.method_warning("未信任设备，跳过", method, udid=udid) return # 获取系统主版本 try: dev = tidevice.Device(udid) system_version_major = int(dev.product_version.split(".")[0]) except Exception as e: LogManager.method_warning(f"读取系统版本失败：{e}", method, udid=udid) system_version_major = 0 # 保底 # === iOS>17：先“被动探测”WDA，未运行则交给 IOSActivator，并通过 HTTP 轮询等待 === if system_version_major > 17: if self._wda_is_running(udid): LogManager.method_info("检测到 WDA 已运行，直接映射", method, udid=udid) else: LogManager.method_info("WDA 未运行，调用 IOSActivator（pymobiledevice3 自动挂载）", method, udid=udid) try: ios = IOSActivator() threading.Thread(target=ios.activate, args=(udid,), daemon=True).start() except Exception as e: LogManager.method_error(f"IOSActivator 启动异常：{e}", method, udid=udid) return # 关键：HTTP 轮询等待 WDA Ready（默认最多 35s），不会触发 xctest if not self._wait_wda_ready_http(udid, total_timeout_sec=self.WDA_READY_TIMEOUT): LogManager.method_error("WDA 未在超时内就绪（iOS>17 分支）", method, udid=udid) return else: # iOS <= 17：保持原逻辑（app_start + 简单等待） try: dev = tidevice.Device(udid) LogManager.method_info(f"app_start WDA: {WdaAppBundleId}", method, udid=udid) dev.app_start(WdaAppBundleId) time.sleep(3) except Exception as e: LogManager.method_error(f"WDA 启动异常：{e}", method, udid=udid) return # 获取屏幕信息 w, h, s = self._screen_info(udid) if w == 0 or h == 0 or s == 0: LogManager.method_warning("未获取到屏幕信息，放弃新增", method, udid=udid) return # 启动 iproxy（不复用端口：直接新端口） proc = self._start_iproxy(udid, port=None) if not proc: LogManager.method_error("启动 iproxy 失败，放弃新增", method, udid=udid) return with self._lock: port = self._port_by_udid[udid] model = DeviceModel(deviceId=udid, screenPort=port, width=w, height=h, scale=s, type=1) model.ready = True self._models[udid] = model self._procs[udid] = proc LogManager.method_info(f"设备添加完成，port={port}, {w}x{h}@{s}", method, udid=udid) self._manager_send(model) # ---------------- 移除设备（修复：总是发送离线通知） ---------------- def _remove_device(self, udid: str): method = "_remove_device" LogManager.method_info("开始移除设备", method, udid=udid) with self._lock: model = self._models.pop(udid, None) proc = self._procs.pop(udid, None) pid = self._pid_by_udid.pop(udid, None) self._port_by_udid.pop(udid, None) # 清缓存，防止误判 self._trusted_cache.pop(udid, None) self._wda_ok_cache.pop(udid, None) self._last_seen.pop(udid, None) self._first_seen.pop(udid, None) self._kill(proc) if pid: self._kill_pid_gracefully(pid) if model is None: # 构造一个最小的“离线模型”通知前端 try: offline = DeviceModel(deviceId=udid, screenPort=-1, width=0, height=0, scale=0.0, type=2) offline.ready = False self._manager_send(offline) LogManager.method_info("设备移除完毕（无原模型，已发送离线通知）", method, udid=udid) except Exception as e: LogManager.method_warning(f"离线通知（构造模型）异常：{e}", method, udid=udid) return model.type = 2 model.ready = False model.screenPort = -1 try: self._manager_send(model) finally: LogManager.method_info("设备移除完毕（已发送离线通知）", method, udid=udid) # ---------------- 工具函数 ---------------- def _trusted(self, udid: str) -> bool: # 30s 短缓存，减少 IO now = _monotonic() exp = self._trusted_cache.get(udid, 0.0) if exp > now: return True try: BaseDevice(udid).get_value("DeviceName") self._trusted_cache[udid] = now + 30.0 return True except Exception: return False # ======= WDA 探测/等待（仅走 iproxy+HTTP，不触发 xctest） ======= def _wda_http_status_ok(self, udid: str, timeout_sec: float = 1.2) -> bool: """临时 iproxy 转发到 wdaFunctionPort，GET /status 成功视为 OK。""" method = "_wda_http_status_ok" tmp_port = self._pick_new_port() proc = None try: cmd = [self._iproxy_path, "-u", udid, str(tmp_port), str(wdaFunctionPort)] proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) if not self._wait_until_listening(tmp_port, initial_timeout=0.8): LogManager.method_info(f"WDA探测：临时端口未监听（{tmp_port}）", method, udid=udid) return False conn = http.client.HTTPConnection("127.0.0.1", tmp_port, timeout=timeout_sec) try: conn.request("GET", "/status") resp = conn.getresponse() _ = resp.read(256) code = getattr(resp, "status", 0) ok = 200 <= code < 400 LogManager.method_info(f"WDA探测：/status code={code}, ok={ok}", method, udid=udid) return ok except Exception as e: LogManager.method_info(f"WDA探测异常：{e}", method, udid=udid) return False finally: try: conn.close() except Exception: pass finally: if proc: try: p = psutil.Process(proc.pid) p.terminate() p.wait(timeout=0.6) except Exception: try: p.kill() except Exception: pass def _wait_wda_ready_http(self, udid: str, total_timeout_sec: float = None, interval_sec: float = 0.6) -> bool: """ 通过 _wda_http_status_ok 轮询等待 WDA Ready。 total_timeout_sec 默认取环境变量 WDA_READY_TIMEOUT（默认 35s）。 """ method = "_wait_wda_ready_http" if total_timeout_sec is None: total_timeout_sec = self.WDA_READY_TIMEOUT deadline = _monotonic() + total_timeout_sec while _monotonic() < deadline: if self._wda_http_status_ok(udid, timeout_sec=1.2): LogManager.method_info("WDA 就绪（HTTP轮询）", method, udid=udid) return True time.sleep(interval_sec) LogManager.method_warning(f"WDA 等待超时（HTTP轮询，{total_timeout_sec}s）", method, udid=udid) return False def _wda_is_running(self, udid: str, cache_sec: float = 2.0) -> bool: """轻量速查，走 HTTP /status（短缓存节流），避免触发 xctest。""" now = _monotonic() exp = self._wda_ok_cache.get(udid, 0.0) if exp > now: return True ok = self._wda_http_status_ok(udid, timeout_sec=1.2) if ok: self._wda_ok_cache[udid] = now + cache_sec return ok def _screen_info(self, udid: str): method = "_screen_info" try: c = wda.USBClient(udid, wdaFunctionPort) c.home() size = c.window_size() scale = c.scale LogManager.method_info(f"屏幕信息：{int(size.width)}x{int(size.height)}@{float(scale)}", method, udid=udid) return int(size.width), int(size.height), float(scale) except Exception as e: LogManager.method_warning(f"获取屏幕信息异常：{e}", method, udid=udid) return 0, 0, 0 # ---------------- 端口/进程：不复用端口 ---------------- def _is_port_free(self, port: int, host: str = "127.0.0.1") -> bool: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind((host, port)) return True except OSError: return False finally: s.close() def _pick_new_port(self, tries: int = 40) -> int: method = "_pick_new_port" for _ in range(max(1, tries // 2)): p = random.randint(self.PORT_RAND_LOW_1, self.PORT_RAND_HIGH_1) if self._is_port_free(p): LogManager.method_info(f"端口候选可用(首段)：{p}", method, udid="system") return p else: LogManager.method_info(f"端口候选占用(首段)：{p}", method, udid="system") for _ in range(tries): p = random.randint(self.PORT_RAND_LOW_2, self.PORT_RAND_HIGH_2) if self._is_port_free(p): LogManager.method_info(f"端口候选可用(次段)：{p}", method, udid="system") return p else: LogManager.method_info(f"端口候选占用(次段)：{p}", method, udid="system") LogManager.method_warning("随机端口尝试耗尽，改顺序扫描", method, udid="system") return self._pick_free_port(start=self.PORT_SCAN_START, limit=self.PORT_SCAN_LIMIT) def _wait_until_listening(self, port: int, initial_timeout: float = 2.0) -> bool: """自适应等待端口监听：2s -> 3s -> 5s（最多约10s）。""" method = "_wait_until_listening" timeouts = [initial_timeout, 3.0, 5.0] for to in timeouts: deadline = _monotonic() + to while _monotonic() < deadline: with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.settimeout(0.2) if s.connect_ex(("127.0.0.1", port)) == 0: LogManager.method_info(f"端口已开始监听：{port}", method, udid="system") return True time.sleep(0.05) LogManager.method_info(f"监听验收阶段超时：{port}，扩展等待", method, udid="system") LogManager.method_warning(f"监听验收最终超时：{port}", method, udid="system") return False def _start_iproxy(self, udid: str, port: Optional[int] = None) -> Optional[subprocess.Popen]: method = "_start_iproxy" try: with self._lock: old_pid = self._pid_by_udid.get(udid) if old_pid: LogManager.method_info(f"发现旧 iproxy，准备结束：pid={old_pid}", method, udid=udid) self._kill_pid_gracefully(old_pid) self._pid_by_udid.pop(udid, None) attempts = 0 while attempts < 3: attempts += 1 local_port = port if (attempts == 1 and port is not None) else self._pick_new_port() if not self._is_port_free(local_port): LogManager.method_info(f"[attempt {attempts}] 端口竞争，换候选：{local_port}", method, udid=udid) continue LogManager.method_info(f"[attempt {attempts}] 启动 iproxy，port={local_port}", method, udid=udid) creationflags = 0 startupinfo = None if os.name == "nt": creationflags = getattr(subprocess, "CREATE_NO_WINDOW", 0x08000000) | \ getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0x00000200) si = subprocess.STARTUPINFO() si.dwFlags |= subprocess.STARTF_USESHOWWINDOW si.wShowWindow = 0 startupinfo = si cmd = [self._iproxy_path, "-u", udid, str(local_port), str(wdaScreenPort)] try: proc = subprocess.Popen( cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, creationflags=creationflags, startupinfo=startupinfo ) except Exception as e: LogManager.method_warning(f"创建 iproxy 进程失败：{e}", method, udid=udid) continue if not self._wait_until_listening(local_port, initial_timeout=2.0): LogManager.method_warning(f"[attempt {attempts}] iproxy 未监听，重试换端口", method, udid=udid) self._kill(proc) continue with self._lock: self._procs[udid] = proc self._pid_by_udid[udid] = proc.pid self._port_by_udid[udid] = local_port LogManager.method_info(f"iproxy 启动成功并监听，pid={proc.pid}, port={local_port}", method, udid=udid) return proc LogManager.method_error("iproxy 启动多次失败", method, udid=udid) return None except Exception as e: LogManager.method_error(f"_start_iproxy 异常：{e}", method, udid=udid) return None def _kill(self, proc: Optional[subprocess.Popen]): method = "_kill" if not proc: return try: p = psutil.Process(proc.pid) p.terminate() try: p.wait(timeout=2.0) LogManager.method_info("进程已正常终止", method, udid="system") except psutil.TimeoutExpired: p.kill() LogManager.method_warning("进程被强制杀死", method, udid="system") except Exception as e: LogManager.method_warning(f"结束进程异常：{e}", method, udid="system") # ---------------- 自愈：直接换新端口重启 + 指数退避 ---------------- def _next_backoff(self, prev_backoff: float) -> float: if prev_backoff <= 0: return self.BACKOFF_MIN_SEC return min(prev_backoff * self.BACKOFF_GROWTH, self.BACKOFF_MAX_SEC) def _restart_iproxy(self, udid: str): method = "_restart_iproxy" now = _monotonic() next_allowed = self._heal_backoff.get(udid, 0.0) if now < next_allowed: delta = round(next_allowed - now, 2) LogManager.method_info(f"自愈被退避抑制，剩余 {delta}s", method, udid=udid) return with self._lock: proc = self._procs.get(udid) if proc: LogManager.method_info(f"为重启准备清理旧 iproxy，pid={proc.pid}", method, udid=udid) self._kill(proc) model = self._models.get(udid) if not model: LogManager.method_warning("模型不存在，取消自愈", method, udid=udid) return proc2 = self._start_iproxy(udid, port=None) if not proc2: prev = max(0.0, next_allowed - now) backoff = self._next_backoff(prev) self._heal_backoff[udid] = now + backoff LogManager.method_warning(f"重启失败，扩展退避 {round(backoff,2)}s", method, udid=udid) return # 成功后短退避（抑制频繁重启） self._heal_backoff[udid] = now + 1.2 # 通知前端新端口 with self._lock: model = self._models.get(udid) if model: model.screenPort = self._port_by_udid.get(udid, model.screenPort) self._models[udid] = model self._manager_send(model) LogManager.method_info(f"重启成功，使用新端口 {self._port_by_udid.get(udid)}", method, udid=udid) # ---------------- 健康检查 ---------------- def _health_check_mjpeg(self, port: int, timeout: float = 0.8) -> bool: method = "_health_check_mjpeg" try: conn = http.client.HTTPConnection("127.0.0.1", port, timeout=timeout) conn.request("HEAD", "/") resp = conn.getresponse() _ = resp.read(128) code = getattr(resp, "status", 0) conn.close() return 200 <= code < 400 except Exception: return False def _health_check_wda(self, udid: str) -> bool: # 使用 HTTP 探测（带短缓存），避免触发 xctest return self._wda_is_running(udid, cache_sec=1.0) def _check_and_heal_tunnels(self, interval: float = 5.0): method = "_check_and_heal_tunnels" now = _monotonic() if now - self._last_heal_check_ts < interval: return self._last_heal_check_ts = now if (now - self._last_topology_change_ts) < max(self.ORPHAN_COOLDOWN, 6.0): LogManager.method_info("拓扑变更冷却中，本轮跳过自愈", method, udid="system") return with self._lock: items = list(self._models.items()) for udid, model in items: port = model.screenPort if port <= 0: continue ok_local = self._health_check_mjpeg(port, timeout=0.8) ok_wda = self._health_check_wda(udid) LogManager.method_info(f"健康检查：mjpeg={ok_local}, wda={ok_wda}, port={port}", method, udid=udid) if not (ok_local and ok_wda): LogManager.method_warning(f"检测到不健康，触发重启；port={port}", method, udid=udid) self._restart_iproxy(udid) # ---------------- Windows/*nix：列出所有 iproxy 命令行 ---------------- def _get_all_iproxy_cmdlines(self) -> List[str]: method = "_get_all_iproxy_cmdlines" lines: List[str] = [] with self._lock: live_pids = set(self._pid_by_udid.values()) is_windows = os.name == "nt" target_name = "iproxy.exe" if is_windows else "iproxy" for p in psutil.process_iter(attrs=["name", "cmdline", "pid"]): try: name = (p.info.get("name") or "").lower() if name != target_name: continue if p.info["pid"] in live_pids: continue cmdline = p.info.get("cmdline") or [] if not cmdline: continue if "-u" in cmdline: cmd = " ".join(cmdline) lines.append(f"{cmd} {p.info['pid']}") except (psutil.NoSuchProcess, psutil.AccessDenied): continue LogManager.method_info(f"扫描到候选 iproxy 进程数={len(lines)}", method, udid="system") return lines # ---------------- 杀孤儿 ---------------- def _cleanup_orphan_iproxy(self): method = "_cleanup_orphan_iproxy" with self._lock: live_udids = set(self._models.keys()) live_pids = set(self._pid_by_udid.values()) cleaned = 0 for ln in self._get_all_iproxy_cmdlines(): parts = ln.split() try: if "-u" not in parts: continue udid = parts[parts.index('-u') + 1] pid = int(parts[-1]) if pid not in live_pids and udid not in live_udids: self._kill_pid_gracefully(pid) cleaned += 1 LogManager.method_warning(f"孤儿 iproxy 已清理：udid={udid}, pid={pid}", method, udid=udid) except (ValueError, IndexError): continue if cleaned: LogManager.method_info(f"孤儿清理完成，数量={cleaned}", method, udid="system") # ---------------- 按 PID 强杀 ---------------- def _kill_pid_gracefully(self, pid: int): method = "_kill_pid_gracefully" try: p = psutil.Process(pid) p.terminate() try: p.wait(timeout=1.0) LogManager.method_info(f"进程已终止：pid={pid}", method, udid="system") except psutil.TimeoutExpired: p.kill() LogManager.method_warning(f"进程被强制 kill：pid={pid}", method, udid="system") except Exception as e: LogManager.method_warning(f"kill 进程异常：pid={pid}, err={e}", method, udid="system") # ---------------- 端口工具（兜底） ---------------- def _pick_free_port(self, start: int = None, limit: int = 2000) -> int: method = "_pick_free_port" p = self._port if start is None else start tried = 0 while tried < limit: p += 1 tried += 1 if self._is_port_free(p): LogManager.method_info(f"顺序扫描找到端口：{p}", method, udid="system") return p LogManager.method_error("顺序扫描未找到可用端口（范围内）", method, udid="system") raise RuntimeError("未找到可用端口（扫描范围内）") # ---------------- 其他 ---------------- def _manager_send(self, model: DeviceModel): method = "_manager_send" try: self._manager.send(model.toDict()) LogManager.method_info("已通知管理器（前端）", method, udid=model.deviceId) except Exception as e: LogManager.method_warning(f"通知管理器异常：{e}", method, udid=model.deviceId) def _find_iproxy(self) -> str: """优先环境变量 IPROXY_PATH；否则按平台在 resources/iproxy 查找。""" method = "_find_iproxy" env_path = os.getenv("IPROXY_PATH") if env_path and Path(env_path).is_file(): LogManager.method_info(f"使用环境变量指定的 iproxy 路径：{env_path}", method, udid="system") return env_path base = Path(__file__).resolve().parent.parent is_windows = os.name == "nt" name = "iproxy.exe" if is_windows else "iproxy" path = base / "resources" / "iproxy" / name LogManager.method_info(f"查找 iproxy 路径：{path}", method, udid="system") if path.is_file(): return str(path) err = f"iproxy 不存在: {path}" LogManager.method_error(err, method, udid="system") raise FileNotFoundError(err)