Добавить X-Instance-Id, общую идемпотентность и строгий разбор тела запроса
This commit is contained in:
@@ -0,0 +1,39 @@
|
||||
-- Пользователи, чаты, участники и сообщения.
|
||||
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100),
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
-- порядок участника в исходном запросе, чтобы member_ids возвращались как были переданы
|
||||
position integer NOT NULL,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
-- список чатов пользователя: поиск по user_id, первичный ключ начинается с chat_id и для этого не подходит
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
sender_id uuid NOT NULL REFERENCES users (id),
|
||||
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
-- история чата читается запросом
|
||||
-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT $4
|
||||
-- индекс в том же порядке даёт и фильтр, и сортировку без чтения всей истории
|
||||
CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id);
|
||||
@@ -0,0 +1,12 @@
|
||||
-- Результат отправки сообщения по Idempotency-Key. Только новая таблица: версия API без неё продолжает работать.
|
||||
|
||||
CREATE TABLE idempotency_keys (
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
key text NOT NULL CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'),
|
||||
-- проверка отложена до COMMIT: ключ вставляется раньше сообщения, чтобы занять его первым
|
||||
message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
-- область уникальности из контракта: пользователь + метод + путь чата + ключ
|
||||
PRIMARY KEY (user_id, chat_id, key)
|
||||
);
|
||||
@@ -0,0 +1,24 @@
|
||||
# Прямые зависимости
|
||||
fastapi==0.143.0
|
||||
uvicorn==0.54.0
|
||||
psycopg[binary,pool]==3.3.6
|
||||
redis==8.1.0
|
||||
argon2-cffi==25.1.0
|
||||
# Транзитивные, зафиксированы по pip freeze в python:3.13.16-slim-bookworm
|
||||
annotated-doc==0.0.5
|
||||
annotated-types==0.8.0
|
||||
anyio==4.15.1
|
||||
argon2-cffi-bindings==26.1.0
|
||||
cffi==2.1.1
|
||||
click==8.5.0
|
||||
h11==0.16.0
|
||||
idna==3.20
|
||||
opentelemetry-api==1.45.1
|
||||
psycopg-binary==3.3.6
|
||||
psycopg-pool==3.3.3
|
||||
pycparser==3.1
|
||||
pydantic==2.13.5
|
||||
pydantic_core==2.46.5
|
||||
starlette==1.7.0
|
||||
typing-inspection==0.4.4
|
||||
typing_extensions==4.16.0
|
||||
@@ -0,0 +1,47 @@
|
||||
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"))
|
||||
|
||||
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)
|
||||
+326
@@ -0,0 +1,326 @@
|
||||
import base64
|
||||
import json
|
||||
import logging
|
||||
import re
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from typing import Annotated
|
||||
from uuid import UUID
|
||||
|
||||
import psycopg
|
||||
import redis
|
||||
import uvicorn
|
||||
from fastapi import Depends, FastAPI, Path, Query, Request, Response
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from pydantic import ValidationError
|
||||
from starlette.exceptions import HTTPException
|
||||
|
||||
import config
|
||||
import security
|
||||
from errors import ApiError, bad_credentials, error_response, invalid, not_found, unauthorized
|
||||
from schemas import UUID_PATTERN, CreateChat, CreateMessage, CreateUser
|
||||
from sessions import Sessions
|
||||
from store import TIME_FORMAT, IdempotencyConflict, Store, 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)]
|
||||
|
||||
store = Store(config.database_url())
|
||||
sessions = Sessions(config.cache_url())
|
||||
|
||||
|
||||
@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 lab3", 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", "Сервис временно недоступен")
|
||||
|
||||
|
||||
@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:
|
||||
# decode строгий: контракт допускает только UTF-8, а json.loads сам угадал бы UTF-16
|
||||
data = json.loads((await request.body()).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 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:
|
||||
message = store.add_message(str(UUID(chat_id)), session.user_id, body.text, key)
|
||||
except IdempotencyConflict:
|
||||
raise ApiError(409, "conflict", "Этот Idempotency-Key уже использован с другим сообщением")
|
||||
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)
|
||||
|
||||
|
||||
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,42 @@
|
||||
from typing import Annotated
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field, field_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 not_blank(value: str) -> str:
|
||||
if not value.strip():
|
||||
raise ValueError("строка не может состоять только из пробелов")
|
||||
# PostgreSQL не хранит символ NUL в text, а одиночные суррогаты нельзя записать в UTF-8
|
||||
if "\x00" in value or any(0xD800 <= ord(char) <= 0xDFFF for char in value):
|
||||
raise ValueError("строка содержит недопустимые символы")
|
||||
return 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(min_length=1, max_length=4000)
|
||||
|
||||
_text = field_validator("text")(not_blank)
|
||||
@@ -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()
|
||||
+216
@@ -0,0 +1,216 @@
|
||||
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
|
||||
|
||||
|
||||
# ширина строки фиксированная: 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"]),
|
||||
}
|
||||
|
||||
|
||||
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
|
||||
"""
|
||||
|
||||
|
||||
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, 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:
|
||||
row = conn.execute(
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text) VALUES (%s, %s, %s, %s) "
|
||||
"RETURNING id, chat_id, sender_id, text, created_at",
|
||||
(message_id, chat_id, sender_id, text),
|
||||
).fetchone()
|
||||
return message_json(row)
|
||||
row = conn.execute(
|
||||
"SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at 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()
|
||||
if row["text"] != text:
|
||||
raise IdempotencyConflict()
|
||||
return message_json(row)
|
||||
|
||||
def list_messages(self, chat_id: str, user_id: str, after, limit: int):
|
||||
query = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s"
|
||||
params = [chat_id]
|
||||
if after:
|
||||
# keyset: продолжаем с записи после cursor, а не пропускаем N строк
|
||||
query += " AND (created_at, id) > (%s, %s)"
|
||||
params += after
|
||||
query += " ORDER BY created_at, 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