sycommon-python-lib 0.1.56b7__py3-none-any.whl → 0.1.56b9__py3-none-any.whl

sycommon/rabbitmq/rabbitmq_service_producer_manager.py

@@ -0,0 +1,235 @@
+from typing import List, Optional, Union, Dict, Any
+import asyncio
+import json
+import time
+from pydantic import BaseModel
+
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.models.mqsend_config import RabbitMQSendConfig
+from sycommon.config.Config import Config
+from sycommon.models.sso_user import SsoUser
+from sycommon.models.mqmsg_model import MQMsgModel
+from sycommon.rabbitmq.rabbitmq_client import RabbitMQClient
+from sycommon.rabbitmq.rabbitmq_service_client_manager import RabbitMQClientManager
+
+logger = SYLogger
+
+
+class RabbitMQProducerManager(RabbitMQClientManager):
+    """
+    RabbitMQ生产者管理类 - 负责发送器设置、消息发送
+    """
+    # 发送器相关状态
+    _sender_client_names: List[str] = []
+
+    @classmethod
+    async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False, **kwargs) -> None:
+        """设置消息发送器"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法设置发送器")
+            return
+
+        cls.set_mode_flags(has_listeners=has_listeners, has_senders=True)
+        logger.info(f"开始设置 {len(senders)} 个消息发送器，纯发送器模式: {not has_listeners}")
+
+        for idx, sender_config in enumerate(senders):
+            try:
+                if not sender_config.queue_name:
+                    raise ValueError(f"发送器配置第{idx+1}项缺少queue_name")
+
+                prefetch_count = sender_config.prefetch_count
+                queue_name = sender_config.queue_name
+                app_name = cls._config.get(
+                    "APP_NAME", "") if cls._config else ""
+
+                # 处理发送器队列名称
+                normalized_name = queue_name
+                if app_name and normalized_name.endswith(f".{app_name}"):
+                    normalized_name = normalized_name[:-len(f".{app_name}")]
+                    logger.info(f"发送器队列名称移除app-name后缀: {normalized_name}")
+
+                # 检查是否已初始化
+                if normalized_name in cls._sender_client_names:
+                    logger.info(f"发送客户端 '{normalized_name}' 已存在，跳过")
+                    continue
+
+                # 获取或创建客户端
+                if normalized_name in cls._clients:
+                    client = cls._clients[normalized_name]
+                    if not await client.is_connected:
+                        client.create_if_not_exists = False
+                        await client.connect()
+                else:
+                    client = await cls.get_client(
+                        client_name=normalized_name,
+                        exchange_type=sender_config.exchange_type,
+                        durable=sender_config.durable,
+                        auto_delete=sender_config.auto_delete,
+                        auto_parse_json=sender_config.auto_parse_json,
+                        queue_name=queue_name,
+                        create_if_not_exists=False,
+                        prefetch_count=prefetch_count, ** kwargs
+                    )
+
+                # 记录客户端
+                if normalized_name not in cls._clients:
+                    cls._clients[normalized_name] = client
+                    logger.info(f"发送客户端 '{normalized_name}' 已添加")
+
+                if normalized_name not in cls._sender_client_names:
+                    cls._sender_client_names.append(normalized_name)
+                    logger.info(f"发送客户端 '{normalized_name}' 初始化成功（纯发送器模式）")
+
+            except Exception as e:
+                logger.error(
+                    f"初始化发送客户端第{idx+1}项失败: {str(e)}", exc_info=True)
+
+        logger.info(
+            f"消息发送器设置完成，共 {len(cls._sender_client_names)} 个发送器，纯发送器模式: {not has_listeners}")
+
+    @classmethod
+    async def get_sender(cls, queue_name: str) -> Optional[RabbitMQClient]:
+        """获取发送客户端"""
+        if cls._is_shutdown:
+            logger.warning("服务已关闭，无法获取发送器")
+            return None
+
+        if not queue_name:
+            logger.warning("发送器名称不能为空")
+            return None
+
+        # 检查是否在已注册的发送器中
+        if queue_name in cls._sender_client_names and queue_name in cls._clients:
+            client = cls._clients[queue_name]
+            if await client.is_connected:
+                return client
+            else:
+                logger.info(f"发送器 '{queue_name}' 连接已断开，尝试重连")
+                try:
+                    client.create_if_not_exists = False
+                    await client.connect()
+                    if await client.is_connected:
+                        return client
+                except Exception as e:
+                    logger.error(f"发送器 '{queue_name}' 重连失败: {str(e)}")
+            return None
+
+        # 检查是否带有app-name后缀
+        app_name = cls._config.get("APP_NAME", "") if cls._config else ""
+        if app_name:
+            suffixed_name = f"{queue_name}.{app_name}"
+            if suffixed_name in cls._sender_client_names and suffixed_name in cls._clients:
+                client = cls._clients[suffixed_name]
+                if await client.is_connected:
+                    return client
+                else:
+                    logger.info(f"发送器 '{suffixed_name}' 连接已断开，尝试重连")
+                    try:
+                        client.create_if_not_exists = False
+                        await client.connect()
+                        if await client.is_connected:
+                            return client
+                    except Exception as e:
+                        logger.error(f"发送器 '{suffixed_name}' 重连失败: {str(e)}")
+
+        logger.info(f"未找到可用的发送器 '{queue_name}'")
+        return None
+
+    @classmethod
+    async def send_message(
+        cls,
+        data: Union[BaseModel, str, Dict[str, Any], None],
+        queue_name: str, **kwargs
+    ) -> None:
+        """发送消息到指定队列"""
+        if cls._is_shutdown:
+            raise RuntimeError("RabbitMQService已关闭，无法发送消息")
+
+        # 获取发送客户端
+        sender = await cls.get_sender(queue_name)
+        if not sender:
+            error_msg = f"未找到可用的RabbitMQ发送器 (queue_name: {queue_name})"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        # 确保连接有效
+        if not await sender.is_connected:
+            logger.info(f"发送器 '{queue_name}' 连接已关闭，尝试重新连接")
+            max_retry = 3
+            retry_count = 0
+            last_exception = None
+
+            while retry_count < max_retry and not cls._is_shutdown:
+                try:
+                    sender.create_if_not_exists = False
+                    await sender.connect()
+                    if await sender.is_connected:
+                        logger.info(
+                            f"发送器 '{queue_name}' 第 {retry_count + 1} 次重连成功")
+                        break
+                except Exception as e:
+                    last_exception = e
+                    retry_count += 1
+                    logger.warning(
+                        f"发送器 '{queue_name}' 第 {retry_count} 次重连失败: {str(e)}")
+                    await asyncio.sleep(cls.RECONNECT_INTERVAL)
+
+            if retry_count >= max_retry and not await sender.is_connected:
+                error_msg = f"发送器 '{queue_name}' 经过 {max_retry} 次重连仍失败"
+                logger.error(f"{error_msg}: {str(last_exception)}")
+                raise Exception(error_msg) from last_exception
+
+        try:
+            # 处理消息数据
+            msg_content = ""
+            if isinstance(data, str):
+                msg_content = data
+            elif isinstance(data, BaseModel):
+                msg_content = data.model_dump_json()
+            elif isinstance(data, dict):
+                msg_content = json.dumps(data, ensure_ascii=False)
+
+            # 创建标准消息模型
+            mq_message = MQMsgModel(
+                topicCode=queue_name.split('.')[0] if queue_name else "",
+                msg=msg_content,
+                correlationDataId=kwargs.get(
+                    'correlationDataId', logger.get_trace_id()),
+                groupId=kwargs.get('groupId', ''),
+                dataKey=kwargs.get('dataKey', ""),
+                manualFlag=kwargs.get('manualFlag', False),
+                traceId=logger.get_trace_id()
+            )
+
+            # 构建消息头
+            namespaceId = Config().config.get('Nacos', {}).get('namespaceId', '')
+            tenant_id = "T000002" if namespaceId == "prod" or namespaceId == "wsuat1" else "T000003"
+            mq_header = {
+                "context": SsoUser(
+                    tenant_id=tenant_id,
+                    customer_id="SYSTEM",
+                    user_id="SYSTEM",
+                    user_name="SYSTEM",
+                    request_path="/",
+                    req_type="SYSTEM",
+                    trace_id=logger.get_trace_id(),
+                ).model_dump_json(),
+                "tenant_id": logger.get_trace_id(),
+                "createTime": str(int(time.time() * 1000)),
+            }
+
+            # 发送消息
+            await sender.publish(
+                message_body=mq_message.model_dump_json(),
+                headers=mq_header,
+                content_type="application/json"
+            )
+            logger.info(f"消息发送成功 (队列: {queue_name})")
+        except Exception as e:
+            logger.error(f"消息发送失败: {str(e)}", exc_info=True)
+            raise
+
+    @classmethod
+    def clear_senders(cls) -> None:
+        """清理发送器状态"""
+        cls._sender_client_names.clear()

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,106 @@
+import json
+import threading
+import time
+from typing import Callable, Optional, Dict, List
+import yaml
+from sycommon.logging.kafka_log import SYLogger
+
+
+class NacosConfigManager:
+    """Nacos配置管理类 - 负责配置读取、监听和更新"""
+
+    def __init__(self, client_base):
+        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,142 @@
+import threading
+import time
+from sycommon.logging.kafka_log import SYLogger
+
+
+class NacosHeartbeatManager:
+    """Nacos心跳管理类 - 负责心跳发送和监控"""
+
+    def __init__(self, client_base, registration, 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