jettask 0.2.20__py3-none-any.whl → 0.2.24__py3-none-any.whl

jettask/persistence/manager.py

@@ -0,0 +1,304 @@
+"""
+统一的 PostgreSQL 消费者管理器
+自动识别单命名空间和多命名空间模式
+"""
+import asyncio
+import logging
+import multiprocessing
+from typing import Dict, Optional, Set
+from jettask.core.unified_manager_base import UnifiedManagerBase
+from jettask.core.namespace import NamespaceDataAccessManager
+from jettask.persistence.consumer import PostgreSQLConsumer
+
+logger = logging.getLogger(__name__)
+
+
+class UnifiedConsumerManager(UnifiedManagerBase):
+    """
+    统一的消费者管理器
+    继承自 UnifiedManagerBase，实现消费者特定的逻辑
+    """
+
+    def __init__(self,
+                 task_center_url: str,
+                 check_interval: int = 30,
+                 backlog_monitor_interval: int = 30,
+                 concurrency: int = 4,
+                 debug: bool = False):
+        """
+        初始化消费者管理器
+
+        Args:
+            task_center_url: 任务中心URL
+            check_interval: 命名空间检测间隔（秒）
+            backlog_monitor_interval: 积压监控间隔（秒）
+            concurrency: 并发数（每个命名空间的 worker 进程数）
+            debug: 是否启用调试模式
+        """
+        super().__init__(task_center_url, check_interval, debug)
+
+        self.backlog_monitor_interval = backlog_monitor_interval
+        self.concurrency = concurrency
+
+        # 消费者管理
+        self.consumer_instance: Optional[PostgreSQLConsumer] = None  # 单命名空间模式
+        self.consumer_processes: Dict[str, multiprocessing.Process] = {}  # 多命名空间模式
+        self.known_namespaces: Set[str] = set()
+
+        # 命名空间数据访问管理器
+        self.namespace_manager: Optional[NamespaceDataAccessManager] = None
+
+    async def run_single_namespace(self, namespace_name: str):
+        """
+        运行单命名空间模式
+
+        Args:
+            namespace_name: 命名空间名称
+        """
+        logger.info(f"启动单命名空间消费者: {namespace_name}")
+        logger.info(f"积压监控间隔: {self.backlog_monitor_interval}秒")
+
+        try:
+            # 创建命名空间数据访问管理器
+            base_url = self.get_base_url()
+            self.namespace_manager = NamespaceDataAccessManager(task_center_base_url=base_url)
+
+            # 获取命名空间连接
+            conn = await self.namespace_manager.get_connection(namespace_name)
+
+            # 检查是否配置了 PostgreSQL
+            if not conn.pg_config:
+                logger.error(f"命名空间 {namespace_name} 未配置 PostgreSQL，无法启动消费者")
+                return
+
+            logger.info(f"命名空间 {namespace_name} 配置:")
+            logger.info(f"  - Redis: {'已配置' if conn.redis_config else '未配置'}")
+            logger.info(f"  - PostgreSQL: 已配置")
+            logger.info(f"  - Redis Prefix: {conn.redis_prefix}")
+
+            # 创建并启动消费者
+            self.consumer_instance = PostgreSQLConsumer(
+                pg_config=conn.pg_config,
+                redis_config=conn.redis_config,
+                prefix=conn.redis_prefix,
+                namespace_name=namespace_name
+            )
+
+            logger.info(f"✓ 消费者已启动: {namespace_name}")
+
+            # 运行消费者
+            await self.consumer_instance.start(concurrency=self.concurrency)
+
+        except Exception as e:
+            logger.error(f"单命名空间消费者运行失败: {e}", exc_info=self.debug)
+            raise
+        finally:
+            # 清理
+            if self.consumer_instance:
+                await self.consumer_instance.stop()
+                logger.info(f"消费者已停止: {namespace_name}")
+
+            if self.namespace_manager:
+                await self.namespace_manager.close_all()
+
+    async def run_multi_namespace(self, namespace_names: Optional[Set[str]]):
+        """
+        运行多命名空间模式
+
+        Args:
+            namespace_names: 目标命名空间集合，None表示所有命名空间
+        """
+        logger.info("启动多命名空间消费者管理")
+        logger.info(f"命名空间检测间隔: {self.check_interval}秒")
+        logger.info(f"积压监控间隔: {self.backlog_monitor_interval}秒")
+
+        # 创建命名空间数据访问管理器
+        base_url = self.get_base_url()
+        self.namespace_manager = NamespaceDataAccessManager(task_center_base_url=base_url)
+
+        # 获取初始命名空间
+        namespaces = await self.fetch_namespaces_info(namespace_names)
+
+        # 启动每个命名空间的消费者进程
+        for ns_info in namespaces:
+            self._start_consumer_process(ns_info['name'])
+            self.known_namespaces.add(ns_info['name'])
+
+        # 创建并发任务
+        try:
+            health_check_task = asyncio.create_task(self._health_check_loop())
+            namespace_check_task = asyncio.create_task(self._namespace_check_loop())
+
+            # 等待任一任务完成或出错
+            _, pending = await asyncio.wait(
+                [health_check_task, namespace_check_task],
+                return_when=asyncio.FIRST_EXCEPTION
+            )
+
+            # 取消所有未完成的任务
+            for task in pending:
+                task.cancel()
+
+        except asyncio.CancelledError:
+            logger.info("收到取消信号")
+        finally:
+            # 清理
+            if self.namespace_manager:
+                await self.namespace_manager.close_all()
+
+    def _start_consumer_process(self, namespace_name: str):
+        """启动单个命名空间的消费者进程"""
+
+        # 如果进程已存在且存活，跳过
+        if namespace_name in self.consumer_processes:
+            process = self.consumer_processes[namespace_name]
+            if process.is_alive():
+                logger.debug(f"命名空间 {namespace_name} 的消费者进程已在运行")
+                return
+            else:
+                # 清理已停止的进程
+                process.terminate()
+                process.join(timeout=5)
+
+        # 创建新进程
+        logger.info(f"启动命名空间 {namespace_name} 的消费者进程")
+
+        process = multiprocessing.Process(
+            target=_run_consumer_in_process,
+            args=(self.task_center_url, namespace_name, self.backlog_monitor_interval, self.concurrency, self.debug),
+            name=f"Consumer-{namespace_name}"
+        )
+        process.start()
+        self.consumer_processes[namespace_name] = process
+
+        logger.info(f"✓ 消费者进程已启动: {namespace_name} (PID: {process.pid})")
+
+    async def _health_check_loop(self):
+        """健康检查循环 - 检查消费者进程状态"""
+        logger.info("健康检查循环已启动")
+
+        while True:
+            try:
+                # 检查所有消费者进程
+                dead_processes = []
+                for ns_name, process in self.consumer_processes.items():
+                    if not process.is_alive():
+                        logger.warning(f"消费者进程 {ns_name} 已停止 (退出码: {process.exitcode})")
+                        dead_processes.append(ns_name)
+
+                # 重启已停止的进程
+                for ns_name in dead_processes:
+                    logger.info(f"重启消费者进程: {ns_name}")
+                    self._start_consumer_process(ns_name)
+
+                # 等待下一次检查
+                await asyncio.sleep(self.check_interval)
+
+            except Exception as e:
+                logger.error(f"健康检查循环异常: {e}", exc_info=self.debug)
+                await asyncio.sleep(10)
+
+    async def _namespace_check_loop(self):
+        """命名空间检查循环 - 检测新的命名空间"""
+        logger.info("命名空间检查循环已启动")
+
+        while True:
+            try:
+                # 获取当前所有命名空间
+                namespaces = await self.fetch_namespaces_info(None)
+                current_namespaces = {ns['name'] for ns in namespaces}
+
+                # 发现新命名空间
+                new_namespaces = current_namespaces - self.known_namespaces
+                if new_namespaces:
+                    logger.info(f"发现新命名空间: {new_namespaces}")
+                    for ns_name in new_namespaces:
+                        self._start_consumer_process(ns_name)
+                        self.known_namespaces.add(ns_name)
+
+                # 停止已删除的命名空间消费者
+                removed_namespaces = self.known_namespaces - current_namespaces
+                if removed_namespaces:
+                    logger.info(f"命名空间已删除: {removed_namespaces}")
+                    for ns_name in removed_namespaces:
+                        if ns_name in self.consumer_processes:
+                            process = self.consumer_processes[ns_name]
+                            logger.info(f"停止消费者进程: {ns_name}")
+                            process.terminate()
+                            process.join(timeout=10)
+                            del self.consumer_processes[ns_name]
+                        self.known_namespaces.remove(ns_name)
+
+                # 等待下一次检查
+                await asyncio.sleep(self.check_interval)
+
+            except Exception as e:
+                logger.error(f"命名空间检查循环异常: {e}", exc_info=self.debug)
+                await asyncio.sleep(10)
+
+    async def run(self):
+        """
+        运行管理器（自动判断单/多命名空间模式）
+        """
+        try:
+            self.running = True
+
+            if self.is_single_namespace:
+                # 单命名空间模式
+                await self.run_single_namespace(self.namespace_name)
+            else:
+                # 多命名空间模式
+                target_namespaces = self.get_target_namespaces()
+                await self.run_multi_namespace(target_namespaces)
+
+        except KeyboardInterrupt:
+            logger.info("收到中断信号，停止所有消费者...")
+        finally:
+            self.running = False
+
+            # 停止所有消费者进程
+            for ns_name, process in list(self.consumer_processes.items()):
+                logger.info(f"停止消费者进程: {ns_name}")
+                process.terminate()
+                process.join(timeout=10)
+
+            logger.info("所有消费者已停止")
+
+
+def _run_consumer_in_process(task_center_url: str, namespace_name: str,
+                             backlog_monitor_interval: int, concurrency: int, debug: bool):
+    """
+    在独立进程中运行消费者（复用 run_single_namespace 逻辑）
+
+    Args:
+        task_center_url: 任务中心URL
+        namespace_name: 命名空间名称
+        backlog_monitor_interval: 积压监控间隔
+        concurrency: 并发数
+        debug: 是否启用调试模式
+    """
+    import logging
+
+    # 配置日志
+    log_level = logging.DEBUG if debug else logging.INFO
+    logging.basicConfig(
+        level=log_level,
+        format=f'%(asctime)s - [{namespace_name}] - %(name)s - %(levelname)s - %(message)s'
+    )
+
+    # 创建临时管理器实例并运行单命名空间
+    manager = UnifiedConsumerManager(
+        task_center_url=task_center_url,
+        backlog_monitor_interval=backlog_monitor_interval,
+        concurrency=concurrency,
+        debug=debug
+    )
+
+    # 运行异步任务
+    try:
+        asyncio.run(manager.run_single_namespace(namespace_name))
+    except KeyboardInterrupt:
+        logging.getLogger(__name__).info("进程收到中断信号")
+
+
+__all__ = ['UnifiedConsumerManager']

jettask/persistence/persistence.py

@@ -0,0 +1,391 @@
+"""任务持久化模块
+
+负责解析Redis Stream消息，并将任务数据批量插入PostgreSQL数据库。
+"""
+
+import json
+import logging
+import traceback
+from typing import Dict, List, Optional, Any
+from datetime import datetime, timezone
+
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.dialects.postgresql import insert
+
+from jettask.db.models.task import Task
+
+logger = logging.getLogger(__name__)
+
+
+class TaskPersistence:
+    """任务持久化处理器
+
+    职责：
+    - 解析Stream消息为任务信息
+    - 批量插入任务到PostgreSQL的tasks表
+    - 处理插入失败的降级策略
+    """
+
+    def __init__(
+        self,
+        async_session_local: sessionmaker,
+        namespace_id: str,
+        namespace_name: str
+    ):
+        """初始化任务持久化处理器
+
+        Args:
+            async_session_local: SQLAlchemy会话工厂
+            namespace_id: 命名空间ID
+            namespace_name: 命名空间名称
+        """
+        self.AsyncSessionLocal = async_session_local
+        self.namespace_id = namespace_id
+        self.namespace_name = namespace_name
+
+    def parse_stream_message(self, task_id: str, data: dict) -> Optional[dict]:
+        """解析Stream消息为任务信息（返回完整的字段）
+
+        Args:
+            task_id: 任务ID（Redis Stream ID）
+            data: 消息数据
+
+        Returns:
+            解析后的任务信息字典，失败返回None
+        """
+        try:
+            from jettask.utils.serializer import loads_str
+
+            if b'data' in data:
+                task_data = loads_str(data[b'data'])
+            else:
+                task_data = {}
+                for k, v in data.items():
+                    key = k.decode('utf-8') if isinstance(k, bytes) else k
+                    if isinstance(v, bytes):
+                        try:
+                            value = loads_str(v)
+                        except:
+                            value = str(v)
+                    else:
+                        value = v
+                    task_data[key] = value
+
+            # 如果配置了命名空间，检查消息是否属于该命名空间
+            # if self.namespace_id:
+            #     msg_namespace_id = task_data.get('__namespace_id')
+            #     # 如果消息没有namespace_id且当前不是默认命名空间，跳过
+            #     if msg_namespace_id != self.namespace_id:
+            #         if not (msg_namespace_id is None and self.namespace_id == 'default'):
+            #             logger.debug(f"Skipping message from different namespace: {msg_namespace_id} != {self.namespace_id}")
+            #             return None
+
+            queue_name = task_data['queue']
+            task_name = task_data.get('name', task_data.get('task', 'unknown'))
+
+            created_at = None
+            if 'trigger_time' in task_data:
+                try:
+                    timestamp = float(task_data['trigger_time'])
+                    created_at = datetime.fromtimestamp(timestamp, tz=timezone.utc)
+                except:
+                    pass
+
+            # 返回完整的字段，包括所有可能为None的字段
+            return {
+                'id': task_id,
+                'queue_name': queue_name,
+                'task_name': task_name,
+                'task_data': json.dumps(task_data),
+                'priority': int(task_data.get('priority', 0)),
+                'retry_count': int(task_data.get('retry', 0)),
+                'max_retry': int(task_data.get('max_retry', 3)),
+                'status': 'pending',
+                'result': None,  # 新任务没有结果
+                'error_message': None,  # 新任务没有错误信息
+                'created_at': created_at,
+                'started_at': None,  # 新任务还未开始
+                'completed_at': None,  # 新任务还未完成
+                'scheduled_task_id': task_data.get('scheduled_task_id'),  # 调度任务ID
+                'metadata': json.dumps(task_data.get('metadata', {})),
+                'worker_id': None,  # 新任务还未分配worker
+                'execution_time': None,  # 新任务还没有执行时间
+                'duration': None,  # 新任务还没有持续时间
+                'namespace_id': self.namespace_id  # 添加命名空间ID
+            }
+
+        except Exception as e:
+            logger.error(f"Error parsing stream message for task {task_id}: {e}")
+            logger.error(traceback.format_exc())
+            return None
+
+    async def insert_tasks(self, tasks: List[Dict[str, Any]]) -> int:
+        """批量插入任务到PostgreSQL（使用ORM）
+
+        Args:
+            tasks: 任务信息列表
+
+        Returns:
+            实际插入的记录数
+        """
+        if not tasks:
+            return 0
+
+        logger.info(f"Attempting to insert {len(tasks)} tasks to tasks table")
+
+        try:
+            async with self.AsyncSessionLocal() as session:
+                # 准备tasks表的数据
+                tasks_data = []
+                for task in tasks:
+                    task_data = json.loads(task['task_data'])
+
+                    # 从task_data中获取scheduled_task_id
+                    scheduled_task_id = task_data.get('scheduled_task_id') or task.get('scheduled_task_id')
+
+                    # 根据是否有scheduled_task_id来判断任务来源
+                    if scheduled_task_id:
+                        source = 'scheduler'  # 定时任务
+                    else:
+                        source = 'redis_stream'  # 普通任务
+
+                    tasks_data.append({
+                        'stream_id': task['id'],  # Redis Stream ID作为stream_id
+                        'queue': task['queue_name'],
+                        'namespace': self.namespace_name,
+                        'scheduled_task_id': str(scheduled_task_id) if scheduled_task_id else None,
+                        'payload': json.loads(task['task_data']),  # 解析为dict
+                        'priority': task['priority'],
+                        'created_at': task['created_at'],
+                        'source': source,
+                        'task_metadata': json.loads(task.get('metadata', '{}'))  # 对应模型的 task_metadata 字段
+                    })
+
+                # 批量插入 - 使用 ORM 的 INSERT ON CONFLICT DO NOTHING
+                logger.debug(f"Executing batch insert with {len(tasks_data)} tasks")
+
+                try:
+                    # 使用 PostgreSQL 的 insert().on_conflict_do_nothing()
+                    stmt = insert(Task).values(tasks_data).on_conflict_do_nothing(
+                        constraint='tasks_pkey'  # 主键冲突则跳过
+                    )
+
+                    await session.execute(stmt)
+                    await session.commit()
+
+                    # ORM 的 on_conflict_do_nothing 不返回 rowcount，我们假设全部成功
+                    inserted_count = len(tasks_data)
+                    logger.debug(f"Tasks table batch insert transaction completed: {inserted_count} tasks")
+                    return inserted_count
+
+                except Exception as e:
+                    logger.error(f"Error in batch insert, trying fallback: {e}")
+                    await session.rollback()
+
+                    # 降级为逐条插入（更稳妥）
+                    total_inserted = 0
+
+                    for task_dict in tasks_data:
+                        try:
+                            stmt = insert(Task).values(**task_dict).on_conflict_do_nothing(
+                                constraint='tasks_pkey'
+                            )
+                            await session.execute(stmt)
+                            await session.commit()
+                            total_inserted += 1
+                        except Exception as single_error:
+                            logger.error(f"Failed to insert task {task_dict.get('stream_id')}: {single_error}")
+                            await session.rollback()
+
+                    if total_inserted > 0:
+                        logger.info(f"Fallback insert completed: {total_inserted} tasks inserted")
+                    else:
+                        logger.info(f"No new tasks inserted in fallback mode")
+
+                    return total_inserted
+
+        except Exception as e:
+            logger.error(f"Error inserting tasks to PostgreSQL: {e}")
+            logger.error(traceback.format_exc())
+            return 0
+
+    async def batch_insert_tasks(self, tasks: List[Dict[str, Any]]) -> int:
+        """批量插入任务（兼容 buffer.py 调用接口）
+
+        Args:
+            tasks: 任务记录列表
+
+        Returns:
+            实际插入的记录数
+        """
+        if not tasks:
+            return 0
+
+        logger.info(f"[BATCH INSERT] 批量插入 {len(tasks)} 条任务...")
+
+        try:
+            async with self.AsyncSessionLocal() as session:
+                # 准备 ORM 数据
+                insert_data = []
+                for record in tasks:
+                    # record 是从 consumer.py 传入的格式
+                    insert_data.append({
+                        'stream_id': record['stream_id'],
+                        'queue': record['queue'],
+                        'namespace': record['namespace'],
+                        'scheduled_task_id': record.get('scheduled_task_id'),
+                        'payload': record.get('payload', {}),
+                        'priority': record.get('priority', 0),
+                        'created_at': record.get('created_at'),
+                        'source': record.get('source', 'redis_stream'),
+                        'task_metadata': record.get('metadata', {})
+                    })
+
+                # 批量插入 - 使用 PostgreSQL 的 INSERT ON CONFLICT DO NOTHING
+                # 使用约束名称而不是列名
+                stmt = insert(Task).values(insert_data).on_conflict_do_nothing(
+                    constraint='tasks_pkey'
+                )
+
+                await session.execute(stmt)
+                await session.commit()
+
+                logger.info(f"[BATCH INSERT] ✓ 成功插入 {len(insert_data)} 条任务")
+                return len(insert_data)
+
+        except Exception as e:
+            logger.error(f"[BATCH INSERT] ✗ 批量插入失败: {e}", exc_info=True)
+            return 0
+
+    async def batch_update_tasks(self, updates: List[Dict[str, Any]]) -> int:
+        """批量更新任务执行状态到 task_runs 表
+
+        使用 PostgreSQL 的 INSERT ... ON CONFLICT DO UPDATE 实现 UPSERT 操作，
+        如果记录存在则更新，不存在则插入。
+
+        Args:
+            updates: 更新记录列表，每条记录包含：
+                - stream_id: Redis Stream ID（主键）
+                - status: 任务状态
+                - result: 执行结果
+                - error: 错误信息
+                - started_at: 开始时间
+                - completed_at: 完成时间
+                - retries: 重试次数
+
+        Returns:
+            实际更新的记录数
+        """
+        if not updates:
+            return 0
+
+        logger.info(f"[BATCH UPDATE] 批量更新 {len(updates)} 条任务状态...")
+        logger.info(f"[BATCH UPDATE] 更新记录示例: {updates[0] if updates else 'N/A'}")
+
+        try:
+            from sqlalchemy.dialects.postgresql import insert
+            from ..db.models import TaskRun
+            from ..utils.serializer import loads_str
+            from datetime import datetime, timezone
+
+            # 对相同 stream_id 的记录进行去重，保留最新的
+            # 使用字典，key 是 stream_id，value 是记录（后面的会覆盖前面的）
+            deduplicated = {}
+            for record in updates:
+                stream_id = record['stream_id']
+                deduplicated[stream_id] = record
+
+            # 转换回列表
+            unique_updates = list(deduplicated.values())
+
+            if len(unique_updates) < len(updates):
+                logger.info(
+                    f"[BATCH UPDATE] 去重: {len(updates)} 条 → {len(unique_updates)} 条 "
+                    f"(合并了 {len(updates) - len(unique_updates)} 条重复记录)"
+                )
+
+            async with self.AsyncSessionLocal() as session:
+                # 准备 UPSERT 数据
+                upsert_data = []
+                for record in unique_updates:
+                    logger.debug(f"处理记录: {record}")
+                    # 解析 result 字段（如果是序列化的字符串）
+                    result = record.get('result')
+                    if result and isinstance(result, bytes):
+                        try:
+                            result = loads_str(result)
+                        except Exception:
+                            result = result.decode('utf-8') if isinstance(result, bytes) else result
+
+                    # 解析 error 字段
+                    error = record.get('error')
+                    if error and isinstance(error, bytes):
+                        error = error.decode('utf-8')
+
+                    # 计算执行时长
+                    duration = None
+                    started_at = record.get('started_at')
+                    completed_at = record.get('completed_at')
+                    if started_at and completed_at:
+                        duration = completed_at - started_at
+
+                    # 解析 status 字段
+                    status = record.get('status')
+                    if status and isinstance(status, bytes):
+                        status = status.decode('utf-8')
+
+                    # 解析 consumer 字段
+                    consumer = record.get('consumer')
+                    if consumer and isinstance(consumer, bytes):
+                        consumer = consumer.decode('utf-8')
+
+                    upsert_record = {
+                        'stream_id': record['stream_id'],
+                        'status': status,
+                        'result': result,
+                        'error': error,
+                        'started_at': started_at,
+                        'completed_at': completed_at,
+                        'retries': record.get('retries', 0),
+                        'duration': duration,
+                        'consumer': consumer,
+                        'updated_at': datetime.now(timezone.utc),
+                    }
+                    logger.debug(f"upsert_record: {upsert_record}")
+                    upsert_data.append(upsert_record)
+
+                logger.info(f"[BATCH UPDATE] 准备写入 {len(upsert_data)} 条记录")
+
+                # 批量 UPSERT - 如果存在则更新，不存在则插入
+                stmt = insert(TaskRun).values(upsert_data)
+
+                # 定义冲突时的更新策略
+                # 使用 COALESCE 避免用 NULL 覆盖已有数据
+                from sqlalchemy import func
+                stmt = stmt.on_conflict_do_update(
+                    constraint='task_runs_pkey',
+                    set_={
+                        # status 总是更新（状态变化）
+                        'status': stmt.excluded.status,
+                        # 其他字段：如果新值不是 NULL，则更新；否则保留旧值
+                        'result': func.coalesce(stmt.excluded.result, TaskRun.result),
+                        'error': func.coalesce(stmt.excluded.error, TaskRun.error),
+                        'started_at': func.coalesce(stmt.excluded.started_at, TaskRun.started_at),
+                        'completed_at': func.coalesce(stmt.excluded.completed_at, TaskRun.completed_at),
+                        'retries': func.coalesce(stmt.excluded.retries, TaskRun.retries),
+                        'duration': func.coalesce(stmt.excluded.duration, TaskRun.duration),
+                        'consumer': func.coalesce(stmt.excluded.consumer, TaskRun.consumer),
+                        # updated_at 总是更新
+                        'updated_at': stmt.excluded.updated_at,
+                    }
+                )
+
+                await session.execute(stmt)
+                await session.commit()
+
+                logger.info(f"[BATCH UPDATE] ✓ 成功更新 {len(upsert_data)} 条任务状态")
+                return len(upsert_data)
+
+        except Exception as e:
+            logger.error(f"[BATCH UPDATE] ✗ 批量更新失败: {e}", exc_info=True)
+            return 0