forked from mtusi2026/mtusi2026lab2
80 lines
2.8 KiB
Python
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()
|