feat: add replicated messenger and reproducible lab3 stand
This commit is contained in:
@@ -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` и тела. Токен в
|
||||
вывод и отчёт не копировать.
|
||||
+170
@@ -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)]
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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,
|
||||
)
|
||||
@@ -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",
|
||||
]
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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
|
||||
Reference in New Issue
Block a user