164 lines
6.6 KiB
Python
164 lines
6.6 KiB
Python
from collections.abc import AsyncIterator, Sequence
|
|
from contextlib import asynccontextmanager
|
|
from uuid import UUID
|
|
|
|
from dishka import Provider, Scope, make_async_container, provide
|
|
from dishka.integrations.fastapi import FastapiProvider, setup_dishka
|
|
from fastapi import FastAPI
|
|
|
|
from messenger.attachments.application.ports import AttachmentDirectory, ChatMembership
|
|
from messenger.attachments.config import AttachmentsSettings
|
|
from messenger.attachments.entrypoints.errors import ERROR_CODES as ATTACHMENT_ERRORS
|
|
from messenger.attachments.entrypoints.http import UPLOAD_PATH, attachments_router, uploads_router
|
|
from messenger.attachments.entrypoints.ioc import AttachmentsProvider
|
|
from messenger.attachments.entrypoints.journal import LOG_FIELDS as ATTACHMENT_FIELDS
|
|
from messenger.attachments.entrypoints.journal import subscribe_journal
|
|
from messenger.attachments.entrypoints.sweeper import UploadSweeper
|
|
from messenger.identity.config import IdentitySettings
|
|
from messenger.identity.domain.events import SessionClosed, SessionOpened, UserRegistered
|
|
from messenger.identity.entrypoints.authentication import challenge_for, guard
|
|
from messenger.identity.entrypoints.errors import ERROR_CODES as IDENTITY_ERRORS
|
|
from messenger.identity.entrypoints.http import router as users_router
|
|
from messenger.identity.entrypoints.http import sessions_router
|
|
from messenger.identity.entrypoints.ioc import IdentityProvider
|
|
from messenger.identity.entrypoints.journal import LOG_FIELDS as IDENTITY_FIELDS
|
|
from messenger.identity.entrypoints.journal import IdentityJournal
|
|
from messenger.messaging.application.ports import AttachmentStates, ChatDirectory
|
|
from messenger.messaging.config import MessagingSettings
|
|
from messenger.messaging.domain.events import ChatCreated, MessagePosted
|
|
from messenger.messaging.entrypoints.errors import ERROR_CODES as MESSAGING_ERRORS
|
|
from messenger.messaging.entrypoints.http import chats_router, messages_router
|
|
from messenger.messaging.entrypoints.ioc import MessagingProvider
|
|
from messenger.messaging.entrypoints.journal import LOG_FIELDS as MESSAGING_FIELDS
|
|
from messenger.messaging.entrypoints.journal import MessagingJournal
|
|
from messenger.shared.application.messagebus import EventBus
|
|
from messenger.shared.application.ports import Logger
|
|
from messenger.shared.config import PlatformSettings
|
|
from messenger.shared.entrypoints import errors, health
|
|
from messenger.shared.entrypoints.config import TransportSettings
|
|
from messenger.shared.entrypoints.ioc import PlatformProvider
|
|
from messenger.shared.entrypoints.pipeline import RequestPipeline
|
|
from messenger.shared.infrastructure.logging import PLATFORM_FIELDS, StructlogLogger
|
|
|
|
TRANSPORT_FIELDS = frozenset({"dropped_total"})
|
|
|
|
LOG_FIELDS = (
|
|
PLATFORM_FIELDS | TRANSPORT_FIELDS | IDENTITY_FIELDS | MESSAGING_FIELDS | ATTACHMENT_FIELDS
|
|
)
|
|
ERROR_CODES = {**IDENTITY_ERRORS, **MESSAGING_ERRORS, **ATTACHMENT_ERRORS}
|
|
|
|
|
|
class MessagingMembership:
|
|
__slots__ = ("_chats",)
|
|
|
|
def __init__(self, chats: ChatDirectory) -> None:
|
|
self._chats = chats
|
|
|
|
async def is_member(self, chat_id: UUID, user_id: UUID) -> bool:
|
|
return await self._chats.chat_for_member(chat_id, user_id) is not None
|
|
|
|
|
|
class AttachmentGate:
|
|
__slots__ = ("_attachments",)
|
|
|
|
def __init__(self, attachments: AttachmentDirectory) -> None:
|
|
self._attachments = attachments
|
|
|
|
async def unusable(self, chat_id: UUID, attachment_ids: Sequence[UUID]) -> bool:
|
|
return await self._attachments.failed_among(chat_id, attachment_ids)
|
|
|
|
|
|
class ZoneLinks(Provider):
|
|
@provide(scope=Scope.APP)
|
|
def membership(self, chats: ChatDirectory) -> ChatMembership:
|
|
return MessagingMembership(chats)
|
|
|
|
@provide(scope=Scope.APP)
|
|
def attachment_states(self, attachments: AttachmentDirectory) -> AttachmentStates:
|
|
return AttachmentGate(attachments)
|
|
|
|
|
|
def wire_events(bus: EventBus, logger: Logger) -> None:
|
|
identity = IdentityJournal(logger)
|
|
bus.subscribe(UserRegistered, identity.on_user_registered)
|
|
bus.subscribe(SessionOpened, identity.on_session_opened)
|
|
bus.subscribe(SessionClosed, identity.on_session_closed)
|
|
|
|
messaging = MessagingJournal(logger)
|
|
bus.subscribe(ChatCreated, messaging.on_chat_created)
|
|
bus.subscribe(MessagePosted, messaging.on_message_posted)
|
|
|
|
subscribe_journal(bus, logger)
|
|
|
|
|
|
def create_app(
|
|
*,
|
|
platform: PlatformSettings | None = None,
|
|
transport: TransportSettings | None = None,
|
|
identity: IdentitySettings | None = None,
|
|
messaging: MessagingSettings | None = None,
|
|
attachments: AttachmentsSettings | None = None,
|
|
overrides: Sequence[Provider] = (),
|
|
) -> FastAPI:
|
|
platform = platform or PlatformSettings()
|
|
transport = transport or TransportSettings()
|
|
identity = identity or IdentitySettings()
|
|
messaging = messaging or MessagingSettings()
|
|
attachments = attachments or AttachmentsSettings()
|
|
logger = StructlogLogger(level=platform.log_level, allowed_fields=LOG_FIELDS)
|
|
container = make_async_container(
|
|
PlatformProvider(platform, logger),
|
|
IdentityProvider(identity),
|
|
MessagingProvider(messaging),
|
|
AttachmentsProvider(attachments),
|
|
ZoneLinks(),
|
|
FastapiProvider(),
|
|
*overrides,
|
|
)
|
|
sweeper = UploadSweeper(container, attachments, logger)
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(_app: FastAPI) -> AsyncIterator[None]:
|
|
bus = await container.get(EventBus)
|
|
wire_events(bus, logger)
|
|
bus.start()
|
|
sweeper.start()
|
|
logger.info("service.started")
|
|
try:
|
|
yield
|
|
finally:
|
|
await sweeper.stop()
|
|
await bus.stop()
|
|
await container.close()
|
|
logger.info("service.stopped")
|
|
|
|
app = FastAPI(
|
|
title="MTUSI Messenger",
|
|
version="1.5.0",
|
|
lifespan=lifespan,
|
|
docs_url="/docs" if transport.docs else None,
|
|
redoc_url=None,
|
|
openapi_url="/openapi.json" if transport.docs else None,
|
|
)
|
|
app.add_middleware(
|
|
RequestPipeline,
|
|
logger=logger,
|
|
max_bytes=transport.max_body_bytes,
|
|
timeout=transport.request_timeout_seconds,
|
|
guard=guard,
|
|
instance=platform.instance_id,
|
|
limits=((UPLOAD_PATH, attachments.max_upload_bytes),),
|
|
min_rate=transport.min_transfer_rate_bytes,
|
|
)
|
|
errors.install(app, logger, ERROR_CODES, challenge_for, platform.instance_id)
|
|
app.include_router(health.router)
|
|
app.include_router(users_router)
|
|
app.include_router(sessions_router)
|
|
app.include_router(chats_router)
|
|
app.include_router(messages_router)
|
|
app.include_router(uploads_router)
|
|
app.include_router(attachments_router)
|
|
setup_dishka(container, app)
|
|
app.state.sweeper = sweeper
|
|
return app
|