ЛР3: HAProxy, реплики API, идемпотентность, отказы и rolling update, исследование масштабирования

This commit is contained in:
kolya5544
2026-10-03 05:10:45 +03:00
parent 0ab3a341aa
commit 7e6f66c3db
51 changed files with 6943 additions and 21 deletions
+58
View File
@@ -0,0 +1,58 @@
"""Конфигурация из переменных окружения (см. .env.example)."""
import os
def _int(name, default):
value = os.environ.get(name)
return int(value) if value not in (None, "") else default
def _float(name, default):
value = os.environ.get(name)
return float(value) if value not in (None, "") else default
def _secret(name, default=""):
"""Значение из переменной NAME либо из файла NAME_FILE (Docker secrets); файл читается один раз."""
if os.environ.get(name):
return os.environ[name]
path = os.environ.get(name + "_FILE")
if path and os.path.exists(path):
with open(path, encoding="utf-8") as fh:
return fh.read().strip()
return default
APP_HOST = os.environ.get("APP_HOST", "0.0.0.0")
APP_PORT = _int("APP_PORT", 8080)
APP_ENV = os.environ.get("APP_ENV", "lab")
DATABASE_URL = _secret("DATABASE_URL")
DB_POOL_MIN = _int("DB_POOL_MIN", 2)
DB_POOL_MAX = _int("DB_POOL_MAX", 10)
DB_ACQUIRE_TIMEOUT = _float("DB_ACQUIRE_TIMEOUT", 2.0) # ожидание свободного соединения пула
DB_COMMAND_TIMEOUT = _float("DB_COMMAND_TIMEOUT", 5.0) # таймаут одного запроса
DB_CONNECT_TIMEOUT = _float("DB_CONNECT_TIMEOUT", 2.0)
VALKEY_URL = os.environ.get("VALKEY_URL", "") # пусто = кэш сессий выключен
VALKEY_TIMEOUT = _float("VALKEY_TIMEOUT", 0.2)
VALKEY_BREAKER_SECONDS = _float("VALKEY_BREAKER_SECONDS", 5.0)
SESSION_TTL_SECONDS = _int("SESSION_TTL_SECONDS", 3600)
SESSION_CACHE_TTL_SECONDS = _int("SESSION_CACHE_TTL_SECONDS", 60)
ARGON2_TIME_COST = _int("ARGON2_TIME_COST", 2)
ARGON2_MEMORY_KIB = _int("ARGON2_MEMORY_KIB", 19456) # 19 MiB, рекомендация OWASP
ARGON2_PARALLELISM = _int("ARGON2_PARALLELISM", 1)
HASH_CONCURRENCY = _int("HASH_CONCURRENCY", 4)
MAX_BODY_BYTES = _int("MAX_BODY_BYTES", 65536)
MAX_INFLIGHT = _int("MAX_INFLIGHT", 64)
LIMIT_CONCURRENCY = _int("LIMIT_CONCURRENCY", 1000)
RETRY_AFTER_SECONDS = _int("RETRY_AFTER_SECONDS", 1)
MIGRATIONS_DIR = os.environ.get("MIGRATIONS_DIR", os.path.join(os.path.dirname(__file__), "..", "..", "migrations"))
DRAIN_SECONDS = _float("DRAIN_SECONDS", 4.0) # после SIGTERM: readiness=503, сервер ещё принимает запросы
GRACEFUL_SHUTDOWN_SECONDS = _int("GRACEFUL_SHUTDOWN_SECONDS", 8)
KEEPALIVE_SECONDS = _int("KEEPALIVE_SECONDS", 5)
IDEMPOTENCY_TTL_SECONDS = _int("IDEMPOTENCY_TTL_SECONDS", 24 * 3600)
SEND_STRATEGY = os.environ.get("SEND_STRATEGY", "function") # function (миграция 0003) | multi (несколько запросов в транзакции)
+71
View File
@@ -0,0 +1,71 @@
"""PostgreSQL: ограниченный пул asyncpg, таймауты, перевод сбоев зависимости в 503."""
import asyncio
from contextlib import asynccontextmanager
import asyncpg
from . import config
from .web import log, unavailable
DEPENDENCY_ERRORS = (asyncpg.PostgresConnectionError, asyncpg.InterfaceError, asyncpg.exceptions.OperatorInterventionError,
asyncpg.exceptions.InsufficientResourcesError, asyncio.TimeoutError, OSError)
_RETRYABLE = (asyncpg.ConnectionDoesNotExistError, asyncpg.InterfaceError, ConnectionResetError)
class Database:
def __init__(self):
self.pool = None
async def start(self):
if not config.DATABASE_URL:
log("error", "database_url_missing")
return
# min_size=0: приложение стартует и без БД (readiness покажет 503), пул подключается лениво.
self.pool = await asyncpg.create_pool(
dsn=config.DATABASE_URL, min_size=0, max_size=config.DB_POOL_MAX,
command_timeout=config.DB_COMMAND_TIMEOUT, timeout=config.DB_CONNECT_TIMEOUT,
max_inactive_connection_lifetime=60,
server_settings={"application_name": "messenger-api", "timezone": "UTC"})
async def stop(self):
if self.pool:
try:
await asyncio.wait_for(self.pool.close(), 3)
except Exception:
self.pool.terminate()
@asynccontextmanager
async def conn(self):
if self.pool is None:
raise unavailable("База данных не настроена")
try:
async with self.pool.acquire(timeout=config.DB_ACQUIRE_TIMEOUT) as connection:
yield connection
except DEPENDENCY_ERRORS as exc:
log("warning", "db_unavailable", error_type=type(exc).__name__)
raise unavailable() from exc
async def _run(self, method, sql, args, retry):
for attempt in (0, 1):
try:
async with self.conn() as c:
return await getattr(c, method)(sql, *args)
except Exception as exc:
if attempt == 0 and retry and isinstance(exc.__cause__, _RETRYABLE):
continue # разорванное соединение пула (рестарт БД): один повтор только для чтения
raise
async def fetch(self, sql, *args):
return await self._run("fetch", sql, args, True)
async def fetchrow(self, sql, *args, retry=True):
return await self._run("fetchrow", sql, args, retry)
async def fetchval(self, sql, *args):
return await self._run("fetchval", sql, args, True)
async def execute(self, sql, *args):
return await self._run("execute", sql, args, False)
async def ping(self):
return await asyncio.wait_for(self.fetchval("SELECT 1"), 1.0)
+415
View File
@@ -0,0 +1,415 @@
"""ASGI-приложение мессенджера (lab2): REST API, PostgreSQL, сессии Bearer, кэш Valkey."""
import asyncio
import base64
import binascii
import hashlib
import json
import os
import re
import time
import uuid
import asyncpg
from . import config, passwords
from .db import DEPENDENCY_ERRORS, Database
from .sessions import SessionCache, Sessions
from .web import (ApiError, Request, bad, dt_to_us, encode_cursor, format_dt, log, new_request_id, page_params,
parse_json_object, parse_uuid, respond, unavailable, us_to_dt, valid_text, USERNAME_RE)
ROUTES = [
("health_live", re.compile(r"/health/live"), {"GET"}),
("health_ready", re.compile(r"/health/ready"), {"GET"}),
("users", re.compile(r"/api/v1/users"), {"POST"}),
("users_me", re.compile(r"/api/v1/users/me"), {"GET"}),
("create_session", re.compile(r"/api/v1/auth/sessions"), {"POST"}),
("session_current", re.compile(r"/api/v1/auth/sessions/current"), {"DELETE"}),
("chats", re.compile(r"/api/v1/chats"), {"GET", "POST"}),
("chat", re.compile(r"/api/v1/chats/(?P<chat_id>[^/]+)"), {"GET"}),
("messages", re.compile(r"/api/v1/chats/(?P<chat_id>[^/]+)/messages"), {"GET", "POST"}),
]
ROUTE_LABELS = {
"health_live": "/health/live", "health_ready": "/health/ready", "users": "/api/v1/users",
"users_me": "/api/v1/users/me", "create_session": "/api/v1/auth/sessions",
"session_current": "/api/v1/auth/sessions/current", "chats": "/api/v1/chats",
"chat": "/api/v1/chats/{chat_id}", "messages": "/api/v1/chats/{chat_id}/messages",
}
TOKEN_RE = re.compile(r"[A-Za-z0-9_-]{32,128}")
IDEMPOTENCY_KEY_RE = re.compile(r"[A-Za-z0-9._:-]{1,128}")
BEARER = 'Bearer realm="messenger"'
BASIC = 'Basic realm="messenger", charset="UTF-8"'
# Идентификатор реплики: имя хоста контейнера (12 hex, == короткий ID контейнера) -> легко сопоставить с docker ps.
INSTANCE_ID = os.environ.get("INSTANCE_ID") or (os.environ.get("HOSTNAME") or uuid.uuid4().hex)[:12]
CHAT_SELECT = ("SELECT c.id, c.title, c.created_at, "
"(SELECT array_agg(m2.user_id ORDER BY m2.ord) FROM chat_members m2 WHERE m2.chat_id = c.id) AS member_ids ")
def user_json(row):
return {"id": str(row["id"]), "username": row["username"], "display_name": row["display_name"],
"created_at": format_dt(row["created_at"])}
def chat_json(row):
return {"id": str(row["id"]), "title": row["title"], "member_ids": [str(x) for x in row["member_ids"]],
"created_at": format_dt(row["created_at"])}
def message_json(row):
return {"id": str(row["id"]), "chat_id": str(row["chat_id"]), "sender_id": str(row["sender_id"]),
"text": row["text"], "created_at": format_dt(row["created_at"])}
def unauthorized(challenge=BEARER, message="Требуется действительная сессия"):
return ApiError(401, "unauthorized", message, {"www-authenticate": challenge})
class Messenger:
def __init__(self):
self.db = Database()
self.cache = SessionCache()
self.sessions = Sessions(self.db, self.cache)
self.inflight = 0
self.draining = False
# --- аутентификация ------------------------------------------------------
@staticmethod
def bearer_token(req):
header = req.headers.get("authorization", "")
scheme, _, token = header.partition(" ")
if scheme.lower() != "bearer" or not TOKEN_RE.fullmatch(token.strip()):
raise unauthorized()
return token.strip()
async def authenticate(self, req):
token = self.bearer_token(req)
user_id = await self.sessions.resolve(token)
if user_id is None:
raise unauthorized()
req.user_id, req.token = user_id, token
return user_id
# --- обработчики -----------------------------------------------------------
async def health_live(self, req, params):
return 200, {"status": "ok"}
async def health_ready(self, req, params):
# Критичная зависимость — PostgreSQL. Valkey — необязательный кэш: его отказ не останавливает API.
if self.draining:
raise unavailable("Сервис останавливается")
try:
await self.db.ping()
except ApiError:
raise
except Exception:
raise unavailable() from None
return 200, {"status": "ok"}
async def users(self, req, params):
req.require_json_media_type()
data = parse_json_object(await req.body(), {"username", "display_name", "password"},
{"username", "display_name", "password"})
username = data["username"]
if not isinstance(username, str) or not USERNAME_RE.fullmatch(username):
raise bad("username должен соответствовать [a-z0-9_]{3,32}")
display_name = valid_text(data["display_name"], "display_name", 100)
password = valid_text(data["password"], "password", 128, allow_empty=True)
if len(password) < 12:
raise bad("password должен содержать от 12 до 128 символов")
pw_hash = await passwords.hash_password(password)
row = await self.db.fetchrow(
"INSERT INTO users (id, username, display_name, password_hash) VALUES ($1, $2, $3, $4) "
"ON CONFLICT (username) DO NOTHING RETURNING id, username, display_name, created_at",
uuid.uuid4(), username, display_name, pw_hash)
if row is None:
raise ApiError(409, "conflict", "username уже занят")
return 201, user_json(row)
async def users_me(self, req, params):
user_id = await self.authenticate(req)
row = await self.db.fetchrow("SELECT id, username, display_name, created_at FROM users WHERE id = $1", user_id)
if row is None:
raise unauthorized()
return 200, user_json(row)
async def create_session(self, req, params):
header = req.headers.get("authorization", "")
scheme, _, value = header.partition(" ")
if scheme.lower() != "basic" or not value.strip():
raise unauthorized(BASIC, "Неверные учётные данные")
try:
decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8")
username, sep, password = decoded.partition(":")
if not sep:
raise ValueError
except (binascii.Error, ValueError, UnicodeDecodeError):
raise unauthorized(BASIC, "Неверные учётные данные") from None
row = None
if USERNAME_RE.fullmatch(username):
row = await self.db.fetchrow("SELECT id, username, display_name, created_at, password_hash FROM users "
"WHERE username = $1", username)
ok = await passwords.verify_password(row["password_hash"] if row else None, password)
if not ok:
raise unauthorized(BASIC, "Неверные учётные данные")
token, expires_at = await self.sessions.create(row["id"])
return 201, {"token": token, "token_type": "Bearer", "expires_at": format_dt(expires_at), "user": user_json(row)}
async def session_current(self, req, params):
await self.authenticate(req)
await self.sessions.revoke(req.token)
return 204, None
async def chats(self, req, params):
user_id = await self.authenticate(req)
if req.method == "GET":
limit, after = page_params(req.query, "c", user_id)
if after is None:
rows = await self.db.fetch(
CHAT_SELECT + "FROM chat_members m JOIN chats c ON c.id = m.chat_id WHERE m.user_id = $1 "
"ORDER BY m.chat_created_at, m.chat_id LIMIT $2", user_id, limit + 1)
else:
rows = await self.db.fetch(
CHAT_SELECT + "FROM chat_members m JOIN chats c ON c.id = m.chat_id WHERE m.user_id = $1 "
"AND (m.chat_created_at, m.chat_id) > ($2, $3) ORDER BY m.chat_created_at, m.chat_id LIMIT $4",
user_id, us_to_dt(after[0]), uuid.UUID(after[1]), limit + 1)
more = len(rows) > limit
rows = rows[:limit]
cursor = encode_cursor("c", user_id, (dt_to_us(rows[-1]["created_at"]), str(rows[-1]["id"]))) if more else None
return 200, {"items": [chat_json(r) for r in rows], "next_cursor": cursor}
req.require_json_media_type()
data = parse_json_object(await req.body(), {"title", "member_ids"}, {"title", "member_ids"})
title = valid_text(data["title"], "title", 100)
members = data["member_ids"]
if not isinstance(members, list) or not 1 <= len(members) <= 100:
raise bad("member_ids должен содержать от 1 до 100 элементов")
ids = [parse_uuid(m, "member_id") for m in members]
if len(set(ids)) != len(ids):
raise bad("member_ids содержит дубликаты")
if user_id not in ids:
raise bad("Создатель должен быть в member_ids")
chat_id = uuid.uuid4()
uuids = [uuid.UUID(i) for i in ids]
try:
async with self.db.conn() as c:
async with c.transaction(): # чат и участники создаются атомарно
# Существование участников проверяет внешний ключ chat_members.user_id: при неизвестном
# участнике вставка падает и откатывается вся транзакция, включая уже созданный чат.
created = await c.fetchval("INSERT INTO chats (id, title) VALUES ($1, $2) RETURNING created_at",
chat_id, title)
await c.execute(
"INSERT INTO chat_members (chat_id, user_id, chat_created_at, ord) "
"SELECT $1, u, $2, o FROM unnest($3::uuid[]) WITH ORDINALITY AS t(u, o)",
chat_id, created, uuids)
except asyncpg.ForeignKeyViolationError:
raise bad("Неизвестный участник") from None
return 201, {"id": str(chat_id), "title": title, "member_ids": ids, "created_at": format_dt(created)}
async def _require_member(self, user_id, params):
chat_id = parse_uuid(params["chat_id"], "chat_id")
ok = await self.db.fetchval("SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2", chat_id, user_id)
if not ok:
raise ApiError(404, "not_found", "Чат не найден")
return chat_id
async def chat(self, req, params):
user_id = await self.authenticate(req)
chat_id = parse_uuid(params["chat_id"], "chat_id")
row = await self.db.fetchrow(
CHAT_SELECT + "FROM chats c JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $2 WHERE c.id = $1",
chat_id, user_id)
if row is None:
raise ApiError(404, "not_found", "Чат не найден")
return 200, chat_json(row)
async def messages(self, req, params):
user_id = await self.authenticate(req)
if req.method == "POST":
row = await self._post_message(req, parse_uuid(params["chat_id"], "chat_id"), user_id)
return 201, message_json(row)
chat_id = await self._require_member(user_id, params)
if req.method == "GET":
limit, after = page_params(req.query, "m", chat_id)
if after is None:
rows = await self.db.fetch(
"SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1 "
"ORDER BY created_at, id LIMIT $2", chat_id, limit + 1)
else:
rows = await self.db.fetch(
"SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1 "
"AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT $4",
chat_id, us_to_dt(after[0]), uuid.UUID(after[1]), limit + 1)
more = len(rows) > limit
rows = rows[:limit]
cursor = encode_cursor("m", chat_id, (dt_to_us(rows[-1]["created_at"]), str(rows[-1]["id"]))) if more else None
return 200, {"items": [message_json(r) for r in rows], "next_cursor": cursor}
async def _post_message(self, req, chat_id, user_id):
# Сначала разбор запроса; ошибка валидации (400) возвращается только участнику чата — постороннему всегда 404.
try:
key = req.headers.get("idempotency-key", "")
if not IDEMPOTENCY_KEY_RE.fullmatch(key):
raise bad("Требуется заголовок Idempotency-Key ([A-Za-z0-9._:-]{1,128})")
req.require_json_media_type()
data = parse_json_object(await req.body(), {"text"}, {"text"})
text = valid_text(data["text"], "text", 4000)
except ApiError:
await self._require_member(user_id, {"chat_id": chat_id})
raise
# Нормализованное представление запроса: порядок ключей JSON не важен, отсутствие attachment_ids == [].
request_hash = hashlib.sha256(json.dumps({"text": text, "attachment_ids": []}, sort_keys=True,
ensure_ascii=False).encode("utf-8")).digest()
if config.SEND_STRATEGY == "function":
return await self._send_message_function(chat_id, user_id, key, request_hash, text)
await self._require_member(user_id, {"chat_id": chat_id})
return await self._send_message(chat_id, user_id, key, request_hash, text)
async def _send_message_function(self, chat_id, user_id, key, request_hash, text):
"""Один вызов серверной функции send_message (миграция 0003): членство + идемпотентность + вставка."""
row = await self.db.fetchrow("SELECT * FROM send_message($1, $2, $3, $4, $5, $6)", uuid.UUID(chat_id), uuid.UUID(user_id),
key, request_hash, text, float(config.IDEMPOTENCY_TTL_SECONDS), retry=False)
if row["outcome"] == "not_member":
raise ApiError(404, "not_found", "Чат не найден")
if bytes(row["request_hash"]) != request_hash:
raise ApiError(409, "conflict", "Idempotency-Key уже использован с другим телом запроса")
return {"id": row["msg_id"], "chat_id": row["msg_chat"], "sender_id": row["msg_sender"], "text": row["msg_text"],
"created_at": row["msg_created"]}
async def _send_message(self, chat_id, user_id, key, request_hash, text):
"""Идемпотентная отправка: ключ и сообщение пишутся одной транзакцией.
Одновременные повторы (в том числе через разные реплики) сериализуются уникальным индексом ключа:
второй INSERT ждёт COMMIT первого, затем видит чужую запись и возвращает сохранённое сообщение.
Транзиентный сбой откатывает транзакцию целиком, ключ не фиксируется, повтор безопасен.
"""
chat_uuid, user_uuid, message_id = uuid.UUID(chat_id), uuid.UUID(user_id), uuid.uuid4()
async with self.db.conn() as c:
async with c.transaction():
# просроченный (старше TTL) ключ этой же области считается свободным
await c.execute("DELETE FROM idempotency_keys WHERE user_id = $1 AND chat_id = $2 AND idem_key = $3 "
"AND created_at < now() - make_interval(secs => $4)",
user_uuid, chat_uuid, key, float(config.IDEMPOTENCY_TTL_SECONDS))
inserted = await c.fetchval(
"INSERT INTO idempotency_keys (user_id, chat_id, idem_key, request_hash, message_id) "
"VALUES ($1, $2, $3, $4, $5) ON CONFLICT DO NOTHING RETURNING message_id",
user_uuid, chat_uuid, key, request_hash, message_id)
if inserted is not None:
return await c.fetchrow(
"INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1, $2, $3, $4) "
"RETURNING id, chat_id, sender_id, text, created_at", message_id, chat_uuid, user_uuid, text)
existing = await c.fetchrow(
"SELECT k.request_hash, 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 = $1 AND k.chat_id = $2 AND k.idem_key = $3",
user_uuid, chat_uuid, key)
if existing is None: # ключ исчез между попытками (очистка) — клиент может повторить запрос
raise unavailable("Повторите запрос")
if bytes(existing["request_hash"]) != request_hash:
raise ApiError(409, "conflict", "Idempotency-Key уже использован с другим телом запроса")
return existing
# --- ASGI ----------------------------------------------------------------------
async def __call__(self, scope, receive, send):
if scope["type"] == "lifespan":
return await self.lifespan(receive, send)
if scope["type"] != "http":
return
started = time.perf_counter()
request_id = new_request_id()
route_name, status, headers = "unknown", 500, {}
try:
req = Request(scope, receive, request_id)
handler, params, route_name = self.route(req.method, req.path)
if not route_name.startswith("health") and self.inflight >= config.MAX_INFLIGHT:
raise ApiError(429, "rate_limited", "Слишком много одновременных запросов",
{"retry-after": str(config.RETRY_AFTER_SECONDS)})
self.inflight += 1
try:
await asyncio.sleep(0)
status, body = await handler(req, params)
finally:
self.inflight -= 1
except ApiError as exc:
status, headers = exc.status, exc.headers
body = {"error": {"code": exc.code, "message": exc.message, "request_id": request_id}}
except DEPENDENCY_ERRORS as exc:
log("warning", "dependency_error", request_id=request_id, error_type=type(exc).__name__)
status, headers = 503, {"retry-after": str(config.RETRY_AFTER_SECONDS)}
body = {"error": {"code": "unavailable", "message": "Зависимость временно недоступна", "request_id": request_id}}
except Exception as exc:
log("error", "unhandled_exception", request_id=request_id, error_type=type(exc).__name__)
status = 500
body = {"error": {"code": "internal_error", "message": "Внутренняя ошибка", "request_id": request_id}}
await respond(send, status, body, request_id, headers, INSTANCE_ID)
if os.environ.get("ACCESS_LOG", "1") != "0":
log("info", "request", request_id=request_id, method=scope.get("method"),
route=ROUTE_LABELS.get(route_name, "unmatched"), status=status,
duration_ms=round((time.perf_counter() - started) * 1000, 3))
async def janitor(self):
"""Удаляет давно просроченные ключи идемпотентности и сессии (безопасно запускать на каждой реплике)."""
import random
await asyncio.sleep(random.uniform(5, 30))
while True:
try:
await self.db.execute("DELETE FROM idempotency_keys WHERE ctid IN (SELECT ctid FROM idempotency_keys "
"WHERE created_at < now() - make_interval(secs => $1) LIMIT 5000)",
float(config.IDEMPOTENCY_TTL_SECONDS) + 3600)
await self.db.execute("DELETE FROM sessions WHERE ctid IN (SELECT ctid FROM sessions "
"WHERE expires_at < now() - interval '1 day' LIMIT 5000)")
except Exception as exc:
log("warning", "janitor_failed", error_type=type(exc).__name__)
await asyncio.sleep(3600)
def route(self, method, path):
for name, pattern, methods in ROUTES:
m = pattern.fullmatch(path)
if m:
if method not in methods:
raise ApiError(405, "invalid_request", "Метод не поддерживается", {"allow": ", ".join(sorted(methods))})
return getattr(self, name), m.groupdict(), name
raise ApiError(404, "not_found", "Ресурс не найден")
async def lifespan(self, receive, send):
while True:
event = await receive()
if event["type"] == "lifespan.startup":
await self.db.start()
await self.cache.start()
self._janitor = asyncio.create_task(self.janitor())
log("info", "startup", env=config.APP_ENV, instance=INSTANCE_ID, revision=os.environ.get("APP_REVISION", "dev"), cache=bool(config.VALKEY_URL),
session_ttl=config.SESSION_TTL_SECONDS, pool_max=config.DB_POOL_MAX)
await send({"type": "lifespan.startup.complete"})
elif event["type"] == "lifespan.shutdown":
self.draining = True
self._janitor.cancel()
await self.cache.stop()
await self.db.stop()
log("info", "shutdown")
await send({"type": "lifespan.shutdown.complete"})
return
async def overloaded_app(scope, receive, send):
"""Ответ uvicorn при превышении --limit-concurrency в контрактном формате."""
if scope["type"] != "http":
return
request_id = new_request_id()
body = {"error": {"code": "unavailable", "message": "Сервер перегружен: слишком много соединений",
"request_id": request_id}}
await respond(send, 503, body, request_id, {"retry-after": str(config.RETRY_AFTER_SECONDS), "connection": "close"}, INSTANCE_ID)
def _install_overload_response():
for name in ("uvicorn.protocols.http.httptools_impl", "uvicorn.protocols.http.h11_impl"):
try:
module = __import__(name, fromlist=["service_unavailable"])
except ImportError:
continue
module.service_unavailable = overloaded_app
def create_app():
_install_overload_response()
return Messenger()
app = create_app()
+64
View File
@@ -0,0 +1,64 @@
"""Применение версионируемых SQL-миграций: python -m app.migrate
Свойства:
* повторный запуск ничего не делает (таблица schema_migrations);
* одновременный запуск нескольких экземпляров безопасен (advisory lock);
* каждая миграция — одна транзакция вместе с записью о применении;
* ждёт готовности PostgreSQL до MIGRATE_WAIT_SECONDS.
"""
import asyncio
import hashlib
import os
import sys
import time
import asyncpg
from . import config
from .web import log
LOCK_ID = 7352001
async def connect(deadline):
while True:
try:
return await asyncpg.connect(config.DATABASE_URL, timeout=3)
except (OSError, asyncpg.PostgresError, asyncio.TimeoutError) as exc:
if time.monotonic() > deadline:
raise
log("info", "waiting_for_database", error_type=type(exc).__name__)
await asyncio.sleep(1)
async def main():
wait = float(os.environ.get("MIGRATE_WAIT_SECONDS", "60"))
conn = await connect(time.monotonic() + wait)
try:
await conn.execute("SELECT pg_advisory_lock($1)", LOCK_ID)
await conn.execute("CREATE TABLE IF NOT EXISTS schema_migrations ("
"version text PRIMARY KEY, checksum text NOT NULL, applied_at timestamptz NOT NULL DEFAULT now())")
applied = {r["version"]: r["checksum"] for r in await conn.fetch("SELECT version, checksum FROM schema_migrations")}
directory = os.path.abspath(config.MIGRATIONS_DIR)
files = sorted(f for f in os.listdir(directory) if f.endswith(".sql"))
count = 0
for name in files:
sql = open(os.path.join(directory, name), encoding="utf-8").read()
checksum = hashlib.sha256(sql.encode("utf-8")).hexdigest()
if name in applied:
if applied[name] != checksum:
log("error", "migration_modified", version=name)
sys.exit(2)
continue
async with conn.transaction():
await conn.execute(sql)
await conn.execute("INSERT INTO schema_migrations (version, checksum) VALUES ($1, $2)", name, checksum)
count += 1
log("info", "migration_applied", version=name)
log("info", "migrations_done", applied=count, total=len(files))
finally:
await conn.close()
if __name__ == "__main__":
asyncio.run(main())
+31
View File
@@ -0,0 +1,31 @@
"""Хеширование паролей: Argon2id (библиотека argon2-cffi), вычисления вне event loop."""
import asyncio
from concurrent.futures import ThreadPoolExecutor
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError, VerifyMismatchError
from . import config
_hasher = PasswordHasher(time_cost=config.ARGON2_TIME_COST, memory_cost=config.ARGON2_MEMORY_KIB,
parallelism=config.ARGON2_PARALLELISM)
_pool = ThreadPoolExecutor(max_workers=config.HASH_CONCURRENCY, thread_name_prefix="argon2")
# Для неизвестного username проверяем фиктивный хеш: время ответа не выдаёт существование пользователя.
_DUMMY = _hasher.hash("dummy-password-for-timing-equalisation")
async def hash_password(password):
return await asyncio.get_running_loop().run_in_executor(_pool, _hasher.hash, password)
def _verify(stored, password):
try:
return _hasher.verify(stored, password)
except (VerifyMismatchError, VerificationError, InvalidHashError):
return False
async def verify_password(stored, password):
"""stored=None -> проверка фиктивного хеша, результат всегда False."""
ok = await asyncio.get_running_loop().run_in_executor(_pool, _verify, stored or _DUMMY, password)
return ok and stored is not None
+40
View File
@@ -0,0 +1,40 @@
"""Точка входа: uvicorn с управляемым завершением (drain).
SIGTERM -> readiness сразу 503 -> DRAIN_SECONDS продолжаем обслуживать запросы, пока балансировщик
исключает реплику -> uvicorn прекращает приём и дожидается текущих запросов (timeout_graceful_shutdown).
Так плановая остановка/rolling update не даёт ошибок клиентам.
"""
import signal
import threading
import uvicorn
from . import config
from .main import app
from .web import log
class DrainingServer(uvicorn.Server):
_draining = False
def handle_exit(self, sig, frame):
if sig == signal.SIGTERM and not self._draining and config.DRAIN_SECONDS > 0:
self._draining = True
app.draining = True
log("info", "draining", seconds=config.DRAIN_SECONDS)
timer = threading.Timer(config.DRAIN_SECONDS, super().handle_exit, args=(sig, frame))
timer.daemon = True
timer.start()
return
super().handle_exit(sig, frame)
def main():
cfg = uvicorn.Config(app, host=config.APP_HOST, port=config.APP_PORT, workers=1, access_log=False,
log_level="warning", timeout_graceful_shutdown=config.GRACEFUL_SHUTDOWN_SECONDS,
timeout_keep_alive=config.KEEPALIVE_SECONDS, limit_concurrency=config.LIMIT_CONCURRENCY)
DrainingServer(cfg).run()
if __name__ == "__main__":
main()
+131
View File
@@ -0,0 +1,131 @@
"""Сессии: PostgreSQL — источник истины; Valkey — кэш с TTL (read-through).
Политики:
* токен — 256 бит из secrets; в БД и Valkey хранится только SHA-256 токена;
* expiry: expires_at в БД (по часам БД). В кэше TTL = min(остаток жизни, SESSION_CACHE_TTL_SECONDS);
* инвалидация: logout помечает revoked_at в БД и удаляет ключ в Valkey;
* Valkey недоступен -> кэш обходится (чтение из БД), анонимный запрос никогда не считается доверенным;
circuit breaker не даёт каждому запросу ждать таймаут;
* окно устаревания: если Valkey был недоступен во время logout, ключ может прожить до SESSION_CACHE_TTL_SECONDS.
"""
import hashlib
import secrets
import time
from . import config
from .web import log
try:
import redis.asyncio as aioredis
except ImportError: # кэш опционален
aioredis = None
def token_hash(token):
return hashlib.sha256(token.encode("ascii")).digest()
class SessionCache:
def __init__(self):
self.client = None
self.down_until = 0.0
self.stats = {"hit": 0, "miss": 0, "error": 0}
async def start(self):
if config.VALKEY_URL and aioredis:
self.client = aioredis.Redis.from_url(config.VALKEY_URL, socket_timeout=config.VALKEY_TIMEOUT,
socket_connect_timeout=config.VALKEY_TIMEOUT)
async def stop(self):
if self.client:
await self.client.aclose()
def _usable(self):
return self.client is not None and time.monotonic() >= self.down_until
def _fail(self, exc):
self.stats["error"] += 1
if time.monotonic() >= self.down_until:
log("warning", "session_cache_unavailable", error_type=type(exc).__name__)
self.down_until = time.monotonic() + config.VALKEY_BREAKER_SECONDS
async def get(self, key):
if not self._usable():
return None
try:
value = await self.client.get(b"s:" + key)
except Exception as exc:
self._fail(exc)
return None
self.stats["hit" if value is not None else "miss"] += 1
return value
async def put(self, key, value, ttl):
if not self._usable() or ttl <= 0:
return
try:
await self.client.set(b"s:" + key, value, ex=max(1, int(ttl)))
except Exception as exc:
self._fail(exc)
async def delete(self, key):
if not self._usable():
return
try:
await self.client.delete(b"s:" + key)
except Exception as exc:
self._fail(exc)
async def ping(self):
if self.client is None:
return None
try:
return bool(await self.client.ping())
except Exception:
return False
class Sessions:
def __init__(self, db, cache):
self.db, self.cache = db, cache
@staticmethod
def _cache_value(user_id, expires_at):
return ("%s|%d" % (user_id, int(expires_at.timestamp() * 1000))).encode()
async def create(self, user_id):
token = secrets.token_urlsafe(32) # 256 бит энтропии
digest = token_hash(token)
row = await self.db.fetchrow(
"INSERT INTO sessions (token_hash, user_id, expires_at) "
"VALUES ($1, $2, now() + make_interval(secs => $3)) RETURNING expires_at",
digest, user_id, float(config.SESSION_TTL_SECONDS))
remaining = row["expires_at"].timestamp() - time.time()
await self.cache.put(digest, self._cache_value(user_id, row["expires_at"]),
min(remaining, config.SESSION_CACHE_TTL_SECONDS))
return token, row["expires_at"]
async def resolve(self, token):
"""token -> user_id (str) либо None, если сессии нет/истекла/отозвана."""
digest = token_hash(token)
cached = await self.cache.get(digest)
if cached is not None:
user_id, _, expires_ms = cached.decode().partition("|")
if int(expires_ms) > time.time() * 1000:
return user_id
await self.cache.delete(digest)
row = await self.db.fetchrow(
"SELECT user_id, expires_at FROM sessions "
"WHERE token_hash = $1 AND revoked_at IS NULL AND expires_at > now()", digest)
if row is None:
return None
user_id = str(row["user_id"])
remaining = row["expires_at"].timestamp() - time.time()
await self.cache.put(digest, self._cache_value(user_id, row["expires_at"]),
min(remaining, config.SESSION_CACHE_TTL_SECONDS))
return user_id
async def revoke(self, token):
digest = token_hash(token)
await self.db.execute("UPDATE sessions SET revoked_at = now() WHERE token_hash = $1 AND revoked_at IS NULL", digest)
await self.cache.delete(digest)
+187
View File
@@ -0,0 +1,187 @@
"""Общий HTTP-слой: ошибки, запрос, валидация, курсоры, ответы, журнал."""
import base64
import json
import re
import sys
import time
import uuid
from datetime import datetime, timedelta, timezone
from urllib.parse import parse_qsl
from . import config
UUID_RE = re.compile(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}")
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}")
LIMIT_RE = re.compile(r"[0-9]{1,9}")
EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)
class ApiError(Exception):
def __init__(self, status, code, message, headers=None):
super().__init__(message)
self.status, self.code, self.message, self.headers = status, code, message, headers or {}
def bad(message):
return ApiError(400, "invalid_request", message)
def unavailable(message="Зависимость временно недоступна"):
return ApiError(503, "unavailable", message, {"retry-after": str(config.RETRY_AFTER_SECONDS)})
def log(level, msg, **fields):
record = {"ts": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), "level": level, "msg": msg}
record.update(fields)
sys.stdout.write(json.dumps(record, ensure_ascii=False) + "\n")
sys.stdout.flush()
# --- время -------------------------------------------------------------------
def format_dt(value):
value = value.astimezone(timezone.utc)
return value.strftime("%Y-%m-%dT%H:%M:%S.") + "%06dZ" % value.microsecond
def dt_to_us(value):
return (value - EPOCH) // timedelta(microseconds=1)
def us_to_dt(us):
return EPOCH + timedelta(microseconds=us)
# --- валидация ---------------------------------------------------------------
def parse_uuid(value, what="id"):
if not isinstance(value, str) or not UUID_RE.fullmatch(value):
raise bad("Некорректный %s" % what)
return value.lower()
def valid_text(value, field, maximum, allow_empty=False):
if not isinstance(value, str):
raise bad("Поле %s должно быть строкой" % field)
try:
value.encode("utf-8")
except UnicodeEncodeError:
raise bad("Поле %s содержит некорректные символы" % field) from None
if "\x00" in value:
raise bad("Поле %s содержит NUL" % field)
if len(value) > maximum:
raise bad("Поле %s слишком длинное" % field)
if not allow_empty and not value.strip():
raise bad("Поле %s не может быть пустым" % field)
return value
def _reject_constant(name):
raise ValueError(name)
def parse_json_object(raw, required, allowed):
try:
data = json.loads(raw.decode("utf-8"), parse_constant=_reject_constant)
except (UnicodeDecodeError, ValueError, RecursionError):
raise bad("Тело запроса — некорректный JSON") from None
if not isinstance(data, dict):
raise bad("Ожидается JSON-объект")
if set(data) - allowed:
raise bad("Лишние поля в запросе")
if any(key not in data for key in required):
raise bad("Не хватает обязательных полей")
return data
def encode_cursor(kind, resource, key):
payload = json.dumps({"k": kind, "r": resource, "t": key[0], "i": key[1]}, separators=(",", ":"))
return base64.urlsafe_b64encode(payload.encode()).decode().rstrip("=")
def decode_cursor(text, kind, resource):
try:
data = json.loads(base64.urlsafe_b64decode(text + "=" * (-len(text) % 4)).decode())
if (not isinstance(data, dict) or data.get("k") != kind or data.get("r") != resource
or not isinstance(data.get("t"), int) or isinstance(data.get("t"), bool)
or not isinstance(data.get("i"), str) or not UUID_RE.fullmatch(data["i"])
or not -62135596800000000 < data["t"] < 253402300799000000):
raise ValueError
return data["t"], data["i"]
except (ValueError, UnicodeError):
raise bad("Некорректный cursor") from None
def page_params(query, kind, resource):
limit, cursor = 50, None
if "limit" in query:
if len(query["limit"]) != 1 or not LIMIT_RE.fullmatch(query["limit"][0]):
raise bad("limit должен быть целым числом 1–100")
limit = int(query["limit"][0])
if not 1 <= limit <= 100:
raise bad("limit должен быть целым числом 1–100")
if "cursor" in query:
if len(query["cursor"]) != 1 or not query["cursor"][0]:
raise bad("Некорректный cursor")
cursor = decode_cursor(query["cursor"][0], kind, resource)
return limit, cursor
def parse_query(raw):
result = {}
if raw:
for key, value in parse_qsl(raw.decode("latin-1"), keep_blank_values=True):
result.setdefault(key, []).append(value)
return result
class Request:
def __init__(self, scope, receive, request_id):
self.method = scope["method"]
self.path = scope["path"]
self.query = parse_query(scope.get("query_string", b""))
self.headers = {k.decode("latin-1").lower(): v.decode("latin-1") for k, v in scope["headers"]}
self.receive = receive
self.request_id = request_id
self.user_id = None
async def body(self):
declared = self.headers.get("content-length")
if declared is not None:
if not declared.isdigit():
raise bad("Некорректный Content-Length")
if int(declared) > config.MAX_BODY_BYTES:
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое", {"connection": "close"})
chunks, size = [], 0
while True:
event = await self.receive()
if event["type"] == "http.disconnect":
raise bad("Соединение закрыто клиентом")
chunk = event.get("body", b"")
size += len(chunk)
if size > config.MAX_BODY_BYTES:
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое", {"connection": "close"})
chunks.append(chunk)
if not event.get("more_body"):
return b"".join(chunks)
def require_json_media_type(self):
media = self.headers.get("content-type", "").split(";")[0].strip().lower()
if media != "application/json":
raise ApiError(415, "unsupported_media_type", "Ожидается Content-Type: application/json")
async def respond(send, status, body, request_id, extra=None, instance_id=None):
payload = b"" if status == 204 else json.dumps(body, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
headers = [(b"x-request-id", request_id.encode())]
if status != 204:
headers += [(b"content-type", b"application/json"), (b"content-length", str(len(payload)).encode())]
else:
headers.append((b"content-length", b"0"))
if instance_id:
headers.append((b"x-instance-id", instance_id.encode()))
headers += [(k.encode(), v.encode()) for k, v in (extra or {}).items()]
await send({"type": "http.response.start", "status": status, "headers": headers})
await send({"type": "http.response.body", "body": payload})
def new_request_id():
return uuid.uuid4().hex