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)