315 lines
13 KiB
Python
315 lines
13 KiB
Python
#!/usr/bin/env python3
|
||
"""ecat_proc.py — ecat_native 进程治理（跨进程锁 / autostart / kill / RealTime）。
|
||
|
||
从 esp32_server.py 外提（R8）。职责是「谁有权把 ecat_native 拉起来/杀掉」，
|
||
不碰 HTTP/静态/lease——那些留在 esp32_server.py。
|
||
|
||
路径注入：BASE_DIR **只在 esp32_server 定义一次**，启动时调用
|
||
`init(BASE_DIR)` 设置本模块的 ECAT_DIR / ECAT_NATIVE_EXE，并向
|
||
ecat_client 注册 autostart 钩子。
|
||
|
||
保留 P0 行为（不得回退）：
|
||
- 跨进程命名互斥锁 _EcatProcXLock（GUI 进程 + 服务子进程串行 kill/start）
|
||
- **先复用健康监听实例**，绝不 kill 对方刚拉起的 native
|
||
- 默认网卡 I210（与 js/common/device-link.js / pages/motor.html 一致，R2）
|
||
- 拉起时带 --parent-pid，native 在本服务退出后自我了断
|
||
- stdout 落盘（DEVNULL 会吞掉崩溃现场）
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import ctypes
|
||
import os
|
||
import subprocess
|
||
import threading
|
||
import time
|
||
|
||
import ecat_client
|
||
|
||
# 网卡默认子串：与 js/common/device-link.js / pages/motor.html 保持一致（R2）
|
||
ECAT_DEFAULT_ADAPTER = "I210"
|
||
|
||
ECAT_DIR = None
|
||
ECAT_NATIVE_EXE = None
|
||
|
||
g_ecat_child = None # 由本服务拉起的 ecat 服务子进程(复用已有实例时为 None)
|
||
g_ecat_log_fp = None # native stdout 落盘句柄(见 autostart 内注释)
|
||
g_ecat_lock = threading.Lock() # 串行化自动启动, 避免并发请求拉起多个进程
|
||
|
||
# R3: 跨进程互斥（GUI 进程 + 服务子进程都可能 autostart/kill native）
|
||
_ECAT_XPROC_MUTEX_NAME = "Local\\DCU_Esp32Tools_EcatNativeProc"
|
||
|
||
|
||
def _resolve_ecat_dir(base_dir):
|
||
"""定位 tools/ecat（ecat_native.exe 的仓库，与本仓库平级）。
|
||
|
||
从 git worktree（.../tools/ESP32/.worktrees/<slug>）启动时，BASE_DIR 的
|
||
上一级是 .worktrees 而不是 tools，直接 join("..","ecat") 会拼成
|
||
.../ESP32/.worktrees/ecat，找不到 exe。先走回主检出再取兄弟目录。
|
||
"""
|
||
d = os.path.abspath(base_dir)
|
||
parent = os.path.dirname(d)
|
||
if os.path.basename(parent) == ".worktrees":
|
||
d = os.path.dirname(parent) # → .../tools/ESP32 主检出
|
||
return os.path.normpath(os.path.join(d, "..", "ecat"))
|
||
|
||
|
||
def init(base_dir: str) -> dict:
|
||
"""由 esp32_server 在导入时调用：注入 BASE_DIR，注册 autostart 钩子。"""
|
||
global ECAT_DIR, ECAT_NATIVE_EXE
|
||
ECAT_DIR = _resolve_ecat_dir(base_dir)
|
||
ECAT_NATIVE_EXE = os.path.join(ECAT_DIR, "build_native", "ecat_native.exe")
|
||
ecat_client.set_autostart_hook(autostart)
|
||
return {"ecat_dir": ECAT_DIR, "native_exe": ECAT_NATIVE_EXE}
|
||
|
||
|
||
class _EcatProcXLock:
|
||
"""Windows 命名互斥锁：串行化所有会 kill/拉起 ecat_native 的路径。"""
|
||
|
||
def __init__(self, timeout_ms=60000):
|
||
self.timeout_ms = timeout_ms
|
||
self._handle = None
|
||
self._owned = False
|
||
|
||
def __enter__(self):
|
||
k32 = ctypes.WinDLL("kernel32", use_last_error=True)
|
||
self._handle = k32.CreateMutexW(None, False, _ECAT_XPROC_MUTEX_NAME)
|
||
if not self._handle:
|
||
return self
|
||
r = k32.WaitForSingleObject(self._handle, self.timeout_ms)
|
||
# WAIT_OBJECT_0=0, WAIT_ABANDONED=0x80
|
||
self._owned = r in (0, 0x80)
|
||
return self
|
||
|
||
def __exit__(self, *exc):
|
||
if not self._handle:
|
||
return False
|
||
k32 = ctypes.WinDLL("kernel32", use_last_error=True)
|
||
try:
|
||
if self._owned:
|
||
k32.ReleaseMutex(self._handle)
|
||
finally:
|
||
k32.CloseHandle(self._handle)
|
||
self._handle = None
|
||
return False
|
||
|
||
|
||
def _set_ecat_realtime(pid: int) -> bool:
|
||
"""把 ecat_native 提到 RealTime 进程优先级。
|
||
|
||
native 自己 SetPriorityClass(RT) 会被系统静默钳成 High（令牌无
|
||
SeIncreaseBasePriorityPrivilege）。由本服务（启动方）从外部设置才能粘住。
|
||
pdo 线程已是 TIME_CRITICAL：进程类 High→线程 15，RealTime→线程 31，
|
||
后者才扛得住桌面 DPC/调度抢占。实测 1ms 档 late ~12/s → 个位数。
|
||
失败返回 False，不影响启动。
|
||
"""
|
||
try:
|
||
import ctypes.wintypes as wt # noqa: F401
|
||
PROCESS_SET_INFORMATION = 0x0200
|
||
REALTIME_PRIORITY_CLASS = 0x00000100
|
||
HIGH_PRIORITY_CLASS = 0x00000080
|
||
k32 = ctypes.WinDLL("kernel32", use_last_error=True)
|
||
h = k32.OpenProcess(PROCESS_SET_INFORMATION, False, int(pid))
|
||
if not h:
|
||
return False
|
||
try:
|
||
if k32.SetPriorityClass(h, REALTIME_PRIORITY_CLASS):
|
||
return True
|
||
return bool(k32.SetPriorityClass(h, HIGH_PRIORITY_CLASS))
|
||
finally:
|
||
k32.CloseHandle(h)
|
||
except Exception:
|
||
return False
|
||
|
||
|
||
def _ecat_reuse_listening_native():
|
||
"""端口上已有健康 native → 直接复用（可能是另一进程刚拉起的），不 kill。"""
|
||
g_port = ecat_client.g_ecat_port
|
||
ports = ([g_port] if g_port else []) + \
|
||
[p for p in ecat_client.ECAT_PORTS if p != g_port]
|
||
for p in ports:
|
||
if not ecat_client._port_taken(p):
|
||
continue
|
||
try:
|
||
status, data = ecat_client._ecat_post(
|
||
p, "/api/native/health", b"{}", 1.0,
|
||
connect_timeout=0.4)
|
||
if status == 200:
|
||
return p
|
||
except Exception:
|
||
continue
|
||
return None
|
||
|
||
|
||
def _kill_all_ecat_native():
|
||
"""强杀所有 ecat_native.exe，返回杀掉的个数。
|
||
|
||
两个 native 并存会抢 Npcap 适配器：后起的抓不到从站、HTTP 超时、
|
||
PDO 空转。启动新实例前必须保证旧的死透。只按进程名杀，不碰 python。
|
||
"""
|
||
try:
|
||
out = subprocess.check_output(
|
||
["tasklist", "/FI", "IMAGENAME eq ecat_native.exe",
|
||
"/FO", "CSV", "/NH"],
|
||
text=True, stderr=subprocess.DEVNULL, timeout=8,
|
||
creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
|
||
) or ""
|
||
except Exception:
|
||
return 0
|
||
pids = []
|
||
for line in (out or "").splitlines():
|
||
parts = [p.strip().strip('"') for p in line.split(",")]
|
||
if len(parts) >= 2 and parts[0].lower() == "ecat_native.exe":
|
||
try:
|
||
pids.append(int(parts[1]))
|
||
except ValueError:
|
||
pass
|
||
if not pids:
|
||
return 0
|
||
for pid in pids:
|
||
try:
|
||
subprocess.run(
|
||
["taskkill", "/F", "/PID", str(pid)],
|
||
capture_output=True, timeout=5,
|
||
creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
|
||
)
|
||
except Exception:
|
||
pass
|
||
# 等 Npcap 句柄随进程退出由内核回收
|
||
deadline = time.time() + 3.0
|
||
while time.time() < deadline:
|
||
try:
|
||
again = subprocess.check_output(
|
||
["tasklist", "/FI", "IMAGENAME eq ecat_native.exe",
|
||
"/FO", "CSV", "/NH"],
|
||
text=True, stderr=subprocess.DEVNULL, timeout=4,
|
||
creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
|
||
) or ""
|
||
if "ecat_native.exe" not in (again or "").lower():
|
||
break
|
||
except Exception:
|
||
break
|
||
time.sleep(0.2)
|
||
else:
|
||
time.sleep(0.3)
|
||
return len(pids)
|
||
|
||
|
||
def autostart():
|
||
"""按需拉起 tools/ecat 的服务进程。返回 (port, log_lines)。
|
||
|
||
单实例策略（2026-09-12，R3 加固 2026-09-23）：
|
||
- 跨进程命名互斥锁串行化 kill/start（GUI 进程与服务子进程共用）。
|
||
- **先探测健康监听实例并复用**，绝不 kill 对方刚拉起的 native。
|
||
- 本进程子进程仍存活 → 只等它听口，**绝不 kill_all**（否则启动中的实例
|
||
会被自己下一次请求杀掉，形成 8s kill_stale 死循环）。
|
||
- 子进程已死 / 从未拉起且无健康监听 → 先 taskkill 全部残留 ecat_native，再起唯一实例。
|
||
port 为 None 表示拉不起来。
|
||
"""
|
||
global g_ecat_child, g_ecat_log_fp
|
||
if not ECAT_NATIVE_EXE:
|
||
return None, ["ecat_proc.init 未调用（BASE_DIR 未注入）"]
|
||
with _EcatProcXLock():
|
||
with g_ecat_lock:
|
||
logs = []
|
||
|
||
# ── R3: 另一进程（GUI/服务）已在跑的健康实例 → 复用 ──
|
||
reuse = _ecat_reuse_listening_native()
|
||
if reuse:
|
||
ecat_client.g_ecat_port = reuse
|
||
return reuse, [f"复用已在监听的 EtherCAT native (端口 {reuse})"]
|
||
|
||
# ── 我们自己拉起的还活着：只复用/等它，不杀 ──
|
||
if g_ecat_child is not None and g_ecat_child.poll() is None:
|
||
port = ecat_client._ecat_find_port()
|
||
if port:
|
||
ecat_client.g_ecat_port = port
|
||
return port, []
|
||
# 仍在启动（kill_stale/绑口最多约 10s）：等完再判
|
||
deadline = time.time() + 10
|
||
while time.time() < deadline:
|
||
if g_ecat_child.poll() is not None:
|
||
break
|
||
port = ecat_client._ecat_find_port()
|
||
if port:
|
||
ecat_client.g_ecat_port = port
|
||
return port, []
|
||
time.sleep(0.3)
|
||
if g_ecat_child.poll() is None:
|
||
return None, logs + ["EtherCAT 服务仍在启动中(未监听端口)，请稍候再试"]
|
||
g_ecat_child = None
|
||
|
||
if g_ecat_child is not None and g_ecat_child.poll() is not None:
|
||
g_ecat_child = None
|
||
|
||
if not os.path.isfile(ECAT_NATIVE_EXE):
|
||
return None, [
|
||
f"找不到 EtherCAT 原生守护进程: {ECAT_NATIVE_EXE}",
|
||
"请先运行 tools\\ecat\\build_native.bat 编译(需 VS2022 + Npcap)。",
|
||
]
|
||
|
||
# 无健康监听才清残留：禁止双实例抢网卡
|
||
killed = _kill_all_ecat_native()
|
||
if killed:
|
||
logs.append(f"已清掉 {killed} 个残留 ecat_native（单实例，防抢网卡）")
|
||
|
||
try:
|
||
# 日志落文件而不是 DEVNULL：native 的 stdout 是崩溃/楔死/自动重拉的
|
||
# 唯一现场（WEDGE、kill_stale、进 OP 全打这里），DEVNULL 吞掉后只能靠
|
||
# Windows 事件日志反推（2026-09-12 教训）。追加写，重启服务不清零。
|
||
if g_ecat_log_fp is None:
|
||
g_ecat_log_fp = open(
|
||
os.path.join(ECAT_DIR, "build_native", "native_stdout.log"),
|
||
"ab", buffering=0)
|
||
g_ecat_child = subprocess.Popen(
|
||
[ECAT_NATIVE_EXE, "--substr", ECAT_DEFAULT_ADAPTER,
|
||
"--mask", "0x50",
|
||
"--web", "src/web", "--parent-pid", str(os.getpid())],
|
||
cwd=ECAT_DIR,
|
||
stdout=g_ecat_log_fp, stderr=subprocess.STDOUT,
|
||
stdin=subprocess.DEVNULL,
|
||
creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
|
||
)
|
||
logs.append(f"已自动启动 EtherCAT 原生守护进程(pid {g_ecat_child.pid})")
|
||
if _set_ecat_realtime(g_ecat_child.pid):
|
||
logs.append(f"EtherCAT 进程优先级已提到 RealTime(pid {g_ecat_child.pid})")
|
||
else:
|
||
logs.append("EtherCAT 进程 RealTime 提权失败(保持默认/High, 可手动设)")
|
||
|
||
except OSError as e:
|
||
return None, logs + [f"启动 EtherCAT 服务失败: {type(e).__name__}: {e}"]
|
||
|
||
deadline = time.time() + 12
|
||
while time.time() < deadline:
|
||
if g_ecat_child.poll() is not None:
|
||
return None, logs + [
|
||
f"EtherCAT 守护进程启动后立刻退出(exit={g_ecat_child.returncode}) —— "
|
||
"多为 Npcap 未安装或 8090..8095 全被占; "
|
||
"可双击 tools/ecat/ecat_web.bat 看具体报错"]
|
||
port = ecat_client._ecat_find_port()
|
||
if port:
|
||
ecat_client.g_ecat_port = port
|
||
logs.append(f"EtherCAT 服务已就绪(端口 {port})")
|
||
return port, logs
|
||
time.sleep(0.3)
|
||
return None, logs + ["EtherCAT 服务启动超时(12s 内未监听端口)"]
|
||
|
||
|
||
# 旧名兼容（server / 脚本）
|
||
_ecat_autostart = autostart
|
||
|
||
|
||
def watch_parent(ppid):
|
||
"""兜底看门狗(Job Object 万一不可用时): 父 GUI 进程消失就自我了断,
|
||
避免窗口关了服务还在后台占端口。"""
|
||
def _loop():
|
||
k32 = ctypes.windll.kernel32
|
||
h = k32.OpenProcess(0x00100000, False, ppid) # SYNCHRONIZE
|
||
if not h:
|
||
return
|
||
k32.WaitForSingleObject(h, 0xFFFFFFFF) # 父进程退出即返回
|
||
os._exit(0)
|
||
threading.Thread(target=_loop, daemon=True).start()
|
||
|
||
|
||
_watch_parent = watch_parent
|