Files
mtusi2026lab3/src/app/main.py
T

416 lines
23 KiB
Python

"""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()