forked from mtusi2026/mtusi2026lab2
491 lines
18 KiB
Python
491 lines
18 KiB
Python
import base64
|
||
import binascii
|
||
import hashlib
|
||
import json
|
||
import logging
|
||
import os
|
||
import secrets
|
||
import uuid
|
||
from contextlib import asynccontextmanager
|
||
from datetime import datetime, timezone
|
||
|
||
import psycopg
|
||
from psycopg import errors
|
||
from argon2 import PasswordHasher
|
||
from argon2.exceptions import InvalidHashError, VerificationError
|
||
from fastapi import Depends, FastAPI, Header, HTTPException, Query, Request, Response
|
||
from fastapi.exceptions import RequestValidationError
|
||
from fastapi.responses import JSONResponse
|
||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||
|
||
import cache
|
||
import db
|
||
from schemas import (
|
||
User, CreateUser, Session,
|
||
Chat, CreateChat, ChatPage,
|
||
Message, CreateMessage, MessagePage,
|
||
)
|
||
|
||
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
|
||
log = logging.getLogger("messenger")
|
||
|
||
SESSION_TTL_SECONDS = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
|
||
|
||
ph = PasswordHasher() # по умолчанию Argon2id
|
||
# Хеш-заглушка: проверяем пароль даже для несуществующего username,
|
||
# чтобы по времени ответа нельзя было узнать, есть ли такой пользователь
|
||
DUMMY_HASH = ph.hash("dummy-password-for-timing")
|
||
|
||
BASIC_CHALLENGE = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
|
||
BEARER_CHALLENGE = {"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||
|
||
ERROR_CODES = {
|
||
400: "invalid_request",
|
||
401: "unauthorized",
|
||
404: "not_found",
|
||
409: "conflict",
|
||
413: "payload_too_large",
|
||
415: "unsupported_media_type",
|
||
429: "rate_limited",
|
||
503: "unavailable",
|
||
}
|
||
|
||
|
||
@asynccontextmanager
|
||
async def lifespan(app):
|
||
db.pool.open(wait=True, timeout=30) # ждём, пока БД станет доступна
|
||
db.run_migrations()
|
||
cache.start() # фоновая проверка доступности Redis
|
||
yield # тут приложение работает
|
||
db.pool.close() # при остановке (SIGTERM) закрываем пул
|
||
|
||
|
||
app = FastAPI(lifespan=lifespan)
|
||
|
||
|
||
# ---------- Вспомогательные функции ----------
|
||
|
||
def iso(dt: datetime) -> str:
|
||
return dt.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
|
||
|
||
|
||
def parse_uuid(value: str, what: str) -> str:
|
||
try:
|
||
return str(uuid.UUID(value))
|
||
except ValueError:
|
||
raise HTTPException(400, f"invalid {what}")
|
||
|
||
|
||
def hash_token(token: str) -> str:
|
||
return hashlib.sha256(token.encode()).hexdigest()
|
||
|
||
|
||
def check_password(password_hash: str, password: str) -> bool:
|
||
try:
|
||
return ph.verify(password_hash, password)
|
||
except (VerificationError, InvalidHashError):
|
||
return False
|
||
|
||
|
||
def user_from_row(row) -> User:
|
||
return User(
|
||
id=str(row["id"]),
|
||
username=row["username"],
|
||
display_name=row["display_name"],
|
||
created_at=iso(row["created_at"]),
|
||
)
|
||
|
||
|
||
def chat_from_row(row) -> Chat:
|
||
return Chat(
|
||
id=str(row["id"]),
|
||
title=row["title"],
|
||
member_ids=[str(m) for m in row["member_ids"]],
|
||
created_at=iso(row["created_at"]),
|
||
)
|
||
|
||
|
||
def message_from_row(row) -> Message:
|
||
return Message(
|
||
id=str(row["id"]),
|
||
chat_id=str(row["chat_id"]),
|
||
sender_id=str(row["sender_id"]),
|
||
text=row["text"],
|
||
created_at=iso(row["created_at"]),
|
||
)
|
||
|
||
|
||
# Курсор = base64(JSON) с последним (created_at, id) и "областью" (какой чат/список).
|
||
# Курсор от другого чата не подойдёт -> 400.
|
||
def encode_cursor(scope: str, created_at: datetime, item_id) -> str:
|
||
raw = json.dumps({"s": scope, "t": iso(created_at), "i": str(item_id)})
|
||
return base64.urlsafe_b64encode(raw.encode()).decode().rstrip("=")
|
||
|
||
|
||
def decode_cursor(cursor: str, scope: str) -> tuple[datetime, str]:
|
||
try:
|
||
padded = cursor + "=" * (-len(cursor) % 4)
|
||
data = json.loads(base64.urlsafe_b64decode(padded))
|
||
if data["s"] != scope:
|
||
raise ValueError("cursor from another resource")
|
||
return datetime.fromisoformat(data["t"]), str(uuid.UUID(data["i"]))
|
||
except (ValueError, KeyError, TypeError, binascii.Error):
|
||
raise HTTPException(400, "invalid cursor")
|
||
|
||
|
||
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
|
||
|
||
|
||
# ---------- Ошибки и X-Request-Id ----------
|
||
|
||
def error_response(status: int, message: str, request_id: str, headers=None) -> JSONResponse:
|
||
if status in ERROR_CODES:
|
||
code = ERROR_CODES[status]
|
||
elif status < 500:
|
||
code = "invalid_request"
|
||
else:
|
||
code = "internal_error"
|
||
return JSONResponse(
|
||
status_code=status,
|
||
content={"error": {"code": code, "message": message, "request_id": request_id}},
|
||
headers=headers or {},
|
||
)
|
||
|
||
|
||
@app.middleware("http")
|
||
async def request_id_middleware(request: Request, call_next):
|
||
rid = request.headers.get("X-Request-Id")
|
||
if not rid or len(rid) > 128:
|
||
rid = str(uuid.uuid4())
|
||
request.state.request_id = rid
|
||
try:
|
||
response = await call_next(request)
|
||
except psycopg.OperationalError:
|
||
# БД недоступна / пул исчерпан (PoolTimeout тоже OperationalError)
|
||
log.exception("database unavailable")
|
||
response = error_response(503, "service temporarily unavailable", rid)
|
||
except Exception:
|
||
log.exception("unhandled error")
|
||
response = error_response(500, "internal error", rid)
|
||
response.headers["X-Request-Id"] = rid
|
||
return response
|
||
|
||
|
||
@app.exception_handler(RequestValidationError)
|
||
async def validation_handler(request: Request, exc: RequestValidationError):
|
||
return error_response(400, "invalid request", request.state.request_id)
|
||
|
||
|
||
@app.exception_handler(StarletteHTTPException)
|
||
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
|
||
return error_response(exc.status_code, str(exc.detail), request.state.request_id, exc.headers)
|
||
|
||
|
||
# ---------- Аутентификация ----------
|
||
|
||
def parse_basic(authorization: str | None) -> tuple[str, str]:
|
||
scheme, _, encoded = (authorization or "").partition(" ")
|
||
if scheme.lower() != "basic" or not encoded.strip():
|
||
raise HTTPException(401, "unauthorized", BASIC_CHALLENGE)
|
||
try:
|
||
decoded = base64.b64decode(encoded.strip(), validate=True).decode("utf-8")
|
||
except (binascii.Error, UnicodeDecodeError):
|
||
raise HTTPException(401, "unauthorized", BASIC_CHALLENGE)
|
||
username, sep, password = decoded.partition(":") # двоеточие в пароле допустимо
|
||
if not sep:
|
||
raise HTTPException(401, "unauthorized", BASIC_CHALLENGE)
|
||
return username, password
|
||
|
||
|
||
def current_session(authorization: str | None = Header(default=None)) -> dict:
|
||
# Принимаем только Bearer; X-User-Id и Basic здесь игнорируются -> 401
|
||
scheme, _, token = (authorization or "").partition(" ")
|
||
token = token.strip()
|
||
if scheme.lower() != "bearer" or not token:
|
||
raise HTTPException(401, "unauthorized", BEARER_CHALLENGE)
|
||
token_hash = hash_token(token)
|
||
|
||
# 1. Кэш Redis (если доступен)
|
||
cached = cache.get_session(token_hash)
|
||
if cached == cache.REVOKED:
|
||
raise HTTPException(401, "unauthorized", BEARER_CHALLENGE)
|
||
if cached is not None:
|
||
return {"user": User(**cached["user"]), "token_hash": token_hash}
|
||
|
||
# 2. Промах или Redis недоступен -> источник истины PostgreSQL
|
||
with db.pool.connection() as conn:
|
||
row = conn.execute(
|
||
"""
|
||
SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at
|
||
FROM sessions s
|
||
JOIN users u ON u.id = s.user_id
|
||
WHERE s.token_hash = %s
|
||
AND s.revoked_at IS NULL
|
||
AND s.expires_at > now()
|
||
""",
|
||
(token_hash,),
|
||
).fetchone()
|
||
if row is None:
|
||
raise HTTPException(401, "unauthorized", BEARER_CHALLENGE)
|
||
user = user_from_row(row)
|
||
cache.put_session(token_hash, user.model_dump(), row["expires_at"])
|
||
return {"user": user, "token_hash": token_hash}
|
||
|
||
|
||
def current_user(session: dict = Depends(current_session)) -> User:
|
||
return session["user"]
|
||
|
||
|
||
# ---------- Health ----------
|
||
|
||
@app.get("/health/live")
|
||
def liveness():
|
||
return {"status": "ok"}
|
||
|
||
|
||
@app.get("/health/ready")
|
||
def readiness():
|
||
try:
|
||
with db.pool.connection(timeout=2) as conn:
|
||
conn.execute("SELECT 1")
|
||
except Exception:
|
||
raise HTTPException(503, "database unavailable")
|
||
return {"status": "ok"}
|
||
|
||
|
||
# ---------- Пользователи и сессии ----------
|
||
|
||
@app.post("/api/v1/users", status_code=201, response_model=User)
|
||
def register_user(payload: CreateUser):
|
||
password_hash = ph.hash(payload.password)
|
||
try:
|
||
with db.pool.connection() as conn:
|
||
row = conn.execute(
|
||
"""
|
||
INSERT INTO users (id, username, display_name, password_hash)
|
||
VALUES (%s, %s, %s, %s)
|
||
RETURNING id, username, display_name, created_at
|
||
""",
|
||
(uuid.uuid4(), payload.username, payload.display_name, password_hash),
|
||
).fetchone()
|
||
except errors.UniqueViolation:
|
||
# Гонку двух одинаковых регистраций разруливает UNIQUE в БД
|
||
raise HTTPException(409, "username already taken")
|
||
return user_from_row(row)
|
||
|
||
|
||
@app.post("/api/v1/auth/sessions", status_code=201, response_model=Session)
|
||
def create_session(authorization: str | None = Header(default=None)):
|
||
username, password = parse_basic(authorization)
|
||
|
||
with db.pool.connection() as conn:
|
||
row = conn.execute(
|
||
"""
|
||
SELECT id, username, display_name, created_at, password_hash
|
||
FROM users WHERE username = %s
|
||
""",
|
||
(username,),
|
||
).fetchone()
|
||
|
||
# Проверка пароля вне соединения с БД: argon2 медленный, не держим соединение пула
|
||
if row is None:
|
||
check_password(DUMMY_HASH, password)
|
||
raise HTTPException(401, "invalid credentials", BASIC_CHALLENGE)
|
||
if not check_password(row["password_hash"], password):
|
||
raise HTTPException(401, "invalid credentials", BASIC_CHALLENGE)
|
||
|
||
token = secrets.token_urlsafe(32) # 32 случайных байта = 256 бит
|
||
with db.pool.connection() as conn:
|
||
session = conn.execute(
|
||
"""
|
||
INSERT INTO sessions (token_hash, user_id, expires_at)
|
||
VALUES (%s, %s, now() + %s * interval '1 second')
|
||
RETURNING expires_at
|
||
""",
|
||
(hash_token(token), row["id"], SESSION_TTL_SECONDS),
|
||
).fetchone()
|
||
|
||
user = user_from_row(row)
|
||
# Сессия уже сохранена в PostgreSQL (COMMIT); кэш — только ускорение
|
||
cache.put_session(hash_token(token), user.model_dump(), session["expires_at"])
|
||
return Session(
|
||
token=token,
|
||
token_type="Bearer",
|
||
expires_at=iso(session["expires_at"]),
|
||
user=user,
|
||
)
|
||
|
||
|
||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||
def delete_session(session: dict = Depends(current_session)):
|
||
with db.pool.connection() as conn:
|
||
conn.execute(
|
||
"UPDATE sessions SET revoked_at = now() WHERE token_hash = %s AND revoked_at IS NULL",
|
||
(session["token_hash"],),
|
||
)
|
||
# Сначала отзыв в источнике истины, потом "надгробие" в кэше
|
||
cache.revoke_session(session["token_hash"])
|
||
return Response(status_code=204)
|
||
|
||
|
||
@app.get("/api/v1/users/me", response_model=User)
|
||
def get_me(me: User = Depends(current_user)):
|
||
return me
|
||
|
||
|
||
# ---------- Чаты ----------
|
||
|
||
@app.post("/api/v1/chats", status_code=201, response_model=Chat)
|
||
def create_chat(payload: CreateChat, me: User = Depends(current_user)):
|
||
member_ids = [parse_uuid(m, "member id") for m in payload.member_ids]
|
||
if len(set(member_ids)) != len(member_ids):
|
||
raise HTTPException(400, "member_ids must be unique")
|
||
if me.id not in member_ids:
|
||
raise HTTPException(400, "caller must be a member")
|
||
|
||
chat_id = uuid.uuid4()
|
||
try:
|
||
with db.pool.connection() as conn:
|
||
# Атомарно: чат и все участники сохраняются вместе или не сохраняется ничего
|
||
with conn.transaction():
|
||
chat = conn.execute(
|
||
"INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING id, title, created_at",
|
||
(chat_id, payload.title),
|
||
).fetchone()
|
||
with conn.cursor() as cur:
|
||
cur.executemany(
|
||
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
|
||
[(chat_id, m) for m in member_ids],
|
||
)
|
||
except errors.ForeignKeyViolation:
|
||
# Неизвестный участник: транзакция откатилась, чата в БД нет
|
||
raise HTTPException(400, "unknown member")
|
||
|
||
return Chat(
|
||
id=str(chat["id"]),
|
||
title=chat["title"],
|
||
member_ids=member_ids,
|
||
created_at=iso(chat["created_at"]),
|
||
)
|
||
|
||
|
||
@app.get("/api/v1/chats", response_model=ChatPage)
|
||
def list_chats(
|
||
limit: int = Query(default=50, ge=1, le=100),
|
||
cursor: str | None = Query(default=None, min_length=1),
|
||
me: User = Depends(current_user),
|
||
):
|
||
scope = "chats:" + me.id
|
||
params: list = [me.id]
|
||
after = ""
|
||
if cursor is not None:
|
||
created_at, last_id = decode_cursor(cursor, scope)
|
||
after = "AND (c.created_at, c.id) > (%s, %s)"
|
||
params += [created_at, last_id]
|
||
params.append(limit + 1) # берём на 1 больше, чтобы понять, есть ли следующая страница
|
||
|
||
with db.pool.connection() as conn:
|
||
rows = conn.execute(
|
||
f"""
|
||
SELECT c.id, c.title, c.created_at,
|
||
array_agg(m.user_id ORDER BY m.user_id) AS member_ids
|
||
FROM chat_members my
|
||
JOIN chats c ON c.id = my.chat_id
|
||
JOIN chat_members m ON m.chat_id = c.id
|
||
WHERE my.user_id = %s {after}
|
||
GROUP BY c.id
|
||
ORDER BY c.created_at, c.id
|
||
LIMIT %s
|
||
""",
|
||
params,
|
||
).fetchall()
|
||
|
||
next_cursor = None
|
||
if len(rows) > limit:
|
||
rows = rows[:limit]
|
||
next_cursor = encode_cursor(scope, rows[-1]["created_at"], rows[-1]["id"])
|
||
return ChatPage(items=[chat_from_row(r) for r in rows], next_cursor=next_cursor)
|
||
|
||
|
||
@app.get("/api/v1/chats/{chat_id}", response_model=Chat)
|
||
def get_chat(chat_id: str, me: User = Depends(current_user)):
|
||
cid = parse_uuid(chat_id, "chat id")
|
||
with db.pool.connection() as conn:
|
||
if not is_member(conn, cid, me.id):
|
||
raise HTTPException(404, "chat not found") # чужой чат = как будто его нет
|
||
row = conn.execute(
|
||
"""
|
||
SELECT c.id, c.title, c.created_at,
|
||
array_agg(m.user_id ORDER BY m.user_id) AS member_ids
|
||
FROM chats c
|
||
JOIN chat_members m ON m.chat_id = c.id
|
||
WHERE c.id = %s
|
||
GROUP BY c.id
|
||
""",
|
||
(cid,),
|
||
).fetchone()
|
||
return chat_from_row(row)
|
||
|
||
|
||
# ---------- Сообщения ----------
|
||
|
||
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201, response_model=Message)
|
||
def create_message(chat_id: str, payload: CreateMessage, me: User = Depends(current_user)):
|
||
cid = parse_uuid(chat_id, "chat id")
|
||
with db.pool.connection() as conn:
|
||
if not is_member(conn, cid, me.id):
|
||
raise HTTPException(404, "chat not found")
|
||
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
|
||
""",
|
||
(uuid.uuid4(), cid, me.id, payload.text),
|
||
).fetchone()
|
||
return message_from_row(row)
|
||
|
||
|
||
@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage)
|
||
def list_messages(
|
||
chat_id: str,
|
||
limit: int = Query(default=50, ge=1, le=100),
|
||
cursor: str | None = Query(default=None, min_length=1),
|
||
me: User = Depends(current_user),
|
||
):
|
||
cid = parse_uuid(chat_id, "chat id")
|
||
scope = "messages:" + cid
|
||
params: list = [cid]
|
||
after = ""
|
||
if cursor is not None:
|
||
created_at, last_id = decode_cursor(cursor, scope)
|
||
# keyset-пагинация: продолжаем строго после последнего (created_at, id)
|
||
after = "AND (created_at, id) > (%s, %s)"
|
||
params += [created_at, last_id]
|
||
params.append(limit + 1)
|
||
|
||
with db.pool.connection() as conn:
|
||
if not is_member(conn, cid, me.id):
|
||
raise HTTPException(404, "chat not found")
|
||
rows = conn.execute(
|
||
f"""
|
||
SELECT id, chat_id, sender_id, text, created_at
|
||
FROM messages
|
||
WHERE chat_id = %s {after}
|
||
ORDER BY created_at, id
|
||
LIMIT %s
|
||
""",
|
||
params,
|
||
).fetchall()
|
||
|
||
next_cursor = None
|
||
if len(rows) > limit:
|
||
rows = rows[:limit]
|
||
next_cursor = encode_cursor(scope, rows[-1]["created_at"], rows[-1]["id"])
|
||
return MessagePage(items=[message_from_row(r) for r in rows], next_cursor=next_cursor)
|