sycommon-python-lib 0.1.7__tar.gz → 0.1.9__tar.gz

{sycommon_python_lib-0.1.7 → sycommon_python_lib-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.7
+Version: 0.1.9
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.1.7 → sycommon_python_lib-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.1.7"
+version = "0.1.9"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.10"

{sycommon_python_lib-0.1.7 → sycommon_python_lib-0.1.9}/src/sycommon/middleware/traceid.py

@@ -95,7 +95,7 @@ def setup_trace_id_handler(app):
                 if "application/json" in content_type and not content_disposition.startswith("attachment"):
                     try:
                         data = json.loads(response_body)
-                        data["trace_id"] = trace_id
+                        data["traceId"] = trace_id
                         new_body = json.dumps(
                             data, ensure_ascii=False).encode()
                         response = Response(

{sycommon_python_lib-0.1.7 → sycommon_python_lib-0.1.9}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -183,8 +183,14 @@ class RabbitMQClient:
                 await asyncio.sleep(1)
         return False
 
-    async def connect(self, force_reconnect: bool = False, max_retries: int = 3) -> None:
-        """建立连接并检查/创建资源"""
+    async def connect(self, force_reconnect: bool = False, declare_queue: bool = True) -> None:
+        """建立连接并检查/创建资源，新增declare_queue参数控制是否声明队列"""
+        # 增加日志确认参数状态
+        logging.debug(
+            f"connect() 调用 - force_reconnect={force_reconnect}, "
+            f"declare_queue={declare_queue}, create_if_not_exists={self.create_if_not_exists}"
+        )
+
         if self.is_connected and not force_reconnect:
             return
 
@@ -196,7 +202,8 @@ class RabbitMQClient:
             f"尝试连接RabbitMQ - 主机: {self.host}:{self.port}, "
             f"虚拟主机: {self.virtualhost}, "
             f"队列: {self.queue_name}, "
-            f"心跳间隔: {self.heartbeat}s"
+            f"声明队列: {declare_queue}, "
+            f"允许创建: {self.create_if_not_exists}"
         )
 
         # 重置状态
@@ -207,13 +214,13 @@ class RabbitMQClient:
         retries = 0
         last_exception = None
 
-        while retries < max_retries:
+        while retries < 3:  # 使用固定重试次数
             try:
                 # 关闭旧连接
                 if self.connection and not self.connection.is_closed:
                     await self.connection.close()
 
-                # 建立新连接 - 配置更短的心跳间隔
+                # 建立新连接
                 self.connection = await asyncio.wait_for(
                     aio_pika.connect_robust(
                         host=self.host,
@@ -223,7 +230,7 @@ class RabbitMQClient:
                         virtualhost=self.virtualhost,
                         heartbeat=self.heartbeat,
                         client_properties={
-                            "connection_name": self.app_name or "rabbitmq-client"}  # 增加连接标识
+                            "connection_name": self.app_name or "rabbitmq-client"}
                     ),
                     timeout=self.connection_timeout
                 )
@@ -262,28 +269,29 @@ class RabbitMQClient:
                     )
                     logging.info(f"使用已存在的交换机 '{self.exchange_name}'")
 
-                # 2. 处理队列
-                if self.queue_name:
+                # 2. 处理队列 - 只有declare_queue为True时才处理
+                if declare_queue and self.queue_name:
                     queue_exists = await self._check_queue_exists()
 
                     if not queue_exists:
-                        if self.create_if_not_exists:
-                            # 创建队列
-                            self.queue = await asyncio.wait_for(
-                                self.channel.declare_queue(
-                                    name=self.queue_name,
-                                    durable=self.durable,
-                                    auto_delete=self.auto_delete,
-                                    exclusive=False,
-                                    passive=False
-                                ),
-                                timeout=self.rpc_timeout
-                            )
-                            self._queue_exists = True
-                            logging.info(f"已创建队列 '{self.queue_name}'")
-                        else:
+                        # 关键检查点：确保有权限创建队列
+                        if not self.create_if_not_exists:
                             raise Exception(
                                 f"队列 '{self.queue_name}' 不存在且不允许自动创建")
+
+                        # 创建队列
+                        self.queue = await asyncio.wait_for(
+                            self.channel.declare_queue(
+                                name=self.queue_name,
+                                durable=self.durable,
+                                auto_delete=self.auto_delete,
+                                exclusive=False,
+                                passive=False
+                            ),
+                            timeout=self.rpc_timeout
+                        )
+                        self._queue_exists = True
+                        logging.info(f"已创建队列 '{self.queue_name}'")
                     else:
                         # 获取已有队列
                         self.queue = await asyncio.wait_for(
@@ -292,12 +300,18 @@ class RabbitMQClient:
                         )
                         logging.info(f"使用已存在的队列 '{self.queue_name}'")
 
-                # 3. 绑定队列到交换机
-                if self.queue and self.exchange:
-                    bound = await self._bind_queue()
-                    if not bound:
-                        raise Exception(
-                            f"队列 '{self.queue_name}' 绑定到交换机 '{self.exchange_name}' 失败")
+                    # 3. 绑定队列到交换机
+                    if self.queue and self.exchange:
+                        bound = await self._bind_queue()
+                        if not bound:
+                            raise Exception(
+                                f"队列 '{self.queue_name}' 绑定到交换机 '{self.exchange_name}' 失败")
+                else:
+                    # 不声明队列时，将队列相关状态设为False
+                    self.queue = None
+                    self._queue_exists = False
+                    self._queue_bound = False
+                    logging.debug(f"跳过队列 '{self.queue_name}' 的声明和绑定")
 
                 # 如果之前在消费，重新开始消费
                 if self._is_consuming and self.message_handler:
@@ -308,23 +322,22 @@ class RabbitMQClient:
                 self._start_keepalive_task()
 
                 self._update_activity_timestamp()
-                logging.info(f"RabbitMQ客户端连接成功 (队列: {self.queue_name})")
+                logging.info(
+                    f"RabbitMQ客户端连接成功 (队列: {self.queue_name}, 声明队列: {declare_queue})")
                 return
 
             except Exception as e:
                 retries += 1
                 last_exception = e
                 logging.warning(
-                    f"连接失败（{retries}/{max_retries}）: {str(e)}，重试中...")
+                    f"连接失败（{retries}/3）: {str(e)}, create_if_not_exists={self.create_if_not_exists}, 重试中...")
 
-            if retries < max_retries:
+            if retries < 3:
                 await asyncio.sleep(self.reconnection_delay)
 
-        logging.error(f"最终连接失败: {str(last_exception)}", exc_info=True)
+        logging.error(f"最终连接失败: {str(last_exception)}")
         raise Exception(
-            f"经过{max_retries}次重试后仍无法完成连接和资源初始化。"
-            f"最后错误: {str(last_exception)}"
-        )
+            f"经过3次重试后仍无法完成连接和资源初始化。最后错误: {str(last_exception)}")
 
     def _start_connection_monitor(self):
         """启动连接监控任务，检测连接/通道关闭"""
@@ -534,16 +547,31 @@ class RabbitMQClient:
         self.message_handler = handler
 
     async def start_consuming(self, timeout: Optional[float] = None) -> str:
-        """开始消费消息并返回consumer_tag，支持超时控制"""
+        """开始消费消息并返回consumer_tag，支持超时控制和队列检查重试"""
         if self._is_consuming:
             logging.debug("已经在消费中，返回现有consumer_tag")
             return self._consumer_tag
 
-        if not self.is_connected:
-            await self.connect()
+        # 增加队列检查和连接确保逻辑
+        max_attempts = 5
+        attempt = 0
+        while attempt < max_attempts:
+            if not self.is_connected:
+                await self.connect()
+
+            if self.queue:
+                break
+
+            attempt += 1
+            logging.warning(f"队列尚未初始化，等待后重试（{attempt}/{max_attempts}）")
+            await asyncio.sleep(1)
 
         if not self.queue:
-            raise Exception("队列未初始化")
+            # 最后尝试一次显式连接并声明队列
+            logging.warning("最后尝试重新连接并声明队列")
+            await self.connect(force_reconnect=True, declare_queue=True)
+            if not self.queue:
+                raise Exception("队列未初始化，多次尝试后仍无法创建")
 
         if not self.message_handler:
             raise Exception("未设置消息处理函数")

{sycommon_python_lib-0.1.7 → sycommon_python_lib-0.1.9}/src/sycommon/rabbitmq/rabbitmq_service.py

@@ -31,15 +31,22 @@ class RabbitMQService:
     _initialized_queues: Dict[str, Dict[str, bool]] = {}
     # 添加异步锁
     _init_lock: Dict[str, asyncio.Lock] = {}
+    _has_listeners: bool = False
+    _has_senders: bool = False
 
     @classmethod
-    def init(cls, config: dict) -> Type['RabbitMQService']:
-        """初始化RabbitMQ服务，保存配置"""
+    def init(cls, config: dict, has_listeners: bool = False, has_senders: bool = False) -> Type['RabbitMQService']:
+        """初始化RabbitMQ服务，保存配置和发送器/监听器状态"""
         from sycommon.synacos.nacos_service import NacosService
         # 获取 common 配置
         cls.config = NacosService(config).share_configs.get(
             "mq.yml", {}).get('spring', {}).get('rabbitmq', {})
         cls.config["APP_NAME"] = config.get("Name", "")
+
+        # 保存发送器和监听器存在状态
+        cls._has_listeners = has_listeners
+        cls._has_senders = has_senders
+
         return cls()
 
     @classmethod
@@ -56,21 +63,35 @@ class RabbitMQService:
 
     @classmethod
     def create_client(cls, mq_config: dict, queue_name: str, **kwargs):
-        """创建并返回新的RabbitMQClient实例"""
-        # 从kwargs中提取是否自动创建队列的参数，默认True
-        create_if_not_exists = kwargs.get('create_if_not_exists', True)
+        """创建并返回新的RabbitMQClient实例，遵循队列创建规则"""
+        # 获取当前项目名
+        app_name = kwargs.get('app_name', cls.config.get(
+            "APP_NAME", "")) if cls.config else kwargs.get('app_name', "")
 
         # 确保只在需要时处理一次队列名称
         processed_queue_name = queue_name
 
-        # 如果是监听器且需要自动创建队列，确保队列名拼接app-name（只拼接一次）
-        if create_if_not_exists and processed_queue_name and 'app_name' in kwargs and kwargs['app_name']:
-            app_name = kwargs['app_name']
-            # 只在队列名尚未包含app-name时进行拼接
+        # 通过上下文判断是否为发送器
+        # 发送器场景：当没有监听器时
+        is_sender = not cls._has_listeners
+
+        # 核心逻辑：根据组件存在状态决定是否允许创建队列
+        # 1. 只有发送器：不允许创建队列
+        # 2. 只有监听器：允许创建队列
+        # 3. 两者都存在：允许创建队列（由监听器负责）
+        create_if_not_exists = cls._has_listeners  # 只要有监听器就允许创建
+
+        # 当需要创建队列且是监听器时，拼接项目名
+        if create_if_not_exists and not is_sender and processed_queue_name and app_name:
             if not processed_queue_name.endswith(f".{app_name}"):
                 processed_queue_name = f"{processed_queue_name}.{app_name}"
                 logging.debug(f"监听器队列名称自动拼接app-name: {processed_queue_name}")
 
+        logging.debug(
+            f"队列创建权限 - 监听器存在: {cls._has_listeners}, 发送器存在: {cls._has_senders}, "
+            f"是否发送器: {is_sender}, 允许创建: {create_if_not_exists}, 队列: {processed_queue_name}"
+        )
+
         return RabbitMQClient(
             host=mq_config.get('host', ""),
             port=mq_config.get('port', 0),
@@ -80,7 +101,7 @@ class RabbitMQService:
             exchange_name=mq_config.get(
                 'exchange_name', "system.topic.exchange"),
             exchange_type=kwargs.get('exchange_type', "topic"),
-            queue_name=processed_queue_name,  # 使用处理后的队列名
+            queue_name=processed_queue_name,
             routing_key=kwargs.get(
                 'routing_key', f"{processed_queue_name.split('.')[0]}.#" if processed_queue_name else "#"),
             durable=kwargs.get('durable', True),
@@ -89,7 +110,7 @@ class RabbitMQService:
             create_if_not_exists=create_if_not_exists,
             connection_timeout=kwargs.get('connection_timeout', 10),
             rpc_timeout=kwargs.get('rpc_timeout', 5),
-            app_name=kwargs.get('app_name', "")
+            app_name=app_name
         )
 
     @classmethod
@@ -105,52 +126,80 @@ class RabbitMQService:
         async with cls._init_lock[client_name]:
             if client_name in cls.clients:
                 client = cls.clients[client_name]
+                # 移除is_sender判断，通过上下文推断
+                is_sender = not cls._has_listeners or (
+                    not kwargs.get('create_if_not_exists', True))
+
                 if client.is_connected:
-                    logging.debug(f"客户端 '{client_name}' 已存在且连接有效，直接返回")
+                    if not is_sender and not client.queue:
+                        logging.debug(f"客户端 '{client_name}' 存在但队列未初始化，重新连接")
+                        client.create_if_not_exists = True
+                        await client.connect(force_reconnect=True, declare_queue=True)
+                    else:
+                        logging.debug(f"客户端 '{client_name}' 已存在且连接有效，直接返回")
                     return client
                 else:
                     logging.debug(f"客户端 '{client_name}' 存在但连接已关闭，重新连接")
-                    await client.connect()
+                    if not is_sender:
+                        client.create_if_not_exists = True
+                    await client.connect(declare_queue=not is_sender)
                     return client
 
             initial_queue_name = kwargs.pop('queue_name', '')
-            create_if_not_exists = kwargs.get('create_if_not_exists', True)
+            # 移除is_sender参数，通过上下文推断
+            is_sender = not cls._has_listeners or (
+                not kwargs.get('create_if_not_exists', True))
+
+            # 发送器特殊处理
+            if is_sender:
+                kwargs['create_if_not_exists'] = False
 
-            # 检查队列是否已初始化
-            if initial_queue_name in cls._initialized_queues:
-                logging.debug(f"队列 '{initial_queue_name}' 已初始化过，直接创建客户端")
                 client = RabbitMQService.create_client(
                     mq_config,
                     initial_queue_name,
                     app_name=cls.config.get("APP_NAME", ""),
-                    **kwargs
+                    **kwargs  # 不再传递is_sender参数
                 )
-                await client.connect()
+
+                await client.connect(declare_queue=False)
                 cls.clients[client_name] = client
                 return client
 
-            # 处理create_if_not_exists参数，避免重复传递
-            create_if_not_exists = kwargs.pop('create_if_not_exists', True)
+            # 监听器逻辑
+            kwargs['create_if_not_exists'] = True
 
-            # 对于监听器，确保create_if_not_exists为True
-            # 判断是否为监听器：客户端名称与队列名称相同通常是监听器
-            is_listener = client_name == initial_queue_name and initial_queue_name
-            if is_listener:
-                create_if_not_exists = True
-                logging.debug(f"监听器 '{client_name}' 将自动创建队列（如果不存在）")
+            if initial_queue_name in cls._initialized_queues:
+                logging.debug(f"队列 '{initial_queue_name}' 已初始化过，直接创建客户端")
+                client = RabbitMQService.create_client(
+                    mq_config,
+                    initial_queue_name,
+                    # 不再传递is_sender参数
+                    app_name=cls.config.get("APP_NAME", ""), ** kwargs
+                )
+                await client.connect(declare_queue=True)
+                cls.clients[client_name] = client
+                return client
 
-            # 创建客户端（这里会处理队列名称，添加app-name）
             client = RabbitMQService.create_client(
                 mq_config,
                 initial_queue_name,
                 app_name=cls.config.get("APP_NAME", ""),
-                create_if_not_exists=create_if_not_exists,
-                connection_timeout=mq_config.get('connection_timeout', 15),
-                rpc_timeout=mq_config.get('rpc_timeout', 5), ** kwargs
+                **kwargs  # 不再传递is_sender参数
             )
 
-            # 连接时不再处理队列名称，避免重复添加app-name
-            await client.connect()
+            client.create_if_not_exists = True
+            logging.debug(
+                f"监听器客户端创建 - create_if_not_exists={client.create_if_not_exists}")
+
+            await client.connect(declare_queue=True)
+
+            if not client.queue:
+                logging.error(f"队列 '{initial_queue_name}' 创建失败，尝试重新创建")
+                client.create_if_not_exists = True
+                await client.connect(force_reconnect=True, declare_queue=True)
+                if not client.queue:
+                    raise Exception(f"无法创建队列 '{initial_queue_name}'")
+
             final_queue_name = client.queue_name
 
             if final_queue_name not in cls._initialized_queues:
@@ -163,8 +212,11 @@ class RabbitMQService:
             return client
 
     @classmethod
-    async def setup_senders(cls, senders: List[RabbitMQSendConfig]):
-        """设置MQ发送客户端 - 保持不自动创建队列的行为"""
+    async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False):
+        """设置MQ发送客户端"""
+        cls._has_listeners = has_listeners
+        cls._has_senders = True  # 明确标记存在发送器
+
         async def setup_sender_tasks():
             for idx, sender_config in enumerate(senders):
                 try:
@@ -173,20 +225,23 @@ class RabbitMQService:
 
                     normalized_name = sender_config.queue_name
                     app_name = cls.config.get("APP_NAME", "")
+
                     if app_name and normalized_name.endswith(f".{app_name}"):
                         normalized_name = normalized_name[:-
                                                           len(f".{app_name}")]
+                        logging.debug(
+                            f"发送器队列名称移除app-name后缀: {normalized_name}")
 
                     if normalized_name in cls.sender_client_names:
-                        logging.debug(f"发送客户端 '{normalized_name}' 已存在，跳过重复配置")
+                        logging.debug(f"发送客户端 '{normalized_name}' 已存在，跳过")
                         continue
 
                     if normalized_name in cls.clients:
                         client = cls.clients[normalized_name]
                         if not client.is_connected:
-                            await client.connect()
+                            await client.connect(declare_queue=False)
                     else:
-                        # 发送端明确设置不自动创建队列
+                        # 移除is_sender参数传递
                         client = await cls.setup_rabbitmq(
                             cls.config,
                             client_name=normalized_name,
@@ -195,12 +250,12 @@ class RabbitMQService:
                             auto_delete=sender_config.auto_delete,
                             auto_parse_json=sender_config.auto_parse_json,
                             queue_name=sender_config.queue_name,
-                            create_if_not_exists=False  # 发送端不自动创建队列
+                            create_if_not_exists=False  # 仅通过此参数控制
                         )
 
                     if normalized_name not in cls.clients:
                         cls.clients[normalized_name] = client
-                        logging.info(f"客户端 '{normalized_name}' 已添加到客户端列表")
+                        logging.info(f"发送客户端 '{normalized_name}' 已添加")
 
                     if normalized_name not in cls.sender_client_names:
                         cls.sender_client_names.append(normalized_name)
@@ -217,8 +272,11 @@ class RabbitMQService:
             raise
 
     @classmethod
-    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig]):
+    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False):
         """设置MQ监听器 - 确保自动创建队列"""
+        # 存在监听器，设置标志
+        cls._has_listeners = True
+
         for listener_config in listeners:
             # 将监听器配置转换为字典并添加到监听器
             # 强制设置create_if_not_exists为True
@@ -337,19 +395,17 @@ class RabbitMQService:
 
     @classmethod
     def get_sender(cls, client_name: Optional[str] = None) -> Optional[RabbitMQClient]:
-        """获取发送客户端（仅返回已注册的客户端，移除模糊匹配）"""
+        """获取发送客户端（仅返回已注册的客户端）"""
         if not client_name:
             logging.warning("发送器名称不能为空")
             return None
 
-        # 仅精确匹配已注册的客户端，不做模糊匹配
+        # 仅精确匹配已注册的客户端
         if client_name in cls.clients:
             return cls.clients[client_name]
 
-        # 不允许通过拼接app-name反向查找（避免绕过注册）
         app_name = cls.config.get("APP_NAME", "") if cls.config else ""
         if app_name and not client_name.endswith(f".{app_name}"):
-            # 不尝试拼接app-name查找，确保只有注册的名称可被找到
             return None
 
         logging.debug(f"发送器 '{client_name}' 不在已注册客户端列表中")
@@ -359,7 +415,7 @@ class RabbitMQService:
     async def send_message(
         cls,
         data: Union[BaseModel, str, Dict[str, Any], None],
-        queue_name: Optional[str] = None, ** kwargs
+        queue_name: Optional[str] = None, **kwargs
     ) -> None:
         """发送消息到RabbitMQ"""
         sender = cls.get_sender(queue_name)
@@ -472,5 +528,6 @@ class RabbitMQService:
         cls.clients.clear()
         cls.sender_client_names.clear()
         cls._init_lock.clear()
+        cls._has_listeners = False  # 重置标志
 
         logging.info("RabbitMQ服务已完全关闭")