sycommon-python-lib 0.1.56b5__py3-none-any.whl → 0.1.57b1__py3-none-any.whl

sycommon/synacos/nacos_client_base.py

@@ -0,0 +1,119 @@
+import threading
+import time
+from typing import Optional
+import nacos
+from sycommon.logging.kafka_log import SYLogger
+
+
+class NacosClientBase:
+    """Nacos客户端基础类 - 负责客户端初始化和连接管理"""
+
+    def __init__(self, nacos_config: dict, enable_register_nacos: bool):
+        self.nacos_config = nacos_config
+        self.enable_register_nacos = enable_register_nacos
+
+        # 客户端配置
+        self.max_retries = self.nacos_config.get('maxRetries', 5)
+        self.retry_delay = self.nacos_config.get('retryDelay', 5)
+        self.max_retry_delay = self.nacos_config.get('maxRetryDelay', 30)
+
+        # 状态管理
+        self._client_initialized = False
+        self._state_lock = threading.RLock()
+        self._shutdown_event = threading.Event()
+        self.nacos_client: Optional[nacos.NacosClient] = None
+
+    def _initialize_client(self) -> bool:
+        """初始化Nacos客户端（仅首次调用时执行）"""
+        if self._client_initialized:
+            return True
+
+        for attempt in range(self.max_retries):
+            try:
+                register_ip = self.nacos_config['registerIp']
+                namespace_id = self.nacos_config['namespaceId']
+                self.nacos_client = nacos.NacosClient(
+                    server_addresses=register_ip,
+                    namespace=namespace_id
+                )
+                SYLogger.info("nacos:客户端初始化成功")
+                self._client_initialized = True
+                return True
+            except Exception as e:
+                delay = min(self.retry_delay, self.max_retry_delay)
+                SYLogger.error(
+                    f"nacos:客户端初始化失败 (尝试 {attempt+1}/{self.max_retries}): {e}")
+                time.sleep(delay)
+
+        SYLogger.warning("nacos:无法连接到 Nacos 服务器，已达到最大重试次数")
+        return False
+
+    def ensure_client_connected(self, retry_once: bool = False) -> bool:
+        """确保Nacos客户端已连接，返回连接状态"""
+        with self._state_lock:
+            if self._client_initialized:
+                return True
+
+        SYLogger.warning("nacos:客户端未初始化，尝试连接...")
+
+        max_attempts = 2 if retry_once else self.max_retries
+        attempt = 0
+
+        while attempt < max_attempts:
+            try:
+                register_ip = self.nacos_config['registerIp']
+                namespace_id = self.nacos_config['namespaceId']
+
+                self.nacos_client = nacos.NacosClient(
+                    server_addresses=register_ip,
+                    namespace=namespace_id
+                )
+
+                if self._verify_client_connection():
+                    with self._state_lock:
+                        self._client_initialized = True
+                    SYLogger.info("nacos:客户端初始化成功")
+                    return True
+                else:
+                    raise ConnectionError("nacos:客户端初始化后无法验证连接")
+
+            except Exception as e:
+                attempt += 1
+                delay = min(self.retry_delay, self.max_retry_delay)
+                SYLogger.error(
+                    f"nacos:客户端初始化失败 (尝试 {attempt}/{max_attempts}): {e}")
+                time.sleep(delay)
+
+        SYLogger.error("nacos:无法连接到 Nacos 服务器，已达到最大重试次数")
+        return False
+
+    def _verify_client_connection(self) -> bool:
+        """验证客户端是否真正连接成功"""
+        if not self.enable_register_nacos:
+            return True
+
+        try:
+            namespace_id = self.nacos_config['namespaceId']
+            self.nacos_client.list_naming_instance(
+                service_name="",  # 空服务名仅用于验证连接
+                namespace_id=namespace_id,
+                group_name="DEFAULT_GROUP",
+                healthy_only=True
+            )
+            return True
+        except Exception as e:
+            SYLogger.warning(f"nacos:客户端连接验证失败: {e}")
+            return False
+
+    def reconnect_nacos_client(self) -> bool:
+        """重新连接Nacos客户端"""
+        SYLogger.warning("nacos:尝试重新连接Nacos客户端")
+        with self._state_lock:
+            self._client_initialized = False
+        return self.ensure_client_connected()
+
+    @property
+    def is_connected(self) -> bool:
+        """检查客户端是否已连接"""
+        with self._state_lock:
+            return self._client_initialized

sycommon/synacos/nacos_config_manager.py

@@ -0,0 +1,107 @@
+import json
+import threading
+import time
+from typing import Callable, Optional, Dict, List
+from sycommon.synacos.nacos_client_base import NacosClientBase
+import yaml
+from sycommon.logging.kafka_log import SYLogger
+
+
+class NacosConfigManager:
+    """Nacos配置管理类 - 负责配置读取、监听和更新"""
+
+    def __init__(self, client_base: NacosClientBase):
+        self.client_base = client_base
+
+        # 配置
+        self.config_watch_interval = self.client_base.nacos_config.get(
+            'configWatchInterval', 30)
+
+        # 状态
+        self.share_configs: Dict = {}
+        self._config_listeners: Dict[str, Callable[[str], None]] = {}
+        self._config_cache: Dict[str, str] = {}
+        self._watch_thread: Optional[threading.Thread] = None
+
+    def read_configs(self, shared_configs: List[Dict]) -> dict:
+        """读取共享配置"""
+        configs = {}
+
+        for config in shared_configs:
+            data_id = config['dataId']
+            group = config['group']
+
+            for attempt in range(self.client_base.max_retries):
+                try:
+                    if not self.client_base.ensure_client_connected():
+                        self.client_base.reconnect_nacos_client()
+
+                    content = self.client_base.nacos_client.get_config(
+                        data_id, group)
+
+                    try:
+                        configs[data_id] = json.loads(content)
+                    except json.JSONDecodeError:
+                        try:
+                            configs[data_id] = yaml.safe_load(content)
+                        except yaml.YAMLError:
+                            SYLogger.error(f"nacos:无法解析 {data_id} 的内容")
+                    break
+                except Exception as e:
+                    if attempt < self.client_base.max_retries - 1:
+                        SYLogger.warning(
+                            f"nacos:读取配置 {data_id} 失败 (尝试 {attempt+1}/{self.client_base.max_retries}): {e}")
+                        time.sleep(self.client_base.retry_delay)
+                    else:
+                        SYLogger.error(
+                            f"nacos:读取配置 {data_id} 失败，已达到最大重试次数: {e}")
+
+        self.share_configs = configs
+        return configs
+
+    def add_config_listener(self, data_id: str, callback: Callable[[str], None]):
+        """添加配置变更监听器"""
+        self._config_listeners[data_id] = callback
+        if config := self.get_config(data_id):
+            callback(config)
+
+    def get_config(self, data_id: str, group: str = "DEFAULT_GROUP") -> Optional[str]:
+        """获取配置内容"""
+        if not self.client_base.ensure_client_connected():
+            return None
+
+        try:
+            return self.client_base.nacos_client.get_config(data_id, group=group)
+        except Exception as e:
+            SYLogger.error(f"nacos:获取配置 {data_id} 失败: {str(e)}")
+            return None
+
+    def start_watch_configs(self):
+        """启动配置监视线程"""
+        self._watch_thread = threading.Thread(
+            target=self._watch_configs, daemon=True)
+        self._watch_thread.start()
+
+    def _watch_configs(self):
+        """配置监听线程"""
+        check_interval = self.config_watch_interval
+
+        while not self.client_base._shutdown_event.is_set():
+            try:
+                for data_id, callback in list(self._config_listeners.items()):
+                    new_config = self.get_config(data_id)
+                    if new_config and new_config != self._config_cache.get(data_id):
+                        callback(new_config)
+                        self._config_cache[data_id] = new_config
+                        try:
+                            self.share_configs[data_id] = json.loads(
+                                new_config)
+                        except json.JSONDecodeError:
+                            try:
+                                self.share_configs[data_id] = yaml.safe_load(
+                                    new_config)
+                            except yaml.YAMLError:
+                                SYLogger.error(f"nacos:无法解析 {data_id} 的内容")
+            except Exception as e:
+                SYLogger.error(f"nacos:配置监视线程异常: {str(e)}")
+            self.client_base._shutdown_event.wait(check_interval)

sycommon/synacos/nacos_heartbeat_manager.py

@@ -0,0 +1,144 @@
+import threading
+import time
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.synacos.nacos_client_base import NacosClientBase
+from sycommon.synacos.nacos_service_registration import NacosServiceRegistration
+
+
+class NacosHeartbeatManager:
+    """Nacos心跳管理类 - 负责心跳发送和监控"""
+
+    def __init__(self, client_base: NacosClientBase, registration: NacosServiceRegistration, heartbeat_interval: int = 15):
+        self.client_base = client_base
+        self.registration = registration
+
+        # 心跳配置
+        self.heartbeat_interval = heartbeat_interval
+        self.heartbeat_timeout = 15
+        self.max_heartbeat_timeout = self.client_base.nacos_config.get(
+            'maxHeartbeatTimeout', 30)
+
+        # 状态管理
+        self._heartbeat_lock = threading.Lock()
+        self._heartbeat_thread = None
+        self._last_heartbeat_time = 0
+        self._heartbeat_fail_count = 0
+
+    def start_heartbeat(self):
+        """启动心跳线程（确保单例）"""
+        with self._heartbeat_lock:
+            if self._heartbeat_thread is not None and self._heartbeat_thread.is_alive():
+                return
+
+            self._heartbeat_thread = None
+
+            self._heartbeat_thread = threading.Thread(
+                target=self._send_heartbeat_loop,
+                name="NacosHeartbeatThread",
+                daemon=True
+            )
+            self._heartbeat_thread.start()
+            SYLogger.info(
+                f"nacos:心跳线程启动，线程ID: {self._heartbeat_thread.ident}，"
+                f"心跳间隔: {self.heartbeat_interval}秒，"
+                f"心跳超时: {self.heartbeat_timeout}秒"
+            )
+
+    def _send_heartbeat_loop(self):
+        """心跳发送循环"""
+        current_thread = threading.current_thread()
+        thread_ident = current_thread.ident
+        SYLogger.info(
+            f"nacos:心跳循环启动 - 线程ID: {thread_ident}, "
+            f"配置间隔: {self.heartbeat_interval}秒, "
+            f"超时时间: {self.heartbeat_timeout}秒"
+        )
+
+        consecutive_fail = 0
+
+        while not self.client_base._shutdown_event.is_set():
+            current_time = time.time()
+
+            try:
+                registered_status = self.registration.registered
+
+                if not registered_status:
+                    SYLogger.warning(
+                        f"nacos:服务未注册，跳过心跳 - 线程ID: {thread_ident}")
+                    consecutive_fail = 0
+                else:
+                    success = self.send_heartbeat()
+                    if success:
+                        consecutive_fail = 0
+                        SYLogger.info(
+                            f"nacos:心跳发送成功 - 时间: {current_time:.3f}, "
+                            f"间隔: {self.heartbeat_interval}秒"
+                        )
+                    else:
+                        consecutive_fail += 1
+                        SYLogger.warning(
+                            f"nacos:心跳发送失败 - 连续失败: {consecutive_fail}次"
+                        )
+                        if consecutive_fail >= 5:
+                            SYLogger.error("nacos:心跳连续失败5次，尝试重连")
+                            self.client_base.reconnect_nacos_client()
+                            consecutive_fail = 0
+
+            except Exception as e:
+                consecutive_fail += 1
+                SYLogger.error(
+                    f"nacos:心跳异常: {str(e)}, 连续失败: {consecutive_fail}次")
+
+            self.client_base._shutdown_event.wait(self.heartbeat_interval)
+
+        SYLogger.info(f"nacos:心跳循环已停止 - 线程ID: {thread_ident}")
+
+    def send_heartbeat(self) -> bool:
+        """发送心跳并添加超时控制"""
+        if not self.client_base.ensure_client_connected():
+            SYLogger.warning("nacos:客户端未连接，心跳发送失败")
+            return False
+
+        result_list = []
+
+        def heartbeat_task():
+            try:
+                result = self._send_heartbeat_internal()
+                result_list.append(result)
+            except Exception as e:
+                SYLogger.error(f"nacos:心跳任务执行异常: {e}")
+                result_list.append(False)
+
+        task_thread = threading.Thread(
+            target=heartbeat_task,
+            daemon=True,
+            name="NacosHeartbeatTaskThread"
+        )
+        task_thread.start()
+        task_thread.join(timeout=self.heartbeat_timeout)
+
+        if not result_list:
+            SYLogger.error(f"nacos:心跳发送超时（{self.heartbeat_timeout}秒）")
+            self.client_base._client_initialized = False
+            return False
+
+        return result_list[0]
+
+    def _send_heartbeat_internal(self) -> bool:
+        """实际的心跳发送逻辑"""
+        result = self.client_base.nacos_client.send_heartbeat(
+            service_name=self.registration.service_name,
+            ip=self.registration.real_ip,
+            port=int(self.registration.port),
+            cluster_name="DEFAULT",
+            weight=1.0,
+            metadata={
+                "version": self.registration.version} if self.registration.version else None
+        )
+
+        if result and isinstance(result, dict) and result.get('lightBeatEnabled', False):
+            SYLogger.info(f"nacos:心跳发送成功，Nacos返回: {result}")
+            return True
+        else:
+            SYLogger.warning(f"nacos:心跳发送失败，Nacos返回: {result}")
+            return False