start_dev_server.py

#!/usr/bin/env python3
"""
CoC 7版 AI 守秘人系统 - 开发服务器启动脚本
统一管理所有服务进程，确保调试环境的一致性
"""

import subprocess
import time
import sys
import os
import signal
import atexit
from pathlib import Path

class DevServerManager:
    def __init__(self):
        self.processes = {}
        self.project_root = Path(__file__).parent
        self.log_dir = self.project_root / "logs"
        self.log_dir.mkdir(exist_ok=True)

        # 注册退出时的清理函数
        atexit.register(self.cleanup_all)

        # 设置信号处理
        signal.signal(signal.SIGINT, self.signal_handler)
        signal.signal(signal.SIGTERM, self.signal_handler)

    def log(self, service, message):
        """记录日志"""
        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
        log_msg = f"[{timestamp}] [{service}] {message}"

        # 控制台输出使用编码处理
        try:
            print(log_msg)
        except UnicodeEncodeError:
            # 如果控制台不支持Unicode，使用ASCII安全版本
            safe_msg = log_msg.encode('ascii', errors='ignore').decode('ascii')
            print(safe_msg)

        # 写入日志文件
        log_file = self.log_dir / f"{service.lower()}.log"
        with open(log_file, "a", encoding="utf-8") as f:
            f.write(log_msg + "\n")

    def _find_listening_pids_by_port(self, port):
        """Find PIDs listening on a specific port."""
        pids = set()

        if os.name == "nt":
            cmd = f'netstat -ano -p tcp | findstr /R /C:":{port}[ ]"'
            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
            for line in result.stdout.splitlines():
                parts = line.split()
                if len(parts) < 5:
                    continue
                local_addr = parts[1]
                state = parts[3].upper()
                pid = parts[4]
                if local_addr.endswith(f':{port}') and state == "LISTENING" and pid.isdigit():
                    pids.add(int(pid))
        else:
            # Linux/macOS: prefer lsof, fallback to ss.
            lsof_cmd = f"lsof -ti tcp:{port}"
            result = subprocess.run(lsof_cmd, shell=True, capture_output=True, text=True)
            if result.returncode == 0 and result.stdout.strip():
                for line in result.stdout.splitlines():
                    line = line.strip()
                    if line.isdigit():
                        pids.add(int(line))
            else:
                ss_cmd = f"ss -ltnp '( sport = :{port} )'"
                result = subprocess.run(ss_cmd, shell=True, capture_output=True, text=True)
                for line in result.stdout.splitlines():
                    # Example token includes: users:(("python3",pid=12345,fd=3))
                    if "pid=" in line:
                        try:
                            pid_part = line.split("pid=", 1)[1].split(",", 1)[0]
                            if pid_part.isdigit():
                                pids.add(int(pid_part))
                        except Exception:
                            continue

        return pids

    def _kill_pid(self, pid):
        """Terminate a process by PID."""
        try:
            if os.name == "nt":
                subprocess.run(f"taskkill /F /PID {pid}", shell=True, check=False, capture_output=True, text=True)
            else:
                subprocess.run(f"kill -TERM {pid}", shell=True, check=False, capture_output=True, text=True)
            self.log("MANAGER", f"已终止进程 PID: {pid}")
        except Exception as e:
            self.log("MANAGER", f"终止进程失败 PID {pid}: {e}")

    def kill_existing_processes(self):
        """Terminate existing dev services before start."""
        self.log("MANAGER", "正在清理现有进程...")

        # Prefer deterministic cleanup by service ports.
        target_ports = [8000, 8001, 3000]

        try:
            killed = set()
            for port in target_ports:
                pids = self._find_listening_pids_by_port(port)
                if not pids:
                    self.log("MANAGER", f"端口 {port} 未发现残留进程")
                    continue

                for pid in pids:
                    if pid in killed:
                        continue
                    self.log("MANAGER", f"端口 {port} 被进程占用，准备清理 PID: {pid}")
                    self._kill_pid(pid)
                    killed.add(pid)

        except Exception as e:
            self.log("MANAGER", f"清理进程时出错: {e}")

        # Wait for processes to fully terminate.
        time.sleep(2)

    def start_backend_rag(self):
        """启动RAG API服务 (端口8000)"""
        self.log("RAG-API", "启动RAG API服务...")

        log_file = self.log_dir / "rag_api.log"
        with open(log_file, "w", encoding="utf-8") as f:
            process = subprocess.Popen(
                [sys.executable, "gm_api_server.py"],
                cwd=self.project_root,
                stdout=f,
                stderr=subprocess.STDOUT
            )

        self.processes["rag_api"] = process
        self.log("RAG-API", f"RAG API服务已启动，PID: {process.pid}")

        # 等待服务启动
        time.sleep(3)
        return process

    def start_backend_agent(self):
        """启动CoC Agent API服务 (端口8001)"""
        self.log("AGENT-API", "启动CoC Agent API服务...")

        log_file = self.log_dir / "agent_api.log"
        with open(log_file, "w", encoding="utf-8") as f:
            process = subprocess.Popen(
                [sys.executable, "coc_apiagent.py"],
                cwd=self.project_root,
                stdout=f,
                stderr=subprocess.STDOUT
            )

        self.processes["agent_api"] = process
        self.log("AGENT-API", f"CoC Agent API服务已启动，PID: {process.pid}")

        # 等待服务启动
        time.sleep(3)
        return process

    def start_frontend(self):
        """启动前端开发服务器 (端口3000)"""
        self.log("FRONTEND", "启动前端开发服务器...")

        frontend_dir = self.project_root / "coc-frontend"
        log_file = self.log_dir / "frontend.log"

        with open(log_file, "w", encoding="utf-8") as f:
            process = subprocess.Popen(
                ["npm", "run", "dev"],
                cwd=frontend_dir,
                stdout=f,
                stderr=subprocess.STDOUT
            )

        self.processes["frontend"] = process
        self.log("FRONTEND", f"前端开发服务器已启动，PID: {process.pid}")

        # 等待服务启动
        time.sleep(5)
        return process

    def check_service_health(self, service_name, url, max_retries=10):
        """检查服务健康状态"""
        import requests

        for i in range(max_retries):
            try:
                response = requests.get(url, timeout=2)
                if response.status_code == 200:
                    self.log(service_name, f"✅ 服务健康检查通过")
                    return True
            except:
                pass

            self.log(service_name, f"⏳ 健康检查 {i+1}/{max_retries}...")
            time.sleep(1)

        self.log(service_name, f"❌ 服务健康检查失败")
        return False

    def signal_handler(self, signum, frame):
        """信号处理器"""
        self.log("MANAGER", f"收到信号 {signum}，正在关闭所有服务...")
        self.cleanup_all()
        sys.exit(0)

    def cleanup_all(self):
        """清理所有进程"""
        self.log("MANAGER", "正在清理所有服务进程...")

        for service_name, process in self.processes.items():
            if process and process.poll() is None:
                try:
                    process.terminate()
                    self.log(service_name, f"已终止进程 PID: {process.pid}")

                    # 等待进程优雅退出
                    time.sleep(1)

                    if process.poll() is None:
                        process.kill()
                        self.log(service_name, f"强制终止进程 PID: {process.pid}")

                except Exception as e:
                    self.log(service_name, f"终止进程时出错: {e}")

        self.processes.clear()
        self.log("MANAGER", "所有服务进程已清理完毕")

    def start_all(self):
        """启动所有服务"""
        print("=" * 60)
        print("CoC 7版 AI 守秘人系统 - 开发服务器")
        print("=" * 60)

        # 1. 清理现有进程
        self.kill_existing_processes()

        # 2. 启动后端服务
        self.start_backend_rag()
        self.start_backend_agent()

        # 3. 启动前端服务
        self.start_frontend()

        # 4. 健康检查
        print("\n🔍 正在进行服务健康检查...")

        health_checks = [
            ("RAG-API", "http://127.0.0.1:8000/health"),
            ("AGENT-API", "http://127.0.0.1:8001/health"),
        ]

        all_healthy = True
        for service_name, url in health_checks:
            if not self.check_service_health(service_name, url):
                all_healthy = False

        # 5. 显示启动结果
        print("\n" + "=" * 60)
        if all_healthy:
            print("🎉 所有服务启动成功！")
            print("\n📍 访问地址:")
            print("   前端游戏界面: http://localhost:3000")
            print("   RAG API文档:  http://127.0.0.1:8000/docs")
            print("   Agent API文档: http://127.0.0.1:8001/docs")
            print("\n📝 日志文件位置:")
            print(f"   {self.log_dir}")
            print("\n⚠️  按 Ctrl+C 停止所有服务")
        else:
            print("❌ 部分服务启动失败，请检查日志文件")
        print("=" * 60)

        # 6. 保持运行
        try:
            while True:
                # 检查是否有进程异常退出
                for service_name, process in list(self.processes.items()):
                    if process and process.poll() is not None:
                        self.log(service_name, f"⚠️  进程意外退出，PID: {process.pid}")
                        return False

                time.sleep(5)

        except KeyboardInterrupt:
            self.log("MANAGER", "收到中断信号，正在关闭服务...")
            return True

if __name__ == "__main__":
    manager = DevServerManager()
    try:
        success = manager.start_all()
        sys.exit(0 if success else 1)
    except Exception as e:
        manager.log("MANAGER", f"启动失败: {e}")
        manager.cleanup_all()
        sys.exit(1)