407 lines
11 KiB
Python
407 lines
11 KiB
Python
#!/usr/bin/env python3
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import os
|
||
import shutil
|
||
import signal
|
||
import subprocess
|
||
import sys
|
||
import time
|
||
import uuid
|
||
from datetime import datetime, timezone
|
||
from pathlib import Path
|
||
from typing import Any
|
||
|
||
ROOT = Path(__file__).resolve().parent
|
||
STATE_DIR = ROOT / ".tmp" / "dev-manager"
|
||
STATE_FILE = STATE_DIR / "state.json"
|
||
LOG_FILE = STATE_DIR / "dev.log"
|
||
ERR_FILE = STATE_DIR / "dev.err.log"
|
||
SUPERVISOR_MODE = "__serve"
|
||
API_URL = "http://localhost:3001"
|
||
WEB_URL = "http://localhost:5173"
|
||
NPM_EXECUTABLE = "npm.cmd" if os.name == "nt" else "npm"
|
||
|
||
|
||
def now_iso() -> str:
|
||
return datetime.now(timezone.utc).astimezone().isoformat(timespec="seconds")
|
||
|
||
|
||
def print_line(message: str) -> None:
|
||
print(message, flush=True)
|
||
|
||
|
||
def ensure_state_dir() -> None:
|
||
STATE_DIR.mkdir(parents=True, exist_ok=True)
|
||
|
||
|
||
def append_log_header(path: Path, title: str) -> None:
|
||
timestamp = now_iso()
|
||
with path.open("a", encoding="utf-8") as handle:
|
||
handle.write(f"\n[{timestamp}] {title}\n")
|
||
|
||
|
||
def read_state() -> dict[str, Any] | None:
|
||
if not STATE_FILE.exists():
|
||
return None
|
||
|
||
try:
|
||
return json.loads(STATE_FILE.read_text(encoding="utf-8"))
|
||
except (json.JSONDecodeError, OSError):
|
||
return None
|
||
|
||
|
||
def write_state(state: dict[str, Any]) -> None:
|
||
ensure_state_dir()
|
||
STATE_FILE.write_text(
|
||
json.dumps(state, ensure_ascii=True, indent=2),
|
||
encoding="utf-8"
|
||
)
|
||
|
||
|
||
def remove_state(expected_token: str | None = None) -> None:
|
||
if not STATE_FILE.exists():
|
||
return
|
||
|
||
if expected_token is not None:
|
||
current = read_state()
|
||
if not current or current.get("token") != expected_token:
|
||
return
|
||
|
||
STATE_FILE.unlink(missing_ok=True)
|
||
|
||
|
||
def process_exists(pid: int) -> bool:
|
||
try:
|
||
os.kill(pid, 0)
|
||
except ProcessLookupError:
|
||
return False
|
||
except PermissionError:
|
||
return True
|
||
except OSError:
|
||
return False
|
||
return True
|
||
|
||
|
||
def get_process_commandline(pid: int) -> str | None:
|
||
if os.name == "nt":
|
||
command = [
|
||
"powershell",
|
||
"-NoProfile",
|
||
"-Command",
|
||
(
|
||
f'$process = Get-CimInstance Win32_Process -Filter "ProcessId = {pid}"; '
|
||
'if ($process) { [Console]::Out.Write($process.CommandLine) }'
|
||
)
|
||
]
|
||
else:
|
||
command = ["ps", "-o", "command=", "-p", str(pid)]
|
||
|
||
result = subprocess.run(
|
||
command,
|
||
cwd=str(ROOT),
|
||
capture_output=True,
|
||
text=True,
|
||
encoding="utf-8",
|
||
errors="ignore",
|
||
check=False
|
||
)
|
||
|
||
commandline = result.stdout.strip()
|
||
return commandline or None
|
||
|
||
|
||
def is_expected_supervisor(state: dict[str, Any]) -> bool:
|
||
pid = int(state.get("pid", 0))
|
||
token = str(state.get("token", "")).strip()
|
||
if pid <= 0 or not token or not process_exists(pid):
|
||
return False
|
||
|
||
commandline = get_process_commandline(pid)
|
||
if not commandline:
|
||
return True
|
||
|
||
expected_fragments = [Path(__file__).name, SUPERVISOR_MODE, token]
|
||
return all(fragment in commandline for fragment in expected_fragments)
|
||
|
||
|
||
def get_running_state() -> dict[str, Any] | None:
|
||
state = read_state()
|
||
if not state:
|
||
return None
|
||
|
||
if not is_expected_supervisor(state):
|
||
remove_state()
|
||
return None
|
||
|
||
return state
|
||
|
||
|
||
def tail_text(path: Path, line_count: int = 20) -> str:
|
||
if not path.exists():
|
||
return ""
|
||
|
||
try:
|
||
content = path.read_text(encoding="utf-8", errors="ignore")
|
||
except OSError:
|
||
return ""
|
||
|
||
lines = content.splitlines()
|
||
if not lines:
|
||
return ""
|
||
|
||
return "\n".join(lines[-line_count:])
|
||
|
||
|
||
def ensure_npm_available() -> bool:
|
||
return shutil.which(NPM_EXECUTABLE) is not None
|
||
|
||
|
||
def wait_for_process_exit(pid: int, attempts: int = 20, interval: float = 0.25) -> bool:
|
||
for _ in range(attempts):
|
||
if not process_exists(pid):
|
||
return True
|
||
time.sleep(interval)
|
||
return not process_exists(pid)
|
||
|
||
|
||
def stop_process_tree(pid: int) -> bool:
|
||
if os.name == "nt":
|
||
graceful = subprocess.run(
|
||
["taskkill", "/PID", str(pid), "/T"],
|
||
cwd=str(ROOT),
|
||
capture_output=True,
|
||
text=True,
|
||
check=False
|
||
)
|
||
if graceful.returncode == 0:
|
||
if wait_for_process_exit(pid):
|
||
return True
|
||
|
||
forced = subprocess.run(
|
||
["taskkill", "/PID", str(pid), "/T", "/F"],
|
||
cwd=str(ROOT),
|
||
capture_output=True,
|
||
text=True,
|
||
check=False
|
||
)
|
||
if forced.returncode == 0:
|
||
wait_for_process_exit(pid)
|
||
return True
|
||
return not process_exists(pid)
|
||
|
||
try:
|
||
os.killpg(os.getpgid(pid), signal.SIGTERM)
|
||
except OSError:
|
||
return not process_exists(pid)
|
||
|
||
if wait_for_process_exit(pid):
|
||
return True
|
||
|
||
try:
|
||
os.killpg(os.getpgid(pid), signal.SIGKILL)
|
||
except OSError:
|
||
return not process_exists(pid)
|
||
|
||
if wait_for_process_exit(pid):
|
||
return True
|
||
|
||
return not process_exists(pid)
|
||
|
||
|
||
def start_supervisor() -> int:
|
||
ensure_state_dir()
|
||
append_log_header(LOG_FILE, "starting root dev command")
|
||
append_log_header(ERR_FILE, "starting root dev command")
|
||
|
||
token = uuid.uuid4().hex
|
||
creation_flags = 0
|
||
if os.name == "nt":
|
||
creation_flags |= getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
|
||
creation_flags |= getattr(subprocess, "DETACHED_PROCESS", 0)
|
||
|
||
process = subprocess.Popen(
|
||
[sys.executable, str(Path(__file__).resolve()), SUPERVISOR_MODE, token],
|
||
cwd=str(ROOT),
|
||
stdin=subprocess.DEVNULL,
|
||
stdout=subprocess.DEVNULL,
|
||
stderr=subprocess.DEVNULL,
|
||
creationflags=creation_flags,
|
||
close_fds=True
|
||
)
|
||
|
||
deadline = time.monotonic() + 10
|
||
state: dict[str, Any] | None = None
|
||
while time.monotonic() < deadline:
|
||
current = read_state()
|
||
if current and current.get("token") == token and is_expected_supervisor(current):
|
||
state = current
|
||
break
|
||
if process.poll() is not None:
|
||
break
|
||
time.sleep(0.2)
|
||
|
||
if not state:
|
||
print_line("启动失败：后台 supervisor 没有成功创建。")
|
||
error_tail = tail_text(ERR_FILE)
|
||
if error_tail:
|
||
print_line(error_tail)
|
||
return 1
|
||
|
||
time.sleep(3)
|
||
state = get_running_state()
|
||
if not state:
|
||
print_line("启动失败：`npm run dev` 很快退出了。")
|
||
error_tail = tail_text(ERR_FILE)
|
||
if error_tail:
|
||
print_line(error_tail)
|
||
else:
|
||
log_tail = tail_text(LOG_FILE)
|
||
if log_tail:
|
||
print_line(log_tail)
|
||
return 1
|
||
|
||
print_line("已启动前后端开发环境。")
|
||
print_line(f"Web: {WEB_URL}")
|
||
print_line(f"API: {API_URL}")
|
||
print_line(f"状态文件: {STATE_FILE}")
|
||
print_line(f"日志: {LOG_FILE}")
|
||
print_line("关闭命令: python start.py stop")
|
||
print_line("无参数执行时会自动在启动和关闭之间切换。")
|
||
return 0
|
||
|
||
|
||
def stop_supervisor() -> int:
|
||
state = get_running_state()
|
||
if not state:
|
||
remove_state()
|
||
print_line("当前没有运行中的开发环境。")
|
||
return 0
|
||
|
||
pid = int(state["pid"])
|
||
token = str(state["token"])
|
||
stopped = stop_process_tree(pid)
|
||
remove_state(expected_token=token)
|
||
|
||
if stopped:
|
||
print_line("已关闭前后端开发环境。")
|
||
return 0
|
||
|
||
print_line(f"关闭失败：无法结束 supervisor 进程 {pid}。")
|
||
return 1
|
||
|
||
|
||
def show_status() -> int:
|
||
state = get_running_state()
|
||
if not state:
|
||
print_line("状态: 未运行")
|
||
print_line("启动命令: python start.py start")
|
||
return 0
|
||
|
||
print_line("状态: 运行中")
|
||
print_line(f"Supervisor PID: {state['pid']}")
|
||
child_pid = state.get("childPid")
|
||
if child_pid:
|
||
print_line(f"Root dev PID: {child_pid}")
|
||
print_line(f"启动时间: {state['startedAt']}")
|
||
print_line(f"Web: {state['webUrl']}")
|
||
print_line(f"API: {state['apiUrl']}")
|
||
print_line(f"日志: {state['logFile']}")
|
||
print_line(f"错误日志: {state['errorLogFile']}")
|
||
return 0
|
||
|
||
|
||
def run_supervisor(token: str) -> int:
|
||
ensure_state_dir()
|
||
state = {
|
||
"pid": os.getpid(),
|
||
"token": token,
|
||
"startedAt": now_iso(),
|
||
"root": str(ROOT),
|
||
"logFile": str(LOG_FILE),
|
||
"errorLogFile": str(ERR_FILE),
|
||
"webUrl": WEB_URL,
|
||
"apiUrl": API_URL,
|
||
"command": [NPM_EXECUTABLE, "run", "dev"]
|
||
}
|
||
write_state(state)
|
||
|
||
with LOG_FILE.open("a", encoding="utf-8") as stdout_handle, ERR_FILE.open(
|
||
"a",
|
||
encoding="utf-8"
|
||
) as stderr_handle:
|
||
stdout_handle.write(f"[{now_iso()}] supervisor pid={os.getpid()}\n")
|
||
stdout_handle.flush()
|
||
|
||
child = subprocess.Popen(
|
||
[NPM_EXECUTABLE, "run", "dev"],
|
||
cwd=str(ROOT),
|
||
stdin=subprocess.DEVNULL,
|
||
stdout=stdout_handle,
|
||
stderr=stderr_handle
|
||
)
|
||
|
||
state["childPid"] = child.pid
|
||
write_state(state)
|
||
|
||
try:
|
||
return child.wait()
|
||
finally:
|
||
append_log_header(LOG_FILE, "root dev command stopped")
|
||
remove_state(expected_token=token)
|
||
|
||
|
||
def show_usage() -> int:
|
||
print_line("用法: python start.py [start|stop|restart|status|toggle]")
|
||
print_line("无参数默认执行 toggle。")
|
||
return 1
|
||
|
||
|
||
def main() -> int:
|
||
action = sys.argv[1].strip().lower() if len(sys.argv) > 1 else "toggle"
|
||
|
||
if action == SUPERVISOR_MODE:
|
||
if len(sys.argv) < 3:
|
||
return 1
|
||
return run_supervisor(sys.argv[2])
|
||
|
||
if action == "start":
|
||
running = get_running_state()
|
||
if running:
|
||
print_line("开发环境已在运行。")
|
||
return show_status()
|
||
if not ensure_npm_available():
|
||
print_line("未找到 npm，请先安装 Node.js 并确认 npm 已加入 PATH。")
|
||
return 1
|
||
return start_supervisor()
|
||
|
||
if action == "stop":
|
||
return stop_supervisor()
|
||
|
||
if action == "restart":
|
||
stop_code = stop_supervisor()
|
||
if stop_code != 0:
|
||
return stop_code
|
||
if not ensure_npm_available():
|
||
print_line("未找到 npm，请先安装 Node.js 并确认 npm 已加入 PATH。")
|
||
return 1
|
||
return start_supervisor()
|
||
|
||
if action == "status":
|
||
return show_status()
|
||
|
||
if action == "toggle":
|
||
if get_running_state():
|
||
return stop_supervisor()
|
||
if not ensure_npm_available():
|
||
print_line("未找到 npm，请先安装 Node.js 并确认 npm 已加入 PATH。")
|
||
return 1
|
||
return start_supervisor()
|
||
|
||
return show_usage()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|