3 Commits
Author SHA1 Message Date
yulianpoludnev 65959d0dd1 Исправление тестов
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-10-30 20:19:04 +03:00
yulianpoludnev ab8c5e8f3b Добавлены слои данных: контекс, сущности и миграции
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-10-30 19:53:14 +03:00
yulianpoludnev f511c95962 Выполнениие лабораторной работы на 5, трек 2.
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-10-23 21:13:27 +03:00
90 changed files with 5994 additions and 14 deletions
+7
View File
@@ -18,3 +18,10 @@ __pycache__
node_modules
evidence
.DS_Store
# Артефакты сборки хоста: содержат абсолютные пути Windows и ломают restore в контейнере.
**/bin
**/obj
.vs
tools
scr/Messenger.Api.Tests
+5
View File
@@ -9,3 +9,8 @@ DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
# Lab 2, уровень 4
CACHE_TTL_SECONDS=300
# Только для экспериментов: добавляет заголовки X-Cache и X-Db-Queries.
DIAGNOSTIC_HEADERS=false
+1
View File
@@ -0,0 +1 @@
*.sh text eol=lf
+12
View File
@@ -30,3 +30,15 @@ coverage/
.vscode/
# Keep small, sanitized evidence summaries in evidence/ under version control.
# Inspect git diff --cached: ignore rules are not a secret scanner.
# Local IDE/user files
*.csproj.user
.vs/
scr/Messenger.Api/Test/
secrets/
# Рабочие файлы эксперимента трека 2 (пароль контейнера, схема)
scripts/track2/.work/
# Шаблонное правило data/ (локальные данные) на Windows совпадает и с каталогом Data/ приложения (core.ignorecase=true).
# Исходники слоя данных (DbContext, сущности, миграции) обязаны быть в Git.
!scr/Messenger.Api/Data/
+28
View File
@@ -0,0 +1,28 @@
# Версии закреплены тегом и digest (SDK 10.0.401, runtime 10.0.12), сборка воспроизводима.
FROM mcr.microsoft.com/dotnet/sdk:10.0.401@sha256:e70cdb7f80b0348f5cb85f19a8f670fca061f033d57eed12fa003d58b0e06317 AS build
WORKDIR /src
COPY scr/Messenger.Api/Messenger.Api.csproj scr/Messenger.Api/
RUN dotnet restore scr/Messenger.Api/Messenger.Api.csproj
COPY scr/Messenger.Api/ scr/Messenger.Api/
RUN dotnet publish scr/Messenger.Api/Messenger.Api.csproj \
--configuration Release \
--output /app/publish \
--no-restore
FROM mcr.microsoft.com/dotnet/aspnet:10.0.12@sha256:222759b391a1aaf241166672c8f99b2d4ada452e7b5319f3c6e8f265a37b5ad4 AS runtime
WORKDIR /app
COPY --from=build /app/publish .
ENV ASPNETCORE_URLS=http://0.0.0.0:8080
EXPOSE 8080
# Непривилегированный пользователь (APP_UID задан в базовом образе aspnet).
USER $APP_UID
# curl в образе нет, поэтому проверку выполняет само приложение (/health/live).
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 CMD ["dotnet", "Messenger.Api.dll", "--healthcheck"]
ENTRYPOINT ["dotnet", "Messenger.Api.dll"]
+116 -14
View File
@@ -1,37 +1,139 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Автор, группа: Полуднев Юлиан, БВТ2303
- Целевая оценка; выбранный трек, если нужен: 5, трек 2 «План запроса и восстановление».
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Использованные источники, библиотеки и помощь ИИ: документация PostgreSQL, EF Core, Npgsql, Valkey, RFC 7617; NuGet: Npgsql.EntityFrameworkCore.PostgreSQL 10.0.3, EFCore.NamingConventions 10.0.1, Isopoh.Cryptography.Argon2 2.0.0, StackExchange.Redis 3.4.20, Testcontainers.PostgreSql 4.16.0. ИИ-ассистент Claude Code использовался как ментор и для написания части кода; результат проверен запуском тестов и стенда.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Требуются Docker с Compose v2 (проверено на v5.1.3) и POSIX-оболочка для `scripts/*.sh` (Linux/macOS/WSL/Git Bash). Для тестов: Python 3.9+; для `dotnet test` — .NET SDK 10.0.401 и запущенный Docker.
```sh
sh scripts/init-secrets.sh # создаёт secrets/db_password, database_url.compose, cache_password, cache_url (случайные пароли, вне Git)
cp .env.example .env # локальные настройки (SESSION_TTL_SECONDS, CACHE_TTL_SECONDS и др.); .env не коммитится
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait # ждёт healthy всех сервисов; миграции применяет сам API при старте
python3 tests/smoke.py --base-url http://localhost:8080 # = make test
chmod +x scripts/restart.sh
python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh # = make test-persistence ACTION_SCRIPT=scripts/restart.sh
dotnet test scr/Messenger.Api.Tests # собственные тесты (нужен Docker)
```
Эксперимент трека 2 (изолированные контейнеры `track2-*`, стенд compose не затрагивается; нужны Docker, .NET SDK и собранный образ `messenger-api:lab2`):
```sh
sh scripts/track2/run.sh up # PostgreSQL, миграции приложения, 115 000 сообщений
sh scripts/track2/run.sh indexes # 4 варианта индекса: планы, размер, pgbench записи/чтения, WAL
sh scripts/track2/run.sh backup # pg_dump -> восстановление в новое хранилище -> сверка
sh scripts/track2/run.sh down # удалить контейнеры, тома и сеть эксперимента
```
Остановка с сохранением данных: `docker compose stop` (или `down` без `-v`).
Намеренное удаление учебных данных: `docker compose down -v` — удаляет volume `messenger-lab2_pgdata`.
Оператору больше ничего делать не нужно: пароли генерируются скриптом, схема создаётся миграциями при старте API.
Для экспериментов с кэшем `DIAGNOSTIC_HEADERS=true` добавляет заголовки `X-Cache` и `X-Db-Queries` (по умолчанию выключено).
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Клиент → API (ASP.NET Core minimal API, .NET 10) → PostgreSQL 17; Valkey 8.1 — кэш страниц истории.
| Роль | Service (compose) | Образ | Health | Volume | Сеть / порт | Credentials |
| --- | --- | --- | --- | --- | --- | --- |
| api | `api` | собирается из `Dockerfile` (aspnet 10.0.12 по digest) | `dotnet Messenger.Api.dll --healthcheck` → `/health/live` | нет (состояния нет) | `backend`, публикуется `8080` | secrets `database_url`, `cache_url` (файлы `DATABASE_URL_FILE`, `CACHE_URL_FILE`) |
| postgres | `db` | `postgres:17` по digest (17.11) | `pg_isready` | `pgdata` → `/var/lib/postgresql/data` | только `backend` | secret `db_password` (`POSTGRES_PASSWORD_FILE`) |
| cache | `cache` | `valkey/valkey:8.1` по digest (8.1.10) | `valkey-cli ping` | нет (кэш, persistence выключена) | только `backend` | secret `cache_password` (`--requirepass`) |
**Источник истины** — PostgreSQL: пользователи, чаты, участники, сообщения и сессии. Состояния в памяти процесса нет. Сессии хранятся только в PostgreSQL (`SESSION_STORE=postgres`), в Valkey их нет.
**Схема** (миграции EF Core в `scr/Messenger.Api/Data/Migrations/`):
- `users`: `uuid` PK, `UNIQUE(username)`, `CHECK` формата username и непустого display_name, `password_hash` (Argon2id).
- `chats` (`history_version`, `last_message_at`), `chat_members` (PK `(chat_id, user_id)`, индекс по `user_id`), `messages`.
- `messages` связаны с участником **составным FK** `(chat_id, sender_id) → chat_members`: БД не допускает сообщение от не-участника.
- `sessions`: `token_hash` (SHA-256 токена, `UNIQUE`), `user_id` FK, `created_at`, `expires_at`, `revoked_at`.
- Индекс истории `(chat_id, created_at, id)` — под keyset-запрос (обоснование и EXPLAIN — ниже).
**Транзакционные границы:**
- Регистрация: один `INSERT`; гонку одинакового username решает уникальный индекс (`23505` → `409`), а не предварительный `SELECT`.
- Создание чата: чат и все участники сохраняются одним `SaveChanges`, то есть одной транзакцией.
- Отправка сообщения: одна транзакция из `UPDATE chats SET history_version = history_version + 1, last_message_at = GREATEST(...) ... RETURNING` (берёт блокировку строки чата и проверяет членство), `INSERT` сообщения и `COMMIT`.
- Logout: один `UPDATE sessions SET revoked_at ... WHERE revoked_at IS NULL`.
**Порядок истории.** Курсор — `(created_at, id)`. Строка чата блокируется на время записи, а `created_at` выдаётся строго больше предыдущего (`last_message_at + 1 мс`), поэтому порядок коммитов в чате совпадает с порядком `created_at`, и курсор не пропускает сообщение, закоммиченное позже. Цена: записи в один чат сериализуются. Ограничения: время назначает приложение с точностью до миллисекунды; при >1000 сообщений/с в одном чате `created_at` уходит вперёд относительно часов.
**Аутентификация.** `POST /auth/sessions` принимает только Basic (разделитель — первое двоеточие; любая ошибка заголовка, неверный пароль и неизвестный пользователь дают одинаковый `401` с `WWW-Authenticate: Basic ...`). Для неизвестного пользователя пароль проверяется против заглушки, чтобы выровнять время ответа (замером не подтверждено). Токен — 32 случайных байта (256 бит), в БД только SHA-256. Остальные endpoint защищены стандартным `AuthenticationHandler` (`RequireAuthorization()`), который срабатывает до разбора тела: `401` приоритетнее `400/404`. `X-User-Id` игнорируется. Срок жизни — `SESSION_TTL_SECONDS` (по умолчанию 3600; неверное значение останавливает старт).
**Пароли.** Argon2id (Isopoh.Cryptography.Argon2), параметры по минимуму OWASP: m=19 MiB, t=2, p=1; соль и параметры внутри PHC-строки. Одновременно считается не более 4 хешей (иначе 100 параллельных запросов заняли бы ~2 GiB); при исчерпании слотов — `503`. Хеш считается до открытия транзакции. bcrypt не выбран: он усекает пароль до 72 байт, а контракт допускает до 128 символов UTF-8.
**Readiness.** `/health/ready` возвращает `200`, если API может открыть соединение с PostgreSQL (таймаут 2 с), иначе `503`. Valkey в готовность не входит: он необязателен, при его недоступности API полностью работоспособен. `/health/live` не обращается к зависимостям.
### Valkey: кэш страниц истории
- **Роль.** Ускоряет `GET /chats/{id}/messages`: страница (готовый JSON) хранится под ключом `hist:{chat_id}:v{history_version}:l{limit}:{cursor}`.
- **Источник истины** — PostgreSQL. Кэш ничего не хранит в единственном экземпляре; потеря всего содержимого (flush, рестарт) влияет только на скорость.
- **Согласованность и инвалидация.** `history_version` читается из PostgreSQL при каждом чтении, тем же запросом, что проверяет членство (`404` для постороннего). Версия растёт в транзакции записи сообщения, до подтверждения `201`. Поэтому после подтверждённой записи читатель вычисляет другой ключ и не может получить старую страницу; удалять ключи при записи не нужно. Страница, прочитанная из БД после чтения версии, может оказаться свежее ключа, но не старее. Устаревшие ключи удаляются по TTL (300 с) и вытесняются LRU (`maxmemory 64mb`, `allkeys-lru`).
- **Что кэшируется.** Только ответы на чтение истории; доступ проверяется до обращения к кэшу, поэтому закэшированная страница не видна постороннему.
- **Persistence.** Выключена намеренно (`--save "" --appendonly no`): кэш воспроизводим из PostgreSQL. Сессии в нём не хранятся, поэтому требование о persistence для единственного хранилища сессий неприменимо.
- **Отказ кэша.** Таймауты клиента 500 мс подключение / 200 мс операция, `AbortOnConnectFail=false`. При ошибке кэш обходится на 5 с (чтобы запросы не ждали таймаут), чтение идёт из PostgreSQL, ответ тот же; метка `bypass` в `X-Cache` при диагностике.
### Устойчивость к отказам зависимостей
| Параметр | Значение (по умолчанию) | Переменная |
| --- | --- | --- |
| Максимум соединений с PostgreSQL от экземпляра | 20 | `DB_MAX_POOL_SIZE` |
| Одновременных вычислений Argon2 / ожидание слота до `503` | 4 / 2 с | `PASSWORD_HASH_CONCURRENCY`, `PASSWORD_HASH_QUEUE_TIMEOUT_SECONDS` |
| Ожидание соединения / открытие | 5 с | `DB_CONNECT_TIMEOUT_SECONDS` |
| Таймаут команды | 5 с | `DB_COMMAND_TIMEOUT_SECONDS` |
Недоступность или перегрузка PostgreSQL (нет соединения, таймаут, исчерпан пул, остановка сервера) отображаются в `503 unavailable` с телом из общего формата без SQL, хоста и стека (они только в логе). Запрос без токена по-прежнему получает `401`: анонимный пользователь не становится доверенным ни при каком отказе. Все SQL-запросы параметризованы (LINQ / `FromSql` с интерполяцией EF и `NpgsqlCommand` с параметрами); конкатенации SQL из пользовательского ввода нет.
**Что перенесено из lab1 и что изменено.** Сохранены контракт API, формат ошибок, `X-Request-Id`, keyset-курсор, привязанный к чату, и логика доступа (`404` для постороннего). Заменены: `InMemoryStorage` → PostgreSQL; `X-User-Id` → Bearer-сессии (объявленный переход lab2); в регистрацию добавлен пароль.
**Соответствие `.env.example`.** `APP_PORT`, `SESSION_TTL_SECONDS`, `DATABASE_URL_FILE`, `CACHE_URL_FILE`, `CACHE_TTL_SECONDS`, `DIAGNOSTIC_HEADERS`, `SESSION_STORE=postgres` отражают реальную конфигурацию (последняя пока только документирует выбор). `APP_HOST` и `APP_ENV` приложением не читаются. Дополнительно приложение читает `DB_MAX_POOL_SIZE`, `DB_CONNECT_TIMEOUT_SECONDS`, `DB_COMMAND_TIMEOUT_SECONDS`, `PASSWORD_HASH_CONCURRENCY`, `PASSWORD_HASH_QUEUE_TIMEOUT_SECONDS`, `CACHE_CONNECTION` (используется тестами), а compose — `API_PUBLISHED_PORT`.
## Доказательства критериев
Уровень 3 — [evidence/lab2-level3.md](evidence/lab2-level3.md), уровень 4 — [evidence/lab2-level4.md](evidence/lab2-level4.md).
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke | `python3 tests/smoke.py --base-url http://localhost:8080` (= `make test`) | PASS (в том числе при остановленном кэше и после восстановления БД) | lab2-level3.md, lab2-level4.md |
| Данные и действующие сессии переживают рестарт API и хранилищ без удаления volumes | `tests/resilience.py --mode persistence --action-script scripts/restart.sh` | PASS; перезапущены `db`, `cache`, `api` (время старта изменилось), volume тот же, прежний токен работает | lab2-level4.md |
| PostgreSQL: users, chats, members, messages; PK/FK, уникальность username, атомарное создание чата | миграции; тесты `CreateChat_WithUnknownMember...`, `RegisterSameUsernameConcurrently...` | таблицы и ограничения созданы | lab2-level3.md |
| Миграции повторяемы без дублей | рестарт стенда (API снова вызывает `Migrate()`) | `__EFMigrationsHistory`: 2 → 2; данные не изменились | lab2-level3.md |
| Basic только на `POST /auth/sessions`; остальное — Bearer; срок жизни и отзыв; `X-User-Id` не даёт доступ | `AuthTests` | PASS | lab2-level3.md |
| Пароли хешируются KDF | `PasswordsAreStoredAsArgon2id`, `PasswordHasherTests` | `$argon2id$v=19$m=19456,t=2,p=1$...` | lab2-level3.md |
| Secrets и volumes не в Git | `git check-ignore -v .env secrets/db_password` | оба игнорируются | — |
| **4.** Valkey реально используется; источник истины, expiry, инвалидация описаны | раздел «Valkey: кэш страниц истории»; сценарий miss/hit/запись/отказ | `X-Cache` miss→hit, после записи новый ключ; SQL-запросов 3 → 2 на попадание | lab2-level4.md §1 |
| **4.** Параметризованные запросы / ORM, ограниченный пул, таймауты | раздел «Устойчивость к отказам зависимостей»; тест `ExhaustedConnectionPool_ReturnsBoundedError` | пул 1 соединение, ожидание 1 с → `503` быстрее 6 с | lab2-level4.md §4 |
| **4.** Гонка регистрации и rollback составной операции | `RegisterSameUsernameConcurrently...`, `FailedMessageInsert_RollsBack...`, `FailedChatMemberInsert_RollsBack...` | один `201` и 19 `409`; после внедрённого сбоя версия, время и строки не изменились | lab2-level4.md §4 |
| **4.** Индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на ≥10 000 сообщений; пагинация не сканирует всю историю | `scripts/explain-history.sql`, 75 000 сообщений | страница = ~54 буфера на любой глубине; без индекса 926 буферов и Seq Scan; OFFSET — 30 293 буфера | lab2-level4.md §3 |
| **4.** Автоматические проверки: expiry при коротком TTL, logout, неверный пароль, недоступность Redis/БД | `ShortSessionTtl_ExpiresSessionByItself`, `Logout_*`, `Login_WrongPassword...`, `DatabaseDown_*`, `UnavailableCache_*` | 63 из 63 тестов проходят (в том числе из чистого клона репозитория); проверка тестов мутациями | lab2-level4.md §4 |
| **4.** При потере сервиса — ограниченная ошибка / обход кэша, анонимный не доверенный | остановка `db` и `cache` на стенде | `503` без деталей; без токена `401`; кэш обходится (`bypass`), ответы корректны | lab2-level4.md §2 |
| **5. Трек 2.** ≥100 000 сообщений с неравномерными размерами чатов | `scripts/track2/seed.sql` | 115 000 сообщений в 2 007 чатах: 80 000 / 20 000 / 5×1 000 / 2 000×5 | lab2-track2.md |
| **5. Трек 2.** Сравнение ≥2 индексов/запросов и стоимость записи | `scripts/track2/run.sh indexes` | 4 варианта индекса + keyset против OFFSET; чтение 213 → ~6 200 страниц/с; индекс +47% WAL и +25% времени bulk-вставки; покрывающий индекс отклонён (ломает сообщения >2,7 КБ) | lab2-track2.md |
| **5. Трек 2.** Backup → восстановление в новое хранилище → сверка количества и выбранных сообщений | `scripts/track2/run.sh backup` | `pg_dump` 0,9 с (6,2 МиБ); новое хранилище, `pg_restore` + `ANALYZE` 1,3 с; 12 контрольных проверок совпали, API на копии отдаёт те же страницы побайтно; негативный контроль ловит изменение | lab2-track2.md |
| **5. Трек 2.** Обсуждение времени восстановления и границ потери данных | раздел «Время восстановления и границы потери данных» | RTO 1,3 с измерен только для самого `pg_restore`; RPO = интервал между backup (в опыте потеряно 100 сообщений); PITR не реализован | lab2-track2.md |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Методика, команды и сырые выводы — в [evidence/lab2-level4.md](evidence/lab2-level4.md). Измерения единичные, на одной машине, нагрузочных замеров пока нет (они нужны для трека 1).
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Полный рестарт `api`, `db` и `cache` с сохранением volume | подтверждённые данные и сессия сохраняются | сохранились; прежний токен работает; кэш пуст и наполняется заново | хук ≤ 90 с по условию теста; потери данных нет |
| Остановка Valkey | сервис работает без кэша | smoke `PASS`, `X-Cache: bypass`, чтение и запись корректны | обход мгновенный; кэш возвращается после старта Valkey (miss → hit) |
| Остановка PostgreSQL | `503` без деталей, анонимные не доверенные | `me=503` за 0,03 с; вход `503`; без токена `401`; `ready=503`, `live=200` | после старта БД тот же токен работает через 0,6 с, API не перезапускался; данные не потеряны |
| Потеря основного хранилища (трек 2: восстановление из `pg_dump` в новый контейнер и том) | данные до момента backup восстановлены полностью | 12 проверок совпали; записанные после backup 100 сообщений потеряны | `pg_restore` + `ANALYZE` 1,3 с (без развёртывания и переключения) |
| Сбой внутри транзакции (триггер БД) | полный откат | версия чата, `last_message_at`, чат и участники не изменились; ответ `500 internal_error` без деталей | — |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Трек 1 (согласованность кэша) не выбран; кэш с версией в ключе реализован и протестирован как часть уровня 4, но защита от stampede и сравнение с «наивным» кэшем не делались.
- Трек 2: backup логический (`pg_dump`), без архивации WAL и PITR; восстановление измерено только как `pg_restore` + `ANALYZE` на 6,2 МиБ; backup хранится на том же хосте и не шифруется; восстановление старого backup «воскрешает» сессии, отозванные позже, поэтому после него нужно отозвать все сессии. Нагрузочные измерения короткие (3 повтора по 10 с, 4 клиента), на одном хосте, на прогретых данных.
- Кэш не уменьшает число запросов к БД до нуля: на каждое чтение остаются запрос сессии и запрос версии/доступа (на попадании — 2 запроса вместо 3).
- Просроченные и отозванные сессии не удаляются из `sessions` (индекс `ix_sessions_expires_at` для очистки есть).
- Замер времени ответа для неизвестного пользователя против неверного пароля не проводился.
- EXPLAIN выполнен на синтетических данных в памяти; влияние на запись и поведение на диске не измерялись.
- HTTP без TLS допустим только для локального изолированного стенда с синтетическими данными (условие контракта для lab2).
- На Windows `tests/resilience.py` не запускает `.sh` напрямую; проверка выполнена через обёртку `.cmd`. На Linux/macOS команда из раздела запуска работает как есть (нужен executable bit: `chmod +x scripts/restart.sh`).
+84
View File
@@ -0,0 +1,84 @@
# Имя проекта задаёт префикс томов и сетей (messenger-lab2_pgdata): не пересекается с ручными контейнерами.
# Lab 2: API + PostgreSQL. Запуск: scripts/init-secrets.sh && cp .env.example .env && docker compose --env-file .env up -d --build --wait
name: messenger-lab2
services:
db:
# PostgreSQL 17.11; тег закреплён digest'ом, сборка воспроизводима.
image: postgres:17@sha256:b8faeff7712663c2773a190181e1246e37e364b887611c04658c28b44e2408fe
restart: unless-stopped
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/db_password
secrets:
- db_password
volumes:
# Именованный volume: переживает restart/down; удаляется только явным `docker compose down -v`.
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 20
start_period: 10s
networks: [backend]
cache:
# Valkey 8.1: кэш страниц истории сообщений. Источник истины — PostgreSQL, потеря содержимого кэша ничего не ломает,
# поэтому persistence выключена (--save "" --appendonly no). Память ограничена, вытеснение LRU.
image: valkey/valkey:8.1@sha256:640c5e62cea04b6d6f2084232651d0cc70362d31f4f805e7be94dbed6855e8f2
restart: unless-stopped
command:
- sh
- -c
- exec valkey-server --requirepass "$$(cat /run/secrets/cache_password)" --save "" --appendonly no --maxmemory 64mb --maxmemory-policy allkeys-lru
secrets:
- cache_password
healthcheck:
test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/cache_password)\" valkey-cli ping | grep -q PONG"]
interval: 5s
timeout: 3s
retries: 10
networks: [backend]
api:
build:
context: .
dockerfile: Dockerfile
image: messenger-api:lab2
restart: unless-stopped
# Кэш не входит в depends_on: API обязан стартовать и работать без него (чтение идёт напрямую из PostgreSQL).
depends_on:
db:
condition: service_healthy
environment:
ASPNETCORE_URLS: http://0.0.0.0:8080
APP_PORT: "8080"
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
CACHE_TTL_SECONDS: ${CACHE_TTL_SECONDS:-300}
DIAGNOSTIC_HEADERS: ${DIAGNOSTIC_HEADERS:-false}
secrets:
- database_url
- cache_url
ports:
- "${API_PUBLISHED_PORT:-8080}:8080"
networks: [backend]
volumes:
pgdata:
networks:
backend:
secrets:
db_password:
file: ./secrets/db_password
database_url:
file: ./secrets/database_url.compose
cache_password:
file: ./secrets/cache_password
cache_url:
file: ./secrets/cache_url
+13
View File
@@ -0,0 +1,13 @@
{
"version": 1,
"isRoot": true,
"tools": {
"dotnet-ef": {
"version": "10.0.13",
"commands": [
"dotnet-ef"
],
"rollForward": false
}
}
}
+52
View File
@@ -0,0 +1,52 @@
# Лабораторная 2: проверки уровня 3
Дата: 2026-10-23. Стенд: Docker Desktop (Windows 11), `docker compose` v5.1.3. Commit: рабочая копия до коммита.
Образы: `postgres:17` (сервер 17.11, закреплён digest в `compose.yaml`), `mcr.microsoft.com/dotnet/aspnet:10.0.12` (digest в `Dockerfile`).
Токены и пароли в этом файле не приводятся.
## Публичный smoke
```
$ python tests/smoke.py --base-url http://localhost:8080
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
```
## Проверка сохранности (restart + прежний токен)
Хук `scripts/restart.sh` на момент этого прогона: `docker compose stop api` → `restart db` → `up -d --wait db` → `up -d --wait api` (позже добавлен перезапуск `cache`, см. lab2-level4.md). Volume `messenger-lab2_pgdata` сохраняется.
На Windows тест запускался через обёртку `.cmd`, вызывающую `bash scripts/restart.sh` (Python на Windows не запускает `.sh` напрямую).
Время старта контейнеров (`docker inspect --format '{{.State.StartedAt}}'`):
| Контейнер | До хука | После хука |
| --- | --- | --- |
| db | 2026-10-23T17:11:14Z | 2026-10-23T17:11:49Z |
| api | 2026-10-23T17:11:19Z | 2026-10-23T17:11:55Z |
```
$ python tests/resilience.py --mode persistence --action-script <wrapper> --base-url http://localhost:8080
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
```
## Миграции повторно применяются без дублей
API при каждом старте вызывает `Database.Migrate()`. После полного рестарта стенда:
| | До | После |
| --- | --- | --- |
| строк в `__EFMigrationsHistory` | 2 | 2 |
| users / sessions / messages | 6 / 6 / 3 | 6 / 6 / 3 |
Миграции с нуля: на пустом контейнере PostgreSQL 17 применены `InitialSchema` и `AddChatLastMessageAt` (так стартует каждый прогон xunit-тестов, см. ниже).
## Собственные тесты
```
$ dotnet test scr/Messenger.Api.Tests
Пройден! не пройдено 0, пройдено 49, пропущено 0, всего 49
```
Тесты поднимают одноразовый контейнер PostgreSQL (Testcontainers) и приложение в процессе. Покрыто: регистрация и дубликат, 20 параллельных регистраций одного username (ровно один `201`),
Argon2id в `users.password_hash`, вход (Basic, двоеточие в пароле, одинаковый `401` для неверного пароля/неизвестного пользователя/битого заголовка),
`Authorization: Bearer` на всех защищённых endpoint, игнорирование `X-User-Id`, `401` до `400` для битого тела без токена, logout и повторный logout,
истёкшая сессия, в `sessions` лежит SHA-256 токена, доступ к чужому чату (`404`), keyset-пагинация, cursor другого чата (`400`), порядок истории при 300 параллельных отправках.
+82
View File
@@ -0,0 +1,82 @@
# Лабораторная 2: проверки уровня 4
Дата: 2026-10-23. Стенд: Docker Desktop (Windows 11), `docker compose` v5.1.3, PostgreSQL 17.11, Valkey 8.1.10, .NET 10.
Commit: рабочая копия до коммита. Токены и пароли в файле не приводятся. Уровень 3: [lab2-level3.md](lab2-level3.md).
## 1. Роль Valkey: кэш страниц истории
Источник истины — PostgreSQL. Ключ страницы: `hist:{chat_id}:v{history_version}:l{limit}:{cursor}`, значение — готовый JSON ответа, TTL 300 с, `maxmemory 64mb`, вытеснение `allkeys-lru`, persistence выключена (`--save "" --appendonly no`).
Версия `chats.history_version` читается из PostgreSQL при каждом чтении (тем же запросом, что проверяет доступ) и увеличивается в транзакции записи, поэтому после подтверждённой записи ключ меняется и устаревшая страница недостижима.
Сценарий на живом стенде (`DIAGNOSTIC_HEADERS=true`, заголовки `X-Cache`, `X-Db-Queries`):
| Шаг | X-Cache | SQL-запросов | Сообщений в ответе |
| --- | --- | --- | --- |
| 1. первое чтение | miss | 3 (сессия, версия+доступ, страница) | 3 |
| 2. повторное чтение | hit | 2 | 3 |
| 3. POST сообщения (201) и сразу чтение | miss (новая версия) | 3 | 4 |
| 4. повторное чтение | hit | 2 | 4 |
| 5. Valkey остановлен, чтение | bypass | 3 | 4 |
| 5б. запись при остановленном Valkey, чтение | bypass | 3 | 5 |
| 6. Valkey запущен снова | miss, затем hit | 3, затем 2 | 5 |
## 2. Эксперименты отказов
| Воздействие | Что ожидаем | Что наблюдали |
| --- | --- | --- |
| `docker compose stop cache` во время публичного smoke | smoke проходит, ответы корректны | `PASS` |
| `docker compose stop db` | запрос с токеном → `503 unavailable` без деталей; без токена → `401`; вход → `503`; `/health/ready` → `503`, `/health/live` → `200` | `me=503` за 0,03 с, тело `{"error":{"code":"unavailable","message":"Сервис временно недоступен",...}}`; `chats` без токена `401`; `login=503`; `ready=503`, `live=200` |
| `docker compose start db` | тот же токен снова работает без перезапуска API | `200` через 0,6 с после старта; затем smoke `PASS` |
| `scripts/restart.sh` (теперь перезапускает `db`, `cache`, `api`) + `tests/resilience.py --mode persistence` | данные и прежний токен сохранены | `PASS`; время старта: db 17:14:59→17:35:58, cache 17:30:29→17:35:57, api 17:35:47→17:36:04 (UTC) |
## 3. План запроса истории: EXPLAIN (ANALYZE, BUFFERS)
Скрипт: [scripts/explain-history.sql](../scripts/explain-history.sql). Данные: 75 000 сообщений в 2 002 чатах (1 чат — 60 000, 1 — 5 000, 2 000 по 5), порядок вставки перемешан. Запускалось в отдельной БД `explain_lab` внутри контейнера `db` (удалена после замера); `ANALYZE` выполнен; таблица 7,4 МБ, индекс `ix_messages_chat_history` 5,5 МБ. Все чтения из shared buffers (набор данных помещается в память), поэтому абсолютное время мало, а сравнивать надо буферы и число строк.
Запрос — тот, который генерирует EF (подзапрос + `ORDER BY created_at, id LIMIT 51`), параметры подставлены.
| Вариант | План | Прочитано строк | Buffers (shared hit) | Время выполнения |
| --- | --- | --- | --- | --- |
| A. первая страница большого чата, индекс есть | Index Scan `ix_messages_chat_history` | 51 | 53 | 0,050 мс |
| B. страница из середины (30 000 до курсора), keyset, индекс есть | Index Scan, `Index Cond: (chat_id = …) AND (ROW(created_at, id) > ROW(…))` | 51 | 54 | 0,087 мс |
| C. последняя страница, keyset, индекс есть | Index Scan | 50 | 54 | 0,116 мс |
| D. маленький чат (5), индекс есть | Index Scan | 5 | 8 | 0,034 мс |
| E. то же, что B, но OFFSET 30000 | Index Only Scan + 30 051 Heap Fetches | 30 051 | 30 293 | 13,1 мс |
| F. то же, что B, **без индекса** | Seq Scan по всей таблице + top-N heapsort | 75 000 (29 999 прошли фильтр) | 926 | 11,4 мс |
| G. маленький чат, без индекса | Index Scan по `ix_messages_chat_id_sender_id` + Sort | 5 | 7 | 0,031 мс |
Выводы:
- Условие курсора `(created_at, id) > (…)` целиком попадает в `Index Cond`: страница стоит ~54 буфера независимо от глубины (A, B, C), то есть история не сканируется целиком на каждую страницу.
- Без индекса (F) тот же запрос читает всю таблицу: в 17 раз больше буферов и в ~130 раз медленнее; с ростом таблицы разрыв растёт линейно. OFFSET-пагинация (E) хоть и использует индекс, читает все пропускаемые строки: 30 293 буфера против 54.
- Для маленьких чатов (G) индекс истории почти не нужен: помогает FK-индекс `(chat_id, sender_id)`. Индекс `(chat_id, created_at, id)` оправдан именно большими чатами.
- Ограничения: данные синтетические и прогреты в памяти; диск, конкуренция и стоимость записи индекса не измерялись (это тема трека 2).
## 4. Автоматические проверки (`dotnet test scr/Messenger.Api.Tests`)
```
Пройден! не пройдено 0, пройдено 63, пропущено 0, всего 63
```
Соответствие требованиям уровня 4:
| Требование | Тест |
| --- | --- |
| Истечение сессии при коротком `SESSION_TTL_SECONDS` | `AuthTests.ShortSessionTtl_ExpiresSessionByItself` (отдельный экземпляр приложения с TTL=2 с, без правок БД) |
| Logout | `AuthTests.Logout_RevokesTokenAndSecondLogoutIsUnauthorized`, `LogoutOfOneSession_DoesNotAffectAnotherSessionOfSameUser` |
| Неверный пароль | `AuthTests.Login_WrongPasswordAndUnknownUser_GiveIdenticalUnauthorized` |
| Недоступность БД | `DependencyFailureTests.DatabaseDown_Returns503_NeverTrustsAnonymous_AndRecovers` |
| Недоступность кэша | `CacheTests.UnavailableCache_IsBypassed_AndRequestsStillSucceed`, `UnavailableCache_DoesNotTrustAnonymousRequests` |
| Ограниченный пул и таймауты | `DependencyFailureTests.ExhaustedConnectionPool_ReturnsBoundedError` (пул из 1 соединения, ожидание 1 с → `503` быстрее 6 с) |
| Гонка регистрации одного username | `ConcurencyTests.RegisterSameUsernameConcurrently_ExactlyOneSucceeds_NoServerErrors` (20 параллельных → один `201`, 19 `409`) |
| Rollback составной операции | `DependencyFailureTests.FailedMessageInsert_RollsBackVersionAndTimestamp`, `FailedChatMemberInsert_RollsBackWholeChat` (сбой внедряется триггером БД; после сбоя версия, `last_message_at`, строки чата и участников не изменились) |
| Кэш не отдаёт устаревшее | `CacheTests.ReadAfterWrite_NeverReturnsStaleCachedPage`, `FlushedCache_DoesNotChangeResults`, `CachedPage_IsNotVisibleToNonMember` |
Проверка самих тестов (мутации, затем возврат кода):
- функция, превращающая отказ БД в `503`, заменена на `false` → `DatabaseDown...` и `ExhaustedConnectionPool...` упали (`Expected: ServiceUnavailable, Actual: InternalServerError`);
- версия убрана из ключа кэша → `CacheTests` упали (`Assert.Contains() Failure: Item not found in collection`).
## 5. Проверка из чистого клона (2026-10-30)
Репозиторий клонирован в пустой каталог (`git clone`, commit `ab8c5e8`), стенд поднят под другим именем проекта и портом (`COMPOSE_PROJECT_NAME=verify-clean`, `API_PUBLISHED_PORT=18080`), чтобы не затрагивать рабочий. Шаги: `scripts/init-secrets.sh`, `cp .env.example .env`, `docker compose up -d --build --wait`.
- `scripts/check_contract.py` — PASS; `tests/smoke.py` — PASS (до и после рестарта); `tests/resilience.py --mode persistence` с `scripts/restart.sh` — PASS (время старта `db`, `cache`, `api` изменилось).
- `scripts/track2/run.sh up` и `backup` — работают из клона: сидирование 115 000 сообщений, `pg_dump`, восстановление в новое хранилище, все контрольные суммы совпали, API на копии отдаёт те же страницы (8 из 8). Время `pg_dump` 2,4 с, `pg_restore` + `ANALYZE` 3,4 с (в прошлом прогоне 0,9 с и 1,3 с на той же машине): время восстановления заметно колеблется между запусками.
- `dotnet test`: в первом клоне 60 из 61, упал `RegisterSameUsernameConcurrently...` (20 параллельных регистраций одного username). Причина: один хеш Argon2 в Debug-сборке занимает ~0,3 с, ограничитель пропускает 4 хеша и ждёт слот 2 с, поэтому часть запросов получала `503` вместо `409`. Тест проверял скорость машины, а не гарантию уникального индекса. Исправление: параметры ограничителя стали настраиваемыми (`PASSWORD_HASH_CONCURRENCY`, `PASSWORD_HASH_QUEUE_TIMEOUT_SECONDS`), тест гонки выполняется с длинной очередью, добавлены тесты поведения при перегрузке (`Hash_WhenAllSlotsAreBusy_FailsWithBusyException`, `RegistrationBurstBeyondHashingCapacity_GetsBoundedUnavailable_NotServerError`). После исправления в чистом клоне два полных прогона подряд: 63 из 63.
+81
View File
@@ -0,0 +1,81 @@
# Лабораторная 2, трек 2: план запроса и восстановление
Дата: 2026-10-23. Стенд: Docker Desktop (Windows 11, 16 CPU, 8 ГБ памяти у Docker), PostgreSQL 17.11 в одноразовом контейнере `track2-src` (параметры по умолчанию: `shared_buffers` 128 МБ, `fsync` включён). Commit: рабочая копия до коммита.
Воспроизведение: `sh scripts/track2/run.sh up && sh scripts/track2/run.sh indexes && sh scripts/track2/run.sh backup && sh scripts/track2/run.sh down`.
Сырые результаты — в [evidence/track2/](track2/). Данные синтетические; токены и пароли не приводятся.
## Гипотеза
1. Индекс `(chat_id, created_at, id)` делает стоимость страницы истории независимой от глубины и размера чата (читаются ~50 буферов вместо сканирования таблицы). Варианты: без индекса, `(chat_id, created_at)` (уже и дешевле при записи, но без `id`), покрывающий `(chat_id, created_at, id) INCLUDE (sender_id, text)` (быстрее чтение за счёт Index Only Scan, но шире).
2. Дополнительный индекс удорожает запись: больше WAL и времени на вставку, больше места.
3. Логический backup (`pg_dump -Fc`) восстанавливается в чистое хранилище без потерь данных до момента backup, а всё записанное после него теряется (граница потери — интервал между backup).
## Данные
115 000 сообщений в 2 007 чатах, неравномерно: 1 чат — 80 000, 1 — 20 000, 5 — по 1 000, 2 000 — по 5 сообщений. Порядок вставки перемешан, `ANALYZE` выполнен. Скрипт: [scripts/track2/seed.sql](../scripts/track2/seed.sql).
## Методика
- Запрос — тот, что генерирует приложение (подзапрос с `ORDER BY created_at, id LIMIT 51`, keyset-условие `(created_at, id) > (…)`). Планы — `EXPLAIN (ANALYZE, BUFFERS)` на **втором (прогретом) запуске**; для каждого варианта таблица пересобирается `VACUUM FULL`, строки прошлых прогонов записи удаляются.
- Чтение: `pgbench -c 4 -j 2 -T 10`, страница большого чата с курсором случайной глубины ([read.pgbench](../scripts/track2/read.pgbench)); 3 повтора, приведена медиана и разброс.
- Запись: `pgbench -c 4 -j 2 -T 10`, 80% вставок в большой чат, 20% в средний, одна вставка = одна транзакция ([write.pgbench](../scripts/track2/write.pgbench)); 3 повтора.
- Стоимость индекса: bulk-вставка 100 000 строк в большой чат одним оператором (`EXPLAIN (ANALYZE, WAL)`, затем `ROLLBACK`): здесь нет fsync на каждую строку, видна чистая стоимость поддержки индекса.
## Результаты: планы (прогретые буферы, shared hit)
| Запрос | Без индекса | `(chat_id, created_at, id)` | `(chat_id, created_at)` | покрывающий `INCLUDE (sender_id, text)` |
| --- | --- | --- | --- | --- |
| Q1 первая страница большого чата | Gather Merge + Parallel Seq Scan, 1 930 буферов, 14,6 мс | Index Scan, 54 буфера, 0,30 мс | Incremental Sort + Index Scan, 64, 0,30 мс | Index Only Scan, 55, 0,23 мс |
| Q2 страница из середины (keyset) | Parallel Seq Scan, 1 901, 12,1 мс | Index Scan, 54, 0,21 мс | Incremental Sort, 56, 0,28 мс | Index Only Scan, 55, 0,23 мс |
| Q3 последняя страница (keyset) | Seq Scan, 1 886, 10,5 мс | Index Scan, 35, 0,13 мс | Incremental Sort, 36, 0,19 мс | Index Only Scan, 35, 0,12 мс |
| Q4 маленький чат (5 сообщений) | Index Scan по FK-индексу `(chat_id, sender_id)` + Sort, 7, 0,04 мс | Index Scan, 8, 0,05 мс | FK-индекс + Sort, 7, 0,06 мс | Index Only Scan, 8, 0,05 мс |
| Q5 то же, что Q2, но `OFFSET 40000` | Seq Scan + внешняя сортировка на диске (temp), 1 886, 50,7 мс | Index Scan, 40 322, 20,4 мс | 40 235, 24,6 мс | Index Only Scan, 40 672, 19,2 мс |
## Результаты: нагрузка (pgbench, 4 клиента)
| Вариант | Чтение, страниц/с (медиана; мин–макс) | Задержка чтения | Запись, вставок/с (медиана; мин–макс) |
| --- | --- | --- | --- |
| без индекса | 213 (211–218) | ~18,8 мс | 1 677 (1 645–1 692) |
| `(chat_id, created_at, id)` | 6 219 (6 149–6 352) | ~0,64 мс | 1 694 (1 665–1 696) |
| `(chat_id, created_at)` | 5 994 (5 697–6 041) | ~0,67 мс | 1 624 (1 605–1 679) |
| покрывающий | 6 216 (5 882–6 794) | ~0,64 мс | 1 685 (1 656–1 694) |
## Результаты: стоимость индекса
| Вариант | Размер индекса до записи | после ~50 тыс. вставок | WAL при bulk-вставке 100 000 строк | Время bulk-вставки | Вставка сообщения 4 000 символов |
| --- | --- | --- | --- | --- | --- |
| без индекса | — | — | 31,1 МБ (базовая линия) | 1 351 мс | ок |
| `(chat_id, created_at, id)` | 6,5 МБ | 11 МБ | 45,8 МБ (+14,7 МБ, +47%) | 1 695 мс (+25%) | ок |
| `(chat_id, created_at)` | 4,5 МБ | 7,6 МБ | 42,4 МБ (+11,3 МБ, +36%) | 1 588 мс (+18%) | ок |
| покрывающий | 14 МБ | 22 МБ | 52,5 МБ (+21,4 МБ, +69%) | 1 760 мс (+30%) | **ошибка:** `index row size 4072 exceeds btree version 4 maximum 2704` |
## Выводы по индексам
- Индекс для истории обязателен: без него страница стоит ~1 900 буферов (вся таблица) и ~10–15 мс уже на 115 000 строк, пропускная способность чтения ниже в ~29 раз (213 против 6 219 страниц/с); стоимость растёт линейно с таблицей. С индексом страница стоит ~35–64 буфера на любой глубине.
- Выбор: **оставить `(chat_id, created_at, id)`**. Его порядок совпадает с `ORDER BY` и keyset-условием, сортировка не нужна, задержка предсказуема.
- `(chat_id, created_at)` на 31% меньше и на 23% дешевле по WAL, но требует Incremental Sort и читает чуть больше буферов; чтение в пределах разброса. Это допустимая альтернатива, если важнее место и запись, но выигрыш невелик.
- Покрывающий индекс отклонён: чтение в пределах разброса измерений (Index Only Scan экономит обращения к куче, но на прогретых данных разница меньше шума), индекс вдвое больше, WAL +69%, а главное — он **ломает запись длинных сообщений**: контракт разрешает 4 000 символов, а строка B-дерева ограничена ~2,7 КБ.
- Запись: на уровне транзакций (один COMMIT на вставку) различия между вариантами (±3–4%) меньше разброса между повторами: время определяется fsync журнала. Стоимость индекса видна в WAL и времени bulk-вставки (+18…30%) и в размере. Число байт WAL на одну вставку при pgbench колебалось между прогонами (472–858) из-за полностраничных записей после контрольных точек и как показатель не используется.
- OFFSET-пагинация (Q5) даже с индексом читает все пропущенные строки (~40 000 буферов против 54), а без индекса ещё и сбрасывает сортировку на диск: keyset-курсор принципиально лучше.
## Backup и восстановление
Источник: БД `track2-src` (115 000 сообщений, 1 активная сессия, схема приложения и `__EFMigrationsHistory`). Схема `bench` с вспомогательными таблицами эксперимента в backup не входит (`pg_dump -N bench`).
| Шаг | Команда / действие | Результат |
| --- | --- | --- |
| 1. Контрольные суммы источника | [verify.sql](../scripts/track2/verify.sql): числа строк и md5 от полного содержимого | 12 проверок: users, chats, chat_members, messages (вся таблица), sessions, миграции, сообщений по чатам, первые и последние 100 сообщений большого чата, выборка ~1/115 (1 021 сообщение), индексы (14), ограничения (17) |
| 2. Backup | `pg_dump -Fc -N bench` | 0,9 с; 6 487 754 байт (6,2 МиБ) |
| 3. Запись после backup | +100 сообщений в источник | в источнике 115 100 |
| 4. Восстановление в новое хранилище | новый контейнер `track2-restore`, новый том `track2_restore`, `createdb`, `pg_restore --exit-on-error --jobs 4`, затем `ANALYZE` | 0,8 с + 0,5 с = 1,3 с |
| 5. Сверка | те же контрольные суммы на копии, `diff` с источником «до backup» | **совпали полностью** (все 12 проверок); сообщений в копии 115 000, в источнике 115 100: **потеряно 100 (записано после backup)** |
| 6. Приложение поверх копии | второй экземпляр API на копии, тот же Bearer-токен, что был выдан до backup | `GET /users/me` → 200 (сессия восстановлена); 8 страниц истории большого чата по `limit=100` через API на источнике и на копии совпали побайтно; миграции повторно не применялись |
Проверка самой сверки (негативный контроль, [verify-negative-control.txt](track2/verify-negative-control.txt)): после дописывания одного символа в одно сообщение копии не совпал хеш **всей таблицы** `messages`, а выборочные хеши (первые/последние 100, ~1/115) остались прежними, так как изменённая строка в них не попала. Значит, достоверность дают хеши полного содержимого таблиц; выборки лишь дополнительно показывают конкретные сообщения.
## Время восстановления и границы потери данных
- **Измеренное время восстановления (RTO)** для этого набора: 1,3 с на `pg_restore` + `ANALYZE` (6,2 МиБ дампа, 115 000 сообщений). Сюда **не входят** создание хранилища и контейнера, передача дампа, переключение приложения и обнаружение сбоя. Для больших объёмов время будет расти (минимум линейно из-за построения индексов и I/O); экстраполяция по одному измерению на малых данных — гипотеза, а не результат.
- **Граница потери данных (RPO)** при логическом backup равна интервалу между backup: в эксперименте потеряны ровно 100 сообщений, записанных после дампа. `pg_dump` читает согласованный снимок на момент начала, но восстановить состояние «за минуту до сбоя» (PITR) нельзя. Для этого нужны непрерывная архивация WAL (`archive_command` / `pg_basebackup`) и отдельное хранилище архива; в работе они **не реализованы**.
- **Что дополнительно важно.** (1) Восстановление старого backup «воскрешает» сессии, отозванные после него (`revoked_at` восстанавливается из дампа): после восстановления из backup нужно отозвать все сессии. (2) Дамп содержит хеши паролей и хеши токенов сессий: хранить его нужно как секрет. (3) Backup лежит на том же хосте, что и источник, и не шифруется: от потери хоста он не защищает.
- Ограничения измерений: один хост и один прогон backup, синтетические данные, холодных чтений с диска нет (набор помещается в память), `fsync` Docker Desktop может отличаться от реального диска.
+7
View File
@@ -0,0 +1,7 @@
pg_dump: 0.9 с, размер дампа: 6487754 байт
в источнике теперь 115100 сообщений
pg_restore (--jobs 4): 0.8 с; ANALYZE: 0.5 с; итого до готовности к работе: 1.3 с
СОВПАДАЕТ: все контрольные суммы и числа строк идентичны
сообщений в копии: 115000; в источнике: 115100; потеряно (записано после backup): 100
сессия, созданная до backup, действует на копии: GET /users/me -> 200
страницы истории большого чата через API (источник и копия) совпадают побайтно: 8 из 8
+8
View File
@@ -0,0 +1,8 @@
read:
number of transactions actually processed: 62138 latency average = 0.643 ms tps = 6216.254799 (without initial connection time)
number of transactions actually processed: 58790 latency average = 0.680 ms tps = 5881.725592 (without initial connection time)
number of transactions actually processed: 67909 latency average = 0.589 ms tps = 6794.075551 (without initial connection time)
write:
number of transactions actually processed: 16847 latency average = 2.374 ms tps = 1685.193930 (without initial connection time)
number of transactions actually processed: 16939 latency average = 2.361 ms tps = 1694.410526 (without initial connection time)
number of transactions actually processed: 16557 latency average = 2.416 ms tps = 1655.868733 (without initial connection time)
+8
View File
@@ -0,0 +1,8 @@
read:
number of transactions actually processed: 62256 latency average = 0.643 ms tps = 6218.755638 (without initial connection time)
number of transactions actually processed: 63493 latency average = 0.630 ms tps = 6352.291929 (without initial connection time)
number of transactions actually processed: 61567 latency average = 0.650 ms tps = 6149.124893 (without initial connection time)
write:
number of transactions actually processed: 16946 latency average = 2.362 ms tps = 1693.745167 (without initial connection time)
number of transactions actually processed: 16641 latency average = 2.403 ms tps = 1664.848849 (without initial connection time)
number of transactions actually processed: 16963 latency average = 2.358 ms tps = 1696.038471 (without initial connection time)
+8
View File
@@ -0,0 +1,8 @@
read:
number of transactions actually processed: 2127 latency average = 18.819 ms tps = 212.554761 (without initial connection time)
number of transactions actually processed: 2108 latency average = 18.988 ms tps = 210.654143 (without initial connection time)
number of transactions actually processed: 2183 latency average = 18.340 ms tps = 218.100983 (without initial connection time)
write:
number of transactions actually processed: 16448 latency average = 2.432 ms tps = 1644.662835 (without initial connection time)
number of transactions actually processed: 16916 latency average = 2.364 ms tps = 1691.860716 (without initial connection time)
number of transactions actually processed: 16770 latency average = 2.386 ms tps = 1676.663158 (without initial connection time)
+8
View File
@@ -0,0 +1,8 @@
read:
number of transactions actually processed: 59903 latency average = 0.667 ms tps = 5994.227418 (without initial connection time)
number of transactions actually processed: 60383 latency average = 0.662 ms tps = 6041.275328 (without initial connection time)
number of transactions actually processed: 56943 latency average = 0.702 ms tps = 5697.289368 (without initial connection time)
write:
number of transactions actually processed: 16061 latency average = 2.493 ms tps = 1604.783436 (without initial connection time)
number of transactions actually processed: 16784 latency average = 2.382 ms tps = 1679.071629 (without initial connection time)
number of transactions actually processed: 16241 latency average = 2.463 ms tps = 1623.989731 (without initial connection time)
+67
View File
@@ -0,0 +1,67 @@
--- Q1 первая страница большого чата (80 000), keyset
QUERY PLAN
---------------------------------------------------------------------------------
Limit (actual rows=51 loops=1)
Buffers: shared hit=55
-> Index Only Scan using ix_t2_covering on messages (actual rows=51 loops=1)
Index Cond: (chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid)
Heap Fetches: 51
Buffers: shared hit=55
Planning:
Buffers: shared hit=161
Planning Time: 0.806 ms
Execution Time: 0.234 ms
(10 rows)
--- Q2 страница из середины большого чата, keyset
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (actual rows=51 loops=1)
Buffers: shared hit=55
-> Index Only Scan using ix_t2_covering on messages (actual rows=51 loops=1)
Index Cond: ((chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 11:06:24+00'::timestamp with time zone, '3126d0c5-166f-481e-96bf-c950463908dc'::uuid)))
Heap Fetches: 51
Buffers: shared hit=55
Planning Time: 0.073 ms
Execution Time: 0.230 ms
(8 rows)
--- Q3 последняя страница большого чата, keyset
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (actual rows=32 loops=1)
Buffers: shared hit=35
-> Index Only Scan using ix_t2_covering on messages (actual rows=32 loops=1)
Index Cond: ((chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 22:12:48+00'::timestamp with time zone, 'c8a497c3-78fd-44f5-8bc7-3abcc4d06d1d'::uuid)))
Heap Fetches: 32
Buffers: shared hit=35
Planning Time: 0.077 ms
Execution Time: 0.117 ms
(8 rows)
--- Q4 маленький чат (5 сообщений)
QUERY PLAN
--------------------------------------------------------------------------------
Limit (actual rows=5 loops=1)
Buffers: shared hit=8
-> Index Only Scan using ix_t2_covering on messages (actual rows=5 loops=1)
Index Cond: (chat_id = 'a7223743-6f48-4880-9b67-0e0cc8635177'::uuid)
Heap Fetches: 5
Buffers: shared hit=8
Planning Time: 0.067 ms
Execution Time: 0.050 ms
(8 rows)
--- Q5 середина большого чата, OFFSET 40000 (для сравнения с keyset)
QUERY PLAN
--------------------------------------------------------------------------------------
Limit (actual rows=51 loops=1)
Buffers: shared hit=40672
-> Index Only Scan using ix_t2_covering on messages m (actual rows=40051 loops=1)
Index Cond: (chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid)
Heap Fetches: 40051
Buffers: shared hit=40672
Planning Time: 0.056 ms
Execution Time: 19.230 ms
(8 rows)
+62
View File
@@ -0,0 +1,62 @@
--- Q1 первая страница большого чата (80 000), keyset
QUERY PLAN
------------------------------------------------------------------------------
Limit (actual rows=51 loops=1)
Buffers: shared hit=54
-> Index Scan using ix_t2_hist on messages (actual rows=51 loops=1)
Index Cond: (chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid)
Buffers: shared hit=54
Planning:
Buffers: shared hit=155
Planning Time: 0.530 ms
Execution Time: 0.300 ms
(9 rows)
--- Q2 страница из середины большого чата, keyset
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (actual rows=51 loops=1)
Buffers: shared hit=54
-> Index Scan using ix_t2_hist on messages (actual rows=51 loops=1)
Index Cond: ((chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 11:06:24+00'::timestamp with time zone, '3126d0c5-166f-481e-96bf-c950463908dc'::uuid)))
Buffers: shared hit=54
Planning Time: 0.088 ms
Execution Time: 0.209 ms
(7 rows)
--- Q3 последняя страница большого чата, keyset
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (actual rows=32 loops=1)
Buffers: shared hit=35
-> Index Scan using ix_t2_hist on messages (actual rows=32 loops=1)
Index Cond: ((chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 22:12:48+00'::timestamp with time zone, 'c8a497c3-78fd-44f5-8bc7-3abcc4d06d1d'::uuid)))
Buffers: shared hit=35
Planning Time: 0.094 ms
Execution Time: 0.131 ms
(7 rows)
--- Q4 маленький чат (5 сообщений)
QUERY PLAN
------------------------------------------------------------------------------
Limit (actual rows=5 loops=1)
Buffers: shared hit=8
-> Index Scan using ix_t2_hist on messages (actual rows=5 loops=1)
Index Cond: (chat_id = 'a7223743-6f48-4880-9b67-0e0cc8635177'::uuid)
Buffers: shared hit=8
Planning Time: 0.114 ms
Execution Time: 0.051 ms
(7 rows)
--- Q5 середина большого чата, OFFSET 40000 (для сравнения с keyset)
QUERY PLAN
------------------------------------------------------------------------------
Limit (actual rows=51 loops=1)
Buffers: shared hit=40322
-> Index Scan using ix_t2_hist on messages m (actual rows=40051 loops=1)
Index Cond: (chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid)
Buffers: shared hit=40322
Planning Time: 0.082 ms
Execution Time: 20.350 ms
(7 rows)
+96
View File
@@ -0,0 +1,96 @@
--- Q1 первая страница большого чата (80 000), keyset
QUERY PLAN
--------------------------------------------------------------------------------------
Limit (actual rows=51 loops=1)
Buffers: shared hit=1930
-> Gather Merge (actual rows=51 loops=1)
Workers Planned: 1
Workers Launched: 1
Buffers: shared hit=1930
-> Sort (actual rows=40 loops=2)
Sort Key: messages.created_at, messages.id
Sort Method: top-N heapsort Memory: 36kB
Buffers: shared hit=1930
Worker 0: Sort Method: top-N heapsort Memory: 36kB
-> Parallel Seq Scan on messages (actual rows=40000 loops=2)
Filter: (chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid)
Rows Removed by Filter: 17500
Buffers: shared hit=1886
Planning:
Buffers: shared hit=133
Planning Time: 0.474 ms
Execution Time: 14.564 ms
(19 rows)
--- Q2 страница из середины большого чата, keyset
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (actual rows=51 loops=1)
Buffers: shared hit=1901
-> Gather Merge (actual rows=51 loops=1)
Workers Planned: 1
Workers Launched: 1
Buffers: shared hit=1901
-> Sort (actual rows=40 loops=2)
Sort Key: messages.created_at, messages.id
Sort Method: top-N heapsort Memory: 35kB
Buffers: shared hit=1901
Worker 0: Sort Method: top-N heapsort Memory: 36kB
-> Parallel Seq Scan on messages (actual rows=20008 loops=2)
Filter: ((chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 11:06:24+00'::timestamp with time zone, '3126d0c5-166f-481e-96bf-c950463908dc'::uuid)))
Rows Removed by Filter: 37492
Buffers: shared hit=1886
Planning Time: 0.081 ms
Execution Time: 12.118 ms
(17 rows)
--- Q3 последняя страница большого чата, keyset
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (actual rows=32 loops=1)
Buffers: shared hit=1886
-> Sort (actual rows=32 loops=1)
Sort Key: messages.created_at, messages.id
Sort Method: quicksort Memory: 29kB
Buffers: shared hit=1886
-> Seq Scan on messages (actual rows=32 loops=1)
Filter: ((chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 22:12:48+00'::timestamp with time zone, 'c8a497c3-78fd-44f5-8bc7-3abcc4d06d1d'::uuid)))
Rows Removed by Filter: 114968
Buffers: shared hit=1886
Planning Time: 0.162 ms
Execution Time: 10.543 ms
(12 rows)
--- Q4 маленький чат (5 сообщений)
QUERY PLAN
------------------------------------------------------------------------------------------------
Limit (actual rows=5 loops=1)
Buffers: shared hit=7
-> Sort (actual rows=5 loops=1)
Sort Key: messages.created_at, messages.id
Sort Method: quicksort Memory: 25kB
Buffers: shared hit=7
-> Index Scan using ix_messages_chat_id_sender_id on messages (actual rows=5 loops=1)
Index Cond: (chat_id = 'a7223743-6f48-4880-9b67-0e0cc8635177'::uuid)
Buffers: shared hit=7
Planning Time: 0.080 ms
Execution Time: 0.036 ms
(11 rows)
--- Q5 середина большого чата, OFFSET 40000 (для сравнения с keyset)
QUERY PLAN
--------------------------------------------------------------------------------
Limit (actual rows=51 loops=1)
Buffers: shared hit=1886, temp read=782 written=1109
-> Sort (actual rows=40051 loops=1)
Sort Key: created_at, id
Sort Method: external merge Disk: 8848kB
Buffers: shared hit=1886, temp read=782 written=1109
-> Seq Scan on messages m (actual rows=80000 loops=1)
Filter: (chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid)
Rows Removed by Filter: 35000
Buffers: shared hit=1886
Planning Time: 0.040 ms
Execution Time: 50.742 ms
(12 rows)
+92
View File
@@ -0,0 +1,92 @@
--- Q1 первая страница большого чата (80 000), keyset
QUERY PLAN
----------------------------------------------------------------------------------------------
Limit (actual rows=51 loops=1)
Buffers: shared hit=64
-> Incremental Sort (actual rows=51 loops=1)
Sort Key: messages.created_at, messages.id
Presorted Key: messages.created_at
Full-sort Groups: 2 Sort Method: quicksort Average Memory: 29kB Peak Memory: 29kB
Buffers: shared hit=64
-> Index Scan using ix_t2_nosort on messages (actual rows=52 loops=1)
Index Cond: (chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid)
Buffers: shared hit=55
Planning:
Buffers: shared hit=152
Planning Time: 0.510 ms
Execution Time: 0.296 ms
(14 rows)
--- Q2 страница из середины большого чата, keyset
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (actual rows=51 loops=1)
Buffers: shared hit=56
-> Incremental Sort (actual rows=51 loops=1)
Sort Key: messages.created_at, messages.id
Presorted Key: messages.created_at
Full-sort Groups: 2 Sort Method: quicksort Average Memory: 29kB Peak Memory: 29kB
Buffers: shared hit=56
-> Index Scan using ix_t2_nosort on messages (actual rows=52 loops=1)
Index Cond: ((chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid) AND (created_at >= '2026-01-01 11:06:24+00'::timestamp with time zone))
Filter: (ROW(created_at, id) > ROW('2026-01-01 11:06:24+00'::timestamp with time zone, '3126d0c5-166f-481e-96bf-c950463908dc'::uuid))
Rows Removed by Filter: 1
Buffers: shared hit=56
Planning:
Buffers: shared hit=9
Planning Time: 0.109 ms
Execution Time: 0.278 ms
(16 rows)
--- Q3 последняя страница большого чата, keyset
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (actual rows=32 loops=1)
Buffers: shared hit=36
-> Incremental Sort (actual rows=32 loops=1)
Sort Key: messages.created_at, messages.id
Presorted Key: messages.created_at
Full-sort Groups: 1 Sort Method: quicksort Average Memory: 29kB Peak Memory: 29kB
Buffers: shared hit=36
-> Index Scan using ix_t2_nosort on messages (actual rows=32 loops=1)
Index Cond: ((chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid) AND (created_at >= '2026-01-01 22:12:48+00'::timestamp with time zone))
Filter: (ROW(created_at, id) > ROW('2026-01-01 22:12:48+00'::timestamp with time zone, 'c8a497c3-78fd-44f5-8bc7-3abcc4d06d1d'::uuid))
Rows Removed by Filter: 1
Buffers: shared hit=36
Planning Time: 0.104 ms
Execution Time: 0.188 ms
(14 rows)
--- Q4 маленький чат (5 сообщений)
QUERY PLAN
------------------------------------------------------------------------------------------------
Limit (actual rows=5 loops=1)
Buffers: shared hit=7
-> Sort (actual rows=5 loops=1)
Sort Key: messages.created_at, messages.id
Sort Method: quicksort Memory: 25kB
Buffers: shared hit=7
-> Index Scan using ix_messages_chat_id_sender_id on messages (actual rows=5 loops=1)
Index Cond: (chat_id = 'a7223743-6f48-4880-9b67-0e0cc8635177'::uuid)
Buffers: shared hit=7
Planning Time: 0.093 ms
Execution Time: 0.061 ms
(11 rows)
--- Q5 середина большого чата, OFFSET 40000 (для сравнения с keyset)
QUERY PLAN
-------------------------------------------------------------------------------------------------
Limit (actual rows=51 loops=1)
Buffers: shared hit=40235
-> Incremental Sort (actual rows=40051 loops=1)
Sort Key: created_at, id
Presorted Key: created_at
Full-sort Groups: 1252 Sort Method: quicksort Average Memory: 29kB Peak Memory: 29kB
Buffers: shared hit=40235
-> Index Scan using ix_t2_nosort on messages m (actual rows=40052 loops=1)
Index Cond: (chat_id = '60e7163e-605c-470b-81c0-820c332cfec7'::uuid)
Buffers: shared hit=40235
Planning Time: 0.070 ms
Execution Time: 24.558 ms
(12 rows)
+5
View File
@@ -0,0 +1,5 @@
messages | chats | biggest_chat
----------+-------+--------------
115000 | 2007 | 80000
(1 row)
+56
View File
@@ -0,0 +1,56 @@
### none
index_size_before_writes: - ; index_size_after_writes: -
insert_4000_chars: INSERT 0 1
wal_bytes_per_inserted_row (pgbench, 1 строка = 1 транзакция): 858
bulk_insert_100000_rows: WAL: records=302444 bytes=31081344 Execution Time: 1350.743 ms
read:
number of transactions actually processed: 2127 latency average = 18.819 ms tps = 212.554761 (without initial connection time)
number of transactions actually processed: 2108 latency average = 18.988 ms tps = 210.654143 (without initial connection time)
number of transactions actually processed: 2183 latency average = 18.340 ms tps = 218.100983 (without initial connection time)
write:
number of transactions actually processed: 16448 latency average = 2.432 ms tps = 1644.662835 (without initial connection time)
number of transactions actually processed: 16916 latency average = 2.364 ms tps = 1691.860716 (without initial connection time)
number of transactions actually processed: 16770 latency average = 2.386 ms tps = 1676.663158 (without initial connection time)
### hist
index_size_before_writes: 6640 kB ; index_size_after_writes: 11 MB
insert_4000_chars: INSERT 0 1
wal_bytes_per_inserted_row (pgbench, 1 строка = 1 транзакция): 616
bulk_insert_100000_rows: WAL: records=403760 bytes=45789852 Execution Time: 1695.049 ms
read:
number of transactions actually processed: 62256 latency average = 0.643 ms tps = 6218.755638 (without initial connection time)
number of transactions actually processed: 63493 latency average = 0.630 ms tps = 6352.291929 (without initial connection time)
number of transactions actually processed: 61567 latency average = 0.650 ms tps = 6149.124893 (without initial connection time)
write:
number of transactions actually processed: 16946 latency average = 2.362 ms tps = 1693.745167 (without initial connection time)
number of transactions actually processed: 16641 latency average = 2.403 ms tps = 1664.848849 (without initial connection time)
number of transactions actually processed: 16963 latency average = 2.358 ms tps = 1696.038471 (without initial connection time)
### nosort
index_size_before_writes: 4584 kB ; index_size_after_writes: 7760 kB
insert_4000_chars: INSERT 0 1
wal_bytes_per_inserted_row (pgbench, 1 строка = 1 транзакция): 583
bulk_insert_100000_rows: WAL: records=403328 bytes=42385380 Execution Time: 1587.981 ms
read:
number of transactions actually processed: 59903 latency average = 0.667 ms tps = 5994.227418 (without initial connection time)
number of transactions actually processed: 60383 latency average = 0.662 ms tps = 6041.275328 (without initial connection time)
number of transactions actually processed: 56943 latency average = 0.702 ms tps = 5697.289368 (without initial connection time)
write:
number of transactions actually processed: 16061 latency average = 2.493 ms tps = 1604.783436 (without initial connection time)
number of transactions actually processed: 16784 latency average = 2.382 ms tps = 1679.071629 (without initial connection time)
number of transactions actually processed: 16241 latency average = 2.463 ms tps = 1623.989731 (without initial connection time)
### covering
index_size_before_writes: 14 MB ; index_size_after_writes: 22 MB
insert_4000_chars: ERROR: index row size 4072 exceeds btree version 4 maximum 2704 for index "ix_t2_covering"
wal_bytes_per_inserted_row (pgbench, 1 строка = 1 транзакция): 666
bulk_insert_100000_rows: WAL: records=404576 bytes=52517584 Execution Time: 1760.480 ms
read:
number of transactions actually processed: 62138 latency average = 0.643 ms tps = 6216.254799 (without initial connection time)
number of transactions actually processed: 58790 latency average = 0.680 ms tps = 5881.725592 (without initial connection time)
number of transactions actually processed: 67909 latency average = 0.589 ms tps = 6794.075551 (without initial connection time)
write:
number of transactions actually processed: 16847 latency average = 2.374 ms tps = 1685.193930 (without initial connection time)
number of transactions actually processed: 16939 latency average = 2.361 ms tps = 1694.410526 (without initial connection time)
number of transactions actually processed: 16557 latency average = 2.416 ms tps = 1655.868733 (without initial connection time)
View File
@@ -0,0 +1,4 @@
4c4
< messages (вся таблица)|115000|e7f19607379781ee110b9200494bbcf3
---
> messages (вся таблица)|115000|b807300ed40a4955402060d63cdc19a5
+12
View File
@@ -0,0 +1,12 @@
users|3|51bcdca8513517684d2dfa6fd4c4aff5
chats|2007|0da84d05ff1ad3e7a62433144c4582ac
chat_members|6021|779ff444836543e364e76f63f6a384bb
messages (вся таблица)|115000|e7f19607379781ee110b9200494bbcf3
sessions|1|c8063ca9281542b6ba8f4484a1a99d16
ef_migrations|2|6f913313d9b9a19dfa647da18c45bb08
сообщений по чатам|2007|c6b7fa4e7d14dd960089a87244b52b86
большой чат: первые 100|100|d55e32e077b1346e0ee2bdc26f8ff82e
большой чат: последние 100|100|bd6aacada35def95a3404cc6e88c4317
выборка ~1/115|1021|347c369111e508ee71004d0388ab7e14
индексы|14|02562701b856f65b731b4567c3499a3a
ограничения|17|6138d2f6f3395e1e26f36c6071a2de0c
+12
View File
@@ -0,0 +1,12 @@
users|3|51bcdca8513517684d2dfa6fd4c4aff5
chats|2007|0da84d05ff1ad3e7a62433144c4582ac
chat_members|6021|779ff444836543e364e76f63f6a384bb
messages (вся таблица)|115000|e7f19607379781ee110b9200494bbcf3
sessions|1|c8063ca9281542b6ba8f4484a1a99d16
ef_migrations|2|6f913313d9b9a19dfa647da18c45bb08
сообщений по чатам|2007|c6b7fa4e7d14dd960089a87244b52b86
большой чат: первые 100|100|d55e32e077b1346e0ee2bdc26f8ff82e
большой чат: последние 100|100|bd6aacada35def95a3404cc6e88c4317
выборка ~1/115|1021|347c369111e508ee71004d0388ab7e14
индексы|14|02562701b856f65b731b4567c3499a3a
ограничения|17|6138d2f6f3395e1e26f36c6071a2de0c
+2
View File
@@ -0,0 +1,2 @@
track2_restore
track2_src
+36
View File
@@ -0,0 +1,36 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.5.2.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "scr", "scr", "{027FA04E-56EC-7B26-372C-A48CC532505F}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Messenger.Api", "scr\Messenger.Api\Messenger.Api.csproj", "{630C0B6F-93DF-AAC7-9A7B-184D4E60B431}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Messenger.Api.Tests", "scr\Messenger.Api.Tests\Messenger.Api.Tests.csproj", "{4F2D7000-2CE0-BBF9-8937-6B7E8F80C7D2}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{630C0B6F-93DF-AAC7-9A7B-184D4E60B431}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{630C0B6F-93DF-AAC7-9A7B-184D4E60B431}.Debug|Any CPU.Build.0 = Debug|Any CPU
{630C0B6F-93DF-AAC7-9A7B-184D4E60B431}.Release|Any CPU.ActiveCfg = Release|Any CPU
{630C0B6F-93DF-AAC7-9A7B-184D4E60B431}.Release|Any CPU.Build.0 = Release|Any CPU
{4F2D7000-2CE0-BBF9-8937-6B7E8F80C7D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{4F2D7000-2CE0-BBF9-8937-6B7E8F80C7D2}.Debug|Any CPU.Build.0 = Debug|Any CPU
{4F2D7000-2CE0-BBF9-8937-6B7E8F80C7D2}.Release|Any CPU.ActiveCfg = Release|Any CPU
{4F2D7000-2CE0-BBF9-8937-6B7E8F80C7D2}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{630C0B6F-93DF-AAC7-9A7B-184D4E60B431} = {027FA04E-56EC-7B26-372C-A48CC532505F}
{4F2D7000-2CE0-BBF9-8937-6B7E8F80C7D2} = {027FA04E-56EC-7B26-372C-A48CC532505F}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {41A93240-9911-4469-8EAB-F192C6DC6640}
EndGlobalSection
EndGlobal
+98
View File
@@ -0,0 +1,98 @@
using DotNet.Testcontainers.Builders;
using DotNet.Testcontainers.Containers;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc.Testing;
using Npgsql;
using StackExchange.Redis;
using Testcontainers.PostgreSql;
namespace Messenger.Api.Tests;
// Один одноразовый контейнер PostgreSQL и один Valkey на весь тестовый прогон. Приложение поднимается в процессе теста
// и применяет миграции к пустой БД, как при настоящем старте. Нужен только запущенный Docker.
// Настройки передаются через UseSetting (а не переменные окружения), поэтому тест может поднять второй экземпляр
// приложения с другими настройками: fixture.WithWebHostBuilder(b => b.UseSetting("SESSION_TTL_SECONDS", "2")).
public sealed class ApiFixture : WebApplicationFactory<Program>, IAsyncLifetime
{
public const string PostgresImage = "postgres:17@sha256:b8faeff7712663c2773a190181e1246e37e364b887611c04658c28b44e2408fe";
private const string ValkeyImage = "valkey/valkey:8.1@sha256:640c5e62cea04b6d6f2084232651d0cc70362d31f4f805e7be94dbed6855e8f2";
private readonly PostgreSqlContainer _db = new PostgreSqlBuilder().WithImage(PostgresImage).Build();
private readonly IContainer _cache = new ContainerBuilder()
.WithImage(ValkeyImage)
.WithPortBinding(6379, true)
.WithWaitStrategy(Wait.ForUnixContainer().UntilMessageIsLogged("Ready to accept connections"))
.Build();
private string _connectionFile = string.Empty;
public string ConnectionString => _db.GetConnectionString();
public string CacheConnection => $"{_cache.Hostname}:{_cache.GetMappedPublicPort(6379)}";
public async Task InitializeAsync()
{
await Task.WhenAll(_db.StartAsync(), _cache.StartAsync());
_connectionFile = WriteConnectionFile(_db.GetConnectionString());
}
async Task IAsyncLifetime.DisposeAsync()
{
await _db.DisposeAsync();
await _cache.DisposeAsync();
File.Delete(_connectionFile);
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.UseSetting("DATABASE_URL_FILE", _connectionFile);
builder.UseSetting("CACHE_CONNECTION", CacheConnection);
builder.UseSetting("DIAGNOSTIC_HEADERS", "true");
}
public static string WriteConnectionFile(string connectionString)
{
var path = Path.Combine(Path.GetTempPath(), $"messenger-test-{Guid.NewGuid():N}.conn");
File.WriteAllText(path, connectionString);
return path;
}
// Прямой доступ к БД для проверок, которые нельзя выразить через API (например, состояние таблицы sessions).
public async Task<NpgsqlConnection> OpenConnectionAsync()
{
var connection = new NpgsqlConnection(ConnectionString);
await connection.OpenAsync();
return connection;
}
public async Task<T?> ScalarAsync<T>(string sql, params (string Name, object Value)[] parameters)
{
await using var db = await OpenConnectionAsync();
await using var command = new NpgsqlCommand(sql, db);
foreach (var (name, value) in parameters)
{
command.Parameters.AddWithValue(name, value);
}
var result = await command.ExecuteScalarAsync();
return result is null or DBNull ? default : (T)result;
}
public async Task ExecuteAsync(string sql)
{
await using var db = await OpenConnectionAsync();
await using var command = new NpgsqlCommand(sql, db);
await command.ExecuteNonQueryAsync();
}
// Полная очистка содержимого кэша (эквивалент FLUSHALL / перезапуска Valkey без persistence).
public async Task FlushCacheAsync()
{
using var connection = await ConnectionMultiplexer.ConnectAsync(
new ConfigurationOptions { EndPoints = { CacheConnection }, AllowAdmin = true });
await connection.GetServer(connection.GetEndPoints()[0]).FlushAllDatabasesAsync();
}
}
[CollectionDefinition("api")]
public sealed class ApiCollection : ICollectionFixture<ApiFixture>;
+101
View File
@@ -0,0 +1,101 @@
using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
namespace Messenger.Api.Tests;
internal sealed record TestUser(Guid Id, string Username, string Password, string Token);
internal static class ApiHelpers
{
public const string DefaultPassword = "correct horse battery staple";
public static StringContent Json(string raw) =>
new(raw, Encoding.UTF8, "application/json");
// user != null — запрос с Bearer-токеном этого пользователя.
public static HttpRequestMessage Request(HttpMethod method, string url, TestUser? user = null, HttpContent? content = null)
{
var request = new HttpRequestMessage(method, url) { Content = content };
if (user is not null)
{
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", user.Token);
}
return request;
}
public static async Task<JsonElement> ReadJsonAsync(HttpResponseMessage response)
{
var body = await response.Content.ReadAsStringAsync();
return JsonDocument.Parse(body).RootElement.Clone();
}
public static async Task<string> ErrorCodeAsync(HttpResponseMessage response)
{
var json = await ReadJsonAsync(response);
return json.GetProperty("error").GetProperty("code").GetString()!;
}
public static string BasicHeader(string username, string password) =>
"Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes($"{username}:{password}"));
public static async Task<HttpResponseMessage> LoginAsync(HttpClient client, string username, string password)
{
using var request = new HttpRequestMessage(HttpMethod.Post, "/api/v1/auth/sessions");
request.Headers.TryAddWithoutValidation("Authorization", BasicHeader(username, password));
return await client.SendAsync(request);
}
// Регистрирует пользователя и входит: возвращает его с рабочим Bearer-токеном.
public static async Task<TestUser> CreateUserAsync(HttpClient client, string? username = null)
{
username ??= "u" + Guid.NewGuid().ToString("N")[..12];
var response = await client.PostAsJsonAsync("/api/v1/users",
new { username, display_name = "Тест", password = DefaultPassword });
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var id = (await ReadJsonAsync(response)).GetProperty("id").GetGuid();
var login = await LoginAsync(client, username, DefaultPassword);
Assert.Equal(HttpStatusCode.Created, login.StatusCode);
var token = (await ReadJsonAsync(login)).GetProperty("token").GetString()!;
return new TestUser(id, username, DefaultPassword, token);
}
public static async Task<Guid> CreateChatAsync(HttpClient client, TestUser owner, params TestUser[] others)
{
var members = others.Append(owner).Select(u => u.Id).ToArray();
using var request = Request(HttpMethod.Post, "/api/v1/chats", owner,
JsonContent.Create(new { title = "Чат", member_ids = members }));
var response = await client.SendAsync(request);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
return (await ReadJsonAsync(response)).GetProperty("id").GetGuid();
}
public static async Task<HttpResponseMessage> SendMessageAsync(HttpClient client, TestUser sender, Guid chatId, string text)
{
using var request = Request(HttpMethod.Post, $"/api/v1/chats/{chatId}/messages", sender,
JsonContent.Create(new { text }));
return await client.SendAsync(request);
}
public static async Task<List<Guid>> ReadAllMessagesAsync(HttpClient client, Guid chatId, TestUser user, int limit)
{
string? cursor = null;
var received = new List<Guid>();
do
{
var url = $"/api/v1/chats/{chatId}/messages?limit={limit}" +
(cursor is null ? "" : "&cursor=" + Uri.EscapeDataString(cursor));
using var request = Request(HttpMethod.Get, url, user);
var page = await ReadJsonAsync(await client.SendAsync(request));
received.AddRange(page.GetProperty("items").EnumerateArray().Select(m => m.GetProperty("id").GetGuid()));
var next = page.GetProperty("next_cursor");
cursor = next.ValueKind == JsonValueKind.Null ? null : next.GetString();
}
while (cursor is not null);
return received;
}
}
+302
View File
@@ -0,0 +1,302 @@
using System.Net;
using System.Text.Json;
using static Messenger.Api.Tests.ApiHelpers;
namespace Messenger.Api.Tests;
[Collection("api")]
public class ApiTests(ApiFixture fixture)
{
private HttpClient NewClient() => fixture.CreateClient();
[Fact]
public async Task CreateUser_WithMalformedJson_ReturnsBadRequest()
{
using var client = NewClient();
var response = await client.PostAsync("/api/v1/users", Json("{bad"));
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
Assert.Equal("invalid_request", await ErrorCodeAsync(response));
Assert.True(response.Headers.Contains("X-Request-Id"));
}
[Fact]
public async Task CreateUser_WithoutBody_ReturnsBadRequest()
{
using var client = NewClient();
var response = await client.PostAsync("/api/v1/users", null);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
Assert.Equal("invalid_request", await ErrorCodeAsync(response));
}
[Fact]
public async Task CreateUser_WithDuplicateUsername_ReturnsConflict()
{
using var client = NewClient();
var user = await CreateUserAsync(client);
var response = await client.PostAsync("/api/v1/users",
Json($$"""{"username":"{{user.Username}}","display_name":"Другой","password":"{{DefaultPassword}}"}"""));
Assert.Equal(HttpStatusCode.Conflict, response.StatusCode);
Assert.Equal("conflict", await ErrorCodeAsync(response));
}
[Theory]
[InlineData("short")]
[InlineData("12345678901")] // 11 символов
public async Task CreateUser_WithShortPassword_ReturnsBadRequest(string password)
{
using var client = NewClient();
var response = await client.PostAsync("/api/v1/users",
Json($$"""{"username":"short_pw_probe","display_name":"A","password":"{{password}}"}"""));
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
[Fact]
public async Task CreateUser_Response_DoesNotExposePasswordOrHash()
{
using var client = NewClient();
var response = await client.PostAsync("/api/v1/users",
Json($$"""{"username":"no_leak_probe","display_name":"A","password":"{{DefaultPassword}}"}"""));
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var body = await response.Content.ReadAsStringAsync();
Assert.DoesNotContain("password", body, StringComparison.OrdinalIgnoreCase);
Assert.DoesNotContain("argon2", body, StringComparison.OrdinalIgnoreCase);
}
[Fact]
public async Task GetChat_ByNonMember_ReturnsNotFound()
{
using var client = NewClient();
var alice = await CreateUserAsync(client);
var bob = await CreateUserAsync(client);
var eve = await CreateUserAsync(client);
var chatId = await CreateChatAsync(client, alice, bob);
using var request = Request(HttpMethod.Get, $"/api/v1/chats/{chatId}", eve);
var response = await client.SendAsync(request);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
Assert.Equal("not_found", await ErrorCodeAsync(response));
}
[Fact]
public async Task ListChats_ShowsOnlyChatsOfCurrentUser()
{
using var client = NewClient();
var alice = await CreateUserAsync(client);
var bob = await CreateUserAsync(client);
var eve = await CreateUserAsync(client);
var shared = await CreateChatAsync(client, alice, bob);
var other = await CreateChatAsync(client, eve);
using var request = Request(HttpMethod.Get, "/api/v1/chats", bob);
var page = await ReadJsonAsync(await client.SendAsync(request));
var ids = page.GetProperty("items").EnumerateArray().Select(c => c.GetProperty("id").GetGuid()).ToList();
Assert.Contains(shared, ids);
Assert.DoesNotContain(other, ids);
}
[Fact]
public async Task CreateChat_WithUnknownMember_ReturnsBadRequestAndCreatesNothing()
{
using var client = NewClient();
var alice = await CreateUserAsync(client);
using var request = Request(HttpMethod.Post, "/api/v1/chats", alice,
Json($$"""{"title":"X","member_ids":["{{alice.Id}}","{{Guid.NewGuid()}}"]}"""));
var response = await client.SendAsync(request);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
using var list = Request(HttpMethod.Get, "/api/v1/chats", alice);
var page = await ReadJsonAsync(await client.SendAsync(list));
Assert.Empty(page.GetProperty("items").EnumerateArray());
}
[Fact]
public async Task SendMessage_ToForeignChat_ReturnsNotFound()
{
using var client = NewClient();
var alice = await CreateUserAsync(client);
var bob = await CreateUserAsync(client);
var eve = await CreateUserAsync(client);
var chatId = await CreateChatAsync(client, alice, bob);
var response = await SendMessageAsync(client, eve, chatId, "чужое");
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
[Theory]
[InlineData("")]
[InlineData(" ")]
public async Task SendMessage_WithEmptyText_ReturnsBadRequest(string text)
{
using var client = NewClient();
var alice = await CreateUserAsync(client);
var chatId = await CreateChatAsync(client, alice);
var response = await SendMessageAsync(client, alice, chatId, text);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
Assert.Equal("invalid_request", await ErrorCodeAsync(response));
}
[Fact]
public async Task SendMessage_SenderIsTakenFromSession_NotFromRequest()
{
using var client = NewClient();
var alice = await CreateUserAsync(client);
var bob = await CreateUserAsync(client);
var chatId = await CreateChatAsync(client, alice, bob);
using var request = Request(HttpMethod.Post, $"/api/v1/chats/{chatId}/messages", alice,
Json($$"""{"text":"привет","sender_id":"{{bob.Id}}"}"""));
var withSender = await client.SendAsync(request);
var ok = await SendMessageAsync(client, alice, chatId, "привет");
Assert.Equal(HttpStatusCode.BadRequest, withSender.StatusCode); // sender_id в запросе не принимается
Assert.Equal(alice.Id, (await ReadJsonAsync(ok)).GetProperty("sender_id").GetGuid());
}
[Fact]
public async Task ListMessages_WalksAllPagesWithoutGapsOrDuplicates()
{
using var client = NewClient();
var alice = await CreateUserAsync(client);
var bob = await CreateUserAsync(client);
var chatId = await CreateChatAsync(client, alice, bob);
const int total = 7;
var sent = new List<Guid>();
for (var i = 0; i < total; i++)
{
var response = await SendMessageAsync(client, i % 2 == 0 ? alice : bob, chatId, $"сообщение {i}");
sent.Add((await ReadJsonAsync(response)).GetProperty("id").GetGuid());
}
var received = new List<Guid>();
string? cursor = null;
var pages = 0;
do
{
var url = $"/api/v1/chats/{chatId}/messages?limit=3" +
(cursor is null ? "" : "&cursor=" + Uri.EscapeDataString(cursor));
using var request = Request(HttpMethod.Get, url, alice);
var page = await ReadJsonAsync(await client.SendAsync(request));
received.AddRange(page.GetProperty("items").EnumerateArray().Select(m => m.GetProperty("id").GetGuid()));
var next = page.GetProperty("next_cursor");
cursor = next.ValueKind == JsonValueKind.Null ? null : next.GetString();
pages++;
}
while (cursor is not null && pages < 10);
Assert.Equal(3, pages);
Assert.Equal(total, received.Count);
// Один автор в одном чате: порядок истории совпадает с порядком отправки.
Assert.Equal(sent, received);
}
[Fact]
public async Task ListMessages_WithCursorFromAnotherChat_ReturnsBadRequest()
{
using var client = NewClient();
var alice = await CreateUserAsync(client);
var chat1 = await CreateChatAsync(client, alice);
var chat2 = await CreateChatAsync(client, alice);
await SendMessageAsync(client, alice, chat1, "a");
await SendMessageAsync(client, alice, chat1, "b");
using var first = Request(HttpMethod.Get, $"/api/v1/chats/{chat1}/messages?limit=1", alice);
var cursor = (await ReadJsonAsync(await client.SendAsync(first))).GetProperty("next_cursor").GetString()!;
using var request = Request(HttpMethod.Get,
$"/api/v1/chats/{chat2}/messages?cursor={Uri.EscapeDataString(cursor)}", alice);
var response = await client.SendAsync(request);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
[Fact]
public async Task ListMessages_ReturnsSameOrderForAnyPageSize()
{
using var client = NewClient();
var alice = await CreateUserAsync(client);
var chatId = await CreateChatAsync(client, alice);
var sent = new List<Guid>();
for (var i = 0; i < 120; i++)
{
var response = await SendMessageAsync(client, alice, chatId, $"m{i}");
sent.Add((await ReadJsonAsync(response)).GetProperty("id").GetGuid());
}
var baseline = await ReadAllMessagesAsync(client, chatId, alice, 100);
Assert.Equal(sent, baseline);
foreach (var limit in new[] { 1, 7, 50 })
{
var received = await ReadAllMessagesAsync(client, chatId, alice, limit);
Assert.Equal(baseline, received);
}
}
[Fact]
public async Task ListMessages_AfterConcurrentSends_IsOrderedByTimeThenId()
{
using var client = NewClient();
var users = new List<TestUser>();
for (var i = 0; i < 10; i++)
{
users.Add(await CreateUserAsync(client));
}
var chatId = await CreateChatAsync(client, users[0], users.Skip(1).ToArray());
var sends = Enumerable.Range(0, 300).Select(i => SendMessageAsync(client, users[i % 10], chatId, $"m{i}"));
foreach (var response in await Task.WhenAll(sends))
{
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
}
var items = new List<(string CreatedAt, Guid Id)>();
string? cursor = null;
do
{
var url = $"/api/v1/chats/{chatId}/messages?limit=100" +
(cursor is null ? "" : "&cursor=" + Uri.EscapeDataString(cursor));
using var request = Request(HttpMethod.Get, url, users[0]);
var page = await ReadJsonAsync(await client.SendAsync(request));
items.AddRange(page.GetProperty("items").EnumerateArray()
.Select(m => (m.GetProperty("created_at").GetString()!, m.GetProperty("id").GetGuid())));
var next = page.GetProperty("next_cursor");
cursor = next.ValueKind == JsonValueKind.Null ? null : next.GetString();
}
while (cursor is not null);
Assert.Equal(300, items.Count);
Assert.Equal(300, items.Select(x => x.Id).Distinct().Count());
// Серверное время строго возрастает внутри чата (см. last_message_at), поэтому порядок истории — порядок записи.
Assert.Equal(300, items.Select(x => x.CreatedAt).Distinct().Count());
Assert.Equal(items.OrderBy(x => x.CreatedAt, StringComparer.Ordinal).ToList(), items);
}
[Theory]
[InlineData("""{"USERNAME":"probe_case_a","display_name":"A","password":"correct horse battery staple"}""")]
[InlineData("""{"username":"probe_case_b","Display_Name":"A","password":"correct horse battery staple"}""")]
[InlineData("""{"Username":"probe_case_c","display_name":"A","password":"correct horse battery staple"}""")]
public async Task CreateUser_WithDifferentlyCasedFieldNames_ReturnsBadRequest(string body)
{
using var client = NewClient();
var response = await client.PostAsync("/api/v1/users", Json(body));
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
Assert.Equal("invalid_request", await ErrorCodeAsync(response));
}
}
+252
View File
@@ -0,0 +1,252 @@
using System.Net;
using System.Net.Http.Headers;
using static Messenger.Api.Tests.ApiHelpers;
namespace Messenger.Api.Tests;
[Collection("api")]
public class AuthTests(ApiFixture fixture)
{
private static readonly string[] ProtectedGets =
[
"/api/v1/users/me",
"/api/v1/chats",
"/api/v1/chats/00000000-0000-0000-0000-000000000001",
"/api/v1/chats/00000000-0000-0000-0000-000000000001/messages"
];
[Fact]
public async Task Login_WithValidCredentials_ReturnsOpaqueBearerSession()
{
using var client = fixture.CreateClient();
var user = await CreateUserAsync(client);
var response = await LoginAsync(client, user.Username, user.Password);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var json = await ReadJsonAsync(response);
Assert.Equal("Bearer", json.GetProperty("token_type").GetString());
Assert.True(json.GetProperty("token").GetString()!.Length >= 43); // 256 бит в base64url
Assert.Equal(user.Id, json.GetProperty("user").GetProperty("id").GetGuid());
Assert.DoesNotContain("password", await response.Content.ReadAsStringAsync(), StringComparison.OrdinalIgnoreCase);
}
[Fact]
public async Task Login_AcceptsColonInPassword()
{
using var client = fixture.CreateClient();
var username = "colon" + Guid.NewGuid().ToString("N")[..8];
await client.PostAsync("/api/v1/users",
Json($$"""{"username":"{{username}}","display_name":"A","password":"pass:with:colons-123"}"""));
var response = await LoginAsync(client, username, "pass:with:colons-123");
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
}
[Fact]
public async Task Login_WrongPasswordAndUnknownUser_GiveIdenticalUnauthorized()
{
using var client = fixture.CreateClient();
var user = await CreateUserAsync(client);
var wrongPassword = await LoginAsync(client, user.Username, "totally-wrong-password");
var unknownUser = await LoginAsync(client, "nobody_" + Guid.NewGuid().ToString("N")[..8], DefaultPassword);
foreach (var response in new[] { wrongPassword, unknownUser })
{
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
Assert.Equal("Basic realm=\"messenger\", charset=\"UTF-8\"", response.Headers.WwwAuthenticate.ToString());
Assert.Equal("unauthorized", await ErrorCodeAsync(response));
}
var a = (await ReadJsonAsync(wrongPassword)).GetProperty("error").GetProperty("message").GetString();
var b = (await ReadJsonAsync(unknownUser)).GetProperty("error").GetProperty("message").GetString();
Assert.Equal(a, b);
}
[Theory]
[InlineData("Basic !!!not-base64")]
[InlineData("Basic bm9jb2xvbg==")] // "nocolon"
[InlineData("Bearer sometoken")]
[InlineData("")]
public async Task Login_WithMalformedAuthorization_ReturnsUnauthorized(string header)
{
using var client = fixture.CreateClient();
using var request = new HttpRequestMessage(HttpMethod.Post, "/api/v1/auth/sessions");
if (header.Length > 0)
{
request.Headers.TryAddWithoutValidation("Authorization", header);
}
var response = await client.SendAsync(request);
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
Assert.StartsWith("Basic", response.Headers.WwwAuthenticate.ToString());
}
[Theory]
[MemberData(nameof(ProtectedUrls))]
public async Task ProtectedEndpoints_WithoutToken_ReturnUnauthorizedWithBearerChallenge(string url)
{
using var client = fixture.CreateClient();
var response = await client.GetAsync(url);
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
Assert.Equal("Bearer realm=\"messenger\"", response.Headers.WwwAuthenticate.ToString());
Assert.True(response.Headers.Contains("X-Request-Id"));
}
public static IEnumerable<object[]> ProtectedUrls() => ProtectedGets.Select(u => new object[] { u });
[Fact]
public async Task ProtectedEndpoint_WithBasicAuth_ReturnsUnauthorized()
{
using var client = fixture.CreateClient();
var user = await CreateUserAsync(client);
using var request = new HttpRequestMessage(HttpMethod.Get, "/api/v1/users/me");
request.Headers.TryAddWithoutValidation("Authorization", BasicHeader(user.Username, user.Password));
var response = await client.SendAsync(request);
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
}
[Fact]
public async Task XUserIdHeader_IsIgnored()
{
using var client = fixture.CreateClient();
var alice = await CreateUserAsync(client);
var eve = await CreateUserAsync(client);
// Без токена X-User-Id не даёт доступа.
using var anonymous = new HttpRequestMessage(HttpMethod.Get, "/api/v1/users/me");
anonymous.Headers.Add("X-User-Id", alice.Id.ToString());
Assert.Equal(HttpStatusCode.Unauthorized, (await client.SendAsync(anonymous)).StatusCode);
// С токеном — владелец сессии не подменяется.
using var spoofed = Request(HttpMethod.Get, "/api/v1/users/me", alice);
spoofed.Headers.Add("X-User-Id", eve.Id.ToString());
var me = await ReadJsonAsync(await client.SendAsync(spoofed));
Assert.Equal(alice.Id, me.GetProperty("id").GetGuid());
}
[Fact]
public async Task UnauthenticatedPostWithMalformedBody_ReturnsUnauthorizedNotBadRequest()
{
using var client = fixture.CreateClient();
var response = await client.PostAsync("/api/v1/chats", Json("{bad"));
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); // сначала аутентификация
}
[Fact]
public async Task Logout_RevokesTokenAndSecondLogoutIsUnauthorized()
{
using var client = fixture.CreateClient();
var user = await CreateUserAsync(client);
using var first = Request(HttpMethod.Delete, "/api/v1/auth/sessions/current", user);
var firstResponse = await client.SendAsync(first);
Assert.Equal(HttpStatusCode.NoContent, firstResponse.StatusCode);
Assert.Equal(0, firstResponse.Content.Headers.ContentLength ?? 0);
using var again = Request(HttpMethod.Delete, "/api/v1/auth/sessions/current", user);
Assert.Equal(HttpStatusCode.Unauthorized, (await client.SendAsync(again)).StatusCode);
using var me = Request(HttpMethod.Get, "/api/v1/users/me", user);
Assert.Equal(HttpStatusCode.Unauthorized, (await client.SendAsync(me)).StatusCode);
}
[Fact]
public async Task LogoutOfOneSession_DoesNotAffectAnotherSessionOfSameUser()
{
using var client = fixture.CreateClient();
var user = await CreateUserAsync(client);
var secondLogin = await ReadJsonAsync(await LoginAsync(client, user.Username, user.Password));
var second = user with { Token = secondLogin.GetProperty("token").GetString()! };
using var logout = Request(HttpMethod.Delete, "/api/v1/auth/sessions/current", user);
await client.SendAsync(logout);
using var me = Request(HttpMethod.Get, "/api/v1/users/me", second);
Assert.Equal(HttpStatusCode.OK, (await client.SendAsync(me)).StatusCode);
}
[Fact]
public async Task ExpiredSession_IsRejected()
{
using var client = fixture.CreateClient();
var user = await CreateUserAsync(client);
using var before = Request(HttpMethod.Get, "/api/v1/users/me", user);
Assert.Equal(HttpStatusCode.OK, (await client.SendAsync(before)).StatusCode);
// Состарим сессию в БД: created_at < expires_at < now (ограничение таблицы требует expires_at > created_at).
await using (var db = await fixture.OpenConnectionAsync())
await using (var age = new Npgsql.NpgsqlCommand(
"update sessions set created_at = now() - interval '10 seconds', expires_at = now() - interval '5 seconds' where user_id = @u", db))
{
age.Parameters.AddWithValue("u", user.Id);
Assert.Equal(1, await age.ExecuteNonQueryAsync());
}
using var after = Request(HttpMethod.Get, "/api/v1/users/me", user);
Assert.Equal(HttpStatusCode.Unauthorized, (await client.SendAsync(after)).StatusCode);
}
[Fact]
public async Task ShortSessionTtl_ExpiresSessionByItself()
{
// Отдельный экземпляр приложения с SESSION_TTL_SECONDS=2 поверх той же БД: никаких подмен данных в таблице.
await using var app = fixture.WithWebHostBuilder(b => b.UseSetting("SESSION_TTL_SECONDS", "2"));
using var client = app.CreateClient();
var user = await CreateUserAsync(client);
using (var alive = Request(HttpMethod.Get, "/api/v1/users/me", user))
{
Assert.Equal(HttpStatusCode.OK, (await client.SendAsync(alive)).StatusCode);
}
await Task.Delay(TimeSpan.FromSeconds(3));
using var expired = Request(HttpMethod.Get, "/api/v1/users/me", user);
var response = await client.SendAsync(expired);
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
Assert.Equal("Bearer realm=\"messenger\"", response.Headers.WwwAuthenticate.ToString());
// Истёкшая сессия не продлевается: повторный вход выдаёт новую.
Assert.Equal(HttpStatusCode.Created, (await LoginAsync(client, user.Username, user.Password)).StatusCode);
}
[Fact]
public async Task SessionsTable_StoresTokenHashNotToken()
{
using var client = fixture.CreateClient();
var user = await CreateUserAsync(client);
await using var db = await fixture.OpenConnectionAsync();
await using var query = new Npgsql.NpgsqlCommand(
"select token_hash from sessions where user_id = @u", db);
query.Parameters.AddWithValue("u", user.Id);
var stored = (byte[])(await query.ExecuteScalarAsync())!;
Assert.Equal(32, stored.Length);
Assert.NotEqual(System.Text.Encoding.UTF8.GetBytes(user.Token), stored);
Assert.Equal(System.Security.Cryptography.SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(user.Token)), stored);
}
[Fact]
public async Task PasswordsAreStoredAsArgon2id()
{
using var client = fixture.CreateClient();
var user = await CreateUserAsync(client);
await using var db = await fixture.OpenConnectionAsync();
await using var query = new Npgsql.NpgsqlCommand("select password_hash from users where id = @u", db);
query.Parameters.AddWithValue("u", user.Id);
var hash = (string)(await query.ExecuteScalarAsync())!;
Assert.StartsWith("$argon2id$", hash);
Assert.DoesNotContain(user.Password, hash);
}
}
+150
View File
@@ -0,0 +1,150 @@
using System.Net;
using Microsoft.AspNetCore.Mvc.Testing;
using static Messenger.Api.Tests.ApiHelpers;
namespace Messenger.Api.Tests;
[Collection("api")]
public class CacheTests(ApiFixture fixture)
{
private static string Header(HttpResponseMessage response, string name) =>
response.Headers.TryGetValues(name, out var values) ? values.First() : "";
private static async Task<HttpResponseMessage> GetPageAsync(
HttpClient client, TestUser user, Guid chatId, int limit = 50, string? cursor = null)
{
var url = $"/api/v1/chats/{chatId}/messages?limit={limit}" +
(cursor is null ? "" : "&cursor=" + Uri.EscapeDataString(cursor));
using var request = Request(HttpMethod.Get, url, user);
return await client.SendAsync(request);
}
private static async Task<(TestUser Alice, TestUser Bob, Guid Chat)> ChatWithMessagesAsync(HttpClient client, int messages)
{
var alice = await CreateUserAsync(client);
var bob = await CreateUserAsync(client);
var chat = await CreateChatAsync(client, alice, bob);
for (var i = 0; i < messages; i++)
{
Assert.Equal(HttpStatusCode.Created, (await SendMessageAsync(client, alice, chat, $"m{i}")).StatusCode);
}
return (alice, bob, chat);
}
[Fact]
public async Task SecondRead_IsServedFromCache_WithFewerSqlQueries_AndIdenticalBody()
{
using var client = fixture.CreateClient();
var (_, bob, chat) = await ChatWithMessagesAsync(client, 3);
var first = await GetPageAsync(client, bob, chat);
var second = await GetPageAsync(client, bob, chat);
Assert.Equal("miss", Header(first, "X-Cache"));
Assert.Equal("hit", Header(second, "X-Cache"));
// miss: сессия + версия/доступ + страница; hit: сессия + версия/доступ.
Assert.Equal("3", Header(first, "X-Db-Queries"));
Assert.Equal("2", Header(second, "X-Db-Queries"));
Assert.Equal(await first.Content.ReadAsStringAsync(), await second.Content.ReadAsStringAsync());
}
[Fact]
public async Task ReadAfterWrite_NeverReturnsStaleCachedPage()
{
using var client = fixture.CreateClient();
var (alice, bob, chat) = await ChatWithMessagesAsync(client, 2);
await GetPageAsync(client, bob, chat); // прогрели кэш
Assert.Equal("hit", Header(await GetPageAsync(client, bob, chat), "X-Cache"));
for (var i = 0; i < 20; i++)
{
var sent = await SendMessageAsync(client, alice, chat, $"new {i}");
var id = (await ReadJsonAsync(sent)).GetProperty("id").GetGuid();
// Сразу после подтверждённой записи (201) следующее чтение обязано содержать новое сообщение.
var ids = await ReadAllMessagesAsync(client, chat, bob, 100);
Assert.Contains(id, ids);
Assert.Equal(3 + i, ids.Count);
}
}
[Fact]
public async Task FlushedCache_DoesNotChangeResults()
{
using var client = fixture.CreateClient();
var (_, bob, chat) = await ChatWithMessagesAsync(client, 5);
var before = await ReadAllMessagesAsync(client, chat, bob, 2);
Assert.Equal("hit", Header(await GetPageAsync(client, bob, chat, 2), "X-Cache"));
await fixture.FlushCacheAsync();
var response = await GetPageAsync(client, bob, chat, 2);
Assert.Equal("miss", Header(response, "X-Cache"));
Assert.Equal(before, await ReadAllMessagesAsync(client, chat, bob, 2));
}
[Fact]
public async Task CachedPage_IsNotVisibleToNonMember()
{
using var client = fixture.CreateClient();
var (_, bob, chat) = await ChatWithMessagesAsync(client, 2);
var eve = await CreateUserAsync(client);
await GetPageAsync(client, bob, chat);
Assert.Equal("hit", Header(await GetPageAsync(client, bob, chat), "X-Cache"));
var response = await GetPageAsync(client, eve, chat);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); // доступ проверяется до обращения к кэшу
Assert.DoesNotContain("m0", await response.Content.ReadAsStringAsync());
}
[Fact]
public async Task PagesWithDifferentLimitsAndCursors_AreCachedSeparately()
{
using var client = fixture.CreateClient();
var (_, bob, chat) = await ChatWithMessagesAsync(client, 9);
var firstPass = await ReadAllMessagesAsync(client, chat, bob, 4);
var secondPass = await ReadAllMessagesAsync(client, chat, bob, 4); // все страницы уже в кэше
var otherLimit = await ReadAllMessagesAsync(client, chat, bob, 3);
Assert.Equal(9, firstPass.Count);
Assert.Equal(firstPass, secondPass);
Assert.Equal(firstPass, otherLimit);
}
[Fact]
public async Task UnavailableCache_IsBypassed_AndRequestsStillSucceed()
{
using var client = fixture.CreateClient();
var (_, bob, chat) = await ChatWithMessagesAsync(client, 3);
var expected = await ReadAllMessagesAsync(client, chat, bob, 100);
// Второй экземпляр приложения, у которого кэш указывает на закрытый порт.
await using var broken = fixture.WithWebHostBuilder(b => b.UseSetting("CACHE_CONNECTION", "127.0.0.1:1"));
using var brokenClient = broken.CreateClient();
for (var i = 0; i < 3; i++)
{
var response = await GetPageAsync(brokenClient, bob, chat);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("bypass", Header(response, "X-Cache"));
}
Assert.Equal(expected, await ReadAllMessagesAsync(brokenClient, chat, bob, 100));
// Запись тоже не зависит от кэша.
Assert.Equal(HttpStatusCode.Created, (await SendMessageAsync(brokenClient, bob, chat, "при отказе кэша")).StatusCode);
}
[Fact]
public async Task UnavailableCache_DoesNotTrustAnonymousRequests()
{
await using var broken = fixture.WithWebHostBuilder(b => b.UseSetting("CACHE_CONNECTION", "127.0.0.1:1"));
using var client = broken.CreateClient();
var response = await client.GetAsync($"/api/v1/chats/{Guid.NewGuid()}/messages");
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
}
}
@@ -0,0 +1,79 @@
using System.Net;
using static Messenger.Api.Tests.ApiHelpers;
namespace Messenger.Api.Tests;
[Collection("api")]
public class ConcurencyTests(ApiFixture fixture)
{
[Fact]
public async Task Create100MessagesBy10DifferentUsers_Concurrent()
{
using var client = fixture.CreateClient();
var users = new List<TestUser>();
for (var i = 0; i < 10; i++)
{
users.Add(await CreateUserAsync(client));
}
var chat = await CreateChatAsync(client, users[0], users.Skip(1).ToArray());
var messageTasks = Enumerable.Range(0, 100)
.Select(i => SendMessageAsync(client, users[i % 10], chat, $"Message {i + 1} from {users[i % 10].Username}"))
.ToList();
foreach (var response in await Task.WhenAll(messageTasks))
{
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
}
var messages = await ReadAllMessagesAsync(client, chat, users[0], 7);
Assert.Equal(100, messages.Count);
Assert.Equal(100, messages.Distinct().Count());
}
[Fact]
public async Task RegisterSameUsernameConcurrently_ExactlyOneSucceeds_NoServerErrors()
{
// Проверяется гарантия уникального индекса, а не скорость железа: очередь хеширования делаем практически
// неограниченной по времени (по умолчанию лишние запросы получают 503, см. следующий тест).
await using var app = fixture.WithWebHostBuilder(b => b.UseSetting("PASSWORD_HASH_QUEUE_TIMEOUT_SECONDS", "120"));
using var client = app.CreateClient();
var username = "race" + Guid.NewGuid().ToString("N")[..10];
var attempts = Enumerable.Range(0, 20).Select(_ => client.PostAsync("/api/v1/users",
Json($$"""{"username":"{{username}}","display_name":"Гонка","password":"{{DefaultPassword}}"}""")));
var statuses = (await Task.WhenAll(attempts)).Select(r => r.StatusCode).ToList();
Assert.Single(statuses, HttpStatusCode.Created);
Assert.Equal(19, statuses.Count(s => s == HttpStatusCode.Conflict));
await using var db = await fixture.OpenConnectionAsync();
await using var count = new Npgsql.NpgsqlCommand("select count(*) from users where username = @u", db);
count.Parameters.AddWithValue("u", username);
Assert.Equal(1L, await count.ExecuteScalarAsync());
}
[Fact]
public async Task RegistrationBurstBeyondHashingCapacity_GetsBoundedUnavailable_NotServerError()
{
// Один слот Argon2 и ожидание 50 мс: пачка регистраций разных пользователей упирается в лимит.
// Лишние запросы получают 503 unavailable (а не 500 и не зависание), принятые — 201.
await using var app = fixture.WithWebHostBuilder(b => b
.UseSetting("PASSWORD_HASH_CONCURRENCY", "1")
.UseSetting("PASSWORD_HASH_QUEUE_TIMEOUT_SECONDS", "0.05"));
using var client = app.CreateClient();
var prefix = "burst" + Guid.NewGuid().ToString("N")[..6];
var responses = await Task.WhenAll(Enumerable.Range(0, 12).Select(i => client.PostAsync("/api/v1/users",
Json($$"""{"username":"{{prefix}}_{{i}}","display_name":"Пачка","password":"{{DefaultPassword}}"}"""))));
var statuses = responses.Select(r => r.StatusCode).ToList();
Assert.All(statuses, s => Assert.True(s is HttpStatusCode.Created or HttpStatusCode.ServiceUnavailable, $"неожиданный статус {s}"));
Assert.Contains(HttpStatusCode.Created, statuses);
Assert.Contains(HttpStatusCode.ServiceUnavailable, statuses);
var rejected = responses.First(r => r.StatusCode == HttpStatusCode.ServiceUnavailable);
Assert.Equal("unavailable", await ErrorCodeAsync(rejected));
}
}
@@ -0,0 +1,192 @@
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Testcontainers.PostgreSql;
using static Messenger.Api.Tests.ApiHelpers;
namespace Messenger.Api.Tests;
[Collection("api")]
public class DependencyFailureTests(ApiFixture fixture)
{
private static int FreePort()
{
using var listener = new TcpListener(IPAddress.Loopback, 0);
listener.Start();
return ((IPEndPoint)listener.LocalEndpoint).Port;
}
[Fact]
public async Task DatabaseDown_Returns503_NeverTrustsAnonymous_AndRecovers()
{
// Отдельный контейнер БД, который тест останавливает и запускает снова на том же порту.
var port = FreePort();
await using var pg = new PostgreSqlBuilder().WithImage(ApiFixture.PostgresImage).WithPortBinding(port, 5432).Build();
await pg.StartAsync();
var file = ApiFixture.WriteConnectionFile(pg.GetConnectionString());
try
{
await using var app = fixture.WithWebHostBuilder(b => b
.UseSetting("DATABASE_URL_FILE", file)
.UseSetting("DB_CONNECT_TIMEOUT_SECONDS", "2"));
using var client = app.CreateClient();
var user = await CreateUserAsync(client);
using (var ok = Request(HttpMethod.Get, "/api/v1/users/me", user))
{
Assert.Equal(HttpStatusCode.OK, (await client.SendAsync(ok)).StatusCode);
}
await pg.StopAsync();
// Аутентифицированный запрос: ограниченная ошибка 503 без внутренних деталей.
using var down = Request(HttpMethod.Get, "/api/v1/users/me", user);
var downResponse = await client.SendAsync(down);
Assert.Equal(HttpStatusCode.ServiceUnavailable, downResponse.StatusCode);
Assert.Equal("unavailable", await ErrorCodeAsync(downResponse));
var body = await downResponse.Content.ReadAsStringAsync();
Assert.DoesNotContain("Npgsql", body);
Assert.DoesNotContain("Host=", body);
Assert.True(downResponse.Headers.Contains("X-Request-Id"));
// Анонимный запрос не становится доверенным: без токена по-прежнему 401, а не 200/503 «как гость».
Assert.Equal(HttpStatusCode.Unauthorized, (await client.GetAsync("/api/v1/chats")).StatusCode);
// Токен, который нельзя проверить, не принимается.
Assert.Equal(HttpStatusCode.ServiceUnavailable,
(await LoginAsync(client, user.Username, user.Password)).StatusCode);
// Готовность отражает отказ, живость — нет.
Assert.Equal(HttpStatusCode.ServiceUnavailable, (await client.GetAsync("/health/ready")).StatusCode);
Assert.Equal(HttpStatusCode.OK, (await client.GetAsync("/health/live")).StatusCode);
// Восстановление: после запуска БД тот же токен снова работает (данные не потеряны), без перезапуска API.
await pg.StartAsync();
var recovered = false;
var started = Stopwatch.StartNew();
while (started.Elapsed < TimeSpan.FromSeconds(30) && !recovered)
{
using var retry = Request(HttpMethod.Get, "/api/v1/users/me", user);
recovered = (await client.SendAsync(retry)).StatusCode == HttpStatusCode.OK;
if (!recovered)
{
await Task.Delay(500);
}
}
Assert.True(recovered, "API не восстановился после возврата PostgreSQL");
}
finally
{
File.Delete(file);
}
}
[Fact]
public async Task ExhaustedConnectionPool_ReturnsBoundedError()
{
using var setup = fixture.CreateClient();
var user = await CreateUserAsync(setup);
// Пул из одного соединения и короткое ожидание: пока тест держит единственное соединение, запросы не зависают.
await using var app = fixture.WithWebHostBuilder(b => b
.UseSetting("DB_MAX_POOL_SIZE", "1")
.UseSetting("DB_CONNECT_TIMEOUT_SECONDS", "1"));
using var client = app.CreateClient();
using var scope = app.Services.CreateScope();
var held = scope.ServiceProvider.GetRequiredService<Data.MessengerDbContext>();
await held.Database.OpenConnectionAsync();
try
{
var started = Stopwatch.StartNew();
using var request = Request(HttpMethod.Get, "/api/v1/users/me", user);
var response = await client.SendAsync(request);
started.Stop();
Assert.Equal(HttpStatusCode.ServiceUnavailable, response.StatusCode);
Assert.True(started.Elapsed < TimeSpan.FromSeconds(6), $"ответ занял {started.Elapsed}");
}
finally
{
await held.Database.CloseConnectionAsync();
}
// После освобождения соединения сервис работает.
using var after = Request(HttpMethod.Get, "/api/v1/users/me", user);
Assert.Equal(HttpStatusCode.OK, (await client.SendAsync(after)).StatusCode);
}
[Fact]
public async Task FailedMessageInsert_RollsBackVersionAndTimestamp()
{
using var client = fixture.CreateClient();
var alice = await CreateUserAsync(client);
var chat = await CreateChatAsync(client, alice);
Assert.Equal(HttpStatusCode.Created, (await SendMessageAsync(client, alice, chat, "до сбоя")).StatusCode);
var marker = "boom-" + Guid.NewGuid().ToString("N");
var suffix = Guid.NewGuid().ToString("N")[..8];
// Сбой «после UPDATE чата, во время INSERT сообщения»: триггер БД отклоняет сообщение с маркером.
await fixture.ExecuteAsync($$"""
CREATE FUNCTION fail_{{suffix}}() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN IF NEW.text = '{{marker}}' THEN RAISE EXCEPTION 'injected failure'; END IF; RETURN NEW; END $$;
CREATE TRIGGER tr_{{suffix}} BEFORE INSERT ON messages FOR EACH ROW EXECUTE FUNCTION fail_{{suffix}}();
""");
try
{
var versionBefore = await fixture.ScalarAsync<long>("select history_version from chats where id = @c", ("c", chat));
var lastBefore = await fixture.ScalarAsync<DateTime?>("select last_message_at from chats where id = @c", ("c", chat));
var failed = await SendMessageAsync(client, alice, chat, marker);
Assert.Equal(HttpStatusCode.InternalServerError, failed.StatusCode);
var body = await failed.Content.ReadAsStringAsync();
Assert.Contains("internal_error", body);
Assert.DoesNotContain("injected", body); // внутренние детали не раскрываются
Assert.Equal(versionBefore, await fixture.ScalarAsync<long>("select history_version from chats where id = @c", ("c", chat)));
Assert.Equal(lastBefore, await fixture.ScalarAsync<DateTime?>("select last_message_at from chats where id = @c", ("c", chat)));
Assert.Equal(1L, await fixture.ScalarAsync<long>("select count(*) from messages where chat_id = @c", ("c", chat)));
// Блокировка строки чата снята, следующая запись проходит и версия растёт ровно на 1.
Assert.Equal(HttpStatusCode.Created, (await SendMessageAsync(client, alice, chat, "после сбоя")).StatusCode);
Assert.Equal(versionBefore + 1, await fixture.ScalarAsync<long>("select history_version from chats where id = @c", ("c", chat)));
}
finally
{
await fixture.ExecuteAsync($"DROP TRIGGER tr_{suffix} ON messages; DROP FUNCTION fail_{suffix}();");
}
}
[Fact]
public async Task FailedChatMemberInsert_RollsBackWholeChat()
{
using var client = fixture.CreateClient();
var alice = await CreateUserAsync(client);
var bob = await CreateUserAsync(client);
var suffix = Guid.NewGuid().ToString("N")[..8];
var title = "rollback-" + suffix;
// Сбой при добавлении второго участника, уже после вставки строки чата и первого участника.
await fixture.ExecuteAsync($$"""
CREATE FUNCTION fail_{{suffix}}() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN IF NEW.user_id = '{{bob.Id}}' THEN RAISE EXCEPTION 'injected failure'; END IF; RETURN NEW; END $$;
CREATE TRIGGER tr_{{suffix}} BEFORE INSERT ON chat_members FOR EACH ROW EXECUTE FUNCTION fail_{{suffix}}();
""");
try
{
using var request = Request(HttpMethod.Post, "/api/v1/chats", alice,
Json($$"""{"title":"{{title}}","member_ids":["{{alice.Id}}","{{bob.Id}}"]}"""));
var response = await client.SendAsync(request);
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
Assert.Equal(0L, await fixture.ScalarAsync<long>("select count(*) from chats where title = @t", ("t", title)));
Assert.Equal(0L, await fixture.ScalarAsync<long>(
"select count(*) from chat_members where user_id in (@a, @b) ", ("a", alice.Id), ("b", bob.Id)));
}
finally
{
await fixture.ExecuteAsync($"DROP TRIGGER tr_{suffix} ON chat_members; DROP FUNCTION fail_{suffix}();");
}
}
}
+28
View File
@@ -0,0 +1,28 @@
using System.Net;
namespace Messenger.Api.Tests;
[Collection("api")]
public class HealthTests(ApiFixture fixture)
{
[Fact]
public async Task Live_ReturnsOk()
{
using var client = fixture.CreateClient();
var response = await client.GetAsync("/health/live");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
[Fact]
public async Task Ready_ReturnsOkWhenDatabaseIsAvailable()
{
using var client = fixture.CreateClient();
var response = await client.GetAsync("/health/ready");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.True(response.Headers.Contains("X-Request-Id"));
}
}
@@ -0,0 +1,27 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net10.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="coverlet.collector" Version="6.0.4" />
<PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.12" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
<PackageReference Include="Testcontainers.PostgreSql" Version="4.16.0" />
<PackageReference Include="xunit" Version="2.9.3" />
<PackageReference Include="xunit.runner.visualstudio" Version="3.1.4" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Messenger.Api\Messenger.Api.csproj" />
</ItemGroup>
<ItemGroup>
<Using Include="Xunit" />
</ItemGroup>
</Project>
@@ -0,0 +1,69 @@
using Messenger.Api.Services;
namespace Messenger.Api.Tests;
public class PasswordHasherTests
{
private readonly Argon2PasswordHasher _hasher = new(new PasswordHashingSettings(4, TimeSpan.FromSeconds(30)));
[Fact]
public async Task Hash_IsArgon2idPhcString_WithoutPlaintext()
{
var hash = await _hasher.HashAsync("correct horse battery staple", CancellationToken.None);
Assert.StartsWith("$argon2id$", hash);
Assert.DoesNotContain("correct horse", hash);
}
[Fact]
public async Task Hash_UsesRandomSalt()
{
var a = await _hasher.HashAsync("same-password-123", CancellationToken.None);
var b = await _hasher.HashAsync("same-password-123", CancellationToken.None);
Assert.NotEqual(a, b);
}
[Theory]
[InlineData("correct horse battery staple")]
[InlineData("пароль-с-юникодом-и:двоеточием-12")]
public async Task Verify_AcceptsCorrect_RejectsWrong(string password)
{
var hash = await _hasher.HashAsync(password, CancellationToken.None);
Assert.True(await _hasher.VerifyAsync(hash, password, CancellationToken.None));
Assert.False(await _hasher.VerifyAsync(hash, password + "x", CancellationToken.None));
}
[Fact]
public async Task Verify_DoesNotTruncateLongPasswords()
{
// Это ограничение bcrypt (72 байта); Argon2id его не имеет. Пароли отличаются только хвостом.
var prefix = new string('я', 60); // 120 байт в UTF-8
var hash = await _hasher.HashAsync(prefix + "A", CancellationToken.None);
Assert.False(await _hasher.VerifyAsync(hash, prefix + "B", CancellationToken.None));
}
[Fact]
public async Task Hash_WhenAllSlotsAreBusy_FailsWithBusyException()
{
// Один слот и почти нулевое ожидание: параллельные вызовы не копят память, лишние получают исключение (→ 503).
var hasher = new Argon2PasswordHasher(new PasswordHashingSettings(1, TimeSpan.FromMilliseconds(20)));
var attempts = await Task.WhenAll(Enumerable.Range(0, 6).Select(async _ =>
{
try { await hasher.HashAsync("some-long-enough-password", CancellationToken.None); return true; }
catch (PasswordHasherBusyException) { return false; }
}));
Assert.Contains(true, attempts); // кто-то получил слот
Assert.Contains(false, attempts); // остальные получили контролируемый отказ
}
[Fact]
public async Task Verify_UnknownUser_ReturnsFalse()
{
Assert.False(await _hasher.VerifyAsync(null, "any-password-123", CancellationToken.None));
}
}
@@ -0,0 +1,20 @@
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Design;
namespace Messenger.Api.Data;
// Используется только командами `dotnet ef`. Для генерации миграций подключение к БД не открывается;
// для `dotnet ef database update` строка берётся из MESSENGER_DESIGN_CONNECTION.
public sealed class DesignTimeDbContextFactory : IDesignTimeDbContextFactory<MessengerDbContext>
{
public MessengerDbContext CreateDbContext(string[] args)
{
var connection = Environment.GetEnvironmentVariable("MESSENGER_DESIGN_CONNECTION")
?? "Host=localhost;Database=messenger;Username=design;Password=design";
var options = new DbContextOptionsBuilder<MessengerDbContext>()
.UseNpgsql(connection)
.UseSnakeCaseNamingConvention()
.Options;
return new MessengerDbContext(options);
}
}
+54
View File
@@ -0,0 +1,54 @@
namespace Messenger.Api.Data;
// Строки таблиц. API-модели (Messenger.Api.Models) остаются отдельными: в них нет password_hash и служебных полей.
public sealed class UserEntity
{
public Guid Id { get; set; }
public string Username { get; set; } = string.Empty;
public string DisplayName { get; set; } = string.Empty;
// Результат Argon2id (PHC-строка с солью и параметрами). Наружу не отдаётся никогда.
public string PasswordHash { get; set; } = string.Empty;
public DateTimeOffset CreatedAt { get; set; }
}
public sealed class ChatEntity
{
public Guid Id { get; set; }
public string Title { get; set; } = string.Empty;
public DateTimeOffset CreatedAt { get; set; }
// Версия истории: растёт на 1 в той же транзакции, что и вставка сообщения (UPDATE ... RETURNING).
// Источник версии для ключей кэша; одновременно сериализует записи в один чат (см. DESIGN).
public long HistoryVersion { get; set; }
// Время последнего сообщения. Обновляется тем же UPDATE, что и версия: следующее сообщение получает
// created_at строго больше этого значения, поэтому порядок (created_at, id) совпадает с порядком коммитов.
public DateTimeOffset? LastMessageAt { get; set; }
}
public sealed class ChatMemberEntity
{
public Guid ChatId { get; set; }
public Guid UserId { get; set; }
}
public sealed class MessageEntity
{
public Guid Id { get; set; }
public Guid ChatId { get; set; }
public Guid SenderId { get; set; }
public string Text { get; set; } = string.Empty;
public DateTimeOffset CreatedAt { get; set; }
}
public sealed class SessionEntity
{
public Guid Id { get; set; }
// SHA-256 от токена. Сам токен в БД не хранится: утечка БД не даёт действующих Bearer-токенов.
public byte[] TokenHash { get; set; } = Array.Empty<byte>();
public Guid UserId { get; set; }
public DateTimeOffset CreatedAt { get; set; }
public DateTimeOffset ExpiresAt { get; set; }
public DateTimeOffset? RevokedAt { get; set; }
}
@@ -0,0 +1,97 @@
using Microsoft.EntityFrameworkCore;
namespace Messenger.Api.Data;
public sealed class MessengerDbContext(DbContextOptions<MessengerDbContext> options) : DbContext(options)
{
public DbSet<UserEntity> Users => Set<UserEntity>();
public DbSet<ChatEntity> Chats => Set<ChatEntity>();
public DbSet<ChatMemberEntity> ChatMembers => Set<ChatMemberEntity>();
public DbSet<MessageEntity> Messages => Set<MessageEntity>();
public DbSet<SessionEntity> Sessions => Set<SessionEntity>();
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// Идентификаторы создаёт приложение (Guid.CreateVersion7: монотонные, индексы вставляются «справа»).
// Время created_at тоже назначает приложение, а не DEFAULT now(): см. порядок операций отправки сообщения.
modelBuilder.Entity<UserEntity>(e =>
{
e.ToTable("users", t =>
{
t.HasCheckConstraint("ck_users_username_format", @"username ~ '^[a-z0-9_]{3,32}$'");
t.HasCheckConstraint("ck_users_display_name_not_blank", @"display_name ~ '\S'");
});
e.HasKey(x => x.Id);
e.Property(x => x.Id).ValueGeneratedNever();
e.Property(x => x.Username).HasMaxLength(32).IsRequired();
e.Property(x => x.DisplayName).HasMaxLength(100).IsRequired(); // varchar(n) считает символы, не байты
e.Property(x => x.PasswordHash).IsRequired();
e.Property(x => x.CreatedAt).IsRequired();
e.HasIndex(x => x.Username).IsUnique().HasDatabaseName("ux_users_username");
});
modelBuilder.Entity<ChatEntity>(e =>
{
e.ToTable("chats", t =>
{
t.HasCheckConstraint("ck_chats_title_not_blank", @"title ~ '\S'");
t.HasCheckConstraint("ck_chats_history_version_nonneg", "history_version >= 0");
});
e.HasKey(x => x.Id);
e.Property(x => x.Id).ValueGeneratedNever();
e.Property(x => x.Title).HasMaxLength(100).IsRequired();
e.Property(x => x.CreatedAt).IsRequired();
e.Property(x => x.HistoryVersion).HasDefaultValue(0L).IsRequired();
// Список чатов: сортировка по (created_at, id) с keyset-курсором.
e.HasIndex(x => new { x.CreatedAt, x.Id }).HasDatabaseName("ix_chats_created_at_id");
});
modelBuilder.Entity<ChatMemberEntity>(e =>
{
e.ToTable("chat_members");
e.HasKey(x => new { x.ChatId, x.UserId }); // один пользователь не может быть в чате дважды
e.HasOne<ChatEntity>().WithMany().HasForeignKey(x => x.ChatId).OnDelete(DeleteBehavior.Cascade);
e.HasOne<UserEntity>().WithMany().HasForeignKey(x => x.UserId).OnDelete(DeleteBehavior.Restrict);
// PK обслуживает «участники чата»; этот индекс — «чаты пользователя» и проверку доступа.
e.HasIndex(x => x.UserId).HasDatabaseName("ix_chat_members_user_id");
});
modelBuilder.Entity<MessageEntity>(e =>
{
e.ToTable("messages", t =>
t.HasCheckConstraint("ck_messages_text_not_blank", @"text ~ '\S'")); // lab2: вложений нет
e.HasKey(x => x.Id);
e.Property(x => x.Id).ValueGeneratedNever();
e.Property(x => x.Text).HasMaxLength(4000).IsRequired();
e.Property(x => x.CreatedAt).IsRequired();
// Составной FK: отправитель обязан быть участником именно этого чата. Он же гарантирует существование
// чата и пользователя, поэтому отдельные FK на chats/users не нужны.
e.HasOne<ChatMemberEntity>().WithMany()
.HasForeignKey(x => new { x.ChatId, x.SenderId })
.HasPrincipalKey(x => new { x.ChatId, x.UserId })
.OnDelete(DeleteBehavior.Cascade);
// Страница истории: WHERE chat_id = @c AND (created_at, id) > (@t, @i) ORDER BY created_at, id LIMIT n.
e.HasIndex(x => new { x.ChatId, x.CreatedAt, x.Id }).HasDatabaseName("ix_messages_chat_history");
});
modelBuilder.Entity<SessionEntity>(e =>
{
e.ToTable("sessions", t =>
{
t.HasCheckConstraint("ck_sessions_token_hash_len", "octet_length(token_hash) = 32");
t.HasCheckConstraint("ck_sessions_expiry_after_creation", "expires_at > created_at");
});
e.HasKey(x => x.Id);
e.Property(x => x.Id).ValueGeneratedNever();
e.Property(x => x.TokenHash).IsRequired();
e.Property(x => x.CreatedAt).IsRequired();
e.Property(x => x.ExpiresAt).IsRequired();
e.HasOne<UserEntity>().WithMany().HasForeignKey(x => x.UserId).OnDelete(DeleteBehavior.Cascade);
// Аутентификация каждого запроса: поиск по хешу токена.
e.HasIndex(x => x.TokenHash).IsUnique().HasDatabaseName("ux_sessions_token_hash");
// Фоновая очистка истёкших сессий.
e.HasIndex(x => x.ExpiresAt).HasDatabaseName("ix_sessions_expires_at");
});
}
}
@@ -0,0 +1,251 @@
// <auto-generated />
using System;
using Messenger.Api.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
#nullable disable
namespace Messenger.Api.Data.Migrations
{
[DbContext(typeof(MessengerDbContext))]
[Migration("20261023140810_InitialSchema")]
partial class InitialSchema
{
/// <inheritdoc />
protected override void BuildTargetModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder
.HasAnnotation("ProductVersion", "10.0.13")
.HasAnnotation("Relational:MaxIdentifierLength", 63);
NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
modelBuilder.Entity("Messenger.Api.Data.ChatEntity", b =>
{
b.Property<Guid>("Id")
.HasColumnType("uuid")
.HasColumnName("id");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("created_at");
b.Property<long>("HistoryVersion")
.ValueGeneratedOnAdd()
.HasColumnType("bigint")
.HasDefaultValue(0L)
.HasColumnName("history_version");
b.Property<string>("Title")
.IsRequired()
.HasMaxLength(100)
.HasColumnType("character varying(100)")
.HasColumnName("title");
b.HasKey("Id")
.HasName("pk_chats");
b.HasIndex("CreatedAt", "Id")
.HasDatabaseName("ix_chats_created_at_id");
b.ToTable("chats", null, t =>
{
t.HasCheckConstraint("ck_chats_history_version_nonneg", "history_version >= 0");
t.HasCheckConstraint("ck_chats_title_not_blank", "title ~ '\\S'");
});
});
modelBuilder.Entity("Messenger.Api.Data.ChatMemberEntity", b =>
{
b.Property<Guid>("ChatId")
.HasColumnType("uuid")
.HasColumnName("chat_id");
b.Property<Guid>("UserId")
.HasColumnType("uuid")
.HasColumnName("user_id");
b.HasKey("ChatId", "UserId")
.HasName("pk_chat_members");
b.HasIndex("UserId")
.HasDatabaseName("ix_chat_members_user_id");
b.ToTable("chat_members", (string)null);
});
modelBuilder.Entity("Messenger.Api.Data.MessageEntity", b =>
{
b.Property<Guid>("Id")
.HasColumnType("uuid")
.HasColumnName("id");
b.Property<Guid>("ChatId")
.HasColumnType("uuid")
.HasColumnName("chat_id");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("created_at");
b.Property<Guid>("SenderId")
.HasColumnType("uuid")
.HasColumnName("sender_id");
b.Property<string>("Text")
.IsRequired()
.HasMaxLength(4000)
.HasColumnType("character varying(4000)")
.HasColumnName("text");
b.HasKey("Id")
.HasName("pk_messages");
b.HasIndex("ChatId", "SenderId")
.HasDatabaseName("ix_messages_chat_id_sender_id");
b.HasIndex("ChatId", "CreatedAt", "Id")
.HasDatabaseName("ix_messages_chat_history");
b.ToTable("messages", null, t =>
{
t.HasCheckConstraint("ck_messages_text_not_blank", "text ~ '\\S'");
});
});
modelBuilder.Entity("Messenger.Api.Data.SessionEntity", b =>
{
b.Property<Guid>("Id")
.HasColumnType("uuid")
.HasColumnName("id");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("created_at");
b.Property<DateTimeOffset>("ExpiresAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("expires_at");
b.Property<DateTimeOffset?>("RevokedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("revoked_at");
b.Property<byte[]>("TokenHash")
.IsRequired()
.HasColumnType("bytea")
.HasColumnName("token_hash");
b.Property<Guid>("UserId")
.HasColumnType("uuid")
.HasColumnName("user_id");
b.HasKey("Id")
.HasName("pk_sessions");
b.HasIndex("ExpiresAt")
.HasDatabaseName("ix_sessions_expires_at");
b.HasIndex("TokenHash")
.IsUnique()
.HasDatabaseName("ux_sessions_token_hash");
b.HasIndex("UserId")
.HasDatabaseName("ix_sessions_user_id");
b.ToTable("sessions", null, t =>
{
t.HasCheckConstraint("ck_sessions_expiry_after_creation", "expires_at > created_at");
t.HasCheckConstraint("ck_sessions_token_hash_len", "octet_length(token_hash) = 32");
});
});
modelBuilder.Entity("Messenger.Api.Data.UserEntity", b =>
{
b.Property<Guid>("Id")
.HasColumnType("uuid")
.HasColumnName("id");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("created_at");
b.Property<string>("DisplayName")
.IsRequired()
.HasMaxLength(100)
.HasColumnType("character varying(100)")
.HasColumnName("display_name");
b.Property<string>("PasswordHash")
.IsRequired()
.HasColumnType("text")
.HasColumnName("password_hash");
b.Property<string>("Username")
.IsRequired()
.HasMaxLength(32)
.HasColumnType("character varying(32)")
.HasColumnName("username");
b.HasKey("Id")
.HasName("pk_users");
b.HasIndex("Username")
.IsUnique()
.HasDatabaseName("ux_users_username");
b.ToTable("users", null, t =>
{
t.HasCheckConstraint("ck_users_display_name_not_blank", "display_name ~ '\\S'");
t.HasCheckConstraint("ck_users_username_format", "username ~ '^[a-z0-9_]{3,32}$'");
});
});
modelBuilder.Entity("Messenger.Api.Data.ChatMemberEntity", b =>
{
b.HasOne("Messenger.Api.Data.ChatEntity", null)
.WithMany()
.HasForeignKey("ChatId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired()
.HasConstraintName("fk_chat_members_chats_chat_id");
b.HasOne("Messenger.Api.Data.UserEntity", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Restrict)
.IsRequired()
.HasConstraintName("fk_chat_members_users_user_id");
});
modelBuilder.Entity("Messenger.Api.Data.MessageEntity", b =>
{
b.HasOne("Messenger.Api.Data.ChatMemberEntity", null)
.WithMany()
.HasForeignKey("ChatId", "SenderId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired()
.HasConstraintName("fk_messages_chat_members_chat_id_sender_id");
});
modelBuilder.Entity("Messenger.Api.Data.SessionEntity", b =>
{
b.HasOne("Messenger.Api.Data.UserEntity", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired()
.HasConstraintName("fk_sessions_users_user_id");
});
#pragma warning restore 612, 618
}
}
}
@@ -0,0 +1,179 @@
using System;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace Messenger.Api.Data.Migrations
{
/// <inheritdoc />
public partial class InitialSchema : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "chats",
columns: table => new
{
id = table.Column<Guid>(type: "uuid", nullable: false),
title = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
created_at = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
history_version = table.Column<long>(type: "bigint", nullable: false, defaultValue: 0L)
},
constraints: table =>
{
table.PrimaryKey("pk_chats", x => x.id);
table.CheckConstraint("ck_chats_history_version_nonneg", "history_version >= 0");
table.CheckConstraint("ck_chats_title_not_blank", "title ~ '\\S'");
});
migrationBuilder.CreateTable(
name: "users",
columns: table => new
{
id = table.Column<Guid>(type: "uuid", nullable: false),
username = table.Column<string>(type: "character varying(32)", maxLength: 32, nullable: false),
display_name = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
password_hash = table.Column<string>(type: "text", nullable: false),
created_at = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("pk_users", x => x.id);
table.CheckConstraint("ck_users_display_name_not_blank", "display_name ~ '\\S'");
table.CheckConstraint("ck_users_username_format", "username ~ '^[a-z0-9_]{3,32}$'");
});
migrationBuilder.CreateTable(
name: "chat_members",
columns: table => new
{
chat_id = table.Column<Guid>(type: "uuid", nullable: false),
user_id = table.Column<Guid>(type: "uuid", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("pk_chat_members", x => new { x.chat_id, x.user_id });
table.ForeignKey(
name: "fk_chat_members_chats_chat_id",
column: x => x.chat_id,
principalTable: "chats",
principalColumn: "id",
onDelete: ReferentialAction.Cascade);
table.ForeignKey(
name: "fk_chat_members_users_user_id",
column: x => x.user_id,
principalTable: "users",
principalColumn: "id",
onDelete: ReferentialAction.Restrict);
});
migrationBuilder.CreateTable(
name: "sessions",
columns: table => new
{
id = table.Column<Guid>(type: "uuid", nullable: false),
token_hash = table.Column<byte[]>(type: "bytea", nullable: false),
user_id = table.Column<Guid>(type: "uuid", nullable: false),
created_at = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
expires_at = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
revoked_at = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("pk_sessions", x => x.id);
table.CheckConstraint("ck_sessions_expiry_after_creation", "expires_at > created_at");
table.CheckConstraint("ck_sessions_token_hash_len", "octet_length(token_hash) = 32");
table.ForeignKey(
name: "fk_sessions_users_user_id",
column: x => x.user_id,
principalTable: "users",
principalColumn: "id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "messages",
columns: table => new
{
id = table.Column<Guid>(type: "uuid", nullable: false),
chat_id = table.Column<Guid>(type: "uuid", nullable: false),
sender_id = table.Column<Guid>(type: "uuid", nullable: false),
text = table.Column<string>(type: "character varying(4000)", maxLength: 4000, nullable: false),
created_at = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("pk_messages", x => x.id);
table.CheckConstraint("ck_messages_text_not_blank", "text ~ '\\S'");
table.ForeignKey(
name: "fk_messages_chat_members_chat_id_sender_id",
columns: x => new { x.chat_id, x.sender_id },
principalTable: "chat_members",
principalColumns: new[] { "chat_id", "user_id" },
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateIndex(
name: "ix_chat_members_user_id",
table: "chat_members",
column: "user_id");
migrationBuilder.CreateIndex(
name: "ix_chats_created_at_id",
table: "chats",
columns: new[] { "created_at", "id" });
migrationBuilder.CreateIndex(
name: "ix_messages_chat_history",
table: "messages",
columns: new[] { "chat_id", "created_at", "id" });
migrationBuilder.CreateIndex(
name: "ix_messages_chat_id_sender_id",
table: "messages",
columns: new[] { "chat_id", "sender_id" });
migrationBuilder.CreateIndex(
name: "ix_sessions_expires_at",
table: "sessions",
column: "expires_at");
migrationBuilder.CreateIndex(
name: "ix_sessions_user_id",
table: "sessions",
column: "user_id");
migrationBuilder.CreateIndex(
name: "ux_sessions_token_hash",
table: "sessions",
column: "token_hash",
unique: true);
migrationBuilder.CreateIndex(
name: "ux_users_username",
table: "users",
column: "username",
unique: true);
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(
name: "messages");
migrationBuilder.DropTable(
name: "sessions");
migrationBuilder.DropTable(
name: "chat_members");
migrationBuilder.DropTable(
name: "chats");
migrationBuilder.DropTable(
name: "users");
}
}
}
@@ -0,0 +1,255 @@
// <auto-generated />
using System;
using Messenger.Api.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
#nullable disable
namespace Messenger.Api.Data.Migrations
{
[DbContext(typeof(MessengerDbContext))]
[Migration("20261023170730_AddChatLastMessageAt")]
partial class AddChatLastMessageAt
{
/// <inheritdoc />
protected override void BuildTargetModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder
.HasAnnotation("ProductVersion", "10.0.13")
.HasAnnotation("Relational:MaxIdentifierLength", 63);
NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
modelBuilder.Entity("Messenger.Api.Data.ChatEntity", b =>
{
b.Property<Guid>("Id")
.HasColumnType("uuid")
.HasColumnName("id");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("created_at");
b.Property<long>("HistoryVersion")
.ValueGeneratedOnAdd()
.HasColumnType("bigint")
.HasDefaultValue(0L)
.HasColumnName("history_version");
b.Property<DateTimeOffset?>("LastMessageAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("last_message_at");
b.Property<string>("Title")
.IsRequired()
.HasMaxLength(100)
.HasColumnType("character varying(100)")
.HasColumnName("title");
b.HasKey("Id")
.HasName("pk_chats");
b.HasIndex("CreatedAt", "Id")
.HasDatabaseName("ix_chats_created_at_id");
b.ToTable("chats", null, t =>
{
t.HasCheckConstraint("ck_chats_history_version_nonneg", "history_version >= 0");
t.HasCheckConstraint("ck_chats_title_not_blank", "title ~ '\\S'");
});
});
modelBuilder.Entity("Messenger.Api.Data.ChatMemberEntity", b =>
{
b.Property<Guid>("ChatId")
.HasColumnType("uuid")
.HasColumnName("chat_id");
b.Property<Guid>("UserId")
.HasColumnType("uuid")
.HasColumnName("user_id");
b.HasKey("ChatId", "UserId")
.HasName("pk_chat_members");
b.HasIndex("UserId")
.HasDatabaseName("ix_chat_members_user_id");
b.ToTable("chat_members", (string)null);
});
modelBuilder.Entity("Messenger.Api.Data.MessageEntity", b =>
{
b.Property<Guid>("Id")
.HasColumnType("uuid")
.HasColumnName("id");
b.Property<Guid>("ChatId")
.HasColumnType("uuid")
.HasColumnName("chat_id");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("created_at");
b.Property<Guid>("SenderId")
.HasColumnType("uuid")
.HasColumnName("sender_id");
b.Property<string>("Text")
.IsRequired()
.HasMaxLength(4000)
.HasColumnType("character varying(4000)")
.HasColumnName("text");
b.HasKey("Id")
.HasName("pk_messages");
b.HasIndex("ChatId", "SenderId")
.HasDatabaseName("ix_messages_chat_id_sender_id");
b.HasIndex("ChatId", "CreatedAt", "Id")
.HasDatabaseName("ix_messages_chat_history");
b.ToTable("messages", null, t =>
{
t.HasCheckConstraint("ck_messages_text_not_blank", "text ~ '\\S'");
});
});
modelBuilder.Entity("Messenger.Api.Data.SessionEntity", b =>
{
b.Property<Guid>("Id")
.HasColumnType("uuid")
.HasColumnName("id");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("created_at");
b.Property<DateTimeOffset>("ExpiresAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("expires_at");
b.Property<DateTimeOffset?>("RevokedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("revoked_at");
b.Property<byte[]>("TokenHash")
.IsRequired()
.HasColumnType("bytea")
.HasColumnName("token_hash");
b.Property<Guid>("UserId")
.HasColumnType("uuid")
.HasColumnName("user_id");
b.HasKey("Id")
.HasName("pk_sessions");
b.HasIndex("ExpiresAt")
.HasDatabaseName("ix_sessions_expires_at");
b.HasIndex("TokenHash")
.IsUnique()
.HasDatabaseName("ux_sessions_token_hash");
b.HasIndex("UserId")
.HasDatabaseName("ix_sessions_user_id");
b.ToTable("sessions", null, t =>
{
t.HasCheckConstraint("ck_sessions_expiry_after_creation", "expires_at > created_at");
t.HasCheckConstraint("ck_sessions_token_hash_len", "octet_length(token_hash) = 32");
});
});
modelBuilder.Entity("Messenger.Api.Data.UserEntity", b =>
{
b.Property<Guid>("Id")
.HasColumnType("uuid")
.HasColumnName("id");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("created_at");
b.Property<string>("DisplayName")
.IsRequired()
.HasMaxLength(100)
.HasColumnType("character varying(100)")
.HasColumnName("display_name");
b.Property<string>("PasswordHash")
.IsRequired()
.HasColumnType("text")
.HasColumnName("password_hash");
b.Property<string>("Username")
.IsRequired()
.HasMaxLength(32)
.HasColumnType("character varying(32)")
.HasColumnName("username");
b.HasKey("Id")
.HasName("pk_users");
b.HasIndex("Username")
.IsUnique()
.HasDatabaseName("ux_users_username");
b.ToTable("users", null, t =>
{
t.HasCheckConstraint("ck_users_display_name_not_blank", "display_name ~ '\\S'");
t.HasCheckConstraint("ck_users_username_format", "username ~ '^[a-z0-9_]{3,32}$'");
});
});
modelBuilder.Entity("Messenger.Api.Data.ChatMemberEntity", b =>
{
b.HasOne("Messenger.Api.Data.ChatEntity", null)
.WithMany()
.HasForeignKey("ChatId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired()
.HasConstraintName("fk_chat_members_chats_chat_id");
b.HasOne("Messenger.Api.Data.UserEntity", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Restrict)
.IsRequired()
.HasConstraintName("fk_chat_members_users_user_id");
});
modelBuilder.Entity("Messenger.Api.Data.MessageEntity", b =>
{
b.HasOne("Messenger.Api.Data.ChatMemberEntity", null)
.WithMany()
.HasForeignKey("ChatId", "SenderId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired()
.HasConstraintName("fk_messages_chat_members_chat_id_sender_id");
});
modelBuilder.Entity("Messenger.Api.Data.SessionEntity", b =>
{
b.HasOne("Messenger.Api.Data.UserEntity", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired()
.HasConstraintName("fk_sessions_users_user_id");
});
#pragma warning restore 612, 618
}
}
}
@@ -0,0 +1,29 @@
using System;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace Messenger.Api.Data.Migrations
{
/// <inheritdoc />
public partial class AddChatLastMessageAt : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.AddColumn<DateTimeOffset>(
name: "last_message_at",
table: "chats",
type: "timestamp with time zone",
nullable: true);
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropColumn(
name: "last_message_at",
table: "chats");
}
}
}
@@ -0,0 +1,252 @@
// <auto-generated />
using System;
using Messenger.Api.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
#nullable disable
namespace Messenger.Api.Data.Migrations
{
[DbContext(typeof(MessengerDbContext))]
partial class MessengerDbContextModelSnapshot : ModelSnapshot
{
protected override void BuildModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder
.HasAnnotation("ProductVersion", "10.0.13")
.HasAnnotation("Relational:MaxIdentifierLength", 63);
NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
modelBuilder.Entity("Messenger.Api.Data.ChatEntity", b =>
{
b.Property<Guid>("Id")
.HasColumnType("uuid")
.HasColumnName("id");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("created_at");
b.Property<long>("HistoryVersion")
.ValueGeneratedOnAdd()
.HasColumnType("bigint")
.HasDefaultValue(0L)
.HasColumnName("history_version");
b.Property<DateTimeOffset?>("LastMessageAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("last_message_at");
b.Property<string>("Title")
.IsRequired()
.HasMaxLength(100)
.HasColumnType("character varying(100)")
.HasColumnName("title");
b.HasKey("Id")
.HasName("pk_chats");
b.HasIndex("CreatedAt", "Id")
.HasDatabaseName("ix_chats_created_at_id");
b.ToTable("chats", null, t =>
{
t.HasCheckConstraint("ck_chats_history_version_nonneg", "history_version >= 0");
t.HasCheckConstraint("ck_chats_title_not_blank", "title ~ '\\S'");
});
});
modelBuilder.Entity("Messenger.Api.Data.ChatMemberEntity", b =>
{
b.Property<Guid>("ChatId")
.HasColumnType("uuid")
.HasColumnName("chat_id");
b.Property<Guid>("UserId")
.HasColumnType("uuid")
.HasColumnName("user_id");
b.HasKey("ChatId", "UserId")
.HasName("pk_chat_members");
b.HasIndex("UserId")
.HasDatabaseName("ix_chat_members_user_id");
b.ToTable("chat_members", (string)null);
});
modelBuilder.Entity("Messenger.Api.Data.MessageEntity", b =>
{
b.Property<Guid>("Id")
.HasColumnType("uuid")
.HasColumnName("id");
b.Property<Guid>("ChatId")
.HasColumnType("uuid")
.HasColumnName("chat_id");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("created_at");
b.Property<Guid>("SenderId")
.HasColumnType("uuid")
.HasColumnName("sender_id");
b.Property<string>("Text")
.IsRequired()
.HasMaxLength(4000)
.HasColumnType("character varying(4000)")
.HasColumnName("text");
b.HasKey("Id")
.HasName("pk_messages");
b.HasIndex("ChatId", "SenderId")
.HasDatabaseName("ix_messages_chat_id_sender_id");
b.HasIndex("ChatId", "CreatedAt", "Id")
.HasDatabaseName("ix_messages_chat_history");
b.ToTable("messages", null, t =>
{
t.HasCheckConstraint("ck_messages_text_not_blank", "text ~ '\\S'");
});
});
modelBuilder.Entity("Messenger.Api.Data.SessionEntity", b =>
{
b.Property<Guid>("Id")
.HasColumnType("uuid")
.HasColumnName("id");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("created_at");
b.Property<DateTimeOffset>("ExpiresAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("expires_at");
b.Property<DateTimeOffset?>("RevokedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("revoked_at");
b.Property<byte[]>("TokenHash")
.IsRequired()
.HasColumnType("bytea")
.HasColumnName("token_hash");
b.Property<Guid>("UserId")
.HasColumnType("uuid")
.HasColumnName("user_id");
b.HasKey("Id")
.HasName("pk_sessions");
b.HasIndex("ExpiresAt")
.HasDatabaseName("ix_sessions_expires_at");
b.HasIndex("TokenHash")
.IsUnique()
.HasDatabaseName("ux_sessions_token_hash");
b.HasIndex("UserId")
.HasDatabaseName("ix_sessions_user_id");
b.ToTable("sessions", null, t =>
{
t.HasCheckConstraint("ck_sessions_expiry_after_creation", "expires_at > created_at");
t.HasCheckConstraint("ck_sessions_token_hash_len", "octet_length(token_hash) = 32");
});
});
modelBuilder.Entity("Messenger.Api.Data.UserEntity", b =>
{
b.Property<Guid>("Id")
.HasColumnType("uuid")
.HasColumnName("id");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("timestamp with time zone")
.HasColumnName("created_at");
b.Property<string>("DisplayName")
.IsRequired()
.HasMaxLength(100)
.HasColumnType("character varying(100)")
.HasColumnName("display_name");
b.Property<string>("PasswordHash")
.IsRequired()
.HasColumnType("text")
.HasColumnName("password_hash");
b.Property<string>("Username")
.IsRequired()
.HasMaxLength(32)
.HasColumnType("character varying(32)")
.HasColumnName("username");
b.HasKey("Id")
.HasName("pk_users");
b.HasIndex("Username")
.IsUnique()
.HasDatabaseName("ux_users_username");
b.ToTable("users", null, t =>
{
t.HasCheckConstraint("ck_users_display_name_not_blank", "display_name ~ '\\S'");
t.HasCheckConstraint("ck_users_username_format", "username ~ '^[a-z0-9_]{3,32}$'");
});
});
modelBuilder.Entity("Messenger.Api.Data.ChatMemberEntity", b =>
{
b.HasOne("Messenger.Api.Data.ChatEntity", null)
.WithMany()
.HasForeignKey("ChatId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired()
.HasConstraintName("fk_chat_members_chats_chat_id");
b.HasOne("Messenger.Api.Data.UserEntity", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Restrict)
.IsRequired()
.HasConstraintName("fk_chat_members_users_user_id");
});
modelBuilder.Entity("Messenger.Api.Data.MessageEntity", b =>
{
b.HasOne("Messenger.Api.Data.ChatMemberEntity", null)
.WithMany()
.HasForeignKey("ChatId", "SenderId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired()
.HasConstraintName("fk_messages_chat_members_chat_id_sender_id");
});
modelBuilder.Entity("Messenger.Api.Data.SessionEntity", b =>
{
b.HasOne("Messenger.Api.Data.UserEntity", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired()
.HasConstraintName("fk_sessions_users_user_id");
});
#pragma warning restore 612, 618
}
}
}
@@ -0,0 +1,146 @@
using System.Text;
using Messenger.Api.Data;
using Messenger.Api.Models;
using Messenger.Api.Services;
using Microsoft.EntityFrameworkCore;
namespace Messenger.Api.Endpoints;
public static class AuthEndpoints
{
private const string BasicChallenge = "Basic realm=\"messenger\", charset=\"UTF-8\"";
public static IEndpointRouteBuilder MapAuthEndpoints(this IEndpointRouteBuilder endpoints)
{
endpoints.MapPost("/api/v1/auth/sessions", CreateSession);
endpoints.MapDelete("/api/v1/auth/sessions/current", RevokeCurrentSession).RequireAuthorization();
return endpoints;
}
private static async Task<IResult> CreateSession(
HttpContext httpContext,
MessengerDbContext db,
IPasswordHasher hasher,
AuthSessionOptions options,
CancellationToken ct)
{
// Любая проблема с заголовком или credentials даёт один и тот же ответ.
var unauthorized = () => ApiErrors.Unauthorized(httpContext, BasicChallenge, "Неверное имя пользователя или пароль");
if (!TryParseBasic(httpContext.Request, out var username, out var password))
{
return unauthorized();
}
var user = await db.Users.AsNoTracking().FirstOrDefaultAsync(u => u.Username == username, ct);
// Проверка выполняется и для несуществующего пользователя (null → заглушка), чтобы время ответа
// не выдавало, существует ли username.
bool passwordOk;
try
{
passwordOk = await hasher.VerifyAsync(user?.PasswordHash, password, ct);
}
catch (PasswordHasherBusyException)
{
return ApiErrors.Error(httpContext, 503, "unavailable", "Сервис временно перегружен, повторите запрос позже");
}
if (user is null || !passwordOk)
{
return unauthorized();
}
var token = SessionTokens.Generate();
var now = Timestamps.UtcNowMilliseconds();
var session = new SessionEntity
{
Id = Guid.CreateVersion7(),
TokenHash = SessionTokens.Hash(token),
UserId = user.Id,
CreatedAt = now,
ExpiresAt = now + options.Ttl
};
db.Sessions.Add(session);
await db.SaveChangesAsync(ct);
// Ответ с токеном нельзя кэшировать промежуточными узлами.
httpContext.Response.Headers.CacheControl = "no-store";
return Results.Json(
new SessionResponse(
token,
"Bearer",
session.ExpiresAt,
new User
{
Id = user.Id,
Username = user.Username,
DisplayName = user.DisplayName,
CreatedAt = user.CreatedAt
}),
statusCode: StatusCodes.Status201Created);
}
private static async Task<IResult> RevokeCurrentSession(
HttpContext httpContext,
MessengerDbContext db,
CancellationToken ct)
{
var sessionId = httpContext.GetSessionId();
var now = Timestamps.UtcNowMilliseconds();
// Один UPDATE с условием: отзыв атомарен даже при двух параллельных DELETE с одним токеном.
var revoked = await db.Sessions
.Where(s => s.Id == sessionId && s.RevokedAt == null)
.ExecuteUpdateAsync(s => s.SetProperty(x => x.RevokedAt, now), ct);
return revoked == 0
? ApiErrors.Unauthorized(httpContext, BearerAuth.Challenge, "Требуется действительный Bearer-токен")
: Results.NoContent();
}
// Basic: base64("username:password"), разделитель — ПЕРВОЕ двоеточие (в пароле двоеточие допустимо).
// Всё, что не разбирается строго (схема, base64, UTF-8, формат), считается неверными credentials.
private static bool TryParseBasic(HttpRequest request, out string username, out string password)
{
username = password = string.Empty;
if (request.Headers.Authorization.Count != 1)
{
return false;
}
var header = request.Headers.Authorization[0];
const string prefix = "Basic ";
if (header is null || !header.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
{
return false;
}
string decoded;
try
{
var bytes = Convert.FromBase64String(header[prefix.Length..].Trim());
decoded = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true).GetString(bytes);
}
catch (Exception ex) when (ex is FormatException or DecoderFallbackException)
{
return false;
}
var separator = decoded.IndexOf(':');
if (separator <= 0)
{
return false;
}
username = decoded[..separator];
password = decoded[(separator + 1)..];
// Username по контракту — ASCII [a-z0-9_]{3,32}; пароль — 12..128 code points. Отсекаем до дорогого Argon2.
var length = ApiErrors.CodePoints(password);
return username.Length is >= 3 and <= 32 && length is >= 12 and <= 128;
}
}
@@ -0,0 +1,158 @@
using Messenger.Api.Data;
using Messenger.Api.Models;
using Messenger.Api.Services;
using Microsoft.EntityFrameworkCore;
using Npgsql;
namespace Messenger.Api.Endpoints;
public static class ChatEndpoints
{
public static IEndpointRouteBuilder MapChatEndpoints(
this IEndpointRouteBuilder endpoints)
{
endpoints.MapPost("/api/v1/chats", CreateChat).RequireAuthorization();
endpoints.MapGet("/api/v1/chats", ListChats).RequireAuthorization();
endpoints.MapGet("/api/v1/chats/{chatId}", GetChat).RequireAuthorization();
return endpoints;
}
private static async Task<IResult> CreateChat(
CreateChatRequest request,
HttpContext httpContext,
MessengerDbContext db,
CancellationToken ct)
{
var userId = httpContext.GetUserId();
if (string.IsNullOrWhiteSpace(request.Title) ||
ApiErrors.CodePoints(request.Title) > 100 ||
request.MemberIds.Count is < 1 or > 100 ||
request.MemberIds.Distinct().Count() != request.MemberIds.Count)
{
return ApiErrors.Error(httpContext, 400, "invalid_request", "Некорректные данные чата");
}
if (!request.MemberIds.Contains(userId))
{
return ApiErrors.Error(httpContext, 400, "invalid_request", "Создатель должен быть участником чата");
}
var knownMembers = await db.Users.CountAsync(u => request.MemberIds.Contains(u.Id), ct);
if (knownMembers != request.MemberIds.Count)
{
return ApiErrors.Error(httpContext, 400, "invalid_request", "Неизвестный участник чата");
}
var chat = new ChatEntity
{
Id = Guid.CreateVersion7(),
Title = request.Title,
CreatedAt = Timestamps.UtcNowMilliseconds()
};
// Чат и все его участники сохраняются одним SaveChanges, то есть одной транзакцией:
// либо создано всё, либо ничего (нет чата без участников).
db.Chats.Add(chat);
db.ChatMembers.AddRange(request.MemberIds.Select(id => new ChatMemberEntity { ChatId = chat.Id, UserId = id }));
try
{
await db.SaveChangesAsync(ct);
}
catch (DbUpdateException ex) when (ex.InnerException is PostgresException { SqlState: PostgresErrorCodes.ForeignKeyViolation })
{
return ApiErrors.Error(httpContext, 400, "invalid_request", "Неизвестный участник чата");
}
return Results.Created($"/api/v1/chats/{chat.Id}", ToDto(chat, request.MemberIds.Order().ToList()));
}
private static async Task<IResult> ListChats(
int? limit,
string? cursor,
HttpContext httpContext,
MessengerDbContext db,
CancellationToken ct)
{
var userId = httpContext.GetUserId();
var pageSize = limit ?? 50;
if (pageSize is < 1 or > 100 || !Cursors.TryDecode(cursor, Cursors.Chats, out var after))
{
return ApiErrors.Error(httpContext, 400, "invalid_request", "Некорректные параметры пагинации");
}
// Keyset: строковое сравнение (created_at, id) > (курсор), без OFFSET и без просмотра всей выдачи.
IQueryable<ChatEntity> source = after is null
? db.Chats.FromSql($"""
SELECT c.* FROM chats c
WHERE EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = {userId})
""")
: db.Chats.FromSql($"""
SELECT c.* FROM chats c
WHERE EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = {userId})
AND (c.created_at, c.id) > ({after.Value.CreatedAt}, {after.Value.Id})
""");
var chats = await source
.AsNoTracking()
.OrderBy(c => c.CreatedAt).ThenBy(c => c.Id)
.Take(pageSize + 1)
.ToListAsync(ct);
var hasNext = chats.Count > pageSize;
if (hasNext)
{
chats.RemoveAt(chats.Count - 1);
}
var ids = chats.Select(c => c.Id).ToList();
var members = (await db.ChatMembers
.AsNoTracking()
.Where(m => ids.Contains(m.ChatId))
.Select(m => new { m.ChatId, m.UserId })
.ToListAsync(ct))
.ToLookup(m => m.ChatId, m => m.UserId);
var items = chats.Select(c => ToDto(c, members[c.Id].Order().ToList())).ToList();
var nextCursor = hasNext ? Cursors.Encode(Cursors.Chats, chats[^1].CreatedAt, chats[^1].Id) : null;
return Results.Ok(new { items, next_cursor = nextCursor });
}
private static async Task<IResult> GetChat(
Guid chatId,
HttpContext httpContext,
MessengerDbContext db,
CancellationToken ct)
{
var userId = httpContext.GetUserId();
// Отсутствующий и чужой чат неразличимы: оба дают 404.
var chat = await db.Chats
.AsNoTracking()
.FirstOrDefaultAsync(c => c.Id == chatId && db.ChatMembers.Any(m => m.ChatId == c.Id && m.UserId == userId), ct);
if (chat is null)
{
return ApiErrors.Error(httpContext, 404, "not_found", "Объект не найден");
}
var memberIds = await db.ChatMembers
.AsNoTracking()
.Where(m => m.ChatId == chatId)
.Select(m => m.UserId)
.ToListAsync(ct);
return Results.Ok(ToDto(chat, memberIds.Order().ToList()));
}
private static Chat ToDto(ChatEntity chat, List<Guid> memberIds) => new()
{
Id = chat.Id,
Title = chat.Title,
MemberIds = memberIds,
CreatedAt = chat.CreatedAt
};
}
@@ -0,0 +1,200 @@
using Messenger.Api.Data;
using Messenger.Api.Models;
using Messenger.Api.Services;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Storage;
using Microsoft.Extensions.Options;
using Npgsql;
namespace Messenger.Api.Endpoints;
public static class MessageEndpoints
{
public static IEndpointRouteBuilder MapMessageEndpoints(
this IEndpointRouteBuilder endpoints)
{
endpoints.MapPost("/api/v1/chats/{chatId}/messages", CreateMessage).RequireAuthorization();
endpoints.MapGet("/api/v1/chats/{chatId}/messages", ListMessages).RequireAuthorization();
return endpoints;
}
private static async Task<IResult> CreateMessage(
Guid chatId,
CreateMessageRequest request,
HttpContext httpContext,
MessengerDbContext db,
CancellationToken ct)
{
var userId = httpContext.GetUserId();
// Сначала доступ к ресурсу (404 для постороннего), затем валидация тела.
if (!await IsMemberAsync(db, chatId, userId, ct))
{
return ApiErrors.Error(httpContext, 404, "not_found", "Объект не найден");
}
if (string.IsNullOrWhiteSpace(request.Text) || ApiErrors.CodePoints(request.Text) > 4000)
{
return ApiErrors.Error(httpContext, 400, "invalid_request", "Некорректный текст сообщения");
}
// Транзакция: (1) UPDATE чата берёт блокировку его строки и выдаёт created_at, (2) INSERT сообщения, (3) COMMIT.
// Записи в один чат идут строго по очереди, поэтому порядок коммитов совпадает с порядком (created_at, id)
// и курсор не может «проскочить» сообщение, закоммиченное позже. Версия истории растёт в той же транзакции.
await using var tx = await db.Database.BeginTransactionAsync(ct);
var createdAt = await ReserveMessageSlotAsync(db, tx, chatId, userId, ct);
if (createdAt is null)
{
return ApiErrors.Error(httpContext, 404, "not_found", "Объект не найден");
}
var message = new MessageEntity
{
Id = Guid.CreateVersion7(),
ChatId = chatId,
SenderId = userId,
Text = request.Text,
CreatedAt = createdAt.Value
};
db.Messages.Add(message);
try
{
await db.SaveChangesAsync(ct);
}
catch (DbUpdateException ex) when (ex.InnerException is PostgresException { SqlState: PostgresErrorCodes.CheckViolation })
{
return ApiErrors.Error(httpContext, 400, "invalid_request", "Некорректный текст сообщения");
}
await tx.CommitAsync(ct);
return Results.Created($"/api/v1/chats/{chatId}/messages", ToDto(message));
}
private static async Task<IResult> ListMessages(
Guid chatId,
int? limit,
string? cursor,
HttpContext httpContext,
MessengerDbContext db,
IMessageHistoryCache cache,
DiagnosticsSettings diagnostics,
IOptions<Microsoft.AspNetCore.Http.Json.JsonOptions> jsonOptions,
CancellationToken ct)
{
var userId = httpContext.GetUserId();
var pageSize = limit ?? 50;
// Один запрос проверяет доступ (null → 404) и читает актуальную версию истории из PostgreSQL.
// Версия берётся из БД при каждом чтении, а не из кэша: после подтверждённой записи ключ гарантированно новый.
var version = await db.Chats
.AsNoTracking()
.Where(c => c.Id == chatId && db.ChatMembers.Any(m => m.ChatId == c.Id && m.UserId == userId))
.Select(c => (long?)c.HistoryVersion)
.FirstOrDefaultAsync(ct);
if (version is null)
{
return ApiErrors.Error(httpContext, 404, "not_found", "Объект не найден");
}
if (pageSize is < 1 or > 100 || !Cursors.TryDecode(cursor, Cursors.Messages(chatId), out var after))
{
return ApiErrors.Error(httpContext, 400, "invalid_request", "Некорректные параметры пагинации");
}
// Ключ = чат + версия истории + размер страницы + курсор. Страница под этим ключом никогда не устаревает:
// любая запись увеличивает версию, и читатели переходят на другой ключ.
var key = $"hist:{chatId:N}:v{version}:l{pageSize}:{cursor ?? "-"}";
var (cached, status) = await cache.GetAsync(key, ct);
if (cached is not null)
{
return CachedJson(httpContext, diagnostics, cached, status);
}
// Keyset по индексу (chat_id, created_at, id): читается только страница, а не вся история.
IQueryable<MessageEntity> source = after is null
? db.Messages.FromSql($"SELECT * FROM messages WHERE chat_id = {chatId}")
: db.Messages.FromSql($"""
SELECT * FROM messages
WHERE chat_id = {chatId} AND (created_at, id) > ({after.Value.CreatedAt}, {after.Value.Id})
""");
var messages = await source
.AsNoTracking()
.OrderBy(m => m.CreatedAt).ThenBy(m => m.Id)
.Take(pageSize + 1)
.ToListAsync(ct);
var hasNext = messages.Count > pageSize;
if (hasNext)
{
messages.RemoveAt(messages.Count - 1);
}
var nextCursor = hasNext
? Cursors.Encode(Cursors.Messages(chatId), messages[^1].CreatedAt, messages[^1].Id)
: null;
var json = System.Text.Json.JsonSerializer.Serialize(
new { items = messages.Select(ToDto).ToList(), next_cursor = nextCursor },
jsonOptions.Value.SerializerOptions);
await cache.SetAsync(key, json, ct);
return CachedJson(httpContext, diagnostics, json, status);
}
// Ответ из кэша и ответ из БД байт-в-байт одинаковы: сериализуется одна и та же структура теми же настройками.
private static IResult CachedJson(HttpContext context, DiagnosticsSettings diagnostics, string json, CacheStatus status)
{
if (diagnostics.Headers)
{
context.Response.Headers["X-Cache"] = status.ToString().ToLowerInvariant();
}
return Results.Content(json, "application/json; charset=utf-8");
}
private static Task<bool> IsMemberAsync(MessengerDbContext db, Guid chatId, Guid userId, CancellationToken ct) =>
db.ChatMembers.AnyAsync(m => m.ChatId == chatId && m.UserId == userId, ct);
// Атомарно: проверяет членство, увеличивает версию истории и возвращает created_at нового сообщения —
// строго больше времени предыдущего (даже при откате системных часов или двух сообщениях в одну миллисекунду).
// null — чата нет или пользователь не участник.
private static async Task<DateTimeOffset?> ReserveMessageSlotAsync(
MessengerDbContext db,
IDbContextTransaction tx,
Guid chatId,
Guid userId,
CancellationToken ct)
{
var connection = (NpgsqlConnection)db.Database.GetDbConnection();
await using var command = new NpgsqlCommand("""
UPDATE chats c
SET history_version = c.history_version + 1,
last_message_at = GREATEST(@now, COALESCE(c.last_message_at + interval '1 millisecond', @now))
WHERE c.id = @chat
AND EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = @user)
RETURNING c.last_message_at
""", connection, (NpgsqlTransaction)tx.GetDbTransaction());
command.Parameters.AddWithValue("now", Timestamps.UtcNowMilliseconds());
command.Parameters.AddWithValue("chat", chatId);
command.Parameters.AddWithValue("user", userId);
await using var reader = await command.ExecuteReaderAsync(ct);
return await reader.ReadAsync(ct) ? reader.GetFieldValue<DateTimeOffset>(0) : null;
}
private static Message ToDto(MessageEntity m) => new()
{
Id = m.Id,
ChatId = m.ChatId,
SenderId = m.SenderId,
Text = m.Text,
CreatedAt = m.CreatedAt
};
}
@@ -0,0 +1,125 @@
using System.Text.RegularExpressions;
using Messenger.Api.Models;
using Messenger.Api.Services;
using Microsoft.EntityFrameworkCore;
using Messenger.Api.Data;
using Npgsql;
namespace Messenger.Api.Endpoints;
public static class UserEndpoints
{
public static IEndpointRouteBuilder MapUserEndpoints(
this IEndpointRouteBuilder endpoints)
{
endpoints.MapPost(
"/api/v1/users",
CreateUser);
endpoints.MapGet(
"/api/v1/users/me",
GetCurrentUser).RequireAuthorization();
return endpoints;
}
private static async Task<IResult> CreateUser(
CreateUserRequest request,
HttpContext httpContext,
MessengerDbContext db,
IPasswordHasher hasher,
CancellationToken ct)
{
if (!Regex.IsMatch(request.Username, @"\A[a-z0-9_]{3,32}\z"))
{
return ApiErrors.Error(httpContext, 400, "invalid_request", "Некорректный username");
}
if (string.IsNullOrWhiteSpace(request.DisplayName) ||
ApiErrors.CodePoints(request.DisplayName) > 100)
{
return ApiErrors.Error(httpContext, 400, "invalid_request", "display_name должен содержать от 1 до 100 символов");
}
var passwordLength = ApiErrors.CodePoints(request.Password);
if (passwordLength < 12 || passwordLength > 128)
{
return ApiErrors.Error(httpContext, 400, "invalid_request", "Пароль должен содержать от 12 до 128 символов");
}
// Быстрый отказ, чтобы не тратить дорогой Argon2 на заведомо занятый username.
// Это только оптимизация: от гонки защищает уникальный индекс (см. catch ниже).
if (await db.Users.AnyAsync(u => u.Username == request.Username, ct))
{
return ApiErrors.Error(httpContext, 409, "conflict", "Username уже занят");
}
// Хеш считается до SaveChanges: соединение с БД не простаивает на CPU-работе.
string passwordHash;
try
{
passwordHash = await hasher.HashAsync(request.Password, ct);
}
catch (PasswordHasherBusyException)
{
return ApiErrors.Error(httpContext, 503, "unavailable", "Сервис временно перегружен, повторите запрос позже");
}
var entity = new UserEntity
{
Id = Guid.CreateVersion7(),
Username = request.Username,
DisplayName = request.DisplayName,
PasswordHash = passwordHash,
CreatedAt = Timestamps.UtcNowMilliseconds()
};
db.Users.Add(entity);
try
{
await db.SaveChangesAsync(ct);
}
catch (DbUpdateException ex) when (
ex.InnerException is PostgresException { SqlState: PostgresErrorCodes.UniqueViolation, ConstraintName: "ux_users_username" })
{
// Параллельный запрос с тем же username успел раньше проверки AnyAsync.
return ApiErrors.Error(httpContext, 409, "conflict", "Username уже занят");
}
// В ответ уходит API-модель без password_hash, а не сущность таблицы.
var user = new User
{
Id = entity.Id,
Username = entity.Username,
DisplayName = entity.DisplayName,
CreatedAt = entity.CreatedAt
};
return Results.Created($"/api/v1/users/{user.Id}", user);
}
private static async Task<IResult> GetCurrentUser(
HttpContext httpContext,
MessengerDbContext db,
CancellationToken ct)
{
var userId = httpContext.GetUserId();
var user = await db.Users
.AsNoTracking()
.Where(u => u.Id == userId)
.Select(u => new User
{
Id = u.Id,
Username = u.Username,
DisplayName = u.DisplayName,
CreatedAt = u.CreatedAt
})
.FirstOrDefaultAsync(ct);
// Сессия ссылается на пользователя внешним ключом, поэтому null здесь невозможен; ответ всё равно безопасный.
return user is null
? ApiErrors.Unauthorized(httpContext, BearerAuth.Challenge, "Требуется действительный Bearer-токен")
: Results.Ok(user);
}
}
+25
View File
@@ -0,0 +1,25 @@
<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<TargetFramework>net10.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
</PropertyGroup>
<ItemGroup>
<Folder Include="Services\" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="EFCore.NamingConventions" Version="10.0.1" />
<PackageReference Include="Isopoh.Cryptography.Argon2" Version="2.0.0" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.13">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
<PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="10.0.13" />
<PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="10.0.3" />
<PackageReference Include="StackExchange.Redis" Version="3.4.20" />
</ItemGroup>
</Project>
+14
View File
@@ -0,0 +1,14 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Messenger.Api.Models
{
public sealed class Chat
{
public Guid Id { get; init; }
public string Title { get; init; } = String.Empty;
public List<Guid> MemberIds { get; init; } = new List<Guid>();
public DateTimeOffset CreatedAt { get; init; }
}
}
@@ -0,0 +1,6 @@
namespace Messenger.Api.Models
{
public sealed record CreateChatRequest(
[property: System.Text.Json.Serialization.JsonRequired] string Title,
[property: System.Text.Json.Serialization.JsonRequired] List<Guid> MemberIds);
}
@@ -0,0 +1,3 @@
namespace Messenger.Api.Models;
public sealed record CreateMessageRequest([property: System.Text.Json.Serialization.JsonRequired] string Text);
@@ -0,0 +1,12 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Messenger.Api.Models
{
public sealed record CreateUserRequest(
[property: System.Text.Json.Serialization.JsonRequired] string Username,
[property: System.Text.Json.Serialization.JsonRequired] string DisplayName,
[property: System.Text.Json.Serialization.JsonRequired] string Password);
}
+16
View File
@@ -0,0 +1,16 @@
using Microsoft.AspNetCore.Http.HttpResults;
using System;
using System.Collections.Generic;
using System.Text;
namespace Messenger.Api.Models
{
public sealed class Message
{
public Guid Id { get; init; }
public Guid ChatId { get; init; }
public Guid SenderId { get; init; }
public string Text { get; init; } = String.Empty;
public DateTimeOffset CreatedAt { get; init; }
}
}
@@ -0,0 +1,7 @@
namespace Messenger.Api.Models;
public sealed record SessionResponse(
string Token,
string TokenType,
DateTimeOffset ExpiresAt,
User User);
+14
View File
@@ -0,0 +1,14 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Messenger.Api.Models
{
public sealed class User
{
public Guid Id { get; init; }
public string Username { get; init; } = string.Empty;
public string DisplayName { get; init; } = string.Empty;
public DateTimeOffset CreatedAt { get; init; }
}
}
+198
View File
@@ -0,0 +1,198 @@
using Microsoft.AspNetCore.Diagnostics;
using Messenger.Api.Endpoints;
using Messenger.Api.Services;
using Messenger.Api.Data;
using System.Text.Json;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Authentication;
// Режим для Docker HEALTHCHECK: в образе aspnet нет curl, поэтому проверку выполняет само приложение.
if (args.Contains("--healthcheck"))
{
var port = Environment.GetEnvironmentVariable("APP_PORT") ?? "8080";
try
{
using var probe = new HttpClient { Timeout = TimeSpan.FromSeconds(2) };
var probeResponse = await probe.GetAsync($"http://127.0.0.1:{port}/health/live");
return probeResponse.IsSuccessStatusCode ? 0 : 1;
}
catch (Exception)
{
return 1;
}
}
var builder = WebApplication.CreateBuilder(args);
// SIGTERM: новые запросы перестают приниматься, активные получают не более 8 секунд (лимит задания — 10).
builder.Services.Configure<HostOptions>(options => options.ShutdownTimeout = TimeSpan.FromSeconds(8));
// Настройки читаются лениво из IConfiguration (после Build), поэтому тесты могут задавать их через UseSetting.
builder.Services.AddSingleton(sp => DatabaseSettings.From(sp.GetRequiredService<IConfiguration>()));
builder.Services.AddSingleton(sp => AuthSessionOptions.From(sp.GetRequiredService<IConfiguration>()));
builder.Services.AddSingleton(sp => CacheSettings.From(sp.GetRequiredService<IConfiguration>()));
builder.Services.AddSingleton(sp => DiagnosticsSettings.From(sp.GetRequiredService<IConfiguration>()));
builder.Services.AddHttpContextAccessor();
builder.Services.AddSingleton<QueryCountingInterceptor>();
builder.Services.AddDbContext<MessengerDbContext>((sp, options) =>
{
options.UseNpgsql(sp.GetRequiredService<DatabaseSettings>().ConnectionString)
.UseSnakeCaseNamingConvention();
if (sp.GetRequiredService<DiagnosticsSettings>().Headers)
{
options.AddInterceptors(sp.GetRequiredService<QueryCountingInterceptor>());
}
});
builder.Services.AddSingleton(sp => PasswordHashingSettings.From(sp.GetRequiredService<IConfiguration>()));
builder.Services.AddSingleton<IPasswordHasher, Argon2PasswordHasher>();
builder.Services.AddSingleton<IMessageHistoryCache>(sp =>
{
var settings = sp.GetRequiredService<CacheSettings>();
return settings.Enabled
? new ValkeyMessageHistoryCache(settings, sp.GetRequiredService<ILogger<ValkeyMessageHistoryCache>>())
: new NullMessageHistoryCache();
});
builder.Services.AddAuthentication(BearerAuth.Scheme)
.AddScheme<AuthenticationSchemeOptions, SessionAuthenticationHandler>(BearerAuth.Scheme, null);
builder.Services.AddAuthorization();
builder.Services.ConfigureHttpJsonOptions(options =>
{
options.SerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower;
options.SerializerOptions.Converters.Add(new UtcDateTimeOffsetJsonConverter());
options.SerializerOptions.UnmappedMemberHandling = System.Text.Json.Serialization.JsonUnmappedMemberHandling.Disallow;
options.SerializerOptions.RespectNullableAnnotations = true;
// Web-настройки по умолчанию включают регистронезависимое сопоставление имён: контракт его не допускает.
options.SerializerOptions.PropertyNameCaseInsensitive = false;
});
var app = builder.Build();
using (var scope = app.Services.CreateScope())
{
scope.ServiceProvider.GetRequiredService<MessengerDbContext>().Database.Migrate();
}
// Диагностика (только при DIAGNOSTIC_HEADERS=true): число SQL-команд EF Core за запрос — в заголовке X-Db-Queries.
if (app.Services.GetRequiredService<DiagnosticsSettings>().Headers)
{
app.Use(async (context, next) =>
{
var counter = new QueryCounter();
context.Items[QueryCountingInterceptor.ItemKey] = counter;
context.Response.OnStarting(() =>
{
context.Response.Headers["X-Db-Queries"] = Volatile.Read(ref counter.Count).ToString();
return Task.CompletedTask;
});
await next();
});
}
app.Use(async (context, next) =>
{
var requestId = Guid.NewGuid().ToString();
context.Items["request_id"] = requestId;
context.Response.Headers["X-Request-Id"] = requestId;
await next();
});
// Лог запроса: метод, путь, статус, время, request_id. Тело и query не логируются.
app.Use(async (context, next) =>
{
var logger = context.RequestServices.GetRequiredService<ILoggerFactory>().CreateLogger("Messenger.Requests");
var started = System.Diagnostics.Stopwatch.GetTimestamp();
try
{
await next();
}
finally
{
logger.LogInformation(
"{Method} {Path} -> {Status} in {ElapsedMs:0.0} ms (request_id={RequestId})",
context.Request.Method,
context.Request.Path.Value,
context.Response.StatusCode,
System.Diagnostics.Stopwatch.GetElapsedTime(started).TotalMilliseconds,
context.Items["request_id"]);
}
});
app.UseExceptionHandler(errorApp => errorApp.Run(context =>
{
// В Development ошибки чтения запроса приходят исключением: сохраняем их 400/415 вместо 500.
var error = context.Features.Get<IExceptionHandlerFeature>()?.Error;
if (error is BadHttpRequestException { StatusCode: 400 or 415 } badRequest)
{
var (code, message) = badRequest.StatusCode == 415
? ("unsupported_media_type", "Требуется Content-Type: application/json")
: ("invalid_request", "Некорректный запрос");
return ApiErrors.Error(context, badRequest.StatusCode, code, message).ExecuteAsync(context);
}
// PostgreSQL недоступен или перегружен: ограниченный ответ 503 без внутренних деталей (стек и SQL только в логе).
if (DependencyFailures.IsDatabaseUnavailable(error))
{
return ApiErrors.Error(context, 503, "unavailable", "Сервис временно недоступен").ExecuteAsync(context);
}
return ApiErrors.Error(context, 500, "internal_error", "Внутренняя ошибка сервера").ExecuteAsync(context);
}));
// Пустые ответы 400/404/415 (ошибки привязки, неизвестный маршрут) получают стандартное тело ошибки.
app.UseStatusCodePages(context =>
{
var http = context.HttpContext;
var (code, message) = http.Response.StatusCode switch
{
400 => ("invalid_request", "Некорректный запрос"),
404 => ("not_found", "Объект не найден"),
415 => ("unsupported_media_type", "Требуется Content-Type: application/json"),
_ => ("internal_error", "Ошибка запроса")
};
return ApiErrors.Error(http, http.Response.StatusCode, code, message).ExecuteAsync(http);
});
// Аутентификация (Bearer) выполняется до выбора обработчика и разбора тела: 401 приоритетнее 400/404.
app.UseAuthentication();
app.UseAuthorization();
app.MapGet("/health/live", () =>
{
return Results.Ok(new
{
status = "ok"
});
});
// Готовность = API может обслуживать обязательный синхронный путь, а он требует PostgreSQL.
app.MapGet("/health/ready", async (HttpContext context, MessengerDbContext db) =>
{
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(context.RequestAborted);
timeout.CancelAfter(TimeSpan.FromSeconds(2));
try
{
return await db.Database.CanConnectAsync(timeout.Token)
? Results.Ok(new { status = "ok" })
: ApiErrors.Error(context, 503, "unavailable", "База данных недоступна");
}
catch (OperationCanceledException) when (!context.RequestAborted.IsCancellationRequested)
{
return ApiErrors.Error(context, 503, "unavailable", "База данных недоступна");
}
});
app.MapUserEndpoints();
app.MapAuthEndpoints();
app.MapChatEndpoints();
app.MapMessageEndpoints();
app.Lifetime.ApplicationStarted.Register(() => app.Logger.LogInformation("Messenger API started"));
app.Lifetime.ApplicationStopping.Register(() => app.Logger.LogInformation("SIGTERM received: shutting down, new requests are no longer accepted"));
app.Lifetime.ApplicationStopped.Register(() => app.Logger.LogInformation("Messenger API stopped"));
app.Run();
return 0;
// Делает Program доступным для WebApplicationFactory<Program> в тестах.
public partial class Program { }
@@ -0,0 +1,23 @@
{
"$schema": "https://json.schemastore.org/launchsettings.json",
"profiles": {
"http": {
"commandName": "Project",
"dotnetRunMessages": true,
"launchBrowser": true,
"applicationUrl": "http://localhost:5015",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
},
"https": {
"commandName": "Project",
"dotnetRunMessages": true,
"launchBrowser": true,
"applicationUrl": "https://localhost:7165;http://localhost:5015",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
}
}
}
+37
View File
@@ -0,0 +1,37 @@
namespace Messenger.Api.Services;
public static class ApiErrors
{
public static int CodePoints(string value) => value.EnumerateRunes().Count();
// 401 с обязательным заголовком WWW-Authenticate (контракт: Basic для входа, Bearer для остального API).
public static IResult Unauthorized(HttpContext context, string challenge, string message)
{
context.Response.Headers.WWWAuthenticate = challenge;
return Error(context, 401, "unauthorized", message);
}
public static IResult Error(
HttpContext context,
int statusCode,
string code,
string message)
{
var requestId = context.Items["request_id"]?.ToString() ?? context.TraceIdentifier;
// UseExceptionHandler очищает заголовки ответа, поэтому выставляем X-Request-Id заново.
context.Response.Headers["X-Request-Id"] = requestId;
return Results.Json(
new
{
error = new
{
code,
message,
request_id = requestId
}
},
statusCode: statusCode);
}
}
@@ -0,0 +1,68 @@
using Isopoh.Cryptography.Argon2;
namespace Messenger.Api.Services;
public sealed class Argon2PasswordHasher : IPasswordHasher
{
// Минимум по рекомендации OWASP для Argon2id: m=19 MiB, t=2, p=1. Обоснование и выбор — в REPORT.md.
private const int TimeCost = 2;
private const int MemoryCostKiB = 19 * 1024;
private const int Parallelism = 1;
// Каждое вычисление занимает ~19 MiB и ядро CPU: без лимита 100 параллельных входов = ~2 GiB памяти.
// Размер и время ожидания слотов задаются PASSWORD_HASH_CONCURRENCY / PASSWORD_HASH_QUEUE_TIMEOUT_SECONDS.
private readonly SemaphoreSlim _slots;
private readonly TimeSpan _slotWaitTimeout;
// Хеш от случайного пароля, который никто не знает. Нужен только для выравнивания времени при неизвестном username.
private readonly string _dummyHash;
public Argon2PasswordHasher(PasswordHashingSettings settings)
{
_slots = new SemaphoreSlim(settings.MaxConcurrency, settings.MaxConcurrency);
_slotWaitTimeout = settings.QueueTimeout;
_dummyHash = HashCore(Convert.ToBase64String(System.Security.Cryptography.RandomNumberGenerator.GetBytes(32)));
}
public async Task<string> HashAsync(string password, CancellationToken ct)
{
await AcquireSlotAsync(ct);
try
{
return await Task.Run(() => HashCore(password), ct);
}
finally
{
_slots.Release();
}
}
public async Task<bool> VerifyAsync(string? hash, string password, CancellationToken ct)
{
await AcquireSlotAsync(ct);
try
{
return await Task.Run(() =>
{
var ok = Argon2.Verify(hash ?? _dummyHash, password, secret: null, secureArrayCall: null);
return hash is not null && ok;
}, ct);
}
finally
{
_slots.Release();
}
}
private async Task AcquireSlotAsync(CancellationToken ct)
{
if (!await _slots.WaitAsync(_slotWaitTimeout, ct))
{
throw new PasswordHasherBusyException();
}
}
// HybridAddressing — это Argon2id. Соль генерируется библиотекой и входит в возвращаемую строку.
private static string HashCore(string password) =>
Argon2.Hash(password, TimeCost, MemoryCostKiB, Parallelism, Argon2Type.HybridAddressing);
}
+91
View File
@@ -0,0 +1,91 @@
using System.Security.Claims;
using System.Text.Encodings.Web;
using Messenger.Api.Data;
using Microsoft.AspNetCore.Authentication;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
namespace Messenger.Api.Services;
public static class BearerAuth
{
public const string Scheme = "Bearer";
public const string Challenge = "Bearer realm=\"messenger\"";
public const string SessionIdClaim = "session_id";
// Ровно один заголовок Authorization вида "Bearer <token>"; иначе null (Basic и прочее здесь не принимаются).
public static string? ExtractToken(HttpRequest request)
{
if (request.Headers.Authorization.Count != 1)
{
return null;
}
var value = request.Headers.Authorization[0];
const string prefix = "Bearer ";
if (value is null || !value.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
{
return null;
}
var token = value[prefix.Length..].Trim();
return token.Length == 0 ? null : token;
}
public static Guid GetUserId(this HttpContext context) =>
Guid.Parse(context.User.FindFirstValue(ClaimTypes.NameIdentifier)!);
public static Guid GetSessionId(this HttpContext context) =>
Guid.Parse(context.User.FindFirstValue(SessionIdClaim)!);
}
// Стандартный обработчик аутентификации ASP.NET: превращает Bearer-токен в ClaimsPrincipal.
// Срабатывает до выбора и выполнения эндпоинта (в том числе до разбора тела), поэтому 401 всегда раньше 400/404.
public sealed class SessionAuthenticationHandler(
IOptionsMonitor<AuthenticationSchemeOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
MessengerDbContext db)
: AuthenticationHandler<AuthenticationSchemeOptions>(options, logger, encoder)
{
protected override async Task<AuthenticateResult> HandleAuthenticateAsync()
{
var token = BearerAuth.ExtractToken(Request);
if (token is null)
{
return AuthenticateResult.NoResult();
}
var hash = SessionTokens.Hash(token);
var now = Timestamps.UtcNowMilliseconds();
// Неизвестный, истёкший и отозванный токен неразличимы для клиента: во всех случаях это один 401.
var session = await db.Sessions
.AsNoTracking()
.Where(s => s.TokenHash == hash && s.RevokedAt == null && s.ExpiresAt > now)
.Select(s => new { s.Id, s.UserId })
.FirstOrDefaultAsync(Context.RequestAborted);
if (session is null)
{
return AuthenticateResult.Fail("Недействительная сессия");
}
var identity = new ClaimsIdentity(
[
new Claim(ClaimTypes.NameIdentifier, session.UserId.ToString()),
new Claim(BearerAuth.SessionIdClaim, session.Id.ToString())
],
BearerAuth.Scheme);
return AuthenticateResult.Success(
new AuthenticationTicket(new ClaimsPrincipal(identity), BearerAuth.Scheme));
}
protected override async Task HandleChallengeAsync(AuthenticationProperties properties)
{
await ApiErrors
.Unauthorized(Context, BearerAuth.Challenge, "Требуется действительный Bearer-токен")
.ExecuteAsync(Context);
}
}
+56
View File
@@ -0,0 +1,56 @@
using System.Text;
namespace Messenger.Api.Services;
// Непрозрачный для клиента cursor keyset-пагинации: (created_at, id) последнего элемента страницы.
// Привязан к ресурсу (scope): cursor от другого списка или чата отклоняется как 400.
public static class Cursors
{
public const string Chats = "chats";
public static string Messages(Guid chatId) => $"messages/{chatId:D}";
public static string Encode(string scope, DateTimeOffset createdAt, Guid id) =>
Convert.ToBase64String(Encoding.UTF8.GetBytes($"{scope}|{createdAt.UtcTicks}:{id:D}"));
// cursor == null — первая страница (успех, value == null). Любая ошибка формата или чужой scope — false.
public static bool TryDecode(string? cursor, string scope, out (DateTimeOffset CreatedAt, Guid Id)? value)
{
value = null;
if (cursor is null)
{
return true;
}
if (cursor.Length == 0)
{
return false;
}
try
{
var decoded = new UTF8Encoding(false, throwOnInvalidBytes: true).GetString(Convert.FromBase64String(cursor));
var scoped = decoded.Split('|', 2);
if (scoped.Length != 2 || scoped[0] != scope)
{
return false;
}
var parts = scoped[1].Split(':', 2);
if (parts.Length != 2 ||
!long.TryParse(parts[0], out var ticks) ||
ticks < DateTimeOffset.MinValue.UtcTicks || ticks > DateTimeOffset.MaxValue.UtcTicks ||
!Guid.TryParse(parts[1], out var id))
{
return false;
}
value = (new DateTimeOffset(ticks, TimeSpan.Zero), id);
return true;
}
catch (Exception ex) when (ex is FormatException or ArgumentException or DecoderFallbackException)
{
return false;
}
}
}
+90
View File
@@ -0,0 +1,90 @@
using System.Data.Common;
using Microsoft.EntityFrameworkCore.Diagnostics;
using Npgsql;
namespace Messenger.Api.Services;
public sealed class QueryCounter
{
public int Count;
}
// Считает SQL-команды, выполненные EF Core в рамках текущего HTTP-запроса (для измерения «запросов к БД на запрос API»).
// Включается только при DIAGNOSTIC_HEADERS=true. Команда ReserveMessageSlot (сырой NpgsqlCommand) не учитывается.
public sealed class QueryCountingInterceptor(IHttpContextAccessor accessor) : DbCommandInterceptor
{
public const string ItemKey = "diagnostics.query_counter";
private void Count()
{
if (accessor.HttpContext?.Items[ItemKey] is QueryCounter counter)
{
Interlocked.Increment(ref counter.Count);
}
}
public override InterceptionResult<DbDataReader> ReaderExecuting(DbCommand command, CommandEventData eventData, InterceptionResult<DbDataReader> result)
{
Count();
return result;
}
public override ValueTask<InterceptionResult<DbDataReader>> ReaderExecutingAsync(DbCommand command, CommandEventData eventData, InterceptionResult<DbDataReader> result, CancellationToken cancellationToken = default)
{
Count();
return ValueTask.FromResult(result);
}
public override InterceptionResult<int> NonQueryExecuting(DbCommand command, CommandEventData eventData, InterceptionResult<int> result)
{
Count();
return result;
}
public override ValueTask<InterceptionResult<int>> NonQueryExecutingAsync(DbCommand command, CommandEventData eventData, InterceptionResult<int> result, CancellationToken cancellationToken = default)
{
Count();
return ValueTask.FromResult(result);
}
public override InterceptionResult<object> ScalarExecuting(DbCommand command, CommandEventData eventData, InterceptionResult<object> result)
{
Count();
return result;
}
public override ValueTask<InterceptionResult<object>> ScalarExecutingAsync(DbCommand command, CommandEventData eventData, InterceptionResult<object> result, CancellationToken cancellationToken = default)
{
Count();
return ValueTask.FromResult(result);
}
}
public static class DependencyFailures
{
// Недоступность или перегрузка PostgreSQL (нет соединения, таймаут, исчерпан пул, остановка сервера) — это 503,
// а не 500: ошибка ограничена, внутренние детали не раскрываются, запрос не принимается как доверенный.
public static bool IsDatabaseUnavailable(Exception? error)
{
for (var e = error; e is not null; e = e.InnerException)
{
switch (e)
{
case PostgresException pg:
// 08 — соединение, 53 — нехватка ресурсов, 57 — вмешательство оператора (shutdown и т.п.)
if (pg.SqlState.StartsWith("08") || pg.SqlState.StartsWith("53") || pg.SqlState.StartsWith("57"))
{
return true;
}
break;
case NpgsqlException:
case TimeoutException:
case System.Net.Sockets.SocketException:
return true;
}
}
return false;
}
}
@@ -0,0 +1,18 @@
namespace Messenger.Api.Services;
public interface IPasswordHasher
{
/// <summary>PHC-строка Argon2id (соль и параметры внутри). Бросает <see cref="PasswordHasherBusyException"/>, если слот не освободился вовремя.</summary>
Task<string> HashAsync(string password, CancellationToken ct);
/// <summary>
/// <paramref name="hash"/> == null означает «пользователя нет»: проверка всё равно выполняется (против заглушки),
/// чтобы время ответа не раскрывало существование username.
/// </summary>
Task<bool> VerifyAsync(string? hash, string password, CancellationToken ct);
}
public sealed class PasswordHasherBusyException : Exception
{
public PasswordHasherBusyException() : base("Слишком много одновременных вычислений хеша пароля") { }
}
@@ -0,0 +1,102 @@
using StackExchange.Redis;
namespace Messenger.Api.Services;
public enum CacheStatus
{
Disabled, // кэш не настроен
Hit,
Miss,
Bypass // кэш настроен, но недоступен: запрос обслужен напрямую из PostgreSQL
}
// Кэш страниц истории. Источник истины — PostgreSQL; кэш лишь ускоряет чтение и никогда не обязателен.
// Согласованность: версия истории чата (chats.history_version) входит в ключ, а версия читается из PostgreSQL
// при каждом запросе (см. MessageEndpoints). Запись увеличивает версию в своей транзакции, поэтому
// после подтверждённой записи ключ меняется, и устаревшая страница недостижима — явная инвалидация не нужна.
// Старые ключи удаляются по TTL (CACHE_TTL_SECONDS) и вытесняются политикой maxmemory.
public interface IMessageHistoryCache
{
Task<(string? Json, CacheStatus Status)> GetAsync(string key, CancellationToken ct);
Task SetAsync(string key, string json, CancellationToken ct);
}
public sealed class NullMessageHistoryCache : IMessageHistoryCache
{
public Task<(string? Json, CacheStatus Status)> GetAsync(string key, CancellationToken ct) =>
Task.FromResult<(string?, CacheStatus)>((null, CacheStatus.Disabled));
public Task SetAsync(string key, string json, CancellationToken ct) => Task.CompletedTask;
}
public sealed class ValkeyMessageHistoryCache : IMessageHistoryCache, IDisposable
{
// После ошибки кэш пропускается на это время, чтобы каждый запрос не ждал таймаут недоступного сервера.
private static readonly TimeSpan BypassWindow = TimeSpan.FromSeconds(5);
private readonly ConnectionMultiplexer _connection;
private readonly TimeSpan _ttl;
private readonly ILogger<ValkeyMessageHistoryCache> _logger;
private long _bypassUntilTicks;
public ValkeyMessageHistoryCache(CacheSettings settings, ILogger<ValkeyMessageHistoryCache> logger)
{
var options = ConfigurationOptions.Parse(settings.Connection!);
// Недоступный кэш не должен ронять ни старт, ни запросы: короткие таймауты, подключение в фоне.
options.AbortOnConnectFail = false;
options.ConnectTimeout = 500;
options.SyncTimeout = 200;
options.AsyncTimeout = 200;
options.ConnectRetry = 1;
_connection = ConnectionMultiplexer.Connect(options);
_ttl = settings.Ttl;
_logger = logger;
}
public async Task<(string? Json, CacheStatus Status)> GetAsync(string key, CancellationToken ct)
{
if (IsBypassed())
{
return (null, CacheStatus.Bypass);
}
try
{
var value = await _connection.GetDatabase().StringGetAsync(key);
return value.IsNull ? (null, CacheStatus.Miss) : ((string?)value, CacheStatus.Hit);
}
catch (Exception ex) when (ex is RedisException or TimeoutException)
{
StartBypass(ex);
return (null, CacheStatus.Bypass);
}
}
public async Task SetAsync(string key, string json, CancellationToken ct)
{
if (IsBypassed())
{
return;
}
try
{
await _connection.GetDatabase().StringSetAsync(key, json, _ttl);
}
catch (Exception ex) when (ex is RedisException or TimeoutException)
{
StartBypass(ex);
}
}
private bool IsBypassed() => Environment.TickCount64 < Interlocked.Read(ref _bypassUntilTicks);
private void StartBypass(Exception ex)
{
Interlocked.Exchange(ref _bypassUntilTicks, Environment.TickCount64 + (long)BypassWindow.TotalMilliseconds);
_logger.LogWarning("Кэш недоступен ({Error}); чтение идёт напрямую из PostgreSQL ближайшие {Seconds} с",
ex.GetType().Name, BypassWindow.TotalSeconds);
}
public void Dispose() => _connection.Dispose();
}
@@ -0,0 +1,16 @@
using System.Security.Cryptography;
using System.Text;
namespace Messenger.Api.Services;
public static class SessionTokens
{
// 32 случайных байта = 256 бит энтропии (контракт: не менее 256). В base64url это 43 символа.
public static string Generate() =>
Convert.ToBase64String(RandomNumberGenerator.GetBytes(32))
.TrimEnd('=').Replace('+', '-').Replace('/', '_');
// В БД хранится только SHA-256 токена. Быстрый хеш здесь уместен: токен случайный и длинный, подбирать нечего
// (в отличие от пароля, который выбирает человек и который поэтому хешируется медленным Argon2id).
public static byte[] Hash(string token) => SHA256.HashData(Encoding.UTF8.GetBytes(token));
}
+87
View File
@@ -0,0 +1,87 @@
namespace Messenger.Api.Services;
// Все настройки читаются из IConfiguration (переменные окружения и, в тестах, UseSetting), а не напрямую из окружения:
// так одно приложение можно поднять с разными настройками в одном процессе. Секреты передаются файлами (*_FILE).
public sealed record DatabaseSettings(string ConnectionString)
{
public static DatabaseSettings From(IConfiguration configuration)
{
var file = configuration["DATABASE_URL_FILE"]
?? throw new InvalidOperationException("DATABASE_URL_FILE не задан");
var builder = new Npgsql.NpgsqlConnectionStringBuilder(File.ReadAllText(file).Trim())
{
Pooling = true,
MinPoolSize = 1,
// Ограниченный пул: больше MaxPoolSize соединений от одного экземпляра не открывается,
// ожидающие запросы ждут не дольше Timeout и затем получают 503.
MaxPoolSize = configuration.GetValue("DB_MAX_POOL_SIZE", 20),
Timeout = configuration.GetValue("DB_CONNECT_TIMEOUT_SECONDS", 5),
CommandTimeout = configuration.GetValue("DB_COMMAND_TIMEOUT_SECONDS", 5)
};
return new DatabaseSettings(builder.ConnectionString);
}
}
public sealed record AuthSessionOptions(TimeSpan Ttl)
{
// SESSION_TTL_SECONDS: по умолчанию 3600; в тесте истечения допустимо 2. Неверное значение — ошибка старта, а не молчаливый дефолт.
public static AuthSessionOptions From(IConfiguration configuration)
{
var raw = configuration["SESSION_TTL_SECONDS"];
if (string.IsNullOrWhiteSpace(raw))
{
return new AuthSessionOptions(TimeSpan.FromSeconds(3600));
}
if (!int.TryParse(raw, out var seconds) || seconds < 1)
{
throw new InvalidOperationException("SESSION_TTL_SECONDS должен быть положительным целым числом");
}
return new AuthSessionOptions(TimeSpan.FromSeconds(seconds));
}
}
// Ограничитель Argon2: сколько хешей считается одновременно и сколько запрос ждёт свободный слот, прежде чем получить 503.
// Один хеш занимает ~19 MiB и ядро CPU, поэтому без лимита пачка регистраций исчерпала бы память.
public sealed record PasswordHashingSettings(int MaxConcurrency, TimeSpan QueueTimeout)
{
public static PasswordHashingSettings From(IConfiguration configuration)
{
var concurrency = configuration.GetValue("PASSWORD_HASH_CONCURRENCY", 4);
var timeoutSeconds = configuration.GetValue("PASSWORD_HASH_QUEUE_TIMEOUT_SECONDS", 2.0);
if (concurrency < 1 || timeoutSeconds < 0)
{
throw new InvalidOperationException("PASSWORD_HASH_CONCURRENCY >= 1 и PASSWORD_HASH_QUEUE_TIMEOUT_SECONDS >= 0");
}
return new PasswordHashingSettings(concurrency, TimeSpan.FromSeconds(timeoutSeconds));
}
}
// Кэш необязателен: без CACHE_URL_FILE / CACHE_CONNECTION приложение работает только на PostgreSQL.
public sealed record CacheSettings(string? Connection, TimeSpan Ttl)
{
public bool Enabled => !string.IsNullOrWhiteSpace(Connection);
public static CacheSettings From(IConfiguration configuration)
{
var connection = configuration["CACHE_CONNECTION"];
var file = configuration["CACHE_URL_FILE"];
if (!string.IsNullOrWhiteSpace(file) && File.Exists(file))
{
connection = File.ReadAllText(file).Trim();
}
return new CacheSettings(connection, TimeSpan.FromSeconds(configuration.GetValue("CACHE_TTL_SECONDS", 300)));
}
}
// Диагностические заголовки X-Cache и X-Db-Queries для экспериментов; в обычной работе выключены.
public sealed record DiagnosticsSettings(bool Headers)
{
public static DiagnosticsSettings From(IConfiguration configuration) =>
new(configuration.GetValue("DIAGNOSTIC_HEADERS", false));
}
+13
View File
@@ -0,0 +1,13 @@
namespace Messenger.Api.Services;
public static class Timestamps
{
// Единая точность времени для хранения, сортировки, cursor и JSON-ответа: миллисекунды.
// Клиент видит время с точностью до миллисекунды, поэтому порядок (created_at, id) должен
// определяться теми же значениями, которые он видит.
public static DateTimeOffset UtcNowMilliseconds()
{
var ticks = DateTimeOffset.UtcNow.UtcTicks;
return new DateTimeOffset(ticks - ticks % TimeSpan.TicksPerMillisecond, TimeSpan.Zero);
}
}
@@ -0,0 +1,28 @@
using System.Globalization;
using System.Text.Json;
using System.Text.Json.Serialization;
namespace Messenger.Api.Services;
public sealed class UtcDateTimeOffsetJsonConverter : JsonConverter<DateTimeOffset>
{
public override DateTimeOffset Read(
ref Utf8JsonReader reader,
Type typeToConvert,
JsonSerializerOptions options)
{
return DateTimeOffset.Parse(
reader.GetString()!,
CultureInfo.InvariantCulture,
DateTimeStyles.RoundtripKind);
}
public override void Write(
Utf8JsonWriter writer,
DateTimeOffset value,
JsonSerializerOptions options)
{
writer.WriteStringValue(
value.UtcDateTime.ToString("yyyy-MM-dd'T'HH:mm:ss.fff'Z'", CultureInfo.InvariantCulture));
}
}
@@ -0,0 +1,8 @@
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
}
}
+9
View File
@@ -0,0 +1,9 @@
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"AllowedHosts": "*"
}
+98
View File
@@ -0,0 +1,98 @@
-- Воспроизводимый эксперимент: план запроса страницы истории (EXPLAIN (ANALYZE, BUFFERS)) на ~67 000 сообщений.
-- Запускать в ОТДЕЛЬНОЙ базе со схемой приложения (миграции применены), см. evidence/lab2-level4-explain.md:
-- docker compose exec -T db psql -U messenger -d explain_lab -f - < scripts/explain-history.sql
-- Данные синтетические. Порядок вставки перемешан (ORDER BY random()), чтобы строки одного чата не лежали в куче подряд,
-- как при реальной записи в много чатов одновременно.
\set ON_ERROR_STOP on
\pset pager off
\timing off
TRUNCATE messages, chat_members, chats, sessions, users CASCADE;
INSERT INTO users (id, username, display_name, password_hash, created_at)
SELECT gen_random_uuid(), 'seed_user_' || g, 'Seed', 'not-a-real-hash', now() FROM generate_series(1, 3) g;
-- 1 большой чат (60 000), 1 средний (5 000) и 2 000 маленьких (по 5 сообщений): неравномерные размеры.
CREATE TEMP TABLE seed_chats AS
SELECT gen_random_uuid() AS id, n, CASE WHEN n = 1 THEN 60000 WHEN n = 2 THEN 5000 ELSE 5 END AS msgs
FROM generate_series(1, 2002) n;
INSERT INTO chats (id, title, created_at, history_version)
SELECT id, 'seed ' || n, now() + n * interval '1 millisecond', msgs FROM seed_chats;
INSERT INTO chat_members (chat_id, user_id)
SELECT c.id, u.id FROM seed_chats c CROSS JOIN users u;
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), c.id, s.id, 'message ' || g, timestamptz '2026-01-01 00:00:00+00' + g * interval '1 second'
FROM seed_chats c
CROSS JOIN LATERAL generate_series(1, c.msgs) g
CROSS JOIN (SELECT id FROM users WHERE username = 'seed_user_1') s
ORDER BY random();
ANALYZE;
SELECT count(*) AS messages_total,
(SELECT count(*) FROM messages m JOIN seed_chats c ON c.id = m.chat_id AND c.n = 1) AS big_chat,
(SELECT count(*) FROM chats) AS chats
FROM messages;
SELECT id AS big FROM seed_chats WHERE n = 1 \gset
SELECT id AS small FROM seed_chats WHERE n = 3 \gset
-- Курсор «в середине» истории большого чата (30 000-е сообщение) и «в конце» (59 949-е).
SELECT created_at AS mid_t, id AS mid_id FROM messages WHERE chat_id = :'big' ORDER BY created_at, id OFFSET 30000 LIMIT 1 \gset
SELECT created_at AS end_t, id AS end_id FROM messages WHERE chat_id = :'big' ORDER BY created_at, id OFFSET 59949 LIMIT 1 \gset
\echo
\echo '=== A. Первая страница большого чата (с индексом ix_messages_chat_history) ==='
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF, TIMING OFF)
SELECT m.id, m.chat_id, m.created_at, m.sender_id, m.text
FROM (SELECT * FROM messages WHERE chat_id = :'big') AS m
ORDER BY m.created_at, m.id LIMIT 51;
\echo
\echo '=== B. Страница из середины истории (30 000 сообщений до курсора), keyset, с индексом ==='
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF, TIMING OFF)
SELECT m.id, m.chat_id, m.created_at, m.sender_id, m.text
FROM (SELECT * FROM messages WHERE chat_id = :'big' AND (created_at, id) > (:'mid_t', :'mid_id')) AS m
ORDER BY m.created_at, m.id LIMIT 51;
\echo
\echo '=== C. Последняя страница большого чата, keyset, с индексом ==='
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF, TIMING OFF)
SELECT m.id, m.chat_id, m.created_at, m.sender_id, m.text
FROM (SELECT * FROM messages WHERE chat_id = :'big' AND (created_at, id) > (:'end_t', :'end_id')) AS m
ORDER BY m.created_at, m.id LIMIT 51;
\echo
\echo '=== D. Маленький чат (5 сообщений) на той же таблице, с индексом ==='
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF, TIMING OFF)
SELECT m.id, m.chat_id, m.created_at, m.sender_id, m.text
FROM (SELECT * FROM messages WHERE chat_id = :'small') AS m
ORDER BY m.created_at, m.id LIMIT 51;
\echo
\echo '=== E. Для сравнения: OFFSET-пагинация, та же страница из середины (индекс есть) ==='
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF, TIMING OFF)
SELECT m.id FROM messages m WHERE m.chat_id = :'big' ORDER BY m.created_at, m.id OFFSET 30000 LIMIT 51;
\echo
\echo '=== F. Тот же запрос B БЕЗ индекса (DROP INDEX ix_messages_chat_history) ==='
BEGIN;
DROP INDEX ix_messages_chat_history;
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF, TIMING OFF)
SELECT m.id, m.chat_id, m.created_at, m.sender_id, m.text
FROM (SELECT * FROM messages WHERE chat_id = :'big' AND (created_at, id) > (:'mid_t', :'mid_id')) AS m
ORDER BY m.created_at, m.id LIMIT 51;
\echo
\echo '=== G. Запрос D (маленький чат) БЕЗ индекса ==='
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF, TIMING OFF)
SELECT m.id, m.chat_id, m.created_at, m.sender_id, m.text
FROM (SELECT * FROM messages WHERE chat_id = :'small') AS m
ORDER BY m.created_at, m.id LIMIT 51;
ROLLBACK;
\echo
\echo '=== H. Размеры: таблица и индекс ==='
SELECT pg_size_pretty(pg_relation_size('messages')) AS table_size,
pg_size_pretty(pg_relation_size('ix_messages_chat_history')) AS history_index_size;
+30
View File
@@ -0,0 +1,30 @@
#!/bin/sh
# Создаёт локальные секреты для compose.yaml, если их ещё нет. Существующие файлы не перезаписываются.
# Пароль случайный (24 символа [A-Za-z0-9]); значения не печатаются. Каталог secrets/ исключён из Git.
set -eu
cd "$(dirname "$0")/.."
mkdir -p secrets
umask 077
if [ ! -f secrets/db_password ]; then
# tr читает конечный поток /dev/urandom до нужной длины; head закрывает канал.
LC_ALL=C tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 24 > secrets/db_password
echo "created secrets/db_password"
fi
if [ ! -f secrets/database_url.compose ]; then
printf 'Host=db;Port=5432;Database=messenger;Username=messenger;Password=%s' "$(cat secrets/db_password)" \
> secrets/database_url.compose
echo "created secrets/database_url.compose"
fi
if [ ! -f secrets/cache_password ]; then
LC_ALL=C tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 24 > secrets/cache_password
echo "created secrets/cache_password"
fi
if [ ! -f secrets/cache_url ]; then
printf 'cache:6379,password=%s' "$(cat secrets/cache_password)" > secrets/cache_url
echo "created secrets/cache_url"
fi
+12
View File
@@ -0,0 +1,12 @@
#!/bin/sh
# Полный перезапуск стенда для `make test-persistence`: останавливается API, затем перезапускаются ВСЕ хранилища —
# PostgreSQL (тот же именованный volume) и Valkey (кэш без persistence: его содержимое после этого пусто),
# затем API запускается заново. Volumes не удаляются, данные не пересоздаются.
# Токены сессий живут в таблице sessions в PostgreSQL, поэтому переживают этот перезапуск; кэш — только ускорение.
set -eu
cd "$(dirname "$0")/.."
docker compose stop api
docker compose restart db cache
docker compose up -d --wait db cache
docker compose up -d --wait api
+87
View File
@@ -0,0 +1,87 @@
#!/bin/sh
# Фаза backup трека 2 (подключается из run.sh): pg_dump -> восстановление в НОВОЕ хранилище -> сверка.
# 1) контрольные суммы источника; 2) pg_dump -Fc; 3) запись ещё 100 сообщений в источник ПОСЛЕ backup (граница потери данных);
# 4) pg_restore в новый контейнер с новым томом; 5) те же контрольные суммы на копии и diff; 6) API поверх копии отдаёт те же страницы.
now() { date +%s.%N; }
elapsed() { awk "BEGIN { printf \"%.1f\", $2 - $1 }"; }
host_path() { echo "$(pwd -W 2>/dev/null || pwd)/$1"; }
phase_backup() {
pw=$(cat "$WORK/pw")
verify() { docker exec -i "$1" psql -U postgres -d messenger -X -q -f - < scripts/track2/verify.sql; }
: > "$OUT/backup-timings.txt"
echo "== 1. состояние источника до backup"
verify "$SRC" > "$OUT/verify-source.txt"
cat "$OUT/verify-source.txt"
echo "== 2. pg_dump -Fc (без служебной схемы bench)"
t0=$(now)
docker exec "$SRC" pg_dump -U postgres -d messenger -Fc -N bench -f /tmp/messenger.dump
t1=$(now)
dump_bytes=$(docker exec "$SRC" stat -c %s /tmp/messenger.dump)
echo "pg_dump: $(elapsed "$t0" "$t1") с, размер дампа: $dump_bytes байт" | tee -a "$OUT/backup-timings.txt"
docker cp "$SRC":/tmp/messenger.dump "$WORK/messenger.dump"
echo "== 3. запись ПОСЛЕ backup: ещё 100 сообщений в источник"
src_psql -q -c "INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), (SELECT medium FROM bench.params), (SELECT sender FROM bench.params), 'after-backup ' || g, now() + g * interval '1 ms'
FROM generate_series(1, 100) g"
source_total=$(scalar "SELECT count(*) FROM messages")
echo "в источнике теперь $source_total сообщений" | tee -a "$OUT/backup-timings.txt"
echo "== 4. восстановление в новое хранилище (новый контейнер, новый том)"
docker volume create track2_restore >/dev/null
docker run -d --name "$RST" --network "$NET" -e POSTGRES_PASSWORD="$pw" -e POSTGRES_DB=postgres \
-v track2_restore:/var/lib/postgresql/data "$IMG" >/dev/null
wait_ready "$RST"; sleep 3; wait_ready "$RST"
docker exec "$RST" createdb -U postgres messenger
docker cp "$WORK/messenger.dump" "$RST":/tmp/messenger.dump
t2=$(now)
docker exec "$RST" pg_restore -U postgres -d messenger --exit-on-error --jobs 4 /tmp/messenger.dump
t3=$(now)
docker exec "$RST" psql -U postgres -d messenger -q -c "ANALYZE" # статистика планировщика не восстанавливается
t4=$(now)
echo "pg_restore (--jobs 4): $(elapsed "$t2" "$t3") с; ANALYZE: $(elapsed "$t3" "$t4") с; итого до готовности к работе: $(elapsed "$t2" "$t4") с" | tee -a "$OUT/backup-timings.txt"
docker volume ls --format '{{.Name}}' | grep track2 | tee "$OUT/volumes.txt"
echo "== 5. сверка копии с состоянием источника ДО backup"
verify "$RST" > "$OUT/verify-restored.txt"
if diff "$OUT/verify-source.txt" "$OUT/verify-restored.txt" > "$OUT/verify-diff.txt"; then
echo "СОВПАДАЕТ: все контрольные суммы и числа строк идентичны" | tee -a "$OUT/backup-timings.txt"
else
echo "РАСХОЖДЕНИЕ:"; cat "$OUT/verify-diff.txt"; exit 1
fi
restored_total=$(docker exec "$RST" psql -U postgres -d messenger -At -c "SELECT count(*) FROM messages")
echo "сообщений в копии: $restored_total; в источнике: $source_total; потеряно (записано после backup): $((source_total - restored_total))" | tee -a "$OUT/backup-timings.txt"
echo "== 6. приложение поверх копии отдаёт те же данные, что и поверх источника"
printf 'Host=%s;Port=5432;Database=messenger;Username=postgres;Password=%s' "$SRC" "$pw" > "$WORK/url-src"
printf 'Host=%s;Port=5432;Database=messenger;Username=postgres;Password=%s' "$RST" "$pw" > "$WORK/url-restore"
docker run -d --name track2-api-src --network "$NET" -p 18081:8080 -e DATABASE_URL_FILE=/run/secrets/database_url \
-v "$(host_path "$WORK/url-src"):/run/secrets/database_url:ro" messenger-api:lab2 >/dev/null
docker run -d --name track2-api-restore --network "$NET" -p 18082:8080 -e DATABASE_URL_FILE=/run/secrets/database_url \
-v "$(host_path "$WORK/url-restore"):/run/secrets/database_url:ro" messenger-api:lab2 >/dev/null
for port in 18081 18082; do
for _ in $(seq 1 60); do curl -sf "http://localhost:$port/health/ready" >/dev/null && break; sleep 1; done
done
big=$(scalar "SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC, chat_id LIMIT 1")
token=track2-experiment-token
echo "сессия, созданная до backup, действует на копии: GET /users/me -> $(curl -s -o /dev/null -w '%{http_code}' http://localhost:18082/api/v1/users/me -H "Authorization: Bearer $token")" | tee -a "$OUT/backup-timings.txt"
cursor=""; same=0
for page in 1 2 3 4 5 6 7 8; do
for port in 18081 18082; do
if [ -z "$cursor" ]; then
curl -s -G "http://localhost:$port/api/v1/chats/$big/messages" --data-urlencode "limit=100" -H "Authorization: Bearer $token" > "$WORK/page-$port.json"
else
curl -s -G "http://localhost:$port/api/v1/chats/$big/messages" --data-urlencode "limit=100" --data-urlencode "cursor=$cursor" -H "Authorization: Bearer $token" > "$WORK/page-$port.json"
fi
done
cmp -s "$WORK/page-18081.json" "$WORK/page-18082.json" || { echo "страница $page различается"; exit 1; }
same=$((same + 1))
cursor=$(sed -n 's/.*"next_cursor":"\([^"]*\)".*/\1/p' "$WORK/page-18081.json")
[ -n "$cursor" ] || break
done
echo "страницы истории большого чата через API (источник и копия) совпадают побайтно: $same из $same" | tee -a "$OUT/backup-timings.txt"
}
+31
View File
@@ -0,0 +1,31 @@
-- Планы запросов страницы истории для текущего варианта индекса (EXPLAIN (ANALYZE, BUFFERS)).
-- Переменные psql: big, small, mid_t, mid_id, end_t, end_id (задаёт run.sh). Запрос — тот, что генерирует EF.
\set ON_ERROR_STOP on
\pset pager off
\echo '--- Q1 первая страница большого чата (80 000), keyset'
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF, TIMING OFF)
SELECT m.id, m.chat_id, m.created_at, m.sender_id, m.text
FROM (SELECT * FROM messages WHERE chat_id = :'big') AS m ORDER BY m.created_at, m.id LIMIT 51;
\echo '--- Q2 страница из середины большого чата, keyset'
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF, TIMING OFF)
SELECT m.id, m.chat_id, m.created_at, m.sender_id, m.text
FROM (SELECT * FROM messages WHERE chat_id = :'big' AND (created_at, id) > (:'mid_t', :'mid_id')) AS m
ORDER BY m.created_at, m.id LIMIT 51;
\echo '--- Q3 последняя страница большого чата, keyset'
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF, TIMING OFF)
SELECT m.id, m.chat_id, m.created_at, m.sender_id, m.text
FROM (SELECT * FROM messages WHERE chat_id = :'big' AND (created_at, id) > (:'end_t', :'end_id')) AS m
ORDER BY m.created_at, m.id LIMIT 51;
\echo '--- Q4 маленький чат (5 сообщений)'
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF, TIMING OFF)
SELECT m.id, m.chat_id, m.created_at, m.sender_id, m.text
FROM (SELECT * FROM messages WHERE chat_id = :'small') AS m ORDER BY m.created_at, m.id LIMIT 51;
\echo '--- Q5 середина большого чата, OFFSET 40000 (для сравнения с keyset)'
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF, TIMING OFF)
SELECT m.id, m.chat_id, m.created_at, m.sender_id, m.text
FROM messages m WHERE m.chat_id = :'big' ORDER BY m.created_at, m.id OFFSET 40000 LIMIT 51;
+7
View File
@@ -0,0 +1,7 @@
-- Профиль чтения: страница истории большого чата с курсором случайной глубины (keyset), LIMIT 51 как в API (limit=50 + 1).
-- Параметры: -D big='uuid' -D ncur=<число курсоров в bench.cursors>.
\set k random(1, :ncur)
SELECT quote_literal(t::text) AS ct, quote_literal(id::text) AS cid FROM bench.cursors WHERE n = :k \gset
SELECT m.id, m.chat_id, m.created_at, m.sender_id, m.text
FROM (SELECT * FROM messages WHERE chat_id = :big AND (created_at, id) > (:ct::timestamptz, :cid::uuid)) AS m
ORDER BY m.created_at, m.id LIMIT 51;
+146
View File
@@ -0,0 +1,146 @@
#!/bin/sh
# Трек 2: план запроса, стоимость индексов и backup/restore. Изолированный стенд: свои контейнеры, сеть и тома track2-*;
# стенд compose (messenger-lab2) не затрагивается. Фазы: up | indexes | backup | down. Сырые результаты — в evidence/track2/.
# sh scripts/track2/run.sh up # контейнер PostgreSQL, миграции приложения, 115 000 сообщений
# sh scripts/track2/run.sh indexes # сравнение вариантов индекса: планы, размер, pgbench записи/чтения
# sh scripts/track2/run.sh backup # pg_dump -> восстановление в новое хранилище -> сверка
# sh scripts/track2/run.sh down # удалить всё
# Требуются Docker, .NET SDK (dotnet tool restore уже выполнен), образ messenger-api:lab2 (docker compose build) для фазы backup.
set -eu
cd "$(dirname "$0")/../.."
export MSYS_NO_PATHCONV=1 # Git Bash на Windows не должен переписывать пути внутри docker exec
OUT=evidence/track2
NET=track2net
SRC=track2-src
RST=track2-restore
IMG=$(grep -o 'postgres:17@sha256:[0-9a-f]*' compose.yaml | head -1)
WORK=scripts/track2/.work # относительный путь: его понимают и dotnet.exe, и POSIX-оболочка
mkdir -p "$OUT" "$WORK"
. scripts/track2/backup.sh
src_psql() { docker exec -i "$SRC" psql -U postgres -d messenger -v ON_ERROR_STOP=1 "$@"; }
scalar() { src_psql -At -c "$1"; }
wait_ready() { # $1 — контейнер
for _ in $(seq 1 60); do
docker exec "$1" pg_isready -U postgres -d messenger >/dev/null 2>&1 && return 0
sleep 1
done
echo "контейнер $1 не готов" >&2; exit 1
}
phase_up() {
[ -f "$WORK/pw" ] || LC_ALL=C tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 24 > "$WORK/pw"
docker network inspect "$NET" >/dev/null 2>&1 || docker network create "$NET" >/dev/null
docker volume create track2_src >/dev/null
docker run -d --name "$SRC" --network "$NET" -e POSTGRES_PASSWORD="$(cat "$WORK/pw")" -e POSTGRES_DB=messenger \
-v track2_src:/var/lib/postgresql/data "$IMG" >/dev/null
wait_ready "$SRC"; sleep 2; wait_ready "$SRC"
# Схема — те же миграции EF Core, что применяет приложение.
dotnet tool run dotnet-ef migrations script --project scr/Messenger.Api -o "$WORK/schema.sql" >/dev/null
src_psql -q < "$WORK/schema.sql"
echo "seed..."; src_psql -q < scripts/track2/seed.sql
src_psql -c "SELECT (SELECT count(*) FROM messages) AS messages, (SELECT count(*) FROM chats) AS chats, (SELECT max(c) FROM (SELECT count(*) c FROM messages GROUP BY chat_id) s) AS biggest_chat" \
| tee "$OUT/seed-summary.txt"
}
# Варианты индекса истории: имя | определение.
create_variant() {
case "$1" in
none) : ;;
hist) src_psql -q -c "CREATE INDEX ix_t2_hist ON messages (chat_id, created_at, id)" ;;
nosort) src_psql -q -c "CREATE INDEX ix_t2_nosort ON messages (chat_id, created_at)" ;;
covering) src_psql -q -c "CREATE INDEX ix_t2_covering ON messages (chat_id, created_at, id) INCLUDE (sender_id, text)" ;;
esac
}
bench_lines() { # tps и средняя задержка из вывода pgbench
grep -E "^(tps|latency average|number of transactions actually processed)" | tr '\n' ' '; echo
}
phase_indexes() {
big=$(scalar "SELECT big FROM bench.params"); medium=$(scalar "SELECT medium FROM bench.params")
small=$(scalar "SELECT small FROM bench.params"); sender=$(scalar "SELECT sender FROM bench.params")
ncur=$(scalar "SELECT count(*) FROM bench.cursors")
mid_t=$(scalar "SELECT t FROM bench.cursors WHERE n = (SELECT count(*)/2 FROM bench.cursors)")
mid_id=$(scalar "SELECT id FROM bench.cursors WHERE n = (SELECT count(*)/2 FROM bench.cursors)")
end_t=$(scalar "SELECT t FROM bench.cursors WHERE n = (SELECT max(n) FROM bench.cursors)")
end_id=$(scalar "SELECT id FROM bench.cursors WHERE n = (SELECT max(n) FROM bench.cursors)")
docker cp scripts/track2/write.pgbench "$SRC":/tmp/write.pgbench
docker cp scripts/track2/read.pgbench "$SRC":/tmp/read.pgbench
: > "$OUT/variants-summary.txt"
for v in none hist nosort covering; do
echo "=== variant: $v"
# Чистое состояние: удалить строки прошлых прогонов записи, пересобрать таблицу, оставить только индексы варианта.
src_psql -q -c "DELETE FROM messages WHERE text LIKE 'bench %'"
src_psql -q -c "VACUUM FULL messages"
src_psql -q -c "DROP INDEX IF EXISTS ix_messages_chat_history, ix_t2_hist, ix_t2_nosort, ix_t2_covering"
create_variant "$v"
src_psql -q -c "ANALYZE messages"
size=$(scalar "SELECT coalesce((SELECT pg_size_pretty(pg_relation_size(c.oid)) FROM pg_class c WHERE c.relname = 'ix_t2_$v'), '-')")
# Планы снимаются на втором (прогретом) запуске: первый только заполняет shared buffers.
for pass in 1 2; do
src_psql -q -v big="$big" -v small="$small" -v mid_t="$mid_t" -v mid_id="$mid_id" -v end_t="$end_t" -v end_id="$end_id" \
-f - < scripts/track2/plans.sql > "$OUT/plans-$v.txt"
done
# Индекс с INCLUDE (text) ограничен размером строки B-дерева (~2700 байт): проверяем сообщение максимальной длины 4000 символов.
limit_msg=$(src_psql -At -c "BEGIN; INSERT INTO messages (id, chat_id, sender_id, text, created_at) SELECT gen_random_uuid(), '$small', '$sender', (SELECT string_agg(chr(33 + (random()*93)::int), '') FROM generate_series(1,4000)), now(); ROLLBACK;" 2>&1 | grep -E "ERROR|INSERT" | head -1 || true)
echo "read:" > "$WORK/bench.tmp"
for i in 1 2 3; do
docker exec "$SRC" pgbench -U postgres -d messenger -n -c 4 -j 2 -T 10 -f /tmp/read.pgbench \
-D big="'$big'" -D ncur="$ncur" 2>&1 | bench_lines >> "$WORK/bench.tmp"
done
echo "write:" >> "$WORK/bench.tmp"
lsn0=$(scalar "SELECT pg_current_wal_lsn()")
for i in 1 2 3; do
docker exec "$SRC" pgbench -U postgres -d messenger -n -c 4 -j 2 -T 10 -f /tmp/write.pgbench \
-D big="'$big'" -D medium="'$medium'" -D sender="'$sender'" 2>&1 | bench_lines >> "$WORK/bench.tmp"
done
# Размер индекса после нагрузки записи — до bulk-вставки: её откат оставляет мёртвые записи в индексе.
idx_after=$(scalar "SELECT coalesce((SELECT pg_size_pretty(pg_relation_size(c.oid)) FROM pg_class c WHERE c.relname = 'ix_t2_$v'), '-')")
wal_bytes=$(scalar "SELECT pg_wal_lsn_diff(pg_current_wal_lsn(), '$lsn0')")
wal_rows=$(scalar "SELECT count(*) FROM messages WHERE text LIKE 'bench %'")
wal_per_row=$(awk "BEGIN { printf \"%.0f\", $wal_bytes / $wal_rows }")
# Bulk-вставка 100 000 строк в большой чат одним оператором (без fsync на каждую строку): чистая стоимость поддержки индекса.
bulk=$(src_psql -At -c "BEGIN; EXPLAIN (ANALYZE, WAL, COSTS OFF, TIMING OFF) INSERT INTO messages (id, chat_id, sender_id, text, created_at) SELECT gen_random_uuid(), '$big', '$sender', 'bulk ' || g, timestamptz '2027-01-01' + g * interval '1 second' FROM generate_series(1, 100000) g; ROLLBACK;" | grep -E "Execution Time|WAL:" | tr '
' ' ')
{
echo "### $v"
echo "index_size_before_writes: $size ; index_size_after_writes: $idx_after"
echo "insert_4000_chars: ${limit_msg:-ok}"
echo "wal_bytes_per_inserted_row (pgbench, 1 строка = 1 транзакция): $wal_per_row"
echo "bulk_insert_100000_rows: $bulk"
cat "$WORK/bench.tmp"
echo
} | tee -a "$OUT/variants-summary.txt"
cp "$WORK/bench.tmp" "$OUT/pgbench-$v.txt"
done
# Вернуть канонический индекс приложения (как в миграции), убрать строки нагрузки.
src_psql -q -c "DELETE FROM messages WHERE text LIKE 'bench %'"
src_psql -q -c "VACUUM FULL messages"
src_psql -q -c "DROP INDEX IF EXISTS ix_t2_hist, ix_t2_nosort, ix_t2_covering"
src_psql -q -c "CREATE INDEX ix_messages_chat_history ON messages (chat_id, created_at, id)"
src_psql -q -c "ANALYZE"
}
phase_down() {
docker rm -f track2-api-src track2-api-restore "$RST" "$SRC" >/dev/null 2>&1 || true
docker volume rm track2_src track2_restore >/dev/null 2>&1 || true
docker network rm "$NET" >/dev/null 2>&1 || true
rm -rf "$WORK"
}
case "${1:-}" in
up) phase_up ;;
indexes) phase_indexes ;;
backup) phase_backup ;;
down) phase_down ;;
*) echo "usage: $0 up|indexes|backup|down" >&2; exit 2 ;;
esac
+49
View File
@@ -0,0 +1,49 @@
-- Трек 2: синтетические данные. 115 000 сообщений в неравномерных чатах:
-- 1 чат — 80 000, 1 чат — 20 000, 5 чатов — по 1 000, 2 000 чатов — по 5.
-- Порядок вставки перемешан (ORDER BY random()): строки одного чата лежат в куче вперемешку, как при реальной записи.
-- Вспомогательные таблицы эксперимента лежат в схеме bench и в backup не включаются (pg_dump -N bench).
\set ON_ERROR_STOP on
INSERT INTO users (id, username, display_name, password_hash, created_at)
SELECT gen_random_uuid(), 'seed_user_' || g, 'Seed', 'not-a-real-hash', now() FROM generate_series(1, 3) g;
CREATE TEMP TABLE seed_chats AS
SELECT gen_random_uuid() AS id, n,
CASE WHEN n = 1 THEN 80000 WHEN n = 2 THEN 20000 WHEN n <= 7 THEN 1000 ELSE 5 END AS msgs
FROM generate_series(1, 2007) n;
INSERT INTO chats (id, title, created_at, history_version)
SELECT id, 'seed ' || n, now() + n * interval '1 millisecond', msgs FROM seed_chats;
INSERT INTO chat_members (chat_id, user_id)
SELECT c.id, u.id FROM seed_chats c CROSS JOIN users u;
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), c.id, s.id, 'message ' || g || ' ' || md5(random()::text),
timestamptz '2026-01-01 00:00:00+00' + g * interval '1 second'
FROM seed_chats c
CROSS JOIN LATERAL generate_series(1, c.msgs) g
CROSS JOIN (SELECT id FROM users WHERE username = 'seed_user_1') s
ORDER BY random();
-- Сессия с известным токеном, чтобы после restore можно было сходить в API под этим пользователем.
-- Токен учебный и одноразовый; в БД хранится только его SHA-256, как в приложении.
INSERT INTO sessions (id, token_hash, user_id, created_at, expires_at)
SELECT gen_random_uuid(), sha256(convert_to('track2-experiment-token', 'UTF8')), id, now(), now() + interval '30 days'
FROM users WHERE username = 'seed_user_1';
-- Параметры и курсоры эксперимента (каждое 51-е сообщение большого чата — случайная «глубина» страницы).
CREATE SCHEMA bench;
CREATE TABLE bench.params AS
SELECT (SELECT id FROM seed_chats WHERE n = 1) AS big,
(SELECT id FROM seed_chats WHERE n = 2) AS medium,
(SELECT id FROM seed_chats WHERE n = 8) AS small,
(SELECT id FROM users WHERE username = 'seed_user_1') AS sender;
CREATE TABLE bench.cursors AS
SELECT row_number() OVER (ORDER BY rn) AS n, created_at AS t, id
FROM (SELECT created_at, id, row_number() OVER (ORDER BY created_at, id) AS rn
FROM messages WHERE chat_id = (SELECT big FROM bench.params)) x
WHERE rn % 51 = 0;
ANALYZE;
+40
View File
@@ -0,0 +1,40 @@
-- Сверка двух баз после восстановления: одинаковые числа строк и контрольные суммы. Запускается на источнике и на копии,
-- результаты сравниваются построчно (diff). Хеши считаются от полного содержимого строк в детерминированном порядке.
\pset format unaligned
\pset tuples_only on
\pset fieldsep '|'
SELECT 'users', count(*), md5(string_agg(concat_ws('|', id, username, display_name, password_hash, created_at), ',' ORDER BY id)) FROM users
UNION ALL
SELECT 'chats', count(*), md5(string_agg(concat_ws('|', id, title, created_at, history_version, last_message_at), ',' ORDER BY id)) FROM chats
UNION ALL
SELECT 'chat_members', count(*), md5(string_agg(chat_id::text || user_id::text, ',' ORDER BY chat_id, user_id)) FROM chat_members
UNION ALL
SELECT 'messages (вся таблица)', count(*), md5(string_agg(concat_ws('|', id, chat_id, sender_id, text, created_at), ',' ORDER BY id)) FROM messages
UNION ALL
SELECT 'sessions', count(*), md5(string_agg(concat_ws('|', id, encode(token_hash, 'hex'), user_id, created_at, expires_at, revoked_at), ',' ORDER BY id)) FROM sessions
UNION ALL
SELECT 'ef_migrations', count(*), md5(string_agg(migration_id || product_version, ',' ORDER BY migration_id)) FROM "__EFMigrationsHistory"
UNION ALL
-- Распределение сообщений по чатам (неравномерность сохранилась).
SELECT 'сообщений по чатам', count(*), md5(string_agg(chat_id::text || ':' || c, ',' ORDER BY chat_id))
FROM (SELECT chat_id, count(*) c FROM messages GROUP BY chat_id) t
UNION ALL
-- Выбранные сообщения: первые 100 и последние 100 самого большого чата.
SELECT 'большой чат: первые 100', count(*), md5(string_agg(id::text || text || created_at::text, ',' ORDER BY created_at, id))
FROM (SELECT * FROM messages WHERE chat_id = (SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC, chat_id LIMIT 1)
ORDER BY created_at, id LIMIT 100) t
UNION ALL
SELECT 'большой чат: последние 100', count(*), md5(string_agg(id::text || text || created_at::text, ',' ORDER BY created_at, id))
FROM (SELECT * FROM messages WHERE chat_id = (SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC, chat_id LIMIT 1)
ORDER BY created_at DESC, id DESC LIMIT 100) t
UNION ALL
-- Детерминированная выборка ~1 из 115 сообщений по всей таблице (около тысячи сообщений из разных чатов).
SELECT 'выборка ~1/115', count(*), md5(string_agg(id::text || chat_id::text || text || created_at::text, ',' ORDER BY id))
FROM messages WHERE ('x' || substr(md5(id::text), 1, 8))::bit(32)::int % 115 = 0
UNION ALL
-- Схема: индексы и ограничения совпадают с исходными.
SELECT 'индексы', count(*), md5(string_agg(indexdef, ',' ORDER BY indexname)) FROM pg_indexes WHERE schemaname = 'public'
UNION ALL
SELECT 'ограничения', count(*), md5(string_agg(conname || pg_get_constraintdef(oid), ',' ORDER BY conname))
FROM pg_constraint WHERE connamespace = 'public'::regnamespace;
+10
View File
@@ -0,0 +1,10 @@
-- Профиль записи: 80% сообщений в «горячий» большой чат, 20% в средний. Одно сообщение — одна транзакция (как POST).
-- Параметры: -D big='uuid' -D medium='uuid' -D sender='uuid' (значения передаются вместе с кавычками).
\set r random(1, 100)
\if :r <= 80
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES (gen_random_uuid(), :big, :sender, 'bench ' || :client_id, clock_timestamp());
\else
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES (gen_random_uuid(), :medium, :sender, 'bench ' || :client_id, clock_timestamp());
\endif
+62
View File
@@ -0,0 +1,62 @@
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
namespace LoadTest
{
internal sealed record TestUser(Guid Id, string Username);
internal class Helpers
{
public static StringContent Json(string raw) =>
new(raw, Encoding.UTF8, "application/json");
public static HttpRequestMessage Request(HttpMethod method, string url, Guid? userId = null, HttpContent? content = null)
{
var request = new HttpRequestMessage(method, url) { Content = content };
if (userId is not null)
{
request.Headers.Add("X-User-Id", userId.Value.ToString());
}
return request;
}
public static async Task<JsonElement> ReadJsonAsync(HttpResponseMessage response)
{
var body = await response.Content.ReadAsStringAsync();
return JsonDocument.Parse(body).RootElement.Clone();
}
public static async Task<TestUser> CreateUserAsync(HttpClient client, string? username = null)
{
username ??= "u" + Guid.NewGuid().ToString("N")[..12];
var response = await client.PostAsJsonAsync("/api/v1/users",
new { username, display_name = "Тест" });
var json = await ReadJsonAsync(response);
response.EnsureSuccessStatusCode();
return new TestUser(json.GetProperty("id").GetGuid(), username);
}
public static async Task<Guid> CreateChatAsync(HttpClient client, TestUser owner, params TestUser[] others)
{
var members = others.Append(owner).Select(u => u.Id).ToArray();
using var request = Request(HttpMethod.Post, "/api/v1/chats", owner.Id,
JsonContent.Create(new { title = "Чат", member_ids = members }));
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
return (await ReadJsonAsync(response)).GetProperty("id").GetGuid();
}
public static async Task<HttpResponseMessage> SendMessageAsync(HttpClient client, TestUser sender, Guid chatId, string text)
{
using var request = Request(HttpMethod.Post, $"/api/v1/chats/{chatId}/messages", sender.Id,
JsonContent.Create(new { text }));
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
return response;
}
}
}
+10
View File
@@ -0,0 +1,10 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net10.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
</Project>
+143
View File
@@ -0,0 +1,143 @@
using System.Diagnostics;
namespace LoadTest
{
/// <summary>Пользователь и чат с заранее залитой историей; Cursor — позиция нужной страницы (null = первая).</summary>
internal sealed record Scenario(Guid UserId, Guid ChatId, string? Cursor);
/// <summary>Сырые данные измерения: задержки успешных запросов, число ошибок и фактическая длительность.</summary>
internal sealed record MeasureResult(List<double> LatenciesMs, int Errors, double ElapsedSeconds);
internal sealed record Summary(
int Successful,
int Errors,
double ElapsedSeconds,
double Rps,
double P50Ms,
double P95Ms,
double P99Ms,
double MaxMs);
internal static class Phases
{
/// <summary>Создаёт пользователя и чат и заливает historySize сообщений не более чем в fillConcurrency потоков.</summary>
public static async Task<Scenario> PrepareAsync(
HttpClient client, int historySize, int fillConcurrency, int limit, bool lastPage)
{
var user = await Helpers.CreateUserAsync(client);
var chatId = await Helpers.CreateChatAsync(client, user);
var options = new ParallelOptions { MaxDegreeOfParallelism = fillConcurrency };
await Parallel.ForEachAsync(Enumerable.Range(0, historySize), options, async (i, _) =>
{
using var response = await Helpers.SendMessageAsync(client, user, chatId, $"history message {i}");
response.EnsureSuccessStatusCode();
});
string? cursor = null;
if (lastPage)
{
cursor = await FindLastPageCursorAsync(client, user, chatId, limit);
}
return new Scenario(user.Id, chatId, cursor);
}
public static async Task WarmUpAsync(
HttpClient client, Scenario scenario, int clients, TimeSpan duration, int limit)
{
// Результат прогрева отбрасывается: он нужен только для JIT, пулов потоков и соединений.
await MeasureAsync(client, scenario, clients, duration, limit);
}
/// <summary>Замкнутый цикл: каждый из clients клиентов шлёт GET страницы истории до истечения duration.</summary>
public static async Task<MeasureResult> MeasureAsync(
HttpClient client, Scenario scenario, int clients, TimeSpan duration, int limit)
{
var url = PageUrl(scenario.ChatId, limit, scenario.Cursor);
var started = Stopwatch.GetTimestamp();
var deadline = started + (long)(duration.TotalSeconds * Stopwatch.Frequency);
// У каждого клиента свой список задержек: общей изменяемой структуры нет, блокировки не нужны.
var workers = Enumerable.Range(0, clients).Select(_ => Task.Run(async () =>
{
var latencies = new List<double>();
var errors = 0;
while (Stopwatch.GetTimestamp() < deadline)
{
var requestStarted = Stopwatch.GetTimestamp();
try
{
using var request = Helpers.Request(HttpMethod.Get, url, scenario.UserId);
// Тело читается целиком (буферизация по умолчанию), но не разбирается как JSON.
using var response = await client.SendAsync(request);
if (response.IsSuccessStatusCode)
{
latencies.Add(Stopwatch.GetElapsedTime(requestStarted).TotalMilliseconds);
}
else
{
errors++;
}
}
catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException)
{
errors++;
}
}
return (latencies, errors);
})).ToArray();
var results = await Task.WhenAll(workers);
var elapsed = Stopwatch.GetElapsedTime(started).TotalSeconds;
return new MeasureResult(
results.SelectMany(r => r.latencies).ToList(),
results.Sum(r => r.errors),
elapsed);
}
public static Summary GetResults(MeasureResult result)
{
var sorted = result.LatenciesMs.OrderBy(x => x).ToList();
double Percentile(double p) =>
sorted.Count == 0 ? double.NaN : sorted[Math.Max(0, (int)Math.Ceiling(p * sorted.Count) - 1)];
return new Summary(
sorted.Count,
result.Errors,
Math.Round(result.ElapsedSeconds, 3),
Math.Round(sorted.Count / result.ElapsedSeconds, 2),
Math.Round(Percentile(0.50), 3),
Math.Round(Percentile(0.95), 3),
Math.Round(Percentile(0.99), 3),
sorted.Count == 0 ? double.NaN : Math.Round(sorted[^1], 3));
}
private static string PageUrl(Guid chatId, int limit, string? cursor) =>
$"/api/v1/chats/{chatId}/messages?limit={limit}" +
(cursor is null ? "" : "&cursor=" + Uri.EscapeDataString(cursor));
/// <summary>Идёт по страницам до конца и возвращает cursor, с которым была запрошена последняя страница.</summary>
private static async Task<string?> FindLastPageCursorAsync(
HttpClient client, TestUser user, Guid chatId, int limit)
{
string? cursor = null;
while (true)
{
using var request = Helpers.Request(HttpMethod.Get, PageUrl(chatId, limit, cursor), user.Id);
using var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var page = await Helpers.ReadJsonAsync(response);
var next = page.GetProperty("next_cursor");
if (next.ValueKind == System.Text.Json.JsonValueKind.Null)
{
return cursor;
}
cursor = next.GetString();
}
}
}
}
+91
View File
@@ -0,0 +1,91 @@
using System.Text.Json;
using LoadTest;
// Использование (запускать в Release, сервер должен быть уже запущен):
// dotnet run -c Release --project tools/LoadTest -- --history 10000 --clients 8 --duration 15 \
// --container mtusi-messenger-lab1 --label before --output evidence/track1/results.jsonl
var options = ParseArguments(args);
string Get(string key, string fallback) => options.TryGetValue(key, out var value) ? value : fallback;
var url = Get("url", "http://127.0.0.1:8080");
var history = int.Parse(Get("history", "1000"));
var clients = int.Parse(Get("clients", "1"));
var duration = TimeSpan.FromSeconds(double.Parse(Get("duration", "15")));
var warmup = TimeSpan.FromSeconds(double.Parse(Get("warmup", "3")));
var limit = int.Parse(Get("limit", "50"));
var fillConcurrency = int.Parse(Get("fill-concurrency", "16"));
var lastPage = Get("page", "first") == "last";
var container = options.GetValueOrDefault("container");
var label = Get("label", "run");
var output = options.GetValueOrDefault("output");
using var client = new HttpClient { BaseAddress = new Uri(url), Timeout = TimeSpan.FromSeconds(30) };
var rssIdle = Rss.ReadMegabytes(container);
Console.Error.WriteLine($"[1/4] prepare: filling {history} messages ({fillConcurrency} parallel)...");
var scenario = await Phases.PrepareAsync(client, history, fillConcurrency, limit, lastPage);
var rssAfterPrepare = Rss.ReadMegabytes(container);
Console.Error.WriteLine($"[2/4] warm-up: {warmup.TotalSeconds} s, {clients} clients");
await Phases.WarmUpAsync(client, scenario, clients, warmup, limit);
Console.Error.WriteLine($"[3/4] measure: {duration.TotalSeconds} s, {clients} clients, page={(lastPage ? "last" : "first")}");
var measured = await Phases.MeasureAsync(client, scenario, clients, duration, limit);
var rssAfterMeasure = Rss.ReadMegabytes(container);
Console.Error.WriteLine("[4/4] results");
var summary = Phases.GetResults(measured);
var report = new
{
label,
timestamp = DateTimeOffset.UtcNow.ToString("O"),
history,
clients,
page = lastPage ? "last" : "first",
limit,
duration_seconds = duration.TotalSeconds,
successful_requests = summary.Successful,
errors = summary.Errors,
elapsed_seconds = summary.ElapsedSeconds,
rps = summary.Rps,
p50_ms = summary.P50Ms,
p95_ms = summary.P95Ms,
p99_ms = summary.P99Ms,
max_ms = summary.MaxMs,
rss_mb_idle = rssIdle,
rss_mb_after_prepare = rssAfterPrepare,
rss_mb_after_measure = rssAfterMeasure,
};
var json = JsonSerializer.Serialize(report, new JsonSerializerOptions { WriteIndented = false });
Console.WriteLine(JsonSerializer.Serialize(report, new JsonSerializerOptions { WriteIndented = true }));
if (output is not null)
{
Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(output))!);
File.AppendAllText(output, json + Environment.NewLine);
}
return summary.Errors == 0 && summary.Successful > 0 ? 0 : 1;
static Dictionary<string, string> ParseArguments(string[] args)
{
var result = new Dictionary<string, string>();
for (var i = 0; i < args.Length; i++)
{
if (!args[i].StartsWith("--"))
{
throw new ArgumentException($"Unexpected argument: {args[i]}");
}
if (i + 1 >= args.Length)
{
throw new ArgumentException($"Missing value for {args[i]}");
}
result[args[i][2..]] = args[++i];
}
return result;
}
+45
View File
@@ -0,0 +1,45 @@
using System.Diagnostics;
namespace LoadTest
{
internal static class Rss
{
/// <summary>
/// RSS процесса приложения в МБ: читает VmRSS из /proc/1/status внутри контейнера
/// (PID 1 — dotnet, ENTRYPOINT в exec-форме). Возвращает null, если контейнер не задан или недоступен.
/// </summary>
public static double? ReadMegabytes(string? container)
{
if (string.IsNullOrEmpty(container))
{
return null;
}
try
{
var info = new ProcessStartInfo("docker", ["exec", container, "cat", "/proc/1/status"])
{
RedirectStandardOutput = true,
RedirectStandardError = true,
};
using var process = Process.Start(info)!;
var output = process.StandardOutput.ReadToEnd();
process.WaitForExit();
var line = output.Split('\n').FirstOrDefault(l => l.StartsWith("VmRSS:"));
if (line is null)
{
return null;
}
var kb = double.Parse(line.Split(' ', StringSplitOptions.RemoveEmptyEntries)[1],
System.Globalization.CultureInfo.InvariantCulture);
return Math.Round(kb / 1024, 1);
}
catch (Exception)
{
return null;
}
}
}
}
+88
View File
@@ -0,0 +1,88 @@
<#
.SYNOPSIS
Track 1: матрица размер истории x число клиентов с перезапуском контейнера на каждую точку.
.EXAMPLE
# замеры "до" (образ уже собран)
.\tools\LoadTest\run-matrix.ps1 -Label before
# замеры "после": пересобрать образ и повторить те же точки
.\tools\LoadTest\run-matrix.ps1 -Label after -Rebuild
# быстрая проверка скрипта
.\tools\LoadTest\run-matrix.ps1 -Label smoke -Sizes 1000 -Clients 1 -Repeats 1 -Duration 3 -Warmup 2 -Output $env:TEMP\smoke.jsonl
#>
[CmdletBinding()]
param(
[string]$Label = 'before',
[int[]]$Sizes = @(1000, 10000, 50000),
[int[]]$Clients = @(1, 8, 32),
[int]$Repeats = 2,
[int]$Duration = 8,
[int]$Warmup = 5,
[string]$Cpus = '2',
[string]$Memory = '512m',
[string]$Output = 'evidence/track1/results.jsonl',
[string]$Image = 'mtusi-messenger:lab1',
[ValidateSet('first', 'last')][string]$Page = 'first',
[switch]$Rebuild
)
$ErrorActionPreference = 'Stop'
Set-Location (Resolve-Path (Join-Path $PSScriptRoot '..\..'))
$name = 'mtusi-messenger-lab1'
$url = 'http://127.0.0.1:8080'
function Remove-Api {
if (docker ps -aq --filter "name=^/$name$") {
docker rm -f $name | Out-Null
}
}
function Start-Api {
Remove-Api
docker run -d --rm --name $name --cpus $Cpus --memory $Memory `
-p 127.0.0.1:8080:8080 --env-file .env $Image | Out-Null
for ($i = 0; $i -lt 60; $i++) {
try {
if ((Invoke-WebRequest "$url/health/ready" -UseBasicParsing -TimeoutSec 2).StatusCode -eq 200) { return }
} catch { }
Start-Sleep -Milliseconds 500
}
throw 'API did not become ready within 30 s'
}
if ($Rebuild) {
Write-Host 'Rebuilding image...'
docker build -t $Image . | Out-Null
if ($LASTEXITCODE -ne 0) { throw 'docker build failed' }
}
dotnet build tools/LoadTest -c Release -v q | Out-Null
if ($LASTEXITCODE -ne 0) { throw 'LoadTest build failed' }
$points = @(foreach ($n in $Sizes) { foreach ($c in $Clients) { [pscustomobject]@{ History = $n; Clients = $c } } })
$total = $points.Count * $Repeats
$done = 0
$started = Get-Date
Write-Host "Label=$Label page=$Page points=$($points.Count) repeats=$Repeats runs=$total cpus=$Cpus memory=$Memory output=$Output"
try {
for ($rep = 1; $rep -le $Repeats; $rep++) {
# Случайный порядок точек в каждом повторе: эффект прогрева не должен совпасть с одним размером.
foreach ($p in ($points | Sort-Object { Get-Random })) {
$done++
Write-Host ("[{0}/{1}] rep={2} history={3} clients={4} (elapsed {5:mm\:ss})" -f $done, $total, $rep, $p.History, $p.Clients, ((Get-Date) - $started))
Start-Api
dotnet run -c Release --project tools/LoadTest --no-build -- `
--url $url --history $p.History --clients $p.Clients `
--duration $Duration --warmup $Warmup `
--page $Page --container $name --label "$Label-r$rep" --output $Output | Out-Null
if ($LASTEXITCODE -ne 0) { Write-Warning "run failed (exit $LASTEXITCODE), continuing" }
}
}
}
finally {
Remove-Api
}
Write-Host ("Done in {0:mm\:ss}. Results appended to {1}" -f ((Get-Date) - $started), $Output)
+76
View File
@@ -0,0 +1,76 @@
import json, statistics as st, collections, sys
path = sys.argv[1]
rows = [json.loads(l) for l in open(path, encoding='utf-8') if l.strip()]
def group(prefix, page='first'):
g = collections.defaultdict(list)
for r in rows:
if r['label'].startswith(prefix) and r['page'] == page:
g[(r['history'], r['clients'])].append(r)
return g
def mean(rs, k):
v = [r[k] for r in rs if r.get(k) is not None]
return st.mean(v)
def rng(rs, k):
v = [r[k] for r in rs if r.get(k) is not None]
return min(v), max(v)
before = group('before-r')
after = group('after-r')
out = []
out.append('Track 1: before/after summary (mean of repeats; page=first, limit=50; container --cpus=2 --memory=512m)')
out.append('')
hdr = f"{'N':>6} {'C':>3} {'runs':>4} | {'RPS before':>10} {'RPS after':>10} {'x':>6} | {'p50 b':>7} {'p50 a':>7} | {'p95 b':>7} {'p95 a':>7} | {'p99 b':>7} {'p99 a':>7} | {'RSS prep b/a':>12} {'RSS end b/a':>12} | err b/a"
out.append(hdr)
for key in sorted(set(before) | set(after)):
b, a = before.get(key, []), after.get(key, [])
if not b or not a:
continue
rb, ra = mean(b, 'rps'), mean(a, 'rps')
out.append(
f"{key[0]:>6} {key[1]:>3} {len(b):>1}/{len(a):<2} | {rb:>10.0f} {ra:>10.0f} {ra/rb:>6.1f} | "
f"{mean(b,'p50_ms'):>7.1f} {mean(a,'p50_ms'):>7.1f} | {mean(b,'p95_ms'):>7.1f} {mean(a,'p95_ms'):>7.1f} | "
f"{mean(b,'p99_ms'):>7.1f} {mean(a,'p99_ms'):>7.1f} | "
f"{mean(b,'rss_mb_after_prepare'):>5.0f}/{mean(a,'rss_mb_after_prepare'):<5.0f} {mean(b,'rss_mb_after_measure'):>5.0f}/{mean(a,'rss_mb_after_measure'):<5.0f} | "
f"{sum(r['errors'] for r in b)}/{sum(r['errors'] for r in a)}")
out.append('')
out.append('RPS spread (min-max across repeats):')
for key in sorted(set(before) | set(after)):
b, a = before.get(key, []), after.get(key, [])
if b and a:
out.append(f" N={key[0]:>6} C={key[1]:>2} before {rng(b,'rps')[0]:.0f}-{rng(b,'rps')[1]:.0f} after {rng(a,'rps')[0]:.0f}-{rng(a,'rps')[1]:.0f}")
out.append('')
out.append('Idle RSS (empty process, MB): before %.0f, after %.0f' % (
st.mean([r['rss_mb_idle'] for rs in before.values() for r in rs]),
st.mean([r['rss_mb_idle'] for rs in after.values() for r in rs])))
# last page vs first page at N=50000, C=8
bl, al = group('before-last', 'last'), group('after-last', 'last')
out.append('')
out.append('First vs last page, N=50000, C=8 (mean RPS / p95 ms):')
key = (50000, 8)
for name, g_first, g_last in (('before', before, bl), ('after', after, al)):
f, l = g_first.get(key, []), g_last.get(key, [])
if f and l:
out.append(f" {name}: first {mean(f,'rps'):.0f} rps / {mean(f,'p95_ms'):.1f} ms ({len(f)} runs); last {mean(l,'rps'):.0f} rps / {mean(l,'p95_ms'):.1f} ms ({len(l)} runs)")
# saturation: RPS growth with clients per N
out.append('')
out.append('Throughput vs clients (mean RPS):')
for name, g in (('before', before), ('after', after)):
for n in sorted({k[0] for k in g}):
out.append(f" {name} N={n:>6}: " + ' '.join(f"C={c}: {mean(g[(n,c)],'rps'):.0f}" for c in sorted({k[1] for k in g if k[0]==n})))
# per-message cost under saturation (before): 1000/rps at C=32 -> ms per request
out.append('')
out.append('Service time at saturation, C=32 (ms per request = 1000/RPS):')
for name, g in (('before', before), ('after', after)):
out.append(f" {name}: " + ' '.join(f"N={n}: {1000/mean(g[(n,32)],'rps'):.3f}" for n in sorted({k[0] for k in g}) if (n, 32) in g))
print('\n'.join(out))