Files
mtusi2026lab4-fork/app/attachments.py
2026-11-06 13:57:29 +03:00

212 lines
9.5 KiB
Python

"""Synchronous binary uploads with bounded staging and durable database intents."""
import asyncio
import hashlib
import tempfile
import unicodedata
import uuid
import warnings
from urllib.parse import quote
import anyio
from fastapi import APIRouter, Depends, Request
from fastapi.responses import StreamingResponse
from PIL import Image, UnidentifiedImageError
from sqlalchemy import select, func
from sqlalchemy.ext.asyncio import AsyncSession
from starlette.requests import ClientDisconnect
from .auth import current_user, get_session
from .errors import ApiError
from .http_utils import bad_request, parse_uuid
from .models import Attachment, ChatMember, User
from .routes import open_chat
from .schemas import AttachmentOut
from .storage import MAX_BYTES, StorageUnavailable, unavailable
from .timeutil import format_ts
router = APIRouter(prefix="/api/v1")
MAX_PIXELS = 40_000_000
Image.MAX_IMAGE_PIXELS = MAX_PIXELS
def attachment_out(row):
return {
"id": str(row.id), "chat_id": str(row.chat_id), "owner_id": str(row.owner_id),
"filename": row.filename, "content_type": row.content_type,
"size_bytes": row.size_bytes, "sha256": row.sha256,
"status": row.status,
"variants": [], "error_code": None, "created_at": format_ts(row.created_at),
"updated_at": format_ts(row.updated_at),
}
def validate_filename(value):
if value is None or not 1 <= len(value) <= 255 or not value.strip():
raise bad_request("filename: от 1 до 255 символов")
if any(char in "/\\" or unicodedata.category(char) in ("Cc", "Cs") for char in value):
raise bad_request("filename содержит путь или управляющие символы")
return value
def validate_image(stream, declared):
"""Check dimensions before decode; verify CRC and actually decode pixel data."""
try:
stream.seek(0)
with warnings.catch_warnings():
warnings.simplefilter("error", Image.DecompressionBombWarning)
with Image.open(stream, formats=["PNG", "JPEG"]) as image:
width, height = image.size
if width * height > MAX_PIXELS:
raise ApiError(413, "payload_too_large", "Изображение больше 40 млн пикселей")
actual = {"PNG": "image/png", "JPEG": "image/jpeg"}[image.format]
if actual != declared:
raise ApiError(415, "unsupported_media_type", "MIME не соответствует содержимому")
# Animated images are not part of the single-image upload contract.
if getattr(image, "n_frames", 1) != 1:
raise ApiError(415, "unsupported_media_type", "Нужно одно изображение")
image.verify()
stream.seek(0)
with Image.open(stream, formats=["PNG", "JPEG"]) as image:
image.load()
return width, height
except (Image.DecompressionBombWarning, Image.DecompressionBombError):
raise ApiError(413, "payload_too_large", "Изображение больше 40 млн пикселей") from None
except (UnidentifiedImageError, OSError, SyntaxError, ValueError, EOFError):
raise ApiError(415, "unsupported_media_type", "Повреждённый PNG/JPEG") from None
finally:
stream.seek(0)
async def save_attachment(session, storage, row, stream):
"""Commit intent BEFORE PUT; lock it until final ready commit.
On failure keep the intent. A cleanup worker rechecks its state after grace;
never delete blindly after an ambiguous COMMIT acknowledgement.
"""
session.add(row)
await session.commit()
try:
locked = (await session.execute(
select(Attachment.id).where(Attachment.id == row.id).with_for_update()
)).scalar_one_or_none()
if locked is None:
raise ApiError(409, "conflict", "Срок незавершённой загрузки истёк")
await anyio.to_thread.run_sync(storage.put, row.object_key, stream, row.size_bytes, row.content_type)
row.status = "ready"
row.updated_at = (await session.execute(select(func.clock_timestamp()))).scalar_one()
await session.commit()
except BaseException:
await session.rollback()
raise
return row
@router.post("/chats/{chat_id}/attachments", status_code=201, response_model=AttachmentOut)
async def upload(chat_id: str, request: Request, user: User = Depends(current_user),
session: AsyncSession = Depends(get_session)):
chat = await open_chat(session, user, chat_id)
filename = validate_filename(request.query_params.get("filename"))
declared = request.headers.get("content-type", "").split(";", 1)[0].strip().lower()
if declared not in ("image/png", "image/jpeg"):
raise ApiError(415, "unsupported_media_type", "Нужен Content-Type image/png или image/jpeg")
length = request.headers.get("content-length")
if length is not None and (not length.isascii() or not length.isdigit()):
raise bad_request("Некорректный Content-Length")
if length is not None and (len(length) > 20 or int(length) > MAX_BYTES):
raise ApiError(413, "payload_too_large", "Файл больше 10 MiB")
chat_uuid, owner_uuid = chat.id, user.id
# Do not hold a DB connection during the client's network upload or slot wait.
await session.rollback()
storage = request.app.state.storage
if storage is None:
raise unavailable()
try:
await asyncio.wait_for(request.app.state.upload_slots.acquire(), timeout=30)
except TimeoutError:
raise ApiError(503, "unavailable", "Все слоты загрузки заняты") from None
try:
with tempfile.TemporaryFile(mode="w+b") as stream:
size, checksum = 0, hashlib.sha256()
try:
async with asyncio.timeout(30):
async for chunk in request.stream():
size += len(chunk)
if size > MAX_BYTES:
raise ApiError(413, "payload_too_large", "Файл больше 10 MiB")
checksum.update(chunk)
stream.write(chunk)
except TimeoutError:
raise ApiError(408, "invalid_request", "Истекло время приёма файла") from None
except ClientDisconnect:
raise bad_request("Передача файла прервана") from None
if length is not None and int(length) != size:
raise bad_request("Неполное тело запроса")
async with request.app.state.decode_slot:
width, height = await anyio.to_thread.run_sync(validate_image, stream, declared)
row = Attachment(
id=uuid.uuid4(), chat_id=chat_uuid, owner_id=owner_uuid,
filename=filename, object_key="originals/" + uuid.uuid4().hex,
content_type=declared, size_bytes=size, sha256=checksum.hexdigest(),
width=width, height=height, status="uploading",
)
await save_attachment(session, storage, row, stream)
return attachment_out(row)
except StorageUnavailable:
raise unavailable() from None
finally:
request.app.state.upload_slots.release()
async def accessible_attachment(session, user, attachment_id):
ident = uuid.UUID(parse_uuid(attachment_id, "attachment_id"))
row = (await session.execute(
select(Attachment).join(ChatMember, ChatMember.chat_id == Attachment.chat_id)
.where(Attachment.id == ident, ChatMember.user_id == user.id)
)).scalar_one_or_none()
if row is None:
raise ApiError(404, "not_found", "Объект не найден")
if row.status != "ready":
raise ApiError(409, "conflict", "Вложение ещё не готово")
return row
@router.get("/attachments/{attachment_id}", response_model=AttachmentOut)
async def metadata(attachment_id: str, user: User = Depends(current_user),
session: AsyncSession = Depends(get_session)):
return attachment_out(await accessible_attachment(session, user, attachment_id))
@router.get("/attachments/{attachment_id}/content")
async def content(attachment_id: str, request: Request, user: User = Depends(current_user),
session: AsyncSession = Depends(get_session)):
row = await accessible_attachment(session, user, attachment_id)
if request.query_params.get("variant", "original") != "original":
raise ApiError(404, "not_found", "Вариант не найден")
key, mime, size, name = row.object_key, row.content_type, row.size_bytes, row.filename
await session.rollback()
storage = request.app.state.storage
if storage is None:
raise unavailable()
try:
response = await anyio.to_thread.run_sync(storage.get, key)
except StorageUnavailable:
raise unavailable() from None
async def chunks():
try:
while True:
chunk = await anyio.to_thread.run_sync(response.read, 64 * 1024)
if not chunk:
break
yield chunk
finally:
response.close()
response.release_conn()
return StreamingResponse(chunks(), media_type=mime, headers={
"Content-Length": str(size), "X-Content-Type-Options": "nosniff",
"Cache-Control": "private, no-store",
"Content-Disposition": "attachment; filename*=UTF-8''" + quote(name, safe=""),
})