243 lines
8.7 KiB
Python
243 lines
8.7 KiB
Python
"""HTTP-обработчики FastAPI для lab2: Basic/Bearer, PostgreSQL, Redis-кэш сессий."""
|
|
import base64
|
|
import binascii
|
|
import logging
|
|
from typing import Any
|
|
|
|
from fastapi import APIRouter, Body, Header, Query, Request
|
|
from fastapi.responses import JSONResponse, Response
|
|
|
|
from .errors import ApiError
|
|
from .security import hash_password, verify_password
|
|
from .sessions import SessionStore
|
|
from .store import Store
|
|
from .validation import (
|
|
encode_cursor,
|
|
parse_cursor,
|
|
parse_limit,
|
|
validate_chat_id,
|
|
validate_create_chat,
|
|
validate_create_message,
|
|
validate_create_user,
|
|
)
|
|
|
|
router = APIRouter()
|
|
|
|
logger = logging.getLogger("messenger.handlers")
|
|
|
|
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
|
|
BEARER_CHALLENGE = 'Bearer realm="messenger"'
|
|
|
|
|
|
def get_store(request: Request) -> Store:
|
|
return request.app.state.store
|
|
|
|
|
|
def get_sessions(request: Request) -> SessionStore:
|
|
return request.app.state.sessions
|
|
|
|
|
|
def _unauthorized(message: str, challenge: str) -> ApiError:
|
|
err = ApiError(401, "unauthorized", message)
|
|
err.challenge = challenge # type: ignore[attr-defined]
|
|
return err
|
|
|
|
|
|
def current_user_id(request: Request, authorization: str | None) -> str:
|
|
"""lab2: только Bearer. X-User-Id игнорируется."""
|
|
if not authorization or not authorization.lower().startswith("bearer "):
|
|
raise _unauthorized("Требуется Bearer-токен", BEARER_CHALLENGE)
|
|
token = authorization[7:].strip()
|
|
if not token:
|
|
raise _unauthorized("Пустой Bearer-токен", BEARER_CHALLENGE)
|
|
user_id = get_sessions(request).resolve(token)
|
|
if user_id is None:
|
|
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
|
|
return user_id
|
|
|
|
|
|
def _parse_basic(authorization: str | None) -> tuple[str, str]:
|
|
if not authorization or not authorization.lower().startswith("basic "):
|
|
raise _unauthorized("Требуется Basic-аутентификация", BASIC_CHALLENGE)
|
|
try:
|
|
decoded = base64.b64decode(authorization[6:].strip(), validate=True).decode("utf-8")
|
|
except (binascii.Error, UnicodeDecodeError):
|
|
raise _unauthorized("Некорректный Basic", BASIC_CHALLENGE)
|
|
if ":" not in decoded:
|
|
raise _unauthorized("Некорректный Basic", BASIC_CHALLENGE)
|
|
username, password = decoded.split(":", 1)
|
|
return username, password
|
|
|
|
|
|
@router.get("/health/live")
|
|
def health_live() -> dict[str, str]:
|
|
return {"status": "ok"}
|
|
|
|
|
|
@router.get("/health/ready")
|
|
def health_ready(request: Request) -> JSONResponse:
|
|
"""Ready, если доступна БД (обязательный синхронный путь). Redis — кэш."""
|
|
try:
|
|
with get_store(request).pool.connection() as conn:
|
|
with conn.cursor() as cur:
|
|
cur.execute("SELECT 1")
|
|
cur.fetchone()
|
|
except Exception as exc: # noqa: BLE001
|
|
logger.warning("readiness failed: %s", type(exc).__name__)
|
|
raise ApiError(503, "unavailable", "Зависимость недоступна")
|
|
return JSONResponse({"status": "ok"})
|
|
|
|
|
|
@router.post("/api/v1/users", status_code=201)
|
|
def register_user(request: Request, body: Any = Body(...)) -> JSONResponse:
|
|
username, display_name, password = validate_create_user(body)
|
|
store = get_store(request)
|
|
user = store.create_user(username, display_name, hash_password(password))
|
|
if user is None:
|
|
raise ApiError(409, "conflict", "username уже занят")
|
|
return JSONResponse(user, status_code=201)
|
|
|
|
|
|
@router.post("/api/v1/auth/sessions", status_code=201)
|
|
def create_session(
|
|
request: Request,
|
|
authorization: str | None = Header(default=None),
|
|
) -> JSONResponse:
|
|
username, password = _parse_basic(authorization)
|
|
store = get_store(request)
|
|
found = store.get_user_by_username(username)
|
|
if found is None:
|
|
# Одинаковый 401 для неверного username и пароля.
|
|
raise _unauthorized("Неверные учётные данные", BASIC_CHALLENGE)
|
|
user, password_hash = found
|
|
if not verify_password(password_hash, password):
|
|
raise _unauthorized("Неверные учётные данные", BASIC_CHALLENGE)
|
|
session = get_sessions(request).create(user["id"])
|
|
return JSONResponse(
|
|
{
|
|
"token": session["token"],
|
|
"token_type": "Bearer",
|
|
"expires_at": session["expires_at"],
|
|
"user": user,
|
|
},
|
|
status_code=201,
|
|
)
|
|
|
|
|
|
@router.delete("/api/v1/auth/sessions/current", status_code=204)
|
|
def revoke_session(
|
|
request: Request,
|
|
authorization: str | None = Header(default=None),
|
|
) -> JSONResponse:
|
|
if not authorization or not authorization.lower().startswith("bearer "):
|
|
raise _unauthorized("Требуется Bearer-токен", BEARER_CHALLENGE)
|
|
token = authorization[7:].strip()
|
|
if not token or get_sessions(request).resolve(token) is None:
|
|
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
|
|
get_sessions(request).revoke(token)
|
|
return Response(status_code=204)
|
|
|
|
|
|
@router.get("/api/v1/users/me")
|
|
def current_user(
|
|
request: Request, authorization: str | None = Header(default=None)
|
|
) -> dict[str, Any]:
|
|
user_id = current_user_id(request, authorization)
|
|
user = get_store(request).get_user(user_id)
|
|
if user is None:
|
|
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
|
|
return user
|
|
|
|
|
|
@router.post("/api/v1/chats", status_code=201)
|
|
def create_chat(
|
|
request: Request,
|
|
body: Any = Body(...),
|
|
authorization: str | None = Header(default=None),
|
|
) -> JSONResponse:
|
|
caller = current_user_id(request, authorization)
|
|
title, member_ids = validate_create_chat(body, caller)
|
|
store = get_store(request)
|
|
for mid in member_ids:
|
|
if store.get_user(mid) is None:
|
|
raise ApiError(400, "invalid_request", "Неизвестный участник чата")
|
|
chat = store.create_chat(title, member_ids)
|
|
return JSONResponse(chat, status_code=201)
|
|
|
|
|
|
@router.get("/api/v1/chats")
|
|
def list_chats(
|
|
request: Request,
|
|
limit: str | None = Query(default=None),
|
|
cursor: str | None = Query(default=None),
|
|
authorization: str | None = Header(default=None),
|
|
) -> dict[str, Any]:
|
|
caller = current_user_id(request, authorization)
|
|
page_size = parse_limit(limit)
|
|
scope = f"chats:{caller}"
|
|
after = parse_cursor(cursor, scope)
|
|
items, has_more = get_store(request).list_chats_for(caller, page_size, after)
|
|
next_cursor = None
|
|
if has_more and items:
|
|
last = items[-1]
|
|
next_cursor = encode_cursor(last["created_at"], last["id"], scope)
|
|
return {"items": items, "next_cursor": next_cursor}
|
|
|
|
|
|
@router.get("/api/v1/chats/{chat_id}")
|
|
def get_chat(
|
|
chat_id: str,
|
|
request: Request,
|
|
authorization: str | None = Header(default=None),
|
|
) -> dict[str, Any]:
|
|
caller = current_user_id(request, authorization)
|
|
chat_id = validate_chat_id(chat_id)
|
|
store = get_store(request)
|
|
if not store.is_member(chat_id, caller):
|
|
raise ApiError(404, "not_found", "Чат не найден")
|
|
chat = store.get_chat(chat_id)
|
|
if chat is None:
|
|
raise ApiError(404, "not_found", "Чат не найден")
|
|
return chat
|
|
|
|
|
|
@router.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
|
def create_message(
|
|
chat_id: str,
|
|
request: Request,
|
|
body: Any = Body(...),
|
|
authorization: str | None = Header(default=None),
|
|
) -> JSONResponse:
|
|
caller = current_user_id(request, authorization)
|
|
chat_id = validate_chat_id(chat_id)
|
|
store = get_store(request)
|
|
if not store.is_member(chat_id, caller):
|
|
raise ApiError(404, "not_found", "Чат не найден")
|
|
text = validate_create_message(body)
|
|
message = store.add_message(chat_id, caller, text)
|
|
return JSONResponse(message, status_code=201)
|
|
|
|
|
|
@router.get("/api/v1/chats/{chat_id}/messages")
|
|
def list_messages(
|
|
chat_id: str,
|
|
request: Request,
|
|
limit: str | None = Query(default=None),
|
|
cursor: str | None = Query(default=None),
|
|
authorization: str | None = Header(default=None),
|
|
) -> dict[str, Any]:
|
|
caller = current_user_id(request, authorization)
|
|
chat_id = validate_chat_id(chat_id)
|
|
store = get_store(request)
|
|
if not store.is_member(chat_id, caller):
|
|
raise ApiError(404, "not_found", "Чат не найден")
|
|
page_size = parse_limit(limit)
|
|
scope = f"messages:{chat_id}"
|
|
after = parse_cursor(cursor, scope)
|
|
items, has_more = store.list_messages(chat_id, page_size, after)
|
|
next_cursor = None
|
|
if has_more and items:
|
|
last = items[-1]
|
|
next_cursor = encode_cursor(last["created_at"], last["id"], scope)
|
|
return {"items": items, "next_cursor": next_cursor}
|