Spaces:
Runtime error
Runtime error
Download app/integrations/rabbit_consumer.py from MateFerreyra/Modulo-6: direct link, hf CLI and curl.
- Browser
- Download file 5.9 kB
-
https://huggingface.co/spaces/MateFerreyra/Modulo-6/resolve/main/app/integrations/rabbit_consumer.py
- Command line
-
hf download hf://spaces/MateFerreyra/Modulo-6/app/integrations/rabbit_consumer.py
-
curl -L -o rabbit_consumer.py https://huggingface.co/spaces/MateFerreyra/Modulo-6/resolve/main/app/integrations/rabbit_consumer.py
5.9 kB
| """ | |
| Consumer de `internacion.requests`: recibe por el bus del Core (M10) los mismos eventos | |
| que hoy llegan como webhooks REST directos de M1/M9/M2 (`app/routers/webhooks.py`). | |
| La cola y los 5 event types (`internacion.solicitud.creada`, | |
| `internacion.alta-medica.registrada`, `internacion.alerta-emergencia.detectada`, | |
| `internacion.alerta-resuelta.notificada`, `internacion.turno.cancelado`) ya están dados de | |
| alta y bindeados en el Core — ver `M6_DISEÑO.md` §7. Este módulo solo consume: cada | |
| mensaje se despacha a la misma función de servicio que usa el router REST equivalente, sin | |
| lógica de negocio nueva. Cirugía urgente queda fuera (excluida de esta migración, ver | |
| `M6_DISEÑO.md` §7): sigue siendo solo REST. | |
| Los endpoints REST entrantes siguen activos sin cambios durante la transición — cada | |
| equipo (M1/M9/M2) migra su emisor a su propio ritmo. | |
| """ | |
| import asyncio | |
| import json | |
| import logging | |
| import aio_pika | |
| from supabase import Client | |
| from app.config import settings | |
| from app.dependencies import get_db | |
| from app.schemas.reserva import CancelacionQuirofanoRequest | |
| from app.schemas.solicitud import ( | |
| AlertaEmergenciaRequest, | |
| AlertaResueltaRequest, | |
| AltaMedicaWebhook, | |
| SolicitudHceWebhook, | |
| ) | |
| from app.services import solicitud_service | |
| logger = logging.getLogger(__name__) | |
| def _handle_solicitud(db: Client, payload: dict) -> None: | |
| data = SolicitudHceWebhook.model_validate(payload) | |
| solicitud_service.recibir_solicitud(db, data) | |
| def _handle_alta_medica(db: Client, payload: dict) -> None: | |
| data = AltaMedicaWebhook.model_validate(payload) | |
| solicitud_service.procesar_alta_medica(db, data) | |
| def _handle_alerta_emergencia(db: Client, payload: dict) -> None: | |
| data = AlertaEmergenciaRequest.model_validate(payload) | |
| solicitud_service.procesar_alerta_emergencia(db, data.paciente_id) | |
| def _handle_alerta_resuelta(db: Client, payload: dict) -> None: | |
| data = AlertaResueltaRequest.model_validate(payload) | |
| solicitud_service.procesar_alerta_resuelta(db, data.paciente_id) | |
| def _handle_turno_cancelado(db: Client, payload: dict) -> None: | |
| # turno_id viaja en el payload del evento (en el webhook REST equivalente viene en el | |
| # path: POST /turnos/{turno_id}/cancelacion). CancelacionQuirofanoRequest ignora los | |
| # campos extra, así que se puede validar el resto del payload tal cual. | |
| turno_id = payload["turno_id"] | |
| data = CancelacionQuirofanoRequest.model_validate(payload) | |
| solicitud_service.cancelar_reserva_por_turno(db, turno_id, data.motivo) | |
| _HANDLERS = { | |
| "internacion.solicitud.creada": _handle_solicitud, | |
| "internacion.alta-medica.registrada": _handle_alta_medica, | |
| "internacion.alerta-emergencia.detectada": _handle_alerta_emergencia, | |
| "internacion.alerta-resuelta.notificada": _handle_alerta_resuelta, | |
| "internacion.turno.cancelado": _handle_turno_cancelado, | |
| } | |
| def dispatch(event_type_name: str, payload: dict) -> None: | |
| """ | |
| Despacha un mensaje ya parseado a la función de servicio correspondiente. | |
| Lanza `KeyError` si `event_type_name` no está mapeado, o lo que levante el servicio de | |
| negocio (`ValueError`, `HTTPException`, etc.) — `_on_message` decide ack/reject según | |
| el resultado. | |
| """ | |
| handler = _HANDLERS.get(event_type_name) | |
| if handler is None: | |
| raise KeyError(f"event_type_name no reconocido: {event_type_name!r}") | |
| db = get_db() | |
| handler(db, payload) | |
| async def _on_message(message: aio_pika.abc.AbstractIncomingMessage) -> None: | |
| try: | |
| envelope = json.loads(message.body) | |
| event_type_name = envelope["event_type_name"] | |
| payload = json.loads(envelope["payload"]) | |
| except (json.JSONDecodeError, KeyError, TypeError) as e: | |
| logger.error( | |
| "[M10→M6] Mensaje malformado en cola %s — se descarta sin procesar. Error: %s | body_preview=%r", | |
| settings.internacion_requests_queue, e, message.body[:200], | |
| ) | |
| await message.reject(requeue=False) | |
| return | |
| log_id = envelope.get("log_id") | |
| logger.info( | |
| "[M10→M6] Evento recibido: event_type=%r log_id=%s cola=%s", | |
| event_type_name, log_id, settings.internacion_requests_queue, | |
| ) | |
| try: | |
| dispatch(event_type_name, payload) | |
| except KeyError: | |
| logger.error( | |
| "[M10→M6] Evento desconocido: event_type=%r log_id=%s — se descarta (sin handler registrado)", | |
| event_type_name, log_id, | |
| ) | |
| await message.reject(requeue=False) | |
| return | |
| except Exception: | |
| logger.exception( | |
| "[M10→M6] Error procesando event_type=%r log_id=%s — se descarta (reject sin requeue)", | |
| event_type_name, log_id, | |
| ) | |
| await message.reject(requeue=False) | |
| return | |
| await message.ack() | |
| logger.info( | |
| "[M10→M6] Evento procesado OK: event_type=%r log_id=%s", | |
| event_type_name, log_id, | |
| ) | |
| async def run_consumer() -> None: | |
| """ | |
| Conecta a RabbitMQ y consume `internacion.requests` indefinidamente. Pensado para | |
| correr como task de asyncio en el lifespan de FastAPI (`app/main.py`), gateado por | |
| `settings.rabbitmq_consumer_enabled`. | |
| """ | |
| connection = await aio_pika.connect_robust( | |
| host=settings.rabbitmq_host, | |
| port=settings.rabbitmq_port, | |
| login=settings.core_service_email, | |
| password=settings.core_service_password, | |
| virtualhost=settings.rabbitmq_vhost, | |
| ) | |
| async with connection: | |
| channel = await connection.channel() | |
| await channel.set_qos(prefetch_count=10) | |
| # passive=True: la cola ya existe (creada vía POST /rabbit/queues del Core, con | |
| # su propia DLQ) — no la redeclaramos con propiedades propias. | |
| queue = await channel.declare_queue(settings.internacion_requests_queue, passive=True) | |
| await queue.consume(_on_message) | |
| await asyncio.Future() | |