Files
mtusi2026lab4/src/api/dependencies.py
T

267 lines
9.2 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Зависимости ручек: сессия БД, сервисы, вход и текущая сессия, страница.
Сервисы получают сессию БД, а чаты и сообщения — ещё и кэш процесса
(`src/infra/cache/instance.py`). Вложения — фабрику короткой сессии на
шаг, кэш, хранилище объектов (`src/infra/s3/instance.py`) и места
загрузок процесса (`src/infra/upload_slots.py`).
"""
import base64
import binascii
import re
from collections.abc import AsyncIterator
from contextlib import AbstractAsyncContextManager
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 (
AttachmentService,
ChatService,
MessageService,
SessionService,
UserService,
)
from src.infra.cache.instance import cache
from src.infra.db import ping
from src.infra.db.scope import session_scope
from src.infra.db.session import engine, session_factory
from src.infra.logger import current_user_id
from src.infra.s3.instance import object_storage
from src.infra.upload_slots import upload_slots
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,
)
def db_session_scope() -> AbstractAsyncContextManager[AsyncSession]:
"""Сессия БД процесса API на один шаг; commit делает сервис.
`session_scope` (`src/infra/db/scope.py`) с фабрикой процесса API и
сроком `[database] request_timeout_seconds`: незакоммиченное
откатывается, отказ БД — 503 `unavailable`.
"""
return session_scope(
session_factory,
timeout_seconds=settings.database.request_timeout_seconds,
)
async def get_db_session() -> AsyncIterator[AsyncSession]:
"""Одна сессия БД на запрос — `db_session_scope` на весь запрос.
Зависимость с `yield` FastAPI закрывает после отправки ответа, поэтому
срок и соединение пула охватывают и отдачу тела. Ручкам с длинной
передачей (вложения) она не подходит: им — `CurrentUserBrief` и
сервис с `db_session_scope` на шаг (design change `attachments`,
решение 5).
"""
async with db_session_scope() as db_session:
yield db_session
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, cache=cache)
async def get_message_service(db_session: DbSessionDep) -> MessageService:
return MessageService(db_session=db_session, cache=cache)
async def get_session_service(db_session: DbSessionDep) -> SessionService:
return SessionService(db_session=db_session)
async def get_attachment_service() -> AttachmentService:
"""Без сессии запроса: сервис открывает `db_session_scope` на шаг."""
return AttachmentService(
db_scope=db_session_scope,
cache=cache,
storage=object_storage,
slots=upload_slots,
)
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)]
AttachmentServiceDep = Annotated[
AttachmentService,
Depends(get_attachment_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)]
async def get_current_user_brief(
credentials: Annotated[
HTTPAuthorizationCredentials | None,
Security(bearer_scheme),
],
) -> dataclasses.UserFullDTO:
"""Пользователь по Bearer-токену с короткой сессией БД; иначе 401.
Обычная функция, а не генератор: сессия закрыта и соединение
вернулось в пул до тела запроса. Для ручек с длинной передачей байтов
(design change `attachments`, решение 5).
"""
async with db_session_scope() as db_session:
current = await SessionService(db_session=db_session).authenticate(
token=credentials.credentials if credentials else None,
)
current_user_id.set(str(current.user.id))
return current.user
CurrentUserBrief = Annotated[
dataclasses.UserFullDTO,
Depends(get_current_user_brief),
]
@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)]