Files
mtusi2026lab4/app/storage.py
T

950 lines
34 KiB
Python

import asyncio
import base64
from contextlib import asynccontextmanager
import datetime as dt
import hashlib
import json
import logging
import uuid
from typing import Any
import asyncpg
import redis.asyncio as redis
import io
import boto3
import botocore.exceptions
from PIL import Image
from app.auth import generate_session_token, hash_password, verify_password
from app.config import (
CACHE_URL,
DATABASE_URL,
SESSION_TTL_SECONDS,
S3_ENDPOINT,
S3_REGION,
S3_BUCKET,
S3_ACCESS_KEY_ID,
S3_SECRET_ACCESS_KEY,
MAX_UPLOAD_BYTES,
MAX_IMAGE_PIXELS,
)
from app.errors import (
ConflictError,
InvalidRequestError,
NotFoundError,
PayloadTooLargeError,
UnauthorizedError,
UnsupportedMediaTypeError,
)
from app.schemas import (
AttachmentResponse,
ChatResponse,
MessageResponse,
SessionResponse,
UserResponse,
VariantResponse,
now_utc_iso,
)
logger = logging.getLogger("app.storage")
def encode_cursor(data: dict) -> str:
raw = json.dumps(data, separators=(",", ":")).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("utf-8").rstrip("=")
def decode_cursor(cursor_str: str) -> dict:
if not isinstance(cursor_str, str) or not cursor_str.strip():
raise InvalidRequestError("Некорректный курсор")
try:
padded = cursor_str + "=" * (-len(cursor_str) % 4)
raw = base64.urlsafe_b64decode(padded.encode("utf-8"))
data = json.loads(raw.decode("utf-8"))
if not isinstance(data, dict):
raise InvalidRequestError("Некорректный курсор")
return data
except InvalidRequestError:
raise
except Exception as exc:
raise InvalidRequestError("Некорректный курсор") from exc
def _format_dt(d: dt.datetime) -> str:
if d.tzinfo is None:
d = d.replace(tzinfo=dt.timezone.utc)
return d.astimezone(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def _to_text(val: Any) -> str:
if isinstance(val, (bytes, bytearray, memoryview)):
return bytes(val).decode("utf-8")
return str(val)
class PostgresStorage:
def __init__(self) -> None:
self.pg_pool: asyncpg.Pool | None = None
self.redis_client: redis.Redis | None = None
self.s3_client: Any = None
@asynccontextmanager
async def acquire_conn(self, timeout: float = 2.0):
if self.pg_pool is None:
raise asyncpg.InterfaceError("Пул подключений к PostgreSQL не инициализирован")
async with asyncio.timeout(3.0):
async with self.pg_pool.acquire(timeout=timeout) as conn:
yield conn
async def connect(self) -> None:
logger.info("Подключение к PostgreSQL: %s", DATABASE_URL.split("@")[-1])
self.pg_pool = await asyncpg.create_pool(
DATABASE_URL,
min_size=2,
max_size=20,
command_timeout=3.0,
timeout=2.0,
)
logger.info("Подключение к Redis: %s", CACHE_URL.split("@")[-1])
self.redis_client = redis.from_url(
CACHE_URL,
decode_responses=True,
socket_connect_timeout=2.0,
socket_timeout=2.0,
)
logger.info("Подключение к S3 (MinIO): %s, bucket: %s", S3_ENDPOINT, S3_BUCKET)
self.s3_client = boto3.client(
"s3",
endpoint_url=S3_ENDPOINT,
aws_access_key_id=S3_ACCESS_KEY_ID,
aws_secret_access_key=S3_SECRET_ACCESS_KEY,
region_name=S3_REGION,
)
await self._ensure_bucket()
async def _ensure_bucket(self) -> None:
def _init():
try:
self.s3_client.head_bucket(Bucket=S3_BUCKET)
except Exception:
try:
self.s3_client.create_bucket(Bucket=S3_BUCKET)
logger.info("Создан приватный бакет S3: %s", S3_BUCKET)
except Exception as e:
logger.warning("Не удалось создать бакет S3 %s: %s", S3_BUCKET, e)
await asyncio.to_thread(_init)
async def disconnect(self) -> None:
if self.pg_pool:
await self.pg_pool.close()
self.pg_pool = None
if self.redis_client:
await self.redis_client.close()
self.redis_client = None
self.s3_client = None
async def check_health(self) -> bool:
if not self.pg_pool or not self.redis_client or not self.s3_client:
return False
try:
async with asyncio.timeout(2.5):
async with self.acquire_conn(timeout=1.5) as conn:
await conn.fetchval("SELECT 1")
await self.redis_client.ping()
await asyncio.to_thread(self.s3_client.head_bucket, Bucket=S3_BUCKET)
return True
except Exception as exc:
logger.warning("Ошибка проверки health: %s", exc)
return False
# ------------------ Пользователи и аутентификация ------------------
async def create_user(
self, username: str, display_name: str, password: str
) -> UserResponse:
user_id = uuid.uuid4()
now = dt.datetime.now(dt.timezone.utc)
pwd_hash = await asyncio.to_thread(hash_password, password)
try:
async with self.acquire_conn() as conn:
await conn.execute(
"""
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ($1, $2, $3, $4, $5)
""",
user_id,
username,
display_name,
pwd_hash,
now,
)
except asyncpg.UniqueViolationError:
raise ConflictError("Имя пользователя уже занято")
return UserResponse(
id=str(user_id),
username=username,
display_name=display_name,
created_at=_format_dt(now),
)
async def authenticate_user(
self, username: str, password: str
) -> UserResponse | None:
async with self.acquire_conn() as conn:
row = await conn.fetchrow(
"""
SELECT id, username, display_name, password_hash, created_at
FROM users
WHERE username = $1
""",
username,
)
if not row:
return None
is_valid = await asyncio.to_thread(verify_password, row["password_hash"], password)
if not is_valid:
return None
return UserResponse(
id=str(row["id"]),
username=row["username"],
display_name=_to_text(row["display_name"]),
created_at=_format_dt(row["created_at"]),
)
async def get_user_by_id(self, user_id: str) -> UserResponse | None:
try:
uid = uuid.UUID(user_id)
except ValueError:
return None
async with self.acquire_conn() as conn:
row = await conn.fetchrow(
"""
SELECT id, username, display_name, created_at
FROM users
WHERE id = $1
""",
uid,
)
if not row:
return None
return UserResponse(
id=str(row["id"]),
username=row["username"],
display_name=_to_text(row["display_name"]),
created_at=_format_dt(row["created_at"]),
)
# ------------------ Сессии (Redis) ------------------
async def create_session(self, user: UserResponse) -> SessionResponse:
assert self.redis_client is not None
token = generate_session_token()
now = dt.datetime.now(dt.timezone.utc)
expires_at = now + dt.timedelta(seconds=SESSION_TTL_SECONDS)
expires_at_str = _format_dt(expires_at)
session_data = json.dumps(
{
"user_id": user.id,
"expires_at": expires_at_str,
}
)
key = f"session:{token}"
await self.redis_client.set(key, session_data, ex=SESSION_TTL_SECONDS)
return SessionResponse(
token=token,
token_type="Bearer",
expires_at=expires_at_str,
user=user,
)
async def get_session_user(self, token: str) -> UserResponse | None:
if not token or not self.redis_client:
return None
key = f"session:{token}"
raw = await self.redis_client.get(key)
if not raw:
return None
try:
data = json.loads(raw)
user_id = data.get("user_id")
except Exception:
return None
if not user_id:
return None
return await self.get_user_by_id(user_id)
async def delete_session(self, token: str) -> bool:
if not token or not self.redis_client:
return False
key = f"session:{token}"
res = await self.redis_client.delete(key)
return res > 0
# ------------------ Чаты ------------------
async def create_chat(
self, caller_id: str, title: str, member_ids: list[str]
) -> ChatResponse:
if caller_id not in member_ids:
raise InvalidRequestError("Создатель чата должен быть в списке участников")
chat_id = uuid.uuid4()
now = dt.datetime.now(dt.timezone.utc)
member_uuids = [uuid.UUID(m) for m in member_ids]
async with self.acquire_conn() as conn:
# Проверяем существование всех участников
found = await conn.fetch(
"SELECT id FROM users WHERE id = ANY($1::uuid[])", member_uuids
)
if len(found) != len(member_uuids):
raise InvalidRequestError(
"Один или несколько участников чата не найдены"
)
async with conn.transaction():
await conn.execute(
"INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)",
chat_id,
title,
now,
)
member_records = [(chat_id, m) for m in member_uuids]
await conn.executemany(
"INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)",
member_records,
)
return ChatResponse(
id=str(chat_id),
title=title,
member_ids=member_ids,
created_at=_format_dt(now),
)
async def get_chat(self, caller_id: str, chat_id: str) -> ChatResponse:
try:
cid = uuid.UUID(chat_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Чат не найден")
async with self.acquire_conn() as conn:
# Проверяем членство вызывающего
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
cid,
c_caller,
)
if not is_member:
raise NotFoundError("Чат не найден")
chat_row = await conn.fetchrow(
"SELECT id, title, created_at FROM chats WHERE id = $1", cid
)
if not chat_row:
raise NotFoundError("Чат не найден")
members_rows = await conn.fetch(
"SELECT user_id FROM chat_members WHERE chat_id = $1", cid
)
member_ids = [str(r["user_id"]) for r in members_rows]
return ChatResponse(
id=str(chat_row["id"]),
title=_to_text(chat_row["title"]),
member_ids=member_ids,
created_at=_format_dt(chat_row["created_at"]),
)
async def list_chats(
self, caller_id: str, limit: int = 50, cursor: str | None = None
) -> tuple[list[ChatResponse], str | None]:
try:
c_caller = uuid.UUID(caller_id)
except ValueError:
return [], None
c_created: dt.datetime | None = None
c_id: uuid.UUID | None = None
if cursor is not None:
c_data = decode_cursor(cursor)
if c_data.get("type") != "chats":
raise InvalidRequestError("Недействительный тип курсора")
c_created_str = c_data.get("created_at")
c_id_str = c_data.get("id")
if (
not isinstance(c_created_str, str)
or not isinstance(c_id_str, str)
or not c_created_str.strip()
or not c_id_str.strip()
):
raise InvalidRequestError("Поврежденный курсор")
try:
c_created = dt.datetime.fromisoformat(
c_created_str.replace("Z", "+00:00")
)
c_id = uuid.UUID(c_id_str)
except Exception:
raise InvalidRequestError("Некорректные параметры курсора")
async with self.acquire_conn() as conn:
query = """
SELECT c.id, c.title, c.created_at, array_agg(cm.user_id::text) as member_ids
FROM chats c
JOIN chat_members my_m ON c.id = my_m.chat_id AND my_m.user_id = $1
JOIN chat_members cm ON c.id = cm.chat_id
WHERE ($2::timestamptz IS NULL OR (c.created_at, c.id) > ($2::timestamptz, $3::uuid))
GROUP BY c.id, c.title, c.created_at
ORDER BY c.created_at ASC, c.id ASC
LIMIT $4
"""
rows = await conn.fetch(query, c_caller, c_created, c_id, limit + 1)
has_next = len(rows) > limit
items_rows = rows[:limit]
items = [
ChatResponse(
id=str(r["id"]),
title=_to_text(r["title"]),
member_ids=list(r["member_ids"]),
created_at=_format_dt(r["created_at"]),
)
for r in items_rows
]
next_cursor = None
if has_next and items:
last = items[-1]
next_cursor = encode_cursor(
{
"type": "chats",
"created_at": last.created_at,
"id": last.id,
}
)
return items, next_cursor
# ------------------ Сообщения ------------------
@staticmethod
def compute_request_hash(text: str, attachment_ids: list[str] | None = None) -> str:
norm_attachments = [str(x) for x in (attachment_ids or [])]
canonical = json.dumps(
{"attachment_ids": norm_attachments, "text": text},
sort_keys=True,
ensure_ascii=False,
)
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
async def send_message(
self,
caller_id: str,
chat_id: str,
text: str,
idempotency_key: str,
attachment_ids: list[str] | None = None,
) -> MessageResponse:
try:
cid = uuid.UUID(chat_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Чат не найден")
norm_attachments = [str(x) for x in (attachment_ids or [])]
req_hash = self.compute_request_hash(text, norm_attachments)
async with self.acquire_conn() as conn:
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
cid,
c_caller,
)
if not is_member:
raise NotFoundError("Чат не найден")
# Валидация прикрепляемых вложений
att_uuids: list[uuid.UUID] = []
if norm_attachments:
for att_str in norm_attachments:
try:
att_uuids.append(uuid.UUID(att_str))
except ValueError:
raise NotFoundError("Вложение не найдено")
rows = await conn.fetch(
"SELECT id, chat_id, status FROM attachments WHERE id = ANY($1::uuid[])",
att_uuids,
)
if len(rows) != len(att_uuids):
raise NotFoundError("Одно или несколько вложений не найдены")
for r in rows:
if r["chat_id"] != cid:
raise NotFoundError("Вложение принадлежит другому чату")
if r["status"] != "ready":
raise ConflictError("Вложение еще не готово или повреждено")
# 1. Проверяем, обрабатывался ли уже этот idempotency_key
existing = await conn.fetchrow(
"""
SELECT ik.message_id, ik.request_hash, m.text, m.attachment_ids, m.created_at AS msg_created_at
FROM idempotency_keys ik
JOIN messages m ON m.id = ik.message_id
WHERE ik.user_id = $1 AND ik.chat_id = $2 AND ik.idempotency_key = $3
""",
c_caller,
cid,
idempotency_key,
)
if existing:
if existing["request_hash"] == req_hash:
raw_text = existing["text"]
msg_text = (
raw_text.decode("utf-8")
if isinstance(raw_text, (bytes, bytearray))
else str(raw_text)
)
res_attachments = [
str(a) for a in (existing["attachment_ids"] or [])
]
return MessageResponse(
id=str(existing["message_id"]),
chat_id=chat_id,
sender_id=caller_id,
text=msg_text,
attachment_ids=res_attachments,
created_at=_format_dt(existing["msg_created_at"]),
)
else:
raise ConflictError("Ключ идемпотентности уже использован с другим телом запроса")
msg_id = uuid.uuid4()
now = dt.datetime.now(dt.timezone.utc)
text_bytes = text.encode("utf-8")
try:
async with conn.transaction():
await conn.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text, attachment_ids, created_at)
VALUES ($1, $2, $3, $4, $5, $6)
""",
msg_id,
cid,
c_caller,
text_bytes,
att_uuids,
now,
)
await conn.execute(
"""
INSERT INTO idempotency_keys (user_id, chat_id, idempotency_key, message_id, request_hash, created_at)
VALUES ($1, $2, $3, $4, $5, $6)
""",
c_caller,
cid,
idempotency_key,
msg_id,
req_hash,
now,
)
except asyncpg.UniqueViolationError:
winner = await conn.fetchrow(
"""
SELECT ik.message_id, ik.request_hash, m.text, m.attachment_ids, m.created_at AS msg_created_at
FROM idempotency_keys ik
JOIN messages m ON m.id = ik.message_id
WHERE ik.user_id = $1 AND ik.chat_id = $2 AND ik.idempotency_key = $3
""",
c_caller,
cid,
idempotency_key,
)
if winner:
if winner["request_hash"] == req_hash:
raw_text = winner["text"]
msg_text = (
raw_text.decode("utf-8")
if isinstance(raw_text, (bytes, bytearray))
else str(raw_text)
)
res_attachments = [
str(a) for a in (winner["attachment_ids"] or [])
]
return MessageResponse(
id=str(winner["message_id"]),
chat_id=chat_id,
sender_id=caller_id,
text=msg_text,
attachment_ids=res_attachments,
created_at=_format_dt(winner["msg_created_at"]),
)
else:
raise ConflictError("Ключ идемпотентности уже использован с другим телом запроса")
raise
return MessageResponse(
id=str(msg_id),
chat_id=chat_id,
sender_id=caller_id,
text=text,
attachment_ids=norm_attachments,
created_at=_format_dt(now),
)
async def list_messages(
self, caller_id: str, chat_id: str, limit: int = 50, cursor: str | None = None
) -> tuple[list[MessageResponse], str | None]:
try:
cid = uuid.UUID(chat_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Чат не найден")
async with self.acquire_conn() as conn:
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
cid,
c_caller,
)
if not is_member:
raise NotFoundError("Чат не найден")
c_created: dt.datetime | None = None
c_id: uuid.UUID | None = None
if cursor is not None:
c_data = decode_cursor(cursor)
if c_data.get("type") != "messages" or c_data.get("chat_id") != chat_id:
raise InvalidRequestError(
"Курсор принадлежит другому чату или недействителен"
)
c_created_str = c_data.get("created_at")
c_id_str = c_data.get("id")
if (
not isinstance(c_created_str, str)
or not isinstance(c_id_str, str)
or not c_created_str.strip()
or not c_id_str.strip()
):
raise InvalidRequestError("Поврежденный курсор")
try:
c_created = dt.datetime.fromisoformat(
c_created_str.replace("Z", "+00:00")
)
c_id = uuid.UUID(c_id_str)
except Exception:
raise InvalidRequestError("Некорректные параметры курсора")
query = """
SELECT id, chat_id, sender_id, text, attachment_ids, created_at
FROM messages
WHERE chat_id = $1
AND ($2::timestamptz IS NULL OR (created_at, id) > ($2::timestamptz, $3::uuid))
ORDER BY created_at ASC, id ASC
LIMIT $4
"""
rows = await conn.fetch(query, cid, c_created, c_id, limit + 1)
has_next = len(rows) > limit
items_rows = rows[:limit]
def _to_text(val: Any) -> str:
if isinstance(val, (bytes, bytearray, memoryview)):
return bytes(val).decode("utf-8")
return str(val)
items = [
MessageResponse(
id=str(r["id"]),
chat_id=str(r["chat_id"]),
sender_id=str(r["sender_id"]),
text=_to_text(r["text"]),
attachment_ids=[str(a) for a in (r["attachment_ids"] or [])],
created_at=_format_dt(r["created_at"]),
)
for r in items_rows
]
next_cursor = None
if has_next and items:
last = items[-1]
next_cursor = encode_cursor(
{
"type": "messages",
"chat_id": chat_id,
"created_at": last.created_at,
"id": last.id,
}
)
return items, next_cursor
# ------------------ Вложения (Attachments) ------------------
async def upload_attachment(
self,
caller_id: str,
chat_id: str,
filename: str,
content_type: str,
data: bytes,
) -> AttachmentResponse:
try:
cid = uuid.UUID(chat_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Чат не найден")
# 1. Валидация filename
if not filename or len(filename) > 255:
raise InvalidRequestError("Некорректная длина имени файла (1-255 символов)")
if any(c in filename for c in ("/", "\\", "\0")) or any(
ord(c) < 32 for c in filename
):
raise InvalidRequestError("Имя файла содержит недопустимые символы")
# 2. Проверка прав (ACL)
async with self.acquire_conn() as conn:
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
cid,
c_caller,
)
if not is_member:
raise NotFoundError("Чат не найден")
# 3. Валидация Content-Type
ct_clean = content_type.split(";")[0].strip().lower()
if ct_clean not in ("image/png", "image/jpeg"):
raise UnsupportedMediaTypeError(
"Поддерживаются только форматы image/png и image/jpeg"
)
# 4. Валидация размера данных
size_bytes = len(data)
if size_bytes > MAX_UPLOAD_BYTES:
raise PayloadTooLargeError(
f"Размер файла {size_bytes} байт превышает допустимый лимит {MAX_UPLOAD_BYTES} байт"
)
# 5. Проверка магических байтов (сигнатуры MIME)
if ct_clean == "image/png":
if not data.startswith(b"\x89PNG\r\n\x1a\n"):
raise UnsupportedMediaTypeError("Содержимое файла не соответствует формату PNG")
elif ct_clean == "image/jpeg":
if not (data.startswith(b"\xff\xd8\xff")):
raise UnsupportedMediaTypeError("Содержимое файла не соответствует формату JPEG")
# 6. Проверка разрешения (лимит 40 млн пикселей) и целостности растра
def _check_dimensions():
try:
with Image.open(io.BytesIO(data)) as img:
w, h = img.size
if w * h > MAX_IMAGE_PIXELS:
return False
# Проверяем целостность растровых данных и фильтров строк:
img.load()
return True
except Exception:
raise UnsupportedMediaTypeError("Поврежденное изображение")
try:
within_limits = await asyncio.to_thread(_check_dimensions)
if not within_limits:
raise PayloadTooLargeError(
f"Разрешение изображения превышает лимит {MAX_IMAGE_PIXELS} пикселей"
)
except (UnsupportedMediaTypeError, PayloadTooLargeError):
raise
except Exception as e:
logger.warning("upload_attachment check_dimensions unexpected: %s (%s)", type(e), e)
raise UnsupportedMediaTypeError("Поврежденное изображение") from e
# 7. Генерация идентификаторов
att_id = uuid.uuid4()
s3_key = f"chats/{chat_id}/{att_id}/{filename}"
sha256_hash = hashlib.sha256(data).hexdigest()
now = dt.datetime.now(dt.timezone.utc)
# 8. Загрузка файла в S3
def _put_to_s3():
self.s3_client.put_object(
Bucket=S3_BUCKET,
Key=s3_key,
Body=data,
ContentType=ct_clean,
)
await asyncio.to_thread(_put_to_s3)
# 9. Сохранение метаданных в PostgreSQL (с компенсацией удаления из S3 при ошибке)
try:
async with self.acquire_conn() as conn:
await conn.execute(
"""
INSERT INTO attachments (
id, chat_id, owner_id, filename, content_type,
size_bytes, sha256, s3_key, status, error_code,
created_at, updated_at
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'ready', NULL, $9, $9)
""",
att_id,
cid,
c_caller,
filename,
ct_clean,
size_bytes,
sha256_hash,
s3_key,
now,
)
except Exception as db_err:
logger.error("Ошибка записи метаданных в БД, компенсация S3: %s", db_err)
try:
await asyncio.to_thread(
self.s3_client.delete_object, Bucket=S3_BUCKET, Key=s3_key
)
except Exception as del_err:
logger.error("Ошибка удаления S3 объекта при компенсации: %s", del_err)
raise
return AttachmentResponse(
id=str(att_id),
chat_id=str(cid),
owner_id=str(c_caller),
filename=filename,
content_type=ct_clean,
size_bytes=size_bytes,
sha256=sha256_hash,
status="ready",
variants=[],
error_code=None,
created_at=_format_dt(now),
updated_at=_format_dt(now),
)
async def get_attachment(
self, caller_id: str, attachment_id: str
) -> AttachmentResponse:
try:
aid = uuid.UUID(attachment_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Вложение не найдено")
async with self.acquire_conn() as conn:
row = await conn.fetchrow(
"""
SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type,
a.size_bytes, a.sha256, a.status, a.error_code, a.created_at, a.updated_at
FROM attachments a
WHERE a.id = $1
""",
aid,
)
if not row:
raise NotFoundError("Вложение не найдено")
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
row["chat_id"],
c_caller,
)
if not is_member:
raise NotFoundError("Вложение не найдено")
return AttachmentResponse(
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=row["error_code"],
created_at=_format_dt(row["created_at"]),
updated_at=_format_dt(row["updated_at"]),
)
async def get_attachment_content(
self, caller_id: str, attachment_id: str, variant: str | None = None
) -> tuple[bytes, str]:
try:
aid = uuid.UUID(attachment_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Вложение не найдено")
if variant not in (None, "", "original"):
raise NotFoundError("Вариант не найден")
async with self.acquire_conn() as conn:
row = await conn.fetchrow(
"""
SELECT a.chat_id, a.content_type, a.s3_key, a.status
FROM attachments a
WHERE a.id = $1
""",
aid,
)
if not row:
raise NotFoundError("Вложение не найдено")
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
row["chat_id"],
c_caller,
)
if not is_member:
raise NotFoundError("Вложение не найдено")
if row["status"] != "ready":
raise ConflictError("Вложение повреждено или еще не готово")
s3_key = row["s3_key"]
content_type = row["content_type"]
def _get_from_s3():
resp = self.s3_client.get_object(Bucket=S3_BUCKET, Key=s3_key)
return resp["Body"].read()
try:
data = await asyncio.to_thread(_get_from_s3)
except Exception as e:
logger.error("Ошибка чтения объекта из S3 %s: %s", s3_key, e)
raise NotFoundError("Файл не найден в хранилище") from e
return data, content_type
# Глобальный экземпляр хранилища
storage = PostgresStorage()