forked from mtusi2026/mtusi2026lab2
329 lines
7.6 KiB
Python
329 lines
7.6 KiB
Python
from __future__ import annotations
|
|
|
|
import logging
|
|
from collections.abc import AsyncIterator
|
|
from contextlib import asynccontextmanager
|
|
from uuid import UUID, uuid4
|
|
|
|
from fastapi import Depends, FastAPI, Request, Response, Security
|
|
from fastapi.exceptions import RequestValidationError
|
|
from fastapi.responses import JSONResponse
|
|
from sqlalchemy import exc as sa_exc
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.cache import session_cache
|
|
from app.db import check_database_ready, engine, get_db
|
|
from app.deps import basic_scheme, pagination_params, require_user
|
|
from app.errors import ApiError, Unavailable, api_error_handler
|
|
from app.models import (
|
|
Chat,
|
|
ChatPage,
|
|
CreateChat,
|
|
CreateMessage,
|
|
CreateUser,
|
|
Health,
|
|
Message,
|
|
MessagePage,
|
|
Session,
|
|
User,
|
|
)
|
|
from app.services import (
|
|
create_chat,
|
|
create_message,
|
|
create_user_session,
|
|
get_chat,
|
|
list_chats,
|
|
list_messages,
|
|
logout_current_session,
|
|
register_user,
|
|
)
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(_app: FastAPI) -> AsyncIterator[None]:
|
|
yield
|
|
await session_cache.close()
|
|
await engine.dispose()
|
|
|
|
|
|
app = FastAPI(
|
|
title="MTUSI Messenger — лабораторная 2",
|
|
version="1.2.0",
|
|
lifespan=lifespan,
|
|
)
|
|
|
|
@app.middleware("http")
|
|
async def add_request_id(request: Request, call_next):
|
|
request.state.request_id = (
|
|
request.headers.get("X-Request-Id")
|
|
or str(uuid4())
|
|
)
|
|
|
|
response = await call_next(request)
|
|
response.headers["X-Request-Id"] = request.state.request_id
|
|
return response
|
|
|
|
@app.exception_handler(ApiError)
|
|
async def handle_api_error(
|
|
request: Request,
|
|
exc: Exception,
|
|
) -> JSONResponse:
|
|
if not isinstance(exc, ApiError):
|
|
raise exc
|
|
|
|
return await api_error_handler(request, exc)
|
|
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def validation_error_handler(
|
|
request: Request,
|
|
_exc: RequestValidationError,
|
|
) -> JSONResponse:
|
|
request_id = getattr(request.state, "request_id", str(uuid4()))
|
|
|
|
return JSONResponse(
|
|
status_code=400,
|
|
content={
|
|
"error": {
|
|
"code": "invalid_request",
|
|
"message": "Invalid request.",
|
|
"request_id": request_id,
|
|
}
|
|
},
|
|
headers={
|
|
"X-Request-Id": request_id,
|
|
},
|
|
)
|
|
|
|
|
|
logger = logging.getLogger("messenger.api")
|
|
|
|
|
|
def is_dependency_failure(exc: Exception) -> bool:
|
|
"""PostgreSQL is unreachable, restarting, overloaded or timed out."""
|
|
if isinstance(
|
|
exc,
|
|
(
|
|
sa_exc.OperationalError,
|
|
sa_exc.InterfaceError,
|
|
sa_exc.TimeoutError, # connection pool exhausted
|
|
OSError,
|
|
TimeoutError,
|
|
),
|
|
):
|
|
return True
|
|
|
|
return isinstance(exc, sa_exc.DBAPIError) and exc.connection_invalidated
|
|
|
|
|
|
async def dependency_error_handler(
|
|
request: Request,
|
|
exc: Exception,
|
|
) -> JSONResponse:
|
|
if not is_dependency_failure(exc):
|
|
return await unexpected_error_handler(request, exc)
|
|
|
|
logger.warning("database unavailable: %s", type(exc).__name__)
|
|
return await api_error_handler(request, Unavailable())
|
|
|
|
|
|
for _exc_class in (sa_exc.DBAPIError, sa_exc.TimeoutError, OSError, TimeoutError):
|
|
app.add_exception_handler(_exc_class, dependency_error_handler)
|
|
|
|
|
|
@app.exception_handler(Exception)
|
|
async def unexpected_error_handler(
|
|
request: Request,
|
|
exc: Exception,
|
|
) -> JSONResponse:
|
|
request_id = getattr(request.state, "request_id", str(uuid4()))
|
|
# Only the type: SQL parameters and headers may contain secrets.
|
|
logger.error("unexpected error: %s", type(exc).__name__)
|
|
|
|
return JSONResponse(
|
|
status_code=500,
|
|
content={
|
|
"error": {
|
|
"code": "internal_error",
|
|
"message": "Internal server error.",
|
|
"request_id": request_id,
|
|
}
|
|
},
|
|
headers={
|
|
"X-Request-Id": request_id,
|
|
},
|
|
)
|
|
|
|
|
|
@app.get(
|
|
"/health/live",
|
|
response_model=Health,
|
|
)
|
|
async def liveness() -> dict[str, str]:
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.get(
|
|
"/health/ready",
|
|
response_model=Health,
|
|
)
|
|
async def readiness() -> dict[str, str]:
|
|
if not await check_database_ready():
|
|
raise Unavailable()
|
|
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.post(
|
|
"/api/v1/users",
|
|
status_code=201,
|
|
response_model=User,
|
|
)
|
|
async def register_user_route(
|
|
payload: CreateUser,
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
return await register_user(
|
|
db,
|
|
username=payload.username,
|
|
display_name=payload.display_name,
|
|
password=payload.password,
|
|
)
|
|
|
|
|
|
@app.post(
|
|
"/api/v1/auth/sessions",
|
|
status_code=201,
|
|
response_model=Session,
|
|
)
|
|
async def login(
|
|
request: Request,
|
|
db: AsyncSession = Depends(get_db),
|
|
_basic: None = Security(basic_scheme),
|
|
):
|
|
return await create_user_session(
|
|
db,
|
|
request.headers.get("Authorization"),
|
|
)
|
|
|
|
|
|
@app.delete(
|
|
"/api/v1/auth/sessions/current",
|
|
status_code=204,
|
|
)
|
|
async def logout(
|
|
request: Request,
|
|
db: AsyncSession = Depends(get_db),
|
|
_current_user: dict = Depends(require_user),
|
|
) -> Response:
|
|
_, _, token = request.headers["Authorization"].partition(" ")
|
|
|
|
await logout_current_session(
|
|
db,
|
|
token.strip(),
|
|
)
|
|
|
|
return Response(status_code=204)
|
|
|
|
|
|
@app.get(
|
|
"/api/v1/users/me",
|
|
response_model=User,
|
|
)
|
|
async def current_user_route(
|
|
current_user: dict = Depends(require_user),
|
|
):
|
|
return current_user
|
|
|
|
|
|
@app.post(
|
|
"/api/v1/chats",
|
|
status_code=201,
|
|
response_model=Chat,
|
|
)
|
|
async def create_chat_route(
|
|
payload: CreateChat,
|
|
current_user: dict = Depends(require_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
return await create_chat(
|
|
db,
|
|
title=payload.title,
|
|
member_ids=payload.member_ids,
|
|
current_user=current_user,
|
|
)
|
|
|
|
|
|
@app.get(
|
|
"/api/v1/chats",
|
|
response_model=ChatPage,
|
|
)
|
|
async def list_chats_route(
|
|
page: tuple[int, str | None] = Depends(pagination_params),
|
|
current_user: dict = Depends(require_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
limit, cursor = page
|
|
|
|
return await list_chats(
|
|
db,
|
|
limit=limit,
|
|
cursor=cursor,
|
|
current_user=current_user,
|
|
)
|
|
|
|
|
|
@app.get(
|
|
"/api/v1/chats/{chat_id}",
|
|
response_model=Chat,
|
|
)
|
|
async def get_chat_route(
|
|
chat_id: UUID,
|
|
current_user: dict = Depends(require_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
return await get_chat(
|
|
db,
|
|
chat_id=chat_id,
|
|
current_user=current_user,
|
|
)
|
|
|
|
|
|
@app.post(
|
|
"/api/v1/chats/{chat_id}/messages",
|
|
status_code=201,
|
|
response_model=Message,
|
|
)
|
|
async def create_message_route(
|
|
chat_id: UUID,
|
|
payload: CreateMessage,
|
|
current_user: dict = Depends(require_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
return await create_message(
|
|
db,
|
|
chat_id=chat_id,
|
|
text_value=payload.text,
|
|
current_user=current_user,
|
|
)
|
|
|
|
|
|
@app.get(
|
|
"/api/v1/chats/{chat_id}/messages",
|
|
response_model=MessagePage,
|
|
)
|
|
async def list_messages_route(
|
|
chat_id: UUID,
|
|
page: tuple[int, str | None] = Depends(pagination_params),
|
|
current_user: dict = Depends(require_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
limit, cursor = page
|
|
|
|
return await list_messages(
|
|
db,
|
|
chat_id=chat_id,
|
|
limit=limit,
|
|
cursor=cursor,
|
|
current_user=current_user,
|
|
) |