655 lines
15 KiB
Python
655 lines
15 KiB
Python
from __future__ import annotations
|
||
|
||
import base64
|
||
import binascii
|
||
import json
|
||
import logging
|
||
import os
|
||
import re
|
||
from contextlib import asynccontextmanager
|
||
from datetime import datetime, timezone
|
||
from uuid import UUID, uuid4
|
||
|
||
from fastapi import FastAPI, Request
|
||
from fastapi.exceptions import RequestValidationError
|
||
from fastapi.responses import JSONResponse, Response
|
||
from psycopg import InterfaceError, OperationalError
|
||
from psycopg.errors import LockNotAvailable, QueryCanceled
|
||
from psycopg_pool import PoolTimeout, TooManyRequests
|
||
from starlette.exceptions import HTTPException
|
||
|
||
from app.auth import (
|
||
DUMMY_PASSWORD_HASH,
|
||
USERNAME_RE,
|
||
generate_token,
|
||
hash_password,
|
||
hash_token,
|
||
parse_basic_credentials,
|
||
parse_bearer_token,
|
||
verify_password,
|
||
)
|
||
from app.cache import close_cache, get_cached_user
|
||
from app.db import check_db, close_db, open_db
|
||
from app.store import InvalidMembersError, store
|
||
|
||
|
||
logger = logging.getLogger("messenger.api")
|
||
|
||
SESSION_TTL_SECONDS = int(
|
||
os.getenv("SESSION_TTL_SECONDS", "3600")
|
||
)
|
||
|
||
if SESSION_TTL_SECONDS < 1:
|
||
raise ValueError("SESSION_TTL_SECONDS must be positive")
|
||
|
||
|
||
class ApiError(Exception):
|
||
def __init__(
|
||
self,
|
||
status: int,
|
||
code: str,
|
||
message: str,
|
||
challenge: str | None = None,
|
||
):
|
||
super().__init__(message)
|
||
self.status = status
|
||
self.code = code
|
||
self.message = message
|
||
self.challenge = challenge
|
||
|
||
|
||
def invalid(message: str = "Некорректный запрос") -> ApiError:
|
||
return ApiError(400, "invalid_request", message)
|
||
|
||
|
||
def unauthorized(scheme: str = "Bearer") -> ApiError:
|
||
if scheme == "Basic":
|
||
challenge = 'Basic realm="messenger", charset="UTF-8"'
|
||
else:
|
||
challenge = 'Bearer realm="messenger"'
|
||
|
||
return ApiError(
|
||
401,
|
||
"unauthorized",
|
||
"Недействительная аутентификация",
|
||
challenge,
|
||
)
|
||
|
||
|
||
def not_found() -> ApiError:
|
||
return ApiError(404, "not_found", "Объект не найден")
|
||
|
||
|
||
def utc_text(value: datetime) -> str:
|
||
return (
|
||
value.astimezone(timezone.utc)
|
||
.isoformat(timespec="microseconds")
|
||
.replace("+00:00", "Z")
|
||
)
|
||
|
||
|
||
def to_json(value):
|
||
if isinstance(value, UUID):
|
||
return str(value)
|
||
|
||
if isinstance(value, datetime):
|
||
return utc_text(value)
|
||
|
||
if isinstance(value, dict):
|
||
return {
|
||
key: to_json(item)
|
||
for key, item in value.items()
|
||
}
|
||
|
||
if isinstance(value, (list, tuple)):
|
||
return [to_json(item) for item in value]
|
||
|
||
return value
|
||
|
||
|
||
def json_response(value, status: int = 200) -> JSONResponse:
|
||
return JSONResponse(
|
||
status_code=status,
|
||
content=to_json(value),
|
||
)
|
||
|
||
|
||
def error_response(
|
||
request: Request,
|
||
error: ApiError,
|
||
) -> JSONResponse:
|
||
request_id = getattr(
|
||
request.state,
|
||
"request_id",
|
||
str(uuid4()),
|
||
)
|
||
|
||
headers = {"X-Request-Id": request_id}
|
||
|
||
if error.challenge is not None:
|
||
headers["WWW-Authenticate"] = error.challenge
|
||
|
||
return JSONResponse(
|
||
status_code=error.status,
|
||
content={
|
||
"error": {
|
||
"code": error.code,
|
||
"message": error.message,
|
||
"request_id": request_id,
|
||
}
|
||
},
|
||
headers=headers,
|
||
)
|
||
|
||
|
||
@asynccontextmanager
|
||
async def lifespan(app: FastAPI):
|
||
try:
|
||
await open_db()
|
||
yield
|
||
finally:
|
||
await close_cache()
|
||
await close_db()
|
||
|
||
|
||
app = FastAPI(
|
||
title="PostgreSQL messenger — Lab 2",
|
||
docs_url=None,
|
||
redoc_url=None,
|
||
openapi_url=None,
|
||
lifespan=lifespan,
|
||
)
|
||
|
||
|
||
@app.middleware("http")
|
||
async def request_middleware(request: Request, call_next):
|
||
request.state.request_id = str(uuid4())
|
||
|
||
try:
|
||
response = await call_next(request)
|
||
|
||
except ApiError as exc:
|
||
response = error_response(request, exc)
|
||
|
||
except (
|
||
OperationalError,
|
||
InterfaceError,
|
||
PoolTimeout,
|
||
TooManyRequests,
|
||
QueryCanceled,
|
||
LockNotAvailable,
|
||
) as exc:
|
||
logger.warning(
|
||
"Database unavailable request_id=%s error_type=%s",
|
||
request.state.request_id,
|
||
type(exc).__name__,
|
||
)
|
||
response = error_response(
|
||
request,
|
||
ApiError(
|
||
503,
|
||
"unavailable",
|
||
"Сервис временно недоступен",
|
||
),
|
||
)
|
||
|
||
except Exception as exc:
|
||
logger.error(
|
||
"Unhandled error request_id=%s error_type=%s",
|
||
request.state.request_id,
|
||
type(exc).__name__,
|
||
)
|
||
response = error_response(
|
||
request,
|
||
ApiError(
|
||
500,
|
||
"internal_error",
|
||
"Внутренняя ошибка сервера",
|
||
),
|
||
)
|
||
|
||
response.headers["X-Request-Id"] = request.state.request_id
|
||
return response
|
||
|
||
|
||
@app.exception_handler(RequestValidationError)
|
||
async def validation_error_handler(request: Request, exc):
|
||
return error_response(request, invalid())
|
||
|
||
|
||
@app.exception_handler(HTTPException)
|
||
async def http_error_handler(request: Request, exc: HTTPException):
|
||
if exc.status_code == 404:
|
||
error = not_found()
|
||
else:
|
||
error = invalid("Недопустимый HTTP-запрос")
|
||
|
||
return error_response(request, error)
|
||
|
||
|
||
def parse_uuid(value: object) -> UUID:
|
||
if not isinstance(value, str):
|
||
raise invalid("Некорректный UUID")
|
||
|
||
try:
|
||
return UUID(value)
|
||
except ValueError:
|
||
raise invalid("Некорректный UUID") from None
|
||
|
||
|
||
def valid_text(value: object, maximum: int) -> bool:
|
||
return (
|
||
isinstance(value, str)
|
||
and 1 <= len(value) <= maximum
|
||
and bool(value.strip())
|
||
)
|
||
|
||
|
||
async def read_payload(
|
||
request: Request,
|
||
expected_fields: set[str],
|
||
) -> dict:
|
||
content_type = (
|
||
request.headers.get("content-type", "")
|
||
.split(";", 1)[0]
|
||
.strip()
|
||
.lower()
|
||
)
|
||
|
||
if content_type != "application/json":
|
||
raise ApiError(
|
||
415,
|
||
"unsupported_media_type",
|
||
"Требуется Content-Type: application/json",
|
||
)
|
||
|
||
try:
|
||
payload = await request.json()
|
||
except (ValueError, UnicodeError):
|
||
raise invalid("Некорректный JSON") from None
|
||
|
||
if (
|
||
not isinstance(payload, dict)
|
||
or set(payload) != expected_fields
|
||
):
|
||
raise invalid("Некорректные поля запроса")
|
||
|
||
return payload
|
||
|
||
|
||
async def current_user(request: Request) -> tuple[dict, str]:
|
||
token = parse_bearer_token(
|
||
request.headers.get("authorization")
|
||
)
|
||
|
||
if token is None:
|
||
raise unauthorized()
|
||
|
||
token_digest = hash_token(token)
|
||
|
||
user_id = await store.get_session_user_id(token_digest)
|
||
|
||
if user_id is None:
|
||
raise unauthorized()
|
||
|
||
user = await get_cached_user(user_id)
|
||
|
||
if user is None:
|
||
raise unauthorized()
|
||
|
||
return user, token_digest
|
||
|
||
|
||
async def accessible_chat(
|
||
raw_chat_id: str,
|
||
user_id: UUID,
|
||
) -> tuple[UUID, dict]:
|
||
chat_id = parse_uuid(raw_chat_id)
|
||
|
||
chat = await store.get_accessible_chat(chat_id, user_id)
|
||
|
||
if chat is None:
|
||
raise not_found()
|
||
|
||
return chat_id, chat
|
||
|
||
|
||
def encode_cursor(scope: str, item: dict) -> str:
|
||
raw = json.dumps(
|
||
{
|
||
"scope": scope,
|
||
"created_at": utc_text(item["created_at"]),
|
||
"id": str(item["id"]),
|
||
},
|
||
separators=(",", ":"),
|
||
).encode("utf-8")
|
||
|
||
return (
|
||
base64.urlsafe_b64encode(raw)
|
||
.decode("ascii")
|
||
.rstrip("=")
|
||
)
|
||
|
||
|
||
def decode_cursor(
|
||
cursor: str,
|
||
scope: str,
|
||
) -> tuple[datetime, UUID]:
|
||
if not cursor or len(cursor) > 2048:
|
||
raise invalid("Некорректный cursor")
|
||
|
||
try:
|
||
padded = cursor + "=" * (-len(cursor) % 4)
|
||
|
||
raw = base64.b64decode(
|
||
padded,
|
||
altchars=b"-_",
|
||
validate=True,
|
||
)
|
||
|
||
data = json.loads(raw.decode("utf-8"))
|
||
|
||
if (
|
||
not isinstance(data, dict)
|
||
or set(data) != {"scope", "created_at", "id"}
|
||
or data["scope"] != scope
|
||
):
|
||
raise ValueError
|
||
|
||
timestamp = data["created_at"]
|
||
|
||
if (
|
||
not isinstance(timestamp, str)
|
||
or not timestamp.endswith("Z")
|
||
or not isinstance(data["id"], str)
|
||
):
|
||
raise ValueError
|
||
|
||
created_at = datetime.fromisoformat(
|
||
timestamp[:-1] + "+00:00"
|
||
)
|
||
|
||
item_id = UUID(data["id"])
|
||
|
||
return created_at, item_id
|
||
|
||
except (
|
||
ValueError,
|
||
TypeError,
|
||
UnicodeError,
|
||
binascii.Error,
|
||
OverflowError,
|
||
):
|
||
raise invalid("Некорректный cursor") from None
|
||
|
||
|
||
def pagination(
|
||
request: Request,
|
||
scope: str,
|
||
) -> tuple[int, tuple[datetime, UUID] | None]:
|
||
raw_limit = request.query_params.get("limit", "50")
|
||
|
||
if (
|
||
len(raw_limit) > 10
|
||
or re.fullmatch(r"[0-9]+", raw_limit) is None
|
||
):
|
||
raise invalid("Некорректный limit")
|
||
|
||
limit = int(raw_limit)
|
||
|
||
if not 1 <= limit <= 100:
|
||
raise invalid("Некорректный limit")
|
||
|
||
raw_cursor = request.query_params.get("cursor")
|
||
after = None
|
||
|
||
if raw_cursor is not None:
|
||
after = decode_cursor(raw_cursor, scope)
|
||
|
||
return limit, after
|
||
|
||
|
||
def page_response(
|
||
rows: list[dict],
|
||
limit: int,
|
||
scope: str,
|
||
) -> JSONResponse:
|
||
items = rows[:limit]
|
||
next_cursor = None
|
||
|
||
if len(rows) > limit:
|
||
next_cursor = encode_cursor(scope, items[-1])
|
||
|
||
return json_response(
|
||
{
|
||
"items": items,
|
||
"next_cursor": next_cursor,
|
||
}
|
||
)
|
||
|
||
|
||
@app.get("/health/live")
|
||
async def health_live():
|
||
return {"status": "ok"}
|
||
|
||
|
||
@app.get("/health/ready")
|
||
async def health_ready():
|
||
await check_db()
|
||
return {"status": "ok"}
|
||
|
||
|
||
@app.post("/api/v1/users")
|
||
async def create_user(request: Request):
|
||
payload = await read_payload(
|
||
request,
|
||
{"username", "display_name", "password"},
|
||
)
|
||
|
||
username = payload["username"]
|
||
display_name = payload["display_name"]
|
||
password = payload["password"]
|
||
|
||
if (
|
||
not isinstance(username, str)
|
||
or USERNAME_RE.fullmatch(username) is None
|
||
):
|
||
raise invalid("Некорректный username")
|
||
|
||
if not valid_text(display_name, 100):
|
||
raise invalid("Некорректное display_name")
|
||
|
||
if not valid_text(password, 128) or len(password) < 12:
|
||
raise invalid("Пароль должен содержать от 12 до 128 символов")
|
||
|
||
password_digest = await hash_password(password)
|
||
|
||
user = await store.create_user(
|
||
username,
|
||
display_name,
|
||
password_digest,
|
||
)
|
||
|
||
if user is None:
|
||
raise ApiError(
|
||
409,
|
||
"conflict",
|
||
"Username уже занят",
|
||
)
|
||
|
||
return json_response(user, 201)
|
||
|
||
|
||
@app.post("/api/v1/auth/sessions")
|
||
async def create_session(request: Request):
|
||
credentials = parse_basic_credentials(
|
||
request.headers.get("authorization")
|
||
)
|
||
|
||
if credentials is None:
|
||
raise unauthorized("Basic")
|
||
|
||
username, password = credentials
|
||
|
||
user = await store.get_user_for_login(username)
|
||
|
||
stored_hash = (
|
||
DUMMY_PASSWORD_HASH
|
||
if user is None
|
||
else user["password_hash"]
|
||
)
|
||
|
||
password_ok = await verify_password(stored_hash, password)
|
||
|
||
if user is None or not password_ok:
|
||
raise unauthorized("Basic")
|
||
|
||
if await request.body():
|
||
raise invalid("Тело запроса при входе не допускается")
|
||
|
||
token = generate_token()
|
||
|
||
session = await store.create_session(
|
||
user["id"],
|
||
hash_token(token),
|
||
SESSION_TTL_SECONDS,
|
||
)
|
||
|
||
public_user = {
|
||
field: user[field]
|
||
for field in ("id", "username", "display_name", "created_at")
|
||
}
|
||
|
||
return json_response(
|
||
{
|
||
"token": token,
|
||
"token_type": "Bearer",
|
||
"expires_at": session["expires_at"],
|
||
"user": public_user,
|
||
},
|
||
201,
|
||
)
|
||
|
||
|
||
@app.delete("/api/v1/auth/sessions/current")
|
||
async def revoke_session(request: Request):
|
||
_, token_digest = await current_user(request)
|
||
|
||
revoked = await store.revoke_session(token_digest)
|
||
|
||
if not revoked:
|
||
raise unauthorized()
|
||
|
||
return Response(status_code=204)
|
||
|
||
|
||
@app.get("/api/v1/users/me")
|
||
async def get_current_user(request: Request):
|
||
user, _ = await current_user(request)
|
||
return json_response(user)
|
||
|
||
|
||
@app.post("/api/v1/chats")
|
||
async def create_chat(request: Request):
|
||
user, _ = await current_user(request)
|
||
|
||
payload = await read_payload(
|
||
request,
|
||
{"title", "member_ids"},
|
||
)
|
||
|
||
if not valid_text(payload["title"], 100):
|
||
raise invalid("Некорректный title")
|
||
|
||
raw_members = payload["member_ids"]
|
||
|
||
if (
|
||
not isinstance(raw_members, list)
|
||
or not 1 <= len(raw_members) <= 100
|
||
):
|
||
raise invalid("Некорректный member_ids")
|
||
|
||
member_ids = [parse_uuid(item) for item in raw_members]
|
||
|
||
if len(set(member_ids)) != len(member_ids):
|
||
raise invalid("В member_ids есть дубликаты")
|
||
|
||
if user["id"] not in member_ids:
|
||
raise invalid("Создатель должен входить в member_ids")
|
||
|
||
try:
|
||
chat = await store.create_chat(
|
||
payload["title"],
|
||
member_ids,
|
||
)
|
||
except InvalidMembersError:
|
||
raise invalid(
|
||
"В member_ids есть неизвестный пользователь"
|
||
) from None
|
||
|
||
return json_response(chat, 201)
|
||
|
||
|
||
@app.get("/api/v1/chats")
|
||
async def list_chats(request: Request):
|
||
user, _ = await current_user(request)
|
||
|
||
scope = f"chats:{user['id']}"
|
||
limit, after = pagination(request, scope)
|
||
|
||
rows = await store.list_chats(user["id"], limit, after)
|
||
|
||
return page_response(rows, limit, scope)
|
||
|
||
|
||
@app.get("/api/v1/chats/{chat_id}")
|
||
async def get_chat(chat_id: str, request: Request):
|
||
user, _ = await current_user(request)
|
||
|
||
_, chat = await accessible_chat(chat_id, user["id"])
|
||
|
||
return json_response(chat)
|
||
|
||
|
||
@app.post("/api/v1/chats/{chat_id}/messages")
|
||
async def create_message(chat_id: str, request: Request):
|
||
user, _ = await current_user(request)
|
||
|
||
chat_uuid, _ = await accessible_chat(
|
||
chat_id,
|
||
user["id"],
|
||
)
|
||
|
||
payload = await read_payload(request, {"text"})
|
||
|
||
if not valid_text(payload["text"], 4000):
|
||
raise invalid("Некорректный текст сообщения")
|
||
|
||
message = await store.create_message(
|
||
chat_uuid,
|
||
user["id"],
|
||
payload["text"],
|
||
)
|
||
|
||
return json_response(message, 201)
|
||
|
||
|
||
@app.get("/api/v1/chats/{chat_id}/messages")
|
||
async def list_messages(chat_id: str, request: Request):
|
||
user, _ = await current_user(request)
|
||
|
||
chat_uuid, _ = await accessible_chat(
|
||
chat_id,
|
||
user["id"],
|
||
)
|
||
|
||
scope = f"messages:{chat_uuid}"
|
||
limit, after = pagination(request, scope)
|
||
|
||
rows = await store.list_messages(
|
||
chat_uuid,
|
||
limit,
|
||
after,
|
||
)
|
||
|
||
return page_response(rows, limit, scope) |