112 行
3.7 KiB
Python
112 行
3.7 KiB
Python
"""In-memory generation queue primitives."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections import deque
|
|
from dataclasses import dataclass, field
|
|
from datetime import datetime, timezone
|
|
from typing import Any
|
|
from uuid import uuid4
|
|
|
|
from core.fsm import task_transition
|
|
|
|
|
|
def _now() -> str:
|
|
return datetime.now(timezone.utc).isoformat()
|
|
|
|
|
|
@dataclass
|
|
class QueueItem:
|
|
task_id: str
|
|
payload: dict[str, Any]
|
|
status: str = "queued"
|
|
idempotency_key: str | None = None
|
|
attempts: int = 0
|
|
error_message: str | None = None
|
|
created_at: str = field(default_factory=_now)
|
|
updated_at: str = field(default_factory=_now)
|
|
|
|
def to_dict(self) -> dict[str, Any]:
|
|
return {
|
|
"task_id": self.task_id,
|
|
"payload": self.payload,
|
|
"status": self.status,
|
|
"idempotency_key": self.idempotency_key,
|
|
"attempts": self.attempts,
|
|
"error_message": self.error_message,
|
|
"created_at": self.created_at,
|
|
"updated_at": self.updated_at,
|
|
}
|
|
|
|
|
|
class QueueManager:
|
|
def __init__(self):
|
|
self._pending: deque[str] = deque()
|
|
self._items: dict[str, QueueItem] = {}
|
|
self._idempotency_index: dict[str, str] = {}
|
|
|
|
def enqueue(self, payload: dict[str, Any], *, idempotency_key: str | None = None) -> QueueItem:
|
|
if idempotency_key and idempotency_key in self._idempotency_index:
|
|
return self._items[self._idempotency_index[idempotency_key]]
|
|
item = QueueItem(
|
|
task_id=str(payload.get("task_id") or f"task_{uuid4().hex}"),
|
|
payload=dict(payload),
|
|
idempotency_key=idempotency_key,
|
|
)
|
|
self._items[item.task_id] = item
|
|
if idempotency_key:
|
|
self._idempotency_index[idempotency_key] = item.task_id
|
|
self._pending.append(item.task_id)
|
|
return item
|
|
|
|
def dequeue(self) -> QueueItem | None:
|
|
while self._pending:
|
|
task_id = self._pending.popleft()
|
|
item = self._items.get(task_id)
|
|
if item and item.status == "queued":
|
|
self._set_status(item, "running")
|
|
item.attempts += 1
|
|
return item
|
|
return None
|
|
|
|
def complete(self, task_id: str, result: dict[str, Any] | None = None) -> QueueItem:
|
|
item = self.get(task_id)
|
|
item.payload = {**item.payload, "result": result or {}}
|
|
self._set_status(item, "succeeded")
|
|
item.error_message = None
|
|
return item
|
|
|
|
def fail(self, task_id: str, error_message: str, *, dead_letter: bool = False) -> QueueItem:
|
|
item = self.get(task_id)
|
|
self._set_status(item, "failed")
|
|
item.error_message = error_message
|
|
if dead_letter:
|
|
self._set_status(item, "dead_letter")
|
|
return item
|
|
|
|
def retry(self, task_id: str) -> QueueItem:
|
|
item = self.get(task_id)
|
|
self._set_status(item, "queued")
|
|
item.error_message = None
|
|
if task_id not in self._pending:
|
|
self._pending.append(task_id)
|
|
return item
|
|
|
|
def get(self, task_id: str) -> QueueItem:
|
|
item = self._items.get(task_id)
|
|
if item is None:
|
|
raise KeyError(task_id)
|
|
return item
|
|
|
|
def summary(self) -> dict[str, int]:
|
|
counts = {"queued": 0, "running": 0, "succeeded": 0, "failed": 0, "dead_letter": 0}
|
|
for item in self._items.values():
|
|
counts[item.status] = counts.get(item.status, 0) + 1
|
|
return counts
|
|
|
|
def _set_status(self, item: QueueItem, status: str) -> None:
|
|
transition = task_transition(item.status, status)
|
|
if not transition.allowed:
|
|
raise ValueError(transition.reason)
|
|
item.status = transition.target
|
|
item.updated_at = _now()
|