"""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.event_bus import EventBus from core.fsm import task_transition 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, event_bus: EventBus | None = None): self.repository = repository self.audit_service = audit_service self.event_bus = event_bus 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)}, ) idempotency_key = _optional_text(payload.get("idempotency_key")) if idempotency_key: existing = self.repository.get_by_idempotency_key(idempotency_key) if existing is not None: return existing 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": 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(), ) self._publish( "generation.task_created", { "task_id": task.task_id, "status": task.status, "workflow_id": task.workflow_id, "node_id": task.node_id, }, ) 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}, ) self._validate_task_status_transition(before.status, "cancelled") 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(), ) self._publish_status_change(before, after) 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}, ) self._validate_task_status_transition(before.status, "queued") 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(), ) self._publish_status_change(before, after) 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: self._validate_task_status_transition(before.status, str(status)) 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(), ) if before.status != after.status: self._publish_status_change(before, after) self._publish("generation.task_updated", {"task_id": task_id, "status": after.status}) 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 _validate_task_status_transition(self, current: str, target: str) -> None: if target not in TASK_STATUSES: raise ApiError( ErrorCode.VALIDATION_FAILED, "unsupported task status", {"field": "status", "allowed": sorted(TASK_STATUSES)}, ) transition = task_transition(current, target) if not transition.allowed: raise ApiError( ErrorCode.VALIDATION_FAILED, "task status transition is not allowed", {"current": current, "target": target, "reason": transition.reason}, ) def _publish_status_change(self, before: GenerationTask, after: GenerationTask) -> None: self._publish( "generation.task_status_changed", { "task_id": after.task_id, "workflow_id": after.workflow_id, "node_id": after.node_id, "before_status": before.status, "after_status": after.status, }, ) def _publish(self, event_type: str, payload: dict[str, Any]) -> None: if self.event_bus: self.event_bus.publish(event_type, payload) def new_task_id() -> str: return f"task_{uuid4().hex}" def _optional_text(value: Any) -> str | None: if value is None: return None text = str(value).strip() return text or None