Files
mtusi2026labs/src/messenger/relay.py
T

80 lines
2.8 KiB
Python

import asyncio
import signal
from dishka import make_async_container
from faststream.rabbit import Channel, RabbitBroker
from faststream.rabbit.opentelemetry import RabbitTelemetryMiddleware
from messenger.attachments.config import PipelineSettings
from messenger.attachments.entrypoints.heartbeat import Heartbeat
from messenger.attachments.entrypoints.ioc import PipelineProvider, RelayProvider
from messenger.attachments.entrypoints.journal import LOG_FIELDS, subscribe_journal
from messenger.attachments.entrypoints.relay import Relay
from messenger.attachments.infrastructure.queue_metrics import QueueMetrics
from messenger.shared.application.messagebus import EventBus
from messenger.shared.config import PlatformSettings
from messenger.shared.entrypoints.ioc import PlatformProvider
from messenger.shared.infrastructure.logging import PLATFORM_FIELDS, StructlogLogger
from messenger.shared.infrastructure.postgres import Database
from messenger.shared.infrastructure.telemetry import start_telemetry
PING_TIMEOUT_SECONDS = 2.0
async def serve() -> None:
platform = PlatformSettings()
pipeline = PipelineSettings()
fields = PLATFORM_FIELDS | LOG_FIELDS
logger = StructlogLogger(level=platform.log_level, allowed_fields=fields)
telemetry = start_telemetry(platform, fields, "messenger-relay")
broker = RabbitBroker(
pipeline.broker_url.get_secret_value(),
default_channel=Channel(publisher_confirms=True, on_return_raises=True),
logger=None,
middlewares=() if telemetry is None else (RabbitTelemetryMiddleware(),),
)
container = make_async_container(
PlatformProvider(platform, logger), PipelineProvider(pipeline), RelayProvider(broker)
)
stop = asyncio.Event()
loop = asyncio.get_running_loop()
for signum in (signal.SIGTERM, signal.SIGINT):
loop.add_signal_handler(signum, stop.set)
await broker.connect()
bus = await container.get(EventBus)
subscribe_journal(bus, logger)
bus.start()
relay = Relay(container, pipeline, logger)
heartbeat = Heartbeat(
pipeline.heartbeat_file,
lambda: broker.ping(PING_TIMEOUT_SECONDS),
pipeline.heartbeat_interval_seconds,
logger,
)
queue_metrics = QueueMetrics(await container.get(Database), logger)
if telemetry is not None:
queue_metrics.start()
relay.start()
heartbeat.start()
logger.info("relay.started")
try:
await stop.wait()
finally:
await heartbeat.stop()
await queue_metrics.stop()
await relay.stop()
await bus.stop()
await broker.stop()
await container.close()
logger.info("relay.stopped")
if telemetry is not None:
telemetry.shutdown(platform.telemetry_shutdown_seconds)
def main() -> None:
asyncio.run(serve())
if __name__ == "__main__":
main()