forked from mtusi2026/mtusi2026lab4
Добавить вложения: S3, метаданные в PostgreSQL и очистка незавершённых загрузок
This commit is contained in:
@@ -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")
|
||||
@@ -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)
|
||||
@@ -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
@@ -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
|
||||
@@ -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
@@ -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,
|
||||
)
|
||||
@@ -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()
|
||||
@@ -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", [])
|
||||
@@ -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()
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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
@@ -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
|
||||
Reference in New Issue
Block a user