forked from mtusi2026/mtusi2026lab6
79 lines
2.5 KiB
Python
79 lines
2.5 KiB
Python
import asyncio
|
|
import time
|
|
|
|
from dishka import FromDishka
|
|
from faststream import AckPolicy
|
|
from faststream.rabbit import Channel, QueueType, RabbitBroker, RabbitQueue
|
|
from faststream.rabbit.annotations import RabbitMessage
|
|
from pydantic import ValidationError
|
|
|
|
from messenger.attachments.application.bus import AttachmentsCommandBus
|
|
from messenger.attachments.application.commands import ProcessJob
|
|
from messenger.attachments.application.ports import JobObserver
|
|
from messenger.attachments.domain.jobs import Job
|
|
from messenger.attachments.entrypoints.schemas import JobMessage
|
|
from messenger.attachments.infrastructure.rabbitmq import QUEUE
|
|
from messenger.shared.application.ports import Logger
|
|
|
|
REQUEUE_DELAY_SECONDS = 1.0
|
|
JOBS = RabbitQueue(QUEUE, queue_type=QueueType.QUORUM, declare=False)
|
|
|
|
|
|
async def raw(message: RabbitMessage) -> bytes:
|
|
return message.body
|
|
|
|
|
|
async def handle_job(
|
|
message: RabbitMessage,
|
|
bus: FromDishka[AttachmentsCommandBus],
|
|
logger: FromDishka[Logger],
|
|
observer: FromDishka[JobObserver],
|
|
) -> None:
|
|
try:
|
|
job = JobMessage.model_validate_json(message.body).job()
|
|
except ValidationError:
|
|
logger.warning("job.rejected", reason="message does not match jobs.schema.json")
|
|
await message.reject(requeue=False)
|
|
return
|
|
observer.active(1)
|
|
started = time.perf_counter()
|
|
try:
|
|
outcome = (await bus.execute(ProcessJob(job))).value
|
|
except Exception as error:
|
|
observed(job, "error", started, observer, logger)
|
|
logger.warning(
|
|
"job.requeued",
|
|
job_id=str(job.id),
|
|
error=type(error).__name__,
|
|
error_code=getattr(getattr(error, "orig", error), "sqlstate", None),
|
|
)
|
|
await asyncio.sleep(REQUEUE_DELAY_SECONDS)
|
|
await message.nack(requeue=True)
|
|
return
|
|
finally:
|
|
observer.active(-1)
|
|
observed(job, outcome, started, observer, logger)
|
|
await message.ack()
|
|
|
|
|
|
def observed(job: Job, outcome: str, started: float, observer: JobObserver, logger: Logger) -> None:
|
|
seconds = time.perf_counter() - started
|
|
observer.observe(job, outcome, seconds)
|
|
logger.info(
|
|
"job.processed",
|
|
job_id=str(job.id),
|
|
attachment_id=str(job.attachment_id),
|
|
attempt=job.attempt,
|
|
outcome=outcome,
|
|
duration_ms=round(seconds * 1000, 3),
|
|
)
|
|
|
|
|
|
def subscribe(broker: RabbitBroker, concurrency: int) -> None:
|
|
broker.subscriber(
|
|
JOBS,
|
|
channel=Channel(prefetch_count=concurrency),
|
|
ack_policy=AckPolicy.MANUAL,
|
|
decoder=raw,
|
|
)(handle_job)
|