forked from mtusi2026/mtusi2026lab2
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
d824f9474a | ||
|
|
50b30b4b47 |
@@ -20,11 +20,13 @@ __pycache__/
|
||||
node_modules/
|
||||
dist/
|
||||
build/
|
||||
build-*/
|
||||
target/
|
||||
bin/
|
||||
obj/
|
||||
coverage/
|
||||
*.log
|
||||
!evidence/*.log
|
||||
.DS_Store
|
||||
.idea/
|
||||
.vscode/
|
||||
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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-хоста и регулярная автоматическая проверка восстановления.
|
||||
|
||||
|
||||
@@ -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: {}
|
||||
@@ -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]
|
||||
|
||||
@@ -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)
|
||||
```
|
||||
|
||||
@@ -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"
|
||||
@@ -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]
|
||||
|
||||
@@ -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
|
||||
@@ -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]
|
||||
|
||||
@@ -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)
|
||||
```
|
||||
@@ -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)
|
||||
```
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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()
|
||||
Executable
+230
@@ -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()
|
||||
@@ -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()
|
||||
Executable
+27
@@ -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
|
||||
@@ -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)}")
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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);
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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_;
|
||||
};
|
||||
@@ -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
@@ -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
@@ -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;
|
||||
};
|
||||
@@ -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
File diff suppressed because it is too large
Load Diff
@@ -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;
|
||||
}
|
||||
@@ -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_;
|
||||
};
|
||||
@@ -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;
|
||||
};
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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_;
|
||||
};
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
};
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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_;
|
||||
};
|
||||
@@ -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;
|
||||
};
|
||||
@@ -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]);
|
||||
}
|
||||
@@ -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_;
|
||||
};
|
||||
@@ -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()
|
||||
@@ -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
@@ -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)
|
||||
Reference in New Issue
Block a user