Files
mtusi2026lab4/src/messenger/main.py
T
ArtyomandClaude Opus 5.5 00826a40d3 Serve attachment upload, metadata and download through the API
Add the adapters behind the attachments ports: PostgreSQL for the
pending and ready rows, with a foreign key violation on the chat member
turned into 404; Pillow that opens only PNG and JPEG, refuses a type
that differs from Content-Type, checks the pixel count from the header
before any decoding, verifies PNG chunks and decodes JPEG at 1/8 scale
in a worker thread under a semaphore; and S3 on aiobotocore with path
style, SigV4, short timeouts and checksums only when required. botocore
sends Expect: 100-continue for streamed bodies and RustFS behind the
Docker port proxy never answers it, so the PUT hung until the read
timeout; the handler that adds the header is unregistered.

The HTTP layer streams the raw body into the use case, returns the
contract Attachment and streams the original back with its content
type and length and no redirect. The request pipeline takes a body
limit per route, so uploads may carry 10 MiB while JSON stays at 1 MiB.
main.py wires the zone and answers its membership port from the
messaging chat directory.

Tests run the API with an in-memory object store: download by another
member, 404 for strangers, the exact 10 MiB limit and one byte over it
with Content-Length and chunked, 40 MP and above, spoofed and truncated
images, unsupported types, dangerous names, the variant, a failing
store and a lost object.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-28 20:44:32 +03:00

146 lines
6.0 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 ChatMembership
from messenger.attachments.config import AttachmentsSettings
from messenger.attachments.domain.events import AttachmentStored
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 AttachmentsJournal
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 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", "queue", "instance"})
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 ZoneLinks(Provider):
@provide(scope=Scope.APP)
def membership(self, chats: ChatDirectory) -> ChatMembership:
return MessagingMembership(chats)
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)
attachments = AttachmentsJournal(logger)
bus.subscribe(AttachmentStored, attachments.on_attachment_stored)
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,
)
@asynccontextmanager
async def lifespan(_app: FastAPI) -> AsyncIterator[None]:
bus = await container.get(EventBus)
wire_events(bus, logger)
bus.start()
logger.info("service.started")
try:
yield
finally:
await bus.stop()
await container.close()
logger.info("service.stopped")
app = FastAPI(
title="MTUSI Messenger",
version="1.4.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),),
)
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)
return app