- Argon2id password hashes, KDF in a thread with its own limit - POST /auth/sessions with Basic, DELETE /auth/sessions/current - Bearer sessions in PostgreSQL, X-User-Id ignored - migration drops lab 1 data without passwords - student-tests on tokens, sessions spec and synced specs Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
219 lines
7.4 KiB
Python
219 lines
7.4 KiB
Python
"""Зависимости ручек: сессия БД, сервисы, вход и текущая сессия, страница."""
|
|
|
|
import asyncio
|
|
import base64
|
|
import binascii
|
|
import re
|
|
from collections.abc import AsyncIterator
|
|
from dataclasses import dataclass
|
|
from typing import Annotated
|
|
|
|
from fastapi import Depends, Query, Security
|
|
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
|
|
from fastapi.security.http import HTTPBase
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from src.config import settings
|
|
from src.core import exceptions
|
|
from src.core.services import (
|
|
ChatService,
|
|
MessageService,
|
|
SessionService,
|
|
UserService,
|
|
)
|
|
from src.infra.db import is_db_unavailable, ping
|
|
from src.infra.db.session import engine, session_factory
|
|
from src.infra.logger import AbstractLogger, current_user_id, get_logger
|
|
from src.schemas import dataclasses
|
|
from src.utils.constants import (
|
|
PAGE_LIMIT_DEFAULT,
|
|
PAGE_LIMIT_MAX,
|
|
PAGE_LIMIT_MIN,
|
|
PASSWORD_MAX_LENGTH,
|
|
PASSWORD_MIN_LENGTH,
|
|
READINESS_DB_TIMEOUT_SECONDS,
|
|
USERNAME_PATTERN,
|
|
)
|
|
|
|
logger: AbstractLogger = get_logger().bind(module="api_dependencies")
|
|
|
|
|
|
async def get_db_session() -> AsyncIterator[AsyncSession]:
|
|
"""Одна сессия БД на запрос; commit делает сервис.
|
|
|
|
Незакоммиченное при выходе откатывается. Вся работа запроса с БД
|
|
ограничена `[database] request_timeout_seconds`: зависший Postgres не
|
|
держит запрос бесконечно. Недоступность БД (`is_db_unavailable`) —
|
|
503 `unavailable`, а соединение не возвращается в пул: его состояние
|
|
неизвестно, а откат на зависшем сервере повис бы.
|
|
"""
|
|
async with session_factory() as db_session:
|
|
try:
|
|
async with asyncio.timeout(
|
|
settings.database.request_timeout_seconds,
|
|
):
|
|
yield db_session
|
|
except Exception as e:
|
|
if not is_db_unavailable(e):
|
|
raise
|
|
await db_session.invalidate()
|
|
logger.warning(
|
|
"Database is unavailable",
|
|
error_type=type(e).__name__,
|
|
error=str(e),
|
|
)
|
|
raise exceptions.ServiceUnavailable from e
|
|
|
|
|
|
DbSessionDep = Annotated[AsyncSession, Depends(get_db_session)]
|
|
|
|
|
|
async def require_database() -> None:
|
|
"""Readiness: Postgres отвечает на `SELECT 1` за отведённое время.
|
|
|
|
Любая ошибка — 503: готовность не должна отвечать 500. Не логирует:
|
|
healthcheck спрашивает каждые несколько секунд.
|
|
"""
|
|
try:
|
|
await ping(engine, timeout=READINESS_DB_TIMEOUT_SECONDS)
|
|
except Exception as e:
|
|
raise exceptions.ServiceUnavailable from e
|
|
|
|
|
|
async def get_user_service(db_session: DbSessionDep) -> UserService:
|
|
return UserService(db_session=db_session)
|
|
|
|
|
|
async def get_chat_service(db_session: DbSessionDep) -> ChatService:
|
|
return ChatService(db_session=db_session)
|
|
|
|
|
|
async def get_message_service(db_session: DbSessionDep) -> MessageService:
|
|
return MessageService(db_session=db_session)
|
|
|
|
|
|
async def get_session_service(db_session: DbSessionDep) -> SessionService:
|
|
return SessionService(db_session=db_session)
|
|
|
|
|
|
UserServiceDep = Annotated[UserService, Depends(get_user_service)]
|
|
ChatServiceDep = Annotated[ChatService, Depends(get_chat_service)]
|
|
MessageServiceDep = Annotated[MessageService, Depends(get_message_service)]
|
|
SessionServiceDep = Annotated[SessionService, Depends(get_session_service)]
|
|
|
|
|
|
# схемы basicAuth и bearerAuth из contracts/openapi.json: объявлены в
|
|
# /openapi.json и дают кнопку Authorize в /docs. auto_error=False — нет
|
|
# заголовка или схема чужая даёт None, а 401 в формате контракта бросает
|
|
# сервис. HTTPBase отдаёт credentials как есть: HTTPBasic FastAPI
|
|
# декодирует ASCII и на пароле не из ASCII сам ответил бы 401
|
|
basic_scheme = HTTPBase(
|
|
scheme="basic",
|
|
scheme_name="basicAuth",
|
|
auto_error=False,
|
|
)
|
|
bearer_scheme = HTTPBearer(
|
|
scheme_name="bearerAuth",
|
|
bearerFormat="opaque session token",
|
|
auto_error=False,
|
|
)
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class BasicCredentials:
|
|
username: str
|
|
password: str
|
|
|
|
|
|
def parse_basic(
|
|
credentials: HTTPAuthorizationCredentials | None,
|
|
) -> BasicCredentials | None:
|
|
"""username и пароль из `Authorization: Basic`; None — разбор не удался.
|
|
|
|
base64 строго, UTF-8, разделитель — первое двоеточие: в username его
|
|
не бывает, в пароле оно допустимо. Значения, которые не могут быть
|
|
верными (формат username и длина пароля публичны), отсекаются здесь:
|
|
до БД и KDF не доходит ни мусор, ни пароль в мегабайт.
|
|
"""
|
|
if credentials is None or credentials.scheme.lower() != "basic":
|
|
return None
|
|
try:
|
|
decoded = base64.b64decode(credentials.credentials, validate=True)
|
|
username, separator, password = decoded.decode().partition(":")
|
|
except (binascii.Error, UnicodeDecodeError):
|
|
return None
|
|
if not separator or not re.fullmatch(USERNAME_PATTERN, username):
|
|
return None
|
|
if not PASSWORD_MIN_LENGTH <= len(password) <= PASSWORD_MAX_LENGTH:
|
|
return None
|
|
return BasicCredentials(username=username, password=password)
|
|
|
|
|
|
async def get_basic_credentials(
|
|
credentials: Annotated[
|
|
HTTPAuthorizationCredentials | None,
|
|
Security(basic_scheme),
|
|
],
|
|
) -> BasicCredentials:
|
|
"""Учётные данные входа; любой сбой разбора — тот же 401, что и
|
|
неверный пароль."""
|
|
parsed = parse_basic(credentials)
|
|
if parsed is None:
|
|
raise exceptions.InvalidCredentials
|
|
return parsed
|
|
|
|
|
|
BasicCredentialsDep = Annotated[
|
|
BasicCredentials,
|
|
Depends(get_basic_credentials),
|
|
]
|
|
|
|
|
|
async def get_current_session(
|
|
credentials: Annotated[
|
|
HTTPAuthorizationCredentials | None,
|
|
Security(bearer_scheme),
|
|
],
|
|
sessions: SessionServiceDep,
|
|
) -> dataclasses.CurrentSessionDTO:
|
|
"""Действующая сессия по Bearer-токену; иначе 401."""
|
|
current = await sessions.authenticate(
|
|
token=credentials.credentials if credentials else None,
|
|
)
|
|
current_user_id.set(str(current.user.id))
|
|
return current
|
|
|
|
|
|
CurrentSession = Annotated[
|
|
dataclasses.CurrentSessionDTO,
|
|
Depends(get_current_session),
|
|
]
|
|
|
|
|
|
async def get_current_user(
|
|
current: CurrentSession,
|
|
) -> dataclasses.UserFullDTO:
|
|
return current.user
|
|
|
|
|
|
CurrentUser = Annotated[dataclasses.UserFullDTO, Depends(get_current_user)]
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class PageQuery:
|
|
limit: int
|
|
cursor: str | None
|
|
|
|
|
|
async def get_page_query(
|
|
limit: Annotated[
|
|
int,
|
|
Query(ge=PAGE_LIMIT_MIN, le=PAGE_LIMIT_MAX),
|
|
] = PAGE_LIMIT_DEFAULT,
|
|
cursor: Annotated[str | None, Query(min_length=1)] = None,
|
|
) -> PageQuery:
|
|
return PageQuery(limit=limit, cursor=cursor)
|
|
|
|
|
|
PageQueryDep = Annotated[PageQuery, Depends(get_page_query)]
|