import hashlib import time from collections.abc import AsyncIterator, Callable from contextlib import AbstractAsyncContextManager, AsyncExitStack from uuid import UUID, uuid4 import anyio.to_thread from sqlalchemy.ext.asyncio import AsyncSession from src.core import exceptions from src.core.repos import attachment as attachment_repo from src.core.repos import attachment_object as attachment_object_repo from src.core.services.chat import ChatService from src.infra.cache import Cache from src.infra.logger import AbstractLogger, get_logger from src.infra.s3 import ObjectStorage from src.schemas import dataclasses from src.schemas.enums import AttachmentStatus, ImageType from src.utils.constants import ATTACHMENT_MAX_BYTES, ATTACHMENT_MAX_PIXELS from src.utils.image import ( DamagedImage, ImageInfo, TooManyPixels, UnsupportedImage, inspect_image, ) from src.utils.utc import utcnow logger: AbstractLogger = get_logger().bind(module="attachment_service") # Content-Type загрузки: тип без параметров, в нижнем регистре _ACCEPTED_MEDIA_TYPES = frozenset(image_type.value for image_type in ImageType) # короткая сессия БД на один шаг: `db_session_scope` слоя API type DbScope = Callable[[], AbstractAsyncContextManager[AsyncSession]] def _inspect(data: bytes) -> tuple[ImageInfo, bytes]: """Структура изображения и SHA-256 — одним вызовом в потоке.""" info = inspect_image(data, max_pixels=ATTACHMENT_MAX_PIXELS) return info, hashlib.sha256(data).digest() class AttachmentService: """Вложения: загрузка в S3 с метаданными в PostgreSQL, чтение, отдача. Сессии на весь запрос нет: каждый шаг с БД — свой короткий `async with self.db_scope()`, без вложенных, поэтому ни одно соединение пула не занято передачей тела (design change `attachments`, решение 5). `filename` в журнал не пишется. """ def __init__( self, db_scope: DbScope, cache: Cache, storage: ObjectStorage, ) -> None: self.db_scope = db_scope self.cache = cache self.storage = storage async def _require_member( self, *, db_session: AsyncSession, chat_id: UUID, user_id: UUID, ) -> None: await ChatService( db_session=db_session, cache=self.cache, ).get_chat_for_member(chat_id=chat_id, user_id=user_id) async def upload( self, *, chat_id: UUID, owner_id: UUID, filename: str, media_type: str | None, content_length: int | None, body: AsyncIterator[bytes], ) -> dataclasses.AttachmentFullDTO: """Загрузка оригинала; 201 только после `ready` в БД. Порядок проверок — спек «Порядок проверок загрузки»: членство (404), `Content-Type` (415), `Content-Length` (413), затем тело со счётчиком (413) и содержимое (415 или 413). Порядок записи (решение 1): строка `pending` с ключом объекта — commit, PUT, `ready` — commit. Отказ S3 или БД после строки `pending` — 503, строка остаётся до уборщика (`upload-consistency`). """ started = time.monotonic() log = logger.bind( method="upload", chat_id=chat_id, filename_length=len(filename), ) async with self.db_scope() as db_session: await self._require_member( db_session=db_session, chat_id=chat_id, user_id=owner_id, ) if media_type not in _ACCEPTED_MEDIA_TYPES: log.info("Rejected attachment", reason="type") raise exceptions.UnsupportedMediaType if ( content_length is not None and content_length > ATTACHMENT_MAX_BYTES ): log.info( "Rejected attachment", reason="declared_size", declared_size=content_length, ) raise exceptions.PayloadTooLarge data = await self._read_body(body=body, log=log) try: info, sha256 = await anyio.to_thread.run_sync(_inspect, data) except TooManyPixels as e: log.info("Rejected attachment", reason="pixels") raise exceptions.PayloadTooLarge from e except DamagedImage as e: log.info("Rejected attachment", reason="damaged") raise exceptions.UnsupportedMediaType from e except UnsupportedImage as e: log.info("Rejected attachment", reason="content") raise exceptions.UnsupportedMediaType from e if info.content_type != media_type: log.info("Rejected attachment", reason="content_mismatch") raise exceptions.UnsupportedMediaType attachment_id = uuid4() now = utcnow() pending = dataclasses.AttachmentFullDTO( id=attachment_id, chat_id=chat_id, owner_id=owner_id, filename=filename, content_type=info.content_type, size_bytes=len(data), sha256=sha256, object_key=attachment_object_repo.original_key( self.storage, attachment_id=attachment_id, ), status=AttachmentStatus.PENDING, created_at=now, updated_at=now, ) async with self.db_scope() as db_session: await attachment_repo.insert_attachment( db_session=db_session, attachment=pending, ) await db_session.commit() await attachment_object_repo.put_original( self.storage, key=pending.object_key, data=data, content_type=pending.content_type.value, ) async with self.db_scope() as db_session: ready = await attachment_repo.mark_ready( db_session=db_session, attachment_id=attachment_id, updated_at=utcnow(), ) await db_session.commit() if ready is None: # строку pending удалить некому, пока нет уборщика: ветку # переопределит change upload-consistency raise RuntimeError("Pending attachment disappeared before ready") log.info( "Uploaded attachment", attachment_id=attachment_id, size_bytes=ready.size_bytes, content_type=ready.content_type, width=info.width, height=info.height, duration_ms=round((time.monotonic() - started) * 1000), ) return ready async def _read_body( self, *, body: AsyncIterator[bytes], log: AbstractLogger, ) -> bytes: """Тело целиком; больше лимита — 413 сразу, без дочитывания.""" buffer = bytearray() try: async for chunk in body: if len(buffer) + len(chunk) > ATTACHMENT_MAX_BYTES: log.info( "Rejected attachment", reason="size", size=len(buffer) + len(chunk), ) raise exceptions.PayloadTooLarge buffer += chunk except exceptions.UploadInterrupted: log.info("Rejected attachment", reason="interrupted") raise return bytes(buffer) async def get_attachment( self, *, attachment_id: UUID, user_id: UUID, ) -> dataclasses.AttachmentFullDTO: """Готовое вложение для участника его чата; иначе 404. Нет строки, она `pending` или пользователь не участник — одинаковый `AttachmentNotFound`. """ async with self.db_scope() as db_session: attachment = await attachment_repo.get_attachment( db_session=db_session, attachment_id=attachment_id, ) if ( attachment is None or attachment.status != AttachmentStatus.READY ): raise exceptions.AttachmentNotFound try: await self._require_member( db_session=db_session, chat_id=attachment.chat_id, user_id=user_id, ) except exceptions.ChatNotFound as e: raise exceptions.AttachmentNotFound from e return attachment async def open_content( self, *, attachment_id: UUID, user_id: UUID, ) -> dataclasses.AttachmentContentDTO: """Оригинал потоком из S3 (решение 7). Отказ S3 — 503 до заголовков ответа. Нет объекта или размер в S3 другой — `error` в журнале и 500; строку сервис не меняет. """ attachment = await self.get_attachment( attachment_id=attachment_id, user_id=user_id, ) log = logger.bind( method="open_content", attachment_id=attachment_id, object_key=attachment.object_key, ) stack = AsyncExitStack() try: stored = await stack.enter_async_context( attachment_object_repo.open_original( self.storage, key=attachment.object_key, ), ) except exceptions.StoredObjectMissing as e: log.error("Attachment content is missing") raise exceptions.AttachmentContentMissing from e if stored.size != attachment.size_bytes: await stack.aclose() log.error( "Attachment content size differs", size_bytes=attachment.size_bytes, stored_size=stored.size, ) raise exceptions.AttachmentContentMissing async def chunks() -> AsyncIterator[bytes]: try: async for chunk in stored.iter_chunks(): yield chunk finally: await stack.aclose() return dataclasses.AttachmentContentDTO( content_type=attachment.content_type, size_bytes=attachment.size_bytes, chunks=chunks(), close=stack.aclose, )