"""Fila de trabalho: concorrência limitada, fila limitada POR CHAVE, timeout de espera e de execução. - A cota de espera é por `owner` (o `keyId` de quem chamou): uma chave cheia recebe `QueueFull`, as outras continuam entrando. Homologação e produção usam o mesmo serviço com chaves diferentes; o teste de uma não pode recusar a doação paga da outra. - A vaga de execução (CPU) é global, mas é entregue em rodízio entre as chaves que estão esperando, e a chave que acabou de rodar vai para o fim: cada chave espera no máximo o trabalho em curso e um de cada outra chave ativa, e não a fila inteira da outra. Por isso o timeout de espera precisa ser >= 2x o de execução. - A vaga só é devolvida quando a thread realmente termina — mesmo que o cliente já tenha recebido 504 —, para o limite de CPU ser real e não só aparente. """ from __future__ import annotations import asyncio from collections import deque from collections.abc import Callable from concurrent.futures import ThreadPoolExecutor from typing import TypeVar from .errors import QueueFull, QueueTimeout, SynthesisTimeout T = TypeVar("T") class WorkQueue: def __init__(self, max_concurrency: int, max_queue_per_key: int, queue_timeout_s: float, run_timeout_s: float): self.max_concurrency = max_concurrency self.max_queue_per_key = max_queue_per_key self.queue_timeout_s = queue_timeout_s self.run_timeout_s = run_timeout_s self._free = max_concurrency # owner → esperas em ordem de chegada. A ordem do dict é o rodízio: quem é atendido vai para o fim. self._waiters: dict[str, deque[asyncio.Future[None]]] = {} self._executor = ThreadPoolExecutor(max_workers=max_concurrency, thread_name_prefix="work") self.running = 0 @property def waiting(self) -> int: """Total esperando, somadas todas as chaves.""" return sum(len(waiters) for waiters in self._waiters.values()) def waiting_for(self, owner: str) -> int: waiters = self._waiters.get(owner) return len(waiters) if waiters else 0 def is_full(self, owner: str) -> bool: """Verdadeiro quando um `run` novo DESTA chave seria recusado com QueueFull.""" return self._free == 0 and self.waiting_for(owner) >= self.max_queue_per_key async def _acquire(self, owner: str) -> None: if self._free > 0 and not self._waiters: self._free -= 1 return waiter: asyncio.Future[None] = asyncio.get_running_loop().create_future() self._waiters.setdefault(owner, deque()).append(waiter) try: # asyncio.wait não cancela o future no timeout: dá para ver se a vaga chegou no último instante. await asyncio.wait({waiter}, timeout=self.queue_timeout_s) except BaseException: # cliente desistiu (CancelledError) enquanto esperava self._abandon(owner, waiter) raise if not waiter.done(): self._abandon(owner, waiter) raise QueueTimeout() def _abandon(self, owner: str, waiter: asyncio.Future[None]) -> None: if waiter.done() and not waiter.cancelled(): self._release() # a vaga já tinha sido entregue a esta espera: passa adiante return waiter.cancel() waiters = self._waiters.get(owner) if waiters is not None: try: waiters.remove(waiter) except ValueError: pass if not waiters: del self._waiters[owner] def _release(self, finished_owner: str | None = None) -> None: """Entrega a vaga à próxima chave do rodízio; sem ninguém esperando, ela volta a ficar livre.""" if finished_owner is not None and finished_owner in self._waiters and len(self._waiters) > 1: self._waiters[finished_owner] = self._waiters.pop(finished_owner) # quem acabou de rodar vai para o fim while self._waiters: owner = next(iter(self._waiters)) waiters = self._waiters.pop(owner) waiter = waiters.popleft() if waiters: self._waiters[owner] = waiters # volta para o fim do rodízio if not waiter.done(): waiter.set_result(None) return self._free += 1 async def run(self, fn: Callable[[], T], owner: str) -> T: if self.is_full(owner): raise QueueFull() await self._acquire(owner) self.running += 1 future = asyncio.get_running_loop().run_in_executor(self._executor, fn) released = False def _finish(_: object = None) -> None: self.running -= 1 self._release(owner) try: return await asyncio.wait_for(asyncio.shield(future), timeout=self.run_timeout_s) except asyncio.TimeoutError: future.add_done_callback(_finish) released = True raise SynthesisTimeout() from None except asyncio.CancelledError: # Cliente desistiu no meio: a thread segue, então a vaga só volta quando ela terminar. future.add_done_callback(_finish) released = True raise finally: if not released: _finish() def shutdown(self) -> None: self._executor.shutdown(wait=False, cancel_futures=True)