astrbot_plugin_imagestudio/审计/findings/A1-生成与队列.md

29 KiB

A1 · 生成流水线 / 任务队列 / 重试 / 并发

审计范围(实际通读的源文件):

  • backend/services/generation_service.py
  • backend/services/queue_service.py
  • backend/services/worker_service.py
  • backend/services/generation_job_retry_service.py
  • backend/services/workflow_round_service.py
  • backend/services/workflow_round_worker_runtime.py
  • backend/services/cost_guard_service.py、backend/services/cost_service.py
  • backend/services/chat_workflow_service.py(并发相关片段)
  • backend/routes/node_routes.py、backend/routes/job_routes.py
  • core/queue_manager.py、core/fsm.py、core/event_bus.py
  • database/repositories/job_repository.py、database/db_helper.py(连接部分)
  • engines/single_flow.py、engines/image_provider.py(超时部分)
  • main.py(插件生命周期 / asyncio 调度部分)

摘要

队列的 状态机 + CAS(compare-and-set)设计整体是认真的:update_if_status / update_if_status_unless_workflow_cancelled / delete_if_status 都做了单条 SQL 内的条件更新,cancel_job 也有重读循环,这一层没有明显的丢更新。真正的问题集中在 队列语义之外:

  1. QueueService.update_task() 是无条件 UPDATE,而 worker 的成功路径和失败路径全都走它,导致"并发取消被覆盖"的竞态真实存在(P1)。
  2. QueueWorker._claim_next 依赖 JobRepository.list(... ORDER BY created_at DESC),队列实际是 LIFO,积压超过 claim_batch_size 后老任务永久饿死(P1)。
  3. 插件 terminate() 无法保证 worker 线程退出(provider 调用最长 3600s,join 超时 5s),重载后新旧两套 worker 池同时抢同一批任务(P1)。
  4. 详细工作流轮次候选任务 task_type="workflow_round_candidate" 被 GenerationJobRetryService._validate_executable 硬拒,而 worker 侧 RetryPolicy(max_attempts=1) 又等于关闭重试——异步候选一次网络抖动就是终态失败,无任何重试通道(P1)。
  5. 同步生成路径(generate_node)在 asyncio 默认线程池里长时间阻塞、无并发上限、无背压;recover_stale_tasks 只在 worker 启动时跑且只认 source=workflow_round,nodes.generate 崩溃残留永远卡在 running。

发现

[P1-严重] QueueService.update_task() 无 CAS,worker 完成写入会覆盖并发取消

  • 位置:backend/services/queue_service.py:406、database/repositories/job_repository.py:206、backend/services/worker_service.py:116

  • 问题:update_task 只做「读 → 校验迁移 → 无条件 UPDATE」,底层 JobRepository.update 的 WHERE 子句只有 task_id,没有任何状态谓词。而 QueueWorker.run_once 的成功路径、_handle_failure 的失败/重排队路径全部调用它。仓库里明明已有 update_task_if_status / update_if_status 这套 CAS 原语,worker 却没有使用。

  • 代码:

    # queue_service.py:406
    def update_task(self, task_id: str, payload: dict[str, Any], ctx: RequestContext) -> GenerationTask:
        before = self.get_job(task_id)                 # ← 读
        status = payload.get("status")
        if status is not None:
            self._validate_task_status_transition(before.status, str(status))
        after = self.repository.update(task_id, payload)   # ← 无条件写,before.status 没进 WHERE
    
    # job_repository.py:215
    conn.execute(
        f"""
        UPDATE generation_tasks
        SET {", ".join(assignments)}
        WHERE task_id = {placeholder}      # ← 只有 task_id
        """,
    
    # worker_service.py:106-134
    latest = self.queue_service.get_job(task.task_id)
    if latest.status == "cancelled":       # ← 检查点
        ...
    completed = self.queue_service.update_task(   # ← 写入点,两点之间可被取消
        task.task_id, {"status": update.status, ...}, ctx)
    
  • 影响:用户点"取消",worker 恰好在此刻出图完成:取消在 update_task 的 get_job 之后、UPDATE 之前提交,则 cancelled 被直接改写为 succeeded(或 _handle_failure 里改写为 failed / queued)。取消语义失效,已取消的轮次会重新变成"运行中",cancel_workflow_jobs 也可能被同样方式回滚。计费与图片记录随之产生(用户已明确取消却仍被扣费)。

  • 修复建议:worker 的三处写入全部换成 CAS。run_once 成功路径改为 update_task_if_status(task_id, {"running"}, payload, ctx, require_workflow_not_cancelled=True),返回 None 时按"任务已被他人接管"处理(清理已生成产物并返回 cancelled 结果);_handle_failure 的 failed 写入用 {"running"} 作为期望态、重排队写入用 {"failed"} 作为期望态。长期建议把 QueueService.update_task 标记为内部/管理用途,禁止 worker 调用。


[P1-严重] 队列是 LIFO:ORDER BY created_at DESC + 固定 batch 导致老任务永久饿死

  • 位置:database/repositories/job_repository.py:150、backend/services/worker_service.py:208

  • 问题:worker 认领任务时复用了通用列表接口 list_jobs(status="queued", page=1, page_size=claim_batch_size),而该接口为了给前端做"最新在前"用的是 ORDER BY created_at DESC。于是队列变成后进先出,且每次只看最新的 claim_batch_size(round pool 为 25)条。

  • 代码:

    # job_repository.py:145-154
    rows = conn.execute(
        f"""
        SELECT {TASK_COLUMNS}
        FROM generation_tasks
        {where_clause}
        ORDER BY created_at DESC          # ← 队列消费用了倒序
        LIMIT {placeholder} OFFSET {placeholder}
        """,
    
    # worker_service.py:207-221
    def _claim_next(self, ctx: RequestContext) -> GenerationTask | None:
        queued = self.queue_service.list_jobs(status="queued", page=1, page_size=self.claim_batch_size).items
        for candidate in queued:
            if _retry_deferred(candidate):
                continue
    
  • 影响:只要待处理队列长度稳定 > 25,最早入队的候选永远排不到(新任务不断插到窗口顶端)。用户表现为"某个轮次一直卡在 queued,后创建的轮次却先出图"。另外 _retry_deferred 被延迟的任务也会白占这 25 个名额,进一步缩小可认领窗口。SQLite 的 created_at 是 CURRENT_TIMESTAMP(秒级),同一秒创建的 4~8 个候选顺序还完全不确定。

  • 修复建议:给 JobRepository 增加专用的认领查询,ORDER BY created_at ASC, task_id ASC(FIFO + 稳定次序),并让 _claim_next 调用它而不是复用展示用的 list;同时把 created_at 的精度提升到毫秒(或增加自增 seq 列)以消除同秒歧义。


[P1-严重] 插件重载后旧 worker 线程仍存活,与新 worker 池并发抢占同一队列

  • 位置:backend/services/worker_service.py:180、backend/services/worker_service.py:428、backend/services/workflow_round_worker_runtime.py:67、main.py:434

  • 问题:QueueWorker.stop() 只是 set() 停止事件后 join(timeout=5s)。停止事件仅在 _run_loop 的循环顶部被检查,而 run_once 内部会阻塞在 provider HTTP 调用上(engines/image_provider.py 允许 10~3600 秒)。join 超时后 stop() 直接返回 running: True,而 Main.terminate() 无视这个返回值把 runtime 置 None。

  • 代码:

    # worker_service.py:180-185
    def stop(self, *, timeout_seconds: float = 5.0) -> dict[str, Any]:
        self._stop_event.set()
        thread = self._thread
        if thread is not None:
            thread.join(timeout=max(float(timeout_seconds), 0.1))
        return {"worker_id": self.worker_id, "running": self.is_running()}   # ← 可能是 True
    
    # main.py:434-441
    async def terminate(self) -> None:
        ...
        if self.round_worker_runtime is not None:
            self.round_worker_result = self.round_worker_runtime.stop()
            self.round_worker_runtime = None      # ← 不管 running 是否为 True 都丢弃
    
  • 影响:AstrBot 热重载/插件重启时,旧的 5 个 daemon 线程仍在跑(进程没退出),新的 create_workflow_round_worker_runtime() 又起 5 个。两批 worker 共享同一张 generation_tasks 表:CAS 能防止同一条任务被同时认领,但旧线程完成时会用 P1-1 描述的无条件 update_task 写回结果,而新进程的 recover_stale_tasks() 又会把超过 300 秒仍在 running 的任务(可能正被旧线程执行)标记 failed 后重新入队 → 同一候选被生成两次,重复计费、重复落图。worker 数量还会随着每次重载线性膨胀。

  • 修复建议:

    1. QueueWorker.stop() 在 join 超时后返回明确的 stopped: False,QueueWorkerPool.stop() 聚合该标志;
    2. Main.terminate() 在 stopped=False 时不要丢弃 runtime,而是保留引用并拒绝再次 start(),或将 stop 超时提升到略大于 provider 超时;
    3. 给每个 worker 分配 worker_uuid(进程级唯一),update_task 时用 metadata.worker.worker_id 作为 CAS 条件之一,旧进程的写入直接被拒绝;
    4. recover_stale_tasks 增加"当前进程 worker 心跳"判断,避免抢走仍在执行的任务。

[P1-严重] 轮次候选任务无任何重试路径:worker 侧 max_attempts=1,Web 侧 task_type 被硬拒

  • 位置:backend/services/workflow_round_worker_runtime.py:45、backend/services/generation_job_retry_service.py:180、backend/services/generation_service.py:361

  • 问题:两条重试通道同时被关死。

    • worker 侧:round pool 显式传 RetryPolicy(max_attempts=1),而 should_retry 的判定是 if attempt >= max(int(self.max_attempts), 1): return False。首次执行 attempt 已经是 1(claim_queued_task 先自增 worker_attempt),所以永远返回 False。
    • Web 侧:候选任务的 task_type 是 "workflow_round_candidate",而重试服务只接受 "generation"。
  • 代码:

    # workflow_round_worker_runtime.py:39-49
    self.pool = QueueWorkerPool(
        self.queue_service, self._execute,
        retry_policy=RetryPolicy(max_attempts=1),   # ← 等于关闭重试
        task_filter=_is_workflow_round_task, ...)
    
    # generation_service.py:356-364
    return self.queue_service.create_task({
        ...
        "task_type": "workflow_round_candidate",    # ← 非 "generation"
    
    # generation_job_retry_service.py:180-191
    def _validate_executable(self, task: GenerationTask) -> None:
        if task.task_type != "generation" or not task.node_id or not isinstance(task.request, dict):
            raise ApiError(ErrorCode.TASK_NOT_RETRYABLE,
                           "task has no executable generation request", ...)
    
  • 影响:详细工作流一个候选遇到 429 / 连接重置 / provider 5xx,立即变成终态 failed;/jobs/{id}/retry 返回 TASK_NOT_RETRYABLE;workflow_round_service 里也没有候选级重试接口。用户唯一出路是重建整轮(重新走 prepare_persisted_generation,成功的候选也一起重做),成本与语义都错。顺带地,worker_service.py 的 _retry_deferred/next_retry_at 退避逻辑和 workflow_round_service.py:750 的 status == "queued" → retry_scheduled 分支全部成了死代码。

  • 修复建议:

    1. round pool 改为 RetryPolicy(max_attempts=3, base_delay_seconds=2.0, backoff_multiplier=2.0, retryable_error_types=("ImageProviderError",)),并确认 should_retry 的 attempt 语义(当前 attempt=1 即首次,>= 应改为 > 或把 max_attempts 理解成"总次数"后统一);
    2. GenerationJobRetryService._validate_executable 放开 task_type in {"generation", "workflow_round_candidate"},并为候选类型走 enqueue_prepared_generation 重新入队(而不是 generate_node 同步执行);或在 WorkflowRoundService 上新增 retry_candidate(round_id, candidate_id)。

[P1-严重] 同步生成占满 asyncio 默认线程池,全插件无并发上限与背压

  • 位置:backend/services/generation_service.py:119、main.py:333、backend/services/chat_workflow_service.py:216

  • 问题:nodes/generate(Web 与聊天共用)走的是完全同步的 _generate_node_locked:任务刚 create_task(status="queued") 就立刻 CAS 成 running 并在同一个调用栈里发起 provider 请求,整个过程持有进程内的 per-node RLock。所有 Web/桥接请求又都通过 asyncio.to_thread(dispatch_web_request, ...) 派发到 asyncio 默认线程池(min(32, cpu+4))。没有任何信号量或专用 executor 限制并发生成数量。

  • 代码:

    # generation_service.py:119-126
    def generate_node(self, node_id, payload, ctx) -> dict[str, Any]:
        lock_entry = _retain_node_generation_lock(node_id)
        lock_entry.lock.acquire()
        try:
            return self._generate_node_locked(node_id, payload, ctx)   # ← 内含 provider 阻塞调用
        finally:
            ...
    
    # main.py:333-340
    response = await asyncio.to_thread(          # ← 默认 executor,全插件共用
        dispatch_web_request, ctx, dispatch_method, dispatch_endpoint, ...)
    
    # chat_workflow_service.py:216-220  (已经在一个 to_thread 线程里,再嵌套 4 线程池)
    with ThreadPoolExecutor(max_workers=4, thread_name_prefix="imagestudio-chat-fast") as executor:
        futures = {executor.submit(self.generate_node, str(node["node_id"]), chat): node for node in nodes}
    
  • 影响:单次 provider 调用默认 180 秒、最高允许 3600 秒(engines/image_provider.py:308-313)。十几个并发 nodes/generate 就能把默认 executor 占满,此后所有 ImageStudio Web API(列表、状态轮询、取消)一起挂起——包括用来取消这些生成的接口。快速角色 命令还会为每个聊天用户额外派生 4 个线程池线程且 with 退出时 shutdown(wait=True) 不可中断,N 个用户 = 4N 路并发 provider 请求,成本无上限。

  • 修复建议:

    1. 为生成建立独立的、容量可配的 ThreadPoolExecutor(例如 4~8),dispatch_web_request 继续用默认池,二者隔离;
    2. 在 GenerationService 入口加进程级 threading.BoundedSemaphore(max_concurrent_generations),取不到时快速返回 429 / QUEUE_BUSY 而不是排队阻塞;
    3. chat_workflow_service 的 4 图并发改为复用同一个全局生成池,而不是每次新建。

[P2-中等] _BoundedWorkerHandler 的并发限流在生产配置下完全是空操作,且限流点位于"认领之后"

  • 位置:backend/services/worker_service.py:400、backend/services/worker_service.py:443、backend/services/workflow_round_worker_runtime.py:48

  • 问题:全局信号量容量等于 worker 线程数,per-route 信号量在唯一的生产构造里也等于 worker 线程数(per_route_limit=worker_count)。线程数 == 许可数,acquire() 永远不会阻塞。更根本的是:限流器包在 handler 上,而 run_once 是先 _claim_next() 把任务 CAS 成 running,再调用 handler——一旦真的配置成 per_route_limit < worker_count,被阻塞的线程会拿着已经 running 的任务空等,任务的 updated_at 停滞,最终被 recover_stale_tasks 误判为"上个进程遗留"。

  • 代码:

    # worker_service.py:400-405
    count = min(max(int(worker_count), 1), 16)
    bounded_handler = _BoundedWorkerHandler(
        handler,
        global_limit=count,                                   # ← 等于线程数
        per_route_limit=min(max(int(per_route_limit or count), 1), count),
    )
    
    # worker_service.py:451-459
    def __call__(self, task: GenerationTask) -> ...:
        route_key = _task_route_key(task)
        with self._route_guard:
            route_semaphore = self._route_semaphores.setdefault(route_key, threading.BoundedSemaphore(self.per_route_limit))
        with self.global_semaphore, route_semaphore:          # ← 任务此时已是 running
            return self.handler(task)
    
    # workflow_round_worker_runtime.py:39-49
    per_route_limit=worker_count,     # ← 与 worker_count 相同,限流失效
    
  • 影响:对同一 provider/model 的突发保护形同虚设(本意应是防止把单个模型打爆触发 429)。若日后按注释意图调小 per_route_limit,则立刻引入"已认领任务排队等待信号量"的队头阻塞 + 假性 stale 误判。

  • 修复建议:把限流前移到认领之前——_claim_next 里按 route_key 先 acquire(blocking=False),拿不到就跳过该候选去看下一条(不认领);per_route_limit 默认值改为小于 worker_count 的值(例如 max(1, worker_count // 2))并接入配置。


[P2-中等] recover_stale_tasks 只在 worker 启动时执行,且只认 source=workflow_round,同步生成崩溃后节点永久锁死

  • 位置:backend/services/queue_service.py:439、backend/services/queue_service.py:470、backend/services/workflow_round_worker_runtime.py:55、backend/services/generation_service.py:574

  • 问题:全仓库对 recover_stale_tasks 的唯一调用点是 WorkflowRoundWorkerRuntime.start(),且固定传 source="workflow_round";其它来源的任务被直接 skipped: source_not_managed。而 nodes.generate 创建的任务 metadata.source = "nodes.generate"。

  • 代码:

    # queue_service.py:470-480
    for candidate in candidates:
        task_source = str(candidate.metadata.get("source") or "").strip()
        if source is not None and task_source != source:
            skipped.append({"task_id": candidate.task_id, "status": candidate.status,
                            "reason": "source_not_managed"})
            continue
    
    # generation_service.py:574-585  —— 节点被 running 任务锁住
    active_task = self._active_generation_task(node)
    if node.status in {"queued", "running"} and active_task is not None:
        raise ApiError(ErrorCode.VALIDATION_FAILED, "generation is already in progress for this node", ...)
    
  • 影响:进程在同步生成中途被杀(AstrBot 重启、容器 OOM)后,该任务永远停在 running,节点也停在 running。用户再点生成得到"generation is already in progress",且没有自动恢复——只能手动去 /jobs/{id}/cancel 把任务取消才能解锁节点。另外整个进程生命周期内没有周期性 stale 巡检,运行中挂死的任务只能等下一次插件重载。

  • 修复建议:

    1. 把 source 过滤改成可选白名单,nodes.generate 也纳入恢复(恢复动作改为"标记 failed + 释放节点",因为它没有 worker 可重新执行);
    2. 增加一个后台巡检线程(或复用 worker 循环的 idle 分支)周期性调用 recover_stale_tasks,而不是只在 start() 跑一次;
    3. 恢复时同步修复 workflow_nodes.status / metadata.last_task_id,避免任务恢复了但节点还锁着。

[P2-中等] recover_stale_tasks 无重试次数上限,会跨进程重启无限重排队

  • 位置:backend/services/queue_service.py:481

  • 问题:恢复逻辑只在 metadata 里写一个会被覆盖的 recovery 字典,没有累加计数,也没有"超过 N 次进 dead_letter"的出口。

  • 代码:

    # queue_service.py:481-521
    recovery = {
        "source": "plugin_startup_stale_recovery",
        "observed_at": ...,
        "previous_status": candidate.status,
    }
    failed = self.update_task_if_status(candidate.task_id, {candidate.status},
        {"status": "failed", ..., "metadata": {**candidate.metadata, "recovery": recovery}}, ctx)
    ...
    queued = self.update_task_if_status(failed.task_id, {"failed"},
        {"status": "queued", ..., "metadata": {**failed.metadata,
         "recovery": {**recovery, "status": "requeued"}}}, ctx, require_workflow_not_cancelled=True)
    
  • 影响:某条任务如果稳定地让 worker 卡死(例如 provider 对该 prompt 永远超时、或反序列化时崩线程),每次插件重启都会把它重新入队,形成跨重启的无限重试。既浪费额度,也可能反复拖垮同一个 worker。dead_letter 状态在这条路径上从未被使用。

  • 修复建议:在 metadata 里维护 recovery.attempts(int(previous.get("attempts") or 0) + 1),超过阈值(如 3)时不再 requeue,直接迁移到 dead_letter 并在 error_message 里写明原因;recover_stale_tasks 的返回值中额外报告 dead_lettered 列表供诊断 UI 展示。


[P2-中等] 轮次候选的 timeout_seconds 只写进 metadata,执行时从未被读取

  • 位置:backend/services/generation_service.py:355、backend/services/generation_service.py:373、backend/services/generation_service.py:2305、engines/single_flow.py:163

  • 问题:enqueue_prepared_generation 计算出路由级超时并存进 metadata["timeout_seconds"],但 execute_claimed_generation 构造 runtime_request 时既没有把它回填进请求,single_flow_engine 也只读 request.get("timeout_seconds")。全仓库 grep 显示该 metadata 键没有任何读取点。

  • 代码:

    # generation_service.py:355-373
    timeout_seconds = _round_timeout_seconds(request, prepared.get("route_resolution"))
    return self.queue_service.create_task({
        ...,
        "metadata": {..., "timeout_seconds": timeout_seconds, ...},   # ← 只写不读
    }, ctx)
    
    # single_flow.py:163
    timeout_seconds=_optional_timeout_seconds(request.get("timeout_seconds")),   # ← 读的是 request,不是 metadata
    
  • 影响:轮次准备阶段基于路由 settings.timeout_seconds 算出的超时被静默丢弃,实际生效的是 provider 全局配置(model_provider_runtime.py 的 provider.timeout_seconds or 180)。为长耗时模型单独调大/为快模型调小的意图无效;同时 metadata 上的数字会误导排障(看到 600 实际生效 180)。此外整个 worker 执行路径没有任何 wall-clock 上限,只有 HTTP socket 超时,若 provider 慢速滴数据可以远超预期地占住 worker 线程。

  • 修复建议:execute_claimed_generation 在构造 runtime_request 时加上 runtime_request.setdefault("timeout_seconds", task.metadata.get("timeout_seconds"));并在 QueueWorker.run_once 外层加一个基于该值的整体看门狗(例如在独立线程执行 handler 并 join(timeout),超时后写 failed 并记录 timeout 错因)。


[P2-中等] worker 执行成功但回写失败时,已落库的图片记录被孤立且不清理

  • 位置:backend/services/worker_service.py:104、backend/services/generation_service.py:492

  • 问题:execute_claimed_generation 内部一旦成功就已经通过 image_service.create_image 把图片元数据写进数据库并返回;随后 worker 才调用 update_task 回写任务。若这一步抛异常(任务被并发取消导致状态迁移校验失败、数据库瞬时错误),run_once 的 except Exception 只会走 _handle_failure 把任务标记 failed,不会回收刚创建的图片记录与磁盘文件。

  • 代码:

    # generation_service.py:492-496  —— 成功路径已落库
    created = self.image_service.create_image(image_payload, ctx)
    ...
    # worker_service.py:104-146
    try:
        update = _normalize_update(self.handler(task))     # ← handler 已经建好 image 记录
        ...
        completed = self.queue_service.update_task(...)    # ← 这里抛错
    except Exception as exc:
        return self._handle_failure(task, exc, ctx)        # ← 只改任务状态,不清理图片
    
  • 影响:候选在 UI 上显示"失败"(handle_task_terminal 写入 image_id=None),但图库里多出一张无人引用的图片和磁盘文件,且计费统计(CostService.usage_summary 按 generated_images 行统计)仍会把它计入成本。反复发生会污染图库。

  • 修复建议:把"落库图片"与"回写任务"放进同一个补偿边界:WorkflowRoundWorkerRuntime._execute 捕获回写失败后调用 generation_service._cleanup_generation_outputs;或让 _execute 返回 image_ids 并由 _on_terminal 在 current_task.status == "failed" 且 claimed_task 曾产出图片时执行清理。


[P3-轻微] cancel_job 的重读循环无次数上限与退避

  • 位置:backend/services/queue_service.py:134

  • 问题:while True 在 CAS 失败时无限重试,既无最大轮数也无 sleep。

  • 代码:

    # queue_service.py:135-172
    while True:
        before = self.get_job(task_id)
        ...
        after = self.repository.update_if_status(task_id, {before.status}, {...})
        if after is not None:
            break
        # The task changed after it was read. Re-evaluate ...
    
  • 影响:若某条任务被高频写入(例如 P1-1 描述的 worker 无条件 update_task 与取消互相打架),该循环会变成忙等,持续开关 SQLite 连接并占住调用线程。正常情况下 1~2 轮即可收敛,属低概率但无兜底。

  • 修复建议:加最大重试轮数(如 5)与极短退避;超出后抛 ApiError(TASK_NOT_CANCELABLE, "task status is changing too fast"),让调用方重试而不是把线程锁死在服务层。


[P3-轻微] _ensure_round_enqueued 的轮次元数据回写在 _reconcile_lock 之外,存在丢更新

  • 位置:backend/services/workflow_round_service.py:928、backend/services/workflow_round_service.py:799

  • 问题:reconcile_round 明确用 self._reconcile_lock 串行化"读候选 → 聚合 → 写轮次",但 _ensure_round_enqueued 末尾的"读 latest.metadata → 写回 status=queued"这一对读写没有走同一把锁。

  • 代码:

    # workflow_round_service.py:928-940
    latest = self.round_repository.get_round(round_record.round_id) or round_record   # ← 读
    self.round_repository.update_round(round_record.round_id, {
        "status": "queued",
        "metadata": {**latest.metadata, "planned_only": False, "task_ids": task_ids},  # ← 写,中间无锁
    })
    self.reconcile_round(round_record.round_id, ctx)
    
  • 影响:入队线程(HTTP 请求线程)与 worker 线程的 reconcile_round 交错时,worker 刚写入的 execution_summary 会被这里的 {**latest.metadata} 快照覆盖;轮次 status 也会被短暂回退到 queued。后面的 reconcile_round(...) 通常能纠正 status,但 metadata 里的聚合信息可能丢失一轮。

  • 修复建议:把 _ensure_round_enqueued 末尾这段读-改-写包进 with self._reconcile_lock:,或直接改用仓储层的条件更新(只更新 task_ids / planned_only 两个键而不是整块 metadata 覆盖)。


[P3-轻微] _record_generation_failure 与 _clear_retry_preparation 里的裸 except Exception: pass

  • 位置:backend/services/generation_service.py:1865、backend/services/generation_service.py:1887、backend/services/generation_job_retry_service.py:388、backend/services/generation_job_retry_service.py:399

  • 问题:失败记录与重试准备清理这两条"补偿路径"里的异常被完全静默吞掉,没有 logger.exception,也没有任何可观测输出(该模块甚至没有 import logging)。

  • 代码:

    # generation_service.py:1852-1888
    try:
        failed_task = self.queue_service.update_task_if_status(task.task_id, {"queued", "running"}, {...}, ctx)
    except Exception:
        pass                         # ← 任务没能标记 failed,无任何痕迹
    ...
        except Exception:
            pass                     # ← 节点没能标记 failed,无任何痕迹
    
    # generation_job_retry_service.py:378-399
    if isinstance(preparation, dict) and ...:
        metadata.pop("retry_preparation", None)
        workflow_service.update_node(node.node_id, {"metadata": metadata}, ctx)
    except Exception:
        pass                         # ← retry_preparation 残留在节点/工作流 metadata 上
    
  • 影响:任务/节点未能落到 failed 时,前端会看到一个永远停在 running 的节点,而日志里没有任何线索可定位;retry_preparation 残留会让后续 _prepare_node 的所有权判定读到过期 task_id。对比 worker_service.py 里同类补偿路径都规范地写了 logger.exception,这里属于明确的可观测性缺口。

  • 修复建议:在 generation_service.py / generation_job_retry_service.py 中引入 logger = logging.getLogger(__name__),把这 4 处 pass 换成 logger.exception("...", task_id, node_id),并在返回给调用方的 failure 字典中加上 bookkeeping_failed: True 标志,让 UI 能提示"状态可能不一致,请手动刷新/取消"。