267 lines
9.2 KiB
Python
267 lines
9.2 KiB
Python
"""Зависимости ручек: сессия БД, сервисы, вход и текущая сессия, страница.
|
||
|
||
Сервисы получают сессию БД, а чаты и сообщения — ещё и кэш процесса
|
||
(`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)]
|