151 lines
5.8 KiB
Python
151 lines
5.8 KiB
Python
"""S3-клиент (MinIO) и потоковая валидация изображений.
|
|
|
|
Потоковая загрузка: читаем тело запроса чанками, считаем SHA-256 и размер,
|
|
не держим весь файл в памяти. MIME определяем по magic bytes, пиксели —
|
|
через Pillow с защитой от decompression bomb.
|
|
"""
|
|
import hashlib
|
|
import io
|
|
import logging
|
|
import uuid
|
|
from typing import BinaryIO
|
|
|
|
import boto3
|
|
from botocore.client import Config as BotoConfig
|
|
from botocore.exceptions import BotoCoreError, ClientError
|
|
from PIL import Image, UnidentifiedImageError
|
|
|
|
from .config import settings
|
|
from .errors import ApiError
|
|
|
|
logger = logging.getLogger("messenger.s3")
|
|
|
|
PNG_MAGIC = b"\x89PNG\r\n\x1a\n"
|
|
JPEG_MAGIC = b"\xff\xd8\xff"
|
|
|
|
|
|
def _client():
|
|
return boto3.client(
|
|
"s3",
|
|
endpoint_url=settings.s3_endpoint,
|
|
region_name=settings.s3_region,
|
|
aws_access_key_id=settings.s3_access_key_id,
|
|
aws_secret_access_key=settings.s3_secret_access_key,
|
|
use_ssl=settings.s3_use_ssl,
|
|
config=BotoConfig(signature_version="s3v4", s3={"addressing_style": "path"}),
|
|
)
|
|
|
|
|
|
def ensure_bucket() -> None:
|
|
"""Идемпотентно создаёт bucket, если его нет."""
|
|
client = _client()
|
|
try:
|
|
client.head_bucket(Bucket=settings.s3_bucket)
|
|
except ClientError as exc:
|
|
code = exc.response.get("Error", {}).get("Code", "")
|
|
if code in ("404", "NoSuchBucket", "NotFound"):
|
|
client.create_bucket(Bucket=settings.s3_bucket)
|
|
logger.info("created bucket %s", settings.s3_bucket)
|
|
else:
|
|
raise
|
|
|
|
|
|
def new_object_key(chat_id: str, attachment_id: str) -> str:
|
|
"""Случайный ключ; filename не используется как путь."""
|
|
return f"chats/{chat_id}/{attachment_id}/{uuid.uuid4().hex}"
|
|
|
|
|
|
def _detect_mime(head: bytes) -> str | None:
|
|
if head.startswith(PNG_MAGIC):
|
|
return "image/png"
|
|
if head.startswith(JPEG_MAGIC):
|
|
return "image/jpeg"
|
|
return None
|
|
|
|
|
|
def _validate_image(data: bytes, declared_mime: str) -> str:
|
|
"""Проверяет magic bytes, декодирует заголовок, считает пиксели.
|
|
|
|
Возвращает фактический MIME. Бросает ApiError(415/413).
|
|
"""
|
|
actual = _detect_mime(data[:16])
|
|
if actual is None:
|
|
raise ApiError(415, "unsupported_media_type", "Поддерживаются только PNG и JPEG")
|
|
if actual != declared_mime:
|
|
raise ApiError(415, "unsupported_media_type", "Content-Type не совпадает с содержимым")
|
|
try:
|
|
with Image.open(io.BytesIO(data)) as img:
|
|
width, height = img.size
|
|
except (UnidentifiedImageError, OSError):
|
|
raise ApiError(415, "unsupported_media_type", "Повреждённое изображение")
|
|
if width <= 0 or height <= 0:
|
|
raise ApiError(415, "unsupported_media_type", "Повреждённое изображение")
|
|
if width * height > settings.max_image_pixels:
|
|
raise ApiError(413, "payload_too_large", "Слишком много пикселей")
|
|
return actual
|
|
|
|
|
|
def read_upload(stream: BinaryIO, declared_mime: str) -> tuple[bytes, str, str]:
|
|
"""Читает поток с лимитом, возвращает (bytes, sha256, actual_mime).
|
|
|
|
Файл ≤10 MiB, поэтому держим его в памяти — это упрощает валидацию
|
|
и не создаёт неограниченного потребления RAM (лимит жёсткий).
|
|
"""
|
|
limit = settings.max_upload_bytes
|
|
buf = bytearray()
|
|
hasher = hashlib.sha256()
|
|
while True:
|
|
chunk = stream.read(settings.upload_chunk_size)
|
|
if not chunk:
|
|
break
|
|
buf.extend(chunk)
|
|
hasher.update(chunk)
|
|
if len(buf) > limit:
|
|
raise ApiError(413, "payload_too_large", "Файл больше 10 MiB")
|
|
if not buf:
|
|
raise ApiError(400, "invalid_request", "Пустое тело запроса")
|
|
data = bytes(buf)
|
|
actual = _validate_image(data, declared_mime)
|
|
return data, hasher.hexdigest(), actual
|
|
|
|
|
|
def put_object(key: str, data: bytes, content_type: str) -> None:
|
|
client = _client()
|
|
try:
|
|
client.put_object(
|
|
Bucket=settings.s3_bucket,
|
|
Key=key,
|
|
Body=data,
|
|
ContentType=content_type,
|
|
)
|
|
except (BotoCoreError, ClientError) as exc:
|
|
logger.error("s3 put failed: %s", type(exc).__name__)
|
|
raise ApiError(503, "unavailable", "Хранилище недоступно")
|
|
|
|
|
|
def get_object(key: str) -> tuple[bytes, str]:
|
|
client = _client()
|
|
try:
|
|
resp = client.get_object(Bucket=settings.s3_bucket, Key=key)
|
|
body = resp["Body"].read()
|
|
ctype = resp.get("ContentType") or "application/octet-stream"
|
|
return body, ctype
|
|
except ClientError as exc:
|
|
code = exc.response.get("Error", {}).get("Code", "")
|
|
if code in ("NoSuchKey", "404", "NotFound"):
|
|
raise ApiError(404, "not_found", "Объект не найден")
|
|
logger.error("s3 get failed: %s", type(exc).__name__)
|
|
raise ApiError(503, "unavailable", "Хранилище недоступно")
|
|
except BotoCoreError as exc:
|
|
logger.error("s3 get failed: %s", type(exc).__name__)
|
|
raise ApiError(503, "unavailable", "Хранилище недоступно")
|
|
|
|
|
|
def delete_object(key: str) -> None:
|
|
"""Best-effort удаление для компенсации при сбое между S3 и БД."""
|
|
client = _client()
|
|
try:
|
|
client.delete_object(Bucket=settings.s3_bucket, Key=key)
|
|
except (BotoCoreError, ClientError) as exc:
|
|
logger.warning("s3 delete failed: %s", type(exc).__name__)
|