Добавить вложения: S3, метаданные в PostgreSQL и очистка незавершённых загрузок

This commit is contained in:
2026-10-30 23:10:00 +03:00
parent ec540a1a72
commit 694b2ea25f
75 changed files with 5967 additions and 15 deletions
+68
View File
@@ -0,0 +1,68 @@
import os
import socket
from pathlib import Path
HOST = os.getenv("APP_HOST", "0.0.0.0")
PORT = int(os.getenv("APP_PORT", "8080"))
ENV = os.getenv("APP_ENV", "lab")
VERSION = os.getenv("APP_VERSION", "dev")
# имя контейнера совпадает с коротким id, по нему scripts/stop-one.sh находит реплику; в lab7 заменить на alias
INSTANCE_ID = socket.gethostname()
LOG_LEVEL = os.getenv("LOG_LEVEL", "info").lower()
# docker stop по умолчанию ждёт 10 секунд, поэтому укладываемся с запасом
SHUTDOWN_TIMEOUT = int(os.getenv("SHUTDOWN_TIMEOUT", "8"))
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
SESSION_STORE = os.getenv("SESSION_STORE", "redis")
# сколько хранить результат отправки сообщения по Idempotency-Key, контракт требует не менее 24 часов
IDEMPOTENCY_TTL_SECONDS = int(os.getenv("IDEMPOTENCY_TTL_SECONDS", "86400"))
# пул соединений с PostgreSQL и таймауты, всё в секундах
DB_POOL_MIN_SIZE = int(os.getenv("DB_POOL_MIN_SIZE", "2"))
DB_POOL_MAX_SIZE = int(os.getenv("DB_POOL_MAX_SIZE", "10"))
DB_POOL_TIMEOUT = float(os.getenv("DB_POOL_TIMEOUT", "3"))
DB_CONNECT_TIMEOUT = int(os.getenv("DB_CONNECT_TIMEOUT", "3"))
DB_STATEMENT_TIMEOUT = int(os.getenv("DB_STATEMENT_TIMEOUT", "5"))
# вложения: лимиты контракта и время на приём одного файла
MAX_UPLOAD_BYTES = int(os.getenv("MAX_UPLOAD_BYTES", "10485760"))
MAX_IMAGE_PIXELS = int(os.getenv("MAX_IMAGE_PIXELS", "40000000"))
MAX_JSON_BYTES = int(os.getenv("MAX_JSON_BYTES", "1048576"))
MAX_PARALLEL_UPLOADS = int(os.getenv("MAX_PARALLEL_UPLOADS", "32"))
UPLOAD_TIMEOUT_SECONDS = int(os.getenv("UPLOAD_TIMEOUT_SECONDS", "60"))
# записей в S3 одновременно с одной реплики и сколько загрузка ждёт своей очереди
S3_PARALLEL_WRITES = int(os.getenv("S3_PARALLEL_WRITES", "4"))
S3_WRITE_QUEUE_SECONDS = int(os.getenv("S3_WRITE_QUEUE_SECONDS", "10"))
S3_ENDPOINT = os.getenv("S3_ENDPOINT", "http://s3:9000")
S3_REGION = os.getenv("S3_REGION", "us-east-1")
S3_BUCKET = os.getenv("S3_BUCKET", "messenger-attachments")
S3_CONNECT_TIMEOUT = float(os.getenv("S3_CONNECT_TIMEOUT", "2"))
S3_READ_TIMEOUT = float(os.getenv("S3_READ_TIMEOUT", "5"))
S3_POOL_SIZE = int(os.getenv("S3_POOL_SIZE", "32"))
# janitor: возраст, после которого незавершённая загрузка считается брошенной, и период проходов
ATTACHMENT_GRACE_SECONDS = int(os.getenv("ATTACHMENT_GRACE_SECONDS", "3600"))
JANITOR_INTERVAL_SECONDS = int(os.getenv("JANITOR_INTERVAL_SECONDS", "300"))
CACHE_POOL_MAX_SIZE = int(os.getenv("CACHE_POOL_MAX_SIZE", "20"))
CACHE_TIMEOUT = float(os.getenv("CACHE_TIMEOUT", "2"))
def read_secret(name: str) -> str:
"""Значение берётся из файла, путь к которому лежит в NAME_FILE. Для отладки без Docker подойдёт и сама NAME."""
path = os.getenv(name + "_FILE")
if path and Path(path).is_file():
return Path(path).read_text().strip()
value = os.getenv(name)
if not value:
raise SystemExit(f"не задан {name}_FILE или {name}")
return value
def database_url() -> str:
return read_secret("DATABASE_URL")
def cache_url() -> str:
return read_secret("CACHE_URL")
+38
View File
@@ -0,0 +1,38 @@
from fastapi.responses import JSONResponse
class ApiError(Exception):
def __init__(self, status: int, code: str, message: str, headers=None):
self.status = status
self.code = code
self.message = message
self.headers = headers
def invalid(message: str) -> ApiError:
return ApiError(400, "invalid_request", message)
def bad_credentials() -> ApiError:
# один и тот же ответ для неизвестного username и неверного пароля
return ApiError(
401, "unauthorized", "Неверное имя пользователя или пароль",
{"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'},
)
def unauthorized() -> ApiError:
return ApiError(
401, "unauthorized", "Нужен действующий Bearer-токен",
{"WWW-Authenticate": 'Bearer realm="messenger"'},
)
def not_found() -> ApiError:
# одинаковый ответ для несуществующего и чужого объекта
return ApiError(404, "not_found", "Объект не найден")
def error_response(request_id: str, status: int, code: str, message: str, headers=None) -> JSONResponse:
body = {"error": {"code": code, "message": message, "request_id": request_id}}
return JSONResponse(body, status_code=status, headers=headers)
+11
View File
@@ -0,0 +1,11 @@
"""Проверка для Docker HEALTHCHECK: код 0, если /health/ready отвечает 200."""
import os
import sys
import urllib.request
port = os.getenv("APP_PORT", "8080")
try:
with urllib.request.urlopen(f"http://127.0.0.1:{port}/health/ready", timeout=4) as response:
sys.exit(0 if response.status == 200 else 1)
except Exception:
sys.exit(1)
+186
View File
@@ -0,0 +1,186 @@
"""Проверка PNG и JPEG по содержимому. Файл читается блоками, пиксели в память не распаковываются.
Размер изображения берётся из заголовка до любой работы с данными, поэтому decompression bomb
отсекается сразу. Данные PNG проверяются потоково: CRC каждого блока и распаковка с выбрасыванием
результата. У JPEG проверяется структура маркеров, но не содержимое сжатых данных: порча внутри скана
этой проверкой не обнаруживается.
"""
import struct
import zlib
BLOCK = 64 * 1024
PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
JPEG_SIGNATURE = b"\xff\xd8\xff"
# допустимая глубина цвета для каждого типа PNG и число каналов
PNG_COLOR_TYPES = {0: ((1, 2, 4, 8, 16), 1), 2: ((8, 16), 3), 3: ((1, 2, 4, 8), 1), 4: ((8, 16), 2), 6: ((8, 16), 4)}
# все маркеры SOF, кроме DHT (C4), JPG (C8) и DAC (CC), которые попадают в тот же диапазон
JPEG_SOF = set(range(0xC0, 0xD0)) - {0xC4, 0xC8, 0xCC}
class NotAnImage(Exception):
pass
class TooManyPixels(Exception):
pass
def inspect(file, max_pixels: int) -> str:
"""Возвращает настоящий тип файла или бросает NotAnImage / TooManyPixels."""
file.seek(0)
head = file.read(8)
try:
if head == PNG_SIGNATURE:
check_png(file, max_pixels)
return "image/png"
if head[:3] == JPEG_SIGNATURE:
file.seek(2)
check_jpeg(file, max_pixels)
return "image/jpeg"
except (struct.error, zlib.error, ValueError) as error:
raise NotAnImage() from error
raise NotAnImage()
def check_size(width: int, height: int, max_pixels: int) -> None:
if width == 0 or height == 0:
raise NotAnImage()
if width * height > max_pixels:
raise TooManyPixels()
def png_raw_size(width: int, height: int, bits_per_pixel: int) -> int:
"""Размер распакованных данных без чересстрочности: строки плюс байт фильтра на каждую."""
return height * (1 + (width * bits_per_pixel + 7) // 8)
def check_png(file, max_pixels: int) -> None:
inflater = zlib.decompressobj()
header = None
limit = 0
unpacked = 0
interlaced = False
seen_data = False
while True:
length, kind = struct.unpack(">I4s", read_exact(file, 8))
if length >= 2**31 or (header is None and kind != b"IHDR"):
raise NotAnImage()
crc = zlib.crc32(kind)
remaining = length
body = b""
while remaining:
block = file.read(min(BLOCK, remaining))
if not block:
raise NotAnImage()
remaining -= len(block)
crc = zlib.crc32(block, crc)
if kind == b"IHDR":
body += block
elif kind == b"IDAT":
seen_data = True
unpacked += inflate(inflater, block, limit - unpacked)
if struct.unpack(">I", read_exact(file, 4))[0] != crc:
raise NotAnImage()
if kind == b"IHDR":
if header is not None or length != 13:
raise NotAnImage()
header = struct.unpack(">IIBBBBB", body)
width, height, depth, color, compression, filtering, interlace = header
depths, channels = PNG_COLOR_TYPES.get(color, ((), 0))
if depth not in depths or compression != 0 or filtering != 0 or interlace not in (0, 1):
raise NotAnImage()
check_size(width, height, max_pixels)
interlaced = interlace == 1
limit = png_raw_size(width, height, depth * channels)
if interlaced:
# чересстрочная запись длиннее: у каждого из семи проходов свои байты фильтра
limit += 7 * height + limit // 4
elif kind == b"IEND":
break
if not seen_data or not inflater.eof or file.read(1):
raise NotAnImage()
if not interlaced and unpacked != limit:
raise NotAnImage()
def inflate(inflater, block: bytes, allowed: int) -> int:
"""Распаковывает блок, не накапливая результат. Возвращает, сколько байт получилось."""
total = 0
while block and not inflater.eof:
chunk = inflater.decompress(block, BLOCK)
total += len(chunk)
if total > allowed:
raise NotAnImage()
block = inflater.unconsumed_tail
return total
def check_jpeg(file, max_pixels: int) -> None:
file.seek(0, 2)
end = file.tell()
file.seek(2)
seen_frame = False
seen_scan = False
while True:
if read_exact(file, 1) != b"\xff":
raise NotAnImage()
marker = 0xFF
while marker == 0xFF: # перед маркером разрешены байты-заполнители
marker = read_exact(file, 1)[0]
if marker == 0xD9: # конец изображения; данные после него допустимы, так делают камеры
if seen_scan:
return
raise NotAnImage()
if 0xD0 <= marker <= 0xD7 or marker == 0x01:
continue
if marker == 0x00 or marker == 0xD8:
raise NotAnImage()
length = struct.unpack(">H", read_exact(file, 2))[0]
if length < 2 or file.tell() + length - 2 > end:
raise NotAnImage()
if marker in JPEG_SOF:
if seen_frame or length < 8:
raise NotAnImage()
height, width = struct.unpack(">xHH", read_exact(file, 5))
check_size(width, height, max_pixels)
seen_frame = True
file.seek(length - 7, 1)
else:
file.seek(length - 2, 1)
if marker == 0xDA:
if not seen_frame:
raise NotAnImage()
seen_scan = True
skip_scan(file)
def skip_scan(file) -> None:
"""Проходит сжатые данные скана и оставляет файл на следующем маркере."""
while True:
start = file.tell()
block = file.read(BLOCK)
if len(block) < 2:
raise NotAnImage()
position = 0
while True:
position = block.find(b"\xff", position)
if position < 0:
break
if position + 1 == len(block): # маркер разрезан границей блока
file.seek(start + position)
break
following = block[position + 1]
if following == 0x00 or 0xD0 <= following <= 0xD7:
position += 2
elif following == 0xFF:
position += 1
else:
file.seek(start + position)
return
def read_exact(file, size: int) -> bytes:
data = file.read(size)
if len(data) != size:
raise NotAnImage()
return data
+93
View File
@@ -0,0 +1,93 @@
"""Убирает следы незавершённых загрузок. Работает отдельным сервисом со своим S3-ключом.
1. Строка pending старше grace period: загрузка оборвалась между записью в БД, S3 и подтверждением.
Сначала удаляется объект, потом строка: при сбое посередине следующий проход повторит то же самое.
2. Объект старше grace period без строки в БД: сверка на случай, если строка потеряна.
Строка появляется раньше объекта, поэтому у идущей загрузки строка есть всегда, а grace period
больше максимального времени загрузки.
"""
import argparse
import logging
import signal
import sys
import threading
from datetime import datetime, timedelta, timezone
import psycopg
from botocore.exceptions import BotoCoreError, ClientError
import config
from objects import ObjectStore
logging.basicConfig(level=config.LOG_LEVEL.upper(), format="%(asctime)s %(levelname)s %(name)s: %(message)s", stream=sys.stdout)
logging.getLogger("botocore").setLevel(logging.WARNING)
log = logging.getLogger("janitor")
def clean_pending(conn, objects, grace: int, dry_run: bool) -> int:
rows = conn.execute(
"SELECT id, object_key FROM attachments WHERE state = 'pending' "
"AND created_at < now() - make_interval(secs => %s)",
(grace,),
).fetchall()
for attachment_id, key in rows:
if dry_run:
continue
objects.delete(key)
conn.execute("DELETE FROM attachments WHERE id = %s AND state = 'pending'", (attachment_id,))
return len(rows)
def clean_orphans(conn, objects, grace: int, dry_run: bool) -> int:
removed = 0
border = datetime.now(timezone.utc) - timedelta(seconds=grace)
for page in objects.pages():
old = [item["Key"] for item in page if item["LastModified"] < border]
if not old:
continue
known = {row[0] for row in conn.execute("SELECT object_key FROM attachments WHERE object_key = ANY(%s)", (old,))}
for key in old:
if key not in known:
removed += 1
if not dry_run:
objects.delete(key)
return removed
def run_once(objects, grace: int, dry_run: bool = False) -> None:
with psycopg.connect(config.database_url(), autocommit=True, connect_timeout=config.DB_CONNECT_TIMEOUT) as conn:
pending = clean_pending(conn, objects, grace, dry_run)
orphans = clean_orphans(conn, objects, grace, dry_run)
log.info("pass finished dry_run=%s pending_removed=%d orphans_removed=%d grace=%ds", dry_run, pending, orphans, grace)
def main():
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("--once", action="store_true", help="один проход и выход")
parser.add_argument("--dry-run", action="store_true", help="только посчитать, ничего не удалять")
parser.add_argument("--grace-seconds", type=int, default=config.ATTACHMENT_GRACE_SECONDS)
args = parser.parse_args()
objects = ObjectStore(config.read_secret("S3_JANITOR_ACCESS_KEY_ID"), config.read_secret("S3_JANITOR_SECRET_ACCESS_KEY"))
if args.once:
try:
run_once(objects, args.grace_seconds, args.dry_run)
except (psycopg.Error, BotoCoreError, ClientError) as error:
sys.exit(f"проход не выполнен: {type(error).__name__}")
return
# PID 1 без обработчика не завершается по SIGTERM
stop = threading.Event()
signal.signal(signal.SIGTERM, lambda *_: stop.set())
log.info("started interval=%ds grace=%ds", config.JANITOR_INTERVAL_SECONDS, args.grace_seconds)
while not stop.is_set():
try:
run_once(objects, args.grace_seconds)
except (psycopg.Error, BotoCoreError, ClientError) as error:
# хранилище недоступно: следующий проход повторит работу
log.warning("pass failed: %s", type(error).__name__)
stop.wait(config.JANITOR_INTERVAL_SECONDS)
log.info("stopped")
if __name__ == "__main__":
main()
+496
View File
@@ -0,0 +1,496 @@
import asyncio
import base64
import hashlib
import json
import logging
import re
import sys
import tempfile
import time
import unicodedata
import uuid
from contextlib import asynccontextmanager
from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
from typing import Annotated
from urllib.parse import quote
from uuid import UUID
import psycopg
import redis
import uvicorn
from botocore.exceptions import BotoCoreError, ClientError
from fastapi import Depends, FastAPI, Path, Query, Request, Response
from fastapi.concurrency import run_in_threadpool
from fastapi.exceptions import RequestValidationError
from fastapi.responses import StreamingResponse
from pydantic import ValidationError
from starlette.exceptions import HTTPException
from starlette.requests import ClientDisconnect
import config
import images
import security
from errors import ApiError, bad_credentials, error_response, invalid, not_found, unauthorized
from objects import ObjectStore
from schemas import UUID_PATTERN, CreateChat, CreateMessage, CreateUser
from sessions import Sessions
from store import TIME_FORMAT, IdempotencyConflict, Store, UnknownAttachment, UnknownMember, UsernameTaken, timestamp
logging.basicConfig(
level=config.LOG_LEVEL.upper(),
format="%(asctime)s %(levelname)s %(name)s: %(message)s",
stream=sys.stdout,
)
log = logging.getLogger("messenger")
if config.SESSION_STORE != "redis":
sys.exit("поддерживается только SESSION_STORE=redis")
USERNAME = re.compile(r"[a-z0-9_]{3,32}")
IDEMPOTENCY_KEY = re.compile(r"[A-Za-z0-9._:-]{1,128}")
ChatId = Annotated[str, Path(pattern=UUID_PATTERN)]
AttachmentId = Annotated[str, Path(pattern=UUID_PATTERN)]
IMAGE_TYPES = ("image/png", "image/jpeg")
# варианты появятся с lab5; у вложения lab4 их нет, поэтому такой запрос даёт 404, а неизвестное имя 400
FUTURE_VARIANTS = ("thumbnail", "crop", "optimized")
# символы, которые меняют направление текста и позволяют замаскировать расширение файла
BIDI_CONTROLS = set("\u202a\u202b\u202c\u202d\u202e\u2066\u2067\u2068\u2069")
store = Store(config.database_url())
sessions = Sessions(config.cache_url())
objects = ObjectStore(config.read_secret("S3_ACCESS_KEY_ID"), config.read_secret("S3_SECRET_ACCESS_KEY"))
# загрузки на этой реплике; меняется только в цикле событий, поэтому без блокировки
active_uploads = 0
# очередь на запись в S3. Асинхронная: ждущая загрузка не занимает поток, текстовые запросы не страдают
s3_write_slots = asyncio.Semaphore(config.S3_PARALLEL_WRITES)
@asynccontextmanager
async def lifespan(app: FastAPI):
store.open()
log.info(
"started env=%s version=%s instance=%s listen=%s:%d session_ttl=%ds db_pool_max=%d",
config.ENV, config.VERSION, config.INSTANCE_ID, config.HOST, config.PORT,
config.SESSION_TTL_SECONDS, config.DB_POOL_MAX_SIZE,
)
yield
store.close()
sessions.close()
log.info("stopped")
app = FastAPI(title="MTUSI Messenger lab4", lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None)
@app.middleware("http")
async def request_context(request: Request, call_next):
request_id = uuid.uuid4().hex
request.state.request_id = request_id
started = time.perf_counter()
try:
response = await call_next(request)
except Exception:
log.exception("unhandled error request_id=%s", request_id)
response = error_response(request_id, 500, "internal_error", "Внутренняя ошибка сервера")
response.headers["X-Request-Id"] = request_id
response.headers["X-Instance-Id"] = config.INSTANCE_ID
# балансировщик проверяет готовность каждую секунду, эти запросы видны только на уровне debug
level = logging.DEBUG if request.url.path.startswith("/health/") else logging.INFO
# в лог идут только метод, путь и код ответа: тела запросов, пароли и токены не пишем
log.log(
level, "%s %s status=%d duration_ms=%.1f request_id=%s",
request.method, request.url.path, response.status_code,
(time.perf_counter() - started) * 1000, request_id,
)
return response
@app.exception_handler(ApiError)
async def on_api_error(request: Request, exc: ApiError):
return error_response(request.state.request_id, exc.status, exc.code, exc.message, exc.headers)
@app.exception_handler(RequestValidationError)
async def on_validation_error(request: Request, exc: RequestValidationError):
first = exc.errors()[0]
where = ".".join(str(part) for part in first["loc"])
return error_response(request.state.request_id, 400, "invalid_request", f"{where}: {first['msg']}")
@app.exception_handler(HTTPException)
async def on_http_error(request: Request, exc: HTTPException):
# сюда попадают ошибки самого фреймворка: неизвестный путь, неподдерживаемый метод
if exc.status_code == 404:
code, message = "not_found", "Объект не найден"
else:
code, message = "invalid_request", "Запрос не поддерживается"
return error_response(request.state.request_id, exc.status_code, code, message, exc.headers)
# OperationalError — нет связи с PostgreSQL, не дождались соединения из пула или сработал statement_timeout
@app.exception_handler(psycopg.OperationalError)
async def on_database_down(request: Request, exc: Exception):
log.warning("postgres unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id)
return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен")
@app.exception_handler(redis.RedisError)
async def on_cache_down(request: Request, exc: Exception):
log.warning("redis unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id)
return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен")
@app.exception_handler(BotoCoreError)
@app.exception_handler(ClientError)
async def on_storage_down(request: Request, exc: Exception):
log.warning("s3 unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id)
return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен")
@dataclass
class Session:
user_id: str
token: str
def current_session(request: Request) -> Session:
# X-User-Id из lab1 здесь не читается вообще, Basic на бизнес-запросах тоже не принимается
token = security.parse_bearer(request.headers.get("Authorization"))
if token is None:
raise unauthorized()
# если Redis недоступен, здесь будет исключение и ответ 503: без проверки сессии запрос дальше не идёт
user_id = sessions.user_id(token)
if user_id is None:
raise unauthorized()
return Session(user_id, token)
def idempotency_key(request: Request) -> str:
key = request.headers.get("Idempotency-Key", "")
if not IDEMPOTENCY_KEY.fullmatch(key):
raise invalid("Нужен заголовок Idempotency-Key: 1-128 символов A-Z a-z 0-9 . _ : -")
return key
def json_body(model):
"""Разбирает тело запроса зависимостью, чтобы это происходило после проверки токена."""
async def parse(request: Request):
content_type = request.headers.get("Content-Type", "").split(";")[0].strip().lower()
if content_type != "application/json":
raise invalid("Нужен Content-Type: application/json")
try:
raw = bytearray()
async for chunk in request.stream():
raw += chunk
if len(raw) > config.MAX_JSON_BYTES:
raise ApiError(413, "payload_too_large", "Слишком большое тело запроса")
# decode строгий: контракт допускает только UTF-8, а json.loads сам угадал бы UTF-16
data = json.loads(raw.decode("utf-8"))
except (ValueError, RecursionError):
raise invalid("Тело запроса должно быть корректным JSON в UTF-8")
try:
return model.model_validate(data)
except ValidationError as exc:
first = exc.errors()[0]
where = ".".join(str(part) for part in ("body", *first["loc"]))
raise invalid(f"{where}: {first['msg']}")
return parse
def member_chat(chat_id: ChatId, session: Session = Depends(current_session)) -> str:
"""Чат, в котором состоит текущий пользователь. Посторонний получает 404 до чтения тела запроса."""
chat_id = str(UUID(chat_id))
if not store.is_member(chat_id, session.user_id):
raise not_found()
return chat_id
def attachment_filename(filename: Annotated[str, Query(min_length=1, max_length=255)]) -> str:
# имя только показывается пользователю, но оно не должно выглядеть как путь или прятать расширение
dangerous = any(
char in "/\\\ufffd" or char in BIDI_CONTROLS or unicodedata.category(char) == "Cc" for char in filename
)
if dangerous or not filename.strip() or filename in (".", ".."):
raise invalid("Недопустимое имя файла")
return filename
async def receive_file(request: Request, target) -> tuple[int, str]:
"""Пишет тело запроса во временный файл блоками. В памяти одновременно только текущий блок."""
digest = hashlib.sha256()
size = 0
try:
async with asyncio.timeout(config.UPLOAD_TIMEOUT_SECONDS):
async for chunk in request.stream():
size += len(chunk)
if size > config.MAX_UPLOAD_BYTES:
raise ApiError(413, "payload_too_large", "Файл больше 10 MiB")
digest.update(chunk)
target.write(chunk)
except TimeoutError:
raise invalid("Файл не получен вовремя")
except ClientDisconnect:
raise invalid("Загрузка прервана")
return size, digest.hexdigest()
def save_attachment(staging, chat_id, owner_id, filename, declared_type, size, sha256) -> dict:
try:
actual_type = images.inspect(staging, config.MAX_IMAGE_PIXELS)
except images.NotAnImage:
raise ApiError(415, "unsupported_media_type", "Файл не является корректным PNG или JPEG")
except images.TooManyPixels:
raise ApiError(413, "payload_too_large", "Изображение больше 40 млн пикселей")
if actual_type != declared_type:
raise ApiError(415, "unsupported_media_type", "Содержимое файла не совпадает с Content-Type")
attachment_id = uuid.uuid4()
key = f"originals/{attachment_id}"
store.create_pending_attachment(attachment_id, chat_id, owner_id, filename, actual_type, size, sha256, key)
# объект записан, но вложение ещё не видно: 201 будет только после подтверждения в БД
staging.seek(0)
objects.put(key, staging, size, actual_type)
attachment = store.mark_attachment_ready(attachment_id)
if attachment is None:
raise ApiError(503, "unavailable", "Сервис временно недоступен")
return attachment
def encode_cursor(scope: str, created_at: str, item_id: str) -> str:
raw = json.dumps([scope, created_at, item_id])
return base64.urlsafe_b64encode(raw.encode()).decode()
def decode_cursor(scope: str, cursor):
"""Возвращает ключ (created_at, id) последней выданной записи или None для первой страницы."""
if cursor is None:
return None
try:
# validate=True: символ вне алфавита base64 — ошибка, а не пропускается молча
cursor_scope, created_at, item_id = json.loads(base64.b64decode(cursor, altchars=b"-_", validate=True))
# время и id принимаются только в том виде, в котором их выдаёт сам сервер
moment = datetime.strptime(created_at, TIME_FORMAT).replace(tzinfo=timezone.utc)
time_ok = moment.strftime(TIME_FORMAT) == created_at
id_ok = str(UUID(item_id)) == item_id
except (TypeError, ValueError, AttributeError):
raise invalid("Некорректный cursor")
# cursor действует только для того списка, в котором был выдан
if cursor_scope != scope or not time_ok or not id_ok:
raise invalid("Некорректный cursor")
# у одной позиции есть ровно одна запись cursor: другое оформление JSON или base64 не принимается
if encode_cursor(scope, created_at, item_id) != cursor:
raise invalid("Некорректный cursor")
return [moment, item_id]
def page(scope: str, items: list, has_more: bool) -> dict:
next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if has_more else None
return {"items": items, "next_cursor": next_cursor}
@app.get("/health/live")
def liveness():
return {"status": "ok"}
@app.get("/health/ready")
def readiness():
# без PostgreSQL и Redis обязательные запросы не выполнить, поэтому обе зависимости критичны
store.ping()
sessions.ping()
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
def register_user(body: CreateUser = Depends(json_body(CreateUser))):
try:
return store.create_user(body.username, body.display_name, security.hash_password(body.password))
except UsernameTaken:
raise ApiError(409, "conflict", "Такой username уже занят")
@app.post("/api/v1/auth/sessions", status_code=201)
def create_session(request: Request):
credentials = security.parse_basic(request.headers.get("Authorization"))
if credentials is None:
raise bad_credentials()
username, password = credentials
user, password_hash = None, None
# username, который не мог быть зарегистрирован, в БД не ищем, но пароль всё равно сверяем с пустышкой
if USERNAME.fullmatch(username):
user, password_hash = store.get_credentials(username)
if not security.verify_password(password_hash, password):
raise bad_credentials()
token = sessions.create(user["id"])
expires_at = datetime.now(timezone.utc) + timedelta(seconds=config.SESSION_TTL_SECONDS)
return {"token": token, "token_type": "Bearer", "expires_at": timestamp(expires_at), "user": user}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(session: Session = Depends(current_session)):
sessions.revoke(session.token)
return Response(status_code=204)
@app.get("/api/v1/users/me")
def get_me(session: Session = Depends(current_session)):
user = store.get_user(session.user_id)
if user is None:
raise unauthorized()
return user
@app.post("/api/v1/chats", status_code=201)
def create_chat(session: Session = Depends(current_session), body: CreateChat = Depends(json_body(CreateChat))):
member_ids = [str(UUID(member)) for member in body.member_ids]
if len(set(member_ids)) != len(member_ids):
raise invalid("member_ids содержит повторы")
if session.user_id not in member_ids:
raise invalid("Создатель чата должен быть в member_ids")
try:
return store.create_chat(body.title, member_ids)
except UnknownMember:
raise invalid("В member_ids есть несуществующий пользователь")
@app.get("/api/v1/chats")
def list_chats(
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None, min_length=1),
session: Session = Depends(current_session),
):
scope = "chats:" + session.user_id
items, has_more = store.list_chats(session.user_id, decode_cursor(scope, cursor), limit)
return page(scope, items, has_more)
@app.get("/api/v1/chats/{chat_id}")
def get_chat(chat_id: ChatId, session: Session = Depends(current_session)):
chat = store.get_chat(str(UUID(chat_id)), session.user_id)
if chat is None:
raise not_found()
return chat
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def send_message(
chat_id: ChatId,
session: Session = Depends(current_session),
key: str = Depends(idempotency_key),
body: CreateMessage = Depends(json_body(CreateMessage)),
):
# отправитель берётся из сессии, в теле запроса его нет
try:
attachment_ids = [str(UUID(item)) for item in body.attachment_ids]
message = store.add_message(str(UUID(chat_id)), session.user_id, body.text, attachment_ids, key)
except IdempotencyConflict:
raise ApiError(409, "conflict", "Этот Idempotency-Key уже использован с другим сообщением")
except UnknownAttachment:
raise not_found()
if message is None:
raise not_found()
return message
@app.get("/api/v1/chats/{chat_id}/messages")
def list_messages(
chat_id: ChatId,
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None, min_length=1),
session: Session = Depends(current_session),
):
chat_id = str(UUID(chat_id))
scope = "messages:" + chat_id
result = store.list_messages(chat_id, session.user_id, decode_cursor(scope, cursor), limit)
if result is None:
raise not_found()
items, has_more = result
return page(scope, items, has_more)
@app.post("/api/v1/chats/{chat_id}/attachments", status_code=201)
async def upload_attachment(
request: Request,
session: Session = Depends(current_session),
chat_id: str = Depends(member_chat),
filename: str = Depends(attachment_filename),
):
global active_uploads
declared_type = request.headers.get("Content-Type", "").split(";")[0].strip().lower()
if declared_type not in IMAGE_TYPES:
raise ApiError(415, "unsupported_media_type", "Нужен Content-Type: image/png или image/jpeg")
length = request.headers.get("Content-Length", "")
if length.isdigit() and int(length) > config.MAX_UPLOAD_BYTES:
raise ApiError(413, "payload_too_large", "Файл больше 10 MiB")
if active_uploads >= config.MAX_PARALLEL_UPLOADS:
raise ApiError(429, "rate_limited", "Слишком много одновременных загрузок", {"Retry-After": "1"})
active_uploads += 1
try:
# временный файл без имени: система удалит его при любом завершении процесса
with tempfile.TemporaryFile() as staging:
size, sha256 = await receive_file(request, staging)
if size == 0:
raise ApiError(415, "unsupported_media_type", "Файл пуст")
try:
async with asyncio.timeout(config.S3_WRITE_QUEUE_SECONDS):
await s3_write_slots.acquire()
except TimeoutError:
raise ApiError(503, "unavailable", "Сервис временно недоступен")
try:
return await run_in_threadpool(
save_attachment, staging, chat_id, session.user_id, filename, declared_type, size, sha256
)
finally:
s3_write_slots.release()
finally:
active_uploads -= 1
@app.get("/api/v1/attachments/{attachment_id}")
def get_attachment(attachment_id: AttachmentId, session: Session = Depends(current_session)):
attachment, _ = store.get_attachment(str(UUID(attachment_id)), session.user_id)
if attachment is None:
raise not_found()
return attachment
@app.get("/api/v1/attachments/{attachment_id}/content")
def download_attachment(
attachment_id: AttachmentId,
variant: str = Query("original"),
session: Session = Depends(current_session),
):
# доступ проверяет приложение: bucket приватный, и случайный ключ объекта правом доступа не является
attachment, key = store.get_attachment(str(UUID(attachment_id)), session.user_id)
if attachment is None or variant in FUTURE_VARIANTS:
raise not_found()
if variant != "original":
raise invalid("Неизвестный variant")
body = objects.open(key)
def stream():
try:
yield from body.iter_chunks(64 * 1024)
finally:
body.close()
headers = {
"Content-Length": str(attachment["size_bytes"]),
"Content-Disposition": "attachment; filename*=UTF-8''" + quote(attachment["filename"], safe=""),
"X-Content-Type-Options": "nosniff",
"Cache-Control": "private, no-store",
}
return StreamingResponse(stream(), media_type=attachment["content_type"], headers=headers)
if __name__ == "__main__":
uvicorn.run(
app,
host=config.HOST,
port=config.PORT,
log_level=config.LOG_LEVEL,
access_log=False,
timeout_graceful_shutdown=config.SHUTDOWN_TIMEOUT,
)
+48
View File
@@ -0,0 +1,48 @@
"""Применяет SQL-миграции из каталога migrations по порядку имён. Повторный запуск ничего не меняет."""
import os
import sys
import time
from pathlib import Path
import psycopg
import config
MIGRATIONS_DIR = Path(os.getenv("MIGRATIONS_DIR", "migrations"))
LOCK_ID = 20260201 # любое постоянное число: два мигратора не должны работать одновременно
def connect(attempts=30):
for attempt in range(attempts):
try:
return psycopg.connect(config.database_url(), autocommit=True, connect_timeout=config.DB_CONNECT_TIMEOUT)
except psycopg.OperationalError:
if attempt == attempts - 1:
raise
time.sleep(1)
def main():
files = sorted(MIGRATIONS_DIR.glob("*.sql"))
if not files:
sys.exit(f"в {MIGRATIONS_DIR} нет миграций")
with connect() as conn:
conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,))
conn.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
"version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())"
)
applied = {row[0] for row in conn.execute("SELECT version FROM schema_migrations")}
for path in files:
if path.name in applied:
print("уже применена:", path.name)
continue
# миграция и отметка о ней в одной транзакции: либо всё, либо ничего
with conn.transaction():
conn.execute(path.read_text())
conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.name,))
print("применена:", path.name)
if __name__ == "__main__":
main()
+46
View File
@@ -0,0 +1,46 @@
import boto3
from botocore.config import Config
import config
class ObjectStore:
"""Байты вложений в приватном bucket. Какие операции разрешены, решают права конкретного ключа."""
def __init__(self, access_key: str, secret_key: str):
self.bucket = config.S3_BUCKET
self.client = boto3.client(
"s3",
endpoint_url=config.S3_ENDPOINT,
region_name=config.S3_REGION,
aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
config=Config(
signature_version="s3v4",
s3={"addressing_style": "path"},
connect_timeout=config.S3_CONNECT_TIMEOUT,
read_timeout=config.S3_READ_TIMEOUT,
# без повторов: иначе время ответа при отказе складывается и выходит за timeout server балансировщика
retries={"total_max_attempts": 1},
max_pool_connections=config.S3_POOL_SIZE,
# контрольные суммы протокола выключены: целостность проверяет sha256 приложения
request_checksum_calculation="when_required",
response_checksum_validation="when_required",
),
)
def put(self, key: str, file, size: int, content_type: str) -> None:
# из файла, а не из памяти: boto3 читает его блоками
self.client.put_object(Bucket=self.bucket, Key=key, Body=file, ContentLength=size, ContentType=content_type)
def open(self, key: str):
return self.client.get_object(Bucket=self.bucket, Key=key)["Body"]
def delete(self, key: str) -> None:
self.client.delete_object(Bucket=self.bucket, Key=key)
def pages(self):
"""Объекты bucket страницами, чтобы не держать весь список в памяти."""
paginator = self.client.get_paginator("list_objects_v2")
for page in paginator.paginate(Bucket=self.bucket):
yield page.get("Contents", [])
+41
View File
@@ -0,0 +1,41 @@
"""Создаёт приватный bucket и проверяет его пробной записью. Повторный запуск ничего не меняет.
На пустом хранилище первая запись запускает создание томов, это занимает больше таймаута API.
Пробная запись делает это до старта реплик, иначе первая загрузка пользователя получила бы 503.
"""
import sys
import time
from botocore.exceptions import BotoCoreError, ClientError
import config
from objects import ObjectStore
PROBE_KEY = "bootstrap/probe"
def main():
store = ObjectStore(config.read_secret("S3_ADMIN_ACCESS_KEY_ID"), config.read_secret("S3_ADMIN_SECRET_ACCESS_KEY"))
for attempt in range(30):
try:
existing = [bucket["Name"] for bucket in store.client.list_buckets().get("Buckets", [])]
if store.bucket in existing:
print("bucket уже есть:", store.bucket)
else:
# без ACL и политик: доступ есть только у ключей из конфигурации S3-сервера
store.client.create_bucket(Bucket=store.bucket)
print("bucket создан:", store.bucket)
store.client.put_object(Bucket=store.bucket, Key=PROBE_KEY, Body=b"probe")
store.client.get_object(Bucket=store.bucket, Key=PROBE_KEY)["Body"].read()
store.delete(PROBE_KEY)
print("пробная запись прошла")
return
except (BotoCoreError, ClientError) as error:
print("S3 ещё не готов:", type(error).__name__, flush=True)
time.sleep(1)
sys.exit("S3 не ответил за 30 попыток")
if __name__ == "__main__":
main()
+55
View File
@@ -0,0 +1,55 @@
from typing import Annotated
from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
# только запись 8-4-4-4-12: UUID из Python принял бы ещё скобки, urn: и строку без дефисов
UUID_PATTERN = r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
Uuid = Annotated[str, Field(pattern=UUID_PATTERN)]
def storable(value: str) -> str:
# PostgreSQL не хранит символ NUL в text, а одиночные суррогаты нельзя записать в UTF-8
if "\x00" in value or any(0xD800 <= ord(char) <= 0xDFFF for char in value):
raise ValueError("строка содержит недопустимые символы")
return value
def not_blank(value: str) -> str:
if not value.strip():
raise ValueError("строка не может состоять только из пробелов")
return storable(value)
class StrictModel(BaseModel):
# лишние поля в JSON считаются ошибкой
model_config = ConfigDict(extra="forbid")
class CreateUser(StrictModel):
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
_not_blank = field_validator("display_name", "password")(not_blank)
class CreateChat(StrictModel):
title: str = Field(min_length=1, max_length=100)
member_ids: list[Uuid] = Field(min_length=1, max_length=100)
_title = field_validator("title")(not_blank)
class CreateMessage(StrictModel):
text: str = Field(max_length=4000)
attachment_ids: list[Uuid] = Field(default_factory=list, max_length=10)
_text = field_validator("text")(storable)
@model_validator(mode="after")
def text_or_attachment(self):
if not self.text.strip() and not self.attachment_ids:
raise ValueError("нужен текст или хотя бы одно вложение")
if len({item.lower() for item in self.attachment_ids}) != len(self.attachment_ids):
raise ValueError("attachment_ids содержит повторы")
return self
+45
View File
@@ -0,0 +1,45 @@
import base64
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
# Argon2id, параметры из рекомендаций OWASP: 19 МиБ памяти, 2 прохода, 1 поток
hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
# с этим hash сверяется пароль, когда пользователя нет: время ответа не выдаёт, существует ли username
DUMMY_HASH = hasher.hash("no-such-user-password")
def hash_password(password: str) -> str:
return hasher.hash(password)
def verify_password(password_hash, password: str) -> bool:
try:
return hasher.verify(password_hash or DUMMY_HASH, password) and password_hash is not None
except (VerificationError, InvalidHashError):
return False
def parse_basic(header):
"""Разбирает Authorization: Basic base64(username:password). Возвращает пару или None."""
scheme, _, value = (header or "").partition(" ")
if scheme.lower() != "basic":
return None
try:
decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8")
except ValueError:
# три случая сразу: не ASCII в заголовке (сам ValueError), неверный base64 и байты не в UTF-8
# (их исключения — подклассы ValueError)
return None
# двоеточие в пароле допустимо, поэтому делим только по первому
username, colon, password = decoded.partition(":")
if not colon:
return None
return username, password
def parse_bearer(header):
scheme, _, token = (header or "").partition(" ")
if scheme.lower() != "bearer" or not token.strip():
return None
return token.strip()
+47
View File
@@ -0,0 +1,47 @@
import hashlib
import secrets
import redis
from redis.backoff import NoBackoff
from redis.retry import Retry
import config
class Sessions:
"""Сессии лежат только в Redis: ключ session:<sha256 токена>, значение id пользователя, TTL ставит сам Redis."""
def __init__(self, url: str):
pool = redis.BlockingConnectionPool.from_url(
url,
max_connections=config.CACHE_POOL_MAX_SIZE,
timeout=config.CACHE_TIMEOUT, # ожидание свободного соединения
socket_timeout=config.CACHE_TIMEOUT,
socket_connect_timeout=config.CACHE_TIMEOUT,
decode_responses=True,
# одна повторная попытка без паузы: её хватает после перезапуска Redis, а при отказе ответ не затягивается
retry=Retry(NoBackoff(), 1),
)
self.client = redis.Redis(connection_pool=pool)
@staticmethod
def key(token: str) -> str:
# сам токен в Redis не хранится: по дампу нельзя войти от чужого имени
return "session:" + hashlib.sha256(token.encode()).hexdigest()
def create(self, user_id: str) -> str:
token = secrets.token_urlsafe(32) # 256 бит случайности
self.client.set(self.key(token), user_id, ex=config.SESSION_TTL_SECONDS)
return token
def user_id(self, token: str):
return self.client.get(self.key(token))
def revoke(self, token: str) -> None:
self.client.delete(self.key(token))
def ping(self) -> None:
self.client.ping()
def close(self) -> None:
self.client.close()
+298
View File
@@ -0,0 +1,298 @@
import uuid
from datetime import timezone
from psycopg import errors
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
import config
class UsernameTaken(Exception):
pass
class UnknownMember(Exception):
pass
class IdempotencyConflict(Exception):
pass
class UnknownAttachment(Exception):
pass
# ширина строки фиксированная: 6 знаков микросекунд, столько же хранит timestamptz
TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
def timestamp(value) -> str:
return value.astimezone(timezone.utc).strftime(TIME_FORMAT)
def user_json(row) -> dict:
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": timestamp(row["created_at"]),
}
def chat_json(row) -> dict:
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": [str(member) for member in row["member_ids"]],
"created_at": timestamp(row["created_at"]),
}
def message_json(row) -> dict:
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": timestamp(row["created_at"]),
"attachment_ids": [str(item) for item in row["attachment_ids"]],
}
def attachment_json(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": "ready",
"variants": [],
"error_code": None,
"created_at": timestamp(row["created_at"]),
"updated_at": timestamp(row["updated_at"]),
}
CHAT_COLUMNS = """
c.id, c.title, c.created_at,
(SELECT array_agg(m.user_id ORDER BY m.position) FROM chat_members m WHERE m.chat_id = c.id) AS member_ids
"""
MESSAGE_COLUMNS = """
m.id, m.chat_id, m.sender_id, m.text, m.created_at,
COALESCE((SELECT array_agg(a.attachment_id ORDER BY a.position) FROM message_attachments a
WHERE a.message_id = m.id), '{}'::uuid[]) AS attachment_ids
"""
ATTACHMENT_COLUMNS = "a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256, a.created_at, a.updated_at"
class Store:
"""Все данные мессенджера в PostgreSQL. Значения в запросы попадают только через параметры %s."""
def __init__(self, url: str):
self.pool = ConnectionPool(
url,
min_size=config.DB_POOL_MIN_SIZE,
max_size=config.DB_POOL_MAX_SIZE,
timeout=config.DB_POOL_TIMEOUT, # сколько запрос ждёт свободное соединение
kwargs={
"connect_timeout": config.DB_CONNECT_TIMEOUT,
"options": f"-c statement_timeout={config.DB_STATEMENT_TIMEOUT * 1000}",
"row_factory": dict_row,
},
# перед выдачей соединение проверяется, поэтому после перезапуска БД мёртвые соединения не достаются запросам
check=ConnectionPool.check_connection,
open=False,
)
def open(self) -> None:
# не ждём БД: если она недоступна, сервер стартует и отвечает 503
self.pool.open(wait=False)
def close(self) -> None:
self.pool.close()
def ping(self) -> None:
with self.pool.connection() as conn:
conn.execute("SELECT 1")
def create_user(self, username: str, display_name: str, password_hash: str) -> dict:
with self.pool.connection() as conn:
try:
row = conn.execute(
"INSERT INTO users (username, display_name, password_hash) VALUES (%s, %s, %s) "
"RETURNING id, username, display_name, created_at",
(username, display_name, password_hash),
).fetchone()
except errors.UniqueViolation:
# уникальность проверяет сама БД, поэтому два одновременных запроса не создадут двух пользователей
raise UsernameTaken()
return user_json(row)
def get_user(self, user_id: str):
with self.pool.connection() as conn:
row = conn.execute(
"SELECT id, username, display_name, created_at FROM users WHERE id = %s", (user_id,)
).fetchone()
return user_json(row) if row else None
def get_credentials(self, username: str):
"""Пользователь и hash его пароля или (None, None)."""
with self.pool.connection() as conn:
row = conn.execute(
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
(username,),
).fetchone()
if row is None:
return None, None
return user_json(row), row["password_hash"]
def create_chat(self, title: str, member_ids: list) -> dict:
# блок with — одна транзакция: commit при выходе, rollback при любом исключении
with self.pool.connection() as conn:
chat = conn.execute(
"INSERT INTO chats (title) VALUES (%s) RETURNING id, title, created_at", (title,)
).fetchone()
try:
with conn.cursor() as cursor:
cursor.executemany(
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
[(chat["id"], member, position) for position, member in enumerate(member_ids)],
)
except errors.ForeignKeyViolation:
# участника нет в users: транзакция откатывается вместе с уже вставленным чатом
raise UnknownMember()
return chat_json({**chat, "member_ids": member_ids})
def get_chat(self, chat_id: str, user_id: str):
with self.pool.connection() as conn:
row = conn.execute(
f"SELECT {CHAT_COLUMNS} FROM chats c "
"JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s WHERE c.id = %s",
(user_id, chat_id),
).fetchone()
return chat_json(row) if row else None
def list_chats(self, user_id: str, after, limit: int):
query = f"SELECT {CHAT_COLUMNS} FROM chats c JOIN chat_members me ON me.chat_id = c.id WHERE me.user_id = %s"
params = [user_id]
if after:
query += " AND (c.created_at, c.id) > (%s, %s)"
params += after
query += " ORDER BY c.created_at, c.id LIMIT %s"
with self.pool.connection() as conn:
rows = conn.execute(query, params + [limit + 1]).fetchall()
return [chat_json(row) for row in rows[:limit]], len(rows) > limit
def add_message(self, chat_id: str, sender_id: str, text: str, attachment_ids: list, key: str):
"""Отправляет сообщение один раз на ключ. Повтор с тем же телом возвращает исходное сообщение."""
message_id = uuid.uuid4()
# ключ, сообщение и ссылки на вложения пишутся в одной транзакции: при сбое не остаётся ничего
with self.pool.connection() as conn:
if not self._is_member(conn, chat_id, sender_id):
return None
# параллельный запрос с тем же ключом ждёт здесь, пока первая транзакция не завершится;
# строка возвращается, только если ключ свободен или его срок вышел
claimed = conn.execute(
"INSERT INTO idempotency_keys (user_id, chat_id, key, message_id) VALUES (%s, %s, %s, %s) "
"ON CONFLICT (user_id, chat_id, key) DO UPDATE "
"SET message_id = EXCLUDED.message_id, created_at = now() "
"WHERE idempotency_keys.created_at < now() - make_interval(secs => %s) "
"RETURNING message_id",
(sender_id, chat_id, key, message_id, config.IDEMPOTENCY_TTL_SECONDS),
).fetchone()
if claimed:
self._check_attachments(conn, chat_id, attachment_ids)
conn.execute(
"INSERT INTO messages (id, chat_id, sender_id, text) VALUES (%s, %s, %s, %s)",
(message_id, chat_id, sender_id, text),
)
if attachment_ids:
with conn.cursor() as cursor:
cursor.executemany(
"INSERT INTO message_attachments (message_id, attachment_id, position) VALUES (%s, %s, %s)",
[(message_id, item, position) for position, item in enumerate(attachment_ids)],
)
row = conn.execute(
f"SELECT {MESSAGE_COLUMNS} FROM idempotency_keys k JOIN messages m ON m.id = k.message_id "
"WHERE k.user_id = %s AND k.chat_id = %s AND k.key = %s",
(sender_id, chat_id, key),
).fetchone()
message = message_json(row)
if message["text"] != text or message["attachment_ids"] != attachment_ids:
raise IdempotencyConflict()
return message
@staticmethod
def _check_attachments(conn, chat_id: str, attachment_ids: list) -> None:
"""Все вложения должны быть готовы и лежать в этом чате; исключение откатывает транзакцию с ключом."""
if not attachment_ids:
return
found = conn.execute(
"SELECT count(*) AS total FROM attachments WHERE id = ANY(%s::uuid[]) AND chat_id = %s AND state = 'ready'",
(attachment_ids, chat_id),
).fetchone()
if found["total"] != len(attachment_ids):
raise UnknownAttachment()
def create_pending_attachment(self, attachment_id, chat_id, owner_id, filename, content_type, size, sha256, key) -> None:
# строка записывается до объекта: так в S3 не появится объект, о котором не знает БД
with self.pool.connection() as conn:
conn.execute(
"INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key, state) "
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s, 'pending')",
(attachment_id, chat_id, owner_id, filename, content_type, size, sha256, key),
)
def mark_attachment_ready(self, attachment_id):
with self.pool.connection() as conn:
row = conn.execute(
"UPDATE attachments a SET state = 'ready', updated_at = now() "
f"WHERE a.id = %s AND a.state = 'pending' RETURNING {ATTACHMENT_COLUMNS}",
(attachment_id,),
).fetchone()
return attachment_json(row) if row else None
def get_attachment(self, attachment_id: str, user_id: str):
"""Готовое вложение и его object_key, если пользователь состоит в чате."""
with self.pool.connection() as conn:
row = conn.execute(
f"SELECT {ATTACHMENT_COLUMNS}, a.object_key FROM attachments a "
"JOIN chat_members me ON me.chat_id = a.chat_id AND me.user_id = %s "
"WHERE a.id = %s AND a.state = 'ready'",
(user_id, attachment_id),
).fetchone()
return (attachment_json(row), row["object_key"]) if row else (None, None)
def is_member(self, chat_id: str, user_id: str) -> bool:
with self.pool.connection() as conn:
return self._is_member(conn, chat_id, user_id)
def list_messages(self, chat_id: str, user_id: str, after, limit: int):
query = f"SELECT {MESSAGE_COLUMNS} FROM messages m WHERE m.chat_id = %s"
params = [chat_id]
if after:
# keyset: продолжаем с записи после cursor, а не пропускаем N строк
query += " AND (m.created_at, m.id) > (%s, %s)"
params += after
query += " ORDER BY m.created_at, m.id LIMIT %s"
with self.pool.connection() as conn:
if not self._is_member(conn, chat_id, user_id):
return None
# limit + 1: лишняя строка показывает, есть ли следующая страница
rows = conn.execute(query, params + [limit + 1]).fetchall()
return [message_json(row) for row in rows[:limit]], len(rows) > limit
@staticmethod
def _is_member(conn, chat_id: str, user_id: str) -> bool:
row = conn.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user_id)
).fetchone()
return row is not None