Добавить X-Instance-Id, общую идемпотентность и строгий разбор тела запроса

This commit is contained in:
2026-10-30 21:43:16 +03:00
parent 0ab3a341aa
commit 91f1b3c06e
12 changed files with 895 additions and 0 deletions
+39
View File
@@ -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);
+12
View File
@@ -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)
);
+24
View File
@@ -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
+47
View File
@@ -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")
+38
View File
@@ -0,0 +1,38 @@
from fastapi.responses import JSONResponse
class ApiError(Exception):
def __init__(self, status: int, code: str, message: str, headers=None):
self.status = status
self.code = code
self.message = message
self.headers = headers
def invalid(message: str) -> ApiError:
return ApiError(400, "invalid_request", message)
def bad_credentials() -> ApiError:
# один и тот же ответ для неизвестного username и неверного пароля
return ApiError(
401, "unauthorized", "Неверное имя пользователя или пароль",
{"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'},
)
def unauthorized() -> ApiError:
return ApiError(
401, "unauthorized", "Нужен действующий Bearer-токен",
{"WWW-Authenticate": 'Bearer realm="messenger"'},
)
def not_found() -> ApiError:
# одинаковый ответ для несуществующего и чужого объекта
return ApiError(404, "not_found", "Объект не найден")
def error_response(request_id: str, status: int, code: str, message: str, headers=None) -> JSONResponse:
body = {"error": {"code": code, "message": message, "request_id": request_id}}
return JSONResponse(body, status_code=status, headers=headers)
+11
View File
@@ -0,0 +1,11 @@
"""Проверка для Docker HEALTHCHECK: код 0, если /health/ready отвечает 200."""
import os
import sys
import urllib.request
port = os.getenv("APP_PORT", "8080")
try:
with urllib.request.urlopen(f"http://127.0.0.1:{port}/health/ready", timeout=4) as response:
sys.exit(0 if response.status == 200 else 1)
except Exception:
sys.exit(1)
+326
View File
@@ -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,
)
+48
View File
@@ -0,0 +1,48 @@
"""Применяет SQL-миграции из каталога migrations по порядку имён. Повторный запуск ничего не меняет."""
import os
import sys
import time
from pathlib import Path
import psycopg
import config
MIGRATIONS_DIR = Path(os.getenv("MIGRATIONS_DIR", "migrations"))
LOCK_ID = 20260201 # любое постоянное число: два мигратора не должны работать одновременно
def connect(attempts=30):
for attempt in range(attempts):
try:
return psycopg.connect(config.database_url(), autocommit=True, connect_timeout=config.DB_CONNECT_TIMEOUT)
except psycopg.OperationalError:
if attempt == attempts - 1:
raise
time.sleep(1)
def main():
files = sorted(MIGRATIONS_DIR.glob("*.sql"))
if not files:
sys.exit(f"в {MIGRATIONS_DIR} нет миграций")
with connect() as conn:
conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,))
conn.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
"version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())"
)
applied = {row[0] for row in conn.execute("SELECT version FROM schema_migrations")}
for path in files:
if path.name in applied:
print("уже применена:", path.name)
continue
# миграция и отметка о ней в одной транзакции: либо всё, либо ничего
with conn.transaction():
conn.execute(path.read_text())
conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.name,))
print("применена:", path.name)
if __name__ == "__main__":
main()
+42
View File
@@ -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)
+45
View File
@@ -0,0 +1,45 @@
import base64
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
# Argon2id, параметры из рекомендаций OWASP: 19 МиБ памяти, 2 прохода, 1 поток
hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
# с этим hash сверяется пароль, когда пользователя нет: время ответа не выдаёт, существует ли username
DUMMY_HASH = hasher.hash("no-such-user-password")
def hash_password(password: str) -> str:
return hasher.hash(password)
def verify_password(password_hash, password: str) -> bool:
try:
return hasher.verify(password_hash or DUMMY_HASH, password) and password_hash is not None
except (VerificationError, InvalidHashError):
return False
def parse_basic(header):
"""Разбирает Authorization: Basic base64(username:password). Возвращает пару или None."""
scheme, _, value = (header or "").partition(" ")
if scheme.lower() != "basic":
return None
try:
decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8")
except ValueError:
# три случая сразу: не ASCII в заголовке (сам ValueError), неверный base64 и байты не в UTF-8
# (их исключения — подклассы ValueError)
return None
# двоеточие в пароле допустимо, поэтому делим только по первому
username, colon, password = decoded.partition(":")
if not colon:
return None
return username, password
def parse_bearer(header):
scheme, _, token = (header or "").partition(" ")
if scheme.lower() != "bearer" or not token.strip():
return None
return token.strip()
+47
View File
@@ -0,0 +1,47 @@
import hashlib
import secrets
import redis
from redis.backoff import NoBackoff
from redis.retry import Retry
import config
class Sessions:
"""Сессии лежат только в Redis: ключ session:<sha256 токена>, значение id пользователя, TTL ставит сам Redis."""
def __init__(self, url: str):
pool = redis.BlockingConnectionPool.from_url(
url,
max_connections=config.CACHE_POOL_MAX_SIZE,
timeout=config.CACHE_TIMEOUT, # ожидание свободного соединения
socket_timeout=config.CACHE_TIMEOUT,
socket_connect_timeout=config.CACHE_TIMEOUT,
decode_responses=True,
# одна повторная попытка без паузы: её хватает после перезапуска Redis, а при отказе ответ не затягивается
retry=Retry(NoBackoff(), 1),
)
self.client = redis.Redis(connection_pool=pool)
@staticmethod
def key(token: str) -> str:
# сам токен в Redis не хранится: по дампу нельзя войти от чужого имени
return "session:" + hashlib.sha256(token.encode()).hexdigest()
def create(self, user_id: str) -> str:
token = secrets.token_urlsafe(32) # 256 бит случайности
self.client.set(self.key(token), user_id, ex=config.SESSION_TTL_SECONDS)
return token
def user_id(self, token: str):
return self.client.get(self.key(token))
def revoke(self, token: str) -> None:
self.client.delete(self.key(token))
def ping(self) -> None:
self.client.ping()
def close(self) -> None:
self.client.close()
+216
View File
@@ -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