forked from mtusi2026/mtusi2026lab4
793 lines
30 KiB
Python
793 lines
30 KiB
Python
"""Users, sessions, chats, messages, and synchronous attachment upload."""
|
|
|
|
import base64
|
|
import hashlib
|
|
import json
|
|
import logging
|
|
import os
|
|
import re
|
|
import secrets
|
|
import tempfile
|
|
import uuid
|
|
from datetime import datetime, timezone
|
|
|
|
import asyncpg
|
|
from argon2 import PasswordHasher
|
|
from argon2.exceptions import VerifyMismatchError, VerificationError, InvalidHashError
|
|
|
|
from app.config import Settings
|
|
from app.db import pool
|
|
from app.errors import ApiError, unauthorized
|
|
from app.images import validate_image
|
|
from app import s3client
|
|
|
|
logger = logging.getLogger("messenger")
|
|
|
|
_HASHER = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
|
|
_DUMMY_HASH = _HASHER.hash("timing-only-not-a-login-secret")
|
|
_USERNAME = re.compile(r"^[a-z0-9_]{3,32}$")
|
|
_IDEMPOTENCY = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
|
|
_CONTROLS = set(range(32))
|
|
|
|
|
|
def iso(value: datetime) -> str:
|
|
if value.tzinfo is None:
|
|
value = value.replace(tzinfo=timezone.utc)
|
|
else:
|
|
value = value.astimezone(timezone.utc)
|
|
return value.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
|
|
|
|
|
|
def parse_iso(value: str) -> datetime:
|
|
if not isinstance(value, str) or not value.endswith("Z"):
|
|
raise ValueError("timestamp")
|
|
return datetime.fromisoformat(value[:-1] + "+00:00")
|
|
|
|
|
|
def parse_uuid(value: str) -> str:
|
|
try:
|
|
return str(uuid.UUID(str(value)))
|
|
except (ValueError, AttributeError, TypeError) as exc:
|
|
raise ApiError(400, "invalid_request", "Некорректный идентификатор") from exc
|
|
|
|
|
|
def _code_points(value: str) -> int:
|
|
return len(value)
|
|
|
|
|
|
def _require_object(data, allowed: set[str], required: set[str]) -> None:
|
|
if not isinstance(data, dict):
|
|
raise ApiError(400, "invalid_request", "Ожидается JSON-объект")
|
|
extra = set(data) - allowed
|
|
if extra:
|
|
raise ApiError(400, "invalid_request", "Неизвестные поля")
|
|
missing = required - set(data)
|
|
if missing:
|
|
raise ApiError(400, "invalid_request", "Отсутствуют обязательные поля")
|
|
|
|
|
|
def _nonblank(value: str) -> bool:
|
|
return value.strip() != ""
|
|
|
|
|
|
def _lock_keys(scope: str) -> tuple[int, int]:
|
|
digest = hashlib.sha256(scope.encode("utf-8")).digest()
|
|
return int.from_bytes(digest[0:4], "big") & 0x7FFFFFFF, int.from_bytes(digest[4:8], "big") & 0x7FFFFFFF
|
|
|
|
|
|
def _cursor_encode(payload: dict) -> str:
|
|
raw = json.dumps(payload, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
|
|
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
|
|
|
|
|
|
def _cursor_decode(raw: str) -> dict:
|
|
if not isinstance(raw, str) or raw == "":
|
|
raise ApiError(400, "invalid_request", "Некорректный cursor")
|
|
padding = "=" * (-len(raw) % 4)
|
|
try:
|
|
data = json.loads(base64.urlsafe_b64decode(raw + padding).decode("utf-8"))
|
|
except (ValueError, UnicodeError, json.JSONDecodeError) as exc:
|
|
raise ApiError(400, "invalid_request", "Некорректный cursor") from exc
|
|
if not isinstance(data, dict):
|
|
raise ApiError(400, "invalid_request", "Некорректный cursor")
|
|
return data
|
|
|
|
|
|
def user_dict(row) -> dict:
|
|
return {
|
|
"id": str(row["id"]),
|
|
"username": row["username"],
|
|
"display_name": row["display_name"],
|
|
"created_at": iso(row["created_at"]),
|
|
}
|
|
|
|
|
|
def message_dict(row, attachment_ids: list[str]) -> dict:
|
|
return {
|
|
"id": str(row["id"]),
|
|
"chat_id": str(row["chat_id"]),
|
|
"sender_id": str(row["sender_id"]),
|
|
"text": row["text"],
|
|
"created_at": iso(row["created_at"]),
|
|
"attachment_ids": attachment_ids,
|
|
}
|
|
|
|
|
|
def attachment_dict(row) -> dict:
|
|
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": iso(row["created_at"]),
|
|
"updated_at": iso(row["updated_at"]),
|
|
}
|
|
|
|
|
|
async def _attachments_for(conn, message_ids: list) -> dict[str, list[str]]:
|
|
grouped: dict[str, list[str]] = {str(item): [] for item in message_ids}
|
|
if not message_ids:
|
|
return grouped
|
|
rows = await conn.fetch(
|
|
"""
|
|
SELECT message_id, attachment_id
|
|
FROM message_attachments
|
|
WHERE message_id = ANY($1::uuid[])
|
|
ORDER BY message_id, position
|
|
""",
|
|
message_ids,
|
|
)
|
|
for row in rows:
|
|
grouped.setdefault(str(row["message_id"]), []).append(str(row["attachment_id"]))
|
|
return grouped
|
|
|
|
|
|
async def _members_for(conn, chat_ids: list) -> dict[str, list[str]]:
|
|
grouped: dict[str, list[str]] = {str(item): [] for item in chat_ids}
|
|
if not chat_ids:
|
|
return grouped
|
|
rows = await conn.fetch(
|
|
"""
|
|
SELECT chat_id, user_id
|
|
FROM chat_members
|
|
WHERE chat_id = ANY($1::uuid[])
|
|
ORDER BY chat_id, position
|
|
""",
|
|
chat_ids,
|
|
)
|
|
for row in rows:
|
|
grouped.setdefault(str(row["chat_id"]), []).append(str(row["user_id"]))
|
|
return grouped
|
|
|
|
|
|
def chat_dict(row, member_ids: list[str]) -> dict:
|
|
return {
|
|
"id": str(row["id"]),
|
|
"title": row["title"],
|
|
"member_ids": member_ids,
|
|
"created_at": iso(row["created_at"]),
|
|
}
|
|
|
|
|
|
async def register_user(body: dict) -> dict:
|
|
_require_object(body, {"username", "display_name", "password"}, {"username", "display_name", "password"})
|
|
username = body["username"]
|
|
display_name = body["display_name"]
|
|
password = body["password"]
|
|
if not isinstance(username, str) or _USERNAME.fullmatch(username) is None:
|
|
raise ApiError(400, "invalid_request", "Некорректное имя пользователя")
|
|
if not isinstance(display_name, str) or not _nonblank(display_name) or _code_points(display_name) > 100:
|
|
raise ApiError(400, "invalid_request", "Некорректное отображаемое имя")
|
|
if not isinstance(password, str) or not (12 <= _code_points(password) <= 128) or "\x00" in password:
|
|
raise ApiError(400, "invalid_request", "Некорректный пароль")
|
|
password_hash = _HASHER.hash(password)
|
|
try:
|
|
row = await pool().fetchrow(
|
|
"""
|
|
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
|
VALUES ($1, $2, $3, $4, clock_timestamp())
|
|
RETURNING id, username, display_name, created_at
|
|
""",
|
|
uuid.uuid4(),
|
|
username,
|
|
display_name,
|
|
password_hash,
|
|
)
|
|
except asyncpg.UniqueViolationError as exc:
|
|
raise ApiError(409, "conflict", "Имя пользователя занято") from exc
|
|
return user_dict(row)
|
|
|
|
|
|
async def create_session(username: str, password: str, settings: Settings) -> dict:
|
|
if not isinstance(username, str) or _USERNAME.fullmatch(username) is None:
|
|
raise unauthorized("basic")
|
|
if not isinstance(password, str) or "\x00" in password:
|
|
raise unauthorized("basic")
|
|
row = await pool().fetchrow(
|
|
"""
|
|
SELECT id, username, display_name, created_at, password_hash
|
|
FROM users
|
|
WHERE username = $1
|
|
""",
|
|
username,
|
|
)
|
|
if row is None:
|
|
try:
|
|
_HASHER.verify(_DUMMY_HASH, password)
|
|
except (VerifyMismatchError, VerificationError, InvalidHashError):
|
|
pass
|
|
raise unauthorized("basic")
|
|
try:
|
|
ok = _HASHER.verify(row["password_hash"], password)
|
|
except (VerifyMismatchError, VerificationError, InvalidHashError):
|
|
ok = False
|
|
if not ok:
|
|
raise unauthorized("basic")
|
|
token = secrets.token_urlsafe(32)
|
|
token_hash = hashlib.sha256(token.encode("utf-8")).hexdigest()
|
|
expires = await pool().fetchval(
|
|
"""
|
|
INSERT INTO sessions (token_hash, user_id, expires_at)
|
|
VALUES ($1, $2, clock_timestamp() + make_interval(secs => $3::int))
|
|
RETURNING expires_at
|
|
""",
|
|
token_hash,
|
|
row["id"],
|
|
settings.session_ttl_seconds,
|
|
)
|
|
return {
|
|
"token": token,
|
|
"token_type": "Bearer",
|
|
"expires_at": iso(expires),
|
|
"user": user_dict(row),
|
|
}
|
|
|
|
|
|
async def authenticate(token: str) -> dict:
|
|
if not token:
|
|
raise unauthorized("bearer")
|
|
token_hash = hashlib.sha256(token.encode("utf-8")).hexdigest()
|
|
row = await pool().fetchrow(
|
|
"""
|
|
SELECT u.id, u.username, u.display_name, u.created_at
|
|
FROM sessions s
|
|
JOIN users u ON u.id = s.user_id
|
|
WHERE s.token_hash = $1
|
|
AND s.revoked_at IS NULL
|
|
AND s.expires_at > clock_timestamp()
|
|
""",
|
|
token_hash,
|
|
)
|
|
if row is None:
|
|
raise unauthorized("bearer")
|
|
return user_dict(row)
|
|
|
|
|
|
async def revoke_session(token: str) -> None:
|
|
token_hash = hashlib.sha256(token.encode("utf-8")).hexdigest()
|
|
await pool().execute(
|
|
"""
|
|
UPDATE sessions
|
|
SET revoked_at = clock_timestamp()
|
|
WHERE token_hash = $1 AND revoked_at IS NULL
|
|
""",
|
|
token_hash,
|
|
)
|
|
|
|
|
|
async def create_chat(user_id: str, body: dict) -> dict:
|
|
_require_object(body, {"title", "member_ids"}, {"title", "member_ids"})
|
|
title = body["title"]
|
|
member_ids = body["member_ids"]
|
|
if not isinstance(title, str) or not _nonblank(title) or _code_points(title) > 100 or "\x00" in title:
|
|
raise ApiError(400, "invalid_request", "Некорректное название чата")
|
|
if not isinstance(member_ids, list) or not (1 <= len(member_ids) <= 100):
|
|
raise ApiError(400, "invalid_request", "Некорректный список участников")
|
|
canonical = []
|
|
for item in member_ids:
|
|
if not isinstance(item, str):
|
|
raise ApiError(400, "invalid_request", "Некорректный список участников")
|
|
canonical.append(parse_uuid(item))
|
|
if len(canonical) != len(set(canonical)):
|
|
raise ApiError(400, "invalid_request", "Список участников содержит дубликаты")
|
|
if user_id not in canonical:
|
|
raise ApiError(400, "invalid_request", "Создатель должен входить в список участников")
|
|
member_uuids = [uuid.UUID(item) for item in canonical]
|
|
async with pool().acquire() as conn:
|
|
async with conn.transaction():
|
|
found = await conn.fetch("SELECT id FROM users WHERE id = ANY($1::uuid[])", member_uuids)
|
|
if len(found) != len(canonical):
|
|
raise ApiError(400, "invalid_request", "Участник не найден")
|
|
row = await conn.fetchrow(
|
|
"""
|
|
INSERT INTO chats (id, title, created_at)
|
|
VALUES ($1, $2, clock_timestamp())
|
|
RETURNING id, title, created_at
|
|
""",
|
|
uuid.uuid4(),
|
|
title,
|
|
)
|
|
for position, member_id in enumerate(member_uuids):
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO chat_members (chat_id, user_id, position)
|
|
VALUES ($1, $2, $3)
|
|
""",
|
|
row["id"],
|
|
member_id,
|
|
position,
|
|
)
|
|
return chat_dict(row, canonical)
|
|
|
|
|
|
def parse_limit(raw: str | None) -> int:
|
|
if raw is None:
|
|
return 50
|
|
if not re.fullmatch(r"[1-9][0-9]*", raw):
|
|
raise ApiError(400, "invalid_request", "Некорректный limit")
|
|
value = int(raw)
|
|
if value > 100:
|
|
raise ApiError(400, "invalid_request", "Некорректный limit")
|
|
return value
|
|
|
|
|
|
async def list_chats(user_id: str, limit: int, cursor: str | None) -> dict:
|
|
created_at = None
|
|
cursor_id = None
|
|
if cursor is not None:
|
|
payload = _cursor_decode(cursor)
|
|
if payload.get("kind") != "chat" or payload.get("user_id") != user_id:
|
|
raise ApiError(400, "invalid_request", "Некорректный cursor")
|
|
try:
|
|
created_at = parse_iso(payload["created_at"])
|
|
cursor_id = uuid.UUID(parse_uuid(payload["id"]))
|
|
except (KeyError, ValueError, TypeError) as exc:
|
|
raise ApiError(400, "invalid_request", "Некорректный cursor") from exc
|
|
rows = await pool().fetch(
|
|
"""
|
|
SELECT c.id, c.title, c.created_at
|
|
FROM chats c
|
|
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = $1
|
|
WHERE ($2::timestamptz IS NULL OR (c.created_at, c.id) > ($2, $3))
|
|
ORDER BY c.created_at, c.id
|
|
LIMIT $4
|
|
""",
|
|
uuid.UUID(user_id),
|
|
created_at,
|
|
cursor_id,
|
|
limit + 1,
|
|
)
|
|
has_more = len(rows) > limit
|
|
rows = rows[:limit]
|
|
members = await _members_for(pool(), [row["id"] for row in rows])
|
|
items = [chat_dict(row, members.get(str(row["id"]), [])) for row in rows]
|
|
next_cursor = None
|
|
if has_more and rows:
|
|
last = rows[-1]
|
|
next_cursor = _cursor_encode(
|
|
{
|
|
"v": 1,
|
|
"kind": "chat",
|
|
"user_id": user_id,
|
|
"created_at": iso(last["created_at"]),
|
|
"id": str(last["id"]),
|
|
}
|
|
)
|
|
return {"items": items, "next_cursor": next_cursor}
|
|
|
|
|
|
async def get_chat(user_id: str, chat_id: str) -> dict:
|
|
chat_uuid = uuid.UUID(parse_uuid(chat_id))
|
|
row = await pool().fetchrow(
|
|
"""
|
|
SELECT c.id, c.title, c.created_at
|
|
FROM chats c
|
|
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = $2
|
|
WHERE c.id = $1
|
|
""",
|
|
chat_uuid,
|
|
uuid.UUID(user_id),
|
|
)
|
|
if row is None:
|
|
raise ApiError(404, "not_found", "Объект не найден")
|
|
members = await _members_for(pool(), [row["id"]])
|
|
return chat_dict(row, members.get(str(row["id"]), []))
|
|
|
|
|
|
def _message_parts(body: dict) -> tuple[str, list[str]]:
|
|
_require_object(body, {"text", "attachment_ids"}, {"text"})
|
|
text = body["text"]
|
|
if not isinstance(text, str) or "\x00" in text or _code_points(text) > 4000:
|
|
raise ApiError(400, "invalid_request", "Некорректный текст сообщения")
|
|
raw_ids = body.get("attachment_ids", [])
|
|
if raw_ids is None or not isinstance(raw_ids, list) or len(raw_ids) > 10:
|
|
raise ApiError(400, "invalid_request", "Некорректный список вложений")
|
|
attachment_ids = []
|
|
for item in raw_ids:
|
|
if not isinstance(item, str):
|
|
raise ApiError(400, "invalid_request", "Некорректный список вложений")
|
|
attachment_ids.append(parse_uuid(item))
|
|
if len(attachment_ids) != len(set(attachment_ids)):
|
|
raise ApiError(400, "invalid_request", "Список вложений содержит дубликаты")
|
|
if not _nonblank(text) and not attachment_ids:
|
|
raise ApiError(400, "invalid_request", "Пустое сообщение")
|
|
return text, attachment_ids
|
|
|
|
|
|
def _canonical_hash(text: str, attachment_ids: list[str]) -> str:
|
|
payload = json.dumps(
|
|
{"attachment_ids": attachment_ids, "text": text},
|
|
ensure_ascii=False,
|
|
sort_keys=True,
|
|
separators=(",", ":"),
|
|
)
|
|
return hashlib.sha256(payload.encode("utf-8")).hexdigest()
|
|
|
|
|
|
async def create_message(user_id: str, chat_id: str, body: dict, idem_key: str | None, settings: Settings) -> dict:
|
|
chat_id = parse_uuid(chat_id)
|
|
if idem_key is None or _IDEMPOTENCY.fullmatch(idem_key) is None:
|
|
raise ApiError(400, "invalid_request", "Требуется корректный Idempotency-Key")
|
|
text, attachment_ids = _message_parts(body)
|
|
request_hash = _canonical_hash(text, attachment_ids)
|
|
path = f"/api/v1/chats/{chat_id}/messages"
|
|
k1, k2 = _lock_keys(f"{user_id}|POST|{path}|{idem_key}")
|
|
async with pool().acquire() as conn:
|
|
async with conn.transaction():
|
|
await conn.execute("SELECT pg_advisory_xact_lock($1::int, $2::int)", k1, k2)
|
|
member = await conn.fetchval(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
|
|
uuid.UUID(chat_id),
|
|
uuid.UUID(user_id),
|
|
)
|
|
if member is None:
|
|
raise ApiError(404, "not_found", "Объект не найден")
|
|
existing = await conn.fetchrow(
|
|
"""
|
|
SELECT request_hash, response_json,
|
|
created_at > clock_timestamp() - make_interval(secs => $4::int) AS fresh
|
|
FROM idempotency
|
|
WHERE user_id = $1 AND http_method = 'POST' AND path = $2 AND idem_key = $3
|
|
""",
|
|
uuid.UUID(user_id),
|
|
path,
|
|
idem_key,
|
|
settings.idempotency_ttl_seconds,
|
|
)
|
|
if existing is not None and existing["fresh"]:
|
|
if existing["request_hash"] != request_hash:
|
|
raise ApiError(409, "conflict", "Ключ идемпотентности уже использован")
|
|
stored = existing["response_json"]
|
|
if isinstance(stored, str):
|
|
stored = json.loads(stored)
|
|
return stored
|
|
if existing is not None and not existing["fresh"]:
|
|
await conn.execute(
|
|
"""
|
|
DELETE FROM idempotency
|
|
WHERE user_id = $1 AND http_method = 'POST' AND path = $2 AND idem_key = $3
|
|
""",
|
|
uuid.UUID(user_id),
|
|
path,
|
|
idem_key,
|
|
)
|
|
if attachment_ids:
|
|
found = await conn.fetch(
|
|
"SELECT id, chat_id, status FROM attachments WHERE id = ANY($1::uuid[])",
|
|
[uuid.UUID(item) for item in attachment_ids],
|
|
)
|
|
by_id = {str(row["id"]): row for row in found}
|
|
if len(by_id) != len(attachment_ids):
|
|
raise ApiError(404, "not_found", "Объект не найден")
|
|
for attachment_id in attachment_ids:
|
|
row = by_id[attachment_id]
|
|
if str(row["chat_id"]) != chat_id or row["status"] != "ready":
|
|
if str(row["chat_id"]) != chat_id:
|
|
raise ApiError(404, "not_found", "Объект не найден")
|
|
raise ApiError(409, "conflict", "Вложение нельзя прикрепить")
|
|
message = await conn.fetchrow(
|
|
"""
|
|
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
|
VALUES ($1, $2, $3, $4, clock_timestamp())
|
|
RETURNING id, chat_id, sender_id, text, created_at
|
|
""",
|
|
uuid.uuid4(),
|
|
uuid.UUID(chat_id),
|
|
uuid.UUID(user_id),
|
|
text,
|
|
)
|
|
for position, attachment_id in enumerate(attachment_ids):
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO message_attachments (message_id, attachment_id, position)
|
|
VALUES ($1, $2, $3)
|
|
""",
|
|
message["id"],
|
|
uuid.UUID(attachment_id),
|
|
position,
|
|
)
|
|
payload = message_dict(message, attachment_ids)
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO idempotency (
|
|
user_id, http_method, path, idem_key, request_hash, status_code, response_json, created_at
|
|
)
|
|
VALUES ($1, 'POST', $2, $3, $4, 201, $5::jsonb, clock_timestamp())
|
|
""",
|
|
uuid.UUID(user_id),
|
|
path,
|
|
idem_key,
|
|
request_hash,
|
|
payload,
|
|
)
|
|
return payload
|
|
|
|
|
|
async def list_messages(user_id: str, chat_id: str, limit: int, cursor: str | None) -> dict:
|
|
chat_id = parse_uuid(chat_id)
|
|
member = await pool().fetchval(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
|
|
uuid.UUID(chat_id),
|
|
uuid.UUID(user_id),
|
|
)
|
|
if member is None:
|
|
raise ApiError(404, "not_found", "Объект не найден")
|
|
created_at = None
|
|
cursor_id = None
|
|
if cursor is not None:
|
|
payload = _cursor_decode(cursor)
|
|
if payload.get("kind") != "message" or payload.get("chat_id") != chat_id:
|
|
raise ApiError(400, "invalid_request", "Некорректный cursor")
|
|
try:
|
|
created_at = parse_iso(payload["created_at"])
|
|
cursor_id = uuid.UUID(parse_uuid(payload["id"]))
|
|
except (KeyError, ValueError, TypeError) as exc:
|
|
raise ApiError(400, "invalid_request", "Некорректный cursor") from exc
|
|
rows = await pool().fetch(
|
|
"""
|
|
SELECT id, chat_id, sender_id, text, created_at
|
|
FROM messages
|
|
WHERE chat_id = $1
|
|
AND ($2::timestamptz IS NULL OR (created_at, id) > ($2, $3))
|
|
ORDER BY created_at, id
|
|
LIMIT $4
|
|
""",
|
|
uuid.UUID(chat_id),
|
|
created_at,
|
|
cursor_id,
|
|
limit + 1,
|
|
)
|
|
has_more = len(rows) > limit
|
|
rows = rows[:limit]
|
|
grouped = await _attachments_for(pool(), [row["id"] for row in rows])
|
|
items = [message_dict(row, grouped.get(str(row["id"]), [])) for row in rows]
|
|
next_cursor = None
|
|
if has_more and rows:
|
|
last = rows[-1]
|
|
next_cursor = _cursor_encode(
|
|
{
|
|
"v": 1,
|
|
"kind": "message",
|
|
"chat_id": chat_id,
|
|
"created_at": iso(last["created_at"]),
|
|
"id": str(last["id"]),
|
|
}
|
|
)
|
|
return {"items": items, "next_cursor": next_cursor}
|
|
|
|
|
|
def validate_filename(filename: str | None) -> str:
|
|
if filename is None:
|
|
raise ApiError(400, "invalid_request", "Требуется filename")
|
|
if not isinstance(filename, str) or not (1 <= _code_points(filename) <= 255):
|
|
raise ApiError(400, "invalid_request", "Некорректное имя файла")
|
|
if not _nonblank(filename) or filename in {".", ".."}:
|
|
raise ApiError(400, "invalid_request", "Некорректное имя файла")
|
|
for char in filename:
|
|
code = ord(char)
|
|
if char in {"/", "\\"} or code in _CONTROLS or code == 127:
|
|
raise ApiError(400, "invalid_request", "Некорректное имя файла")
|
|
return filename
|
|
|
|
|
|
def _media_type(value: str | None) -> str:
|
|
if not value:
|
|
raise ApiError(415, "unsupported_media_type", "Требуется image/png или image/jpeg")
|
|
media = value.split(";", 1)[0].strip().lower()
|
|
if media not in {"image/png", "image/jpeg"}:
|
|
raise ApiError(415, "unsupported_media_type", "Поддерживаются только image/png и image/jpeg")
|
|
return media
|
|
|
|
|
|
async def _mark_ledger(key: str, state: str) -> None:
|
|
await pool().execute(
|
|
"""
|
|
UPDATE object_ledger
|
|
SET state = $2, updated_at = clock_timestamp()
|
|
WHERE object_key = $1
|
|
""",
|
|
key,
|
|
state,
|
|
)
|
|
|
|
|
|
async def _compensate(settings: Settings, key: str) -> None:
|
|
"""Drop a staged object after a failed metadata commit. A failed delete stays for the reconciler."""
|
|
try:
|
|
await _to_thread(s3client.delete_object, settings, key)
|
|
await _mark_ledger(key, "aborted")
|
|
except Exception:
|
|
logger.exception("compensation failed for staged object; reconciler will retry after the grace period")
|
|
|
|
|
|
async def _to_thread(func, *args):
|
|
import asyncio
|
|
|
|
return await asyncio.to_thread(func, *args)
|
|
|
|
|
|
async def upload_attachment(
|
|
user_id: str,
|
|
chat_id: str,
|
|
filename: str | None,
|
|
content_type_header: str | None,
|
|
content_length: str | None,
|
|
byte_iter,
|
|
settings: Settings,
|
|
) -> dict:
|
|
chat_id = parse_uuid(chat_id)
|
|
member = await pool().fetchval(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
|
|
uuid.UUID(chat_id),
|
|
uuid.UUID(user_id),
|
|
)
|
|
if member is None:
|
|
raise ApiError(404, "not_found", "Объект не найден")
|
|
filename = validate_filename(filename)
|
|
media = _media_type(content_type_header)
|
|
if content_length is not None and not re.fullmatch(r"\d+", content_length):
|
|
raise ApiError(400, "invalid_request", "Некорректный Content-Length")
|
|
attachment_id = str(uuid.uuid4())
|
|
object_key = f"o/{attachment_id}"
|
|
os.makedirs("/tmp/uploads", exist_ok=True)
|
|
fd, temp_path = tempfile.mkstemp(prefix="up-", dir="/tmp/uploads")
|
|
os.close(fd)
|
|
digest = hashlib.sha256()
|
|
size = 0
|
|
try:
|
|
with open(temp_path, "wb") as handle:
|
|
async for chunk in byte_iter:
|
|
if not chunk:
|
|
continue
|
|
size += len(chunk)
|
|
if size > settings.max_upload_bytes:
|
|
raise ApiError(413, "payload_too_large", "Файл превышает 10 МиБ")
|
|
digest.update(chunk)
|
|
handle.write(chunk)
|
|
if size < 1:
|
|
raise ApiError(415, "unsupported_media_type", "Пустой файл")
|
|
await _to_thread(
|
|
validate_image,
|
|
temp_path,
|
|
media,
|
|
settings.max_image_pixels,
|
|
settings.full_decode_pixels,
|
|
)
|
|
sha256 = digest.hexdigest()
|
|
await pool().execute(
|
|
"""
|
|
INSERT INTO object_ledger (
|
|
object_key, attachment_id, chat_id, state, note, size_bytes, created_at, updated_at
|
|
)
|
|
VALUES ($1, $2, $3, 'staging', 'upload', $4, clock_timestamp(), clock_timestamp())
|
|
""",
|
|
object_key,
|
|
uuid.UUID(attachment_id),
|
|
uuid.UUID(chat_id),
|
|
size,
|
|
)
|
|
try:
|
|
await _to_thread(s3client.put_file, settings, object_key, temp_path, media, size)
|
|
except Exception:
|
|
await _compensate(settings, object_key)
|
|
raise
|
|
try:
|
|
async with pool().acquire() as conn:
|
|
async with conn.transaction():
|
|
row = await conn.fetchrow(
|
|
"""
|
|
INSERT INTO attachments (
|
|
id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
|
|
status, object_key, error_code, created_at, updated_at
|
|
)
|
|
VALUES (
|
|
$1, $2, $3, $4, $5, $6, $7, 'ready', $8, NULL,
|
|
clock_timestamp(), clock_timestamp()
|
|
)
|
|
RETURNING id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
|
|
status, created_at, updated_at
|
|
""",
|
|
uuid.UUID(attachment_id),
|
|
uuid.UUID(chat_id),
|
|
uuid.UUID(user_id),
|
|
filename,
|
|
media,
|
|
size,
|
|
sha256,
|
|
object_key,
|
|
)
|
|
updated = await conn.execute(
|
|
"""
|
|
UPDATE object_ledger
|
|
SET state = 'committed', updated_at = clock_timestamp()
|
|
WHERE object_key = $1 AND state = 'staging'
|
|
""",
|
|
object_key,
|
|
)
|
|
if not updated.endswith("1"):
|
|
raise RuntimeError("ledger was not in staging state")
|
|
except Exception:
|
|
logger.exception("metadata commit failed after object upload")
|
|
await _compensate(settings, object_key)
|
|
raise ApiError(503, "unavailable", "Не удалось сохранить метаданные вложения")
|
|
return attachment_dict(row)
|
|
finally:
|
|
try:
|
|
os.remove(temp_path)
|
|
except OSError:
|
|
pass
|
|
|
|
|
|
async def get_attachment(user_id: str, attachment_id: str) -> dict:
|
|
attachment_id = parse_uuid(attachment_id)
|
|
row = await pool().fetchrow(
|
|
"""
|
|
SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256,
|
|
a.status, a.created_at, a.updated_at
|
|
FROM attachments a
|
|
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = $2
|
|
WHERE a.id = $1
|
|
""",
|
|
uuid.UUID(attachment_id),
|
|
uuid.UUID(user_id),
|
|
)
|
|
if row is None:
|
|
raise ApiError(404, "not_found", "Объект не найден")
|
|
return attachment_dict(row)
|
|
|
|
|
|
async def download_attachment(user_id: str, attachment_id: str, variant: str | None, settings: Settings) -> tuple[bytes, str]:
|
|
if variant not in {None, "original"}:
|
|
raise ApiError(400, "invalid_request", "Некорректный variant")
|
|
attachment_id = parse_uuid(attachment_id)
|
|
row = await pool().fetchrow(
|
|
"""
|
|
SELECT a.object_key, a.content_type, a.size_bytes
|
|
FROM attachments a
|
|
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = $2
|
|
WHERE a.id = $1
|
|
""",
|
|
uuid.UUID(attachment_id),
|
|
uuid.UUID(user_id),
|
|
)
|
|
if row is None:
|
|
raise ApiError(404, "not_found", "Объект не найден")
|
|
data = await _to_thread(s3client.get_bytes, settings, row["object_key"], settings.max_upload_bytes)
|
|
if len(data) != row["size_bytes"]:
|
|
raise ApiError(404, "not_found", "Объект не найден")
|
|
return data, row["content_type"]
|
|
|
|
|
|
async def ready(settings: Settings) -> None:
|
|
try:
|
|
await pool().fetchval("SELECT 1")
|
|
except Exception as exc:
|
|
raise ApiError(503, "unavailable", "База данных недоступна") from exc
|
|
await _to_thread(s3client.head_bucket, settings)
|