diff --git a/.gitignore b/.gitignore index b5a71896..df653e70 100644 --- a/.gitignore +++ b/.gitignore @@ -20,11 +20,13 @@ __pycache__/ node_modules/ dist/ build/ +build-*/ target/ bin/ obj/ coverage/ *.log +!evidence/*.log .DS_Store .idea/ .vscode/ diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 00000000..9b380646 --- /dev/null +++ b/CMakeLists.txt @@ -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 +) \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..f01b5e10 --- /dev/null +++ b/Dockerfile @@ -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"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index e42f2b05..614b2827 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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:` = `user_id`, TTL задан командой `SET ... EX `. 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`, а не реальная последовательность отправки. +- Курсор — `|` последнего элемента страницы. Он сохраняет точное время строки, поэтому пагинация не повторяет сообщения, даже если в БД есть время с долями секунды (импорт, 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 не критичен и не подключается. +- Курсор пагинации: формат `|` с логикой **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: ` без 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-хоста и регулярная автоматическая проверка восстановления. + diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..4ab61269 --- /dev/null +++ b/compose.yaml @@ -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: {} \ No newline at end of file diff --git a/evidence/checks.log b/evidence/checks.log new file mode 100644 index 00000000..68623f78 --- /dev/null +++ b/evidence/checks.log @@ -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] + diff --git a/evidence/explain.md b/evidence/explain.md new file mode 100644 index 00000000..bcf47d19 --- /dev/null +++ b/evidence/explain.md @@ -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) +``` + diff --git a/evidence/level3.log b/evidence/level3.log new file mode 100644 index 00000000..28c43caf --- /dev/null +++ b/evidence/level3.log @@ -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" diff --git a/evidence/level4.log b/evidence/level4.log new file mode 100644 index 00000000..9470a06f --- /dev/null +++ b/evidence/level4.log @@ -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] + diff --git a/evidence/migrations.log b/evidence/migrations.log new file mode 100644 index 00000000..1e1836e0 --- /dev/null +++ b/evidence/migrations.log @@ -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 diff --git a/evidence/persistence.log b/evidence/persistence.log new file mode 100644 index 00000000..8ef8cfaa --- /dev/null +++ b/evidence/persistence.log @@ -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] + diff --git a/evidence/track2_indexes.md b/evidence/track2_indexes.md new file mode 100644 index 00000000..06a22c1f --- /dev/null +++ b/evidence/track2_indexes.md @@ -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) +``` diff --git a/evidence/track2_restore.md b/evidence/track2_restore.md new file mode 100644 index 00000000..e7fccfab --- /dev/null +++ b/evidence/track2_restore.md @@ -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) +``` diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..6c67477d --- /dev/null +++ b/migrations/001_init.sql @@ -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); \ No newline at end of file diff --git a/migrations/002_sessions.sql b/migrations/002_sessions.sql new file mode 100644 index 00000000..2ee49852 --- /dev/null +++ b/migrations/002_sessions.sql @@ -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); \ No newline at end of file diff --git a/scripts/collect_evidence.py b/scripts/collect_evidence.py new file mode 100644 index 00000000..c6ee3d8d --- /dev/null +++ b/scripts/collect_evidence.py @@ -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() diff --git a/scripts/perf.py b/scripts/perf.py new file mode 100755 index 00000000..35659b4f --- /dev/null +++ b/scripts/perf.py @@ -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) .""" + 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() \ No newline at end of file diff --git a/scripts/perf100k.py b/scripts/perf100k.py new file mode 100644 index 00000000..3c67c94d --- /dev/null +++ b/scripts/perf100k.py @@ -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() diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..ae420c7e --- /dev/null +++ b/scripts/restart.sh @@ -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 \ No newline at end of file diff --git a/scripts/track2_common.py b/scripts/track2_common.py new file mode 100644 index 00000000..fe022cbf --- /dev/null +++ b/scripts/track2_common.py @@ -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)}") diff --git a/scripts/track2_indexes.py b/scripts/track2_indexes.py new file mode 100644 index 00000000..e471f717 --- /dev/null +++ b/scripts/track2_indexes.py @@ -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() diff --git a/scripts/track2_restore.py b/scripts/track2_restore.py new file mode 100644 index 00000000..5aa035c8 --- /dev/null +++ b/scripts/track2_restore.py @@ -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() diff --git a/src/auth.cpp b/src/auth.cpp new file mode 100644 index 00000000..d6d8cf95 --- /dev/null +++ b/src/auth.cpp @@ -0,0 +1,39 @@ +#include "auth.hpp" + +#include +#include + + +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; +} \ No newline at end of file diff --git a/src/auth.hpp b/src/auth.hpp new file mode 100644 index 00000000..639b0336 --- /dev/null +++ b/src/auth.hpp @@ -0,0 +1,7 @@ +#pragma once + +#include + +std::string hash_password(const std::string& plain); + +bool verify_password(const std::string& plain, const std::string& hash); \ No newline at end of file diff --git a/src/chat_repo.cpp b/src/chat_repo.cpp new file mode 100644 index 00000000..580fc71b --- /dev/null +++ b/src/chat_repo.cpp @@ -0,0 +1,186 @@ +#include "chat_repo.hpp" +#include "cursor.hpp" + +#include + +#include +#include +#include +#include +#include +#include + +namespace { + +std::string make_uuid() { + static std::mt19937_64 rng{std::random_device{}()}; + std::uniform_int_distribution d16(0, 0xffff); + std::uniform_int_distribution 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(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( + 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(); + c.title = r["title"].as(); + c.created_at = epoch_to_rfc3339(r["created_at_epoch"].as()); + return c; +} + +std::vector load_member_ids(pqxx::work& tx, + const std::string& chat_id) { + std::vector 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()); + } + return ids; +} + +constexpr const char* kChatSelect = + "id, title, " + "EXTRACT(EPOCH FROM created_at)::bigint AS created_at_epoch"; + +} + +std::optional ChatRepo::create(const std::string& title, + const std::vector& 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 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 ChatRepo::list_for_user( + const std::string& user_id, + int limit, + const std::optional& cursor) { + + std::optional 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(r.size()) > limit); + const int take = has_more ? limit : static_cast(r.size()); + page.items.reserve(take); + for (int i = 0; i < take; ++i) { + Chat c = row_to_chat(r[static_cast(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(take - 1)]; + page.next_cursor = make_cursor(last["created_us"].as(), + last["id"].as()); + } + + tx.commit(); + return page; +} \ No newline at end of file diff --git a/src/chat_repo.hpp b/src/chat_repo.hpp new file mode 100644 index 00000000..279e2661 --- /dev/null +++ b/src/chat_repo.hpp @@ -0,0 +1,23 @@ +#pragma once + +#include "db.hpp" +#include "models.hpp" + +#include +#include +#include + +class ChatRepo { +public: + explicit ChatRepo(PgPool& pool) : pool_(pool) {} + + std::optional create(const std::string& title, + const std::vector& member_ids); + + std::optional find_by_id(const std::string& id); + + std::optional list_for_user(const std::string& user_id, int limit, const std::optional& cursor); + +private: + PgPool& pool_; +}; \ No newline at end of file diff --git a/src/cursor.hpp b/src/cursor.hpp new file mode 100644 index 00000000..08f08504 --- /dev/null +++ b/src/cursor.hpp @@ -0,0 +1,47 @@ +#pragma once + +#include +#include +#include +#include +#include + +// Непрозрачный для клиента курсор keyset-пагинации: "|". +// Микросекунды сохраняют точный 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 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; +} diff --git a/src/db.cpp b/src/db.cpp new file mode 100644 index 00000000..e1827f5d --- /dev/null +++ b/src/db.cpp @@ -0,0 +1,339 @@ +#include "db.hpp" +#include "errors.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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 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 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 applied; + { + pqxx::work tx(conn); + for (const auto& row : tx.exec("SELECT version FROM schema_migrations")) { + applied.insert(row[0].as()); + } + 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(&e) != nullptr || + dynamic_cast(&e) != nullptr || + dynamic_cast(&e) != nullptr) { + return true; + } + if (const auto* sql = dynamic_cast(&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 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(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 lk(mu_); + shutting_down_ = true; + } + cv_.notify_all(); +} + + +pqxx::connection* PgPool::take() { + std::unique_lock 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 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 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 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; + } +} \ No newline at end of file diff --git a/src/db.hpp b/src/db.hpp new file mode 100644 index 00000000..2ff20bac --- /dev/null +++ b/src/db.hpp @@ -0,0 +1,64 @@ +#pragma once +#include + +#include + +#include +#include +#include +#include +#include + + +std::string read_secret_file(const char* env_name); + +// connect_timeout и tcp_user_timeout добавляются к conninfo, если не заданы; +// statement_timeout — только для соединений пула (миграции могут быть долгими). +std::unique_ptr 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> all_; + std::vector idle_; + std::mutex mu_; + std::condition_variable cv_; + bool shutting_down_ = false; +}; \ No newline at end of file diff --git a/src/errors.hpp b/src/errors.hpp new file mode 100644 index 00000000..4f9f3c5a --- /dev/null +++ b/src/errors.hpp @@ -0,0 +1,11 @@ +#pragma once + +#include +#include + +// PostgreSQL или Valkey недоступны либо не ответили вовремя: клиент получает 503. +struct DependencyUnavailable : std::runtime_error { + using std::runtime_error::runtime_error; +}; + +bool is_dependency_failure(const std::exception& e); diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 00000000..cea57cb3 --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,1320 @@ +#include "models.hpp" +#include "db.hpp" +#include "auth.hpp" +#include "user_repo.hpp" +#include "chat_repo.hpp" +#include "message_repo.hpp" +#include "redis_pool.hpp" +#include "session_repo.hpp" +#include "pg_session_repo.hpp" +#include "session_repo_base.hpp" +#include "errors.hpp" + + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +static void send_all(int fd, const std::string& data) { + size_t sent = 0; + while (sent < data.size()) { + const ssize_t n = ::write(fd, data.data() + sent, data.size() - sent); + if (n <= 0) { + return; + } + sent += static_cast(n); + } +} + + +static std::string http_response(int status, const char* reason, + const std::string& request_id, + const std::string& body) { + std::string out; + out += "HTTP/1.1 " + std::to_string(status) + " " + reason + "\r\n"; + out += "Content-Type: application/json\r\n"; + out += "X-Request-Id: " + request_id + "\r\n"; + out += "Content-Length: " + std::to_string(body.size()) + "\r\n"; + out += "Connection: close\r\n"; + out += "\r\n"; + out += body; + return out; +} + +static std::string http_no_content(const std::string& request_id) { + std::string out; + out += "HTTP/1.1 204 No Content\r\n"; + out += "X-Request-Id: " + request_id + "\r\n"; + out += "Content-Length: 0\r\n"; + out += "Connection: close\r\n"; + out += "\r\n"; + return out; +} + + +static const char* status_reason(int status) { + switch (status) { + case 400: return "Bad Request"; + case 401: return "Unauthorized"; + case 404: return "Not Found"; + case 409: return "Conflict"; + case 413: return "Payload Too Large"; + case 415: return "Unsupported Media Type"; + case 500: return "Internal Server Error"; + case 503: return "Service Unavailable"; + default: return "Error"; + } +} + + +static std::string error_response(int status, + const std::string& code, + const std::string& message, + const std::string& request_id, + const std::string& www_authenticate = "") { + nlohmann::json j; + j["error"]["code"] = code; + j["error"]["message"] = message; + j["error"]["request_id"] = request_id; + const std::string body = j.dump(); + + std::string head = + "HTTP/1.1 " + std::to_string(status) + " " + + status_reason(status) + "\r\n" + "Content-Type: application/json\r\n" + "X-Request-Id: " + request_id + "\r\n"; + if (status == 401 && !www_authenticate.empty()) { + head += "WWW-Authenticate: " + www_authenticate + "\r\n"; + } + head += "Content-Length: " + std::to_string(body.size()) + "\r\n"; + head += "Connection: close\r\n\r\n"; + return head + body; +} + + +static std::string failure_response(const std::exception& e, const char* what, + const std::string& request_id) { + std::clog << what << " failed: " << e.what() << "\n"; + if (is_dependency_failure(e)) { + return error_response(503, "unavailable", "service unavailable", request_id); + } + return error_response(500, "internal_error", "internal error", request_id); +} + + +static std::optional parse_json_object(const std::string& body) { + nlohmann::json j; + try { + j = nlohmann::json::parse(body); + } catch (const nlohmann::json::exception&) { + return std::nullopt; + } + + if (!j.is_object()) { + return std::nullopt; + } + return j; +} + + +static std::optional find_unexpected_key( + const nlohmann::json& j, + std::initializer_list allowed) { + for (const auto& [key, value] : j.items()) { + bool ok = false; + for (const char* a : allowed) { + if (key == a) { ok = true; break; } + } + + if (!ok) { + return key; + } + } + return std::nullopt; +} + + +static std::optional get_string_field( + const nlohmann::json& j, const char* key) { + auto it = j.find(key); + if (it == j.end() || !it->is_string()) { + return std::nullopt; + } + return it->get(); +} + + +static std::optional> get_string_array( + const nlohmann::json& j, const char* key) { + auto it = j.find(key); + if (it == j.end() || !it->is_array()) { + return std::nullopt; + } + std::vector out; + out.reserve(it->size()); + for (const auto& item : *it) { + if (!item.is_string()) { + return std::nullopt; + } + out.push_back(item.get()); + } + return out; +} + +static bool parse_request_line(const std::string& first_line, + std::string& method, + std::string& path, + std::string& query) { + query.clear(); + const auto sp1 = first_line.find(' '); + if (sp1 == std::string::npos) { + return false; + } + + const auto sp2 = first_line.find(' ', sp1 + 1); + if (sp2 == std::string::npos) { + return false; + } + + method = first_line.substr(0, sp1); + path = first_line.substr(sp1 + 1, sp2 - sp1 - 1); + const auto q = path.find('?'); + if (q != std::string::npos) { + query = path.substr(q + 1); + path.resize(q); + } + return !method.empty() && !path.empty() && path[0] == '/'; +} + +static bool match_id_path(const std::string& path, + const std::string& prefix, + std::string& id) { + if (path.compare(0, prefix.size(), prefix) != 0) { + return false; + } + id = path.substr(prefix.size()); + return !id.empty() && id.find('/') == std::string::npos; +} + + +static bool match_chat_messages(const std::string& path, std::string& chat_id) { + const std::string prefix = "/api/v1/chats/"; + const std::string suffix = "/messages"; + if (path.size() <= prefix.size() + suffix.size()) { + return false; + } + if (path.compare(0, prefix.size(), prefix) != 0) { + return false; + } + if (path.compare(path.size() - suffix.size(), suffix.size(), suffix) != 0) { + return false; + } + chat_id = path.substr(prefix.size(), + path.size() - prefix.size() - suffix.size()); + return !chat_id.empty() && chat_id.find('/') == std::string::npos; +} + + +static std::string to_lower(std::string s) { + for (char& c : s) { + c = static_cast(std::tolower(static_cast(c))); + } + return s; +} + + +static std::optional utf8_cps(const std::string& s) { + size_t i = 0; + size_t n = 0; + while (i < s.size()) { + const unsigned char c = static_cast(s[i]); + size_t w = 1; + if (c >= 0x80) { + if ((c & 0xE0) == 0xC0) w = 2; + else if ((c & 0xF0) == 0xE0) w = 3; + else if ((c & 0xF8) == 0xF0) w = 4; + else return std::nullopt; + if (i + w > s.size()) return std::nullopt; + for (size_t k = 1; k < w; ++k) { + if ((static_cast(s[i + k]) & 0xC0) != 0x80) { + return std::nullopt; + } + } + } + ++n; + i += w; + } + return n; +} + + +static bool cps_in_range(const std::string& s, size_t lo, size_t hi) { + const auto n = utf8_cps(s); + return n && *n >= lo && *n <= hi; +} + + +static std::unordered_map parse_headers( + const std::string& request, std::string::size_type after_first_line) { + std::unordered_map headers; + auto pos = after_first_line; + if (pos < request.size() && request.compare(pos, 2, "\r\n") == 0) { + pos += 2; + } + for (;;) { + const auto eol = request.find("\r\n", pos); + if (eol == std::string::npos || eol == pos) { + break; + } + const std::string line = request.substr(pos, eol - pos); + pos = eol + 2; + const auto colon = line.find(':'); + if (colon == std::string::npos) { + continue; + } + std::string name = to_lower(line.substr(0, colon)); + std::string value = line.substr(colon + 1); + while (!value.empty() && (value[0] == ' ' || value[0] == '\t')) { + value.erase(0, 1); + } + headers[name] = value; + } + return headers; +} + + +static std::string user_json(const User& user) { + nlohmann::json j; + j["id"] = user.id; + j["username"] = user.username; + j["display_name"] = user.display_name; + j["created_at"] = user.created_at; + return j.dump(); +} + + +static std::string message_json(const Message& msg) { + nlohmann::json j; + j["id"] = msg.id; + j["chat_id"] = msg.chat_id; + j["sender_id"] = msg.sender_id; + j["text"] = msg.text; + j["created_at"] = msg.created_at; + return j.dump(); +} + + +static std::string chat_json(const Chat& chat) { + nlohmann::json j; + j["id"] = chat.id; + j["title"] = chat.title; + j["member_ids"] = chat.member_ids; + j["created_at"] = chat.created_at; + return j.dump(); +} + + +static std::string messages_page_json(const MessagePage& msgs) { + nlohmann::json j; + j["items"] = nlohmann::json::array(); + for (const auto& m : msgs.items) { + j["items"].push_back(nlohmann::json::parse(message_json(m))); + } + if (msgs.next_cursor) { + j["next_cursor"] = *msgs.next_cursor; + } else { + j["next_cursor"] = nullptr; + } + return j.dump(); +} + + +static std::string chats_page_json(const ChatPage& page) { + nlohmann::json j; + j["items"] = nlohmann::json::array(); + for (const auto& c : page.items) { + j["items"].push_back(nlohmann::json::parse(chat_json(c))); + } + if (page.next_cursor) { + j["next_cursor"] = *page.next_cursor; + } else { + j["next_cursor"] = nullptr; + } + return j.dump(); +} + + +static bool is_json_content_type(const std::string& raw) { + std::string s = to_lower(raw); + const auto sc = s.find(';'); + if (sc != std::string::npos) { + s.resize(sc); + } + while (!s.empty() && (s.back() == ' ' || s.back() == '\t')) { + s.pop_back(); + } + size_t a = 0; + while (a < s.size() && (s[a] == ' ' || s[a] == '\t')) { + ++a; + } + return s.substr(a) == "application/json"; +} + + +static int hex_val(char c) { + if (c >= '0' && c <= '9') return c - '0'; + if (c >= 'a' && c <= 'f') return c - 'a' + 10; + if (c >= 'A' && c <= 'F') return c - 'A' + 10; + return -1; +} + + +static bool json_content_type_ok( + const std::unordered_map& headers) { + const auto it = headers.find("content-type"); + return it != headers.end() && is_json_content_type(it->second); +} + + +static bool contains_nul(const std::string& s) { + return s.find('\0') != std::string::npos; +} + +static bool is_unicode_space(uint32_t cp) { + if (cp <= 0x7F) { + return std::isspace(static_cast(cp)) != 0; + } + if (cp >= 0x2000 && cp <= 0x200A) { + return true; + } + switch (cp) { + case 0x00A0: + case 0x1680: + case 0x2028: + case 0x2029: + case 0x202F: + case 0x205F: + case 0x3000: + case 0xFEFF: + return true; + default: + return false; + } +} + +static bool is_blank(const std::string& s) { + size_t i = 0; + while (i < s.size()) { + const unsigned char c = static_cast(s[i]); + uint32_t cp = c; + size_t w = 1; + if (c >= 0x80) { + if ((c & 0xE0) == 0xC0 && i + 1 < s.size()) { + w = 2; + cp = (static_cast(c & 0x1F) << 6) + | (static_cast(s[i + 1]) & 0x3F); + } else if ((c & 0xF0) == 0xE0 && i + 2 < s.size()) { + w = 3; + cp = (static_cast(c & 0x0F) << 12) + | ((static_cast(s[i + 1]) & 0x3F) << 6) + | (static_cast(s[i + 2]) & 0x3F); + } else if ((c & 0xF8) == 0xF0 && i + 3 < s.size()) { + w = 4; + cp = (static_cast(c & 0x07) << 18) + | ((static_cast(s[i + 1]) & 0x3F) << 12) + | ((static_cast(s[i + 2]) & 0x3F) << 6) + | (static_cast(s[i + 3]) & 0x3F); + } else { + return false; + } + } + if (!is_unicode_space(cp)) { + return false; + } + i += w; + } + return true; +} + + +static bool valid_username(const std::string& s) { + static const std::regex re("^[a-z0-9_]{3,32}$"); + return std::regex_match(s, re); +} + + +static bool valid_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); +} + + +static bool has_duplicate_ids(const std::vector& ids) { + std::unordered_set seen; + for (const auto& id : ids) { + if (!seen.insert(to_lower(id)).second) { + return true; + } + } + return false; +} + + +static std::string url_decode(const std::string& s) { + std::string out; + for (size_t i = 0; i < s.size(); ++i) { + if (s[i] == '%' && i + 2 < s.size()) { + const int hi = hex_val(s[i + 1]); + const int lo = hex_val(s[i + 2]); + if (hi >= 0 && lo >= 0) { + out.push_back(static_cast((hi << 4) | lo)); + i += 2; + continue; + } + } + out.push_back(s[i] == '+' ? ' ' : s[i]); + } + return out; +} + + +static std::unordered_map parse_query( + const std::string& query) { + std::unordered_map out; + size_t pos = 0; + while (pos < query.size()) { + auto amp = query.find('&', pos); + if (amp == std::string::npos) { + amp = query.size(); + } + const auto pair = query.substr(pos, amp - pos); + const auto eq = pair.find('='); + if (eq != std::string::npos) { + out[url_decode(pair.substr(0, eq))] = + url_decode(pair.substr(eq + 1)); + } + pos = amp + 1; + } + return out; +} + + +static std::atomic g_listen{-1}; +static std::atomic g_stop{false}; +static std::mutex g_live_mu; +static std::unordered_set g_live; + +static void set_timeouts(int fd) { + timeval tv{}; + tv.tv_sec = 2; + tv.tv_usec = 0; + ::setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); + ::setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)); +} + +static void live_add(int fd) { + std::lock_guard lk(g_live_mu); + g_live.insert(fd); +} + +static void live_del(int fd) { + std::lock_guard lk(g_live_mu); + g_live.erase(fd); +} + +static void shutdown_all_clients() { + std::lock_guard lk(g_live_mu); + for (int c : g_live) { + ::shutdown(c, SHUT_RDWR); + } +} + + +static std::string read_request(int client, bool& too_large) { + too_large = false; + std::string request; + char buf[4096]; + constexpr std::size_t kMaxBody = 1048576; + for (;;) { + if (g_stop.load()) { + return {}; + } + const ssize_t n = ::read(client, buf, sizeof(buf)); + if (n < 0) { + if (errno == EINTR) { + continue; + } + return {}; + } + if (n == 0) { + return request; + } + request.append(buf, static_cast(n)); + const auto hdr = request.find("\r\n\r\n"); + if (hdr == std::string::npos) { + continue; + } + std::size_t content_length = 0; + const auto cl = to_lower(request).find("content-length:"); + if (cl != std::string::npos && cl < hdr) { + const auto line_end = request.find("\r\n", cl); + const auto colon = request.find(':', cl); + if (line_end != std::string::npos && colon < line_end) { + content_length = static_cast( + std::atoi(request.c_str() + colon + 1)); + } + } + if (content_length > kMaxBody) { + too_large = true; + request.resize(hdr + 4); + return request; + } + const auto need = hdr + 4 + content_length; + if (request.size() >= need) { + request.resize(need); + return request; + } + } +} + +static std::optional> parse_basic_auth( + const std::string& header_value) { + + static const std::string prefix = "Basic "; + if (header_value.size() <= prefix.size() || + header_value.compare(0, prefix.size(), prefix) != 0) { + return std::nullopt; + } + const std::string b64 = header_value.substr(prefix.size()); + + auto b64_val = [](char c) -> int { + if (c >= 'A' && c <= 'Z') return c - 'A'; + if (c >= 'a' && c <= 'z') return c - 'a' + 26; + if (c >= '0' && c <= '9') return c - '0' + 52; + if (c == '+') return 62; + if (c == '/') return 63; + return -1; + }; + + std::string decoded; + int buf = 0, bits = 0; + for (char c : b64) { + if (c == '=') break; + const int v = b64_val(c); + if (v < 0) return std::nullopt; + buf = (buf << 6) | v; + bits += 6; + if (bits >= 8) { + bits -= 8; + decoded.push_back(static_cast((buf >> bits) & 0xFF)); + } + } + + const auto colon = decoded.find(':'); + if (colon == std::string::npos) { + return std::nullopt; + } + return std::make_pair(decoded.substr(0, colon), + decoded.substr(colon + 1)); +} + +static void handle_client(int client, + std::atomic& request_n, + UserRepo& users, + ChatRepo& chats, + MessageRepo& messages, + ISessionRepo& sessions, + PgPool& pg, + RedisPool* redis) { + bool too_large = false; + const std::string request = read_request(client, too_large); + const unsigned nreq = ++request_n; + const std::string request_id = std::to_string(nreq); + + if (too_large) { + send_all(client, error_response(413, "payload_too_large", + "payload too large", request_id)); + live_del(client); + ::close(client); + return; + } + if (request.empty()) { + live_del(client); + ::close(client); + return; + } + + const auto line_end = request.find("\r\n"); + const std::string first_line = request.substr(0, line_end); + std::string method; + std::string path; + std::string query; + if (!parse_request_line(first_line, method, path, query)) { + send_all(client, error_response(400, "invalid_request", + "bad request line", request_id)); + live_del(client); + ::close(client); + return; + } + + const auto headers = parse_headers(request, line_end); + std::string user_id; + std::string bearer_token; + bool auth_backend_error = false; + { + auto it = headers.find("authorization"); + if (it != headers.end()) { + static const std::string prefix = "Bearer "; + const std::string& auth = it->second; + if (auth.size() > prefix.size() && + auth.compare(0, prefix.size(), prefix) == 0) { + bearer_token = auth.substr(prefix.size()); + } + } + if (!bearer_token.empty()) { + try { + auto found = sessions.lookup(bearer_token); + if (found) { + user_id = *found; + } + } catch (const std::exception& e) { + std::clog << "session lookup failed: " << e.what() << "\n"; + auth_backend_error = true; + } + } + } + auto send_auth_error = [&]() -> bool { + if (auth_backend_error) { + send_all(client, error_response(503, "unavailable", + "service unavailable", request_id)); + return true; + } + if (user_id.empty()) { + send_all(client, error_response(401, "unauthorized", + "unauthorized", request_id, + "Bearer realm=\"messenger\"")); + return true; + } + return false; + }; + // Сессия может пережить пользователя; недоступная БД — это 503, а не 401. + auto send_user_error = [&]() -> bool { + try { + if (users.find_by_id(user_id)) { + return false; + } + send_all(client, error_response(401, "unauthorized", + "unauthorized", request_id, + "Bearer realm=\"messenger\"")); + } catch (const std::exception& e) { + send_all(client, failure_response(e, "find_user", request_id)); + } + return true; + }; + + std::string chat_id; + + if (method == "GET" && path == "/health/live") { + send_all(client, http_response(200, "OK", request_id, "{\"status\":\"ok\"}")); + } + else if (method == "GET" && path == "/health/ready") { + const bool pg_ok = pg.ping(); + const bool redis_ok = redis == nullptr || redis->ping(); + if (pg_ok && redis_ok) { + send_all(client, http_response(200, "OK", request_id, "{\"status\":\"ok\"}")); + } else { + std::clog << "readiness failed: pg=" << pg_ok + << " redis=" << redis_ok << "\n"; + send_all(client, error_response(503, "unavailable", + "service unavailable", request_id)); + } + } + else if (method == "POST" && path == "/api/v1/auth/sessions") { + const auto body_at = request.find("\r\n\r\n"); + const std::string session_body = + body_at == std::string::npos ? "" : request.substr(body_at + 4); + if (!session_body.empty()) { + send_all(client, error_response(400, "invalid_request", + "body not allowed", request_id)); + } else { + auto it = headers.find("authorization"); + std::optional> creds; + if (it != headers.end()) { + creds = parse_basic_auth(it->second); + } + + const auto send_basic_401 = [&]() { + send_all(client, error_response( + 401, "unauthorized", "unauthorized", request_id, + "Basic realm=\"messenger\", charset=\"UTF-8\"")); + }; + + if (!creds) { + send_basic_401(); + } else { + const auto& username = creds->first; + const auto& password = creds->second; + try { + const auto user = users.find_by_username(username); + if (!user || !verify_password(password, user->password_hash)) { + send_basic_401(); + } else { + const auto created = sessions.create(user->id); + nlohmann::json j; + j["token"] = created.token; + j["token_type"] = "Bearer"; + const std::time_t t = static_cast( + created.expires_at); + std::tm tm{}; + gmtime_r(&t, &tm); + std::ostringstream out; + out << std::put_time(&tm, "%Y-%m-%dT%H:%M:%SZ"); + j["expires_at"] = out.str(); + j["user"] = nlohmann::json::parse(user_json(*user)); + send_all(client, http_response(201, "Created", + request_id, j.dump())); + } + } catch (const std::exception& e) { + send_all(client, failure_response(e, "create_session", request_id)); + } + } + } + } + else if (method == "GET" && path == "/api/v1/users/me") { + if (send_auth_error()) { + } else { + try { + const auto user = users.find_by_id(user_id); + if (!user) { + send_all(client, error_response(401, "unauthorized", + "unauthorized", request_id, + "Bearer realm=\"messenger\"")); + } else { + send_all(client, http_response(200, "OK", request_id, + user_json(*user))); + } + } catch (const std::exception& e) { + send_all(client, failure_response(e, "find_user", request_id)); + } + } + } + else if (method == "POST" && path == "/api/v1/users") { + if (!json_content_type_ok(headers)) { + send_all(client, error_response(415, "unsupported_media_type", + "unsupported media type", request_id)); + } else { + const auto body_at = request.find("\r\n\r\n"); + const std::string body = + body_at == std::string::npos ? "" : request.substr(body_at + 4); + + const auto j = parse_json_object(body); + if (!j) { + send_all(client, error_response(400, "invalid_request", + "invalid json", request_id)); + } else if (auto bad = find_unexpected_key( + *j, {"username", "display_name", "password"})) { + send_all(client, error_response(400, "invalid_request", + "unexpected field: " + *bad, request_id)); + } else { + const auto username = get_string_field(*j, "username"); + const auto display_name = get_string_field(*j, "display_name"); + const auto password = get_string_field(*j, "password"); + if (!username || !display_name || !password) { + send_all(client, error_response(400, "invalid_request", + "invalid fields", request_id)); + } else if (!valid_username(*username) || + contains_nul(*display_name) || + is_blank(*display_name) || + !cps_in_range(*display_name, 1, 100)) { + send_all(client, error_response(400, "invalid_request", + "invalid fields", request_id)); + } else if (contains_nul(*password) || + !cps_in_range(*password, 12, 128)) { + send_all(client, error_response(400, "invalid_request", + "invalid password", request_id)); + } else { + std::string hash; + try { + hash = hash_password(*password); + } catch (const std::exception& e) { + send_all(client, failure_response(e, "hash_password", request_id)); + } + if (!hash.empty()) { + try { + const auto created = users.create(*username, + *display_name, hash); + if (!created) { + send_all(client, error_response(409, "conflict", + "username taken", request_id)); + } else { + send_all(client, http_response(201, "Created", request_id, + user_json(*created))); + } + } catch (const std::exception& e) { + send_all(client, failure_response(e, "create_user", request_id)); + } + } + } + } + } + } + else if (method == "POST" && path == "/api/v1/chats") { + if (send_auth_error()) { + // ответ отправлен + } else if (send_user_error()) { + // ответ отправлен + } else if (!json_content_type_ok(headers)) { + send_all(client, error_response(415, "unsupported_media_type", + "unsupported media type", request_id)); + } else { + const auto body_at = request.find("\r\n\r\n"); + const std::string body = + body_at == std::string::npos ? "" : request.substr(body_at + 4); + + const auto j = parse_json_object(body); + if (!j) { + send_all(client, error_response(400, "invalid_request", + "invalid json", request_id)); + } else if (auto bad = find_unexpected_key(*j, {"title", "member_ids"})) { + send_all(client, error_response(400, "invalid_request", + "unexpected field: " + *bad, request_id)); + } else { + const auto title = get_string_field(*j, "title"); + const auto member_ids = get_string_array(*j, "member_ids"); + if (!title || !member_ids) { + send_all(client, error_response(400, "invalid_request", + "invalid fields", request_id)); + } else if (contains_nul(*title) || is_blank(*title) || + !cps_in_range(*title, 1, 100)) { + send_all(client, error_response(400, "invalid_request", + "invalid fields", request_id)); + } else if (member_ids->empty() || member_ids->size() > 100) { + send_all(client, error_response(400, "invalid_request", + "invalid members", request_id)); + } else if (std::find(member_ids->begin(), member_ids->end(), + user_id) == member_ids->end()) { + send_all(client, error_response(400, "invalid_request", + "caller not in members", request_id)); + } else if (!std::all_of(member_ids->begin(), member_ids->end(), + valid_uuid)) { + send_all(client, error_response(400, "invalid_request", + "invalid members", request_id)); + } else if (has_duplicate_ids(*member_ids)) { + send_all(client, error_response(400, "invalid_request", + "duplicate members", request_id)); + } else { + try { + const auto created = chats.create(*title, *member_ids); + if (!created) { + send_all(client, error_response(400, "invalid_request", + "invalid members", request_id)); + } else { + send_all(client, http_response(201, "Created", request_id, + chat_json(*created))); + } + } catch (const std::exception& e) { + send_all(client, failure_response(e, "create_chat", request_id)); + } + } + } + } + } + else if (method == "POST" && match_chat_messages(path, chat_id)) { + if (send_auth_error()) { + // ответ отправлен + } else if (send_user_error()) { + // ответ отправлен + } else if (!valid_uuid(chat_id)) { + send_all(client, error_response(400, "invalid_request", + "invalid chat id", request_id)); + } else { + try { + const auto chat = chats.find_by_id(chat_id); + const bool is_member = chat && + (std::find(chat->member_ids.begin(), + chat->member_ids.end(), + user_id) != chat->member_ids.end()); + if (!is_member) { + send_all(client, error_response(404, "not_found", + "not found", request_id)); + } else if (!json_content_type_ok(headers)) { + send_all(client, error_response(415, "unsupported_media_type", + "unsupported media type", request_id)); + } else { + const auto body_at = request.find("\r\n\r\n"); + const std::string body = + body_at == std::string::npos ? "" : request.substr(body_at + 4); + + const auto j = parse_json_object(body); + if (!j) { + send_all(client, error_response(400, "invalid_request", + "invalid json", request_id)); + } else if (auto bad = find_unexpected_key(*j, {"text"})) { + send_all(client, error_response(400, "invalid_request", + "unexpected field: " + *bad, request_id)); + } else { + const auto text = get_string_field(*j, "text"); + if (!text) { + send_all(client, error_response(400, "invalid_request", + "invalid fields", request_id)); + } else if (contains_nul(*text) || is_blank(*text) || + !cps_in_range(*text, 1, 4000)) { + send_all(client, error_response(400, "invalid_request", + "invalid fields", request_id)); + } else { + const auto created = messages.create(chat_id, user_id, *text); + if (!created) { + send_all(client, error_response(404, "not_found", + "not found", request_id)); + } else { + send_all(client, http_response(201, "Created", request_id, + message_json(*created))); + } + } + } + } + } catch (const std::exception& e) { + send_all(client, failure_response(e, "post_message", request_id)); + } + } + } + else if (method == "GET" && match_chat_messages(path, chat_id)) { + if (send_auth_error()) { + } else if (send_user_error()) { + // ответ отправлен + } else if (!valid_uuid(chat_id)) { + send_all(client, error_response(400, "invalid_request", + "invalid chat id", request_id)); + } else { + try { + const auto chat = chats.find_by_id(chat_id); + const bool is_member = chat && + (std::find(chat->member_ids.begin(), + chat->member_ids.end(), + user_id) != chat->member_ids.end()); + if (!is_member) { + send_all(client, error_response(404, "not_found", + "not found", request_id)); + } else { + const auto params = parse_query(query); + int limit = 50; + bool bad_limit = false; + if (params.count("limit")) { + try { + std::size_t consumed = 0; + limit = std::stoi(params.at("limit"), &consumed); + if (consumed != params.at("limit").size() || + limit < 1 || limit > 100) { + bad_limit = true; + } + } catch (...) { + bad_limit = true; + } + } + std::optional cursor; + if (params.count("cursor")) { + cursor = params.at("cursor"); + } + if (bad_limit || (cursor && cursor->empty())) { + send_all(client, error_response(400, "invalid_request", + "bad query", request_id)); + } else { + const auto page = messages.list_page(chat_id, limit, cursor); + if (!page) { + send_all(client, error_response(400, "invalid_request", + "bad cursor", request_id)); + } else { + send_all(client, http_response(200, "OK", + request_id, + messages_page_json(*page))); + } + } + } + } catch (const std::exception& e) { + send_all(client, failure_response(e, "list_messages", request_id)); + } + } + } + else if (method == "GET" && path == "/api/v1/chats") { + if (send_auth_error()) { + // ответ отправлен + } else if (send_user_error()) { + // ответ отправлен + } else { + const auto params = parse_query(query); + int limit = 50; + bool bad_limit = false; + if (params.count("limit")) { + try { + std::size_t consumed = 0; + limit = std::stoi(params.at("limit"), &consumed); + if (consumed != params.at("limit").size() || + limit < 1 || limit > 100) { + bad_limit = true; + } + } catch (...) { + bad_limit = true; + } + } + std::optional cursor; + if (params.count("cursor")) { + cursor = params.at("cursor"); + } + if (bad_limit || (cursor && cursor->empty())) { + send_all(client, error_response(400, "invalid_request", + "bad query", request_id)); + } else { + try { + const auto page = chats.list_for_user(user_id, limit, cursor); + if (!page) { + send_all(client, error_response(400, "invalid_request", + "bad cursor", request_id)); + } else { + send_all(client, http_response(200, "OK", request_id, + chats_page_json(*page))); + } + } catch (const std::exception& e) { + send_all(client, failure_response(e, "list_chats", request_id)); + } + } + } + } + else if (method == "GET" && match_id_path(path, "/api/v1/chats/", chat_id)) { + if (send_auth_error()) { + // ответ отправлен + } else if (send_user_error()) { + // ответ отправлен + } else if (!valid_uuid(chat_id)) { + send_all(client, error_response(400, "invalid_request", + "invalid chat id", request_id)); + } else { + try { + const auto chat = chats.find_by_id(chat_id); + const bool is_member = chat && + (std::find(chat->member_ids.begin(), + chat->member_ids.end(), + user_id) != chat->member_ids.end()); + if (!is_member) { + send_all(client, error_response(404, "not_found", + "not found", request_id)); + } else { + send_all(client, http_response(200, "OK", request_id, + chat_json(*chat))); + } + } catch (const std::exception& e) { + send_all(client, failure_response(e, "find_chat", request_id)); + } + } + } else if (method == "DELETE" && path == "/api/v1/auth/sessions/current") { + if (send_auth_error()) { + } else { + try { + sessions.revoke(bearer_token); + send_all(client, http_no_content(request_id)); + } catch (const std::exception& e) { + send_all(client, failure_response(e, "revoke_session", request_id)); + } + } + } + else { + send_all(client, error_response(404, "not_found", "not found", request_id)); + } + + live_del(client); + ::close(client); +} + +int main() { + const char* host_env = std::getenv("APP_HOST"); + const char* port_env = std::getenv("APP_PORT"); + const char* host = host_env ? host_env : "0.0.0.0"; + const int port = port_env ? std::atoi(port_env) : 8080; + + sigset_t set; + sigemptyset(&set); + sigaddset(&set, SIGTERM); + sigaddset(&set, SIGINT); + if (pthread_sigmask(SIG_BLOCK, &set, nullptr) != 0) { + std::cerr << "pthread_sigmask failed" << std::endl; + return 1; + } + + const std::string db_url = read_secret_file("DATABASE_URL_FILE"); + std::clog << "connecting to db...\n"; + { + auto conn = open_pg_connection(db_url, false); + std::clog << "applying migrations...\n"; + apply_migrations(*conn, "./migrations"); + std::clog << "migrations ok\n"; + } + + PgPool pool(db_url, 8); + std::clog << "pg pool ready (8 connections)\n"; + + UserRepo users(pool); + ChatRepo chats(pool); + MessageRepo messages(pool); + + const char* ttl_env = std::getenv("SESSION_TTL_SECONDS"); + const int ttl_seconds = ttl_env ? std::atoi(ttl_env) : 3600; + + const char* store_env = std::getenv("SESSION_STORE"); + const std::string store = store_env ? store_env : "redis"; + + std::unique_ptr redis_pool; + std::unique_ptr sessions; + if (store == "postgres") { + sessions = std::make_unique(pool, ttl_seconds); + std::clog << "session store: postgres\n"; + } else if (store == "redis") { + redis_pool = std::make_unique(read_secret_file("CACHE_URL_FILE"), 4); + std::clog << "redis pool ready (4 connections)\n"; + sessions = std::make_unique(*redis_pool, ttl_seconds); + std::clog << "session store: redis\n"; + } else { + throw std::runtime_error("unknown SESSION_STORE: " + store); + } + std::clog << "session ttl: " << ttl_seconds << "s\n"; + + const int fd = ::socket(AF_INET, SOCK_STREAM, 0); + if (fd < 0) { + std::cerr << "socket failed" << std::endl; + return 1; + } + + const int yes = 1; + ::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)); + + sockaddr_in addr{}; + addr.sin_family = AF_INET; + addr.sin_port = htons(static_cast(port)); + if (::inet_pton(AF_INET, host, &addr.sin_addr) != 1) { + std::cerr << "invalid APP_HOST" << std::endl; + ::close(fd); + return 1; + } + + if (::bind(fd, reinterpret_cast(&addr), sizeof(addr)) != 0) { + std::cerr << "bind failed on " << host << ":" << port << std::endl; + ::close(fd); + return 1; + } + + if (::listen(fd, 16) != 0) { + std::cerr << "listen failed" << std::endl; + ::close(fd); + return 1; + } + + g_listen.store(fd); + + std::clog << "listening on " << host << ":" << port << std::endl; + + std::atomic request_n{0}; + std::mutex q_mu; + std::condition_variable q_cv; + std::queue q; + const int workers_n = 8; + std::vector workers; + for (int i = 0; i < workers_n; ++i) { + workers.emplace_back([&]() { + for (;;) { + int client = -1; + { + std::unique_lock lk(q_mu); + q_cv.wait(lk, [&]() { return g_stop.load() || !q.empty(); }); + if (g_stop.load() && q.empty()) { + return; + } + client = q.front(); + q.pop(); + } + try { + handle_client(client, request_n, users, chats, messages, *sessions, pool, redis_pool.get()); + } catch (const std::exception& e) { + std::clog << "unhandled request error: " << e.what() << "\n"; + send_all(client, error_response(500, "internal_error", + "internal error", + std::to_string(request_n.load()))); + live_del(client); + ::close(client); + } catch (...) { + live_del(client); + ::close(client); + } + } + }); + } + + std::thread signal_thread([&]() { + int sig = 0; + if (sigwait(&set, &sig) != 0) { + return; + } + g_stop.store(true); + const int lfd = g_listen.load(); + if (lfd >= 0) { + ::shutdown(lfd, SHUT_RDWR); + } + shutdown_all_clients(); + }); + + for (;;) { + const int client = ::accept(fd, nullptr, nullptr); + if (client < 0) { + if (g_stop.load()) { + std::clog << "shutting down\n"; + break; + } + std::cerr << "accept failed\n"; + break; + } + set_timeouts(client); + live_add(client); + { + std::lock_guard lk(q_mu); + q.push(client); + } + q_cv.notify_one(); + } + { + std::lock_guard lk(q_mu); + g_stop.store(true); + } + q_cv.notify_all(); + for (auto& t : workers) { + t.join(); + } + signal_thread.detach(); + + ::close(fd); + std::clog << "stopped\n"; + return 0; +} \ No newline at end of file diff --git a/src/message_repo.cpp b/src/message_repo.cpp new file mode 100644 index 00000000..aafd50b2 --- /dev/null +++ b/src/message_repo.cpp @@ -0,0 +1,146 @@ +#include "message_repo.hpp" +#include "cursor.hpp" + +#include + +#include +#include +#include +#include +#include +#include + +namespace { + +std::string make_uuid() { + static std::mt19937_64 rng{std::random_device{}()}; + std::uniform_int_distribution d16(0, 0xffff); + std::uniform_int_distribution 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(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( + 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(); + m.chat_id = r["chat_id"].as(); + m.sender_id = r["sender_id"].as(); + m.text = r["text"].as(); + m.created_at = epoch_to_rfc3339(r["created_at_epoch"].as()); + return m; +} + +constexpr const char* kMessageSelect = + "id, chat_id, sender_id, text, " + "EXTRACT(EPOCH FROM created_at)::bigint AS created_at_epoch"; + +} + +std::optional 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 MessageRepo::list_page( + const std::string& chat_id, + int limit, + const std::optional& cursor) { + + std::optional 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(r.size()) > limit); + const int take = has_more ? limit : static_cast(r.size()); + page.items.reserve(take); + for (int i = 0; i < take; ++i) { + page.items.push_back(row_to_message(r[static_cast(i)])); + } + + if (has_more && take > 0) { + const auto& last = r[static_cast(take - 1)]; + page.next_cursor = make_cursor(last["created_us"].as(), + last["id"].as()); + } + + tx.commit(); + return page; +} \ No newline at end of file diff --git a/src/message_repo.hpp b/src/message_repo.hpp new file mode 100644 index 00000000..209cec8f --- /dev/null +++ b/src/message_repo.hpp @@ -0,0 +1,25 @@ +#pragma once + +#include "db.hpp" +#include "models.hpp" + +#include +#include +#include + +class MessageRepo { +public: + explicit MessageRepo(PgPool& pool) : pool_(pool) {} + + std::optional create(const std::string& chat_id, + const std::string& sender_id, + const std::string& text); + + std::optional list_page( + const std::string& chat_id, + int limit, + const std::optional& cursor); + +private: + PgPool& pool_; +}; \ No newline at end of file diff --git a/src/models.hpp b/src/models.hpp new file mode 100644 index 00000000..87c3fe30 --- /dev/null +++ b/src/models.hpp @@ -0,0 +1,38 @@ +#pragma once + +#include +#include +#include + +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 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 items; + std::optional next_cursor; +}; + +struct ChatPage { + std::vector items; + std::optional next_cursor; +}; \ No newline at end of file diff --git a/src/pg_session_repo.cpp b/src/pg_session_repo.cpp new file mode 100644 index 00000000..507f2ddd --- /dev/null +++ b/src/pg_session_repo.cpp @@ -0,0 +1,66 @@ +#include "pg_session_repo.hpp" + +#include +#include + +#include +#include +#include + +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::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 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(); +} + +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; +} \ No newline at end of file diff --git a/src/pg_session_repo.hpp b/src/pg_session_repo.hpp new file mode 100644 index 00000000..ed005fec --- /dev/null +++ b/src/pg_session_repo.hpp @@ -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 lookup(const std::string& token) override; + bool revoke(const std::string& token) override; + +private: + PgPool& pool_; + int ttl_; +}; \ No newline at end of file diff --git a/src/redis_pool.cpp b/src/redis_pool.cpp new file mode 100644 index 00000000..035b5f20 --- /dev/null +++ b/src/redis_pool.cpp @@ -0,0 +1,216 @@ +#include "redis_pool.hpp" +#include "errors.hpp" + +#include +#include +#include +#include + +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( + 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( + 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 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 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(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 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 lk(mu_); + idle_.push_back(c); + } + cv_.notify_one(); +} + +bool RedisPool::ping() { + try { + auto lease = acquire(); + redisContext* c = lease.ctx(); + redisReply* r = static_cast(redisCommand(c, "PING")); + if (r == nullptr) return false; + const bool ok = (r->type == REDIS_REPLY_STATUS); + freeReplyObject(r); + return ok; + } catch (...) { + return false; + } +} \ No newline at end of file diff --git a/src/redis_pool.hpp b/src/redis_pool.hpp new file mode 100644 index 00000000..00323151 --- /dev/null +++ b/src/redis_pool.hpp @@ -0,0 +1,59 @@ +#pragma once + +#include + +#include +#include +#include +#include +#include +#include + +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* take(); + void give_back(redisContext* c); + + std::string url_; + std::vector all_; + std::vector idle_; + std::mutex mu_; + std::condition_variable cv_; + bool shutting_down_ = false; +}; \ No newline at end of file diff --git a/src/session_repo.cpp b/src/session_repo.cpp new file mode 100644 index 00000000..28f1edbb --- /dev/null +++ b/src/session_repo.cpp @@ -0,0 +1,87 @@ +#include "session_repo.hpp" +#include "errors.hpp" + +#include + +#include +#include +#include +#include + +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::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( + 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 SessionRepo::lookup(const std::string& token) { + auto lease = pool_.acquire(); + redisContext* c = lease.ctx(); + + redisReply* r = static_cast( + redisCommand(c, "GET session:%s", token.c_str())); + check_reply(c, r); + + std::optional 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( + 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; +} \ No newline at end of file diff --git a/src/session_repo.hpp b/src/session_repo.hpp new file mode 100644 index 00000000..550eae6b --- /dev/null +++ b/src/session_repo.hpp @@ -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 lookup(const std::string& token) override; + bool revoke(const std::string& token) override; + +private: + RedisPool& pool_; + int ttl_; +}; \ No newline at end of file diff --git a/src/session_repo_base.hpp b/src/session_repo_base.hpp new file mode 100644 index 00000000..4a685ba2 --- /dev/null +++ b/src/session_repo_base.hpp @@ -0,0 +1,22 @@ +#pragma once + +#include +#include +#include + + +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 lookup(const std::string& token) = 0; + + virtual bool revoke(const std::string& token) = 0; +}; \ No newline at end of file diff --git a/src/user_repo.cpp b/src/user_repo.cpp new file mode 100644 index 00000000..2cc4bc9c --- /dev/null +++ b/src/user_repo.cpp @@ -0,0 +1,100 @@ +#include "user_repo.hpp" + +#include + +#include +#include +#include +#include +#include +#include + +namespace { + +std::string make_uuid() { + static std::mt19937_64 rng{std::random_device{}()}; + std::uniform_int_distribution d16(0, 0xffff); + std::uniform_int_distribution 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(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( + 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(); + u.username = r["username"].as(); + u.display_name = r["display_name"].as(); + u.password_hash = r["password_hash"].as(); + u.created_at = epoch_to_rfc3339(r["created_at_epoch"].as()); + return u; +} + +constexpr const char* kUserColumns = + "id, username, display_name, password_hash, " + "EXTRACT(EPOCH FROM created_at)::bigint AS created_at_epoch"; + +} + +std::optional 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 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 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]); +} \ No newline at end of file diff --git a/src/user_repo.hpp b/src/user_repo.hpp new file mode 100644 index 00000000..b8cbada2 --- /dev/null +++ b/src/user_repo.hpp @@ -0,0 +1,22 @@ +#pragma once + +#include "db.hpp" +#include "models.hpp" + +#include +#include + +class UserRepo { +public: + explicit UserRepo(PgPool& pool) : pool_(pool) {} + + std::optional create(const std::string& username, + const std::string& display_name, + const std::string& password_hash); + + std::optional find_by_id(const std::string& id); + std::optional find_by_username(const std::string& username); + +private: + PgPool& pool_; +}; \ No newline at end of file diff --git a/student-tests/bench.py b/student-tests/bench.py new file mode 100644 index 00000000..bba2b360 --- /dev/null +++ b/student-tests/bench.py @@ -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() \ No newline at end of file diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 00000000..39d30ddd --- /dev/null +++ b/student-tests/test_api.py @@ -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") diff --git a/tests/level4.py b/tests/level4.py new file mode 100644 index 00000000..a5501661 --- /dev/null +++ b/tests/level4.py @@ -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)