astrbot_plugin_imagestudio/backend/services/queue_service.py

216 行
7.9 KiB
Python

"""Queue and job service."""
from __future__ import annotations
from typing import Any
from uuid import uuid4
from backend.dto.common import ApiError, ErrorCode
from backend.dto.job_dto import GenerationTask, JobListResult
from core.audit_service import AuditService
from core.identity import RequestContext
from database.repositories.job_repository import JobRepository
TASK_STATUSES = {
"created",
"queued",
"running",
"completed",
"succeeded",
"failed",
"cancelled",
"dead_letter",
}
class QueueService:
def __init__(self, repository: JobRepository, audit_service: AuditService):
self.repository = repository
self.audit_service = audit_service
def create_task(self, payload: dict[str, Any], ctx: RequestContext) -> GenerationTask:
status = str(payload.get("status", "created"))
if status not in TASK_STATUSES:
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"unsupported task status",
{"field": "status", "allowed": sorted(TASK_STATUSES)},
)
task = self.repository.create(
{
"task_id": payload.get("task_id") or new_task_id(),
"profile_id": payload.get("profile_id"),
"workflow_id": payload.get("workflow_id"),
"node_id": payload.get("node_id"),
"task_type": payload.get("task_type", "generation"),
"status": status,
"model_route": payload.get("model_route"),
"progress": payload.get("progress", 0),
"idempotency_key": payload.get("idempotency_key"),
"request": payload.get("request") or {},
"result": payload.get("result") or {},
"error_message": payload.get("error_message"),
"metadata": payload.get("metadata") or {},
}
)
self.audit_service.record(
ctx=ctx,
action="create_task",
target_type="generation_task",
target_id=task.task_id,
after_snapshot=task.to_dict(),
)
return task
def list_jobs(
self,
*,
status: str | None = None,
workflow_id: str | None = None,
profile_id: str | None = None,
page: int = 1,
page_size: int = 30,
) -> JobListResult:
if status and status not in TASK_STATUSES:
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"unsupported task status",
{"field": "status", "allowed": sorted(TASK_STATUSES)},
)
normalized_page = max(page, 1)
normalized_page_size = min(max(page_size, 1), 100)
items, total = self.repository.list(
status=status,
workflow_id=workflow_id,
profile_id=profile_id,
page=normalized_page,
page_size=normalized_page_size,
)
return JobListResult(
items=items,
total=total,
page=normalized_page,
page_size=normalized_page_size,
)
def get_job(self, task_id: str) -> GenerationTask:
task = self.repository.get(task_id)
if task is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "task not found", {"task_id": task_id})
return task
def cancel_job(self, task_id: str, ctx: RequestContext) -> GenerationTask:
before = self.get_job(task_id)
if before.status in {"completed", "succeeded", "cancelled"}:
raise ApiError(
ErrorCode.TASK_NOT_CANCELABLE,
"task cannot be cancelled from current status",
{"task_id": task_id, "status": before.status},
)
after = self.repository.update(task_id, {"status": "cancelled"})
if after is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "task not found", {"task_id": task_id})
self.audit_service.record(
ctx=ctx,
action="cancel_task",
target_type="generation_task",
target_id=task_id,
before_snapshot=before.to_dict(),
after_snapshot=after.to_dict(),
)
return after
def retry_job(self, task_id: str, ctx: RequestContext) -> GenerationTask:
before = self.get_job(task_id)
if before.status not in {"failed", "dead_letter", "cancelled"}:
raise ApiError(
ErrorCode.TASK_NOT_RETRYABLE,
"task cannot be retried from current status",
{"task_id": task_id, "status": before.status},
)
after = self.repository.update(
task_id,
{
"status": "queued",
"progress": 0,
"error_message": None,
"metadata": {**before.metadata, "retry_requested": True},
},
)
if after is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "task not found", {"task_id": task_id})
self.audit_service.record(
ctx=ctx,
action="retry_task",
target_type="generation_task",
target_id=task_id,
before_snapshot=before.to_dict(),
after_snapshot=after.to_dict(),
)
return after
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 and status not in TASK_STATUSES:
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"unsupported task status",
{"field": "status", "allowed": sorted(TASK_STATUSES)},
)
after = self.repository.update(task_id, payload)
if after is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "task not found", {"task_id": task_id})
self.audit_service.record(
ctx=ctx,
action="update_task",
target_type="generation_task",
target_id=task_id,
before_snapshot=before.to_dict(),
after_snapshot=after.to_dict(),
)
return after
def queue_summary(self) -> dict[str, int]:
counts = self.repository.count_by_status()
return {
"pending": counts.get("created", 0) + counts.get("queued", 0),
"running": counts.get("running", 0),
"failed": counts.get("failed", 0),
"dead_letter": counts.get("dead_letter", 0),
}
def recent_jobs(self, limit: int = 10) -> list[dict[str, Any]]:
return [task.to_dict() for task in self.repository.recent(limit=limit)]
def retry_dead_letters(self, ctx: RequestContext, *, limit: int = 50) -> dict[str, Any]:
jobs = self.list_jobs(status="dead_letter", page=1, page_size=limit).items
retried = []
errors = []
for job in jobs:
try:
retried.append(self.retry_job(job.task_id, ctx).to_dict())
except ApiError as exc:
errors.append({"task_id": job.task_id, "error_code": exc.error_code.value, "message": exc.message})
return {"retried": retried, "errors": errors, "total": len(retried)}
def move_failed_to_dead_letter(self, ctx: RequestContext, *, limit: int = 50) -> dict[str, Any]:
jobs = self.list_jobs(status="failed", page=1, page_size=limit).items
moved = []
for job in jobs:
moved.append(
self.update_task(
job.task_id,
{
"status": "dead_letter",
"metadata": {**job.metadata, "dead_letter_reason": job.error_message or "manual_move"},
},
ctx,
).to_dict()
)
return {"moved": moved, "total": len(moved)}
def new_task_id() -> str:
return f"task_{uuid4().hex}"