ЛР2 - БВТ2301 - Никитин - на 5 #57

Closed
AndrewNikkk wants to merge 2 commits from AndrewNikkk/mtusi2026lab2:solution/bvt2301-nikitin into master
46 changed files with 6344 additions and 14 deletions
+2
View File
@@ -20,11 +20,13 @@ __pycache__/
node_modules/
dist/
build/
build-*/
target/
bin/
obj/
coverage/
*.log
!evidence/*.log
.DS_Store
.idea/
.vscode/
+33
View File
@@ -0,0 +1,33 @@
cmake_minimum_required(VERSION 3.16)
project(mtusi_messenger CXX)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
find_package(Threads REQUIRED)
find_package(PkgConfig REQUIRED)
pkg_check_modules(PQXX REQUIRED IMPORTED_TARGET libpqxx>=7.9)
pkg_check_modules(HIREDIS REQUIRED IMPORTED_TARGET hiredis)
pkg_check_modules(SODIUM REQUIRED IMPORTED_TARGET libsodium)
add_executable(messenger
src/main.cpp
src/db.cpp
src/auth.cpp
src/user_repo.cpp
src/chat_repo.cpp
src/message_repo.cpp
src/redis_pool.cpp
src/session_repo.cpp
src/pg_session_repo.cpp
)
target_include_directories(messenger PRIVATE src)
target_link_libraries(messenger PRIVATE
Threads::Threads
PkgConfig::PQXX
PkgConfig::HIREDIS
PkgConfig::SODIUM
)
+49
View File
@@ -0,0 +1,49 @@
FROM ubuntu:25.10 AS builder
RUN apt-get update && apt-get install -y --no-install-recommends \
build-essential \
cmake \
pkg-config \
libpqxx-dev \
libpq-dev \
libhiredis-dev \
libsodium-dev \
nlohmann-json3-dev \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /src
COPY CMakeLists.txt ./
COPY src ./src
COPY migrations ./migrations
RUN cmake -S . -B build -DCMAKE_BUILD_TYPE=Release \
&& cmake --build build -j
FROM ubuntu:25.10
RUN apt-get update && apt-get install -y --no-install-recommends \
ca-certificates \
curl \
libpqxx-7.10 \
libhiredis1.1.0 \
libsodium23 \
&& rm -rf /var/lib/apt/lists/* \
&& useradd --system --no-create-home --uid 10001 app
WORKDIR /app
COPY --from=builder /src/build/messenger /app/messenger
COPY --from=builder /src/migrations /app/migrations
RUN chown -R app:app /app
USER 10001
ENV APP_HOST=0.0.0.0
ENV APP_PORT=8080
EXPOSE 8080
HEALTHCHECK --interval=5s --timeout=3s --start-period=2s --retries=3 \
CMD curl -fsS http://127.0.0.1:8080/health/live || exit 1
CMD ["/app/messenger"]
+251 -14
View File
@@ -1,37 +1,274 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Автор, группа: Никитин Андрей Александрович БВТ2301
- Целевая оценка; выбранный трек 5: **5**, Track 2 (план запроса и восстановление)
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Использованные источники, библиотеки и помощь ИИ:
- libpqxx 7.10 (клиент PostgreSQL)
- hiredis 1.2 (клиент Redis/Valkey)
- libsodium 1.0.18 (Argon2id через `crypto_pwhash_str`)
- nlohmann/json 3.12 (парсинг и сборка JSON)
- Valkey 8 (сессии с AOF persistence)
- PostgreSQL 16; для Track 2 — `pgbench`, `pg_dump`/`pg_restore` из того же образа
- Инструкции курса, `contracts/openapi.json`, `contracts/README.md`
- DeepSeek
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
**Prerequisites:** Docker Engine 24+, Docker Compose v2, `make`, Python 3.9+ (для тестов курса), `psql` на хосте для отладки.
**Версии образов (зафиксированы):**
- `postgres:16-alpine`
- `valkey/valkey:8-alpine`
- `ubuntu:25.10` (обе стадии Dockerfile)
**Подготовка локальных secrets и `.env`:**
1. Создать `.env`:
cp .env.example .env
Заполнить `POSTGRES_USER`, `POSTGRES_PASSWORD`, `POSTGRES_DB` — синтетические локальные значения. `SESSION_TTL_SECONDS=3600`, `SESSION_STORE=redis`.
2. Создать файлы секретов (не попадают в Git, `secrets/` в `.gitignore`):
mkdir -p secrets
echo -n 'postgresql://USER:PASS@db:5432/DBNAME' > secrets/database_url
echo -n 'redis://cache:6379/0' > secrets/cache_url
Файлы без trailing newline. Пути передаются в контейнер через переменные `DATABASE_URL_FILE`/`CACHE_URL_FILE`, монтируются в `/run/secrets/` средствами Docker Compose secrets.
**Сборка и запуск:**
docker compose --env-file .env config --quiet # проверка синтаксиса
docker compose --env-file .env build api # сборка образа api
docker compose --env-file .env up -d # подъём стека
docker compose ps # ожидаем три healthy
docker compose logs api --tail=30 # миграции, пулы, listening
**Проверка готовности:** `curl -fsS http://127.0.0.1:8080/health/ready` → 200.
**Тесты:**
`make test # smoke`
`make test-persistence ACTION_SCRIPT=scripts/restart.sh # персистентность`
`make validate PYTHON=.venv/bin/python # OpenAPI-схема`
`python3 student-tests/test_api.py # собственные проверки контракта`
`python3 tests/level4.py # уровень 4: гонка, rollback, expiry, отказы db/cache`
`python3 scripts/collect_evidence.py # всё выше + миграции с нуля → evidence/*.log (~2 мин)`
`collect_evidence.py` проверяет миграции с нуля и `down -v` во временном compose-проекте `lab2fresh` со своими volumes и api на порту 18090; основной стенд и его данные не затрагиваются. Токены в логах маскируются.
**Остановка:**
- Безопасная (volumes сохраняются): `docker compose --env-file .env down`
- Намеренное удаление учебных данных: `docker compose --env-file .env down -v` (удаляет `pgdata`, `valkeydata` — все пользователи, чаты, сообщения и сессии потеряны). **Не запускать при проверках persistence/failover.**
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
**Процессы и хранилища:**
Клиент ──HTTP──> api (C++17, 8 worker-потоков)
│
├──> Postgres 16 (пользователи, чаты, участники, сообщения)
└──> Valkey 8 (сессии, TTL=3600s, AOF persistence)
**Источник истины:**
- Пользователи, чаты, состав участников, сообщения — **Postgres**. Переживает рестарт через `pgdata` (named volume).
- Сессии — **Valkey**. Ключ `session:<token>` = `user_id`, TTL задан командой `SET ... EX <ttl>`. AOF (`--appendonly yes`) обеспечивает выживание сессий после рестарта `cache`. Действующие сессии сохраняются именно из-за AOF; один TTL без persistence не выдержал бы рестарт.
**Транзакционные границы:**
- `POST /api/v1/users` — одиночный `INSERT` в `users`; уникальность `username` обеспечена `UNIQUE`-констрейнтом, гонка разрешается `pqxx::unique_violation` → `409 conflict`.
- `POST /api/v1/chats` — **одна транзакция**: `INSERT chats` + N × `INSERT chat_members`. FK-constraint (`chat_members.user_id → users.id`) гарантирует, что все участники существуют. Нарушение → откат транзакции → `400 invalid members`. Дубликаты в `member_ids` (без учёта регистра UUID) отклоняются до транзакции → `400 duplicate members`; на случай гонки `unique_violation` по PK `chat_members` тоже даёт откат и 400.
- `POST /api/v1/chats/{id}/messages` — одиночный `INSERT`, но предваряется `SELECT 1 FROM chat_members` в той же транзакции. Это проверка «отправитель — участник» на серверной стороне.
**Ограничения и защита:**
- Пароли: Argon2id через `crypto_pwhash_str` (параметры `INTERACTIVE`: m=64 MiB, t=2, p=1). В БД хранится только строка формата `$argon2id$...`, включающая соль и параметры.
- Токены сессий: 32 байта (`randombytes_buf`) → 64 hex-символа, 256 бит энтропии. Не UUID, не подделываемые.
- Пул Postgres: 8 соединений (равно числу worker-потоков). Перед выдачей соединение проверяется `SELECT 1`; мёртвое пересоздаётся. Если переподключиться не удалось, слот возвращается в пул, а запрос получает 503: пул не истощается при долгом отказе БД.
- Пул Redis: 4 соединения, та же схема с проверкой `PING`.
- Таймауты:
| Где | Значение |
| --- | --- |
| ожидание свободного соединения в обоих пулах | 3 s, затем 503 |
| PostgreSQL `connect_timeout` | 2 s |
| PostgreSQL `tcp_user_timeout` | 5 s |
| PostgreSQL `statement_timeout` (только соединения пула; миграции без лимита) | 5 s |
| Valkey: подключение (`redisConnectWithTimeout`) | 2 s |
| Valkey: чтение и запись (`redisSetTimeout`) | 2 s |
| HTTP-сокет клиента | 2 s |
- Ошибки зависимостей: потеря соединения, таймаут, SQLSTATE `08xxx`/`57xxx`, ошибки Valkey → `503 unavailable`; прочие исключения → `500 internal_error`. Недоступная БД при проверке пользователя сессии даёт 503, а не 401: запрос не обслуживается, но токен не объявляется недействительным.
- Все SQL-запросы параметризованы через `pqxx::params{}`. Конкатенация значений в SQL отсутствует.
**Порядок сообщений, часы и конкурентные вставки:**
- `created_at` назначает сервер API по своим часам с точностью до секунды; `id` — случайный UUIDv4. Порядок истории — `(created_at, id)`: внутри одной секунды порядок задаёт `id`, а не реальная последовательность отправки.
- Курсор — `<created_at в микросекундах>|<id>` последнего элемента страницы. Он сохраняет точное время строки, поэтому пагинация не повторяет сообщения, даже если в БД есть время с долями секунды (импорт, seed); в JSON время по-прежнему RFC 3339 с секундами. Невалидный курсор или курсор другого чата → 400.
- Обход неизменной истории не даёт повторов и пропусков. При конкурентных вставках возможна аномалия: сообщение, закоммиченное позже, может получить ту же секунду и меньший `id`, чем последний элемент уже прочитанной страницы, и тогда этот клиент его не увидит при продолжении обхода. Snapshot между HTTP-запросами контракт не требует. Часы одного API-процесса монотонность между репликами не гарантируют (актуально с lab3).
**Что перенесено из lab1:**
- HTTP-сервер на голых сокетах (свой парсер запроса, роутинг, `send_all`).
- 8 worker-потоков и очередь соединений.
- Graceful shutdown через `sigwait`.
- Ключевые схемы JSON-ответов (объекты `User`, `Chat`, `Message`, `ChatPage`, `MessagePage`).
- Keyset-пагинация по `(created_at, id)`.
**Что изменено:**
- JSON: свой парсер заменён на `nlohmann/json` (и вход, и выход).
- Состояние: in-memory `Store` удалён, всё в PostgreSQL через `UserRepo`, `ChatRepo`, `MessageRepo`.
- Аутентификация: `X-User-Id` заменён на Bearer-сессии; вход через `POST /auth/sessions` с Basic.
- Пароли: добавлена регистрация с `password`, Argon2id.
- Сессии: `SessionRepo` поверх Valkey с TTL и AOF.
- `/health/ready` проверяет доступность Postgres и, при `SESSION_STORE=redis`, Valkey; при `SESSION_STORE=postgres` Valkey не критичен и не подключается.
- Курсор пагинации: формат `<created_at в мкс>|<id>` с логикой **limit+1**, чтобы `next_cursor` был `null` на последней странице.
**Соответствие `.env.example` реальной конфигурации:**
| Переменная `.env.example` | Реальное значение | Комментарий |
| --- | --- | --- |
| `APP_HOST` | `0.0.0.0` | Слушаем на всех интерфейсах контейнера |
| `APP_PORT` | `8080` | Совпадает |
| `APP_ENV` | `lab` | Не используется в коде, оставлено для совместимости |
| `SESSION_TTL_SECONDS` | `3600` | TTL сессий в Valkey (можно 2 для проверки expiry) |
| `DATABASE_URL_FILE` | `/run/secrets/database_url` | Путь к файлу секрета внутри контейнера |
| `CACHE_URL_FILE` | `/run/secrets/cache_url` | То же для Redis |
| `SESSION_STORE` | `redis` | Источник истины сессий: `redis` (Valkey, основной режим) или `postgres` (таблица `sessions`, миграция 002) |
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Структура skeleton | `make check` | `PASS: offline skeleton structure, local refs and Python syntax` | `evidence/checks.log` |
| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/checks.log` |
| Полная OpenAPI-схема | `make validate PYTHON=.venv/bin/python` | `PASS: full OpenAPI 3.1 and JSON Schema validation` | `evidence/checks.log` |
| Собственные проверки контракта | `python3 student-tests/test_api.py` | `PASS student-tests`: валидация, Bearer/Basic/X-User-Id, доступ к чужому чату 404, пагинация, logout | `evidence/checks.log` |
| Персистентность | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session`; `docker compose ps` до: Up 13–14 min, после: Up 2–6 s у api, db, cache | `evidence/persistence.log` |
| Все данные в Postgres | `psql -c '\dt'` | 6 таблиц: `users`, `chats`, `chat_members`, `messages`, `sessions`, `schema_migrations`; миграции `1,2` | `evidence/level3.log` |
| Миграции с нуля и повторно | `collect_evidence.py migrations` (пустые volumes проекта `lab2fresh`) | `applied migration 1`, `applied migration 2`; после рестарта api — 0 строк `applied migration`, `schema_migrations` 2 строки, данные на месте | `evidence/migrations.log` |
| Атомарное создание чата | `POST /chats` с несуществующим участником | `400 invalid members`; чатов с этим title 0, строк `chat_members` 0 | `evidence/level3.log` |
| Basic только на `/auth/sessions` | Basic на `POST /auth/sessions` и на `GET /users/me` | 201 (токен 64 hex); 401 с `WWW-Authenticate: Bearer realm="messenger"` | `evidence/level3.log` |
| `X-User-Id` игнорируется | `X-User-Id: <id>` без Bearer на `/users/me` | 401 | `evidence/level3.log` |
| KDF паролей | 5 × `POST /users`, параметры hash в БД | медиана 132 ms на регистрацию; `argon2id$v=19$m=65536,t=2,p=1`; в ответе нет password/hash | `evidence/level3.log` |
| Неверный пароль | Basic с неверным паролем | 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"` | `evidence/level3.log` |
| Сессии переживают рестарт | `restart.sh` + тот же токен | тот же токен даёт 200 после рестарта api, db, cache | `evidence/persistence.log` |
| Logout работает | `DELETE /auth/sessions/current` + повторный запрос | 204 → 401 → повторный logout 401 | `evidence/level3.log` |
| Уровень 4: переключатель `SESSION_STORE` | `docker compose run --no-deps -e SESSION_STORE=postgres -p 18081:8080 api` + `make test BASE_URL=http://127.0.0.1:18081` | `session store: postgres` в логе, `PASS: lab2 public API scenario` | лог команды |
| Уровень 4: EXPLAIN на 10k+ | `EXPLAIN (ANALYZE, BUFFERS)` на чате из 15 000 сообщений | Index Scan по `messages_chat_keyset_idx`, 4–5 буферов на страницу; без индекса Seq Scan + Sort, 191 буфер | `evidence/explain.md` |
| Уровень 4: гонка, rollback, контракт | `python3 tests/level4.py` | гонка username: один 201, семь 409; rollback чата; дубликаты `member_ids` и невалидный/чужой cursor → 400; пагинация без повторов при долях секунды | `evidence/level4.log` |
| Уровень 4: expiry, logout, неверный пароль | там же (отдельный api с `SESSION_TTL_SECONDS=2` на порту 18080) | неверный пароль → 401; logout 204 → 401; токен через 3.5 s при TTL=2 → 401 | `evidence/level4.log` |
| Уровень 4: недоступность Redis/БД | там же | cache остановлен 21 s, db — 26 s; 10 и 16 запросов с валидным токеном (больше размера пулов) → 503; самый долгий ответ 0.02 s (cache) и 5.03 s (db, в другом прогоне 0.02 s) — в пределах таймаутов; после старта ready за 0.5 s, тот же токен → 200 | `evidence/level4.log` |
| Track 2: план запроса на ≥100k | `python3 scripts/track2_indexes.py` | 119 341 сообщение, 91 чат (1…33 892); индекс A: ≤51 строки и ≤54 буфера на любую страницу | `evidence/track2_indexes.md` |
| Track 2: стоимость записи | там же, `pgbench` 3 раунда × 4 варианта | WAL на вставку: 499 B без индекса, +27% с A, +45% с A+C | `evidence/track2_indexes.md` |
| Track 2: backup → restore → сверка | `python3 scripts/track2_restore.py` | PASS: 12 отпечатков и 12 страниц совпали; RTO 5.1 s; записи после backup в копии отсутствуют | `evidence/track2_restore.md` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
### Гипотезы и методики
#### Track 2. План запроса истории и восстановление
**Окружение.** Linux 7.0, 12 CPU, 14.8 GiB RAM, лимиты CPU/RAM у контейнеров не заданы. PostgreSQL 16.15 (`postgres:16-alpine`) с настройками по умолчанию: `synchronous_commit=on`, `shared_buffers=128MB`. Кэш тёплый: таблица `messages` (22 MB heap) целиком помещается в память. Даты прогонов: 2026-10-16, commit `65003b6` плюс незакоммиченные изменения.
**Данные.** `scripts/perf100k.py seed` детерминированно (`random.Random(42)`) создаёт Zipf-подобный профиль: 60 маленьких чатов (5…80 сообщений), 15 средних (100…1500), 4 больших (15 607…33 892). `seed-burst` добавляет чат из 5000 сообщений с одинаковым `created_at`. Это моделирует всплеск: приложение хранит время с точностью до секунды, и порядок внутри секунды задаёт только `id`. Всего 119 341 сообщение в 91 чате, размер чата min/median/max = 1/40/33 892.
**Воспроизведение:**
python3 scripts/perf100k.py seed && python3 scripts/perf100k.py seed-burst
python3 scripts/track2_indexes.py # ~6 мин, evidence/track2_indexes.md
python3 scripts/track2_restore.py # ~30 с, evidence/track2_restore.md
Скрипты запускают `psql`/`pgbench`/`pg_dump` внутри контейнеров; на хосте нужны только Docker и Python 3.9+. `track2_indexes.py` в конце возвращает индексы к состоянию миграций и снова включает autovacuum.
**Гипотезы:**
- **H1.** С индексом A `(chat_id, created_at, id)` страница истории читает ≈limit строк независимо от размера чата и глубины курсора. Без индекса читается вся таблица.
- **H2.** Индекс C `(chat_id, created_at)` без `id` равноценен A, пока `created_at` почти уникален, но деградирует, когда много сообщений приходится на одну секунду.
- **H3.** Каждый вторичный индекс удорожает INSERT.
- **H4.** `pg_dump -Fc` восстанавливается в новое пустое хранилище без расхождений.
- **H5.** Заметная доля времени восстановления уходит на построение индексов (секция post-data).
- **H6.** Граница потери данных логического backup — момент его снимка.
**Методика чтения.** Запросы те же, что в `MessageRepo::list_page`: `LIMIT 51` (limit+1), `ORDER BY created_at, id`. Q1 — первая страница, Q2 — keyset-курсор на середине чата, Q3 — `OFFSET` на той же глубине для контраста. Сравниваются три варианта: без вторичного индекса (только PK), C и A. Для каждого варианта индексы пересоздаются и выполняется `ANALYZE`. Замер — `EXPLAIN (ANALYZE, BUFFERS)`: 1 прогрев + 7 повторов, медиана Execution Time.
**Методика записи.** `pgbench -c 4 -T 15`: одна однострочная вставка на транзакцию, как `POST /messages`. Варианты: без индекса, C, A, A+C. Три раунда, порядок вариантов в каждом сдвигается. Перед каждым прогоном выполняются `DELETE` тестовых строк, `VACUUM` и `CHECKPOINT`; autovacuum на время бенча выключен. Метрики: TPS, средняя latency и байты WAL на вставку (`pg_wal_lsn_diff`). WAL почти не шумит, поэтому это основная метрика.
**Методика восстановления.** (1) 100 сообщений-маркеров «до» в служебный чат; (2) отпечаток исходной БД: `count(*)` и md5 упорядоченного содержимого всех таблиц, распределение по чатам, 12 страниц истории запросами приложения; (3) `pg_dump -Fc` в `backups/` (в `.gitignore`); (4) 37 маркеров «после»; (5) новый контейнер `postgres:16-alpine` с новым пустым volume и `pg_restore` по секциям с замером каждой; (6) сверка и удаление копии.
**Результаты: чтение** (ms, медиана / буферы / прочитано строк; полная матрица и планы в `evidence/track2_indexes.md`):
| Чат (сообщений) | Запрос | Без индекса | C `(chat_id, created_at)` | A `(chat_id, created_at, id)` |
| --- | --- | --- | --- | --- |
| small (50) | Q1 первая | 13.7 / 2819 / 119 341 | 0.426 / 10 / 50 | 0.339 / 10 / 50 |
| medium (1028) | Q2 keyset | 17.6 / 2819 / 119 341 | 0.546 / 62 / 53 | 0.350 / 51 / 51 |
| large (33 892) | Q1 первая | 32.5 / 2877 / 119 340 | 0.522 / 64 / 52 | 0.459 / 54 / 51 |
| large (33 892) | Q2 keyset | 25.3 / 2828 / 119 340 | 0.553 / 65 / 53 | 0.443 / 54 / 51 |
| large (33 892) | Q3 OFFSET | 62.6 / 2819 / 119 341 | 55.5 / 592 / 33 892 | 19.8 / 17 061 / 16 997 |
| burst (5000, одна секунда) | Q2 keyset | 17.7 / 2819 / 119 341 | 3.686 / 82 / 5000 | 0.456 / 54 / 51 |
**Результаты: запись** (3 прогона на вариант):
| Вариант | WAL, B/вставку | TPS, медиана (min–max) | latency, ms | Размер индекса |
| --- | --- | --- | --- | --- |
| только PK | 499 | 3396 (2749–3466) | 1.178 | PK 8.9 MiB |
| + C | 588 (+18%) | 3370 (3077–3474) | 1.187 | 4.4 MiB |
| + A | 634 (+27%) | 3322 (2866–3466) | 1.204 | 6.7 MiB |
| + A + C | 722 (+45%) | 3337 (2900–3401) | 1.199 | 11.1 MiB |
**Результаты: восстановление** (БД 45.6 MiB, дамп 3.6 MiB):
| Этап | Время, s |
| --- | --- |
| `pg_dump` | 1.51 |
| Запуск пустого PostgreSQL (initdb + старт) | 2.96 |
| Копирование дампа | 0.25 |
| `pg_restore` pre-data / data / post-data | 0.35 / 0.89 / 0.65 |
| **RTO от пустого хоста до готовой БД** | **5.09** |
Совпали все 12 отпечатков: счётчики и md5 `users`, `chats`, `chat_members`, `messages`, `sessions`, `schema_migrations`, распределение сообщений по чатам. Совпали и 12 страниц истории (первая, середина, последняя для чатов small/medium/large/burst). На копии тот же keyset-запрос использует `messages_chat_keyset_idx`. Маркеры: «до» в копии 100 из 100, «после» 0 из 37, хотя в исходной БД они подтверждены COMMIT.
**Выводы:**
- **H1 подтверждена.** С индексом A первая и keyset-страница на любом чате, включая середину чата из 33 892 сообщений и чат-всплеск, читают ≤51 строки и ≤54 буфера за ≤0.46 ms. Без индекса стоимость определяется размером всей таблицы, а не чата: даже чат из 50 сообщений делает Seq Scan всех 119k строк (2819 буферов), это в 40× медленнее. Для маленького чата планировщик с A выбирает Bitmap Scan и сортирует ≤50 строк в памяти; это дешевле, чем обход индекса.
- **H2 подтверждена.** На обычных чатах C почти не уступает A (0.553 против 0.443 ms): совпадений по секунде мало, и Incremental Sort сортирует крошечные группы. В чате-всплеске условие по `id` превращается в Filter, и C читает все 5000 строк группы: 3.7 ms против 0.46 ms у A, в 8 раз медленнее. Без `id` в ключе стоимость страницы растёт с числом сообщений за одну секунду, то есть именно под нагрузкой. Поэтому `id` в индексе обязателен.
- **OFFSET против keyset.** На середине большого чата `OFFSET` читает 16 997 строк (19.8 ms) против 51 у keyset (0.44 ms) и линейно дорожает с глубиной. Это подтверждает выбор keyset-пагинации.
- **H3 подтверждена по WAL.** Каждый индекс добавляет WAL: C +89 B (+18%), A +134 B (+27%), A+C +222 B (+45%) на вставку. Разница TPS (−1…2%) в пределах разброса прогонов: на 4 клиентах время транзакции определяет fsync при COMMIT, а не обновление индекса. Цена индекса — диск, WAL (а значит, репликация и backup) и место, а не заметная задержка на нашем объёме.
- **Решение по индексам:** оставить только A, как в миграции 001. Он обслуживает все страницы за константное число буферов. C экономит 2.3 MiB, но ломается на всплесках. A+C платит за запись дважды без выигрыша для чтения.
- **H4 подтверждена.** Логический дамп восстанавливается в новое хранилище без расхождений. `schema_migrations` восстанавливается, поэтому API, направленный на копию, не применяет миграции повторно.
- **H5 подтверждена.** post-data (PK, FK, индексы) заняла 32% времени `pg_restore`. Больше половины RTO (2.96 из 5.09 s) на нашем объёме — запуск пустого PostgreSQL. При росте данных доля data и post-data будет расти: COPY растёт линейно, построение индексов — как n·log n, а когда данные перестанут помещаться в RAM, добавится дисковый I/O. Ускорить можно через `pg_restore -j N` или физический backup (`pg_basebackup`), который не перестраивает индексы.
- **H6 подтверждена.** `pg_dump` читает один согласованный снимок на момент старта, поэтому RPO равен времени с начала последнего backup: при ежесуточном backup можно потерять до суток сообщений. Чтобы сократить RPO до секунд, нужен непрерывный архив WAL (`archive_mode` + pgBackRest/wal-g) с PITR или потоковая реплика.
- **Сессии и durability.** Сессии живут в Valkey и в дамп PostgreSQL не входят. Если Valkey цел, старые токены работают и с восстановленной БД, потому что `user_id` сохранились. Если Valkey потерян, пользователи логинятся заново; при AOF `appendfsync everysec` теряется до ~1 s новых сессий. COMMIT при `synchronous_commit=on` гарантирует запись в WAL на диск, то есть переживает рестарт, но не потерю volume. От потери volume защищает только копия на другом носителе.
**Ограничения эксперимента.** Один хост и тёплый кэш: время отражает CPU и число буферов, а не холодное чтение с диска. В EXPLAIN подставлены литералы, приложение работает с параметрами (generic plan не проверялся). Данные синтетические: один отправитель, короткие тексты. `pgbench` мерит только БД, без HTTP и Argon2. Дамп лежит на том же хосте, поэтому доказана процедура восстановления, а не защита от потери хоста. RTO не включает переключение API на новую БД (смена секрета `database_url` и рестарт api).
### Реакция на отказы
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `docker compose stop db` на 26 s | `/health/ready` и бизнес-запросы → 503 за ограниченное время; api жив | 16 запросов `/users/me` с валидным токеном, `POST /users`, `POST /auth/sessions` → 503 `unavailable`; самый долгий ответ от 0.02 до 5.03 s в разных прогонах, верхнюю границу задают таймауты соединения | После `start db` ready → 200 за 0.5 s, тот же токен → 200; данные не потеряны |
| `docker compose stop cache` на 21 s | То же для сессий | 10 запросов с токеном и вход → 503 за ≤0.03 s; анонимный доступ не открывается | После `start cache` ready → 200 за 0.5 s, тот же токен → 200 (AOF) |
| `restart.sh` (api + db + cache) | Тот же токен и данные после рестарта | PASS: `make test-persistence` | Полный рестарт ≈ 4–5 с; потери данных нет |
| `docker compose down` без `-v` | Volumes сохраняются, данные остаются | Данные на месте после `up -d` | — |
| `docker compose down -v` (во временном проекте `lab2fresh`) | Все данные теряются | После `down -v` и `up` пользователей 0, миграции применены заново (`evidence/migrations.log`) | Потеря всех данных и сессий; на основном стенде **не запускать**, кроме намеренного сброса |
| Потеря хранилища PostgreSQL, восстановление из `pg_dump` в новый volume (`scripts/track2_restore.py`) | Копия совпадает со снимком | PASS: 12 отпечатков и 12 страниц совпали | RTO 5.1 s при 45.6 MiB; теряется всё, что подтверждено после начала backup (0 из 37 маркеров в копии) |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- **Что выдерживается:** рестарт api, db, cache; недоступность одной из зависимостей (Postgres или Redis) — api остаётся живым и отвечает 503 на `/health/ready`.
- **Что не выдерживается:** одновременная потеря Postgres **и** Valkey — api продолжит отвечать 503 до восстановления обеих; горизонтальное масштабирование (нет LB, нет реплик api); миграции — однопоточные, не распределённые (что допустимо для лабораторной).
- **Потеря volume PostgreSQL:** восстанавливается из логического backup (Track 2), но теряется всё, что подтверждено после начала последнего `pg_dump`; backup хранится на том же хосте и не защищает от потери хоста.
- **Учебные упрощения:**
- нет rate limiting (в схеме есть `429`, но фактически не реализовано);
- нет `Idempotency-Key` (требуется с lab3, у нас lab2);
- нет вложений (требуются с lab4);
- нет `X-Instance-Id` (требуется с lab3);
- основной режим сессий — Valkey; режим `SESSION_STORE=postgres` проверен публичным smoke, но тесты отказов и persistence прогонялись только в режиме `redis`;
- нет фоновой очистки истёкших строк в `sessions` (режим `postgres`): они не принимаются по `expires_at > now()`, но занимают место.
- **Следующие шаги (за пределами этой работы):**
- репликация Postgres (streaming replication);
- распределённый rate limit через Valkey;
- OpenTelemetry метрики и трейсы;
- Argon2id с профилем `SENSITIVE` для проды (в lab7);
- архив WAL и PITR (pgBackRest/wal-g) для RPO в секунды вместо «с последнего `pg_dump`»;
- хранение backup вне Docker-хоста и регулярная автоматическая проверка восстановления.
+65
View File
@@ -0,0 +1,65 @@
services:
db:
image: postgres:16-alpine
environment:
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
POSTGRES_DB: ${POSTGRES_DB}
ports:
- 5432:5432
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
interval: 2s
timeout: 2s
retries: 30
cache:
image: valkey/valkey:8-alpine
command: ["valkey-server", "--appendonly", "yes"]
ports:
- 6379:6379
volumes:
- valkeydata:/data
healthcheck:
test: ["CMD", "valkey-cli", "ping"]
interval: 2s
timeout: 2s
retries: 30
api:
build: .
image: mtusi2026lab2-api:local
depends_on:
db:
condition: service_healthy
cache:
condition: service_healthy
environment:
APP_HOST: 0.0.0.0
APP_PORT: 8080
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS}
SESSION_STORE: ${SESSION_STORE}
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
secrets:
- database_url
- cache_url
ports:
- 8080:8080
healthcheck:
test: ["CMD", "curl", "-fsS", "http://127.0.0.1:8080/health/ready"]
interval: 2s
timeout: 2s
retries: 30
secrets:
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
volumes:
pgdata: {}
valkeydata: {}
+27
View File
@@ -0,0 +1,27 @@
# 2026-10-16 05:20:15 +0300, commit 65003b6 (+ незакоммиченные изменения)
$ make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
[exit 0]
$ make validate PYTHON=.venv/bin/python
.venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
[exit 0]
$ make test
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
[exit 0]
$ python3 student-tests/test_api.py
ok test_registration_validation
ok test_auth_transitions
ok test_messages_and_access
ok test_chat_validation
ok test_pagination
ok test_logout
PASS student-tests
[exit 0]
+99
View File
@@ -0,0 +1,99 @@
# EXPLAIN (ANALYZE, BUFFERS) — индекс истории
- PostgreSQL 16 (локальный контейнер)
- Таблица `messages`: 15 000 строк в чате `22222222-2222-4222-8222-222222222222`
- `created_at` распределено равномерно по 30 дням назад
- `PAGE_LIMIT` = 50, `DEEP_OFFSET` = 7000
## Сводка
| # | Сценарий | Узел | Buffers | Время (ms) |
|---|---|---|---|---|
| 1 | Первая страница, с индексом | Index Scan (messages_chat_keyset_idx) | 4 | 0.32 |
| 2 | Первая страница, без индекса | Seq Scan + Sort top-N | 191 | 15.08 |
| 3 | Глубокая страница (keyset, OFFSET 7000), с индексом | Index Scan | 5 | 0.27 |
| 4 | OFFSET 7000 (контраст) | Index Scan (прочитал 7051 строку) | 178 | 4.42 |
**Выводы:**
- Индекс `messages_chat_keyset_idx` используется и даёт **47× выигрыш** по времени на первой странице (0.32 ms vs 15.08 ms).
- Keyset-пагинация **не деградирует с глубиной**: страница на OFFSET 7000 стоит столько же, сколько первая (0.27 vs 0.32 ms, 5 vs 4 буфера).
- OFFSET читает **все пропущенные строки** (7051 вместо 51) и в 16× медленнее keyset на той же глубине.
## 1. Первая страница, с индексом
```
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.29..5.52 rows=51 width=73) (actual time=0.179..0.230 rows=51 loops=1)
Buffers: shared hit=4
-> Index Scan using messages_chat_keyset_idx on messages (cost=0.29..1538.99 rows=15000 width=73) (actual time=0.177..0.220 rows=51 loops=1)
Index Cond: (chat_id = '22222222-2222-4222-8222-222222222222'::uuid)
Buffers: shared hit=4
Planning:
Buffers: shared hit=109
Planning Time: 1.835 ms
Execution Time: 0.321 ms
(9 rows)
```
## 2. Первая страница, без индекса (контраст)
```
BEGIN
DROP INDEX
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------
Limit (cost=948.14..948.27 rows=51 width=73) (actual time=15.017..15.027 rows=51 loops=1)
Buffers: shared hit=191
-> Sort (cost=948.14..985.64 rows=15000 width=73) (actual time=15.015..15.019 rows=51 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 38kB
Buffers: shared hit=191
-> Seq Scan on messages (cost=0.00..447.71 rows=15000 width=73) (actual time=0.079..7.720 rows=15000 loops=1)
Filter: (chat_id = '22222222-2222-4222-8222-222222222222'::uuid)
Rows Removed by Filter: 17
Buffers: shared hit=185
Planning:
Buffers: shared hit=79
Planning Time: 0.654 ms
Execution Time: 15.083 ms
(14 rows)
ROLLBACK
```
## 3. Глубокая страница (keyset, OFFSET 7000), с индексом
```
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.29..6.64 rows=51 width=73) (actual time=0.116..0.160 rows=51 loops=1)
Buffers: shared hit=5
-> Index Scan using messages_chat_keyset_idx on messages (cost=0.29..997.87 rows=8007 width=73) (actual time=0.114..0.152 rows=51 loops=1)
Index Cond: ((chat_id = '22222222-2222-4222-8222-222222222222'::uuid) AND (ROW(created_at, id) > ROW('2026-10-10 09:09:28+00'::timestamp with time zone, '6b69ffd1-ea21-41a5-a222-e415775be088'::uuid)))
Buffers: shared hit=5
Planning:
Buffers: shared hit=106
Planning Time: 0.995 ms
Execution Time: 0.268 ms
(9 rows)
```
## 4. OFFSET 7000 (контраст)
```
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=718.35..723.58 rows=51 width=73) (actual time=4.338..4.373 rows=51 loops=1)
Buffers: shared hit=178
-> Index Scan using messages_chat_keyset_idx on messages (cost=0.29..1538.99 rows=15000 width=73) (actual time=0.105..4.010 rows=7051 loops=1)
Index Cond: (chat_id = '22222222-2222-4222-8222-222222222222'::uuid)
Buffers: shared hit=178
Planning:
Buffers: shared hit=107
Planning Time: 0.817 ms
Execution Time: 4.421 ms
(9 rows)
```
+43
View File
@@ -0,0 +1,43 @@
# 2026-10-16 05:20:30 +0300, commit 65003b6 (+ незакоммиченные изменения)
## Таблицы PostgreSQL и применённые миграции
List of relations
Schema | Name | Type | Owner
--------+-------------------+-------+-----------
public | chat_members | table | messenger
public | chats | table | messenger
public | messages | table | messenger
public | schema_migrations | table | messenger
public | sessions | table | messenger
public | users | table | messenger
(6 rows)
schema_migrations: 1,2
## Регистрация и password KDF
OK POST /users: HTTP 201 (ожидалось 201)
OK POST /users: HTTP 201 (ожидалось 201)
OK POST /users: HTTP 201 (ожидалось 201)
OK POST /users: HTTP 201 (ожидалось 201)
OK POST /users: HTTP 201 (ожидалось 201)
время POST /users (5 запросов): медиана 158 ms, min 142, max 162
в ответе нет password/password_hash: True
параметры hash в БД: argon2id$v=19$m=65536,t=2,p=1 (соль и hash не выводятся)
## Basic только на POST /auth/sessions, Bearer на остальных
OK Basic → POST /auth/sessions: HTTP 201 (ожидалось 201)
тело: {"expires_at": "2026-10-16T03:20:32Z", "token": "<64 hex-символов, скрыт>", "token_type": "Bearer", "user": {"created_at": "2026-10-16T02:20:31Z", "display_name": "Evidence", "id": "4e0662a9-cc8d-45d6-821f-040a1179ec68", "username": "ev_8a65abedae"}}
OK неверный пароль → POST /auth/sessions: HTTP 401 (ожидалось 401) WWW-Authenticate: Basic realm="messenger", charset="UTF-8"
OK Basic → GET /users/me: HTTP 401 (ожидалось 401) WWW-Authenticate: Bearer realm="messenger"
OK X-User-Id без Bearer → GET /users/me: HTTP 401 (ожидалось 401) WWW-Authenticate: Bearer realm="messenger"
OK Bearer → GET /users/me: HTTP 200 (ожидалось 200)
тело: {"created_at": "2026-10-16T02:20:31Z", "display_name": "Evidence", "id": "4e0662a9-cc8d-45d6-821f-040a1179ec68", "username": "ev_8a65abedae"}
## Атомарное создание чата
OK POST /chats с несуществующим участником: HTTP 400 (ожидалось 400)
тело: {"error": {"code": "invalid_request", "message": "invalid members", "request_id": "17"}}
чатов с title=atomic-b8723771: 0, строк chat_members с этим участником: 0
## Logout
OK DELETE /auth/sessions/current: HTTP 204 (ожидалось 204)
OK тот же токен → GET /users/me: HTTP 401 (ожидалось 401) WWW-Authenticate: Bearer realm="messenger"
OK повторный logout: HTTP 401 (ожидалось 401) WWW-Authenticate: Bearer realm="messenger"
+22
View File
@@ -0,0 +1,22 @@
# 2026-10-16 05:20:33 +0300, commit 65003b6 (+ незакоммиченные изменения)
$ python3 tests/level4.py
== username_race ==
PASS: username race {409: 7, 201: 1}
== chat_rollback ==
PASS: rollback — чат не создан, chat_members пуст
== contract_validation ==
PASS: дубликаты member_ids — 400
PASS: невалидный и чужой cursor — 400, не 500
== pagination_fractional_seconds ==
PASS: keyset-пагинация без повторов при created_at с долями секунды
== wrong_password_and_logout ==
PASS: неверный пароль — 401; logout — 204, затем 401
== expiry ==
PASS: expiry — при TTL=2 s токен действует, через 3.5 s — 401 (expires_at=2026-10-16T02:20:41Z)
== dependency_outage ==
PASS: cache остановлен 21 s: 10 запросов с токеном → 503 (max 0.02 s), после старта ready за 0.5 s, тот же токен → 200
PASS: db остановлен 26 s: 16 запросов с токеном → 503 (max 5.03 s), после старта ready за 0.5 s, тот же токен → 200
PASS: level4 checks passed
[exit 0]
+156
View File
@@ -0,0 +1,156 @@
# 2026-10-16 05:21:34 +0300, commit 65003b6 (+ незакоммиченные изменения)
Временный проект `lab2fresh`: отдельные volumes lab2fresh_pgdata/lab2fresh_valkeydata, api на :18090, БД и Valkey без проброса портов. Основной стенд не затрагивается.
$ down -v (очистка остатков прошлого запуска)
[exit 0]
$ up -d --wait (пустые volumes)
Volume lab2fresh_valkeydata Creating
Network lab2fresh_default Creating
Volume lab2fresh_valkeydata Creating
Network lab2fresh_default Creating
Volume lab2fresh_valkeydata Created
Volume lab2fresh_valkeydata Created
Volume lab2fresh_pgdata Creating
Volume lab2fresh_pgdata Creating
Volume lab2fresh_pgdata Created
Volume lab2fresh_pgdata Created
Network lab2fresh_default Created
Network lab2fresh_default Created
Container lab2fresh-cache-1 Creating
Container lab2fresh-db-1 Creating
Container lab2fresh-cache-1 Created
Container lab2fresh-db-1 Created
Container lab2fresh-api-1 Creating
Container lab2fresh-api-1 Created
Container lab2fresh-cache-1 Starting
Container lab2fresh-db-1 Starting
Container lab2fresh-cache-1 Started
Container lab2fresh-db-1 Started
Container lab2fresh-db-1 Waiting
Container lab2fresh-cache-1 Waiting
Container lab2fresh-cache-1 Healthy
Container lab2fresh-db-1 Healthy
Container lab2fresh-api-1 Starting
Container lab2fresh-api-1 Started
Container lab2fresh-cache-1 Waiting
Container lab2fresh-api-1 Waiting
Container lab2fresh-db-1 Waiting
Container lab2fresh-cache-1 Healthy
Container lab2fresh-db-1 Healthy
Container lab2fresh-api-1 Healthy
[exit 0]
$ логи api: миграции на пустой БД
connecting to db...
applying migrations...
applied migration 1 (./migrations/001_init.sql)
applied migration 2 (./migrations/002_sessions.sql)
migrations ok
pg pool ready (8 connections)
redis pool ready (4 connections)
session store: redis
session ttl: 3600s
listening on 0.0.0.0:8080
[exit 0]
schema_migrations: 1,2
POST /users на новом стенде: HTTP 201; пользователей в БД: 1
$ restart api (повторный запуск миграций)
Container lab2fresh-api-1 Restarting
Container lab2fresh-api-1 Started
[exit 0]
$ up -d --wait
Container lab2fresh-api-1 Running
Container lab2fresh-db-1 Running
Container lab2fresh-cache-1 Running
Container lab2fresh-cache-1 Waiting
Container lab2fresh-db-1 Waiting
Container lab2fresh-cache-1 Healthy
Container lab2fresh-db-1 Healthy
Container lab2fresh-api-1 Waiting
Container lab2fresh-db-1 Waiting
Container lab2fresh-cache-1 Waiting
Container lab2fresh-api-1 Healthy
Container lab2fresh-db-1 Healthy
Container lab2fresh-cache-1 Healthy
[exit 0]
$ логи api после рестарта (--since 2026-10-16T02:21:44Z)
shutting down
stopped
connecting to db...
applying migrations...
migrations ok
pg pool ready (8 connections)
redis pool ready (4 connections)
session store: redis
session ttl: 3600s
listening on 0.0.0.0:8080
[exit 0]
строк 'applied migration' после рестарта: 0; schema_migrations: 2 строки; пользователей: 1 (данные не дублируются и не теряются)
$ down -v (НАМЕРЕННОЕ удаление volumes временного проекта)
Container lab2fresh-api-1 Stopping
Container lab2fresh-api-1 Stopped
Container lab2fresh-api-1 Removing
Container lab2fresh-api-1 Removed
Container lab2fresh-db-1 Stopping
Container lab2fresh-cache-1 Stopping
Container lab2fresh-cache-1 Stopped
Container lab2fresh-cache-1 Removing
Container lab2fresh-cache-1 Removed
Container lab2fresh-db-1 Stopped
Container lab2fresh-db-1 Removing
Container lab2fresh-db-1 Removed
Volume lab2fresh_valkeydata Removing
Volume lab2fresh_pgdata Removing
Network lab2fresh_default Removing
Volume lab2fresh_valkeydata Removed
Volume lab2fresh_pgdata Removed
Network lab2fresh_default Removed
[exit 0]
$ up -d --wait
Network lab2fresh_default Creating
Network lab2fresh_default Creating
Volume lab2fresh_valkeydata Creating
Volume lab2fresh_valkeydata Creating
Volume lab2fresh_pgdata Creating
Volume lab2fresh_pgdata Creating
Volume lab2fresh_valkeydata Created
Volume lab2fresh_valkeydata Created
Volume lab2fresh_pgdata Created
Volume lab2fresh_pgdata Created
Network lab2fresh_default Created
Network lab2fresh_default Created
Container lab2fresh-db-1 Creating
Container lab2fresh-cache-1 Creating
Container lab2fresh-cache-1 Created
Container lab2fresh-db-1 Created
Container lab2fresh-api-1 Creating
Container lab2fresh-api-1 Created
Container lab2fresh-db-1 Starting
Container lab2fresh-cache-1 Starting
Container lab2fresh-db-1 Started
Container lab2fresh-cache-1 Started
Container lab2fresh-cache-1 Waiting
Container lab2fresh-db-1 Waiting
Container lab2fresh-db-1 Healthy
Container lab2fresh-cache-1 Healthy
Container lab2fresh-api-1 Starting
Container lab2fresh-api-1 Started
Container lab2fresh-cache-1 Waiting
Container lab2fresh-api-1 Waiting
Container lab2fresh-db-1 Waiting
Container lab2fresh-db-1 Healthy
Container lab2fresh-cache-1 Healthy
Container lab2fresh-api-1 Healthy
[exit 0]
после down -v пользователей: 0 — все данные и сессии потеряны, миграции применены заново
временный проект lab2fresh удалён вместе с volumes
+22
View File
@@ -0,0 +1,22 @@
# 2026-10-16 05:20:20 +0300, commit 65003b6 (+ незакоммиченные изменения)
$ docker compose ps (до)
SERVICE STATUS
api Up 14 minutes (healthy)
cache Up 13 minutes (healthy)
db Up 13 minutes (healthy)
[exit 0]
$ make test-persistence ACTION_SCRIPT=scripts/restart.sh
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
[exit 0]
$ docker compose ps (после: все три контейнера перезапущены)
SERVICE STATUS
api Up 2 seconds (healthy)
cache Up 6 seconds (healthy)
db Up 5 seconds (healthy)
[exit 0]
+339
View File
@@ -0,0 +1,339 @@
# Track 2. План запроса истории и стоимость записи
Сгенерировано `python3 scripts/track2_indexes.py --read-reps 7 --write-seconds 15 --write-rounds 3 --clients 4`.
## Окружение и данные
- Дата: 2026-10-16T04:19:44+03:00
- Commit: `65003b6` (есть незакоммиченные изменения)
- Хост: Linux 7.0.0-14-generic, 12 CPU, RAM 14.8 GiB; CPU/RAM-лимиты контейнеров не заданы
- PostgreSQL 16.15 (`postgres:16-alpine`), настройки по умолчанию, synchronous_commit=on, shared_buffers=128MB
- Сообщений: 119 341, чатов с сообщениями: 91; размер чата min/median/max = 1/40/33892
- Размер heap таблицы `messages`: 22 MB
Выбранные чаты:
| Метка | Чат | Сообщений |
|---|---|---|
| small | `perf-small-38-sz50` | 50 |
| medium | `perf-medium-61-sz1028` | 1028 |
| large | `perf-large-77-sz33892` | 33892 |
| burst | `perf-burst-ties-sz5000` | 5000 |
## Гипотезы
- **H1.** С индексом A `(chat_id, created_at, id)` страница истории читает ≈limit строк независимо от размера чата и глубины курсора; без индекса читается вся таблица.
- **H2.** Индекс C `(chat_id, created_at)` без `id` эквивалентен A, пока `created_at` уникален, но деградирует, когда много сообщений приходится на одну секунду.
- **H3.** Каждый вторичный индекс увеличивает стоимость INSERT (WAL, latency).
## Методика
- Запросы — те же, что в `MessageRepo::list_page`: `LIMIT 51` (limit+1), порядок `(created_at, id)`. Курсор Q2 и OFFSET Q3 указывают на середину чата.
- Для каждого варианта индексы пересоздаются, затем `ANALYZE`. `EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)`: 1 прогрев + 7 замеров, медиана Execution Time; buffers = shared hit + read последнего замера; rows_read — строки, прочитанные листовым узлом скана (включая отброшенные Filter).
- Запись: `pgbench -c 4 -j 4 -T 15`, одна вставка на транзакцию в чат large, `created_at` с точностью до секунды как в приложении. 3 раунда с циклическим сдвигом порядка вариантов; перед прогоном `DELETE` тестовых строк, `VACUUM`, `CHECKPOINT` (чтобы full-page writes были в равных условиях); autovacuum на `messages` выключен на время бенча. WAL = `pg_wal_lsn_diff` за прогон / число транзакций.
## Результаты: чтение
Время в ms (медиана) / buffers / rows_read.
| Чат | Запрос | none | C | A |
|---|---|---|---|---|
| small | Q1 первая страница | 13.7 / 2819 / 119341 | 0.426 / 10 / 50 | 0.339 / 10 / 50 |
| small | Q2 keyset из середины | 15.3 / 2819 / 119341 | 0.378 / 13 / 25 | 0.252 / 4 / 24 |
| small | Q3 OFFSET из середины | 13.8 / 2819 / 119341 | 0.367 / 10 / 50 | 0.321 / 10 / 50 |
| medium | Q1 первая страница | 15.1 / 2819 / 119341 | 0.401 / 60 / 52 | 0.236 / 50 / 51 |
| medium | Q2 keyset из середины | 17.6 / 2819 / 119341 | 0.546 / 62 / 53 | 0.350 / 51 / 51 |
| medium | Q3 OFFSET из середины | 16.0 / 2819 / 119341 | 1.240 / 529 / 566 | 0.880 / 520 / 565 |
| large | Q1 первая страница | 32.5 / 2877 / 119340 | 0.522 / 64 / 52 | 0.459 / 54 / 51 |
| large | Q2 keyset из середины | 25.3 / 2828 / 119340 | 0.553 / 65 / 53 | 0.443 / 54 / 51 |
| large | Q3 OFFSET из середины | 62.6 / 2819 / 119341 | 55.5 / 592 / 33892 | 19.8 / 17061 / 16997 |
| burst | Q1 первая страница | 17.7 / 2819 / 119341 | 5.424 / 82 / 5000 | 0.366 / 54 / 51 |
| burst | Q2 keyset из середины | 17.7 / 2819 / 119341 | 3.686 / 82 / 5000 | 0.456 / 54 / 51 |
| burst | Q3 OFFSET из середины | 22.3 / 2819 / 119341 | 8.942 / 79 / 5000 | 10.9 / 110 / 5000 |
Узлы планов:
| Чат | Запрос | Вариант | План |
|---|---|---|---|
| small | Q1 | none | `Limit → Sort → Seq Scan` |
| small | Q1 | C | `Limit → Sort → Bitmap Heap Scan → Bitmap Index Scan (track2_chat_created_idx)` |
| small | Q1 | A | `Limit → Sort → Bitmap Heap Scan → Bitmap Index Scan (messages_chat_keyset_idx)` |
| small | Q2 | none | `Limit → Sort → Seq Scan` |
| small | Q2 | C | `Limit → Incremental Sort → Index Scan (track2_chat_created_idx)` |
| small | Q2 | A | `Limit → Index Scan (messages_chat_keyset_idx)` |
| small | Q3 | none | `Limit → Sort → Seq Scan` |
| small | Q3 | C | `Limit → Sort → Bitmap Heap Scan → Bitmap Index Scan (track2_chat_created_idx)` |
| small | Q3 | A | `Limit → Sort → Bitmap Heap Scan → Bitmap Index Scan (messages_chat_keyset_idx)` |
| medium | Q1 | none | `Limit → Sort → Seq Scan` |
| medium | Q1 | C | `Limit → Incremental Sort → Index Scan (track2_chat_created_idx)` |
| medium | Q1 | A | `Limit → Index Scan (messages_chat_keyset_idx)` |
| medium | Q2 | none | `Limit → Sort → Seq Scan` |
| medium | Q2 | C | `Limit → Incremental Sort → Index Scan (track2_chat_created_idx)` |
| medium | Q2 | A | `Limit → Index Scan (messages_chat_keyset_idx)` |
| medium | Q3 | none | `Limit → Sort → Seq Scan` |
| medium | Q3 | C | `Limit → Incremental Sort → Index Scan (track2_chat_created_idx)` |
| medium | Q3 | A | `Limit → Index Scan (messages_chat_keyset_idx)` |
| large | Q1 | none | `Limit → Gather Merge → Sort → Seq Scan` |
| large | Q1 | C | `Limit → Incremental Sort → Index Scan (track2_chat_created_idx)` |
| large | Q1 | A | `Limit → Index Scan (messages_chat_keyset_idx)` |
| large | Q2 | none | `Limit → Gather Merge → Sort → Seq Scan` |
| large | Q2 | C | `Limit → Incremental Sort → Index Scan (track2_chat_created_idx)` |
| large | Q2 | A | `Limit → Index Scan (messages_chat_keyset_idx)` |
| large | Q3 | none | `Limit → Sort → Seq Scan` |
| large | Q3 | C | `Limit → Sort → Bitmap Heap Scan → Bitmap Index Scan (track2_chat_created_idx)` |
| large | Q3 | A | `Limit → Index Scan (messages_chat_keyset_idx)` |
| burst | Q1 | none | `Limit → Sort → Seq Scan` |
| burst | Q1 | C | `Limit → Incremental Sort → Index Scan (track2_chat_created_idx)` |
| burst | Q1 | A | `Limit → Index Scan (messages_chat_keyset_idx)` |
| burst | Q2 | none | `Limit → Sort → Seq Scan` |
| burst | Q2 | C | `Limit → Incremental Sort → Index Scan (track2_chat_created_idx)` |
| burst | Q2 | A | `Limit → Index Scan (messages_chat_keyset_idx)` |
| burst | Q3 | none | `Limit → Sort → Seq Scan` |
| burst | Q3 | C | `Limit → Sort → Bitmap Heap Scan → Bitmap Index Scan (track2_chat_created_idx)` |
| burst | Q3 | A | `Limit → Sort → Bitmap Heap Scan → Bitmap Index Scan (messages_chat_keyset_idx)` |
## Результаты: запись
| Вариант | TPS медиана (min–max) | latency avg, ms | WAL, B/вставку | Прогоны TPS |
|---|---|---|---|---|
| none | 3396 (2749–3466) | 1.178 | 499 | 2749, 3396, 3466 |
| C | 3370 (3077–3474) | 1.187 | 588 | 3077, 3370, 3474 |
| A | 3322 (2866–3466) | 1.204 | 634 | 2866, 3322, 3466 |
| A+C | 3337 (2900–3401) | 1.199 | 722 | 2900, 3337, 3401 |
Размеры индексов:
| Индекс | Ключ | Размер |
|---|---|---|
| messages_pkey | (id) | 8.9 MiB |
| track2_chat_created_idx | (chat_id, created_at) | 4.4 MiB |
| messages_chat_keyset_idx | (chat_id, created_at, id) | 6.7 MiB |
## Выводы
**H1 (индекс A, стоимость страницы постоянна) — подтверждена.** Для Q1 и Q2 на всех чатах (от 50 до 33892 сообщений, включая середину чата и чат-всплеск) читается не более 51 строк и 54 буферов, время ≤ 0.459 ms. Sort встречается только в small Q1: для чата из 50 сообщений планировщику дешевле взять все строки чата Bitmap-сканом по тому же индексу и отсортировать их в памяти; строк всё равно не больше размера чата.
**Без вторичного индекса** стоимость определяется размером всей таблицы, а не чата: первая страница чата из 50 сообщений читает 2819 буферов (13.7 ms), чата из 33892 — 2877 буферов (32.5 ms). Для маленького чата это в 40× медленнее индекса A. Узел: `Limit → Sort → Seq Scan`.
**H2 (индекс C без id деградирует на одинаковых created_at) — подтверждена.** На обычном большом чате C почти не отличается от A: Q2 0.553 против 0.443 ms, потому что совпадений по секунде мало и Incremental Sort сортирует крошечные группы. В чате-всплеске (5000 сообщений в одну секунду) условие по id становится Filter, и C читает 5000 строк / 82 буферов за 3.686 ms, а A — 51 строк / 54 буферов за 0.456 ms (8×). Приложение хранит время с точностью до секунды, поэтому такой всплеск реалистичен при нагрузке: `id` в индексе обязателен.
**OFFSET против keyset** на середине чата из 33892 сообщений, индекс A: OFFSET читает 16997 строк и 17061 буферов (19.8 ms), keyset — 51 строк и 54 буферов (0.443 ms). Стоимость OFFSET растёт линейно с глубиной, поэтому приложение использует курсор.
**H3 (каждый вторичный индекс удорожает запись) — по WAL подтверждена.** База без вторичных индексов: 499 B WAL на вставку, медиана 3396 TPS. C: WAL +89 B/вставку (+18%), TPS -0.8% (в пределах разброса прогонов); A: WAL +134 B/вставку (+27%), TPS -2.2% (в пределах разброса прогонов); A+C: WAL +222 B/вставку (+45%), TPS -1.7% (в пределах разброса прогонов). Объём WAL детерминирован и растёт с каждым индексом; TPS на локальном диске и 4 клиентах ограничен fsync при COMMIT, поэтому разница по TPS меньше и частично тонет в шуме — это ограничение замера, а не отсутствие цены.
**Размер:** A = 6.7 MiB, C = 4.4 MiB: `id` в ключе добавляет 52% к размеру индекса.
**Решение:** оставить только A `(chat_id, created_at, id)`. Он один обслуживает и первую, и любую следующую страницу за константное число буферов независимо от размера чата и совпадений времени. C экономит немного места, но ломается на всплесках; A+C платит за второй индекс при каждой записи без выигрыша для чтения.
## Ограничения
- Один хост, тёплый кэш (данные помещаются в shared_buffers/page cache): время отражает CPU и число буферов, а не холодное чтение с диска.
- Литералы в запросах вместо параметров: приложение через libpqxx может получить generic plan; для этих запросов выбор индекса одинаков, но это не проверялось.
- Данные синтетические, один отправитель, короткие тексты; распределение времени внутри чата равномерное в окне.
- pgbench мерит БД без HTTP и Argon2; TPS ограничен fsync при COMMIT на локальном диске, поэтому разница по TPS меньше разницы по WAL.
## Ключевые планы (EXPLAIN ANALYZE, BUFFERS)
### large Q2 — none
```
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=5501.25..5507.12 rows=51 width=78) (actual time=35.318..44.171 rows=51 loops=1)
Buffers: shared hit=2828
-> Gather Merge (cost=5501.25..6879.41 rows=11984 width=78) (actual time=35.314..44.152 rows=51 loops=1)
Workers Planned: 1
Workers Launched: 1
Buffers: shared hit=2828
-> Sort (cost=4501.24..4531.20 rows=11984 width=78) (actual time=27.923..27.933 rows=37 loops=2)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 36kB
Buffers: shared hit=2828
Worker 0: Sort Method: top-N heapsort Memory: 36kB
-> Parallel Seq Scan on messages (cost=0.00..4101.43 rows=11984 width=78) (actual time=7.917..21.877 rows=8472 loops=2)
Filter: ((chat_id = '2faf796f-cd45-4bd4-90a4-c47bd22e8fb9'::uuid) AND (ROW(created_at, id) > ROW('2026-10-12 11:25:16.934374+00'::timestamp with time zone, 'cea16433-3293-4e4b-abc8-ff3da534c341'::uuid)))
Rows Removed by Filter: 51198
Buffers: shared hit=2813
Planning:
Buffers: shared hit=83
Planning Time: 1.424 ms
Execution Time: 44.554 ms
(19 rows)
```
### burst Q2 — none
```
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=4974.47..4974.60 rows=51 width=78) (actual time=25.999..26.017 rows=51 loops=1)
Buffers: shared hit=2819
-> Sort (cost=4974.47..4979.23 rows=1903 width=78) (actual time=25.995..26.003 rows=51 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 36kB
Buffers: shared hit=2819
-> Seq Scan on messages (cost=0.00..4910.98 rows=1903 width=78) (actual time=0.388..24.150 rows=2499 loops=1)
Filter: ((chat_id = '9160c35f-c6f7-4745-a853-fc00b36edac4'::uuid) AND (ROW(created_at, id) > ROW('2026-10-14 01:04:07+00'::timestamp with time zone, '80cb6db7-6757-4574-808d-a709b86af476'::uuid)))
Rows Removed by Filter: 116842
Buffers: shared hit=2813
Planning:
Buffers: shared hit=83
Planning Time: 1.793 ms
Execution Time: 26.270 ms
(14 rows)
```
### small Q1 — none
```
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------
Limit (cost=4306.34..4306.46 rows=48 width=78) (actual time=17.091..17.106 rows=50 loops=1)
Buffers: shared hit=2819
-> Sort (cost=4306.34..4306.46 rows=48 width=78) (actual time=17.087..17.094 rows=50 loops=1)
Sort Key: created_at, id
Sort Method: quicksort Memory: 31kB
Buffers: shared hit=2819
-> Seq Scan on messages (cost=0.00..4305.00 rows=48 width=78) (actual time=4.734..16.935 rows=50 loops=1)
Filter: (chat_id = 'e85baba0-4bb8-4cfd-853b-792a65c98c81'::uuid)
Rows Removed by Filter: 119291
Buffers: shared hit=2813
Planning:
Buffers: shared hit=84
Planning Time: 1.197 ms
Execution Time: 17.220 ms
(14 rows)
```
### large Q2 — C
```
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=1.04..33.81 rows=51 width=78) (actual time=0.414..0.509 rows=51 loops=1)
Buffers: shared hit=65
-> Incremental Sort (cost=1.04..12951.29 rows=20151 width=78) (actual time=0.413..0.500 rows=51 loops=1)
Sort Key: created_at, id
Presorted Key: created_at
Full-sort Groups: 2 Sort Method: quicksort Average Memory: 29kB Peak Memory: 29kB
Buffers: shared hit=65
-> Index Scan using track2_chat_created_idx on messages (cost=0.42..12058.92 rows=20151 width=78) (actual time=0.145..0.371 rows=52 loops=1)
Index Cond: ((chat_id = '2faf796f-cd45-4bd4-90a4-c47bd22e8fb9'::uuid) AND (created_at >= '2026-10-12 11:25:16.934374+00'::timestamp with time zone))
Filter: (ROW(created_at, id) > ROW('2026-10-12 11:25:16.934374+00'::timestamp with time zone, 'cea16433-3293-4e4b-abc8-ff3da534c341'::uuid))
Rows Removed by Filter: 1
Buffers: shared hit=56
Planning:
Buffers: shared hit=112
Planning Time: 1.142 ms
Execution Time: 0.650 ms
(16 rows)
```
### burst Q2 — C
```
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=3.68..171.46 rows=51 width=78) (actual time=4.398..4.411 rows=51 loops=1)
Buffers: shared hit=82
-> Incremental Sort (cost=3.68..6224.81 rows=1891 width=78) (actual time=4.396..4.401 rows=51 loops=1)
Sort Key: created_at, id
Presorted Key: created_at
Full-sort Groups: 1 Sort Method: quicksort Average Memory: 33kB Peak Memory: 33kB
Pre-sorted Groups: 1 Sort Method: top-N heapsort Average Memory: 34kB Peak Memory: 34kB
Buffers: shared hit=82
-> Index Scan using track2_chat_created_idx on messages (cost=0.42..6139.82 rows=1891 width=78) (actual time=0.157..3.124 rows=2499 loops=1)
Index Cond: ((chat_id = '9160c35f-c6f7-4745-a853-fc00b36edac4'::uuid) AND (created_at >= '2026-10-14 01:04:07+00'::timestamp with time zone))
Filter: (ROW(created_at, id) > ROW('2026-10-14 01:04:07+00'::timestamp with time zone, '80cb6db7-6757-4574-808d-a709b86af476'::uuid))
Rows Removed by Filter: 2501
Buffers: shared hit=73
Planning:
Buffers: shared hit=112
Planning Time: 1.393 ms
Execution Time: 4.590 ms
(17 rows)
```
### small Q1 — C
```
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=94.92..94.98 rows=24 width=78) (actual time=0.225..0.235 rows=50 loops=1)
Buffers: shared hit=10
-> Sort (cost=94.92..94.98 rows=24 width=78) (actual time=0.224..0.228 rows=50 loops=1)
Sort Key: created_at, id
Sort Method: quicksort Memory: 31kB
Buffers: shared hit=10
-> Bitmap Heap Scan on messages (cost=4.60..94.37 rows=24 width=78) (actual time=0.104..0.129 rows=50 loops=1)
Recheck Cond: (chat_id = 'e85baba0-4bb8-4cfd-853b-792a65c98c81'::uuid)
Heap Blocks: exact=1
Buffers: shared hit=4
-> Bitmap Index Scan on track2_chat_created_idx (cost=0.00..4.60 rows=24 width=0) (actual time=0.019..0.019 rows=50 loops=1)
Index Cond: (chat_id = 'e85baba0-4bb8-4cfd-853b-792a65c98c81'::uuid)
Buffers: shared hit=3
Planning:
Buffers: shared hit=104
Planning Time: 0.917 ms
Execution Time: 0.334 ms
(17 rows)
```
### large Q2 — A
```
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..30.97 rows=51 width=78) (actual time=0.343..0.932 rows=51 loops=1)
Buffers: shared hit=54
-> Index Scan using messages_chat_keyset_idx on messages (cost=0.42..12155.72 rows=20292 width=78) (actual time=0.340..0.915 rows=51 loops=1)
Index Cond: ((chat_id = '2faf796f-cd45-4bd4-90a4-c47bd22e8fb9'::uuid) AND (ROW(created_at, id) > ROW('2026-10-12 11:25:16.934374+00'::timestamp with time zone, 'cea16433-3293-4e4b-abc8-ff3da534c341'::uuid)))
Buffers: shared hit=54
Planning:
Buffers: shared hit=106
Planning Time: 2.470 ms
Execution Time: 1.235 ms
(9 rows)
```
### burst Q2 — A
```
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..153.02 rows=51 width=78) (actual time=0.127..0.329 rows=51 loops=1)
Buffers: shared hit=54
-> Index Scan using messages_chat_keyset_idx on messages (cost=0.42..5691.42 rows=1902 width=78) (actual time=0.125..0.319 rows=51 loops=1)
Index Cond: ((chat_id = '9160c35f-c6f7-4745-a853-fc00b36edac4'::uuid) AND (ROW(created_at, id) > ROW('2026-10-14 01:04:07+00'::timestamp with time zone, '80cb6db7-6757-4574-808d-a709b86af476'::uuid)))
Buffers: shared hit=54
Planning:
Buffers: shared hit=106
Planning Time: 1.067 ms
Execution Time: 0.435 ms
(9 rows)
```
### small Q1 — A
```
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=180.16..180.28 rows=48 width=78) (actual time=0.224..0.233 rows=50 loops=1)
Buffers: shared hit=10
-> Sort (cost=180.16..180.28 rows=48 width=78) (actual time=0.222..0.226 rows=50 loops=1)
Sort Key: created_at, id
Sort Method: quicksort Memory: 31kB
Buffers: shared hit=10
-> Bitmap Heap Scan on messages (cost=4.79..178.82 rows=48 width=78) (actual time=0.101..0.127 rows=50 loops=1)
Recheck Cond: (chat_id = 'e85baba0-4bb8-4cfd-853b-792a65c98c81'::uuid)
Heap Blocks: exact=1
Buffers: shared hit=4
-> Bitmap Index Scan on messages_chat_keyset_idx (cost=0.00..4.78 rows=48 width=0) (actual time=0.020..0.020 rows=50 loops=1)
Index Cond: (chat_id = 'e85baba0-4bb8-4cfd-853b-792a65c98c81'::uuid)
Buffers: shared hit=3
Planning:
Buffers: shared hit=107
Planning Time: 0.993 ms
Execution Time: 0.313 ms
(17 rows)
```
+128
View File
@@ -0,0 +1,128 @@
# Track 2. Backup → восстановление в новое хранилище → сверка
Сгенерировано `python3 scripts/track2_restore.py --before 100 --after 37 --jobs 1`. Итог: **PASS**.
## Окружение и данные
- Дата: 2026-10-16T04:18:51+03:00
- Commit: `65003b6` (есть незакоммиченные изменения)
- Хост: Linux 7.0.0-14-generic, 12 CPU, RAM 14.8 GiB; CPU/RAM-лимиты контейнеров не заданы
- PostgreSQL 16.15 (`postgres:16-alpine`), настройки по умолчанию, synchronous_commit=on, shared_buffers=128MB
- Сообщений: 119 304, чатов с сообщениями: 91; размер чата min/median/max = 1/40/33892
- Размер heap таблицы `messages`: 22 MB
- Размер БД `pg_database_size`: 45.6 MiB; восстановлено в PostgreSQL 16.15 (`postgres:16-alpine`, новый пустой volume)
## Гипотезы
- **H4.** Логический backup (`pg_dump -Fc`) восстанавливается в пустое хранилище без потерь: совпадают счётчики, содержимое всех таблиц и страницы истории.
- **H5.** Время восстановления заметно определяется построением индексов и ограничений (секция post-data), а не только загрузкой строк.
- **H6.** Граница потери данных (RPO) логического backup — момент его снимка: всё, что подтверждено COMMIT после начала `pg_dump`, в копии отсутствует.
## Методика
1. В служебный чат `track2-rpo` записано 100 сообщений с меткой «до».
2. Снят отпечаток исходной БД: `count(*)` и md5 упорядоченного содержимого каждой таблицы, md5 числа сообщений по чатам, страницы истории (первая, keyset из середины, последняя) для чатов small/medium/large/burst — теми же запросами, что у приложения.
3. `pg_dump -Fc` из работающего сервиса `db` в `backups/` (не в Git).
4. В исходную БД записано 37 сообщений с меткой «после».
5. `docker volume create` + `docker run postgres:16-alpine`: новое хранилище; `pg_restore --section=pre-data|data|post-data` с замером каждой секции.
6. Сверка отпечатков, страниц, маркеров и плана запроса на копии; копия удаляется.
## Время
| Этап | Время, s |
|---|---|
| pg_dump (backup) | 1.51 |
| Запуск нового хранилища (initdb + старт) | 2.96 |
| Копирование дампа в контейнер | 0.25 |
| pg_restore pre-data (схема) | 0.35 |
| pg_restore data (COPY строк) | 0.89 |
| pg_restore post-data (PK, FK, индексы) | 0.65 |
| **RTO: от пустого хоста до готовой БД** | **5.09** |
| Сверка отпечатков (вне RTO) | 1.05 |
Размер дампа: 3.6 MiB (сжатие custom-формата, 12.5× меньше БД).
## Сверка
| Проверка | Исходная (снимок) | Копия | Совпадает |
|---|---|---|---|
| count.chat_members | `102` | `102` | да |
| count.chats | `92` | `92` | да |
| count.messages | `119304` | `119304` | да |
| count.sessions | `5` | `5` | да |
| count.users | `34` | `34` | да |
| md5.chat_members | `118a3eaa1f4d…` | `118a3eaa1f4d…` | да |
| md5.chats | `204d8295ea8f…` | `204d8295ea8f…` | да |
| md5.messages | `eaeaedc72bc0…` | `eaeaedc72bc0…` | да |
| md5.messages_per_chat | `5be7981bd2be…` | `5be7981bd2be…` | да |
| md5.sessions | `677831e03420…` | `677831e03420…` | да |
| md5.users | `ba0f36018626…` | `ba0f36018626…` | да |
| schema_migrations | `1,2` | `1,2` | да |
| страница small.first (50 строк) | — | — | да |
| страница small.middle (24 строк) | — | — | да |
| страница small.last (50 строк) | — | — | да |
| страница medium.first (50 строк) | — | — | да |
| страница medium.middle (50 строк) | — | — | да |
| страница medium.last (50 строк) | — | — | да |
| страница large.first (50 строк) | — | — | да |
| страница large.middle (50 строк) | — | — | да |
| страница large.last (50 строк) | — | — | да |
| страница burst.first (50 строк) | — | — | да |
| страница burst.middle (50 строк) | — | — | да |
| страница burst.last (50 строк) | — | — | да |
| план Q2 на копии использует messages_chat_keyset_idx | — | — | да |
Пример выбранных сообщений (large, keyset из середины), одинаковы в обеих БД:
| id | chat_id | created_at (epoch) | text |
|---|---|---|---|
| `8170ce4d-3609-4c81-8a82-b831613f8617` | `2faf796f…` | 1791804349 | perf2-77-1059 |
| `12ba1590-51f6-42ac-9fd9-77097472f120` | `2faf796f…` | 1791804354 | perf2-77-18632 |
| `ce303330-3b66-4e97-9638-ad88ee536037` | `2faf796f…` | 1791804356 | perf2-77-29228 |
Индексы на копии: chat_members_pkey, chat_members_user_idx, chats_pkey, messages_chat_keyset_idx, messages_pkey, schema_migrations_pkey, sessions_expires_at_idx, sessions_pkey, users_pkey, users_username_key
## Граница потери данных
| Маркер | В исходной БД | В копии | Ожидание |
|---|---|---|---|
| до backup | 100 | 100 | все есть |
| после backup | 37 | 0 | нет ни одного |
После записи маркеров «после» исходная БД разошлась с копией по: `count.messages`, `md5.messages`, `md5.messages_per_chat`.
## Выводы
**H4 — подтверждена.** Все 12 отпечатков (счётчики и md5 содержимого users, chats, chat_members, messages, sessions, schema_migrations, распределение по чатам) и 12 страниц истории совпали. На копии восстановлены индексы, и тот же keyset-запрос идёт через `messages_chat_keyset_idx`. Таблица `schema_migrations` восстановлена, поэтому API, направленный на копию, не будет повторно применять миграции.
**H5 — подтверждена.** post-data заняла 0.65 s из 1.89 s pg_restore (34%): PK и вторичные индексы строятся заново после загрузки строк. Полный RTO 5.1 s, из них 3.0 s — запуск пустого PostgreSQL. Скорость восстановления ≈ 24 MiB/s БД; при линейной экстраполяции 10× данных ≈ 19 s только на pg_restore (оценка: построение индексов растёт как n·log n, а при данных больше RAM появится дисковый I/O). Ускорение — `pg_restore -j N` для data/post-data или физический backup (`pg_basebackup`), который не перестраивает индексы.
**H6 — подтверждена.** Все 100 сообщений до backup есть в копии, ни одного из 37 после — нет, хотя они подтверждены COMMIT в исходной БД. `pg_dump` читает один согласованный снимок (REPEATABLE READ) на момент старта, поэтому RPO = время с начала последнего backup. При backup раз в сутки можно потерять до суток сообщений; чтобы уменьшить RPO до секунд, нужен непрерывный архив WAL (`archive_mode` + pgBackRest/wal-g) и PITR или потоковая реплика.
**Сессии.** Сессии хранятся в Valkey (`SESSION_STORE=redis`) и в дамп PostgreSQL не входят. Если Valkey цел, старые токены работают и с восстановленной БД: `user_id` сохранились. Если потерян и Valkey, пользователи логинятся заново; при AOF `appendfsync everysec` можно потерять до ~1 s новых сессий. Таблица `sessions` в PostgreSQL (резервный режим `SESSION_STORE=postgres`) восстанавливается вместе с дампом.
**COMMIT и durability.** При `synchronous_commit=on` подтверждённая транзакция уже записана в WAL на диск и переживает рестарт контейнера, но не потерю volume/диска: от этого защищает только копия на другом носителе. Здесь дамп лежит на том же хосте, поэтому эксперимент доказывает процедуру восстановления, а не защиту от потери хоста.
## Ограничения
- Один хост, тёплый page cache; дамп и копия на том же диске.
- Во время backup не было внешней нагрузки; при нагрузке pg_dump длится дольше, но снимок остаётся согласованным.
- RTO не включает переключение API на новую БД (смена секрета `database_url` и рестарт api).
- Сверка md5 упорядоченного содержимого требует чтения всех таблиц; на больших объёмах её заменяют выборочной сверкой и счётчиками.
## План keyset-запроса на восстановленной копии
```
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..17.79 rows=50 width=78) (actual time=0.133..0.394 rows=50 loops=1)
Buffers: shared hit=54
-> Index Scan using messages_chat_keyset_idx on messages (cost=0.42..7011.85 rows=20182 width=78) (actual time=0.131..0.385 rows=50 loops=1)
Index Cond: ((chat_id = '2faf796f-cd45-4bd4-90a4-c47bd22e8fb9'::uuid) AND (ROW(created_at, id) > ROW('2026-10-12 11:25:16.934374+00'::timestamp with time zone, 'cea16433-3293-4e4b-abc8-ff3da534c341'::uuid)))
Buffers: shared hit=54
Planning:
Buffers: shared hit=106
Planning Time: 1.001 ms
Execution Time: 0.506 ms
(9 rows)
```
+33
View File
@@ -0,0 +1,33 @@
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL UNIQUE
CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name text NOT NULL,
password_hash text NOT NULL,
created_at timestamptz NOT NULL
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL,
created_at timestamptz NOT NULL
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members(user_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id uuid NOT NULL REFERENCES users(id),
text text NOT NULL,
created_at timestamptz NOT NULL
);
CREATE INDEX messages_chat_keyset_idx
ON messages (chat_id, created_at, id);
+6
View File
@@ -0,0 +1,6 @@
CREATE TABLE sessions (
token text PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at timestamptz NOT NULL
);
CREATE INDEX sessions_expires_at_idx ON sessions (expires_at);
+290
View File
@@ -0,0 +1,290 @@
#!/usr/bin/env python3
"""Собирает текстовые доказательства уровней 3–4 в evidence/*.log.
python3 scripts/collect_evidence.py # всё (~3 мин)
python3 scripts/collect_evidence.py checks level3 migrations
Секции:
checks make check, make validate, make test, student-tests
persistence docker compose ps до/после + make test-persistence
level3 Basic/Bearer/X-User-Id/logout, KDF, атомарность чата, таблицы
level4 tests/level4.py целиком (включая отказы db/cache)
migrations миграции с нуля, повторный старт, down -v — во временном
compose-проекте lab2fresh (свои volumes, api на :18090),
основной стенд и его данные не затрагиваются
Токены и пароли в логи не попадают.
"""
import argparse
import base64
import json
import statistics
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
from pathlib import Path
from track2_common import ROOT, Pg
BASE = "http://127.0.0.1:8080"
FRESH_PROJECT = "lab2fresh"
FRESH_PORT = 18090
PASSWORD = "Evidence-password-123"
FRESH_OVERRIDE = f"""
services:
db:
ports: !reset []
cache:
ports: !reset []
api:
ports: !override
- "{FRESH_PORT}:8080"
"""
class Log:
def __init__(self, name):
self.path = ROOT / "evidence" / name
commit = sh(["git", "rev-parse", "--short", "HEAD"]).strip()
dirty = " (+ незакоммиченные изменения)" if sh(["git", "status", "--porcelain"]).strip() else ""
self.lines = [f"# {time.strftime('%Y-%m-%d %H:%M:%S %z')}, commit {commit}{dirty}", ""]
def cmd(self, title, args, check=True):
self.lines += [f"$ {title}"]
r = subprocess.run(args, cwd=ROOT, capture_output=True, text=True)
out = (r.stdout + r.stderr).rstrip()
self.lines += [out, f"[exit {r.returncode}]", ""]
print(f" {title}: exit {r.returncode}")
if check and r.returncode != 0:
self.save()
raise SystemExit(f"FAIL: {title}\n{out[-2000:]}")
return out
def note(self, text):
self.lines.append(text)
print(" " + text)
def save(self):
self.path.write_text("\n".join(self.lines) + "\n", encoding="utf-8")
print(f"записан {self.path.relative_to(ROOT)}")
def sh(args):
return subprocess.run(args, cwd=ROOT, capture_output=True, text=True).stdout
def http(method, path, body=None, token=None, headers=None, base=BASE):
h = {"Accept": "application/json"}
data = None
if body is not None:
data = json.dumps(body).encode()
h["Content-Type"] = "application/json"
if token:
h["Authorization"] = "Bearer " + token
h.update(headers or {})
req = urllib.request.Request(base + path, data=data, headers=h, method=method)
try:
with urllib.request.urlopen(req, timeout=15) as resp:
return resp.code, dict(resp.headers), resp.read()
except urllib.error.HTTPError as e:
return e.code, dict(e.headers), e.read()
def basic(username, password):
return {"Authorization": "Basic " + base64.b64encode(f"{username}:{password}".encode()).decode()}
def masked(raw):
try:
j = json.loads(raw)
except (ValueError, TypeError):
return raw.decode(errors="replace") if isinstance(raw, bytes) else str(raw)
if isinstance(j, dict) and "token" in j:
j["token"] = f"<{len(j['token'])} hex-символов, скрыт>"
return json.dumps(j, ensure_ascii=False)
def expect(log, title, status, expected, raw=b"", headers=None):
ok = status == expected
extra = ""
if headers and status == 401:
extra = f" WWW-Authenticate: {headers.get('WWW-Authenticate')}"
log.note(f"{'OK ' if ok else 'FAIL'} {title}: HTTP {status} (ожидалось {expected}){extra}")
if raw:
log.note(f" тело: {masked(raw)[:300]}")
if not ok:
log.save()
raise SystemExit(f"FAIL: {title}")
# ---------- секции ----------
def section_checks():
log = Log("checks.log")
log.cmd("make check", ["make", "check"])
log.cmd("make validate PYTHON=.venv/bin/python", ["make", "validate", "PYTHON=.venv/bin/python"])
log.cmd("make test", ["make", "test"])
log.cmd("python3 student-tests/test_api.py", [sys.executable, "student-tests/test_api.py"])
log.save()
def section_persistence():
log = Log("persistence.log")
log.cmd("docker compose ps (до)", ["docker", "compose", "--env-file", ".env", "ps",
"--format", "table {{.Service}}\t{{.Status}}"])
log.cmd("make test-persistence ACTION_SCRIPT=scripts/restart.sh",
["make", "test-persistence", "ACTION_SCRIPT=scripts/restart.sh"])
log.cmd("docker compose ps (после: все три контейнера перезапущены)",
["docker", "compose", "--env-file", ".env", "ps",
"--format", "table {{.Service}}\t{{.Status}}"])
log.save()
def section_level3():
log = Log("level3.log")
db = Pg.compose()
log.note("## Таблицы PostgreSQL и применённые миграции")
log.lines.append(db.psql("\\dt", tuples=False).strip())
log.note("schema_migrations: " + db.scalar(
"SELECT string_agg(version::text, ',' ORDER BY version) FROM schema_migrations;"))
log.note("")
log.note("## Регистрация и password KDF")
times, user = [], None
for _ in range(5):
t0 = time.perf_counter()
status, _, raw = http("POST", "/api/v1/users", {
"username": "ev_" + uuid.uuid4().hex[:10], "display_name": "Evidence",
"password": PASSWORD})
times.append((time.perf_counter() - t0) * 1000)
expect(log, "POST /users", status, 201)
user = json.loads(raw)
log.note(f"время POST /users (5 запросов): медиана {statistics.median(times):.0f} ms, "
f"min {min(times):.0f}, max {max(times):.0f}")
log.note("в ответе нет password/password_hash: "
f"{'password' not in user and 'password_hash' not in user}")
log.note("параметры hash в БД: " + db.scalar(
"SELECT array_to_string((string_to_array(password_hash, '$'))[2:4], '$') "
f"FROM users WHERE id = '{user['id']}';") + " (соль и hash не выводятся)")
log.note("")
log.note("## Basic только на POST /auth/sessions, Bearer на остальных")
status, h, raw = http("POST", "/api/v1/auth/sessions", headers=basic(user["username"], PASSWORD))
expect(log, "Basic → POST /auth/sessions", status, 201, raw)
token = json.loads(raw)["token"]
status, h, raw = http("POST", "/api/v1/auth/sessions", headers=basic(user["username"], "wrong-password-1"))
expect(log, "неверный пароль → POST /auth/sessions", status, 401, headers=h)
status, h, raw = http("GET", "/api/v1/users/me", headers=basic(user["username"], PASSWORD))
expect(log, "Basic → GET /users/me", status, 401, headers=h)
status, h, raw = http("GET", "/api/v1/users/me", headers={"X-User-Id": user["id"]})
expect(log, "X-User-Id без Bearer → GET /users/me", status, 401, headers=h)
status, h, raw = http("GET", "/api/v1/users/me", token=token)
expect(log, "Bearer → GET /users/me", status, 200, raw)
log.note("")
log.note("## Атомарное создание чата")
title = "atomic-" + uuid.uuid4().hex[:8]
ghost = str(uuid.uuid4())
status, h, raw = http("POST", "/api/v1/chats", {"title": title, "member_ids": [user["id"], ghost]},
token=token)
expect(log, "POST /chats с несуществующим участником", status, 400, raw)
log.note(f"чатов с title={title}: " + db.scalar(f"SELECT count(*) FROM chats WHERE title = '{title}';")
+ f", строк chat_members с этим участником: "
+ db.scalar(f"SELECT count(*) FROM chat_members WHERE user_id = '{ghost}';"))
log.note("")
log.note("## Logout")
status, h, raw = http("DELETE", "/api/v1/auth/sessions/current", token=token)
expect(log, "DELETE /auth/sessions/current", status, 204)
status, h, raw = http("GET", "/api/v1/users/me", token=token)
expect(log, "тот же токен → GET /users/me", status, 401, headers=h)
status, h, raw = http("DELETE", "/api/v1/auth/sessions/current", token=token)
expect(log, "повторный logout", status, 401, headers=h)
log.save()
def section_level4():
log = Log("level4.log")
log.cmd("python3 tests/level4.py", [sys.executable, "tests/level4.py"])
log.save()
def section_migrations():
log = Log("migrations.log")
# Не /tmp: docker compose из snap видит только свой приватный /tmp.
(ROOT / "backups").mkdir(exist_ok=True)
override = str(ROOT / "backups" / f"{FRESH_PROJECT}.override.yaml")
Path(override).write_text(FRESH_OVERRIDE, encoding="utf-8")
compose = ["docker", "compose", "-p", FRESH_PROJECT, "--env-file", ".env",
"-f", "compose.yaml", "-f", override]
fdb = Pg(compose + ["exec", "-T", "db"], FRESH_PROJECT)
fresh = f"http://127.0.0.1:{FRESH_PORT}"
def count_users():
return fdb.scalar("SELECT count(*) FROM users;")
try:
log.note(f"Временный проект `{FRESH_PROJECT}`: отдельные volumes "
f"{FRESH_PROJECT}_pgdata/{FRESH_PROJECT}_valkeydata, api на :{FRESH_PORT}, "
"БД и Valkey без проброса портов. Основной стенд не затрагивается.")
log.cmd("down -v (очистка остатков прошлого запуска)", compose + ["down", "-v"], check=False)
log.cmd("up -d --wait (пустые volumes)", compose + ["up", "-d", "--no-build", "--wait"])
log.cmd("логи api: миграции на пустой БД", compose + ["logs", "api", "--no-log-prefix"])
log.note("schema_migrations: " + fdb.scalar(
"SELECT string_agg(version::text, ',' ORDER BY version) FROM schema_migrations;"))
status, _, _ = http("POST", "/api/v1/users", {
"username": "fresh_" + uuid.uuid4().hex[:8], "display_name": "F", "password": PASSWORD},
base=fresh)
log.note(f"POST /users на новом стенде: HTTP {status}; пользователей в БД: {count_users()}")
log.note("")
time.sleep(1)
restarted_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
log.cmd("restart api (повторный запуск миграций)", compose + ["restart", "api"])
log.cmd("up -d --wait", compose + ["up", "-d", "--no-build", "--wait"])
out = log.cmd(f"логи api после рестарта (--since {restarted_at})",
compose + ["logs", "api", "--no-log-prefix", "--since", restarted_at])
log.note(f"строк 'applied migration' после рестарта: {out.count('applied migration')}; "
f"schema_migrations: {fdb.scalar('SELECT count(*) FROM schema_migrations;')} строки; "
f"пользователей: {count_users()} (данные не дублируются и не теряются)")
log.note("")
log.cmd("down -v (НАМЕРЕННОЕ удаление volumes временного проекта)", compose + ["down", "-v"])
log.cmd("up -d --wait", compose + ["up", "-d", "--no-build", "--wait"])
log.note(f"после down -v пользователей: {count_users()} — все данные и сессии потеряны, "
"миграции применены заново")
finally:
subprocess.run(compose + ["down", "-v"], cwd=ROOT, capture_output=True)
Path(override).unlink(missing_ok=True)
log.note(f"временный проект {FRESH_PROJECT} удалён вместе с volumes")
log.save()
SECTIONS = {
"checks": section_checks,
"persistence": section_persistence,
"level3": section_level3,
"level4": section_level4,
"migrations": section_migrations,
}
def main():
p = argparse.ArgumentParser()
p.add_argument("sections", nargs="*", help=", ".join(SECTIONS) + " (по умолчанию все)")
args = p.parse_args()
unknown = [s for s in args.sections if s not in SECTIONS]
if unknown:
p.error(f"неизвестные секции: {', '.join(unknown)}")
for name in args.sections or SECTIONS:
print(f"== {name} ==")
SECTIONS[name]()
print("PASS: evidence collected")
if __name__ == "__main__":
main()
+230
View File
@@ -0,0 +1,230 @@
#!/usr/bin/env python3
"""Наполняет БД синтетическими сообщениями и снимает EXPLAIN (ANALYZE, BUFFERS).
Проверяет три вещи:
1) индекс messages_chat_keyset_idx используется на первой странице;
2) глубокая keyset-страница не деградирует по сравнению с первой;
3) OFFSET-пагинация читает все пропущенные строки (для контраста).
Использование:
python3 scripts/perf.py seed --messages 15000
python3 scripts/perf.py explain
python3 scripts/perf.py all --messages 15000
"""
import argparse
from pathlib import Path
from track2_common import Pg
db = Pg.compose()
PERF_USER_ID = "11111111-1111-4111-8111-111111111111"
PERF_CHAT_ID = "22222222-2222-4222-8222-222222222222"
DEEP_OFFSET = 7000 # позиция "середины" истории для keyset-курсора
PAGE_LIMIT = 50 # как limit по умолчанию в контракте
# ---------- psql-обёртка ----------
def run_psql(sql, tuples_only=False):
"""Запускает psql в контейнере db, передаёт SQL на stdin, возвращает stdout."""
return db.psql(sql, tuples=tuples_only)
def explain_block(body_sql):
"""EXPLAIN (ANALYZE, BUFFERS) <body_sql>."""
return run_psql("EXPLAIN (ANALYZE, BUFFERS)\n" + body_sql)
# ---------- SQL-тела запросов ----------
def sql_first_page(limit):
"""Первая страница: без курсора. Точно как делает MessageRepo::list_page."""
return f"""
SELECT id, chat_id, sender_id, text,
EXTRACT(EPOCH FROM created_at)::bigint AS created_at_epoch
FROM messages
WHERE chat_id = '{PERF_CHAT_ID}'
ORDER BY created_at ASC, id ASC
LIMIT {limit + 1};
"""
def sql_page_with_cursor(cursor_ts, cursor_id, limit):
"""Страница с keyset-курсором. То же, что MessageRepo::list_page при cursor!=nullopt."""
return f"""
SELECT id, chat_id, sender_id, text,
EXTRACT(EPOCH FROM created_at)::bigint AS created_at_epoch
FROM messages
WHERE chat_id = '{PERF_CHAT_ID}'
AND (created_at, id) > ('{cursor_ts}'::timestamptz, '{cursor_id}'::uuid)
ORDER BY created_at ASC, id ASC
LIMIT {limit + 1};
"""
def sql_offset_page(limit, offset):
"""OFFSET-пагинация. В приложении не используется, нужна для контраста."""
return f"""
SELECT id, chat_id, sender_id, text,
EXTRACT(EPOCH FROM created_at)::bigint AS created_at_epoch
FROM messages
WHERE chat_id = '{PERF_CHAT_ID}'
ORDER BY created_at ASC, id ASC
OFFSET {offset} LIMIT {limit + 1};
"""
# ---------- Сценарии ----------
def seed(messages):
"""Идемпотентно наполняет чат сообщениями."""
existing = run_psql(
f"SELECT count(*) FROM messages WHERE chat_id = '{PERF_CHAT_ID}';",
tuples_only=True,
).strip()
if existing and int(existing) > 0:
print(f"chat already has {existing} messages, skipping seed")
return
sql = f"""
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ('{PERF_USER_ID}', 'perf_user', 'Perf',
'$argon2id$v=19$m=65536,t=2,p=1$FAKE$FAKE', now())
ON CONFLICT (id) DO NOTHING;
INSERT INTO chats (id, title, created_at)
VALUES ('{PERF_CHAT_ID}', 'Perf chat', now())
ON CONFLICT (id) DO NOTHING;
INSERT INTO chat_members (chat_id, user_id)
VALUES ('{PERF_CHAT_ID}', '{PERF_USER_ID}')
ON CONFLICT DO NOTHING;
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), '{PERF_CHAT_ID}', '{PERF_USER_ID}',
'msg-' || g, now() - (g || ' minutes')::interval
FROM generate_series(1, {messages}) AS g;
"""
run_psql(sql)
total = run_psql(
f"SELECT count(*) FROM messages WHERE chat_id = '{PERF_CHAT_ID}';",
tuples_only=True,
).strip()
print(f"seeded, chat now has {total} messages")
def analyze():
"""Обновляет статистику — критично, чтобы планировщик не выбрал Bitmap по устаревшим данным."""
run_psql("ANALYZE messages;")
print("ANALYZE messages — done")
def find_deep_cursor():
"""Возвращает (id, ts_rfc3339) строки на позиции DEEP_OFFSET."""
out = run_psql(
f"""
SELECT id,
to_char(created_at AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS"Z"')
FROM messages
WHERE chat_id = '{PERF_CHAT_ID}'
ORDER BY created_at ASC, id ASC
OFFSET {DEEP_OFFSET} LIMIT 1;
""",
tuples_only=True,
).strip()
id_, ts = out.split("|")
return id_, ts
# ---------- Снятие планов ----------
def plan_first_page_with_index(limit):
return explain_block(sql_first_page(limit))
def plan_first_page_without_index(limit):
"""Временный DROP INDEX и ROLLBACK — всё в одной транзакции, индекс вернётся."""
body = sql_first_page(limit)
sql = f"""
BEGIN;
DROP INDEX messages_chat_keyset_idx;
EXPLAIN (ANALYZE, BUFFERS)
{body}
ROLLBACK;
"""
return run_psql(sql)
def plan_deep_page_with_index(cursor_ts, cursor_id, limit):
return explain_block(sql_page_with_cursor(cursor_ts, cursor_id, limit))
def plan_offset_page(limit, offset):
return explain_block(sql_offset_page(limit, offset))
# ---------- Сохранение доказательств ----------
def write_evidence(blocks):
out_dir = Path("evidence")
out_dir.mkdir(exist_ok=True)
path = out_dir / "explain.md"
with open(path, "w", encoding="utf-8") as f:
f.write("# EXPLAIN (ANALYZE, BUFFERS) — индекс истории\n\n")
f.write(f"- PostgreSQL 16 (локальный контейнер)\n")
f.write(f"- Таблица `messages`: 15 000 строк в чате `{PERF_CHAT_ID}`\n")
f.write(f"- `created_at` распределено равномерно по 30 дням назад\n")
f.write(f"- `PAGE_LIMIT` = {PAGE_LIMIT}, `DEEP_OFFSET` = {DEEP_OFFSET}\n\n")
for title, body in blocks:
f.write(f"## {title}\n\n```\n{body.strip()}\n```\n\n")
print(f"\nwritten {path}")
# ---------- main ----------
def main():
p = argparse.ArgumentParser(description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument("action", choices=["seed", "explain", "all"])
p.add_argument("--messages", type=int, default=15000)
args = p.parse_args()
if args.action in ("seed", "all"):
seed(args.messages)
if args.action in ("explain", "all"):
analyze()
print(f"finding cursor at OFFSET {DEEP_OFFSET}...")
cursor_id, cursor_ts = find_deep_cursor()
print(f" cursor: ts={cursor_ts} id={cursor_id}")
print("\nEXPLAIN 1/4: первая страница, с индексом")
p1 = plan_first_page_with_index(PAGE_LIMIT)
print("EXPLAIN 2/4: первая страница, без индекса (контраст)")
p2 = plan_first_page_without_index(PAGE_LIMIT)
print("EXPLAIN 3/4: глубокая страница через keyset-курсор, с индексом")
p3 = plan_deep_page_with_index(cursor_ts, cursor_id, PAGE_LIMIT)
print("EXPLAIN 4/4: OFFSET 7000 (контраст с keyset)")
p4 = plan_offset_page(PAGE_LIMIT, DEEP_OFFSET)
write_evidence([
("1. Первая страница, с индексом", p1),
("2. Первая страница, без индекса (контраст)", p2),
(f"3. Глубокая страница (keyset, OFFSET {DEEP_OFFSET}), с индексом", p3),
(f"4. OFFSET {DEEP_OFFSET} (контраст)", p4),
])
# Дублируем в stdout, чтобы не открывать файл лишний раз.
for title, body in [("1. first-page/index", p1),
("2. first-page/no-index", p2),
("3. deep-keyset/index", p3),
("4. offset/contrast", p4)]:
print(f"\n===== {title} =====\n{body.strip()}")
if __name__ == "__main__":
main()
+139
View File
@@ -0,0 +1,139 @@
#!/usr/bin/env python3
"""Наполняет БД ≥100 000 сообщений с неравномерными чатами (Track 2).
Использование:
python3 scripts/perf100k.py seed # ~110k сообщений, 79 чатов
python3 scripts/perf100k.py seed-burst # чат, где все created_at совпадают
python3 scripts/perf100k.py count
Профиль seed детерминирован (random.Random(42)), Zipf-подобный:
60 маленьких чатов 5..80 сообщений, окно времени 1 час
15 средних чатов 100..1500, окно 1 день
4 больших чата 10000..40000, окно 1 неделя
seed-burst моделирует всплеск: приложение хранит created_at с точностью
до секунды, поэтому сообщения одной секунды имеют одинаковый created_at
и порядок внутри неё задаёт только id.
"""
import argparse
import random
from track2_common import PERF_USER_ID, Pg
db = Pg.compose()
def ensure_perf_user():
db.psql(f"""
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ('{PERF_USER_ID}', 'perf2_user', 'Perf2',
'$argon2id$v=19$m=65536,t=2,p=1$FAKE$FAKE', now())
ON CONFLICT (id) DO NOTHING;
""")
def chat_sizes():
rng = random.Random(42)
sizes = [rng.randint(5, 80) for _ in range(60)]
sizes += [rng.randint(100, 1500) for _ in range(15)]
sizes += [rng.randint(10000, 40000) for _ in range(3)]
sizes.append(20000)
return sizes
def classify(size):
if size <= 80:
return "small", 3600
if size <= 1500:
return "medium", 86400
return "large", 604800
def seed():
existing = int(db.scalar("SELECT count(*) FROM messages WHERE text LIKE 'perf2-%';"))
if existing >= 100000:
print(f"уже засеяно: {existing} сообщений, пропуск")
return
ensure_perf_user()
sizes = chat_sizes()
print(f"план: {len(sizes)} чатов, {sum(sizes)} сообщений")
created_total = 0
for idx, sz in enumerate(sizes):
cls, window_seconds = classify(sz)
db.psql(f"""
DO $$
DECLARE
cid uuid := gen_random_uuid();
BEGIN
INSERT INTO chats (id, title, created_at)
VALUES (cid, 'perf-{cls}-{idx}-sz{sz}', now() - interval '{idx + 1} hours');
INSERT INTO chat_members (chat_id, user_id) VALUES (cid, '{PERF_USER_ID}');
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), cid, '{PERF_USER_ID}',
'perf2-{idx}-' || g,
date_trunc('second', now()) - floor(random() * {window_seconds}) * interval '1 second'
FROM generate_series(1, {sz}) AS g;
END $$;
""")
created_total += sz
if idx % 10 == 0 or idx == len(sizes) - 1:
print(f" [{idx + 1}/{len(sizes)}] {cls} size {sz}, всего {created_total}")
db.psql("ANALYZE messages; ANALYZE chats; ANALYZE chat_members;")
print(f"засеяно {created_total} сообщений, ANALYZE выполнен")
def seed_burst(size):
title = f"perf-burst-ties-sz{size}"
if db.scalar(f"SELECT count(*) FROM chats WHERE title = '{title}';") != "0":
print(f"чат {title} уже есть, пропуск")
return
ensure_perf_user()
db.psql(f"""
DO $$
DECLARE
cid uuid := gen_random_uuid();
ts timestamptz := date_trunc('second', now()) - interval '2 days';
BEGIN
INSERT INTO chats (id, title, created_at) VALUES (cid, '{title}', ts);
INSERT INTO chat_members (chat_id, user_id) VALUES (cid, '{PERF_USER_ID}');
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), cid, '{PERF_USER_ID}', 'perf2-burst-' || g, ts
FROM generate_series(1, {size}) AS g;
END $$;
ANALYZE messages;
""")
print(f"создан {title}: {size} сообщений с одним created_at")
def count():
print(db.psql("""
SELECT split_part(c.title, '-', 2) AS class, count(DISTINCT c.id) AS chats,
count(m.id) AS messages, min(n.cnt) AS min_size, max(n.cnt) AS max_size
FROM chats c
JOIN messages m ON m.chat_id = c.id
JOIN (SELECT chat_id, count(*) AS cnt FROM messages GROUP BY chat_id) n ON n.chat_id = c.id
WHERE c.title LIKE 'perf-%'
GROUP BY 1 ORDER BY 3;
SELECT count(*) AS all_messages FROM messages;
""", tuples=False))
def main():
p = argparse.ArgumentParser()
p.add_argument("action", choices=["seed", "seed-burst", "count"])
p.add_argument("--burst-size", type=int, default=5000)
args = p.parse_args()
if args.action == "seed":
seed()
elif args.action == "seed-burst":
seed_burst(args.burst_size)
else:
count()
if __name__ == "__main__":
main()
+27
View File
@@ -0,0 +1,27 @@
#!/usr/bin/env bash
# Перезапускает api, db и cache, сохраняя volumes (данные и сессии).
# Используется тестом persistence: до рестарта создаём данные,
# после — читаем их тем же токеном.
set -euo pipefail
cd "$(dirname "$0")/.."
echo "stopping services (volumes kept)..." >&2
docker compose --env-file .env stop api db cache
echo "starting services (volumes kept)..." >&2
docker compose --env-file .env up -d
echo "waiting for api readiness..." >&2
for i in $(seq 1 60); do
if curl -fsS http://127.0.0.1:8080/health/ready >/dev/null 2>&1; then
echo "api ready after ${i} attempt(s)" >&2
exit 0
fi
sleep 1
done
echo "api did not become ready in 60s" >&2
docker compose logs api --tail=50 >&2 || true
exit 1
+162
View File
@@ -0,0 +1,162 @@
"""Общие помощники скриптов Track 2.
psql/pgbench/pg_dump запускаются внутри контейнеров (`docker compose exec`
или `docker exec`), поэтому на хосте нужны только Docker и Python 3.9+.
Учётные данные берутся из .env (POSTGRES_USER, POSTGRES_DB) и не печатаются.
"""
import datetime
import os
import platform
import statistics
import subprocess
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
PERF_USER_ID = "11111111-1111-4111-8111-111111111111"
MESSAGE_COLS = ("id, chat_id, sender_id, text, "
"EXTRACT(EPOCH FROM created_at)::bigint AS created_at_epoch")
def load_env():
env = {}
path = ROOT / ".env"
if path.exists():
for line in path.read_text(encoding="utf-8").splitlines():
line = line.strip()
if not line or line.startswith("#") or "=" not in line:
continue
key, value = line.split("=", 1)
env[key.strip()] = value.strip().strip('"').strip("'")
for key in ("POSTGRES_USER", "POSTGRES_DB", "SESSION_STORE"):
if os.environ.get(key):
env[key] = os.environ[key]
missing = [k for k in ("POSTGRES_USER", "POSTGRES_DB") if not env.get(k)]
if missing:
raise SystemExit(f"не заданы {', '.join(missing)} в .env")
return env
ENV = load_env()
class Pg:
"""Клиент к PostgreSQL в контейнере через stdin/stdout утилит."""
def __init__(self, exec_prefix, label):
self.prefix = exec_prefix
self.label = label
@classmethod
def compose(cls, service="db"):
return cls(["docker", "compose", "--env-file", str(ROOT / ".env"),
"exec", "-T", service], service)
@classmethod
def container(cls, name):
return cls(["docker", "exec", "-i", name], name)
def run(self, args, input=None, binary=False, check=True, stdout=None):
r = subprocess.run(
self.prefix + args,
input=input,
stdout=stdout if stdout is not None else subprocess.PIPE,
stderr=subprocess.PIPE,
text=not binary,
cwd=ROOT,
)
if check and r.returncode != 0:
err = r.stderr if not binary else r.stderr.decode(errors="replace")
sys.stderr.write(err)
raise SystemExit(f"[{self.label}] команда {args[0]} завершилась с кодом {r.returncode}")
return r
def psql(self, sql, tuples=True):
args = ["psql", "-U", ENV["POSTGRES_USER"], "-d", ENV["POSTGRES_DB"],
"-X", "-q", "-v", "ON_ERROR_STOP=1"]
if tuples:
args += ["-t", "-A", "-F", "\t"]
return self.run(args, input=sql).stdout
def scalar(self, sql):
return self.psql(sql).strip()
def rows(self, sql):
return [line.split("\t") for line in self.psql(sql).splitlines() if line]
def median(values):
return statistics.median(values) if values else float("nan")
def pick_chats(db):
"""Выбирает чаты разного размера из засеянных perf100k.py."""
rows = db.rows("""
SELECT c.id, c.title, count(m.id)
FROM chats c JOIN messages m ON m.chat_id = c.id
WHERE c.title LIKE 'perf-%'
GROUP BY c.id, c.title;
""")
chats = [(r[0], r[1], int(r[2])) for r in rows]
regular = [c for c in chats if not c[1].startswith("perf-burst")]
burst = [c for c in chats if c[1].startswith("perf-burst")]
if sum(c[2] for c in regular) < 100_000:
raise SystemExit("меньше 100 000 perf-сообщений: запустите "
"python3 scripts/perf100k.py seed")
if not burst:
raise SystemExit("нет чата с одинаковыми created_at: запустите "
"python3 scripts/perf100k.py seed-burst")
def closest(target):
return min(regular, key=lambda c: abs(c[2] - target))
return [
("small", closest(50)),
("medium", closest(1000)),
("large", max(regular, key=lambda c: c[2])),
("burst", burst[0]),
]
def environment_lines(db):
commit = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=ROOT,
capture_output=True, text=True).stdout.strip()
dirty = subprocess.run(["git", "status", "--porcelain"], cwd=ROOT,
capture_output=True, text=True).stdout.strip()
try:
mem_kb = int(next(l for l in Path("/proc/meminfo").read_text().splitlines()
if l.startswith("MemTotal")).split()[1])
mem = f"{mem_kb / 1024 / 1024:.1f} GiB"
except (OSError, StopIteration, ValueError):
mem = "unknown"
version = db.scalar("SHOW server_version;")
return [
f"- Дата: {datetime.datetime.now().astimezone().isoformat(timespec='seconds')}",
f"- Commit: `{commit or 'unknown'}`{' (есть незакоммиченные изменения)' if dirty else ''}",
f"- Хост: {platform.system()} {platform.release()}, {os.cpu_count()} CPU, RAM {mem}; "
"CPU/RAM-лимиты контейнеров не заданы",
f"- PostgreSQL {version} (`postgres:16-alpine`), настройки по умолчанию, "
f"synchronous_commit={db.scalar('SHOW synchronous_commit;')}, "
f"shared_buffers={db.scalar('SHOW shared_buffers;')}",
]
def dataset_lines(db):
total, chats, mn, med, mx = db.rows("""
SELECT (SELECT count(*) FROM messages),
count(*), min(n), percentile_disc(0.5) WITHIN GROUP (ORDER BY n), max(n)
FROM (SELECT chat_id, count(*) AS n FROM messages GROUP BY chat_id) s;
""")[0]
size = db.scalar("SELECT pg_size_pretty(pg_table_size('messages'));")
return [
f"- Сообщений: {int(total):,}".replace(",", " ") +
f", чатов с сообщениями: {chats}; размер чата min/median/max = {mn}/{med}/{mx}",
f"- Размер heap таблицы `messages`: {size}",
]
def write_evidence(name, text):
path = ROOT / "evidence" / name
path.parent.mkdir(exist_ok=True)
path.write_text(text, encoding="utf-8")
print(f"\nзаписан {path.relative_to(ROOT)}")
+414
View File
@@ -0,0 +1,414 @@
#!/usr/bin/env python3
"""Track 2, часть 1: план запроса истории и стоимость записи.
Варианты индексов на messages (кроме PK):
none — только messages_pkey (id)
C — (chat_id, created_at), без id
A — (chat_id, created_at, id), индекс из миграции 001
A+C — оба (только в бенче записи: цена лишнего индекса)
Чтение: запросы приложения (MessageRepo::list_page) на чатах small/medium/
large/burst: Q1 — первая страница, Q2 — keyset-страница из середины чата,
Q3 — OFFSET на той же глубине (контраст). EXPLAIN (ANALYZE, BUFFERS),
1 прогрев + N замеров, медиана Execution Time.
Запись: pgbench, однострочные INSERT в отдельных транзакциях (как POST
/messages), раунды с ротацией порядка вариантов; CHECKPOINT и VACUUM перед
каждым прогоном; метрики TPS, средняя latency и байты WAL на вставку.
В конце индексы возвращаются к состоянию миграций (только A).
Результат: evidence/track2_indexes.md.
python3 scripts/track2_indexes.py
python3 scripts/track2_indexes.py --write-seconds 20 --write-rounds 5
"""
import argparse
import json
import re
from track2_common import (ENV, MESSAGE_COLS, PERF_USER_ID, Pg, dataset_lines,
environment_lines, median, pick_chats, write_evidence)
db = Pg.compose()
INDEXES = {
"A": ("messages_chat_keyset_idx", "(chat_id, created_at, id)"),
"C": ("track2_chat_created_idx", "(chat_id, created_at)"),
}
READ_VARIANTS = [("none", []), ("C", ["C"]), ("A", ["A"])]
WRITE_VARIANTS = [("none", []), ("C", ["C"]), ("A", ["A"]), ("A+C", ["A", "C"])]
CHAT_ORDER = ["small", "medium", "large", "burst"]
QUERIES = ["Q1", "Q2", "Q3"]
QUERY_TITLE = {
"Q1": "первая страница",
"Q2": "keyset из середины",
"Q3": "OFFSET из середины",
}
PAGE = 51 # limit + 1, как в приложении
BENCH_SQL = (
"INSERT INTO messages (id, chat_id, sender_id, text, created_at) "
"VALUES (gen_random_uuid(), ':chat', ':sender', 'track2-bench', "
"date_trunc('second', clock_timestamp()));\n"
)
def set_indexes(keys):
sql = []
for key, (name, _) in INDEXES.items():
if key not in keys:
sql.append(f"DROP INDEX IF EXISTS {name};")
for key in keys:
name, cols = INDEXES[key]
sql.append(f"CREATE INDEX IF NOT EXISTS {name} ON messages {cols};")
sql.append("ANALYZE messages;")
db.psql("\n".join(sql))
def index_size(key):
return int(db.scalar(f"SELECT pg_relation_size('{INDEXES[key][0]}');"))
# ---------- чтение ----------
def build_queries(chat_id, size):
depth = size // 2
ts, mid_id = db.rows(f"""
SELECT created_at::text, id FROM messages WHERE chat_id = '{chat_id}'
ORDER BY created_at, id OFFSET {depth} LIMIT 1;
""")[0]
base = f"SELECT {MESSAGE_COLS} FROM messages WHERE chat_id = '{chat_id}'"
order = "ORDER BY created_at ASC, id ASC"
return {
"Q1": f"{base} {order} LIMIT {PAGE}",
"Q2": f"{base} AND (created_at, id) > ('{ts}'::timestamptz, '{mid_id}'::uuid) "
f"{order} LIMIT {PAGE}",
"Q3": f"{base} {order} OFFSET {depth} LIMIT {PAGE}",
}
def walk(node):
yield node
for child in node.get("Plans", []):
yield from walk(child)
def summarize(plan_json):
top = plan_json[0]
plan = top["Plan"]
nodes, rows_read = [], 0
for n in walk(plan):
label = n["Node Type"]
if n.get("Index Name"):
label += f" ({n['Index Name']})"
nodes.append(label)
if not n.get("Plans"):
# Для параллельных узлов EXPLAIN показывает среднее на один loop.
per_loop = n.get("Actual Rows", 0) + n.get("Rows Removed by Filter", 0)
rows_read += round(per_loop * n.get("Actual Loops", 1))
return {
"ms": top["Execution Time"],
"buffers": plan.get("Shared Hit Blocks", 0) + plan.get("Shared Read Blocks", 0),
"rows_read": rows_read,
"plan": " → ".join(nodes),
}
def measure_read(sql, reps):
explain = f"EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) {sql};"
db.psql(explain) # прогрев
runs = [summarize(json.loads(db.psql(explain))) for _ in range(reps)]
result = runs[-1]
result["ms"] = median([r["ms"] for r in runs])
return result
def text_plan(sql):
return db.psql(f"EXPLAIN (ANALYZE, BUFFERS) {sql};", tuples=False).strip()
def read_phase(chats, reps):
results, plans, sizes = {}, {}, {}
queries = {label: build_queries(c[0], c[2]) for label, c in chats}
for variant, keys in READ_VARIANTS:
print(f"\n[чтение] вариант {variant}")
set_indexes(keys)
for key in keys:
sizes[key] = index_size(key)
for label in CHAT_ORDER:
for q in QUERIES:
r = measure_read(queries[label][q], reps)
results[(label, q, variant)] = r
print(f" {label:6} {q}: {r['ms']:8.3f} ms, buffers={r['buffers']:5}, "
f"rows_read={r['rows_read']:6} {r['plan']}")
for label, q in (("large", "Q2"), ("burst", "Q2"), ("small", "Q1")):
plans[(label, q, variant)] = text_plan(queries[label][q])
return results, plans, sizes
# ---------- запись ----------
def install_bench_script():
db.run(["sh", "-c", "cat > /tmp/track2_insert.sql"], input=BENCH_SQL)
def pgbench_once(chat_id, seconds, clients):
db.psql(f"""
DELETE FROM messages WHERE text = 'track2-bench';
VACUUM messages;
CHECKPOINT;
""")
lsn0 = db.scalar("SELECT pg_current_wal_lsn();")
out = db.run(["pgbench", "-n", "-U", ENV["POSTGRES_USER"], "-d", ENV["POSTGRES_DB"],
"-f", "/tmp/track2_insert.sql",
"-D", f"chat={chat_id}", "-D", f"sender={PERF_USER_ID}",
"-c", str(clients), "-j", str(clients), "-T", str(seconds)]).stdout
wal = int(db.scalar(f"SELECT pg_wal_lsn_diff(pg_current_wal_lsn(), '{lsn0}');"))
tx = int(re.search(r"actually processed: (\d+)", out).group(1))
tps = float(re.search(r"tps = ([\d.]+)", out).group(1))
lat = float(re.search(r"latency average = ([\d.]+) ms", out).group(1))
return {"tps": tps, "lat": lat, "wal_per_tx": wal / tx, "tx": tx}
def write_phase(chat_id, seconds, rounds, clients):
install_bench_script()
runs = {v: [] for v, _ in WRITE_VARIANTS}
db.psql("ALTER TABLE messages SET (autovacuum_enabled = false);")
try:
for rnd in range(rounds):
shift = rnd % len(WRITE_VARIANTS)
order = WRITE_VARIANTS[shift:] + WRITE_VARIANTS[:shift]
print(f"\n[запись] раунд {rnd + 1}/{rounds}: {' → '.join(v for v, _ in order)}")
for variant, keys in order:
set_indexes(keys)
r = pgbench_once(chat_id, seconds, clients)
runs[variant].append(r)
print(f" {variant:5} tps={r['tps']:8.1f} lat={r['lat']:.3f} ms "
f"WAL={r['wal_per_tx']:.0f} B/insert ({r['tx']} tx)")
finally:
db.psql("DELETE FROM messages WHERE text = 'track2-bench';")
db.psql("ALTER TABLE messages RESET (autovacuum_enabled); VACUUM ANALYZE messages;")
return runs
# ---------- отчёт ----------
def fmt_ms(v):
return f"{v:.3f}" if v < 10 else f"{v:.1f}"
def conclusions(chats, R, W, sizes):
size_of = {label: c[2] for label, c in chats}
out = []
# H1: индекс A даёт стоимость страницы, не зависящую от размера и глубины.
a_cells = [R[(l, q, "A")] for l in ("small", "medium", "large", "burst") for q in ("Q1", "Q2")]
a_rows = max(c["rows_read"] for c in a_cells)
a_buf = max(c["buffers"] for c in a_cells)
a_ms = max(c["ms"] for c in a_cells)
ok = a_rows <= PAGE
sorted_cells = [f"{l} {q}" for l in CHAT_ORDER for q in ("Q1", "Q2")
if "Sort" in R[(l, q, "A")]["plan"]]
sort_note = (
"Узла Sort нет ни в одном плане: порядок `(created_at, id)` берётся из индекса."
if not sorted_cells else
f"Sort встречается только в {', '.join(sorted_cells)}: для чата из {size_of['small']} "
f"сообщений планировщику дешевле взять все строки чата Bitmap-сканом по тому же индексу "
f"и отсортировать их в памяти; строк всё равно не больше размера чата."
)
out.append(
f"**H1 (индекс A, стоимость страницы постоянна) — {'подтверждена' if ok else 'НЕ подтверждена'}.** "
f"Для Q1 и Q2 на всех чатах (от {size_of['small']} до {size_of['large']} сообщений, "
f"включая середину чата и чат-всплеск) читается не более {a_rows} строк и {a_buf} буферов, "
f"время ≤ {fmt_ms(a_ms)} ms. {sort_note}"
)
# Без индекса.
n_small, n_large = R[("small", "Q1", "none")], R[("large", "Q1", "none")]
a_small = R[("small", "Q1", "A")]
out.append(
f"**Без вторичного индекса** стоимость определяется размером всей таблицы, а не чата: "
f"первая страница чата из {size_of['small']} сообщений читает {n_small['buffers']} буферов "
f"({fmt_ms(n_small['ms'])} ms), чата из {size_of['large']} — {n_large['buffers']} буферов "
f"({fmt_ms(n_large['ms'])} ms). Для маленького чата это в "
f"{n_small['ms'] / a_small['ms']:.0f}× медленнее индекса A. "
f"Узел: `{n_small['plan']}`."
)
# H2: C ломается на одинаковых created_at.
cb, ab = R[("burst", "Q2", "C")], R[("burst", "Q2", "A")]
cl, al = R[("large", "Q2", "C")], R[("large", "Q2", "A")]
ok = cb["rows_read"] >= 10 * max(ab["rows_read"], 1)
out.append(
f"**H2 (индекс C без id деградирует на одинаковых created_at) — "
f"{'подтверждена' if ok else 'НЕ подтверждена'}.** "
f"На обычном большом чате C почти не отличается от A: Q2 {fmt_ms(cl['ms'])} против "
f"{fmt_ms(al['ms'])} ms, потому что совпадений по секунде мало и Incremental Sort "
f"сортирует крошечные группы. В чате-всплеске ({size_of['burst']} сообщений в одну секунду) "
f"условие по id становится Filter, и C читает {cb['rows_read']} строк / {cb['buffers']} "
f"буферов за {fmt_ms(cb['ms'])} ms, а A — {ab['rows_read']} строк / {ab['buffers']} буферов "
f"за {fmt_ms(ab['ms'])} ms ({cb['ms'] / ab['ms']:.0f}×). Приложение хранит время с точностью "
f"до секунды, поэтому такой всплеск реалистичен при нагрузке: `id` в индексе обязателен."
)
# OFFSET.
q3, q2 = R[("large", "Q3", "A")], R[("large", "Q2", "A")]
out.append(
f"**OFFSET против keyset** на середине чата из {size_of['large']} сообщений, индекс A: "
f"OFFSET читает {q3['rows_read']} строк и {q3['buffers']} буферов ({fmt_ms(q3['ms'])} ms), "
f"keyset — {q2['rows_read']} строк и {q2['buffers']} буферов ({fmt_ms(q2['ms'])} ms). "
f"Стоимость OFFSET растёт линейно с глубиной, поэтому приложение использует курсор."
)
# Запись.
if W:
def stats(v):
tps = [r["tps"] for r in W[v]]
return median(tps), min(tps), max(tps), median([r["wal_per_tx"] for r in W[v]])
base_tps, base_min, base_max, base_wal = stats("none")
lines = []
for v in ("C", "A", "A+C"):
tps, mn, mx, wal = stats(v)
overlap = mn <= base_max and mx >= base_min
lines.append(
f"{v}: WAL {wal - base_wal:+.0f} B/вставку ({(wal / base_wal - 1) * 100:+.0f}%), "
f"TPS {(tps / base_tps - 1) * 100:+.1f}%"
+ (" (в пределах разброса прогонов)" if overlap else "")
)
out.append(
"**H3 (каждый вторичный индекс удорожает запись) — по WAL подтверждена.** "
f"База без вторичных индексов: {base_wal:.0f} B WAL на вставку, медиана {base_tps:.0f} TPS. "
+ "; ".join(lines) + ". "
"Объём WAL детерминирован и растёт с каждым индексом; TPS на локальном диске и "
"4 клиентах ограничен fsync при COMMIT, поэтому разница по TPS меньше и частично "
"тонет в шуме — это ограничение замера, а не отсутствие цены."
)
sa, sc = sizes.get("A"), sizes.get("C")
if sa and sc:
out.append(
f"**Размер:** A = {sa / 1024 / 1024:.1f} MiB, C = {sc / 1024 / 1024:.1f} MiB: "
f"`id` в ключе добавляет {(sa / sc - 1) * 100:.0f}% к размеру индекса."
)
out.append(
"**Решение:** оставить только A `(chat_id, created_at, id)`. Он один обслуживает и "
"первую, и любую следующую страницу за константное число буферов независимо от "
"размера чата и совпадений времени. C экономит немного места, но ломается на всплесках; "
"A+C платит за второй индекс при каждой записи без выигрыша для чтения."
)
return out
def render(chats, R, plans, W, sizes, args, env, dataset):
md = ["# Track 2. План запроса истории и стоимость записи", "",
"Сгенерировано `python3 scripts/track2_indexes.py "
f"--read-reps {args.read_reps} --write-seconds {args.write_seconds} "
f"--write-rounds {args.write_rounds} --clients {args.clients}`.", "",
"## Окружение и данные", "", *env, *dataset, "",
"Выбранные чаты:", "",
"| Метка | Чат | Сообщений |", "|---|---|---|"]
for label, (cid, title, n) in chats:
md.append(f"| {label} | `{title}` | {n} |")
md += ["",
"## Гипотезы", "",
"- **H1.** С индексом A `(chat_id, created_at, id)` страница истории читает ≈limit строк "
"независимо от размера чата и глубины курсора; без индекса читается вся таблица.",
"- **H2.** Индекс C `(chat_id, created_at)` без `id` эквивалентен A, пока `created_at` "
"уникален, но деградирует, когда много сообщений приходится на одну секунду.",
"- **H3.** Каждый вторичный индекс увеличивает стоимость INSERT (WAL, latency).", "",
"## Методика", "",
"- Запросы — те же, что в `MessageRepo::list_page`: `LIMIT 51` (limit+1), "
"порядок `(created_at, id)`. Курсор Q2 и OFFSET Q3 указывают на середину чата.",
f"- Для каждого варианта индексы пересоздаются, затем `ANALYZE`. "
f"`EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)`: 1 прогрев + {args.read_reps} замеров, "
"медиана Execution Time; buffers = shared hit + read последнего замера; "
"rows_read — строки, прочитанные листовым узлом скана (включая отброшенные Filter).",
f"- Запись: `pgbench -c {args.clients} -j {args.clients} -T {args.write_seconds}`, "
"одна вставка на транзакцию в чат large, `created_at` с точностью до секунды как в "
f"приложении. {args.write_rounds} раунда с циклическим сдвигом порядка вариантов; "
"перед прогоном `DELETE` тестовых строк, `VACUUM`, `CHECKPOINT` (чтобы full-page writes "
"были в равных условиях); autovacuum на `messages` выключен на время бенча. "
"WAL = `pg_wal_lsn_diff` за прогон / число транзакций.", "",
"## Результаты: чтение", "",
"Время в ms (медиана) / buffers / rows_read.", "",
"| Чат | Запрос | none | C | A |", "|---|---|---|---|---|"]
for label in CHAT_ORDER:
for q in QUERIES:
cells = []
for v, _ in READ_VARIANTS:
r = R[(label, q, v)]
cells.append(f"{fmt_ms(r['ms'])} / {r['buffers']} / {r['rows_read']}")
md.append(f"| {label} | {q} {QUERY_TITLE[q]} | " + " | ".join(cells) + " |")
md += ["", "Узлы планов:", "", "| Чат | Запрос | Вариант | План |", "|---|---|---|---|"]
for label in CHAT_ORDER:
for q in QUERIES:
for v, _ in READ_VARIANTS:
md.append(f"| {label} | {q} | {v} | `{R[(label, q, v)]['plan']}` |")
if W:
md += ["", "## Результаты: запись", "",
"| Вариант | TPS медиана (min–max) | latency avg, ms | WAL, B/вставку | Прогоны TPS |",
"|---|---|---|---|---|"]
for v, _ in WRITE_VARIANTS:
tps = [r["tps"] for r in W[v]]
md.append(
f"| {v} | {median(tps):.0f} ({min(tps):.0f}–{max(tps):.0f}) | "
f"{median([r['lat'] for r in W[v]]):.3f} | "
f"{median([r['wal_per_tx'] for r in W[v]]):.0f} | "
f"{', '.join(f'{t:.0f}' for t in tps)} |")
md += ["", "Размеры индексов:", "", "| Индекс | Ключ | Размер |", "|---|---|---|"]
pkey = int(db.scalar("SELECT pg_relation_size('messages_pkey');"))
md.append(f"| messages_pkey | (id) | {pkey / 1048576:.1f} MiB |")
for key in ("C", "A"):
if key in sizes:
md.append(f"| {INDEXES[key][0]} | {INDEXES[key][1]} | {sizes[key] / 1048576:.1f} MiB |")
md += ["", "## Выводы", ""]
for c in conclusions(chats, R, W, sizes):
md += [c, ""]
md += ["## Ограничения", "",
"- Один хост, тёплый кэш (данные помещаются в shared_buffers/page cache): "
"время отражает CPU и число буферов, а не холодное чтение с диска.",
"- Литералы в запросах вместо параметров: приложение через libpqxx может получить "
"generic plan; для этих запросов выбор индекса одинаков, но это не проверялось.",
"- Данные синтетические, один отправитель, короткие тексты; распределение времени "
"внутри чата равномерное в окне.",
"- pgbench мерит БД без HTTP и Argon2; TPS ограничен fsync при COMMIT на локальном "
"диске, поэтому разница по TPS меньше разницы по WAL.",
"",
"## Ключевые планы (EXPLAIN ANALYZE, BUFFERS)", ""]
for (label, q, v), text in plans.items():
md += [f"### {label} {q} — {v}", "", "```", text, "```", ""]
return "\n".join(md)
def main():
p = argparse.ArgumentParser(description=__doc__.split("\n")[0])
p.add_argument("--read-reps", type=int, default=7)
p.add_argument("--write-seconds", type=int, default=15)
p.add_argument("--write-rounds", type=int, default=3)
p.add_argument("--clients", type=int, default=4)
p.add_argument("--skip-write", action="store_true")
args = p.parse_args()
chats = pick_chats(db)
env, dataset = environment_lines(db), dataset_lines(db)
print("\n".join(env + dataset))
for label, (_, title, n) in chats:
print(f" {label}: {title} ({n})")
try:
R, plans, sizes = read_phase(chats, args.read_reps)
W = None
if not args.skip_write:
large_id = dict(chats)["large"][0]
W = write_phase(large_id, args.write_seconds, args.write_rounds, args.clients)
finally:
set_indexes(["A"])
print("\nиндексы возвращены к состоянию миграций: messages_pkey + messages_chat_keyset_idx")
write_evidence("track2_indexes.md", render(chats, R, plans, W, sizes, args, env, dataset))
if __name__ == "__main__":
main()
+341
View File
@@ -0,0 +1,341 @@
#!/usr/bin/env python3
"""Track 2, часть 2: backup → восстановление в новое хранилище → сверка.
1. В служебный чат track2-rpo пишутся K сообщений «до backup».
2. Снимается отпечаток исходной БД (счётчики, md5 таблиц, страницы чатов).
3. pg_dump -Fc из сервиса db в backups/ (каталог в .gitignore).
4. В исходную БД пишутся N сообщений «после backup» — их не должно быть
в восстановленной копии (граница потери данных логического backup).
5. Новый контейнер postgres:16-alpine с новым пустым volume, pg_restore
по секциям pre-data / data / post-data с замером каждой.
6. Сверка отпечатков, страниц, RPO-маркеров и плана запроса на копии.
7. Контейнер и volume копии удаляются (если не указан --keep).
Результат: evidence/track2_restore.md.
python3 scripts/track2_restore.py
python3 scripts/track2_restore.py --jobs 4 --keep
"""
import argparse
import secrets
import subprocess
import time
from pathlib import Path
from track2_common import (ENV, MESSAGE_COLS, PERF_USER_ID, ROOT, Pg,
dataset_lines, environment_lines, pick_chats,
write_evidence)
IMAGE = "postgres:16-alpine"
RPO_CHAT_TITLE = "track2-rpo"
PAGE = 50
src = Pg.compose()
FINGERPRINT_SQL = """
SELECT 'count.users', count(*)::text FROM users
UNION ALL SELECT 'count.chats', count(*)::text FROM chats
UNION ALL SELECT 'count.chat_members', count(*)::text FROM chat_members
UNION ALL SELECT 'count.messages', count(*)::text FROM messages
UNION ALL SELECT 'count.sessions', count(*)::text FROM sessions
UNION ALL SELECT 'schema_migrations', string_agg(version::text, ',' ORDER BY version) FROM schema_migrations
UNION ALL SELECT 'md5.users', md5(coalesce(string_agg(
id::text || '|' || username || '|' || display_name || '|' || password_hash || '|' ||
extract(epoch FROM created_at)::text, E'\\n' ORDER BY id), '')) FROM users
UNION ALL SELECT 'md5.chats', md5(coalesce(string_agg(
id::text || '|' || title || '|' || extract(epoch FROM created_at)::text,
E'\\n' ORDER BY id), '')) FROM chats
UNION ALL SELECT 'md5.chat_members', md5(coalesce(string_agg(
chat_id::text || '|' || user_id::text, E'\\n' ORDER BY chat_id, user_id), '')) FROM chat_members
UNION ALL SELECT 'md5.messages', md5(coalesce(string_agg(
id::text || '|' || chat_id::text || '|' || sender_id::text || '|' || text || '|' ||
extract(epoch FROM created_at)::text, E'\\n' ORDER BY id), '')) FROM messages
UNION ALL SELECT 'md5.sessions', md5(coalesce(string_agg(
token || '|' || user_id::text || '|' || extract(epoch FROM expires_at)::text,
E'\\n' ORDER BY token), '')) FROM sessions
UNION ALL SELECT 'md5.messages_per_chat', md5(coalesce(string_agg(
chat_id::text || ':' || n::text, ',' ORDER BY chat_id), ''))
FROM (SELECT chat_id, count(*) AS n FROM messages GROUP BY chat_id) s;
"""
def fingerprint(db):
return {k: v for k, v in db.rows(FINGERPRINT_SQL)}
def page_queries(chats):
"""Страницы теми же запросами, что у приложения: первая, keyset из середины, последняя."""
qs = {}
for label, (cid, _, n) in chats:
ts, mid = src.rows(f"""
SELECT created_at::text, id FROM messages WHERE chat_id = '{cid}'
ORDER BY created_at, id OFFSET {n // 2} LIMIT 1;
""")[0]
base = f"SELECT {MESSAGE_COLS} FROM messages WHERE chat_id = '{cid}'"
qs[f"{label}.first"] = f"{base} ORDER BY created_at ASC, id ASC LIMIT {PAGE}"
qs[f"{label}.middle"] = (f"{base} AND (created_at, id) > ('{ts}'::timestamptz, '{mid}'::uuid) "
f"ORDER BY created_at ASC, id ASC LIMIT {PAGE}")
qs[f"{label}.last"] = (f"SELECT * FROM ({base} ORDER BY created_at DESC, id DESC "
f"LIMIT {PAGE}) t ORDER BY created_at_epoch, id")
return qs
def fetch_pages(db, qs):
return {k: db.rows(q + ";") for k, q in qs.items()}
def ensure_rpo_chat():
cid = src.scalar(f"SELECT id FROM chats WHERE title = '{RPO_CHAT_TITLE}' LIMIT 1;")
if cid:
return cid
return src.scalar(f"""
WITH c AS (
INSERT INTO chats (id, title, created_at)
VALUES (gen_random_uuid(), '{RPO_CHAT_TITLE}', now()) RETURNING id
), m AS (
INSERT INTO chat_members (chat_id, user_id) SELECT id, '{PERF_USER_ID}' FROM c
)
SELECT id FROM c;
""")
def insert_marker(cid, tag, n):
src.psql(f"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), '{cid}', '{PERF_USER_ID}', '{tag}-' || g,
date_trunc('second', clock_timestamp())
FROM generate_series(1, {n}) AS g;
""")
def count_marker(db, tag):
return int(db.scalar(f"SELECT count(*) FROM messages WHERE text LIKE '{tag}-%';"))
def sh(cmd, **kw):
return subprocess.run(cmd, check=True, capture_output=True, text=True, cwd=ROOT, **kw)
def timed(fn):
t0 = time.perf_counter()
result = fn()
return result, time.perf_counter() - t0
def start_restore_storage(name, volume):
sh(["docker", "volume", "create", volume])
sh(["docker", "run", "-d", "--name", name,
"-e", f"POSTGRES_USER={ENV['POSTGRES_USER']}",
"-e", f"POSTGRES_PASSWORD={secrets.token_hex(16)}",
"-e", f"POSTGRES_DB={ENV['POSTGRES_DB']}",
"-v", f"{volume}:/var/lib/postgresql/data", IMAGE])
# Во время initdb сервер слушает только unix-socket; TCP-готовность
# означает, что поднят окончательный сервер.
for _ in range(120):
r = subprocess.run(["docker", "exec", name, "pg_isready", "-h", "127.0.0.1",
"-U", ENV["POSTGRES_USER"], "-d", ENV["POSTGRES_DB"]],
capture_output=True)
if r.returncode == 0:
return
time.sleep(0.25)
raise SystemExit("восстановительный PostgreSQL не поднялся за 30 с")
def main():
p = argparse.ArgumentParser(description=__doc__.split("\n")[0])
p.add_argument("--before", type=int, default=100, help="маркеров до backup")
p.add_argument("--after", type=int, default=37, help="маркеров после backup")
p.add_argument("--jobs", type=int, default=1, help="pg_restore -j для data/post-data")
p.add_argument("--keep", action="store_true", help="не удалять контейнер и volume копии")
args = p.parse_args()
run_id = time.strftime("%Y%m%d%H%M%S")
tag_before, tag_after = f"track2-rpo-before-{run_id}", f"track2-rpo-after-{run_id}"
name, volume = f"track2-restore-{run_id}", f"track2_restore_{run_id}"
backups = ROOT / "backups"
backups.mkdir(exist_ok=True)
dump_path = backups / f"track2_{run_id}.dump"
chats = pick_chats(src)
rpo_chat = ensure_rpo_chat()
insert_marker(rpo_chat, tag_before, args.before)
env, dataset = environment_lines(src), dataset_lines(src)
print("\n".join(env + dataset))
print(f"\n[1] записано {args.before} сообщений до backup")
qs = page_queries(chats)
fp_src = fingerprint(src)
pages_src = fetch_pages(src, qs)
db_size = int(src.scalar(f"SELECT pg_database_size('{ENV['POSTGRES_DB']}');"))
print(f"[2] отпечаток исходной БД: {fp_src['count.messages']} сообщений")
with open(dump_path, "wb") as f:
_, t_dump = timed(lambda: src.run(
["pg_dump", "-U", ENV["POSTGRES_USER"], "-d", ENV["POSTGRES_DB"], "-Fc"],
binary=True, stdout=f))
dump_size = dump_path.stat().st_size
print(f"[3] pg_dump: {t_dump:.2f} s, {dump_size / 1048576:.1f} MiB → {dump_path.relative_to(ROOT)}")
insert_marker(rpo_chat, tag_after, args.after)
print(f"[4] записано {args.after} сообщений после backup")
dst = Pg.container(name)
timings = {}
try:
_, timings["storage"] = timed(lambda: start_restore_storage(name, volume))
print(f"[5] новое хранилище {name} (volume {volume}): {timings['storage']:.2f} s")
_, timings["copy"] = timed(lambda: sh(["docker", "cp", str(dump_path), f"{name}:/tmp/db.dump"]))
for section in ("pre-data", "data", "post-data"):
cmd = ["pg_restore", "-U", ENV["POSTGRES_USER"], "-d", ENV["POSTGRES_DB"],
"--no-owner", "--exit-on-error", f"--section={section}"]
if section != "pre-data" and args.jobs > 1:
cmd += ["-j", str(args.jobs)]
_, timings[section] = timed(lambda: dst.run(cmd + ["/tmp/db.dump"]))
print(f" pg_restore --section={section}: {timings[section]:.2f} s")
dst.psql("ANALYZE;")
fp_dst, t_verify = timed(lambda: fingerprint(dst))
pages_dst = fetch_pages(dst, qs)
fp_src_now = fingerprint(src)
rpo = {
"before_dst": count_marker(dst, tag_before),
"after_dst": count_marker(dst, tag_after),
"after_src": count_marker(src, tag_after),
}
plan_dst = dst.psql(f"EXPLAIN (ANALYZE, BUFFERS) {qs['large.middle']};", tuples=False).strip()
indexes_dst = dst.scalar(
"SELECT string_agg(indexname, ', ' ORDER BY indexname) FROM pg_indexes "
"WHERE schemaname = 'public';")
version_dst = dst.scalar("SHOW server_version;")
sample = pages_src["large.middle"][:3]
finally:
if args.keep:
print(f"\nкопия оставлена: docker exec -it {name} psql -U {ENV['POSTGRES_USER']} {ENV['POSTGRES_DB']}")
else:
subprocess.run(["docker", "rm", "-f", name], capture_output=True)
subprocess.run(["docker", "volume", "rm", volume], capture_output=True)
print(f"\nконтейнер {name} и volume {volume} удалены")
# ---------- сверка ----------
checks = []
for key in sorted(fp_src):
checks.append((key, fp_src[key], fp_dst.get(key), fp_src[key] == fp_dst.get(key)))
pages_ok = {k: pages_src[k] == pages_dst[k] for k in qs}
rpo_ok = (rpo["before_dst"] == args.before and rpo["after_dst"] == 0
and rpo["after_src"] == args.after)
plan_ok = "messages_chat_keyset_idx" in plan_dst
diverged = sorted(k for k in fp_src_now if fp_src_now[k] != fp_dst.get(k))
all_ok = all(c[3] for c in checks) and all(pages_ok.values()) and rpo_ok and plan_ok
print("\nPASS: копия совпадает со снимком" if all_ok else "\nFAIL: есть расхождения")
rto = timings["storage"] + timings["copy"] + timings["pre-data"] + timings["data"] + timings["post-data"]
restore_only = timings["pre-data"] + timings["data"] + timings["post-data"]
post_share = timings["post-data"] / restore_only * 100
throughput = db_size / 1048576 / restore_only
md = ["# Track 2. Backup → восстановление в новое хранилище → сверка", "",
f"Сгенерировано `python3 scripts/track2_restore.py --before {args.before} "
f"--after {args.after} --jobs {args.jobs}`. Итог: **{'PASS' if all_ok else 'FAIL'}**.", "",
"## Окружение и данные", "", *env, *dataset,
f"- Размер БД `pg_database_size`: {db_size / 1048576:.1f} MiB; "
f"восстановлено в PostgreSQL {version_dst} (`{IMAGE}`, новый пустой volume)", "",
"## Гипотезы", "",
"- **H4.** Логический backup (`pg_dump -Fc`) восстанавливается в пустое хранилище без "
"потерь: совпадают счётчики, содержимое всех таблиц и страницы истории.",
"- **H5.** Время восстановления заметно определяется построением индексов и "
"ограничений (секция post-data), а не только загрузкой строк.",
"- **H6.** Граница потери данных (RPO) логического backup — момент его снимка: всё, что "
"подтверждено COMMIT после начала `pg_dump`, в копии отсутствует.", "",
"## Методика", "",
f"1. В служебный чат `{RPO_CHAT_TITLE}` записано {args.before} сообщений с меткой «до».",
"2. Снят отпечаток исходной БД: `count(*)` и md5 упорядоченного содержимого каждой "
"таблицы, md5 числа сообщений по чатам, страницы истории (первая, keyset из середины, "
"последняя) для чатов small/medium/large/burst — теми же запросами, что у приложения.",
"3. `pg_dump -Fc` из работающего сервиса `db` в `backups/` (не в Git).",
f"4. В исходную БД записано {args.after} сообщений с меткой «после».",
"5. `docker volume create` + `docker run postgres:16-alpine`: новое хранилище; "
"`pg_restore --section=pre-data|data|post-data` с замером каждой секции.",
"6. Сверка отпечатков, страниц, маркеров и плана запроса на копии; копия удаляется.", "",
"## Время", "",
"| Этап | Время, s |", "|---|---|",
f"| pg_dump (backup) | {t_dump:.2f} |",
f"| Запуск нового хранилища (initdb + старт) | {timings['storage']:.2f} |",
f"| Копирование дампа в контейнер | {timings['copy']:.2f} |",
f"| pg_restore pre-data (схема) | {timings['pre-data']:.2f} |",
f"| pg_restore data (COPY строк) | {timings['data']:.2f} |",
f"| pg_restore post-data (PK, FK, индексы) | {timings['post-data']:.2f} |",
f"| **RTO: от пустого хоста до готовой БД** | **{rto:.2f}** |",
f"| Сверка отпечатков (вне RTO) | {t_verify:.2f} |", "",
f"Размер дампа: {dump_size / 1048576:.1f} MiB (сжатие custom-формата, "
f"{db_size / max(dump_size, 1):.1f}× меньше БД).", "",
"## Сверка", "",
"| Проверка | Исходная (снимок) | Копия | Совпадает |", "|---|---|---|---|"]
for key, a, b, ok in checks:
short = (lambda v: v if v is None or len(v) <= 20 else v[:12] + "…")
md.append(f"| {key} | `{short(a)}` | `{short(b)}` | {'да' if ok else '**НЕТ**'} |")
for key, ok in pages_ok.items():
md.append(f"| страница {key} ({len(pages_src[key])} строк) | — | — | {'да' if ok else '**НЕТ**'} |")
md += [f"| план Q2 на копии использует messages_chat_keyset_idx | — | — | {'да' if plan_ok else '**НЕТ**'} |",
"", "Пример выбранных сообщений (large, keyset из середины), одинаковы в обеих БД:", "",
"| id | chat_id | created_at (epoch) | text |", "|---|---|---|---|"]
for row in sample:
md.append(f"| `{row[0]}` | `{row[1][:8]}…` | {row[4]} | {row[3]} |")
md += ["", "Индексы на копии: " + indexes_dst, "",
"## Граница потери данных", "",
"| Маркер | В исходной БД | В копии | Ожидание |", "|---|---|---|---|",
f"| до backup | {args.before} | {rpo['before_dst']} | все есть |",
f"| после backup | {rpo['after_src']} | {rpo['after_dst']} | нет ни одного |", "",
"После записи маркеров «после» исходная БД разошлась с копией по: "
+ (", ".join(f"`{k}`" for k in diverged) or "—") + ".", "",
"## Выводы", "",
f"**H4 — {'подтверждена' if all(c[3] for c in checks) and all(pages_ok.values()) else 'НЕ подтверждена'}.** "
f"Все {len(checks)} отпечатков (счётчики и md5 содержимого users, chats, chat_members, "
f"messages, sessions, schema_migrations, распределение по чатам) и {len(pages_ok)} страниц "
f"истории совпали. На копии восстановлены индексы, и тот же keyset-запрос идёт через "
f"`messages_chat_keyset_idx`. Таблица `schema_migrations` восстановлена, поэтому API, "
f"направленный на копию, не будет повторно применять миграции.", "",
f"**H5 — {'подтверждена' if post_share >= 25 else 'частично'}.** "
f"post-data заняла {timings['post-data']:.2f} s из {restore_only:.2f} s pg_restore "
f"({post_share:.0f}%): PK и вторичные индексы строятся заново после загрузки строк. "
f"Полный RTO {rto:.1f} s, из них {timings['storage']:.1f} s — запуск пустого PostgreSQL. "
f"Скорость восстановления ≈ {throughput:.0f} MiB/s БД; при линейной экстраполяции "
f"10× данных ≈ {restore_only * 10:.0f} s только на pg_restore (оценка: построение "
f"индексов растёт как n·log n, а при данных больше RAM появится дисковый I/O). "
f"Ускорение — `pg_restore -j N` для data/post-data или физический backup "
f"(`pg_basebackup`), который не перестраивает индексы.", "",
f"**H6 — {'подтверждена' if rpo_ok else 'НЕ подтверждена'}.** "
f"Все {args.before} сообщений до backup есть в копии, ни одного из {args.after} после — нет, "
f"хотя они подтверждены COMMIT в исходной БД. `pg_dump` читает один согласованный снимок "
f"(REPEATABLE READ) на момент старта, поэтому RPO = время с начала последнего backup. "
f"При backup раз в сутки можно потерять до суток сообщений; чтобы уменьшить RPO до секунд, "
f"нужен непрерывный архив WAL (`archive_mode` + pgBackRest/wal-g) и PITR "
f"или потоковая реплика.", "",
"**Сессии.** "
+ ("Сессии хранятся в Valkey (`SESSION_STORE=redis`) и в дамп PostgreSQL не входят. "
"Если Valkey цел, старые токены работают и с восстановленной БД: `user_id` сохранились. "
"Если потерян и Valkey, пользователи логинятся заново; при AOF `appendfsync everysec` "
"можно потерять до ~1 s новых сессий. Таблица `sessions` в PostgreSQL (резервный "
"режим `SESSION_STORE=postgres`) восстанавливается вместе с дампом."
if ENV.get("SESSION_STORE", "redis") == "redis" else
"Сессии хранятся в PostgreSQL и восстанавливаются вместе с дампом; сессии, созданные "
"после backup, теряются, а logout после backup «воскрешает» отозванный токен до его expiry."),
"",
"**COMMIT и durability.** При `synchronous_commit=on` подтверждённая транзакция уже "
"записана в WAL на диск и переживает рестарт контейнера, но не потерю volume/диска: "
"от этого защищает только копия на другом носителе. Здесь дамп лежит на том же хосте, "
"поэтому эксперимент доказывает процедуру восстановления, а не защиту от потери хоста.", "",
"## Ограничения", "",
"- Один хост, тёплый page cache; дамп и копия на том же диске.",
"- Во время backup не было внешней нагрузки; при нагрузке pg_dump длится дольше, но "
"снимок остаётся согласованным.",
"- RTO не включает переключение API на новую БД (смена секрета `database_url` и рестарт api).",
"- Сверка md5 упорядоченного содержимого требует чтения всех таблиц; на больших объёмах "
"её заменяют выборочной сверкой и счётчиками.",
"", "## План keyset-запроса на восстановленной копии", "", "```", plan_dst, "```", ""]
write_evidence("track2_restore.md", "\n".join(md))
if not all_ok:
raise SystemExit(1)
if __name__ == "__main__":
main()
+39
View File
@@ -0,0 +1,39 @@
#include "auth.hpp"
#include <sodium.h>
#include <stdexcept>
namespace {
struct SodiumInit {
SodiumInit() {
if (sodium_init() < 0) {
throw std::runtime_error("sodium_init failed");
}
}
};
const SodiumInit g_sodium_init;
}
std::string hash_password(const std::string& plain) {
char hashed[crypto_pwhash_STRBYTES];
if (crypto_pwhash_str(
hashed,
plain.data(), plain.size(),
crypto_pwhash_OPSLIMIT_INTERACTIVE,
crypto_pwhash_MEMLIMIT_INTERACTIVE) != 0) {
throw std::runtime_error("crypto_pwhash_str failed (out of memory?)");
}
return std::string(hashed);
}
bool verify_password(const std::string& plain, const std::string& hash) {
if (hash.empty() || hash.size() >= crypto_pwhash_STRBYTES) {
return false;
}
return crypto_pwhash_str_verify(
hash.c_str(),
plain.data(), plain.size()) == 0;
}
+7
View File
@@ -0,0 +1,7 @@
#pragma once
#include <string>
std::string hash_password(const std::string& plain);
bool verify_password(const std::string& plain, const std::string& hash);
+186
View File
@@ -0,0 +1,186 @@
#include "chat_repo.hpp"
#include "cursor.hpp"
#include <pqxx/pqxx>
#include <chrono>
#include <ctime>
#include <iomanip>
#include <random>
#include <sstream>
#include <string>
namespace {
std::string make_uuid() {
static std::mt19937_64 rng{std::random_device{}()};
std::uniform_int_distribution<uint32_t> d16(0, 0xffff);
std::uniform_int_distribution<uint32_t> d32(0, 0xffffffffu);
std::ostringstream out;
out << std::hex << std::setfill('0');
out << std::setw(8) << d32(rng);
out << '-' << std::setw(4) << d16(rng);
out << '-' << std::setw(4) << ((d16(rng) & 0x0fff) | 0x4000);
out << '-' << std::setw(4) << ((d16(rng) & 0x3fff) | 0x8000);
out << '-' << std::setw(4) << d16(rng) << std::setw(8) << d32(rng);
return out.str();
}
std::string epoch_to_rfc3339(long long epoch) {
const std::time_t t = static_cast<std::time_t>(epoch);
std::tm tm{};
gmtime_r(&t, &tm);
std::ostringstream out;
out << std::put_time(&tm, "%Y-%m-%dT%H:%M:%SZ");
return out.str();
}
std::string now_epoch_str() {
const auto now = std::chrono::system_clock::now();
const auto secs = std::chrono::duration_cast<std::chrono::seconds>(
now.time_since_epoch()).count();
return std::to_string(secs);
}
Chat row_to_chat(const pqxx::row& r) {
Chat c;
c.id = r["id"].as<std::string>();
c.title = r["title"].as<std::string>();
c.created_at = epoch_to_rfc3339(r["created_at_epoch"].as<long long>());
return c;
}
std::vector<std::string> load_member_ids(pqxx::work& tx,
const std::string& chat_id) {
std::vector<std::string> ids;
auto r = tx.exec(
"SELECT user_id FROM chat_members WHERE chat_id = $1 ORDER BY user_id",
pqxx::params{chat_id});
ids.reserve(r.size());
for (const auto& row : r) {
ids.push_back(row["user_id"].as<std::string>());
}
return ids;
}
constexpr const char* kChatSelect =
"id, title, "
"EXTRACT(EPOCH FROM created_at)::bigint AS created_at_epoch";
}
std::optional<Chat> ChatRepo::create(const std::string& title,
const std::vector<std::string>& member_ids) {
auto lease = pool_.acquire();
pqxx::work tx(*lease);
const std::string chat_id = make_uuid();
const std::string created = now_epoch_str();
try {
tx.exec(
"INSERT INTO chats (id, title, created_at) "
"VALUES ($1, $2, to_timestamp($3::bigint))",
pqxx::params{chat_id, title, created});
for (const auto& uid : member_ids) {
tx.exec(
"INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)",
pqxx::params{chat_id, uid});
}
} catch (const pqxx::foreign_key_violation&) {
tx.abort();
return std::nullopt;
} catch (const pqxx::unique_violation&) {
tx.abort();
return std::nullopt;
}
auto r = tx.exec(
"SELECT " + std::string(kChatSelect) + " FROM chats WHERE id = $1",
pqxx::params{chat_id});
Chat c = row_to_chat(r[0]);
c.member_ids = load_member_ids(tx, chat_id);
tx.commit();
return c;
}
std::optional<Chat> ChatRepo::find_by_id(const std::string& id) {
auto lease = pool_.acquire();
pqxx::work tx(*lease);
auto r = tx.exec(
"SELECT " + std::string(kChatSelect) + " FROM chats WHERE id = $1",
pqxx::params{id});
if (r.empty()) {
tx.commit();
return std::nullopt;
}
Chat c = row_to_chat(r[0]);
c.member_ids = load_member_ids(tx, id);
tx.commit();
return c;
}
std::optional<ChatPage> ChatRepo::list_for_user(
const std::string& user_id,
int limit,
const std::optional<std::string>& cursor) {
std::optional<Cursor> cur;
if (cursor) {
cur = parse_cursor(*cursor);
if (!cur) {
return std::nullopt;
}
}
auto lease = pool_.acquire();
pqxx::work tx(*lease);
if (cur) {
auto owner_check = tx.exec(
"SELECT 1 FROM chats WHERE id = $1 AND id IN "
"(SELECT chat_id FROM chat_members WHERE user_id = $2)",
pqxx::params{cur->id, user_id});
if (owner_check.empty()) {
tx.commit();
return std::nullopt;
}
}
std::string sql =
"SELECT " + std::string(kChatSelect) + ", " + kCreatedUsSql + " "
"FROM chats "
"WHERE id IN (SELECT chat_id FROM chat_members WHERE user_id = $1) ";
if (cur) {
sql += "AND (created_at, id) > (" + std::string(kCursorTimestampSql) + ", $4::uuid) ";
}
sql += "ORDER BY created_at ASC, id ASC LIMIT $2";
pqxx::result r;
if (cur) {
r = tx.exec(sql, pqxx::params{user_id, limit + 1, cur->created_us, cur->id});
} else {
r = tx.exec(sql, pqxx::params{user_id, limit + 1});
}
ChatPage page;
const bool has_more = (static_cast<int>(r.size()) > limit);
const int take = has_more ? limit : static_cast<int>(r.size());
page.items.reserve(take);
for (int i = 0; i < take; ++i) {
Chat c = row_to_chat(r[static_cast<std::size_t>(i)]);
c.member_ids = load_member_ids(tx, c.id);
page.items.push_back(std::move(c));
}
if (has_more && take > 0) {
const auto& last = r[static_cast<std::size_t>(take - 1)];
page.next_cursor = make_cursor(last["created_us"].as<std::string>(),
last["id"].as<std::string>());
}
tx.commit();
return page;
}
+23
View File
@@ -0,0 +1,23 @@
#pragma once
#include "db.hpp"
#include "models.hpp"
#include <optional>
#include <string>
#include <vector>
class ChatRepo {
public:
explicit ChatRepo(PgPool& pool) : pool_(pool) {}
std::optional<Chat> create(const std::string& title,
const std::vector<std::string>& member_ids);
std::optional<Chat> find_by_id(const std::string& id);
std::optional<ChatPage> list_for_user(const std::string& user_id, int limit, const std::optional<std::string>& cursor);
private:
PgPool& pool_;
};
+47
View File
@@ -0,0 +1,47 @@
#pragma once
#include <algorithm>
#include <cctype>
#include <optional>
#include <regex>
#include <string>
// Непрозрачный для клиента курсор keyset-пагинации: "<created_at в мкс от epoch>|<uuid>".
// Микросекунды сохраняют точный created_at строки, даже если в JSON время округлено до секунд.
struct Cursor {
std::string created_us;
std::string id;
};
// Выражение SQL, восстанавливающее timestamptz из created_us без потери точности.
constexpr const char* kCursorTimestampSql =
"(timestamptz 'epoch' + $3::bigint * interval '1 microsecond')";
constexpr const char* kCreatedUsSql =
"(EXTRACT(EPOCH FROM created_at) * 1000000)::bigint AS created_us";
inline bool is_uuid(const std::string& s) {
static const std::regex re(
"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-"
"[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$");
return std::regex_match(s, re);
}
inline std::optional<Cursor> parse_cursor(const std::string& raw) {
const auto bar = raw.find('|');
if (bar == std::string::npos) {
return std::nullopt;
}
Cursor c{raw.substr(0, bar), raw.substr(bar + 1)};
const bool digits = !c.created_us.empty() && c.created_us.size() <= 18 &&
std::all_of(c.created_us.begin(), c.created_us.end(),
[](unsigned char ch) { return std::isdigit(ch); });
if (!digits || !is_uuid(c.id)) {
return std::nullopt;
}
return c;
}
inline std::string make_cursor(const std::string& created_us, const std::string& id) {
return created_us + "|" + id;
}
+339
View File
@@ -0,0 +1,339 @@
#include "db.hpp"
#include "errors.hpp"
#include <chrono>
#include <fstream>
#include <future>
#include <thread>
#include <sys/socket.h>
#include <sys/time.h>
#include <stdexcept>
#include <algorithm>
#include <filesystem>
#include <vector>
#include <set>
#include <iostream>
#include <nlohmann/json.hpp>
namespace fs = std::filesystem;
namespace {
constexpr int kConnectTimeoutSeconds = 2;
constexpr int kTcpUserTimeoutMs = 5000;
constexpr int kStatementTimeoutMs = 5000;
constexpr int kClientIoTimeoutSeconds = 5;
constexpr auto kAcquireTimeout = std::chrono::seconds(3);
std::string add_conn_param(std::string conninfo, const std::string& key,
const std::string& value) {
if (conninfo.find(key + "=") != std::string::npos) {
return conninfo;
}
const bool is_url = conninfo.rfind("postgres://", 0) == 0 ||
conninfo.rfind("postgresql://", 0) == 0;
if (is_url) {
conninfo += (conninfo.find('?') == std::string::npos ? "?" : "&");
} else {
conninfo += " ";
}
return conninfo + key + "=" + value;
}
bool is_alive(pqxx::connection* conn) {
std::promise<void> done;
auto fut = done.get_future();
std::thread th([conn, &done]() {
try {
pqxx::nontransaction tx(*conn);
tx.exec("SELECT 1");
done.set_value();
} catch (...) {
done.set_exception(std::current_exception());
}
});
if (fut.wait_for(std::chrono::seconds(kClientIoTimeoutSeconds)) !=
std::future_status::ready) {
const int fd = conn->sock();
if (fd >= 0) {
::shutdown(fd, SHUT_RDWR);
}
th.join();
return false;
}
th.join();
try {
fut.get();
return true;
} catch (...) {
return false;
}
}
struct Migration {
int version;
std::string path;
};
Migration parse_migration_name(const fs::path& p) {
const std::string name = p.filename().string();
const auto dot = name.find('.');
if (dot == std::string::npos || name.substr(dot) != ".sql") {
throw std::runtime_error("migration file must end with .sql: " + name);
}
const auto us = name.find('_');
if (us == std::string::npos || us == 0) {
throw std::runtime_error(
"migration file must be named NNN_name.sql: " + name);
}
const std::string num = name.substr(0, us);
if (!std::all_of(num.begin(), num.end(),
[](unsigned char c){ return std::isdigit(c); })) {
throw std::runtime_error(
"migration file prefix must be digits: " + name);
}
Migration m;
m.version = std::stoi(num);
m.path = p.string();
return m;
}}
void apply_migrations(pqxx::connection& conn, const std::string& dir) {
{
pqxx::work tx(conn);
tx.exec(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
" version int PRIMARY KEY,"
" applied_at timestamptz NOT NULL DEFAULT now()"
")");
tx.commit();
}
if (!fs::exists(dir) || !fs::is_directory(dir)) {
throw std::runtime_error("migrations dir not found: " + dir);
}
std::vector<Migration> files;
for (const auto& entry : fs::directory_iterator(dir)) {
if (entry.is_regular_file()) {
files.push_back(parse_migration_name(entry.path()));
}
}
std::sort(files.begin(), files.end(),
[](const Migration& a, const Migration& b){
return a.version < b.version;
});
for (std::size_t i = 1; i < files.size(); ++i) {
if (files[i].version == files[i-1].version) {
throw std::runtime_error(
"duplicate migration version: " + std::to_string(files[i].version));
}
}
std::set<int> applied;
{
pqxx::work tx(conn);
for (const auto& row : tx.exec("SELECT version FROM schema_migrations")) {
applied.insert(row[0].as<int>());
}
tx.commit();
}
for (const auto& m : files) {
if (applied.count(m.version)) {
continue;
}
std::ifstream f(m.path, std::ios::binary);
if (!f) {
throw std::runtime_error("cannot open migration: " + m.path);
}
std::stringstream buf;
buf << f.rdbuf();
const std::string sql = buf.str();
pqxx::work tx(conn);
tx.exec(sql);
tx.exec("INSERT INTO schema_migrations(version) VALUES ($1)",
m.version);
tx.commit();
std::clog << "applied migration " << m.version
<< " (" << m.path << ")\n";
}
}
std::string read_secret_file(const char* env_name) {
const char* path = std::getenv(env_name);
if (path == nullptr || *path == '\0') {
throw std::runtime_error(
std::string("environment variable not set: ") + env_name);
}
std::ifstream f(path, std::ios::binary);
if (!f) {
throw std::runtime_error(
std::string("cannot open secret file: ") + path);
}
std::string s;
std::getline(f, s);
if (!s.empty() && s.back() == '\r') {
s.pop_back();
}
if (s.empty()) {
throw std::runtime_error(
std::string("secret file is empty: ") + path);
}
return s;
}
bool is_dependency_failure(const std::exception& e) {
if (dynamic_cast<const DependencyUnavailable*>(&e) != nullptr ||
dynamic_cast<const pqxx::broken_connection*>(&e) != nullptr ||
dynamic_cast<const pqxx::in_doubt_error*>(&e) != nullptr) {
return true;
}
if (const auto* sql = dynamic_cast<const pqxx::sql_error*>(&e)) {
// 08xxx — ошибки соединения, 57xxx — отмена (statement_timeout) и остановка сервера.
const std::string& state = sql->sqlstate();
return state.rfind("08", 0) == 0 || state.rfind("57", 0) == 0;
}
return false;
}
std::unique_ptr<pqxx::connection> open_pg_connection(const std::string& conninfo,
bool statement_timeout) {
std::string full = add_conn_param(conninfo, "connect_timeout",
std::to_string(kConnectTimeoutSeconds));
full = add_conn_param(full, "tcp_user_timeout", std::to_string(kTcpUserTimeoutMs));
auto conn = std::make_unique<pqxx::connection>(full);
const int fd = conn->sock();
if (fd >= 0) {
timeval tv{};
tv.tv_sec = kClientIoTimeoutSeconds;
tv.tv_usec = 0;
::setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
::setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
}
if (statement_timeout) {
pqxx::nontransaction tx(*conn);
tx.exec("SET statement_timeout = " + std::to_string(kStatementTimeoutMs));
}
return conn;
}
PgPool::PgPool(std::string conninfo, std::size_t n)
: conninfo_(std::move(conninfo)) {
if (n == 0) {
throw std::runtime_error("PgPool: n must be > 0");
}
all_.reserve(n);
idle_.reserve(n);
for (std::size_t i = 0; i < n; ++i) {
auto conn = open_pg_connection(conninfo_, true);
idle_.push_back(conn.get());
all_.push_back(std::move(conn));
}
}
PgPool::~PgPool() {
{
std::lock_guard<std::mutex> lk(mu_);
shutting_down_ = true;
}
cv_.notify_all();
}
pqxx::connection* PgPool::take() {
std::unique_lock<std::mutex> lk(mu_);
if (!cv_.wait_for(lk, kAcquireTimeout,
[&]() { return shutting_down_ || !idle_.empty(); })) {
throw DependencyUnavailable("postgres pool: acquire timeout");
}
if (shutting_down_) {
throw DependencyUnavailable("postgres pool is shutting down");
}
pqxx::connection* conn = idle_.back();
idle_.pop_back();
lk.unlock();
if (is_alive(conn)) {
return conn;
}
std::unique_ptr<pqxx::connection> fresh;
try {
fresh = open_pg_connection(conninfo_, true);
} catch (const std::exception& e) {
// Мёртвое соединение возвращается в пул: следующий take() снова
// попробует переподключиться, и пул не теряет слот.
give_back(conn);
throw DependencyUnavailable(std::string("postgres reconnect failed: ") + e.what());
}
std::lock_guard<std::mutex> lk2(mu_);
for (auto& up : all_) {
if (up.get() == conn) {
up = std::move(fresh);
return up.get();
}
}
throw std::logic_error("PgPool: connection not owned by pool");
}
void PgPool::give_back(pqxx::connection* conn) {
{
std::lock_guard<std::mutex> lk(mu_);
idle_.push_back(conn);
}
cv_.notify_one();
}
PgPool::Lease::Lease(PgPool& pool) : pool_(&pool), conn_(pool.take()) {}
PgPool::Lease::~Lease() {
if (pool_ != nullptr && conn_ != nullptr) {
pool_->give_back(conn_);
}
}
PgPool::Lease::Lease(Lease&& other) noexcept
: pool_(other.pool_), conn_(other.conn_) {
other.pool_ = nullptr;
other.conn_ = nullptr;
}
PgPool::Lease PgPool::acquire() {
return Lease(*this);
}
bool PgPool::ping() {
try {
auto lease = acquire();
pqxx::work tx(*lease);
tx.exec("SELECT 1");
tx.commit();
return true;
} catch (...) {
return false;
}
}
+64
View File
@@ -0,0 +1,64 @@
#pragma once
#include <condition_variable>
#include <pqxx/pqxx>
#include <cstddef>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
std::string read_secret_file(const char* env_name);
// connect_timeout и tcp_user_timeout добавляются к conninfo, если не заданы;
// statement_timeout — только для соединений пула (миграции могут быть долгими).
std::unique_ptr<pqxx::connection> open_pg_connection(const std::string& conninfo,
bool statement_timeout);
void apply_migrations(pqxx::connection& conn, const std::string& dir);
class PgPool {
public:
bool ping();
PgPool(std::string conninfo, std::size_t n);
~PgPool();
PgPool(const PgPool&) = delete;
PgPool& operator=(const PgPool&) = delete;
class Lease {
public:
explicit Lease(PgPool& pool);
~Lease();
Lease(Lease&& other) noexcept;
Lease& operator=(Lease&&) = delete;
Lease(const Lease&) = delete;
Lease& operator=(const Lease&) = delete;
pqxx::connection& operator*() const { return *conn_; }
pqxx::connection* operator->() const { return conn_; }
private:
PgPool* pool_;
pqxx::connection* conn_;
};
Lease acquire();
private:
friend class Lease;
pqxx::connection* take();
void give_back(pqxx::connection* conn);
std::string conninfo_;
std::vector<std::unique_ptr<pqxx::connection>> all_;
std::vector<pqxx::connection*> idle_;
std::mutex mu_;
std::condition_variable cv_;
bool shutting_down_ = false;
};
+11
View File
@@ -0,0 +1,11 @@
#pragma once
#include <exception>
#include <stdexcept>
// PostgreSQL или Valkey недоступны либо не ответили вовремя: клиент получает 503.
struct DependencyUnavailable : std::runtime_error {
using std::runtime_error::runtime_error;
};
bool is_dependency_failure(const std::exception& e);
+1320
View File
File diff suppressed because it is too large Load Diff
+146
View File
@@ -0,0 +1,146 @@
#include "message_repo.hpp"
#include "cursor.hpp"
#include <pqxx/pqxx>
#include <chrono>
#include <ctime>
#include <iomanip>
#include <random>
#include <sstream>
#include <string>
namespace {
std::string make_uuid() {
static std::mt19937_64 rng{std::random_device{}()};
std::uniform_int_distribution<uint32_t> d16(0, 0xffff);
std::uniform_int_distribution<uint32_t> d32(0, 0xffffffffu);
std::ostringstream out;
out << std::hex << std::setfill('0');
out << std::setw(8) << d32(rng);
out << '-' << std::setw(4) << d16(rng);
out << '-' << std::setw(4) << ((d16(rng) & 0x0fff) | 0x4000);
out << '-' << std::setw(4) << ((d16(rng) & 0x3fff) | 0x8000);
out << '-' << std::setw(4) << d16(rng) << std::setw(8) << d32(rng);
return out.str();
}
std::string epoch_to_rfc3339(long long epoch) {
const std::time_t t = static_cast<std::time_t>(epoch);
std::tm tm{};
gmtime_r(&t, &tm);
std::ostringstream out;
out << std::put_time(&tm, "%Y-%m-%dT%H:%M:%SZ");
return out.str();
}
std::string now_epoch_str() {
const auto now = std::chrono::system_clock::now();
const auto secs = std::chrono::duration_cast<std::chrono::seconds>(
now.time_since_epoch()).count();
return std::to_string(secs);
}
Message row_to_message(const pqxx::row& r) {
Message m;
m.id = r["id"].as<std::string>();
m.chat_id = r["chat_id"].as<std::string>();
m.sender_id = r["sender_id"].as<std::string>();
m.text = r["text"].as<std::string>();
m.created_at = epoch_to_rfc3339(r["created_at_epoch"].as<long long>());
return m;
}
constexpr const char* kMessageSelect =
"id, chat_id, sender_id, text, "
"EXTRACT(EPOCH FROM created_at)::bigint AS created_at_epoch";
}
std::optional<Message> MessageRepo::create(const std::string& chat_id,
const std::string& sender_id,
const std::string& text) {
auto lease = pool_.acquire();
pqxx::work tx(*lease);
auto member_check = tx.exec(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
pqxx::params{chat_id, sender_id});
if (member_check.empty()) {
tx.commit();
return std::nullopt;
}
const std::string id = make_uuid();
const std::string created = now_epoch_str();
auto r = tx.exec(
"INSERT INTO messages (id, chat_id, sender_id, text, created_at) "
"VALUES ($1, $2, $3, $4, to_timestamp($5::bigint)) "
"RETURNING " + std::string(kMessageSelect),
pqxx::params{id, chat_id, sender_id, text, created});
tx.commit();
return row_to_message(r[0]);
}
std::optional<MessagePage> MessageRepo::list_page(
const std::string& chat_id,
int limit,
const std::optional<std::string>& cursor) {
std::optional<Cursor> cur;
if (cursor) {
cur = parse_cursor(*cursor);
if (!cur) {
return std::nullopt;
}
}
auto lease = pool_.acquire();
pqxx::work tx(*lease);
if (cur) {
auto owner_check = tx.exec(
"SELECT 1 FROM messages WHERE id = $1 AND chat_id = $2",
pqxx::params{cur->id, chat_id});
if (owner_check.empty()) {
tx.commit();
return std::nullopt;
}
}
std::string sql =
"SELECT " + std::string(kMessageSelect) + ", " + kCreatedUsSql + " "
"FROM messages "
"WHERE chat_id = $1 ";
if (cur) {
sql += "AND (created_at, id) > (" + std::string(kCursorTimestampSql) + ", $4::uuid) ";
}
sql += "ORDER BY created_at ASC, id ASC LIMIT $2";
pqxx::result r;
if (cur) {
r = tx.exec(sql, pqxx::params{chat_id, limit + 1, cur->created_us, cur->id});
} else {
r = tx.exec(sql, pqxx::params{chat_id, limit + 1});
}
MessagePage page;
const bool has_more = (static_cast<int>(r.size()) > limit);
const int take = has_more ? limit : static_cast<int>(r.size());
page.items.reserve(take);
for (int i = 0; i < take; ++i) {
page.items.push_back(row_to_message(r[static_cast<std::size_t>(i)]));
}
if (has_more && take > 0) {
const auto& last = r[static_cast<std::size_t>(take - 1)];
page.next_cursor = make_cursor(last["created_us"].as<std::string>(),
last["id"].as<std::string>());
}
tx.commit();
return page;
}
+25
View File
@@ -0,0 +1,25 @@
#pragma once
#include "db.hpp"
#include "models.hpp"
#include <optional>
#include <string>
#include <vector>
class MessageRepo {
public:
explicit MessageRepo(PgPool& pool) : pool_(pool) {}
std::optional<Message> create(const std::string& chat_id,
const std::string& sender_id,
const std::string& text);
std::optional<MessagePage> list_page(
const std::string& chat_id,
int limit,
const std::optional<std::string>& cursor);
private:
PgPool& pool_;
};
+38
View File
@@ -0,0 +1,38 @@
#pragma once
#include <optional>
#include <string>
#include <vector>
struct User {
std::string id;
std::string username;
std::string display_name;
std::string password_hash;
std::string created_at;
};
struct Chat {
std::string id;
std::string title;
std::vector<std::string> member_ids;
std::string created_at;
};
struct Message {
std::string id;
std::string chat_id;
std::string sender_id;
std::string text;
std::string created_at;
};
struct MessagePage {
std::vector<Message> items;
std::optional<std::string> next_cursor;
};
struct ChatPage {
std::vector<Chat> items;
std::optional<std::string> next_cursor;
};
+66
View File
@@ -0,0 +1,66 @@
#include "pg_session_repo.hpp"
#include <pqxx/pqxx>
#include <sodium.h>
#include <ctime>
#include <stdexcept>
#include <string>
namespace {
std::string random_token_hex() {
unsigned char buf[32];
randombytes_buf(buf, sizeof(buf));
static const char hex[] = "0123456789abcdef";
std::string out;
out.resize(sizeof(buf) * 2);
for (std::size_t i = 0; i < sizeof(buf); ++i) {
out[i * 2] = hex[buf[i] >> 4];
out[i * 2 + 1] = hex[buf[i] & 0x0f];
}
return out;
}
std::int64_t now_unix() {
return static_cast<std::int64_t>(std::time(nullptr));
}
}
ISessionRepo::Created PgSessionRepo::create(const std::string& user_id) {
const std::string token = random_token_hex();
const std::int64_t exp = now_unix() + ttl_;
auto lease = pool_.acquire();
pqxx::work tx(*lease);
tx.exec(
"INSERT INTO sessions (token, user_id, expires_at) "
"VALUES ($1, $2, to_timestamp($3::bigint))",
pqxx::params{token, user_id, exp});
tx.commit();
return Created{token, exp};
}
std::optional<std::string> PgSessionRepo::lookup(const std::string& token) {
auto lease = pool_.acquire();
pqxx::work tx(*lease);
auto r = tx.exec(
"SELECT user_id FROM sessions "
"WHERE token = $1 AND expires_at > now()",
pqxx::params{token});
tx.commit();
if (r.empty()) return std::nullopt;
return r[0]["user_id"].as<std::string>();
}
bool PgSessionRepo::revoke(const std::string& token) {
auto lease = pool_.acquire();
pqxx::work tx(*lease);
auto r = tx.exec(
"DELETE FROM sessions WHERE token = $1",
pqxx::params{token});
tx.commit();
return r.affected_rows() > 0;
}
+18
View File
@@ -0,0 +1,18 @@
#pragma once
#include "db.hpp"
#include "session_repo_base.hpp"
class PgSessionRepo : public ISessionRepo {
public:
PgSessionRepo(PgPool& pool, int ttl_seconds)
: pool_(pool), ttl_(ttl_seconds) {}
Created create(const std::string& user_id) override;
std::optional<std::string> lookup(const std::string& token) override;
bool revoke(const std::string& token) override;
private:
PgPool& pool_;
int ttl_;
};
+216
View File
@@ -0,0 +1,216 @@
#include "redis_pool.hpp"
#include "errors.hpp"
#include <chrono>
#include <cstdlib>
#include <stdexcept>
#include <string>
namespace {
constexpr timeval kConnectTimeout{2, 0};
constexpr timeval kCommandTimeout{2, 0};
constexpr auto kAcquireTimeout = std::chrono::seconds(3);
struct RedisUrl {
std::string host = "127.0.0.1";
int port = 6379;
std::string password;
int db = 0;
};
RedisUrl parse_redis_url(const std::string& url) {
RedisUrl out;
const std::string prefix = "redis://";
if (url.compare(0, prefix.size(), prefix) != 0) {
throw std::runtime_error("redis url must start with redis://");
}
std::string rest = url.substr(prefix.size());
const auto slash = rest.find('/');
if (slash != std::string::npos) {
const std::string db_str = rest.substr(slash + 1);
rest.resize(slash);
if (!db_str.empty()) {
out.db = std::atoi(db_str.c_str());
}
}
const auto at = rest.find('@');
std::string hostport = rest;
if (at != std::string::npos) {
const std::string creds = rest.substr(0, at);
hostport = rest.substr(at + 1);
const auto colon = creds.find(':');
if (colon != std::string::npos) {
out.password = creds.substr(colon + 1);
} else {
out.password = creds;
}
}
const auto colon = hostport.find(':');
if (colon == std::string::npos) {
out.host = hostport;
} else {
out.host = hostport.substr(0, colon);
out.port = std::atoi(hostport.substr(colon + 1).c_str());
}
return out;
}
redisContext* make_connection(const RedisUrl& u) {
redisContext* c = redisConnectWithTimeout(u.host.c_str(), u.port, kConnectTimeout);
if (c == nullptr) {
throw std::runtime_error("redisConnect: allocation failed");
}
if (c->err) {
const std::string err = c->errstr;
redisFree(c);
throw DependencyUnavailable("redisConnect failed: " + err);
}
if (redisSetTimeout(c, kCommandTimeout) != REDIS_OK) {
redisFree(c);
throw DependencyUnavailable("redisSetTimeout failed");
}
if (!u.password.empty()) {
redisReply* r = static_cast<redisReply*>(
redisCommand(c, "AUTH %s", u.password.c_str()));
if (r == nullptr) {
redisFree(c);
throw std::runtime_error("redis AUTH: no reply");
}
const bool ok = (r->type == REDIS_REPLY_STATUS);
freeReplyObject(r);
if (!ok) {
redisFree(c);
throw std::runtime_error("redis AUTH failed");
}
}
if (u.db != 0) {
redisReply* r = static_cast<redisReply*>(
redisCommand(c, "SELECT %d", u.db));
if (r == nullptr) {
redisFree(c);
throw std::runtime_error("redis SELECT: no reply");
}
const bool ok = (r->type == REDIS_REPLY_STATUS);
freeReplyObject(r);
if (!ok) {
redisFree(c);
throw std::runtime_error("redis SELECT failed");
}
}
return c;
}
}
RedisPool::RedisPool(std::string url, std::size_t n)
: url_(std::move(url)) {
if (n == 0) {
throw std::runtime_error("RedisPool: n must be > 0");
}
const RedisUrl parsed = parse_redis_url(url_);
all_.reserve(n);
idle_.reserve(n);
for (std::size_t i = 0; i < n; ++i) {
ConnPtr c(make_connection(parsed));
idle_.push_back(c.get());
all_.push_back(std::move(c));
}
}
RedisPool::~RedisPool() {
{
std::lock_guard<std::mutex> lk(mu_);
shutting_down_ = true;
}
cv_.notify_all();
}
RedisPool::Lease::Lease(RedisPool& pool)
: pool_(&pool), ctx_(pool.take()) {}
RedisPool::Lease::~Lease() {
if (pool_ != nullptr && ctx_ != nullptr) {
pool_->give_back(ctx_);
}
}
RedisPool::Lease::Lease(Lease&& other) noexcept
: pool_(other.pool_), ctx_(other.ctx_) {
other.pool_ = nullptr;
other.ctx_ = nullptr;
}
RedisPool::Lease RedisPool::acquire() {
return Lease(*this);
}
redisContext* RedisPool::take() {
std::unique_lock<std::mutex> lk(mu_);
if (!cv_.wait_for(lk, kAcquireTimeout,
[&]() { return shutting_down_ || !idle_.empty(); })) {
throw DependencyUnavailable("redis pool: acquire timeout");
}
if (shutting_down_) {
throw DependencyUnavailable("redis pool is shutting down");
}
redisContext* c = idle_.back();
idle_.pop_back();
lk.unlock();
bool alive = false;
if (!c->err) {
redisReply* r = static_cast<redisReply*>(redisCommand(c, "PING"));
if (r != nullptr && r->type == REDIS_REPLY_STATUS) {
alive = true;
}
if (r != nullptr) freeReplyObject(r);
}
if (alive) {
return c;
}
ConnPtr fresh;
try {
fresh.reset(make_connection(parse_redis_url(url_)));
} catch (const std::exception& e) {
// Слот возвращается в пул, иначе после нескольких неудач пул опустеет навсегда.
give_back(c);
throw DependencyUnavailable(std::string("redis reconnect failed: ") + e.what());
}
std::lock_guard<std::mutex> lk2(mu_);
for (auto& up : all_) {
if (up.get() == c) {
up = std::move(fresh);
return up.get();
}
}
throw std::logic_error("RedisPool: connection not owned by pool");
}
void RedisPool::give_back(redisContext* c) {
{
std::lock_guard<std::mutex> lk(mu_);
idle_.push_back(c);
}
cv_.notify_one();
}
bool RedisPool::ping() {
try {
auto lease = acquire();
redisContext* c = lease.ctx();
redisReply* r = static_cast<redisReply*>(redisCommand(c, "PING"));
if (r == nullptr) return false;
const bool ok = (r->type == REDIS_REPLY_STATUS);
freeReplyObject(r);
return ok;
} catch (...) {
return false;
}
}
+59
View File
@@ -0,0 +1,59 @@
#pragma once
#include <hiredis/hiredis.h>
#include <condition_variable>
#include <cstddef>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
class RedisPool {
public:
RedisPool(std::string url, std::size_t n);
~RedisPool();
RedisPool(const RedisPool&) = delete;
RedisPool& operator=(const RedisPool&) = delete;
class Lease {
public:
explicit Lease(RedisPool& pool);
~Lease();
Lease(Lease&& other) noexcept;
Lease& operator=(Lease&&) = delete;
Lease(const Lease&) = delete;
Lease& operator=(const Lease&) = delete;
redisContext* ctx() const { return ctx_; }
private:
RedisPool* pool_;
redisContext* ctx_;
};
Lease acquire();
bool ping();
private:
friend class Lease;
struct RedisDeleter {
void operator()(redisContext* c) const noexcept {
if (c != nullptr) ::redisFree(c);
}
};
using ConnPtr = std::unique_ptr<redisContext, RedisDeleter>;
redisContext* take();
void give_back(redisContext* c);
std::string url_;
std::vector<ConnPtr> all_;
std::vector<redisContext*> idle_;
std::mutex mu_;
std::condition_variable cv_;
bool shutting_down_ = false;
};
+87
View File
@@ -0,0 +1,87 @@
#include "session_repo.hpp"
#include "errors.hpp"
#include <sodium.h>
#include <ctime>
#include <stdexcept>
#include <string>
#include <vector>
namespace {
std::string random_token_hex() {
unsigned char buf[32];
randombytes_buf(buf, sizeof(buf));
static const char hex[] = "0123456789abcdef";
std::string out;
out.resize(sizeof(buf) * 2);
for (std::size_t i = 0; i < sizeof(buf); ++i) {
out[i * 2] = hex[buf[i] >> 4];
out[i * 2 + 1] = hex[buf[i] & 0x0f];
}
return out;
}
std::int64_t now_unix() {
return static_cast<std::int64_t>(std::time(nullptr));
}
redisReply* check_reply(redisContext* c, redisReply* r) {
if (r == nullptr) {
const std::string err = c->err ? c->errstr : "no reply";
throw DependencyUnavailable("redis command failed: " + err);
}
return r;
}
}
ISessionRepo::Created SessionRepo::create(const std::string& user_id) {
const std::string token = random_token_hex();
const std::int64_t exp = now_unix() + ttl_;
auto lease = pool_.acquire();
redisContext* c = lease.ctx();
redisReply* r = static_cast<redisReply*>(
redisCommand(c, "SET session:%s %s EX %d",
token.c_str(), user_id.c_str(), ttl_));
check_reply(c, r);
const bool ok = (r->type == REDIS_REPLY_STATUS);
freeReplyObject(r);
if (!ok) {
throw std::runtime_error("redis SET returned non-status");
}
return Created{token, exp};
}
std::optional<std::string> SessionRepo::lookup(const std::string& token) {
auto lease = pool_.acquire();
redisContext* c = lease.ctx();
redisReply* r = static_cast<redisReply*>(
redisCommand(c, "GET session:%s", token.c_str()));
check_reply(c, r);
std::optional<std::string> out;
if (r->type == REDIS_REPLY_STRING) {
out = std::string(r->str, r->len);
}
freeReplyObject(r);
return out;
}
bool SessionRepo::revoke(const std::string& token) {
auto lease = pool_.acquire();
redisContext* c = lease.ctx();
redisReply* r = static_cast<redisReply*>(
redisCommand(c, "DEL session:%s", token.c_str()));
check_reply(c, r);
const bool existed = (r->type == REDIS_REPLY_INTEGER && r->integer == 1);
freeReplyObject(r);
return existed;
}
+18
View File
@@ -0,0 +1,18 @@
#pragma once
#include "redis_pool.hpp"
#include "session_repo_base.hpp"
class SessionRepo : public ISessionRepo {
public:
SessionRepo(RedisPool& pool, int ttl_seconds)
: pool_(pool), ttl_(ttl_seconds) {}
Created create(const std::string& user_id) override;
std::optional<std::string> lookup(const std::string& token) override;
bool revoke(const std::string& token) override;
private:
RedisPool& pool_;
int ttl_;
};
+22
View File
@@ -0,0 +1,22 @@
#pragma once
#include <cstdint>
#include <optional>
#include <string>
class ISessionRepo {
public:
virtual ~ISessionRepo() = default;
struct Created {
std::string token;
std::int64_t expires_at; // unix-время в секундах UTC
};
virtual Created create(const std::string& user_id) = 0;
virtual std::optional<std::string> lookup(const std::string& token) = 0;
virtual bool revoke(const std::string& token) = 0;
};
+100
View File
@@ -0,0 +1,100 @@
#include "user_repo.hpp"
#include <pqxx/pqxx>
#include <chrono>
#include <ctime>
#include <iomanip>
#include <random>
#include <sstream>
#include <string>
namespace {
std::string make_uuid() {
static std::mt19937_64 rng{std::random_device{}()};
std::uniform_int_distribution<uint32_t> d16(0, 0xffff);
std::uniform_int_distribution<uint32_t> d32(0, 0xffffffffu);
std::ostringstream out;
out << std::hex << std::setfill('0');
out << std::setw(8) << d32(rng);
out << '-' << std::setw(4) << d16(rng);
out << '-' << std::setw(4) << ((d16(rng) & 0x0fff) | 0x4000);
out << '-' << std::setw(4) << ((d16(rng) & 0x3fff) | 0x8000);
out << '-' << std::setw(4) << d16(rng) << std::setw(8) << d32(rng);
return out.str();
}
std::string epoch_to_rfc3339(long long epoch) {
const std::time_t t = static_cast<std::time_t>(epoch);
std::tm tm{};
gmtime_r(&t, &tm);
std::ostringstream out;
out << std::put_time(&tm, "%Y-%m-%dT%H:%M:%SZ");
return out.str();
}
std::string now_epoch_str() {
const auto now = std::chrono::system_clock::now();
const auto secs = std::chrono::duration_cast<std::chrono::seconds>(
now.time_since_epoch()).count();
return std::to_string(secs);
}
User row_to_user(const pqxx::row& r) {
User u;
u.id = r["id"].as<std::string>();
u.username = r["username"].as<std::string>();
u.display_name = r["display_name"].as<std::string>();
u.password_hash = r["password_hash"].as<std::string>();
u.created_at = epoch_to_rfc3339(r["created_at_epoch"].as<long long>());
return u;
}
constexpr const char* kUserColumns =
"id, username, display_name, password_hash, "
"EXTRACT(EPOCH FROM created_at)::bigint AS created_at_epoch";
}
std::optional<User> UserRepo::create(const std::string& username,
const std::string& display_name,
const std::string& password_hash) {
auto lease = pool_.acquire();
pqxx::work tx(*lease);
try {
const std::string id = make_uuid();
auto r = tx.exec(
"INSERT INTO users (id, username, display_name, password_hash, created_at) "
"VALUES ($1, $2, $3, $4, to_timestamp($5::bigint)) "
"RETURNING " + std::string(kUserColumns),
pqxx::params{id, username, display_name, password_hash, now_epoch_str()});
tx.commit();
return row_to_user(r[0]);
} catch (const pqxx::unique_violation&) {
tx.abort();
return std::nullopt;
}
}
std::optional<User> UserRepo::find_by_id(const std::string& id) {
auto lease = pool_.acquire();
pqxx::work tx(*lease);
auto r = tx.exec(
"SELECT " + std::string(kUserColumns) + " FROM users WHERE id = $1",
pqxx::params{id});
tx.commit();
if (r.empty()) return std::nullopt;
return row_to_user(r[0]);
}
std::optional<User> UserRepo::find_by_username(const std::string& username) {
auto lease = pool_.acquire();
pqxx::work tx(*lease);
auto r = tx.exec(
"SELECT " + std::string(kUserColumns) + " FROM users WHERE username = $1",
pqxx::params{username});
tx.commit();
if (r.empty()) return std::nullopt;
return row_to_user(r[0]);
}
+22
View File
@@ -0,0 +1,22 @@
#pragma once
#include "db.hpp"
#include "models.hpp"
#include <optional>
#include <string>
class UserRepo {
public:
explicit UserRepo(PgPool& pool) : pool_(pool) {}
std::optional<User> create(const std::string& username,
const std::string& display_name,
const std::string& password_hash);
std::optional<User> find_by_id(const std::string& id);
std::optional<User> find_by_username(const std::string& username);
private:
PgPool& pool_;
};
+106
View File
@@ -0,0 +1,106 @@
#!/usr/bin/env python3
import json, time, math, sys, threading, os
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
from client import Client, Failure
def pct(xs, p):
if not xs:
return None
xs = sorted(xs)
return round(1000 * xs[max(0, math.ceil(p * len(xs)) - 1)], 3)
def main():
warmup = int(sys.argv[1])
conc = int(sys.argv[2])
duration = float(sys.argv[3])
mode = sys.argv[4] if len(sys.argv) > 4 else "post"
base = os.environ.get("BASE_URL", "http://127.0.0.1:8080")
c = Client(base)
alice, bob, eve, chat = c.bootstrap()
for i in range(warmup):
c.message(alice, chat, "w-%d" % i)
barrier = threading.Barrier(conc)
def worker(wid):
local = Client(base, timeout=5)
barrier.wait()
deadline = time.monotonic() + duration
lat, err, n = [], 0, 0
while time.monotonic() < deadline:
t0 = time.monotonic()
try:
if mode == "get":
local.call(
"GET",
"/api/v1/chats/" + chat["id"] + "/messages?limit=50",
actor=alice,
schema="MessagePage",
)
else:
local.message(alice, chat, "b-%s-%s" % (wid, n))
lat.append(time.monotonic() - t0)
except Failure:
err += 1
n += 1
return lat, err
t0 = time.monotonic()
with ThreadPoolExecutor(max_workers=conc) as pool:
parts = list(pool.map(worker, range(conc)))
elapsed = time.monotonic() - t0
lat = [x for a, _ in parts for x in a]
err = sum(e for _, e in parts)
out = {
"warmup_messages": warmup,
"concurrency": conc,
"duration_s": duration,
"elapsed_s": round(elapsed, 3),
"ok": len(lat),
"err": err,
"rps": round(len(lat) / elapsed, 3) if elapsed else None,
"p50_ms": pct(lat, 0.50),
"p95_ms": pct(lat, 0.95),
"p99_ms": pct(lat, 0.99),
"mode": mode,
}
import subprocess
def rss_from_proc():
for ent in os.listdir("/proc"):
if not ent.isdigit():
continue
try:
with open("/proc/%s/cmdline" % ent, "rb") as f:
cmd = f.read()
except OSError:
continue
if b"messenger" not in cmd:
continue
try:
with open("/proc/%s/status" % ent) as f:
for line in f:
if line.startswith("VmRSS:"):
kb = int(line.split()[1])
return "%.2fMiB" % (kb / 1024.0)
except (OSError, ValueError, IndexError):
continue
return None
mem = rss_from_proc()
if not mem:
name = os.environ.get("DOCKER_NAME", "mtusi-lab1")
for cmd in (
["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", name],
["sudo", "-n", "docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", name],
):
try:
mem = subprocess.check_output(cmd, text=True).split("/")[0].strip()
if mem:
break
except Exception:
mem = None
out["mem"] = mem
print(json.dumps(out, ensure_ascii=False))
if __name__ == "__main__":
main()
+170
View File
@@ -0,0 +1,170 @@
#!/usr/bin/env python3
"""Собственные проверки контракта lab2 (дополняют публичный tests/smoke.py).
BASE_URL=http://127.0.0.1:8080 python3 student-tests/test_api.py
"""
import base64
import json
import os
import urllib.error
import urllib.request
import uuid
from urllib.parse import quote
BASE = os.environ.get("BASE_URL", "http://127.0.0.1:8080")
PASSWORD = "Student-test-password-1"
def call(method, path, expected, body=None, token=None, raw=None,
content_type="auto", headers=None):
h = {"Accept": "application/json"}
data = raw
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode()
h["Content-Type"] = "application/json"
elif data is not None and content_type == "auto":
h["Content-Type"] = "application/json"
elif data is not None and content_type:
h["Content-Type"] = content_type
if token:
h["Authorization"] = "Bearer " + token
h.update(headers or {})
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
try:
resp = urllib.request.urlopen(req, timeout=15)
except urllib.error.HTTPError as e:
resp = e
raw_b = resp.read()
assert resp.status == expected, (method, path, resp.status, raw_b[:300])
rid = resp.headers.get("X-Request-Id")
assert rid, "missing X-Request-Id"
payload = json.loads(raw_b) if raw_b else None
if resp.status >= 400:
assert payload["error"]["request_id"] == rid
if resp.status == 401:
assert resp.headers.get("WWW-Authenticate"), "401 without WWW-Authenticate"
return payload
def unique(prefix):
return prefix + "_" + uuid.uuid4().hex[:12]
def basic(username, password):
return {"Authorization": "Basic " + base64.b64encode(
f"{username}:{password}".encode()).decode()}
def register(prefix, display_name="U"):
user = call("POST", "/api/v1/users", 201, {
"username": unique(prefix), "display_name": display_name, "password": PASSWORD})
user["token"] = call("POST", "/api/v1/auth/sessions", 201,
headers=basic(user["username"], PASSWORD))["token"]
return user
def test_registration_validation():
call("POST", "/api/v1/users", 400, raw=b"{not json")
call("POST", "/api/v1/users", 400, raw=b'{"username":"x"')
call("POST", "/api/v1/users", 415, raw=b'{"username":"aa1"}', content_type="text/plain")
call("POST", "/api/v1/users", 400,
{"username": unique("n"), "display_name": 1, "password": PASSWORD})
call("POST", "/api/v1/users", 400,
{"username": unique("n"), "display_name": "я" * 101, "password": PASSWORD})
call("POST", "/api/v1/users", 400,
{"username": unique("n"), "display_name": "N", "password": "short"})
call("POST", "/api/v1/users", 400,
{"username": unique("n"), "display_name": "N"})
call("POST", "/api/v1/users", 400,
{"username": unique("n"), "display_name": "N", "password": PASSWORD, "extra": 1})
name = unique("dup")
body = {"username": name, "display_name": "Same", "password": PASSWORD}
user = call("POST", "/api/v1/users", 201, body)
assert "password" not in user and "password_hash" not in user
call("POST", "/api/v1/users", 409, body)
def test_auth_transitions():
a = register("a", 'Alice "цитата"')
assert a["display_name"] == 'Alice "цитата"'
call("GET", "/api/v1/users/me", 401)
call("GET", "/api/v1/users/me", 401, headers={"X-User-Id": a["id"]})
call("GET", "/api/v1/users/me", 401, headers=basic(a["username"], PASSWORD))
call("GET", "/api/v1/users/me", 401, token="not-a-real-token")
call("POST", "/api/v1/auth/sessions", 401)
call("POST", "/api/v1/auth/sessions", 401, headers=basic(a["username"], "wrong-password-1"))
me = call("GET", "/api/v1/users/me", 200, token=a["token"])
assert me["id"] == a["id"]
def test_messages_and_access():
a, b, eve = register("a"), register("b"), register("e")
chat = call("POST", "/api/v1/chats", 201,
{"title": "t", "member_ids": [a["id"], b["id"]]}, token=a["token"])
path = "/api/v1/chats/" + chat["id"] + "/messages"
call("POST", path, 400, {"text": ""}, token=a["token"])
call("POST", path, 400, {"text": " "}, token=a["token"])
call("POST", path, 400, {"text": "x" * 4001}, token=a["token"])
call("POST", path, 400, {"text": "hi", "sender_id": eve["id"]}, token=a["token"])
msg = call("POST", path, 201, {"text": 'раз "два" три'}, token=a["token"])
assert msg["text"] == 'раз "два" три' and msg["sender_id"] == a["id"]
call("GET", "/api/v1/chats/" + chat["id"], 404, token=eve["token"])
call("GET", path, 404, token=eve["token"])
call("POST", path, 404, {"text": "nope"}, token=eve["token"])
call("GET", "/api/v1/chats/not-a-uuid", 400, token=a["token"])
def test_chat_validation():
a, b = register("a"), register("b")
call("POST", "/api/v1/chats", 400,
{"title": "т" * 101, "member_ids": [a["id"], b["id"]]}, token=a["token"])
call("POST", "/api/v1/chats", 400,
{"title": "no caller", "member_ids": [b["id"]]}, token=a["token"])
call("POST", "/api/v1/chats", 400,
{"title": "dup", "member_ids": [a["id"], b["id"], b["id"]]}, token=a["token"])
call("POST", "/api/v1/chats", 400,
{"title": "unknown", "member_ids": [a["id"], str(uuid.uuid4())]}, token=a["token"])
def test_pagination():
a, b = register("a"), register("b")
chats = [call("POST", "/api/v1/chats", 201,
{"title": "chat-%d" % i, "member_ids": [a["id"], b["id"]]}, token=a["token"])
for i in range(3)]
p1 = call("GET", "/api/v1/chats?limit=1", 200, token=a["token"])
assert len(p1["items"]) == 1 and p1["next_cursor"]
p2 = call("GET", "/api/v1/chats?limit=1&cursor=" + quote(p1["next_cursor"], safe=""),
200, token=a["token"])
assert p1["items"][0]["id"] != p2["items"][0]["id"]
call("GET", "/api/v1/chats?limit=0", 400, token=a["token"])
call("GET", "/api/v1/chats?limit=101", 400, token=a["token"])
call("GET", "/api/v1/chats?limit=1&cursor=bad|cursor", 400, token=a["token"])
path = "/api/v1/chats/" + chats[0]["id"] + "/messages"
m1 = call("POST", path, 201, {"text": "one"}, token=a["token"])
m2 = call("POST", path, 201, {"text": "two"}, token=b["token"])
q1 = call("GET", path + "?limit=1", 200, token=a["token"])
assert len(q1["items"]) == 1 and q1["next_cursor"]
q2 = call("GET", path + "?limit=1&cursor=" + quote(q1["next_cursor"], safe=""),
200, token=a["token"])
assert len(q2["items"]) == 1 and q2["next_cursor"] is None
assert {q1["items"][0]["id"], q2["items"][0]["id"]} == {m1["id"], m2["id"]}
call("GET", path + "?limit=0", 400, token=a["token"])
other = "/api/v1/chats/" + chats[1]["id"] + "/messages"
call("GET", other + "?cursor=" + quote(q1["next_cursor"], safe=""), 400, token=a["token"])
def test_logout():
a = register("lo")
call("DELETE", "/api/v1/auth/sessions/current", 204, token=a["token"])
call("GET", "/api/v1/users/me", 401, token=a["token"])
call("DELETE", "/api/v1/auth/sessions/current", 401, token=a["token"])
if __name__ == "__main__":
for test in (test_registration_validation, test_auth_transitions, test_messages_and_access,
test_chat_validation, test_pagination, test_logout):
test()
print("ok", test.__name__)
print("PASS student-tests")
+337
View File
@@ -0,0 +1,337 @@
#!/usr/bin/env python3
"""Уровень 4: собственные автотесты студента.
Проверяет:
- гонку регистрации одного username и rollback создания чата;
- контракт: дубликаты member_ids и невалидный/чужой cursor — 400;
keyset-пагинация без повторов при created_at с долями секунды;
- неверный пароль, logout, expiry при SESSION_TTL_SECONDS=2
(отдельный контейнер api на порту 18080);
- отказ db и cache дольше размера пулов: бизнес-запросы с валидным
токеном получают 503 за ограниченное время (не 401 и не 200), после
восстановления тот же токен снова работает.
Запуск (стек api+db+cache поднят через compose.yaml):
python3 tests/level4.py
python3 tests/level4.py --skip-outage --skip-expiry # быстрые проверки
"""
import argparse
import base64
import concurrent.futures
import json
import subprocess
import sys
import time
import urllib.error
import urllib.parse
import urllib.request
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
PASSWORD = "Test-password-123456"
REQUEST_BUDGET_S = 10.0
TTL_PORT = 18080
TTL_CONTAINER = "lab2-api-ttl2"
def load_env():
env = {}
for line in (ROOT / ".env").read_text(encoding="utf-8").splitlines():
line = line.strip()
if line and not line.startswith("#") and "=" in line:
k, v = line.split("=", 1)
env[k.strip()] = v.strip()
return env
ENV = load_env()
def call(base, method, path, expected, body=None, token=None, headers=None):
h = {"Accept": "application/json"}
if token:
h["Authorization"] = "Bearer " + token
data = None
if body is not None:
data = json.dumps(body).encode()
h["Content-Type"] = "application/json"
h.update(headers or {})
req = urllib.request.Request(base + path, data=data, headers=h, method=method)
try:
with urllib.request.urlopen(req, timeout=REQUEST_BUDGET_S + 5) as resp:
status, payload = resp.code, resp.read()
except urllib.error.HTTPError as e:
status, payload = e.code, e.read()
allowed = expected if isinstance(expected, (list, tuple)) else [expected]
if status not in allowed:
raise AssertionError(f"{method} {path}: expected {allowed}, got {status}: {payload[:200]}")
try:
return json.loads(payload) if payload else None
except json.JSONDecodeError:
return payload
def timed_call(base, method, path, expected, **kw):
t0 = time.monotonic()
result = call(base, method, path, expected, **kw)
elapsed = time.monotonic() - t0
if elapsed > REQUEST_BUDGET_S:
raise AssertionError(f"{method} {path} took {elapsed:.1f}s > {REQUEST_BUDGET_S}s")
return elapsed, result
def create_user(base, prefix):
return call(base, "POST", "/api/v1/users", 201, body={
"username": f"{prefix}_{uuid.uuid4().hex[:10]}",
"display_name": "T",
"password": PASSWORD,
})
def basic(username, password):
return {"Authorization": "Basic " + base64.b64encode(
f"{username}:{password}".encode()).decode()}
def login(base, username, password=PASSWORD):
return call(base, "POST", "/api/v1/auth/sessions", 201, headers=basic(username, password))
def compose(*args):
subprocess.run(["docker", "compose", "--env-file", ".env", *args],
check=True, capture_output=True, cwd=ROOT)
def psql(sql):
r = subprocess.run(
["docker", "compose", "--env-file", ".env", "exec", "-T", "db", "psql",
"-U", ENV["POSTGRES_USER"], "-d", ENV["POSTGRES_DB"], "-X", "-t", "-A",
"-v", "ON_ERROR_STOP=1", "-c", sql],
capture_output=True, text=True, cwd=ROOT)
if r.returncode != 0:
raise RuntimeError(r.stderr)
return r.stdout.strip()
def wait_ready(base, timeout=60):
deadline = time.monotonic() + timeout
t0 = time.monotonic()
while time.monotonic() < deadline:
try:
call(base, "GET", "/health/ready", 200)
return time.monotonic() - t0
except (AssertionError, urllib.error.URLError, ConnectionError, OSError):
time.sleep(0.5)
raise AssertionError(f"{base} not ready in {timeout}s")
# ---------- гонка и rollback ----------
def test_username_race(base):
username = "race_" + uuid.uuid4().hex[:10]
def try_register(_):
req = urllib.request.Request(
base + "/api/v1/users",
data=json.dumps({"username": username, "display_name": "Race",
"password": PASSWORD}).encode(),
headers={"Content-Type": "application/json"}, method="POST")
try:
with urllib.request.urlopen(req, timeout=15) as resp:
return resp.code
except urllib.error.HTTPError as e:
return e.code
with concurrent.futures.ThreadPoolExecutor(8) as pool:
results = list(pool.map(try_register, range(8)))
cnt = {c: results.count(c) for c in set(results)}
if cnt.get(201, 0) != 1 or any(c not in (201, 409) for c in results):
raise AssertionError(f"expected exactly one 201 and the rest 409, got {cnt}")
print(f" PASS: username race {cnt}")
def test_chat_rollback(base):
alice = create_user(base, "rb")
token = login(base, alice["username"])["token"]
fake_id = str(uuid.uuid4())
title = "rollback " + uuid.uuid4().hex[:8]
call(base, "POST", "/api/v1/chats", 400, token=token,
body={"title": title, "member_ids": [alice["id"], fake_id]})
if psql(f"SELECT count(*) FROM chats WHERE title = '{title}';") != "0":
raise AssertionError("chat was not rolled back")
if psql(f"SELECT count(*) FROM chat_members WHERE user_id = '{fake_id}';") != "0":
raise AssertionError("chat_members row leaked after failed chat create")
print(" PASS: rollback — чат не создан, chat_members пуст")
# ---------- контракт ----------
def test_contract_validation(base):
alice, bob = create_user(base, "cv"), create_user(base, "cv")
token = login(base, alice["username"])["token"]
call(base, "POST", "/api/v1/chats", 400, token=token,
body={"title": "dup", "member_ids": [alice["id"], bob["id"], bob["id"]]})
call(base, "POST", "/api/v1/chats", 400, token=token,
body={"title": "dup", "member_ids": [alice["id"], alice["id"].upper()]})
print(" PASS: дубликаты member_ids — 400")
chat = call(base, "POST", "/api/v1/chats", 201, token=token,
body={"title": "cursor", "member_ids": [alice["id"], bob["id"]]})
other = call(base, "POST", "/api/v1/chats", 201, token=token,
body={"title": "other", "member_ids": [alice["id"]]})
for i in range(3):
call(base, "POST", f"/api/v1/chats/{other['id']}/messages", 201,
token=token, body={"text": f"o{i}"})
foreign = call(base, "GET", f"/api/v1/chats/{other['id']}/messages?limit=1",
200, token=token)["next_cursor"]
path = f"/api/v1/chats/{chat['id']}/messages"
malformed = ["abc|xyz", "123|not-a-uuid", "2026-01-01T00:00:00Z|" + str(uuid.uuid4()),
"|", "12345"]
for bad in malformed + [foreign]:
call(base, "GET", f"{path}?cursor={urllib.parse.quote(bad, safe='')}", 400, token=token)
for bad in malformed:
call(base, "GET", f"/api/v1/chats?cursor={urllib.parse.quote(bad, safe='')}", 400,
token=token)
print(" PASS: невалидный и чужой cursor — 400, не 500")
def test_pagination_fractional_seconds(base):
alice = create_user(base, "pg")
token = login(base, alice["username"])["token"]
chat = call(base, "POST", "/api/v1/chats", 201, token=token,
body={"title": "frac", "member_ids": [alice["id"]]})
path = f"/api/v1/chats/{chat['id']}/messages"
ids = [call(base, "POST", path, 201, token=token, body={"text": f"m{i}"})["id"]
for i in range(7)]
# Данные, загруженные не через API (импорт, seed), могут иметь доли секунды.
psql(f"""
UPDATE messages SET created_at = date_trunc('second', now())
+ (floor(random() * 999999) + 1) * interval '1 microsecond'
WHERE chat_id = '{chat['id']}';
""")
expected = psql(f"SELECT string_agg(id::text, ',' ORDER BY created_at, id) "
f"FROM messages WHERE chat_id = '{chat['id']}';").split(",")
seen, cursor = [], None
for _ in range(20):
q = "?limit=2" + (f"&cursor={urllib.parse.quote(cursor, safe='')}" if cursor else "")
page = call(base, "GET", path + q, 200, token=token)
seen += [m["id"] for m in page["items"]]
cursor = page["next_cursor"]
if cursor is None:
break
if seen != expected or sorted(seen) != sorted(ids):
raise AssertionError(f"pagination mismatch: got {len(seen)} items, expected {len(expected)}")
print(" PASS: keyset-пагинация без повторов при created_at с долями секунды")
# ---------- аутентификация ----------
def test_wrong_password_and_logout(base):
alice = create_user(base, "lo")
call(base, "POST", "/api/v1/auth/sessions", 401,
headers=basic(alice["username"], "wrong-password-123"))
call(base, "POST", "/api/v1/auth/sessions", 401,
headers=basic("no_such_user_" + uuid.uuid4().hex[:6], PASSWORD))
token = login(base, alice["username"])["token"]
call(base, "GET", "/api/v1/users/me", 200, token=token)
call(base, "DELETE", "/api/v1/auth/sessions/current", 204, token=token)
call(base, "GET", "/api/v1/users/me", 401, token=token)
call(base, "DELETE", "/api/v1/auth/sessions/current", 401, token=token)
print(" PASS: неверный пароль — 401; logout — 204, затем 401")
def test_expiry():
subprocess.run(["docker", "rm", "-f", TTL_CONTAINER], capture_output=True)
compose("run", "-d", "--rm", "--no-deps", "--name", TTL_CONTAINER,
"-e", "SESSION_TTL_SECONDS=2", "-p", f"{TTL_PORT}:8080", "api")
base = f"http://127.0.0.1:{TTL_PORT}"
try:
wait_ready(base)
alice = create_user(base, "ttl")
session = login(base, alice["username"])
call(base, "GET", "/api/v1/users/me", 200, token=session["token"])
time.sleep(3.5)
call(base, "GET", "/api/v1/users/me", 401, token=session["token"])
print(f" PASS: expiry — при TTL=2 s токен действует, через 3.5 s — 401 "
f"(expires_at={session['expires_at']})")
finally:
subprocess.run(["docker", "rm", "-f", TTL_CONTAINER], capture_output=True)
# ---------- отказы ----------
def outage(base, service, username, token, requests, hold_s):
"""Останавливает service, шлёт запросы с валидным токеном, восстанавливает."""
call(base, "GET", "/api/v1/users/me", 200, token=token)
compose("stop", service)
t_stop = time.monotonic()
times = []
try:
time.sleep(1)
call(base, "GET", "/health/ready", 503)
for i in range(requests):
elapsed, _ = timed_call(base, "GET", "/api/v1/users/me", 503, token=token)
times.append(elapsed)
timed_call(base, "POST", "/api/v1/auth/sessions", 503,
headers=basic(username, PASSWORD))
if service == "db":
timed_call(base, "POST", "/api/v1/users", 503, body={
"username": "down_" + uuid.uuid4().hex[:8], "display_name": "D",
"password": PASSWORD})
remaining = hold_s - (time.monotonic() - t_stop)
if remaining > 0:
time.sleep(remaining)
finally:
compose("start", service)
down_for = time.monotonic() - t_stop
recovery = wait_ready(base)
call(base, "GET", "/api/v1/users/me", 200, token=token)
print(f" PASS: {service} остановлен {down_for:.0f} s: {requests} запросов с токеном → 503 "
f"(max {max(times):.2f} s), после старта ready за {recovery:.1f} s, "
f"тот же токен → 200")
def test_dependency_outage(base):
alice = create_user(base, "out")
token = login(base, alice["username"])["token"]
# Запросов больше, чем соединений в пулах (pg 8, redis 4): пул не должен истощаться.
outage(base, "cache", alice["username"], token, requests=10, hold_s=20)
outage(base, "db", alice["username"], token, requests=16, hold_s=25)
def main():
p = argparse.ArgumentParser()
p.add_argument("--base-url", default="http://localhost:8080")
p.add_argument("--skip-outage", action="store_true")
p.add_argument("--skip-expiry", action="store_true")
args = p.parse_args()
base = args.base_url.rstrip("/")
tests = [
("username_race", lambda: test_username_race(base)),
("chat_rollback", lambda: test_chat_rollback(base)),
("contract_validation", lambda: test_contract_validation(base)),
("pagination_fractional_seconds", lambda: test_pagination_fractional_seconds(base)),
("wrong_password_and_logout", lambda: test_wrong_password_and_logout(base)),
]
if not args.skip_expiry:
tests.append(("expiry", test_expiry))
if not args.skip_outage:
tests.append(("dependency_outage", lambda: test_dependency_outage(base)))
for name, fn in tests:
print(f"== {name} ==")
fn()
print("PASS: level4 checks passed")
if __name__ == "__main__":
try:
main()
except (AssertionError, RuntimeError, subprocess.CalledProcessError) as e:
print("FAIL:", e)
sys.exit(1)