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

413 行
29 KiB
Markdown

# 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 却没有使用。
- **代码**:
```python
# 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
```
```python
# job_repository.py:215
conn.execute(
f"""
UPDATE generation_tasks
SET {", ".join(assignments)}
WHERE task_id = {placeholder} # ← 只有 task_id
""",
```
```python
# 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)条。
- **代码**:
```python
# 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}
""",
```
```python
# 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。
- **代码**:
```python
# 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
```
```python
# 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"`。
- **代码**:
```python
# 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, ...)
```
```python
# generation_service.py:356-364
return self.queue_service.create_task({
...
"task_type": "workflow_round_candidate", # ← 非 "generation"
```
```python
# 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 限制并发生成数量。
- **代码**:
```python
# 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:
...
```
```python
# main.py:333-340
response = await asyncio.to_thread( # ← 默认 executor,全插件共用
dispatch_web_request, ctx, dispatch_method, dispatch_endpoint, ...)
```
```python
# 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` 误判为"上个进程遗留"。
- **代码**:
```python
# 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),
)
```
```python
# 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)
```
```python
# 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"`。
- **代码**:
```python
# 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
```
```python
# 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"的出口。
- **代码**:
```python
# 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 键没有任何读取点。
- **代码**:
```python
# 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)
```
```python
# 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,**不会**回收刚创建的图片记录与磁盘文件。
- **代码**:
```python
# 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。
- **代码**:
```python
# 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"这一对读写没有走同一把锁。
- **代码**:
```python
# 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)。
- **代码**:
```python
# 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,无任何痕迹
```
```python
# 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 能提示"状态可能不一致,请手动刷新/取消"。