feat: add replicated messenger and reproducible lab3 stand

This commit is contained in:
2026-10-15 13:43:39 +03:00
parent 0ab3a341aa
commit 84dd7fec0a
106 changed files with 17235 additions and 24 deletions
+146
View File
@@ -0,0 +1,146 @@
# src/api/ — HTTP-слой и контракт
Источник правды — `contracts/openapi.json` и `contracts/README.md`.
Сгенерированная FastAPI схема (`/openapi.json`) — только справка, но
схемы безопасности в ней совпадают с контрактом (это проверяет
`student-tests/test_auth.py`).
## Устройство
| Файл | Что делает |
|---|---|
| `routes/health.py` | `/health/live` (всегда 200), `/health/ready` (200, если старт завершён и PostgreSQL отвечает `SELECT 1` за 2 с, иначе 503; Valkey не проверяется). Вне `/api/v1`, без идентификации, в access-лог не пишутся. `/health/ready` раз в секунду опрашивает HAProxy: по нему реплика исключается из LB и возвращается |
| `routes/users.py`, `sessions.py`, `chats.py`, `messages.py` | ручки v1; префикс `/api/v1` добавляет `api_router` в `routes/__init__.py`; `messages.py` объявляет обязательный заголовок `Idempotency-Key` |
| `schemas.py` | все pydantic-модели; имена = схемы контракта (`CreateUser`, `User`, `Session`, `ChatPage`, ...) |
| `deps.py` | `get_storage`, `get_passwords`, фабрики сервисов, `current_identity` / `current_user`, разбор Basic (`basic_credentials`), `PageParams` |
| `identity.py` | `BearerBackend` для `AuthenticationMiddleware`, `PUBLIC_ENDPOINTS`, `on_auth_error` |
| `request_id.py` | чистое ASGI-middleware (`__call__`): id запроса, заголовки `X-Request-Id` и `X-Instance-Id`, access-лог |
| `handlers.py` | `error_response()`, `app_error_response()` (с `WWW-Authenticate`) и обработчики всех исключений |
## Правила ручек
- Ручки и зависимости — только `async def`: драйвер БД асинхронный, а
синхронная `def` ушла бы в threadpool.
- Ручка: зависимости → вызов сервиса именованными аргументами →
`Schema.model_validate(domain_obj)`. Логики, обращений к хранилищу и
`try/except` здесь нет.
- POST создания — `status_code=201` в декораторе; `response_model` —
модель контракта. `DELETE /auth/sessions/current` — 204 без тела
(`response_class=Response`).
- Текущий пользователь — `CurrentUser`, текущая сессия (для logout) —
`CurrentIdentity` из `deps.py`. Заголовки `Authorization` и `X-User-Id`
в ручках не читать и не объявлять `Header()`.
- Ошибки — исключения из `src/errors.py`. `HTTPException` не бросать,
`JSONResponse` с ошибкой руками не собирать — только `handlers.py`.
- Модели API в сервис не передавать: разбирать на именованные аргументы.
## Идентификация (лаба 2)
- Bearer проверяет `BearerBackend` в `AuthenticationMiddleware` **до
роутинга и разбора тела**: битый JSON без токена получает 401, а не
400 («сначала аутентификация», `contracts/README.md`). Не переносить
проверку в зависимость ручки — порядок сломается.
- Защищено всё под `/api/v1/`, кроме `PUBLIC_ENDPOINTS`:
`POST /api/v1/users` и `POST /api/v1/auth/sessions`. Health и `/docs`
— вне `/api/v1`.
- Токен — из `Authorization: Bearer <token>` (схема без учёта
регистра). Нет заголовка, другая схема (в том числе Basic на
бизнес-ручке), пустой, неизвестный, истёкший, отозванный токен —
одинаковый 401 `Unauthorized` с `WWW-Authenticate: Bearer
realm="messenger"`.
- PostgreSQL недоступен во время проверки токена — 503 `unavailable` без
`WWW-Authenticate`: бэкенд заворачивает любую `AppError` в
`AuthFailure`, и `on_auth_error` отвечает её статусом. Запрос никогда
не идёт дальше как анонимный.
- `X-User-Id` не читается нигде: не даёт доступа и не меняет владельца
сессии.
- `current_identity` объявляет `Security(HTTPBearer(scheme_name=
"bearerAuth", bearerFormat="opaque session token", auto_error=False))`
только ради схемы в `/openapi.json` и кнопки Authorize в `/docs`; сам
заголовок там не читается — сессию уже положил бэкенд в `request.user`.
## Вход по Basic (`POST /auth/sessions`)
- Путь публичный для middleware; Basic разбирает зависимость
`basic_credentials`. Схема объявлена через `HTTPBase(scheme="basic",
scheme_name="basicAuth", auto_error=False)` (импорт из
`fastapi.security.http`). **Не `HTTPBasic`**: он декодирует ASCII и на
пароле не из ASCII сам отвечает 401 мимо формата контракта.
- Разбор: схема `Basic` → base64 строго (`validate=True`) → UTF-8 →
`partition(":")` по **первому** двоеточию (в пароле двоеточие
допустимо). Username не по шаблону и пароль вне 12–128 code points
отсекаются здесь, до БД и KDF. Любой сбой — тот же 401
`InvalidCredentials` с `WWW-Authenticate: Basic realm="messenger",
charset="UTF-8"`, что и неверный пароль. Ответа 400 у входа нет.
- JSON-тело входа не читается.
## Ловушки FastAPI и что ждёт контракт
| Ситуация | FastAPI по умолчанию | Нужно |
|---|---|---|
| ошибка валидации тела/пути/query | 422 `{"detail": ...}` | 400 `invalid_request` в формате контракта (`on_validation_error`) |
| битый JSON, массив вместо объекта | 422 `json_invalid` | 400 (с токеном) или 401 (без токена: middleware раньше) |
| неизвестный путь / метод | 404 / 405 `{"detail"}` | формат контракта (`on_http_error`) |
| необработанное исключение | 500 text/plain без `X-Request-Id` | 500 `internal_error` + заголовок (`on_unexpected_error` ставит его сам) |
| `Authorization` как `Header()` | пропуск → 400 из валидации | только схемы безопасности с `auto_error=False` |
| `HTTPBasic` | ASCII, свой 401 | `HTTPBase` + свой разбор |
| `strict=True` на всю модель | UUID-строка из JSON не проходит | строгость на полях: `StrictStr`, `NonBlankStr` |
## Валидация (всё — 400)
- Модели запросов наследуют `_Request` (`extra="forbid"`): лишнее поле,
например `sender_id` в сообщении, — 400.
- Строки — `StrictStr`: число вместо строки — 400. Обязательные строки
(`display_name`, `title`, `text`, `password`) — `NonBlankStr`: одни
пробелы — 400, значение не обрезается и не нормализуется.
- Длины — в Unicode code points (`len(str)`): `display_name`, `title`
1–100, `text` 1–4000, `password` 12–128. `username` —
`^[a-z0-9_]{3,32}$` целиком.
- `member_ids`: 1–100 UUID; дубликаты, неизвестные и отсутствие
вызывающего — 400 из сервиса/хранилища (`InvalidMembers`).
- `chat_id` не UUID, `limit` вне 1–100 или не число, пустой или битый
`cursor` — 400.
- Лимиты — только из `src/constants.py`.
## Ответы
- Модели ответа наследуют `_Response` (`from_attributes=True`), время —
тип `Timestamp` (RFC 3339 с `Z`). Лишних полей нет: smoke сверяет
`additionalProperties: false`. В `User` нет пароля, хэша и сессии.
- `Session`: `token`, `token_type="Bearer"`, `expires_at`, `user`.
- Список — `{"items": [...], "next_cursor": null | "..."}`.
- `X-Request-Id` ставит `RequestIdMiddleware` каждому ответу; входящий
заголовок принимается, только если он `[A-Za-z0-9._-]{1,64}`.
- `X-Instance-Id` (лаба 3) — **в каждом ответе API**: успех, ошибки,
health, 401/503 от аутентификации, 404 неизвестного пути, 405, 500.
Одно значение на процесс (`Settings.instance_id`: `APP_INSTANCE_ID` или
hostname — в контейнере начало ID). Ответы самого HAProxy (502/503/504)
его не имеют — контракт допускает. Тест — `test_request_id.py`.
- Access-лог: одна строка `METHOD path -> status (ms)`, без query, тела
и заголовков. Второй access-лог (uvicorn) выключен.
## Отправка сообщения: `Idempotency-Key` (лаба 3)
- Заголовок обязателен только у `POST /api/v1/chats/{chat_id}/messages`:
параметр ручки `Header(alias="Idempotency-Key", pattern=...)` с
шаблоном `IDEMPOTENCY_KEY_PATTERN` (`^[A-Za-z0-9._:-]{1,128}$`). Нет
ключа, пустой, длиннее 128, недопустимый символ, не-ASCII — 400
`invalid_request` той же валидацией, что тело; значение ключа в текст
ошибки не попадает. Другие POST ключ не читают.
- Порядок кодов: 401 (сессия — middleware) → 400 (ключ и тело — схема
ручки) → 404 (не участник — сервис) → 409 (ключ занят другим телом —
хранилище). Без токена — 401 даже с битым JSON и без ключа:
аутентификация в middleware раньше разбора тела и заголовков ручки.
Закреплено `test_idempotency.py::test_codes_order_401_400_404_409`.
- Повтор того же тела — **тот же 201 и то же `Message`** (тот же `id`,
`created_at` до микросекунды): ручка не различает новое и повторное.
«То же тело» — семантически: пробелы и `\u`-экранирование не важны
(хэш канонического JSON в сервисе).
- Прозрачных повторов других POST нет ни в API, ни в LB.
## Проверка правок этого слоя
`make fmt && make lint && make test-isolated`. Для точечной проверки —
рабочий стенд (`make up`) и `curl -s -i` с выводом статуса,
`x-request-id`, `x-instance-id`, `www-authenticate` и тела. Токен в
вывод и отчёт не копировать.
View File
+170
View File
@@ -0,0 +1,170 @@
"""Зависимости ручек: хранилище, сервисы, текущая сессия, вход, страница."""
import base64
import binascii
import re
from dataclasses import dataclass, field
from typing import Annotated
from fastapi import Depends, Query, Request, Security
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
from fastapi.security.http import HTTPBase
from src.constants import (
PAGE_LIMIT_DEFAULT,
PAGE_LIMIT_MAX,
PAGE_LIMIT_MIN,
PASSWORD_MAX_LENGTH,
PASSWORD_MIN_LENGTH,
USERNAME_PATTERN,
)
from src.domain import Identity, User
from src.errors import InvalidCredentials, Unauthorized
from src.passwords import Passwords
from src.services import ChatService, MessageService, SessionService, UserService
from src.storage import Storage
async def get_storage(request: Request) -> Storage:
return request.app.state.storage
async def get_passwords(request: Request) -> Passwords:
return request.app.state.passwords
StorageDep = Annotated[Storage, Depends(get_storage)]
PasswordsDep = Annotated[Passwords, Depends(get_passwords)]
async def get_user_service(storage: StorageDep, passwords: PasswordsDep) -> UserService:
return UserService(storage, passwords)
async def get_session_service(
request: Request,
storage: StorageDep,
passwords: PasswordsDep,
) -> SessionService:
return SessionService(
storage, passwords, ttl=request.app.state.settings.session_ttl
)
async def get_chat_service(storage: StorageDep) -> ChatService:
return ChatService(storage)
async def get_message_service(request: Request, storage: StorageDep) -> MessageService:
return MessageService(
storage,
key_ttl=request.app.state.settings.idempotency_ttl,
)
UserServiceDep = Annotated[UserService, Depends(get_user_service)]
SessionServiceDep = Annotated[SessionService, Depends(get_session_service)]
ChatServiceDep = Annotated[ChatService, Depends(get_chat_service)]
MessageServiceDep = Annotated[MessageService, Depends(get_message_service)]
# схемы bearerAuth и basicAuth из contracts/openapi.json: они есть в
# /openapi.json и дают кнопку Authorize в /docs. auto_error=False —
# FastAPI не отвечает сам своим 403/401 мимо формата контракта.
# Bearer проверяет BearerBackend (identity.py) ещё до роутинга.
bearer_scheme = HTTPBearer(
scheme_name="bearerAuth",
bearerFormat="opaque session token",
auto_error=False,
)
# HTTPBase, а не HTTPBasic: HTTPBasic декодирует credentials как ASCII и
# на пароле не из ASCII сам отвечает 401, а контракт требует UTF-8
basic_scheme = HTTPBase(scheme="basic", scheme_name="basicAuth", auto_error=False)
async def current_identity(
request: Request,
_credentials: Annotated[
HTTPAuthorizationCredentials | None, Security(bearer_scheme)
],
) -> Identity:
"""Сессия, которую нашёл BearerBackend.
`_credentials` здесь не читается: параметр только объявляет схему
bearerAuth в OpenAPI. Если ручку вдруг повесили на публичный путь,
сессии нет — 401, а не падение.
"""
identity = request.user
if not isinstance(identity, Identity):
raise Unauthorized
return identity
CurrentIdentity = Annotated[Identity, Depends(current_identity)]
async def current_user(identity: CurrentIdentity) -> User:
return identity.user
CurrentUser = Annotated[User, Depends(current_user)]
@dataclass(frozen=True, slots=True)
class BasicCredentials:
username: str
password: str = field(repr=False)
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 basic_credentials(
credentials: Annotated[HTTPAuthorizationCredentials | None, Security(basic_scheme)],
) -> BasicCredentials:
"""Учётные данные входа; любой сбой разбора — тот же 401, что неверный пароль."""
parsed = parse_basic(credentials)
if parsed is None:
raise InvalidCredentials
return parsed
BasicCredentialsDep = Annotated[BasicCredentials, Depends(basic_credentials)]
@dataclass(frozen=True, slots=True)
class PageParams:
limit: int
cursor: str | None
async def page_params(
limit: Annotated[int, Query(ge=PAGE_LIMIT_MIN, le=PAGE_LIMIT_MAX)] = (
PAGE_LIMIT_DEFAULT
),
cursor: Annotated[str | None, Query(min_length=1)] = None,
) -> PageParams:
return PageParams(limit=limit, cursor=cursor)
PageDep = Annotated[PageParams, Depends(page_params)]
+121
View File
@@ -0,0 +1,121 @@
"""Любая ошибка → `{"error": {"code", "message", "request_id"}}`.
- `AppError`: статус, `code` и `WWW-Authenticate` (у 401) берутся из
класса исключения.
- Ошибки валидации FastAPI → 400 `invalid_request` (422 не отдаётся).
- 404 неизвестного пути и 405 → формат контракта.
- Непредвиденное исключение → 500 без деталей. Traceback пишет uvicorn:
Starlette после ответа бросает исключение дальше.
"""
from uuid import uuid4
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from starlette.exceptions import HTTPException as StarletteHTTPException
from starlette.requests import HTTPConnection
from src.api.schemas import ErrorBody, ErrorResponse
from src.constants import INSTANCE_ID_HEADER, REQUEST_ID_HEADER
from src.errors import AppError
_HTTP_ERRORS: dict[int, tuple[str, str]] = {
404: ("not_found", "Not found"),
405: ("invalid_request", "Method not allowed"),
}
def request_id_of(conn: HTTPConnection) -> str:
"""Id запроса от RequestIdMiddleware; запасной — если ошибка случилась раньше."""
return getattr(conn.state, "request_id", None) or uuid4().hex
def error_response(
conn: HTTPConnection,
*,
status_code: int,
code: str,
message: str,
headers: dict[str, str] | None = None,
) -> JSONResponse:
request_id = request_id_of(conn)
body = ErrorResponse(
error=ErrorBody(code=code, message=message, request_id=request_id),
)
return JSONResponse(
status_code=status_code,
content=body.model_dump(),
# заголовки ставит и middleware; здесь они нужны ответам 500,
# которые формируются снаружи всех middleware
headers={
**(headers or {}),
REQUEST_ID_HEADER: request_id,
INSTANCE_ID_HEADER: conn.app.state.settings.instance_id,
},
)
def app_error_response(conn: HTTPConnection, exc: AppError) -> JSONResponse:
"""Ответ на доменную ошибку; общий для ручек и AuthenticationMiddleware."""
return error_response(
conn,
status_code=exc.status_code,
code=exc.code,
message=str(exc),
headers={"WWW-Authenticate": exc.challenge} if exc.challenge else None,
)
async def on_app_error(request: Request, exc: AppError) -> JSONResponse:
return app_error_response(request, exc)
async def on_validation_error(
request: Request,
exc: RequestValidationError,
) -> JSONResponse:
# первая ошибка: где и что не так; входное значение в ответ не попадает
errors = exc.errors()
first = errors[0] if errors else {}
location = ".".join(str(part) for part in first.get("loc", ()))
reason = first.get("msg", "Invalid request")
return error_response(
request,
status_code=400,
code="invalid_request",
message=f"{location}: {reason}" if location else reason,
)
async def on_http_error(
request: Request,
exc: StarletteHTTPException,
) -> JSONResponse:
code, message = _HTTP_ERRORS.get(
exc.status_code,
("invalid_request", "Invalid request"),
)
return error_response(
request,
status_code=exc.status_code,
code=code,
message=message,
headers=exc.headers,
)
async def on_unexpected_error(request: Request, _exc: Exception) -> JSONResponse:
return error_response(
request,
status_code=500,
code="internal_error",
message="Internal server error",
)
def install(app: FastAPI) -> None:
app.add_exception_handler(AppError, on_app_error)
app.add_exception_handler(RequestValidationError, on_validation_error)
app.add_exception_handler(StarletteHTTPException, on_http_error)
app.add_exception_handler(Exception, on_unexpected_error)
+89
View File
@@ -0,0 +1,89 @@
"""Идентификация лабы 2: Bearer-сессия — до роутинга и разбора тела.
Работает через стандартный `AuthenticationMiddleware` Starlette.
`BearerBackend` вызывается на каждый запрос:
- публичный путь (health, docs, `POST /api/v1/users`,
`POST /api/v1/auth/sessions`) — `None`, запрос идёт дальше без
пользователя. Вход по Basic разбирает сама ручка входа (`deps.py`);
- защищённый путь — сессия по токену из `Authorization: Bearer <token>`
или отказ, и middleware сразу отвечает через `on_auth_error`.
Поэтому 401 приходит раньше любой проверки тела, пути и query: «сначала
аутентификация» из contracts/README.md выполняется даже для битого JSON.
Ручки берут готовую сессию из `request.user` (`deps.current_identity`).
`X-User-Id` больше не читается нигде: он не даёт доступа и не меняет
владельца сессии. Basic на бизнес-ручке — чужая схема, тот же 401 с
вызовом Bearer. Недоступность PostgreSQL — 503, а не 401 и не анонимный
доступ.
"""
from fastapi.responses import JSONResponse
from fastapi.security.utils import get_authorization_scheme_param
from starlette.authentication import (
AuthCredentials,
AuthenticationBackend,
AuthenticationError,
)
from starlette.requests import HTTPConnection
from src.api.handlers import app_error_response
from src.constants import API_PREFIX, AUTHORIZATION_HEADER, SESSIONS_PATH
from src.domain import Identity
from src.errors import AppError, Unauthorized
from src.services import SessionService
# публичные пути внутри API_PREFIX: регистрация и вход по Basic
PUBLIC_ENDPOINTS = frozenset(
{
("POST", f"{API_PREFIX}/users"),
("POST", SESSIONS_PATH),
},
)
def requires_identity(method: str, path: str) -> bool:
return path.startswith(f"{API_PREFIX}/") and (method, path) not in PUBLIC_ENDPOINTS
def bearer_token(header: str | None) -> str | None:
"""Токен из `Authorization: Bearer <token>`; другая схема — `None`."""
scheme, token = get_authorization_scheme_param(header)
if scheme.lower() != "bearer" or not token:
return None
return token
class AuthFailure(AuthenticationError):
"""Отказ бэкенда с доменной ошибкой: 401 или 503 (БД недоступна)."""
def __init__(self, error: AppError) -> None:
super().__init__(str(error))
self.error = error
class BearerBackend(AuthenticationBackend):
async def authenticate(
self,
conn: HTTPConnection,
) -> tuple[AuthCredentials, Identity] | None:
if not requires_identity(conn.scope.get("method", ""), conn.scope["path"]):
return None
state = conn.app.state
sessions = SessionService(
state.storage,
state.passwords,
ttl=state.settings.session_ttl,
)
token = bearer_token(conn.headers.get(AUTHORIZATION_HEADER))
try:
identity = await sessions.authenticate(token=token)
except AppError as exc:
raise AuthFailure(exc) from exc
return AuthCredentials(["authenticated"]), identity
def on_auth_error(conn: HTTPConnection, exc: AuthenticationError) -> JSONResponse:
error = exc.error if isinstance(exc, AuthFailure) else Unauthorized()
return app_error_response(conn, error)
+83
View File
@@ -0,0 +1,83 @@
"""X-Request-Id и X-Instance-Id на каждом ответе, одна строка access-лога.
Чистое ASGI-middleware: прямой вызов приложения и обёртка send.
Без дочерней задачи и потока сообщений на каждый запрос: это уменьшает
накладные расходы слоя, исследуемые в треке «5».
Id запроса: входящий `X-Request-Id`, если он короткий и безопасный
(`[A-Za-z0-9._-]{1,64}`), иначе новый uuid4. Так id проходит через
балансировщик, а мусор из заголовка не попадает в логи. Тот же id — в
заголовке ответа, в `request_id` тела ошибки и в каждой строке лога
этого запроса.
`X-Instance-Id` (лаба 3) — реплика, которая обслужила запрос: одно
значение на процесс (`Settings.instance_id`). Ответы, которые создаёт
сам HAProxy (502/503/504), его не имеют — контракт это допускает.
"""
import re
import time
from uuid import uuid4
from starlette.datastructures import Headers, MutableHeaders
from starlette.types import ASGIApp, Message, Receive, Scope, Send
from src.constants import HEALTH_PATHS, INSTANCE_ID_HEADER, REQUEST_ID_HEADER
from src.log import get_logger, request_id_var
log = get_logger("src.http")
_SAFE_REQUEST_ID = re.compile(r"[A-Za-z0-9._-]{1,64}")
def _request_id(scope: Scope) -> str:
incoming = Headers(scope=scope).get(REQUEST_ID_HEADER)
if incoming and _SAFE_REQUEST_ID.fullmatch(incoming):
return incoming
return uuid4().hex
class RequestIdMiddleware:
def __init__(self, app: ASGIApp, *, instance_id: str) -> None:
self.app = app
self.instance_id = instance_id
async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
if scope["type"] != "http":
await self.app(scope, receive, send)
return
request_id = _request_id(scope)
# request.state.request_id — для обработчиков ошибок
scope.setdefault("state", {})["request_id"] = request_id
# не сбрасывается: у каждого запроса в uvicorn своя задача, а
# traceback непредвиденной ошибки uvicorn пишет уже после выхода
# отсюда, и в нём тоже нужен rid
request_id_var.set(request_id)
status_code = 500
started = time.perf_counter()
async def send_with_ids(message: Message) -> None:
nonlocal status_code
if message["type"] == "http.response.start":
status_code = message["status"]
headers = MutableHeaders(scope=message)
if REQUEST_ID_HEADER not in headers:
headers.append(REQUEST_ID_HEADER, request_id)
if INSTANCE_ID_HEADER not in headers:
headers.append(INSTANCE_ID_HEADER, self.instance_id)
await send(message)
try:
await self.app(scope, receive, send_with_ids)
finally:
# health дёргают healthcheck и балансировщик: в лог не пишем.
# Путь без query; тела и заголовки идентификации не логируются
if scope["path"] not in HEALTH_PATHS:
log.info(
"%s %s -> %d (%.1f ms)",
scope["method"],
scope["path"],
status_code,
(time.perf_counter() - started) * 1000,
)
+24
View File
@@ -0,0 +1,24 @@
"""Роутеры. `api_router` собирает ручки версии 1 под API_PREFIX.
Новый домен регистрируется только здесь.
"""
from fastapi import APIRouter
from src.api.routes.chats import router as chats_router
from src.api.routes.health import router as health_router
from src.api.routes.messages import router as messages_router
from src.api.routes.sessions import router as sessions_router
from src.api.routes.users import router as users_router
from src.constants import API_PREFIX
api_router = APIRouter(prefix=API_PREFIX)
api_router.include_router(users_router)
api_router.include_router(sessions_router)
api_router.include_router(chats_router)
api_router.include_router(messages_router)
__all__ = [
"api_router",
"health_router",
]
+46
View File
@@ -0,0 +1,46 @@
from uuid import UUID
from fastapi import APIRouter
from src.api import schemas
from src.api.deps import ChatServiceDep, CurrentUser, PageDep
router = APIRouter(prefix="/chats", tags=["chats"])
@router.post("", status_code=201, response_model=schemas.Chat)
async def create_chat(
user: CurrentUser,
body: schemas.CreateChat,
chats: ChatServiceDep,
) -> schemas.Chat:
chat = await chats.create(
creator_id=user.id,
title=body.title,
member_ids=body.member_ids,
)
return schemas.Chat.model_validate(chat)
@router.get("", response_model=schemas.ChatPage)
async def list_chats(
user: CurrentUser,
page: PageDep,
chats: ChatServiceDep,
) -> schemas.ChatPage:
result = await chats.list_for(
user_id=user.id,
limit=page.limit,
cursor=page.cursor,
)
return schemas.ChatPage.model_validate(result)
@router.get("/{chat_id}", response_model=schemas.Chat)
async def get_chat(
user: CurrentUser,
chat_id: UUID,
chats: ChatServiceDep,
) -> schemas.Chat:
chat = await chats.get(chat_id=chat_id, user_id=user.id)
return schemas.Chat.model_validate(chat)
+32
View File
@@ -0,0 +1,32 @@
from fastapi import APIRouter, Request
from src.api.schemas import ErrorResponse, Health
from src.constants import HEALTH_LIVE_PATH, HEALTH_READY_PATH
from src.errors import Unavailable
# вне версии API, без идентификации, в access-лог не пишутся
router = APIRouter(tags=["health"])
@router.get(HEALTH_LIVE_PATH, response_model=Health)
async def live() -> Health:
"""Процесс жив и отвечает по HTTP. Хранилища не проверяются."""
return Health()
@router.get(
HEALTH_READY_PATH,
response_model=Health,
responses={503: {"model": ErrorResponse}},
)
async def ready(request: Request) -> Health:
"""Можно обслуживать обязательный путь; иначе 503.
Критичная зависимость — PostgreSQL (`SELECT 1` за 2 с): в нём данные
и сессии. Valkey не проверяется: это кэш, без него запросы идут в
PostgreSQL. До конца старта и с начала остановки — тоже 503.
"""
if not request.app.state.ready:
raise Unavailable
await request.app.state.storage.ping()
return Health()
+51
View File
@@ -0,0 +1,51 @@
from typing import Annotated
from uuid import UUID
from fastapi import APIRouter, Header
from src.api import schemas
from src.api.deps import CurrentUser, MessageServiceDep, PageDep
from src.constants import IDEMPOTENCY_KEY_HEADER, IDEMPOTENCY_KEY_PATTERN
router = APIRouter(prefix="/chats/{chat_id}/messages", tags=["messages"])
# обязательный заголовок (лаба 3). Проверяет схема ручки вместе с телом:
# нет ключа или он не по шаблону — 400 после 401 (middleware) и до 404
# (членство в сервисе). Значение в текст ошибки не попадает
IdempotencyKey = Annotated[
str,
Header(alias=IDEMPOTENCY_KEY_HEADER, pattern=IDEMPOTENCY_KEY_PATTERN),
]
@router.post("", status_code=201, response_model=schemas.Message)
async def send_message(
user: CurrentUser,
chat_id: UUID,
body: schemas.CreateMessage,
idempotency_key: IdempotencyKey,
messages: MessageServiceDep,
) -> schemas.Message:
message = await messages.send(
chat_id=chat_id,
sender_id=user.id,
text=body.text,
idempotency_key=idempotency_key,
)
return schemas.Message.model_validate(message)
@router.get("", response_model=schemas.MessagePage)
async def list_messages(
user: CurrentUser,
chat_id: UUID,
page: PageDep,
messages: MessageServiceDep,
) -> schemas.MessagePage:
result = await messages.history(
chat_id=chat_id,
user_id=user.id,
limit=page.limit,
cursor=page.cursor,
)
return schemas.MessagePage.model_validate(result)
+29
View File
@@ -0,0 +1,29 @@
from fastapi import APIRouter, Response
from src.api import schemas
from src.api.deps import BasicCredentialsDep, CurrentIdentity, SessionServiceDep
router = APIRouter(prefix="/auth/sessions", tags=["sessions"])
@router.post("", status_code=201, response_model=schemas.Session)
async def create_session(
credentials: BasicCredentialsDep,
sessions: SessionServiceDep,
) -> schemas.Session:
"""Вход по `Authorization: Basic`; тело запроса не читается."""
issued = await sessions.login(
username=credentials.username,
password=credentials.password,
)
return schemas.Session.model_validate(issued)
@router.delete("/current", status_code=204, response_class=Response)
async def revoke_current_session(
identity: CurrentIdentity,
sessions: SessionServiceDep,
) -> Response:
"""Выход: отзывается только сессия этого токена."""
await sessions.revoke(session_id=identity.session_id)
return Response(status_code=204)
+24
View File
@@ -0,0 +1,24 @@
from fastapi import APIRouter
from src.api import schemas
from src.api.deps import CurrentUser, UserServiceDep
router = APIRouter(prefix="/users", tags=["users"])
@router.post("", status_code=201, response_model=schemas.User)
async def register_user(
body: schemas.CreateUser,
users: UserServiceDep,
) -> schemas.User:
user = await users.register(
username=body.username,
display_name=body.display_name,
password=body.password,
)
return schemas.User.model_validate(user)
@router.get("/me", response_model=schemas.User)
async def get_me(user: CurrentUser) -> schemas.User:
return schemas.User.model_validate(user)
+133
View File
@@ -0,0 +1,133 @@
"""HTTP-модели. Имена и поля совпадают со схемами contracts/openapi.json.
Модели запросов строгие: лишнее поле или неверный тип — 400. Строгость
задаётся на уровне полей (`StrictStr`), а не `strict=True` на всю
модель: иначе UUID, пришедший строкой в JSON, не прошёл бы проверку.
"""
from datetime import datetime
from typing import Annotated, Literal
from uuid import UUID
from pydantic import (
AfterValidator,
BaseModel,
ConfigDict,
Field,
PlainSerializer,
StrictStr,
)
from src.clock import to_rfc3339
from src.constants import (
CHAT_MEMBERS_MAX,
CHAT_TITLE_MAX_LENGTH,
DISPLAY_NAME_MAX_LENGTH,
MESSAGE_TEXT_MAX_LENGTH,
PASSWORD_MAX_LENGTH,
PASSWORD_MIN_LENGTH,
USERNAME_PATTERN,
)
def _not_blank(value: str) -> str:
"""Строка из одних пробельных символов невалидна; значение не обрезается."""
if not value.strip():
raise ValueError("must not be blank")
return value
# строгая непустая строка: число не превращается в строку, пробелы — 400
NonBlankStr = Annotated[StrictStr, AfterValidator(_not_blank)]
# время в ответе: RFC 3339 UTC с микросекундами и Z
Timestamp = Annotated[datetime, PlainSerializer(to_rfc3339, return_type=str)]
class _Request(BaseModel):
model_config = ConfigDict(extra="forbid")
class _Response(BaseModel):
model_config = ConfigDict(from_attributes=True)
class CreateUser(_Request):
username: StrictStr = Field(pattern=USERNAME_PATTERN)
display_name: NonBlankStr = Field(min_length=1, max_length=DISPLAY_NAME_MAX_LENGTH)
# длина в code points; значение не обрезается и не нормализуется
password: NonBlankStr = Field(
min_length=PASSWORD_MIN_LENGTH,
max_length=PASSWORD_MAX_LENGTH,
json_schema_extra={"writeOnly": True},
)
class User(_Response):
"""Пароля, его хэша и данных сессии здесь нет и быть не может."""
id: UUID
username: str
display_name: str
created_at: Timestamp
class Session(_Response):
"""Ответ на вход. Токен клиент видит только здесь, один раз."""
token: str
token_type: Literal["Bearer"] = "Bearer"
expires_at: Timestamp
user: User
class CreateChat(_Request):
title: NonBlankStr = Field(min_length=1, max_length=CHAT_TITLE_MAX_LENGTH)
# только форма списка; дубликаты, существование участников и
# вызывающего в списке проверяет ChatService.create
member_ids: list[UUID] = Field(min_length=1, max_length=CHAT_MEMBERS_MAX)
class Chat(_Response):
id: UUID
title: str
member_ids: list[UUID]
created_at: Timestamp
class ChatPage(_Response):
items: list[Chat]
next_cursor: str | None
class CreateMessage(_Request):
"""Отправитель берётся из идентификации: поле sender_id даёт 400."""
text: NonBlankStr = Field(min_length=1, max_length=MESSAGE_TEXT_MAX_LENGTH)
class Message(_Response):
id: UUID
chat_id: UUID
sender_id: UUID
text: str
created_at: Timestamp
class MessagePage(_Response):
items: list[Message]
next_cursor: str | None
class Health(BaseModel):
status: Literal["ok"] = "ok"
class ErrorBody(BaseModel):
code: str
message: str
request_id: str
class ErrorResponse(BaseModel):
error: ErrorBody