416 lines
23 KiB
Python
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()
|