280 lines
9.7 KiB
Python
280 lines
9.7 KiB
Python
import asyncio
|
|
import logging
|
|
import os
|
|
import socket
|
|
from dataclasses import dataclass
|
|
from typing import Any, Dict, Optional
|
|
|
|
try:
|
|
import nacos # type: ignore
|
|
except ImportError:
|
|
nacos = None
|
|
|
|
from config import Config
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
@dataclass
|
|
class NacosConfig:
|
|
"""Nacos 配置"""
|
|
enabled: bool
|
|
server_addresses: str
|
|
namespace: str
|
|
group_name: str
|
|
cluster_name: str
|
|
username: Optional[str]
|
|
password: Optional[str]
|
|
heartbeat_interval: int
|
|
weight: float
|
|
ephemeral: bool
|
|
register_port: Optional[int]
|
|
|
|
|
|
@dataclass
|
|
class ServiceConfig:
|
|
"""服务配置"""
|
|
service_name: str
|
|
host: str
|
|
port: int
|
|
ip: str
|
|
metadata: Dict[str, Any]
|
|
|
|
|
|
def _get_local_ip() -> str:
|
|
"""获取本地 IP 地址"""
|
|
for env_name in ("POD_IP", "HOST_IP"):
|
|
env_ip = os.getenv(env_name)
|
|
if env_ip:
|
|
return env_ip
|
|
|
|
try:
|
|
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
|
s.connect(("8.8.8.8", 80))
|
|
ip = s.getsockname()[0]
|
|
s.close()
|
|
return ip
|
|
except Exception:
|
|
try:
|
|
host_ip = socket.gethostbyname(socket.gethostname())
|
|
if host_ip and host_ip != "127.0.0.1":
|
|
return host_ip
|
|
except Exception:
|
|
pass
|
|
|
|
logger.warning("获取本地 IP 失败，使用 127.0.0.1")
|
|
return "127.0.0.1"
|
|
|
|
|
|
def load_nacos_config() -> NacosConfig:
|
|
"""从 config.ini 读取 Nacos 配置"""
|
|
section = "nacos"
|
|
enabled = Config._config.getboolean(section, "enabled", fallback=False)
|
|
register_port = Config._config.getint(section, "register_port", fallback=0)
|
|
return NacosConfig(
|
|
enabled=enabled,
|
|
server_addresses=Config._config.get(section, "server", fallback="localhost:8848"),
|
|
namespace=Config._config.get(section, "namespace", fallback="public"),
|
|
group_name=Config._config.get(section, "group_name", fallback="DEFAULT_GROUP"),
|
|
cluster_name=Config._config.get(section, "cluster_name", fallback="DEFAULT"),
|
|
username=Config._config.get(section, "username", fallback="") or None,
|
|
password=Config._config.get(section, "password", fallback="") or None,
|
|
heartbeat_interval=Config._config.getint(section, "heartbeat_interval", fallback=5),
|
|
weight=Config._config.getfloat(section, "weight", fallback=1.0),
|
|
ephemeral=Config._config.getboolean(section, "ephemeral", fallback=True),
|
|
register_port=register_port if register_port > 0 else None,
|
|
)
|
|
|
|
|
|
def load_service_config() -> ServiceConfig:
|
|
"""从 config.ini 读取服务配置"""
|
|
section = "app"
|
|
service_name = Config._config.get(section, "service_name", fallback="apbo-boat-agent")
|
|
host = Config._config.get(section, "host", fallback="0.0.0.0")
|
|
port = Config._config.getint(section, "port", fallback=8000)
|
|
ip = host if host not in ("0.0.0.0", "::") else _get_local_ip()
|
|
|
|
metadata = {
|
|
"version": Config._config.get(section, "version", fallback="1.0.0"),
|
|
"service_type": "fastapi",
|
|
"api_paths": "/health,/api/workflows,/api/workflows/stream,/nacos/status",
|
|
"streaming": "true",
|
|
"model_section": Config._config.get(section, "model_section", fallback=Config.DEFAULT_MODEL_SECTION),
|
|
}
|
|
|
|
extra_meta = Config.get_section("metadata")
|
|
if extra_meta:
|
|
metadata.update(extra_meta)
|
|
|
|
return ServiceConfig(
|
|
service_name=service_name,
|
|
host=host,
|
|
port=port,
|
|
ip=ip,
|
|
metadata=metadata,
|
|
)
|
|
|
|
|
|
class NacosManager:
|
|
"""Nacos 服务注册与心跳管理"""
|
|
|
|
def __init__(self, nacos_config: NacosConfig, service_config: ServiceConfig):
|
|
self.nacos_config = nacos_config
|
|
self.service_config = service_config
|
|
self.client = None
|
|
self._heartbeat_task: Optional[asyncio.Task] = None
|
|
self._stop_event = asyncio.Event()
|
|
self.is_registered = False
|
|
|
|
def _registration_port(self) -> int:
|
|
"""Nacos 注册端口：优先使用 nacos.register_port，未配置时回退 app.port。"""
|
|
return int(self.nacos_config.register_port or self.service_config.port)
|
|
|
|
def _init_client(self) -> bool:
|
|
"""初始化 Nacos 客户端"""
|
|
if nacos is None:
|
|
raise ImportError("未安装 nacos-sdk-python，请先安装依赖")
|
|
|
|
try:
|
|
self.client = nacos.NacosClient(
|
|
server_addresses=self.nacos_config.server_addresses,
|
|
namespace=self.nacos_config.namespace,
|
|
username=self.nacos_config.username,
|
|
password=self.nacos_config.password,
|
|
)
|
|
logger.info(f"Nacos 客户端初始化成功: {self.nacos_config.server_addresses}")
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"Nacos 客户端初始化失败: {e}")
|
|
return False
|
|
|
|
def register_service(self) -> bool:
|
|
"""注册服务到 Nacos"""
|
|
if not self.client and not self._init_client():
|
|
return False
|
|
|
|
try:
|
|
self.client.add_naming_instance(
|
|
service_name=self.service_config.service_name,
|
|
ip=self.service_config.ip,
|
|
port=self._registration_port(),
|
|
cluster_name=self.nacos_config.cluster_name,
|
|
group_name=self.nacos_config.group_name,
|
|
weight=self.nacos_config.weight,
|
|
metadata=self.service_config.metadata,
|
|
ephemeral=self.nacos_config.ephemeral,
|
|
)
|
|
self.is_registered = True
|
|
logger.info(
|
|
"✅ 服务注册成功: %s (%s:%s)",
|
|
self.service_config.service_name,
|
|
self.service_config.ip,
|
|
self._registration_port(),
|
|
)
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"❌ 服务注册失败: {e}")
|
|
self.is_registered = False
|
|
return False
|
|
|
|
def deregister_service(self) -> bool:
|
|
"""从 Nacos 注销服务"""
|
|
if not self.client or not self.is_registered:
|
|
return True
|
|
|
|
try:
|
|
self.client.remove_naming_instance(
|
|
service_name=self.service_config.service_name,
|
|
ip=self.service_config.ip,
|
|
port=self._registration_port(),
|
|
cluster_name=self.nacos_config.cluster_name,
|
|
group_name=self.nacos_config.group_name,
|
|
)
|
|
self.is_registered = False
|
|
logger.info("✅ 服务注销成功: %s", self.service_config.service_name)
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"❌ 服务注销失败: {e}")
|
|
return False
|
|
|
|
def _send_heartbeat(self) -> None:
|
|
"""发送心跳"""
|
|
if not self.client or not self.is_registered:
|
|
return
|
|
|
|
self.client.send_heartbeat(
|
|
service_name=self.service_config.service_name,
|
|
ip=self.service_config.ip,
|
|
port=self._registration_port(),
|
|
cluster_name=self.nacos_config.cluster_name,
|
|
group_name=self.nacos_config.group_name,
|
|
)
|
|
|
|
async def _heartbeat_loop(self) -> None:
|
|
"""心跳循环"""
|
|
interval = max(1, self.nacos_config.heartbeat_interval)
|
|
self._stop_event.clear()
|
|
|
|
while not self._stop_event.is_set():
|
|
try:
|
|
if not self.is_registered:
|
|
if self.register_service():
|
|
logger.info("✅ Nacos 重试注册成功: %s", self.service_config.service_name)
|
|
else:
|
|
logger.warning("⚠️ Nacos 注册重试失败: %s", self.service_config.service_name)
|
|
else:
|
|
self._send_heartbeat()
|
|
logger.debug("心跳发送成功: %s", self.service_config.service_name)
|
|
except Exception as e:
|
|
logger.warning(f"心跳发送失败: {e}")
|
|
# 尝试重新注册
|
|
try:
|
|
self.register_service()
|
|
except Exception as re:
|
|
logger.error(f"重新注册失败: {re}")
|
|
|
|
try:
|
|
await asyncio.wait_for(self._stop_event.wait(), timeout=interval)
|
|
except asyncio.TimeoutError:
|
|
continue
|
|
|
|
async def start(self) -> None:
|
|
"""启动注册与心跳"""
|
|
if not self.nacos_config.enabled:
|
|
logger.info("Nacos 未启用，跳过注册")
|
|
return
|
|
|
|
if not self.register_service():
|
|
logger.warning("⚠️ Nacos 注册失败，服务继续运行")
|
|
|
|
# 无论首次注册是否成功，都启动循环以便持续重试注册
|
|
self._heartbeat_task = asyncio.create_task(self._heartbeat_loop())
|
|
logger.info("✅ Nacos 心跳任务已启动")
|
|
|
|
async def stop(self) -> None:
|
|
"""停止心跳并注销"""
|
|
self._stop_event.set()
|
|
|
|
if self._heartbeat_task:
|
|
self._heartbeat_task.cancel()
|
|
try:
|
|
await self._heartbeat_task
|
|
except asyncio.CancelledError:
|
|
pass
|
|
|
|
self.deregister_service()
|
|
|
|
def status(self) -> Dict[str, Any]:
|
|
"""获取当前状态"""
|
|
return {
|
|
"service_name": self.service_config.service_name,
|
|
"ip": self.service_config.ip,
|
|
"port": self.service_config.port,
|
|
"register_port": self._registration_port(),
|
|
"namespace": self.nacos_config.namespace,
|
|
"group": self.nacos_config.group_name,
|
|
"cluster": self.nacos_config.cluster_name,
|
|
"registered": self.is_registered,
|
|
"heartbeat_running": self._heartbeat_task is not None and not self._heartbeat_task.done(),
|
|
}
|