diff --git a/.env.example b/.env.example index 714c807..93ca3bd 100644 --- a/.env.example +++ b/.env.example @@ -1,11 +1,14 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. +# Copy to .env. These values are for the local stand only. +# .env is gitignored. Do not put a real password here and then reuse it anywhere else. APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url +SESSION_STORE=redis +POSTGRES_PASSWORD=lab2localpass +REDIS_PASSWORD=lab2redispass +MAX_MESSAGES=100000 +MAX_PER_SECOND=10000 +MAX_INFLIGHT_BODIES=32 +# The API container receives DATABASE_URL and REDIS_URL from compose.yaml. +# DATABASE_URL_FILE and CACHE_URL_FILE are also read if you mount those files instead. diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..f4609ac --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +*.sh text eol=lf +*.cmd text eol=crlf diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 8ceefa1..a283086 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,18 +1,22 @@ ## Лабораторная 2 -Автор / группа: TODO -Целевая оценка (3/4/5): TODO -Трек 5, если заявлен: TODO +Автор / группа: Казанцева Виктория / БПИ2301 +Целевая оценка (3/4/5): 5 +Трек 5, если заявлен: трек 2, план запроса и восстановление из копии -Что реализовано и что перенесено: TODO -Команды запуска из чистого clone: TODO -Результаты проверок и ссылка на REPORT.md: TODO -Ограничения / известные ошибки: TODO -Источники и использование ИИ: TODO +Что реализовано и что перенесено: минимум лабораторной 1 перенесён в PostgreSQL. Регистрация с паролем Argon2id, сессия только через Basic, остальные запросы через Bearer. X-User-Id больше не даёт доступ. Сессии лежат в Redis с AOF и appendfsync always. Чаты создаются одной транзакцией. История читается keyset-запросом по индексу (chat_id, created_at, id). -- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. -- [ ] Контракт и публичные тесты не ослаблены. -- [ ] make check и make test выполнены; приложен реальный вывод. -- [ ] Сценарии отказов/безопасности своего уровня воспроизведены. -- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. -- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. +Команды запуска из чистого clone: copy .env.example .env, затем docker compose --env-file .env up -d --build. Миграции применяет API при старте. Подробности и команды проверок в REPORT.md. + +Результаты проверок и ссылка на REPORT.md: smoke PASS, persistence PASS, 7 своих тестов OK, отказ Redis и Postgres даёт 503 и не пускает анонима, короткий TTL кончается 401. Трек 2: 100100 сообщений, EXPLAIN и pg_dump в новый том, числа сошлись. См. REPORT.md и evidence/. + +Ограничения / известные ошибки: один процесс API, HTTP только на localhost, лимит частоты в памяти процесса, дамп не заменяет архив WAL и не содержит сессии. На Windows публичный persistence-тест нужно запускать с scripts/restart.cmd: shebang из scripts/restart.sh Windows Python сам не исполняет. Оба скрипта делают один и тот же docker restart. + +Источники: PostgreSQL, Redis AOF, RFC 7617, контракт курса. Команды и замеры прогнаны локально. + +- [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. +- [x] Контракт и публичные тесты не ослаблены. +- [x] make check и make test выполнены; приложен реальный вывод. +- [x] Сценарии отказов/безопасности своего уровня воспроизведены. +- [x] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. +- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..b2a291a --- /dev/null +++ b/Dockerfile @@ -0,0 +1,25 @@ +FROM python:3.12.7-slim-bookworm + +ENV PYTHONUNBUFFERED=1 \ + PYTHONDONTWRITEBYTECODE=1 \ + PIP_DISABLE_PIP_VERSION_CHECK=1 \ + APP_HOST=0.0.0.0 \ + APP_PORT=8080 + +WORKDIR /app + +RUN useradd --uid 10001 --create-home --shell /usr/sbin/nologin app + +COPY requirements.txt /app/requirements.txt +RUN pip install --no-cache-dir -r /app/requirements.txt + +COPY migrations /app/migrations +COPY src /app/src + +USER app +EXPOSE 8080 + +HEALTHCHECK --interval=5s --timeout=3s --start-period=20s --retries=12 \ + CMD ["python", "-c", "import os,urllib.request; urllib.request.urlopen('http://127.0.0.1:%s/health/ready' % os.environ.get('APP_PORT','8080'), timeout=2).read()"] + +CMD ["python", "/app/src/app.py"] diff --git a/REPORT.md b/REPORT.md index e42f2b0..90acb92 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,146 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +Автор, группа: Казанцева Виктория / БПИ2301 + +Целевая оценка; выбранный трек 5, если нужен: 5, трек 2 (план запроса и восстановление из копии) + +Commit/PR: TODO после публикации + +Использованные источники и библиотеки: контракт и публичные тесты skeleton, свой код лабораторной 1, документация PostgreSQL (транзакции, EXPLAIN, pg_dump/pg_restore), документация Redis про AOF, RFC 7617 про Basic. Библиотеки: argon2-cffi 23.1.0, psycopg 3.2.9 с пулом, redis 5.2.1. Образы: python:3.12.7-slim-bookworm, postgres:16.8-bookworm, redis:7.4.2-alpine. Команды, smoke и замеры прогнаны локально, числа ниже с этого запуска. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker и Python 3.9+. У меня проверки шли на Python 3.11.5, Windows. `python3` в Makefile на этой машине не обязателен: те же команды ниже вызывают `python`. + +Пароль стенда лежит только в `.env`. Файл в gitignore. В репозиторий попадает `.env.example` с учебным паролем локального стенда, его не надо использовать нигде кроме этой машины. + +```text +copy .env.example .env +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +``` + +Дальше подождать, пока `http://127.0.0.1:8080/health/ready` ответит 200. Миграции накатывает сам API при старте, отдельную команду запускать не нужно. + +Проверки: + +```text +python scripts/check_contract.py +python tests/smoke.py --base-url http://127.0.0.1:8080 +python tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080 +python -m unittest discover -s student-tests -v +python student-tests/check_dependencies.py +python -m venv .venv +.venv\Scripts\python -m pip install -r requirements.txt +.venv\Scripts\python student-tests\experiment_track2.py +``` + +На Linux и macOS persistence запускается так, как написано в задании: `make test-persistence ACTION_SCRIPT=scripts/restart.sh` после `chmod +x scripts/restart.sh`. На Windows публичный тест стартует hook как программу и не смотрит на shebang, поэтому тот же перезапуск лежит в `scripts/restart.cmd`. Я прогнала публичный тест с `.cmd` и отдельно выполнила `scripts/restart.sh` через Git Bash: поднялись те же три контейнера, `/health/ready` снова стал 200, после этого smoke ещё раз прошёл. + +Остановка без удаления данных: `docker compose --env-file .env stop`. Данные остаются в томах `pg-data` и `redis-data`. + +Намеренный сброс учебного стенда, его не вызывать в проверке сохранности: `docker compose --env-file .env down -v`. После этого пользователи, сообщения и сессии пропадут. Файл дампа эксперимента `backups/messenger_bench.dump` в git не входит, его можно удалить руками. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Клиент ходит в один процесс API. Пользователи, чаты, участники и сообщения лежат в PostgreSQL. Сессии лежат только в Redis. История сообщений в Redis не кэшируется: после успешного POST следующее чтение идёт в PostgreSQL, поэтому устаревшей страницы истории быть не должно. + +Из лабораторной 1 остались разбор HTTP, курсор, лимит тела 65536 байт, ограничение одновременных тел и лимит запросов в секунду. Лимит частоты по-прежнему в памяти процесса и после рестарта начинается заново. Изменилась аутентификация. Вместо `X-User-Id` при регистрации нужен пароль, сессия создаётся только `POST /api/v1/auth/sessions` с Basic, остальные запросы принимают только Bearer. Заголовок `X-User-Id` читается и ни на что не влияет. + +Пароль хешируется Argon2id, параметры m=19456, t=2, p=1. Это медленный KDF с солью. bcrypt я не брала: он режет длинный UTF-8 пароль около 72 байт, а по контракту пароль может быть до 128 code points и содержать двоеточие. SHA-256 пароля тоже не подходит: он быстрый, и перебор остаётся дешёвым. В Redis ключ сессии — это SHA-256 от случайного токена. Это быстрый поиск, не хеш пароля. Если скопировать Redis, там будет дайджест, а не строка, которой можно представиться. Сам токен — `token_urlsafe(32)`, 256 бит, клиенту он отдаётся один раз. + +Аутентификация и доступ к чату — разные проверки. Сначала нужно понять, кто пришёл. Нет токена, токен неизвестен, он просрочен или уже отозван — 401. Неверный пароль и несуществующий username дают один и тот же 401, без подсказки, что именно не так. Если человек известен, но чата нет или его там нет среди участников, ответ 404 и один и тот же текст. 403 я не использую, чтобы по коду нельзя было понять, существует чужой чат или нет. + +Сессия живёт `SESSION_TTL_SECONDS`. На обычном стенде это 3600, для отдельной проверки — 2. В Redis у ключа стоит такой же TTL. При чтении TTL не продлевается, рестарт его тоже не продлевает. Logout удаляет ключ. Пока Redis не отвечает, запрос с Bearer получает 503, а не 200. Запрос вообще без токена по-прежнему 401: анонима я не считаю пользователем только из-за того, что хранилище сессий лежит. То же с PostgreSQL: профиль и история без базы не отдаются. + +`/health/live` смотрит только на процесс. `/health/ready` делает `SELECT 1` и `PING`. Если Postgres или Redis недоступны, ready отвечает 503. + +Пул Postgres: минимум 1 соединение, максимум 8, ждать свободное можно 5 секунд, connect timeout 3 секунды, `statement_timeout` 3 секунды, `lock_timeout` 2 секунды. Перед выдачей соединения пул проверяет его `SELECT 1`, поэтому после возвращения базы старые обрывы не остаются навсегда. Запросы только с параметрами `%s`. В тесте display_name со строкой `a'; drop table users;--` сохранился как текст, таблица `users` осталась. + +Границы транзакций записаны в `migrations/001_init.sql` и повторены в `src/db.py`: + +- регистрация — один INSERT. Гонку одного username решает уникальный индекс, в процессе отдельного замка на это нет. Восемь параллельных регистраций дали один 201 и семь 409, в таблице одна строка; +- создание чата — INSERT чата и INSERT участников в одной транзакции. Если участника нет, внешний ключ рвёт транзакцию, и строка чата тоже откатывается. Проверка: число чатов до и после такого запроса совпало, чата с этим названием нет; +- сообщение — проверка участия и INSERT в одной транзакции. Сверху взята `pg_advisory_xact_lock`, чтобы предел `MAX_MESSAGES` не проехал на два сразу. Это простой замок на все записи сообщений, для стенда его хватает, при большой нагрузке он станет узким местом; +- чтение — одна транзакция без записи. + +COMMIT при `synchronous_commit=on` и `fsync=on` значит, что запись WAL дошла до диска до ответа клиенту. Оба параметра явно стоят в `compose.yaml`, там же `full_page_writes=on`. Если бы synchronous_commit был off, COMMIT мог бы вернуться раньше сброса на диск, и авария сразу после ответа потеряла бы последние сообщения. Удаление тома это всё равно не лечит: том — это и есть диск. + +Redis запущен с `--appendonly yes --appendfsync always`. `CONFIG GET` показал `appendfsync always`, `INFO persistence` — `aof_enabled:1` и `aof_last_write_status:ok`. SET не возвращается, пока запись не сброшена. Поэтому токен, который клиент уже получил, переживает рестарт Redis. Режим everysec мог бы потерять около секунды. `FLUSHALL` или том Redis без AOF сессии сотрёт, сообщения в Postgres при этом останутся. Проверено наоборот: `docker stop` Redis без удаления тома, затем start, тот же токен снова читает того же пользователя, текст сообщения на месте. + +Повторный запуск миграций ничего не вставляет. Версия лежит в `schema_migrations`. Второй вызов `apply_migrations()` вернул 0, число пользователей не изменилось. + +Стенд публикует порты только на 127.0.0.1. Это HTTP без TLS, для удалённой демонстрации его недостаточно. Контейнер API работает не от root, uid 10001. + +Образы, которые реально стояли: + +| Роль | Образ | Digest | +| --- | --- | --- | +| API | свой Dockerfile от python:3.12.7-slim-bookworm | sha256:60d9996b6a8a3689d36db740b49f4327be3be09a21122bd02fb8895abb38b50d | +| Postgres | postgres:16.8-bookworm | sha256:301bcb60b8a3ee4ab7e147932723e3abd1cef53516ce5210b39fd9fe5e3602ae | +| Redis | redis:7.4.2-alpine | sha256:02419de7eddf55aa5bcf49efb74e88fa8d931b4d77c07eff8a6b2144472b6952 | + +Имена контейнеров фиксированы: `mtusi-lab2-api`, `mtusi-lab2-postgres`, `mtusi-lab2-redis`. Hook перезапускает именно их и не делает `down -v`. ## Доказательства критериев +Машина: 12th Gen Intel Core i7-12650H, Windows видит около 15,7 ГБ памяти. Буферы в EXPLAIN — `shared hit`, то есть страницы уже были в кэше Postgres. Это сравнение планов, не холодного диска. + + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Публичный smoke | python tests/smoke.py --base-url http://127.0.0.1:8080 | PASS: lab2 public API scenario. После restart.sh smoke прошёл ещё раз | вывод консоли | +| Сохранность тома | python tests/resilience.py --mode persistence --action-script scripts/restart.cmd | PASS: тот же токен и то же сообщение после рестарта API, Postgres и Redis | вывод консоли | +| Hook на sh | Git Bash scripts/restart.sh | docker restart вернул три контейнера, затем /health/ready 200 | scripts/restart.sh | +| Повтор миграции | test_migrations_do_not_duplicate | в schema_migrations одна строка, повторный вызов вернул 0, пользователи не задвоились | student-tests/test_api.py | +| Гонка username | test_duplicate_username_race | 8 потоков: один 201, семь 409, в users ровно одна строка | student-tests/test_api.py | +| Откат создания чата | test_chat_create_rolls_back | 400, чат с таким title не появился, общее число чатов не выросло | student-tests/test_api.py | +| Argon2id и параметры | test_password_hash_is_argon2id_and_quotes_stay_data | префикс хеша `$argon2id`, пароль внутри хеша не лежит, кавычки в имени не выполнились как SQL | student-tests/test_api.py | +| Logout, Basic не на бизнес-методе, X-User-Id | test_colon_in_password_and_logout | пароль с двоеточием входит; Basic и голый X-User-Id на /users/me дают 401 Bearer; после DELETE 204 тот же токен даёт 401 | student-tests/test_api.py | +| Чужой курсор, огромный limit, лишний тип | test_lab1_edges_still_hold | 415 на application/jsonx, 400 на cursor `@@@` и на limit из девяток | student-tests/test_api.py | +| Короткий TTL | python student-tests/check_dependencies.py | окно сессии 1,991 с, сразу после входа 200, после паузы 401 Bearer | evidence/dependencies.json | +| Redis недоступен | тот же скрипт, docker stop mtusi-lab2-redis | без токена 401, с токеном 503, live 200, ready 503. После start тот же токен 200, сообщение на месте | evidence/dependencies.json | +| Postgres недоступен | docker stop mtusi-lab2-postgres | те же коды: аноним 401, Bearer 503, live 200, ready 503. После start история та же | evidence/dependencies.json | +| EXPLAIN на большой истории | student-tests/experiment_track2.py | 100100 сообщений, самый большой чат 80000. Keyset-страница: Index Scan messages_chat_history_idx, 50 строк, shared hit=6, 0,027 мс | evidence/explain-keyset.txt, evidence/track2.json | +| Второй план и второй индекс | тот же эксперимент | OFFSET 40000: 40050 строк, shared hit=788, 4,180 мс. Без индекса: Seq Scan, фильтр выкинул 98101 строку, shared hit=1248, 3,986 мс. Индекс только по created_at на чате в 4000: выкинул 205 строк, shared hit=259, 0,073 мс | evidence/explain-offset.txt, explain-seqscan.txt, explain-created-only.txt | +| Цена записи | тот же эксперимент | 2000 вставок с индексом истории 31,8 мс, без него 27,6 мс. Построение индекса на 100100 строках 71,9 мс | evidence/track2.json | +| Backup и новое хранилище | pg_dump -Fc, затем новый контейнер и новый том | дамп 3 094 487 байт за 0,477 с, восстановление 0,610 с. Пользователи 3, чаты 155, участники 165, сообщения 100100. Пять выбранных сообщений совпали. На новой базе тот же keyset снова Index Scan, shared hit=6 | evidence/track2.json, evidence/explain-restored.txt | +| Redis реально хранит сессии | CONFIG GET и INFO persistence | appendfsync always, aof_enabled 1, aof_last_write_status ok | evidence/redis-persistence.txt | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. + +Свои тесты API: `python -m unittest discover -s student-tests -v` — 7 тестов, OK, 3,203 с. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Трек 2. Гипотеза: страница истории одного чата не должна читать всю таблицу, если есть индекс `(chat_id, created_at, id)`, а `OFFSET` и индекс только по времени так не умеют. Отдельно: логический дамп, залитый в пустой том, сохраняет строки, но не заменяет непрерывный архив WAL и ничего не знает про Redis. + +Как мерила. Отдельная база `messenger_bench`, не та, куда пишет API. 155 чатов: один на 80000 сообщений, четыре по 4000, десять по 300, двадцать по 40, двадцать по 10 и сто по одному сообщению. Всего 100100. Время сообщений специально перемешано между чатами, иначе индекс по `created_at` случайно попадает в один чат просто потому, что строки лежали подряд. После загрузки `ANALYZE`. Каждый `EXPLAIN (ANALYZE, BUFFERS)` снят вторым прогоном, первый только прогревал план. Потом индекс истории снят, снят полный просмотр для страницы чата на 4000 сообщений, создан индекс только по `created_at`, снят его план, рабочий индекс возвращён. Вставки для цены записи откатываются, в дамп они не попадают. Дамп снят `pg_dump -Fc` внутри контейнера Postgres 16.8 и залит `pg_restore` в новый контейнер с новым томом `mtusi-lab2-restore-data`, порт 127.0.0.1:5433. После сверки контейнер и том удалены, дамп остался в `backups/`, он в gitignore. + +Что вышло на этом запуске. Загрузка 100100 строк заняла 2,356 с. Страница большого чата по ключу курсора прочитала 50 строк и 6 страниц буфера за 0,027 мс. Та же история через `OFFSET 40000` прочитала 40050 строк и 788 страниц за 4,180 мс: индекс тот же, но офсет не умеет прыгнуть сразу на нужное место. Без вторичного индекса страница среднего чата просмотрела таблицу, фильтр отбросил 98101 строку, буфер 1248, время 3,986 мс. Индекс только по `created_at` на этом же месте отбросил 205 чужих строк и взял 259 страниц против 6 у нормального индекса. Время у него всё ещё маленькое, 0,073 мс, потому что данные в кэше, но страниц он трогает больше: ведущая колонка не та, по которой идёт запрос. + +Запись 2000 строк с индексом истории заняла 31,8 мс, без него 27,6 мс. На такой пачке разница маленькая, по одному запуску я бы не стала говорить, что индекс «заметно тормозит вставку». Честнее цена построения: создать его на уже лежащих 100100 строках стоило 71,9 мс. Для этой лабораторной я оставляю узкий индекс без `body`. Тело всё равно читается из кучи, но страница — это 50 строк, а более широкий индекс дороже на каждой вставке. + +Дамп получился на 3,0 МБ за 0,477 с. Восстановление в пустой том — 0,610 с. Счётчики совпали: 3 пользователя, 155 чатов, 165 участий, 100100 сообщений. Совпали первое, среднее и последнее сообщение большого чата, сообщение из чата на 4000 и единственное сообщение маленького чата. На восстановленной базе тот же keyset снова пошёл в `messages_chat_history_idx`, 6 страниц, 0,027 мс. Индекс `messages_created_only_idx` в дамп не входил, его я создавала только на время замера и удалила. + +Потеря данных. `pg_dump` берёт снимок на начало копирования. То, что записали после старта дампа, в файл не попадает. Это не архив WAL: дыра равна всему, что случилось после последней копии. 0,610 с — время этого маленького дампа на ноутбуке, не оценка для большой базы. Сессий в дампе нет. Если восстановить только Postgres, сообщения будут, а старые токены нет, пока жив Redis с тем же AOF. Если стереть том Redis и оставить Postgres, будет наоборот. `synchronous_commit=on` не спасает от `down -v` и не спасает от дампа, который просто давно не снимали. + | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| рестарт API, Postgres и Redis с томами | тот же токен читает те же сообщения | публичный persistence-тест PASS | контейнеры поднялись, ready снова 200. Новых дыр в данных тест не увидел | +| stop/start Redis без удаления тома | 503, пока он лежит; потом тот же токен | без токена 401, с токеном 503, live 200, ready 503; после start токен и сообщение на месте | AOF остался, TTL не продлился | +| stop/start Postgres | 503 на бизнес-запросе, история не пропадает | Bearer 503, аноним 401; после start та же история и тот же токен | пул дождался базы. Сообщения не переписывались | +| SESSION_TTL_SECONDS=2 | свежая сессия работает, потом 401 | окно 1,991 с, затем 401 | сессия кончилась по времени, пользователь в Postgres остался | +| неверный пароль и logout | 401, хеш пароля не светится | 401 Basic на чужом пароле; после logout 401 Bearer | учётная запись не удалялась | +| дамп и новый том | те же числа и выбранные строки | 100100 = 100100, пять сообщений совпали | 0,477 с на дамп и 0,610 с на восстановление. Всё новее дампа в него не вошло бы | + ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Кэш истории я сознательно не делала. Контракт требует, чтобы успешная запись была видна следующему чтению, а для трека 2 вопрос был про план и копию, не про stampede. Если кэш появится, его придётся сбрасывать в той же транзакции, что и INSERT, иначе страница устареет. + +`COUNT(*)` под advisory lock на каждое сообщение точный, но сериализует запись. Лимит частоты живёт в памяти одного процесса. Тело больше 64 КБ по-прежнему обрывается, как в первой работе, но это не защита от числа соединений. + +EXPLAIN снят на тёплом кэше, `shared_buffers` у контейнера 128 МБ, вся таблица туда помещается. По `shared hit` видно, сколько страниц тронул план, и не видно, сколько заняло бы чтение с диска. Один прогон вставки на 2000 строк слишком короткий, чтобы по нему сравнивать индексы: 31,8 и 27,6 мс легко поедут от шума. + +Дамп не включает Redis и не является PITR. Стенд один, без второй реплики API. HTTP открыт только на localhost и без TLS. Пароль Redis и Postgres — учебные, они не должны уезжать с этой машины. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..bb9dab6 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,111 @@ +# Local stand for lab2. Fixed container names so scripts/restart.sh can restart +# the API and both stores without guessing the compose project name. +# Volumes are named and are not removed by restart. +name: mtusi-lab2 + +x-api-image: &api-image mtusi-messenger:lab2 + +services: + postgres: + image: postgres:16.8-bookworm + container_name: mtusi-lab2-postgres + environment: + POSTGRES_USER: messenger + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + POSTGRES_DB: messenger + command: + - postgres + - -c + - synchronous_commit=on + - -c + - fsync=on + - -c + - full_page_writes=on + volumes: + - pg-data:/var/lib/postgresql/data + ports: + - "127.0.0.1:5432:5432" + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 20 + start_period: 10s + restart: unless-stopped + + redis: + image: redis:7.4.2-alpine + container_name: mtusi-lab2-redis + environment: + REDIS_PASSWORD: ${REDIS_PASSWORD} + command: + - redis-server + - --appendonly + - "yes" + - --appendfsync + - always + - --dir + - /data + - --requirepass + - ${REDIS_PASSWORD} + volumes: + - redis-data:/data + ports: + - "127.0.0.1:6379:6379" + healthcheck: + test: ["CMD-SHELL", "redis-cli -a \"$$REDIS_PASSWORD\" --no-auth-warning ping | grep -q PONG"] + interval: 5s + timeout: 3s + retries: 20 + start_period: 5s + restart: unless-stopped + + api: + image: *api-image + build: . + container_name: mtusi-lab2-api + environment: &api-env + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + DATABASE_URL: postgresql://messenger:${POSTGRES_PASSWORD}@postgres:5432/messenger + REDIS_URL: redis://:${REDIS_PASSWORD}@redis:6379/0 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + MAX_MESSAGES: ${MAX_MESSAGES:-100000} + MAX_PER_SECOND: ${MAX_PER_SECOND:-10000} + MAX_INFLIGHT_BODIES: ${MAX_INFLIGHT_BODIES:-32} + ports: + - "127.0.0.1:8080:8080" + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + healthcheck: + test: ["CMD", "python", "-c", "import os,urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).read()"] + interval: 5s + timeout: 3s + retries: 20 + start_period: 20s + stop_grace_period: 15s + restart: unless-stopped + + api-short: + profiles: ["shortttl"] + image: *api-image + build: . + container_name: mtusi-lab2-api-short + environment: + <<: *api-env + SESSION_TTL_SECONDS: "2" + ports: + - "127.0.0.1:8081:8080" + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + restart: "no" + +volumes: + pg-data: + redis-data: diff --git a/evidence/dependencies.json b/evidence/dependencies.json new file mode 100644 index 0000000..4d12147 --- /dev/null +++ b/evidence/dependencies.json @@ -0,0 +1,80 @@ +{ + "redis_and_postgres": [ + { + "name": "redis down, no token", + "status": 401, + "code": "unauthorized", + "www_authenticate": "Bearer realm=\"messenger\"" + }, + { + "name": "redis down, bearer", + "status": 503, + "code": "unavailable", + "www_authenticate": null + }, + { + "name": "redis down, live", + "status": 200, + "code": null, + "www_authenticate": null + }, + { + "name": "redis down, ready", + "status": 503, + "code": "unavailable", + "www_authenticate": null + }, + { + "name": "redis back, same token", + "status": 200, + "code": null, + "www_authenticate": null + }, + { + "name": "history after redis stop", + "status": 200, + "same_message": true + }, + { + "name": "postgres down, no token", + "status": 401, + "code": "unauthorized", + "www_authenticate": "Bearer realm=\"messenger\"" + }, + { + "name": "postgres down, bearer", + "status": 503, + "code": "unavailable", + "www_authenticate": null + }, + { + "name": "postgres down, live", + "status": 200, + "code": null, + "www_authenticate": null + }, + { + "name": "postgres down, ready", + "status": 503, + "code": "unavailable", + "www_authenticate": null + }, + { + "name": "postgres back, same token", + "status": 200, + "code": null, + "www_authenticate": null + }, + { + "name": "history after postgres stop", + "status": 200, + "same_message": true + } + ], + "short_ttl": { + "ttl_window_seconds": 1.991, + "after_expiry": 401, + "www_authenticate": "Bearer realm=\"messenger\"", + "error_code": "unauthorized" + } +} diff --git a/evidence/explain-created-only.txt b/evidence/explain-created-only.txt new file mode 100644 index 0000000..b3f860a --- /dev/null +++ b/evidence/explain-created-only.txt @@ -0,0 +1,14 @@ +Limit (cost=2.65..122.42 rows=50 width=66) (actual time=0.042..0.064 rows=50 loops=1) + Buffers: shared hit=259 + -> Incremental Sort (cost=2.65..8232.71 rows=3436 width=66) (actual time=0.042..0.061 rows=50 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=259 + -> Index Scan using messages_created_only_idx on messages (cost=0.29..8078.09 rows=3436 width=66) (actual time=0.015..0.053 rows=51 loops=1) + Index Cond: (created_at >= '2026-01-01 00:00:00.310001+00'::timestamp with time zone) + Filter: ((chat_id = '9af8786b-05c3-4793-b29e-a0702fab01fc'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:00.310001+00'::timestamp with time zone, '50567333-6286-45dd-99db-ccbf6c94925b'::uuid))) + Rows Removed by Filter: 205 + Buffers: shared hit=259 +Planning Time: 0.051 ms +Execution Time: 0.073 ms diff --git a/evidence/explain-keyset.txt b/evidence/explain-keyset.txt new file mode 100644 index 0000000..5c1d482 --- /dev/null +++ b/evidence/explain-keyset.txt @@ -0,0 +1,7 @@ +Limit (cost=0.42..10.37 rows=50 width=66) (actual time=0.009..0.018 rows=50 loops=1) + Buffers: shared hit=6 + -> Index Scan using messages_chat_history_idx on messages (cost=0.42..6377.26 rows=32040 width=66) (actual time=0.008..0.015 rows=50 loops=1) + Index Cond: ((chat_id = '87a5ea91-8f1b-41ae-8ff7-8f67b1711963'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:06.2+00'::timestamp with time zone, '9ad9f914-0b9b-41f7-814d-284d3d4e85e9'::uuid))) + Buffers: shared hit=6 +Planning Time: 0.046 ms +Execution Time: 0.027 ms diff --git a/evidence/explain-offset.txt b/evidence/explain-offset.txt new file mode 100644 index 0000000..3028e78 --- /dev/null +++ b/evidence/explain-offset.txt @@ -0,0 +1,7 @@ +Limit (cost=4354.45..4359.89 rows=50 width=66) (actual time=4.163..4.171 rows=50 loops=1) + Buffers: shared hit=788 + -> Index Scan using messages_chat_history_idx on messages (cost=0.42..8739.72 rows=80287 width=66) (actual time=0.008..3.212 rows=40050 loops=1) + Index Cond: (chat_id = '87a5ea91-8f1b-41ae-8ff7-8f67b1711963'::uuid) + Buffers: shared hit=788 +Planning Time: 0.037 ms +Execution Time: 4.180 ms diff --git a/evidence/explain-restored.txt b/evidence/explain-restored.txt new file mode 100644 index 0000000..9a56e26 --- /dev/null +++ b/evidence/explain-restored.txt @@ -0,0 +1,7 @@ +Limit (cost=0.42..10.31 rows=50 width=66) (actual time=0.009..0.019 rows=50 loops=1) + Buffers: shared hit=6 + -> Index Scan using messages_chat_history_idx on messages (cost=0.42..6254.08 rows=31611 width=66) (actual time=0.009..0.016 rows=50 loops=1) + Index Cond: ((chat_id = '87a5ea91-8f1b-41ae-8ff7-8f67b1711963'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:06.2+00'::timestamp with time zone, '9ad9f914-0b9b-41f7-814d-284d3d4e85e9'::uuid))) + Buffers: shared hit=6 +Planning Time: 0.045 ms +Execution Time: 0.027 ms diff --git a/evidence/explain-seqscan.txt b/evidence/explain-seqscan.txt new file mode 100644 index 0000000..cae7c02 --- /dev/null +++ b/evidence/explain-seqscan.txt @@ -0,0 +1,12 @@ +Limit (cost=3112.96..3113.09 rows=50 width=66) (actual time=3.970..3.974 rows=50 loops=1) + Buffers: shared hit=1248 + -> Sort (cost=3112.96..3121.48 rows=3408 width=66) (actual time=3.969..3.971 rows=50 loops=1) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 31kB + Buffers: shared hit=1248 + -> Seq Scan on messages (cost=0.00..2999.75 rows=3408 width=66) (actual time=3.147..3.873 rows=1999 loops=1) + Filter: ((chat_id = '9af8786b-05c3-4793-b29e-a0702fab01fc'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:00.310001+00'::timestamp with time zone, '50567333-6286-45dd-99db-ccbf6c94925b'::uuid))) + Rows Removed by Filter: 98101 + Buffers: shared hit=1248 +Planning Time: 0.048 ms +Execution Time: 3.986 ms diff --git a/evidence/redis-persistence.txt b/evidence/redis-persistence.txt new file mode 100644 index 0000000..7bda927 --- /dev/null +++ b/evidence/redis-persistence.txt @@ -0,0 +1,4 @@ +aof_enabled:1 +appendfsync:always +aof_last_write_status:ok +aof_current_size:3709 diff --git a/evidence/track2.json b/evidence/track2.json new file mode 100644 index 0000000..aeb9a85 --- /dev/null +++ b/evidence/track2.json @@ -0,0 +1,87 @@ +{ + "platform": "Windows-10-10.0.26100-SP0", + "processor": "Intel64 Family 6 Model 154 Stepping 3, GenuineIntel", + "python": "3.11.5", + "seed_seconds": 2.356, + "chat_sizes_head": [ + 80000, + 4000, + 4000, + 4000, + 4000, + 300, + 300, + 300 + ], + "chat_count": 155, + "smallest_chat": 1, + "largest_chat": 80000, + "source": { + "users": 3, + "chats": 155, + "chat_members": 165, + "messages": 100100, + "version": "PostgreSQL 16.8 (Debian 16.8-1.pgdg120+1) on x86_64-pc-linux-gnu, compiled by gcc (Debian 12.2.0-14) 12.2.0, 64-bit", + "synchronous_commit": "on", + "fsync": "on", + "shared_buffers": "128MB" + }, + "restored": { + "users": 3, + "chats": 155, + "chat_members": 165, + "messages": 100100 + }, + "counts_match": true, + "samples_match": { + "huge_first": true, + "huge_middle": true, + "huge_last": true, + "medium": true, + "tiny": true + }, + "dump_seconds": 0.477, + "dump_bytes": 3094487, + "restore_seconds": 0.61, + "create_index_ms": 71.9, + "write_cost": { + "rows": 2000, + "with_history_index_ms": 31.8, + "without_secondary_index_ms": 27.6 + }, + "keyset": { + "scan": "-> Index Scan using messages_chat_history_idx on messages (cost=0.42..6377.26 rows=32040 width=66) (actual time=0.008..0.015 rows=50 loops=1)", + "buffers": "Buffers: shared hit=6", + "execution_time": "Execution Time: 0.027 ms", + "planning_time": "Planning Time: 0.046 ms" + }, + "offset": { + "scan": "-> Index Scan using messages_chat_history_idx on messages (cost=0.42..8739.72 rows=80287 width=66) (actual time=0.008..3.212 rows=40050 loops=1)", + "buffers": "Buffers: shared hit=788", + "execution_time": "Execution Time: 4.180 ms", + "planning_time": "Planning Time: 0.037 ms" + }, + "seqscan": { + "scan": "-> Seq Scan on messages (cost=0.00..2999.75 rows=3408 width=66) (actual time=3.147..3.873 rows=1999 loops=1)", + "buffers": "Buffers: shared hit=1248", + "execution_time": "Execution Time: 3.986 ms", + "planning_time": "Planning Time: 0.048 ms" + }, + "created_only": { + "scan": "-> Index Scan using messages_created_only_idx on messages (cost=0.29..8078.09 rows=3436 width=66) (actual time=0.015..0.053 rows=51 loops=1)", + "buffers": "Buffers: shared hit=259", + "execution_time": "Execution Time: 0.073 ms", + "planning_time": "Planning Time: 0.051 ms" + }, + "restored_keyset": { + "scan": "-> Index Scan using messages_chat_history_idx on messages (cost=0.42..6254.08 rows=31611 width=66) (actual time=0.009..0.016 rows=50 loops=1)", + "buffers": "Buffers: shared hit=6", + "execution_time": "Execution Time: 0.027 ms", + "planning_time": "Planning Time: 0.045 ms" + }, + "restored_message_indexes": [ + "messages_chat_history_idx", + "messages_pkey" + ], + "dump_file": "backups/messenger_bench.dump" +} diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 0000000..6affb3d --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,62 @@ +-- Tables, constraints and indexes. Queries live in src/db.py and follow this layout. +-- +-- users one row per account; username is unique; password_hash is Argon2id, never returned +-- chats one row per chat +-- chat_members membership; primary key (chat_id, user_id); member_ord keeps the request order +-- a chat and its members are inserted in one transaction +-- messages history of one chat; page query is +-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3) +-- ORDER BY created_at, id +-- LIMIT $4 +-- +-- Transaction boundaries (see src/db.py): +-- register: single INSERT; unique username aborts that insert +-- create chat: INSERT chats + INSERT chat_members, one transaction; any failure rolls both back +-- send message: membership check + INSERT, one transaction, under an advisory lock with the cap +-- reads: one transaction, no write +-- Sessions are not stored here. Redis is the only session store (see compose.yaml). +-- Re-running these statements does not insert rows. The runner also records schema_migrations. + +CREATE TABLE IF NOT EXISTS users ( + id uuid PRIMARY KEY, + username text NOT NULL, + display_name text NOT NULL, + password_hash text NOT NULL, + created_at timestamptz NOT NULL, + CONSTRAINT users_username_unique UNIQUE (username), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100), + CONSTRAINT users_password_hash_present CHECK (char_length(password_hash) > 0) +); + +CREATE TABLE IF NOT EXISTS chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_at timestamptz NOT NULL, + CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100) +); + +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + user_id uuid NOT NULL REFERENCES users (id), + member_ord integer NOT NULL, + PRIMARY KEY (chat_id, user_id), + CONSTRAINT chat_members_ord_unique UNIQUE (chat_id, member_ord), + CONSTRAINT chat_members_ord_nonneg CHECK (member_ord >= 0) +); + +-- List "chats of this user" filters by user_id. The primary key leads with chat_id, so it does not serve that lookup. +CREATE INDEX IF NOT EXISTS chat_members_user_idx ON chat_members (user_id); + +CREATE TABLE IF NOT EXISTS messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + sender_id uuid NOT NULL REFERENCES users (id), + body text NOT NULL, + created_at timestamptz NOT NULL, + CONSTRAINT messages_body_len CHECK (char_length(body) BETWEEN 1 AND 4000) +); + +-- Matches the history query above: the scan stays inside one chat and already has the page order, +-- so LIMIT stops after one page instead of sorting the whole chat. +CREATE INDEX IF NOT EXISTS messages_chat_history_idx ON messages (chat_id, created_at, id); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..bb6ebc7 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,3 @@ +argon2-cffi==23.1.0 +psycopg[binary,pool]==3.2.9 +redis==5.2.1 diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 0000000..9905a2a --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,4 @@ +@echo off +REM Same restart as scripts/restart.sh. Windows Python cannot exec a shebang script. +docker restart mtusi-lab2-api mtusi-lab2-postgres mtusi-lab2-redis +exit /b %ERRORLEVEL% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 0000000..5d6b758 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,5 @@ +#!/bin/sh +# Restart the API and every store the API uses. Volumes stay in place. +# Do not seed, flush, or run compose down -v from here. +set -eu +docker restart mtusi-lab2-api mtusi-lab2-postgres mtusi-lab2-redis diff --git a/src/app.py b/src/app.py new file mode 100644 index 0000000..c7b758d --- /dev/null +++ b/src/app.py @@ -0,0 +1,731 @@ +import json +import os +import re +import signal +import socket +import sys +import threading +import time +import uuid +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from urllib.parse import parse_qs, urlsplit +import base64 + +import cursor +import db +import passwords +import sessions +from errors import DependencyDown + +MAX_BODY = 65536 +DEFAULT_INFLIGHT_BODIES = 32 +USERNAME = re.compile(r'^[a-z0-9_]{3,32}$') +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' +BEARER_CHALLENGE = 'Bearer realm="messenger"' + + +class State: + def __init__(self, max_inflight_bodies): + self.accepting = True + slots = int(max_inflight_bodies) + if slots < 1: + slots = 1 + self.body_slots = threading.BoundedSemaphore(slots) + + +class Limiter: + def __init__(self, max_per_second): + self.max_per_second = max_per_second + self._lock = threading.Lock() + self._recent = [] + + def allow(self): + if self.max_per_second <= 0: + return True + now = time.monotonic() + with self._lock: + self._recent = [stamp for stamp in self._recent if now - stamp < 1] + if len(self._recent) >= self.max_per_second: + return False + self._recent.append(now) + return True + + +def canonical_uuid(value): + if not isinstance(value, str): + return None + try: + return str(uuid.UUID(value)) + except ValueError: + return None + + +def make_server(state, limiter, host, port): + class Handler(BaseHTTPRequestHandler): + def address_string(self): + return self.client_address[0] + + def log_message(self, fmt, *args): + return + + def do_GET(self): + self._handle() + + def do_POST(self): + self._handle() + + def do_PUT(self): + self._handle() + + def do_PATCH(self): + self._handle() + + def do_DELETE(self): + self._handle() + + def _handle(self): + self.request_id = str(uuid.uuid4()) + self._status = '-' + try: + self.connection.settimeout(15) + except OSError: + pass + try: + self._route() + except DependencyDown as exc: + print('dependency %s' % type(exc).__name__, flush=True) + if self._status == '-': + self._error(503, 'unavailable', 'Сервис временно недоступен') + except Exception as exc: + print('internal %s' % type(exc).__name__, flush=True) + if self._status == '-': + self._error(500, 'internal_error', 'Внутренняя ошибка') + + def _route(self): + parsed = urlsplit(self.path) + path = parsed.path + query = parse_qs(parsed.query, keep_blank_values=True) + if path == '/health/live' and self.command == 'GET': + self._json(200, {'status': 'ok'}) + return + if not state.accepting: + self._error(503, 'unavailable', 'Сервер останавливается') + return + if path == '/health/ready' and self.command == 'GET': + self._ready() + return + if path == '/api/v1/users' and self.command == 'POST': + self._register() + return + if path == '/api/v1/auth/sessions' and self.command == 'POST': + self._login() + return + if path.startswith('/api/'): + self._api(path, query) + return + if path in ('/health/live', '/health/ready', '/api/v1/users', '/api/v1/auth/sessions'): + self._error(400, 'invalid_request', 'Метод не поддерживается') + return + self._error(404, 'not_found', 'Объект не найден') + + def _ready(self): + try: + db.ping() + sessions.ping() + except DependencyDown: + self._error(503, 'unavailable', 'Сервис временно недоступен') + return + self._json(200, {'status': 'ok'}) + + def _api(self, path, query): + if not limiter.allow(): + self._discard_body() + self._error(429, 'rate_limited', 'Слишком много запросов', retry_after=1) + return + user = self._user() + if user is None: + return + if path == '/api/v1/auth/sessions/current' and self.command == 'DELETE': + self._logout() + return + if path == '/api/v1/users/me' and self.command == 'GET': + self._json(200, user) + return + if path == '/api/v1/chats' and self.command == 'POST': + self._create_chat(user) + return + if path == '/api/v1/chats' and self.command == 'GET': + self._list_chats(user, query) + return + chat_match = re.fullmatch(r'/api/v1/chats/([^/]+)', path) + if chat_match and self.command == 'GET': + self._get_chat(user, chat_match.group(1)) + return + msg_match = re.fullmatch(r'/api/v1/chats/([^/]+)/messages', path) + if msg_match and self.command == 'POST': + self._create_message(user, msg_match.group(1)) + return + if msg_match and self.command == 'GET': + self._list_messages(user, msg_match.group(1), query) + return + self._error(404, 'not_found', 'Объект не найден') + + def _user(self): + # X-User-Id is ignored from lab2. Basic is only valid on POST /auth/sessions. + scheme, value = _authorization(self.headers.get('Authorization')) + if scheme != 'bearer' or not sessions.token_shape(value): + self._discard_body() + self._error(401, 'unauthorized', 'Пользователь не опознан', challenge=BEARER_CHALLENGE) + return None + try: + user_id = sessions.read(value) + if user_id is None: + self._discard_body() + self._error(401, 'unauthorized', 'Пользователь не опознан', challenge=BEARER_CHALLENGE) + return None + user = db.get_user(user_id) + except DependencyDown: + self._discard_body() + self._error(503, 'unavailable', 'Сервис временно недоступен') + return None + if user is None: + self._discard_body() + self._error(401, 'unauthorized', 'Пользователь не опознан', challenge=BEARER_CHALLENGE) + return None + self._bearer = value + return user + + def _logout(self): + self._discard_body() + if self._status != '-': + return + try: + gone = sessions.revoke(getattr(self, '_bearer', '')) + except DependencyDown: + self._error(503, 'unavailable', 'Сервис временно недоступен') + return + if not gone: + self._error(401, 'unauthorized', 'Пользователь не опознан', challenge=BEARER_CHALLENGE) + return + self._json(204, None) + + def _login(self): + if not limiter.allow(): + self._discard_body() + self._error(429, 'rate_limited', 'Слишком много запросов', retry_after=1) + return + raw_body, rejected = self._optional_empty_body() + if rejected: + return + if raw_body: + self._error(400, 'invalid_request', 'Тело запроса не нужно') + return + username, password = _basic_credentials(self.headers.get('Authorization')) + if username is None: + self._error(401, 'unauthorized', 'Пользователь не опознан', challenge=BASIC_CHALLENGE) + return + try: + found = db.get_credentials(username) + except DependencyDown: + self._error(503, 'unavailable', 'Сервис временно недоступен') + return + if found is None: + passwords.verify_password(passwords.DUMMY_HASH, password) + self._error(401, 'unauthorized', 'Пользователь не опознан', challenge=BASIC_CHALLENGE) + return + user, password_hash = found + if not passwords.verify_password(password_hash, password): + self._error(401, 'unauthorized', 'Пользователь не опознан', challenge=BASIC_CHALLENGE) + return + try: + token, expires_at = sessions.create(user['id']) + except DependencyDown: + self._error(503, 'unavailable', 'Сервис временно недоступен') + return + self._json(201, { + 'token': token, + 'token_type': 'Bearer', + 'expires_at': expires_at, + 'user': user, + }) + + def _discard_body(self): + length, problem = _parse_content_length(self.headers.get('Content-Length')) + if problem == 'missing': + return + if problem == 'too_big': + self._reject_too_large() + return + if problem == 'bad': + self.close_connection = True + return + if length == 0: + return + data, busy = self._read_exact(length) + if busy or data is None or len(data) != length: + self.close_connection = True + + def _optional_empty_body(self): + length, problem = _parse_content_length(self.headers.get('Content-Length')) + if problem == 'missing' or length == 0: + return b'', False + if problem == 'too_big': + self._reject_too_large() + self._error(413, 'payload_too_large', 'Тело запроса слишком большое') + return None, True + if problem == 'bad': + self.close_connection = True + self._error(400, 'invalid_request', 'Некорректный запрос') + return None, True + raw, busy = self._read_exact(length) + if busy: + self._error(503, 'unavailable', 'Слишком много одновременных тел запроса') + return None, True + if raw is None or len(raw) != length: + self.close_connection = True + self._error(400, 'invalid_request', 'Некорректный запрос') + return None, True + return raw.strip(), False + + def _read_exact(self, length): + if length == 0: + return b'', False + if not state.body_slots.acquire(blocking=False): + self.close_connection = True + return None, True + try: + return self.rfile.read(length), False + finally: + state.body_slots.release() + + def _reject_too_large(self): + self.close_connection = True + if not state.body_slots.acquire(blocking=False): + return + previous = self.connection.gettimeout() + self.connection.settimeout(0.2) + try: + remaining = MAX_BODY + while remaining > 0: + try: + chunk = self.rfile.read(min(8192, remaining)) + except (TimeoutError, socket.timeout, OSError): + break + if not chunk: + break + remaining -= len(chunk) + finally: + state.body_slots.release() + try: + self.connection.settimeout(previous) + except OSError: + pass + + def _register(self): + if not limiter.allow(): + self._discard_body() + self._error(429, 'rate_limited', 'Слишком много запросов', retry_after=1) + return + body, problem = self._json_body({'username', 'display_name', 'password'}) + if problem: + return + username = body['username'] + display_name = body['display_name'] + password = body['password'] + if not isinstance(username, str) or USERNAME.fullmatch(username) is None: + self._error(400, 'invalid_request', 'Некорректный username') + return + if not _text_ok(display_name, 100): + self._error(400, 'invalid_request', 'Некорректный display_name') + return + if not _password_ok(password): + self._error(400, 'invalid_request', 'Некорректный пароль') + return + try: + status, user = db.create_user(username, display_name, passwords.hash_password(password)) + except DependencyDown: + self._error(503, 'unavailable', 'Сервис временно недоступен') + return + if status == 'conflict': + self._error(409, 'conflict', 'Такой username уже занят') + return + if status != 'ok': + self._error(400, 'invalid_request', 'Некорректные поля JSON') + return + self._json(201, user) + + def _create_chat(self, user): + body, problem = self._json_body({'title', 'member_ids'}) + if problem: + return + title = body['title'] + member_ids = body['member_ids'] + if not _text_ok(title, 100): + self._error(400, 'invalid_request', 'Некорректный title') + return + parsed_ids, ok = _member_ids(member_ids, user['id']) + if not ok: + self._error(400, 'invalid_request', 'Некорректный список участников') + return + try: + status, chat = db.create_chat(user['id'], title, parsed_ids) + except DependencyDown: + self._error(503, 'unavailable', 'Сервис временно недоступен') + return + if status != 'ok': + self._error(400, 'invalid_request', 'Некорректный список участников') + return + self._json(201, chat) + + def _list_chats(self, user, query): + limit, page_cursor, problem = _page_args(query, 'chats', user['id']) + if problem: + self._error(400, 'invalid_request', problem) + return + try: + items, nxt = db.list_chats(user['id'], limit, page_cursor) + except DependencyDown: + self._error(503, 'unavailable', 'Сервис временно недоступен') + return + self._json(200, {'items': items, 'next_cursor': nxt}) + + def _get_chat(self, user, raw_chat_id): + chat_id = canonical_uuid(raw_chat_id) + if chat_id is None: + self._error(400, 'invalid_request', 'Некорректный UUID') + return + try: + chat = db.get_chat(chat_id, user['id']) + except DependencyDown: + self._error(503, 'unavailable', 'Сервис временно недоступен') + return + if chat is None: + self._error(404, 'not_found', 'Объект не найден') + return + self._json(200, chat) + + def _create_message(self, user, raw_chat_id): + chat_id = canonical_uuid(raw_chat_id) + if chat_id is None: + self._error(400, 'invalid_request', 'Некорректный UUID') + return + body, problem = self._json_body({'text'}) + if problem: + return + text = body['text'] + if not _text_ok(text, 4000): + self._error(400, 'invalid_request', 'Некорректный текст сообщения') + return + try: + status, message = db.add_message(chat_id, user['id'], text) + except DependencyDown: + self._error(503, 'unavailable', 'Сервис временно недоступен') + return + if status == 'missing': + self._error(404, 'not_found', 'Объект не найден') + return + if status == 'full': + self._error(503, 'unavailable', 'Достигнут предел числа сообщений') + return + self._json(201, message) + + def _list_messages(self, user, raw_chat_id, query): + chat_id = canonical_uuid(raw_chat_id) + if chat_id is None: + self._error(400, 'invalid_request', 'Некорректный UUID') + return + limit, page_cursor, problem = _page_args(query, 'msgs', chat_id) + if problem: + self._error(400, 'invalid_request', problem) + return + try: + status, items, nxt = db.list_messages(chat_id, user['id'], limit, page_cursor) + except DependencyDown: + self._error(503, 'unavailable', 'Сервис временно недоступен') + return + if status == 'missing': + self._error(404, 'not_found', 'Объект не найден') + return + self._json(200, {'items': items, 'next_cursor': nxt}) + + def _json_body(self, fields): + raw, code, message = self._read_body() + if code: + self._error(code, _error_code(code), message) + return None, True + try: + body = json.loads(raw.decode('utf-8')) + except (UnicodeError, json.JSONDecodeError): + self._error(400, 'invalid_request', 'Некорректный JSON') + return None, True + if not isinstance(body, dict) or set(body) != fields: + self._error(400, 'invalid_request', 'Некорректные поля JSON') + return None, True + return body, False + + def _read_body(self): + length, problem = _parse_content_length(self.headers.get('Content-Length')) + if problem == 'missing' or problem == 'bad': + self.close_connection = True + return None, 400, 'Некорректный JSON' + if problem == 'too_big': + self._reject_too_large() + return None, 413, 'Тело запроса слишком большое' + if not _json_content_type(self.headers.get('Content-Type', '')): + self._read_exact(length) + return None, 415, 'Нужен Content-Type application/json' + raw, busy = self._read_exact(length) + if busy: + return None, 503, 'Слишком много одновременных тел запроса' + if raw is None or len(raw) != length: + self.close_connection = True + return None, 400, 'Некорректный JSON' + return raw, None, None + + def _error(self, status, code, message, retry_after=None, challenge=None): + self._json(status, { + 'error': { + 'code': code, + 'message': message, + 'request_id': self.request_id, + } + }, retry_after=retry_after, challenge=challenge) + + def _json(self, status, payload, retry_after=None, challenge=None): + if self._status != '-': + return + if status == 204: + body = b'' + else: + body = json.dumps(payload, ensure_ascii=False).encode('utf-8') + self.send_response(status) + if status != 204: + self.send_header('Content-Type', 'application/json; charset=utf-8') + self.send_header('Content-Length', str(len(body))) + self.send_header('X-Request-Id', self.request_id) + if challenge is not None: + self.send_header('WWW-Authenticate', challenge) + if retry_after is not None: + self.send_header('Retry-After', str(retry_after)) + self.end_headers() + if body: + self.wfile.write(body) + self._status = status + path = urlsplit(self.path).path + print('%s %s %s %s' % (self.request_id, self.command, path, status), flush=True) + + class Server(ThreadingHTTPServer): + allow_reuse_address = True + daemon_threads = True + + return Server((host, port), Handler) + + +def _error_code(status): + return { + 400: 'invalid_request', + 413: 'payload_too_large', + 415: 'unsupported_media_type', + 503: 'unavailable', + }.get(status, 'invalid_request') + + +def _json_content_type(value): + if not value: + return False + media = value.split(';', 1)[0].strip().lower() + return media == 'application/json' + + +def _parse_content_length(raw): + if raw is None: + return None, 'missing' + text = raw.strip() + if not re.fullmatch(r'[0-9]+', text): + return None, 'bad' + digits = text.lstrip('0') or '0' + if len(digits) > 7: + return None, 'too_big' + try: + length = int(digits) + except ValueError: + return None, 'too_big' + if length > MAX_BODY: + return length, 'too_big' + return length, None + + +def _text_ok(value, limit): + return ( + isinstance(value, str) + and 1 <= len(value) <= limit + and value.strip() != '' + ) + + +def _password_ok(value): + return ( + isinstance(value, str) + and 12 <= len(value) <= 128 + and value.strip() != '' + ) + + +def _member_ids(value, owner_id): + if not isinstance(value, list) or not 1 <= len(value) <= 100: + return None, False + parsed = [] + for item in value: + item_id = canonical_uuid(item) + if item_id is None: + return None, False + parsed.append(item_id) + if len(set(parsed)) != len(parsed): + return None, False + if owner_id not in parsed: + return None, False + return parsed, True + + +def _page_args(query, kind, owner_id): + if 'limit' not in query: + limit = 50 + else: + raw = query['limit'] + if len(raw) != 1 or re.fullmatch(r'[0-9]+', raw[0]) is None: + return None, None, 'Некорректный limit' + digits = raw[0].lstrip('0') or '0' + if len(digits) > 3: + return None, None, 'Некорректный limit' + try: + limit = int(digits) + except ValueError: + return None, None, 'Некорректный limit' + if limit < 1 or limit > 100: + return None, None, 'Некорректный limit' + if 'cursor' not in query: + return limit, None, None + raw_cursor = query['cursor'] + if len(raw_cursor) != 1 or raw_cursor[0] == '': + return None, None, 'Некорректный cursor' + page_cursor = cursor.read_cursor(raw_cursor[0], kind, owner_id) + if page_cursor is None: + return None, None, 'Некорректный cursor' + return limit, page_cursor, None + + +def _authorization(header): + if not header: + return None, None + parts = header.split(None, 1) + if len(parts) != 2: + return None, None + return parts[0].lower(), parts[1].strip() + + +def _basic_credentials(header): + scheme, value = _authorization(header) + if scheme != 'basic' or not value: + return None, None + try: + raw = base64.b64decode(value, validate=True) + text = raw.decode('utf-8') + except (ValueError, UnicodeError): + return None, None + if ':' not in text: + return None, None + username, password = text.split(':', 1) + if USERNAME.fullmatch(username) is None or password == '': + return None, None + return username, password + + +def _positive_int(name, default): + raw = os.environ.get(name, str(default)) + try: + value = int(raw) + except ValueError: + print('bad integer %s' % name, flush=True) + return None + return value + + +def wait_until_ready(stop): + deadline = time.monotonic() + 75 + while not stop['flag']: + try: + applied = db.apply_migrations() + db.open_pool() + sessions.open_client() + sessions.ping() + db.ping() + if applied: + print('migrations applied: %s' % ','.join(applied), flush=True) + else: + print('migrations already applied', flush=True) + return True + except RuntimeError: + print('configuration error', flush=True) + return False + except Exception as exc: + print('waiting for postgres/redis: %s' % type(exc).__name__, flush=True) + db.close_pool() + sessions.close_client() + if time.monotonic() > deadline: + print('dependencies not ready', flush=True) + return False + time.sleep(1) + return False + + +def main(): + host = os.environ.get('APP_HOST', '0.0.0.0') + port = _positive_int('APP_PORT', 8080) + message_cap = _positive_int('MAX_MESSAGES', 100000) + max_per_second = _positive_int('MAX_PER_SECOND', 10000) + max_inflight_bodies = _positive_int('MAX_INFLIGHT_BODIES', DEFAULT_INFLIGHT_BODIES) + ttl = _positive_int('SESSION_TTL_SECONDS', 3600) + if None in (port, message_cap, max_per_second, max_inflight_bodies, ttl) or ttl < 1: + sys.exit(1) + sessions.configure(ttl) + db.configure(message_cap) + stop = {'flag': False} + + def stop_waiting(signum, frame): + stop['flag'] = True + print('signal %s during startup' % signum, flush=True) + + signal.signal(signal.SIGTERM, stop_waiting) + signal.signal(signal.SIGINT, stop_waiting) + if not wait_until_ready(stop): + db.close_pool() + sessions.close_client() + sys.exit(0 if stop['flag'] else 1) + + state = State(max_inflight_bodies) + limiter = Limiter(max_per_second) + httpd = make_server(state, limiter, host, port) + + def stop_serving(signum, frame): + state.accepting = False + print('signal %s: stop accepting' % signum, flush=True) + threading.Thread(target=httpd.shutdown, daemon=True).start() + + signal.signal(signal.SIGTERM, stop_serving) + signal.signal(signal.SIGINT, stop_serving) + print( + 'listen http://%s:%s ttl=%s max_messages=%s pool=%s-%s' + % (host, port, ttl, message_cap, db.POOL_MIN, db.POOL_MAX), + flush=True, + ) + try: + httpd.serve_forever() + finally: + httpd.server_close() + db.close_pool() + sessions.close_client() + print('process stopped', flush=True) + + +if __name__ == '__main__': + main() diff --git a/src/cursor.py b/src/cursor.py new file mode 100644 index 0000000..7d4ec25 --- /dev/null +++ b/src/cursor.py @@ -0,0 +1,59 @@ +import base64 +import re +import uuid +from datetime import datetime + +# Same cursor as lab1. The page query itself moved into PostgreSQL. +_CURSOR_TOKEN = re.compile(r'^[A-Za-z0-9_-]+={0,2}$') + + +def cursor_token(kind, owner_id, created_at, item_id): + raw = '|'.join((kind, owner_id, created_at, item_id)) + return base64.urlsafe_b64encode(raw.encode('ascii')).decode('ascii') + + +def _timestamp_ok(value): + if not isinstance(value, str) or not value.endswith('Z'): + return False + if not 20 <= len(value) <= 32: + return False + for fmt in ('%Y-%m-%dT%H:%M:%S.%fZ', '%Y-%m-%dT%H:%M:%SZ'): + try: + datetime.strptime(value, fmt) + except ValueError: + continue + else: + return True + return False + + +def _decode_cursor(token): + if len(token) % 4 == 1: + raise ValueError('bad base64 length') + padded = token + '=' * (-len(token) % 4) + try: + return base64.b64decode(padded.encode('ascii'), altchars=b'-_', validate=True) + except TypeError: + return base64.b64decode(padded.encode('ascii'), altchars=b'-_') + + +def read_cursor(token, kind, owner_id): + if not isinstance(token, str) or _CURSOR_TOKEN.fullmatch(token) is None: + return None + try: + raw = _decode_cursor(token) + canonical = base64.urlsafe_b64encode(raw).decode('ascii') + if canonical.rstrip('=') != token.rstrip('='): + return None + parts = raw.decode('ascii').split('|') + if len(parts) != 4: + return None + got_kind, got_owner, created_at, item_id = parts + if got_kind != kind or got_owner != owner_id: + return None + if not _timestamp_ok(created_at): + return None + item_id = str(uuid.UUID(item_id)) + except (ValueError, UnicodeError): + return None + return created_at, item_id diff --git a/src/db.py b/src/db.py new file mode 100644 index 0000000..9a9870b --- /dev/null +++ b/src/db.py @@ -0,0 +1,459 @@ +import os +import threading +import uuid +from datetime import datetime, timedelta, timezone +from pathlib import Path + +import psycopg +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool, PoolTimeout + +import cursor +from errors import DependencyDown +from timefmt import format_z, parse_z + +# Serialises only the message cap. Registration stays unlocked so the unique index decides the race. +MESSAGE_LOCK = 814202 + + +def _uuid(value): + if isinstance(value, uuid.UUID): + return value + return uuid.UUID(str(value)) +POOL_MIN = 1 +POOL_MAX = 8 +POOL_TIMEOUT_SECONDS = 5 +CONNECT_TIMEOUT_SECONDS = 3 +STATEMENT_TIMEOUT_MS = 3000 +LOCK_TIMEOUT_MS = 2000 + +pool = None +max_messages = 100000 +_clock_lock = threading.Lock() +_last_stamp = None + + +def database_url(): + file_path = os.environ.get('DATABASE_URL_FILE') + if file_path: + return Path(file_path).read_text(encoding='utf-8').strip() + url = os.environ.get('DATABASE_URL', '').strip() + if not url: + raise RuntimeError('DATABASE_URL is not set') + return url + + +def migrations_dir(): + override = os.environ.get('MIGRATIONS_DIR') + if override: + return Path(override) + return Path(__file__).resolve().parents[1] / 'migrations' + + +def _statements(sql): + lines = [] + for line in sql.splitlines(): + if line.strip().startswith('--'): + continue + lines.append(line) + parts = [] + for part in '\n'.join(lines).split(';'): + statement = part.strip() + if statement: + parts.append(statement) + return parts + + +def apply_migrations(conninfo=None): + """Apply pending SQL files. A second call inserts nothing and returns [].""" + conninfo = conninfo or database_url() + applied = [] + with psycopg.connect(conninfo, connect_timeout=CONNECT_TIMEOUT_SECONDS, row_factory=dict_row) as conn: + conn.execute( + """ + CREATE TABLE IF NOT EXISTS schema_migrations ( + version text PRIMARY KEY, + applied_at timestamptz NOT NULL DEFAULT now() + ) + """ + ) + conn.commit() + done = {row['version'] for row in conn.execute('SELECT version FROM schema_migrations')} + for path in sorted(migrations_dir().glob('*.sql')): + if path.name in done: + continue + sql = path.read_text(encoding='utf-8') + with conn.transaction(): + for statement in _statements(sql): + conn.execute(statement) + conn.execute( + 'INSERT INTO schema_migrations (version) VALUES (%s)', + (path.name,), + ) + applied.append(path.name) + return applied + + +def open_pool(): + global pool + if pool is not None: + return pool + options = '-c statement_timeout=%s -c lock_timeout=%s -c timezone=UTC -c application_name=messenger' % ( + STATEMENT_TIMEOUT_MS, + LOCK_TIMEOUT_MS, + ) + pool = ConnectionPool( + database_url(), + min_size=POOL_MIN, + max_size=POOL_MAX, + timeout=POOL_TIMEOUT_SECONDS, + max_waiting=32, + reconnect_timeout=5, + check=ConnectionPool.check_connection, + kwargs={ + 'connect_timeout': CONNECT_TIMEOUT_SECONDS, + 'row_factory': dict_row, + 'application_name': 'messenger', + 'options': options, + }, + open=False, + ) + pool.open(wait=True, timeout=10) + return pool + + +def close_pool(): + global pool + if pool is not None: + pool.close() + pool = None + + +def configure(message_cap): + global max_messages + max_messages = int(message_cap) + + +def _guard(fn): + try: + return fn() + except (psycopg.OperationalError, psycopg.InterfaceError, PoolTimeout) as exc: + raise DependencyDown(type(exc).__name__) from None + + +def ping(): + def run(): + with pool.connection() as conn: + with conn.transaction(): + conn.execute('SELECT 1') + _guard(run) + + +def stamp(): + """Wall clock, but never goes backwards inside this process. + + Two inserts in the same microsecond would make the page order depend on + UUID byte order. Bumping one microsecond keeps (created_at, id) stable. + """ + global _last_stamp + with _clock_lock: + current = datetime.now(timezone.utc) + if _last_stamp is not None and current <= _last_stamp: + current = _last_stamp + timedelta(microseconds=1) + _last_stamp = current + return current + + +def _user_out(row): + return { + 'id': str(row['id']), + 'username': row['username'], + 'display_name': row['display_name'], + 'created_at': format_z(row['created_at']), + } + + +def _message_out(row): + return { + 'id': str(row['id']), + 'chat_id': str(row['chat_id']), + 'sender_id': str(row['sender_id']), + 'text': row['body'], + 'created_at': format_z(row['created_at']), + } + + +def create_user(username, display_name, password_hash): + user_id = str(uuid.uuid4()) + created = stamp() + + def run(): + try: + with pool.connection() as conn: + with conn.transaction(): + row = conn.execute( + """ + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES (%s, %s, %s, %s, %s) + RETURNING id, username, display_name, created_at + """, + (_uuid(user_id), username, display_name, password_hash, created), + ).fetchone() + return 'ok', _user_out(row) + except psycopg.errors.UniqueViolation: + return 'conflict', None + except psycopg.errors.CheckViolation: + return 'bad', None + + return _guard(run) + + +def get_user(user_id): + def run(): + with pool.connection() as conn: + with conn.transaction(): + row = conn.execute( + """ + SELECT id, username, display_name, created_at + FROM users + WHERE id = %s + """, + (_uuid(user_id),), + ).fetchone() + return None if row is None else _user_out(row) + + return _guard(run) + + +def get_credentials(username): + def run(): + with pool.connection() as conn: + with conn.transaction(): + row = conn.execute( + """ + SELECT id, username, display_name, created_at, password_hash + FROM users + WHERE username = %s + """, + (username,), + ).fetchone() + if row is None: + return None + return _user_out(row), row['password_hash'] + + return _guard(run) + + +def _members(conn, chat_ids): + if not chat_ids: + return {} + rows = conn.execute( + """ + SELECT chat_id, user_id + FROM chat_members + WHERE chat_id = ANY(%s) + ORDER BY chat_id, member_ord + """, + ([_uuid(item) for item in chat_ids],), + ).fetchall() + grouped = {} + for row in rows: + grouped.setdefault(str(row['chat_id']), []).append(str(row['user_id'])) + return grouped + + +def _chat_out(row, member_ids): + return { + 'id': str(row['id']), + 'title': row['title'], + 'member_ids': member_ids, + 'created_at': format_z(row['created_at']), + } + + +def create_chat(owner_id, title, member_ids): + chat_id = str(uuid.uuid4()) + created = stamp() + + def run(): + try: + with pool.connection() as conn: + with conn.transaction(): + conn.execute( + """ + INSERT INTO chats (id, title, created_at) + VALUES (%s, %s, %s) + """, + (_uuid(chat_id), title, created), + ) + for ordinal, member_id in enumerate(member_ids): + conn.execute( + """ + INSERT INTO chat_members (chat_id, user_id, member_ord) + VALUES (%s, %s, %s) + """, + (_uuid(chat_id), _uuid(member_id), ordinal), + ) + row = conn.execute( + """ + SELECT id, title, created_at + FROM chats + WHERE id = %s + """, + (_uuid(chat_id),), + ).fetchone() + members = _members(conn, [chat_id]).get(chat_id, []) + return 'ok', _chat_out(row, members) + except (psycopg.errors.ForeignKeyViolation, psycopg.errors.UniqueViolation, psycopg.errors.CheckViolation): + return 'bad', None + + return _guard(run) + + +def get_chat(chat_id, user_id): + def run(): + with pool.connection() as conn: + with conn.transaction(): + row = conn.execute( + """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s + WHERE c.id = %s + """, + (_uuid(user_id), _uuid(chat_id)), + ).fetchone() + if row is None: + return None + members = _members(conn, [chat_id]).get(chat_id, []) + return _chat_out(row, members) + + return _guard(run) + + +def list_chats(user_id, limit, cursor_pair): + def run(): + with pool.connection() as conn: + with conn.transaction(): + if cursor_pair is None: + rows = conn.execute( + """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s + ORDER BY c.created_at, c.id + LIMIT %s + """, + (_uuid(user_id), limit + 1), + ).fetchall() + else: + rows = conn.execute( + """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s + WHERE (c.created_at, c.id) > (%s, %s) + ORDER BY c.created_at, c.id + LIMIT %s + """, + (_uuid(user_id), parse_z(cursor_pair[0]), _uuid(cursor_pair[1]), limit + 1), + ).fetchall() + members = _members(conn, [row['id'] for row in rows[:limit]]) + extra = len(rows) > limit + page = rows[:limit] + items = [_chat_out(row, members.get(str(row['id']), [])) for row in page] + if extra and items: + last = items[-1] + nxt = cursor.cursor_token('chats', user_id, last['created_at'], last['id']) + else: + nxt = None + return items, nxt + + return _guard(run) + + +def add_message(chat_id, sender_id, text): + message_id = str(uuid.uuid4()) + created = stamp() + + def run(): + with pool.connection() as conn: + with conn.transaction(): + conn.execute('SELECT pg_advisory_xact_lock(%s)', (MESSAGE_LOCK,)) + count = conn.execute('SELECT count(*) AS n FROM messages').fetchone()['n'] + if count >= max_messages: + return 'full', None + row = conn.execute( + """ + INSERT INTO messages (id, chat_id, sender_id, body, created_at) + SELECT %s, %s, %s, %s, %s + WHERE EXISTS ( + SELECT 1 FROM chat_members + WHERE chat_id = %s AND user_id = %s + ) + RETURNING id, chat_id, sender_id, body, created_at + """, + ( + _uuid(message_id), + _uuid(chat_id), + _uuid(sender_id), + text, + created, + _uuid(chat_id), + _uuid(sender_id), + ), + ).fetchone() + if row is None: + return 'missing', None + return 'ok', _message_out(row) + + return _guard(run) + + +def list_messages(chat_id, user_id, limit, cursor_pair): + def run(): + with pool.connection() as conn: + with conn.transaction(): + member = conn.execute( + """ + SELECT 1 AS ok + FROM chat_members + WHERE user_id = %s AND chat_id = %s + """, + (_uuid(user_id), _uuid(chat_id)), + ).fetchone() + if member is None: + return 'missing', None, None + if cursor_pair is None: + rows = conn.execute( + """ + SELECT id, chat_id, sender_id, body, created_at + FROM messages + WHERE chat_id = %s + ORDER BY created_at, id + LIMIT %s + """, + (_uuid(chat_id), limit + 1), + ).fetchall() + else: + rows = conn.execute( + """ + SELECT id, chat_id, sender_id, body, created_at + FROM messages + WHERE chat_id = %s + AND (created_at, id) > (%s, %s) + ORDER BY created_at, id + LIMIT %s + """, + (_uuid(chat_id), parse_z(cursor_pair[0]), _uuid(cursor_pair[1]), limit + 1), + ).fetchall() + extra = len(rows) > limit + page = [_message_out(row) for row in rows[:limit]] + if extra and page: + last = page[-1] + nxt = cursor.cursor_token('msgs', chat_id, last['created_at'], last['id']) + else: + nxt = None + return 'ok', page, nxt + + return _guard(run) diff --git a/src/errors.py b/src/errors.py new file mode 100644 index 0000000..0847764 --- /dev/null +++ b/src/errors.py @@ -0,0 +1,2 @@ +class DependencyDown(Exception): + """Postgres or Redis did not answer. The message stays off the HTTP body.""" diff --git a/src/passwords.py b/src/passwords.py new file mode 100644 index 0000000..9f03050 --- /dev/null +++ b/src/passwords.py @@ -0,0 +1,25 @@ +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError, VerifyMismatchError + +# OWASP Argon2id baseline. bcrypt would cut a long UTF-8 password at 72 bytes. +HASHER = PasswordHasher( + time_cost=2, + memory_cost=19456, + parallelism=1, + hash_len=32, + salt_len=16, +) + +# One hash so a missing username still pays for a verify. +DUMMY_HASH = HASHER.hash('not-a-real-password') + + +def hash_password(password): + return HASHER.hash(password) + + +def verify_password(password_hash, password): + try: + return HASHER.verify(password_hash, password) + except (VerifyMismatchError, VerificationError, InvalidHashError): + return False diff --git a/src/sessions.py b/src/sessions.py new file mode 100644 index 0000000..5dff42b --- /dev/null +++ b/src/sessions.py @@ -0,0 +1,127 @@ +import hashlib +import json +import os +import re +import secrets +import uuid +from datetime import datetime, timedelta, timezone +from pathlib import Path + +import redis + +from errors import DependencyDown +from timefmt import format_z, parse_z + +# Opaque bearer token, at least 256 bits. Redis stores only the SHA-256 of it. +TOKEN_SHAPE = re.compile(r'^[A-Za-z0-9_-]{32,128}$') +SOCKET_TIMEOUT_SECONDS = 1 + +client = None +ttl_seconds = 3600 + + +def redis_url(): + for name in ('REDIS_URL_FILE', 'CACHE_URL_FILE'): + file_path = os.environ.get(name) + if file_path: + return Path(file_path).read_text(encoding='utf-8').strip() + url = os.environ.get('REDIS_URL', '').strip() + if not url: + raise RuntimeError('REDIS_URL is not set') + return url + + +def configure(ttl): + global ttl_seconds + ttl_seconds = int(ttl) + if ttl_seconds < 1: + raise RuntimeError('SESSION_TTL_SECONDS must be >= 1') + + +def open_client(): + global client + if client is not None: + return client + client = redis.Redis.from_url( + redis_url(), + socket_connect_timeout=SOCKET_TIMEOUT_SECONDS, + socket_timeout=SOCKET_TIMEOUT_SECONDS, + decode_responses=True, + ) + return client + + +def close_client(): + global client + if client is not None: + client.close() + client = None + + +def _key(token): + digest = hashlib.sha256(token.encode('utf-8')).hexdigest() + return 'sess:' + digest + + +def _guard(fn): + try: + return fn() + except redis.RedisError as exc: + raise DependencyDown(type(exc).__name__) from None + + +def ping(): + _guard(lambda: client.ping()) + + +def token_shape(token): + return isinstance(token, str) and TOKEN_SHAPE.fullmatch(token) is not None + + +def create(user_id): + token = secrets.token_urlsafe(32) + expires = datetime.now(timezone.utc) + timedelta(seconds=ttl_seconds) + payload = json.dumps({ + 'user_id': user_id, + 'expires_at': format_z(expires), + }, separators=(',', ':')) + + def run(): + # ex= is the Redis TTL. A restart does not extend it. + client.set(_key(token), payload, ex=ttl_seconds) + return token, format_z(expires) + + return _guard(run) + + +def read(token): + if not token_shape(token): + return None + + def run(): + raw = client.get(_key(token)) + if raw is None: + return None + try: + payload = json.loads(raw) + user_id = str(uuid.UUID(payload['user_id'])) + expires = parse_z(payload['expires_at']) + except (ValueError, KeyError, TypeError): + client.delete(_key(token)) + return None + if expires <= datetime.now(timezone.utc): + client.delete(_key(token)) + return None + return user_id + + return _guard(run) + + +def revoke(token): + if not token_shape(token): + return False + + def run(): + return client.delete(_key(token)) == 1 + + return _guard(run) diff --git a/src/timefmt.py b/src/timefmt.py new file mode 100644 index 0000000..6969250 --- /dev/null +++ b/src/timefmt.py @@ -0,0 +1,17 @@ +from datetime import datetime, timezone + + +def format_z(value): + if value.tzinfo is None: + value = value.replace(tzinfo=timezone.utc) + value = value.astimezone(timezone.utc) + return value.strftime('%Y-%m-%dT%H:%M:%S.%fZ') + + +def parse_z(value): + for fmt in ('%Y-%m-%dT%H:%M:%S.%fZ', '%Y-%m-%dT%H:%M:%SZ'): + try: + return datetime.strptime(value, fmt).replace(tzinfo=timezone.utc) + except ValueError: + continue + raise ValueError('bad timestamp') diff --git a/student-tests/api.py b/student-tests/api.py new file mode 100644 index 0000000..9b62278 --- /dev/null +++ b/student-tests/api.py @@ -0,0 +1,37 @@ +import json +import urllib.error +import urllib.request + + +def request(method, path, base='http://127.0.0.1:8080', body=None, headers=None, timeout=10): + data = None + hdrs = {} + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode('utf-8') + hdrs['Content-Type'] = 'application/json' + if headers: + hdrs.update(headers) + req = urllib.request.Request(base + path, data=data, headers=hdrs, method=method) + try: + response = urllib.request.urlopen(req, timeout=timeout) + except urllib.error.HTTPError as error: + response = error + with response: + raw = response.read() + payload = None + if raw: + try: + payload = json.loads(raw.decode('utf-8')) + except (UnicodeError, json.JSONDecodeError): + payload = None + return response.status, response.headers, payload + + +def basic(username, password): + import base64 + token = base64.b64encode((username + ':' + password).encode('utf-8')).decode('ascii') + return {'Authorization': 'Basic ' + token} + + +def bearer(token): + return {'Authorization': 'Bearer ' + token} diff --git a/student-tests/check_dependencies.py b/student-tests/check_dependencies.py new file mode 100644 index 0000000..b6f2933 --- /dev/null +++ b/student-tests/check_dependencies.py @@ -0,0 +1,163 @@ +"""Logout is covered in test_api.py. This script checks expiry and a dead Redis or Postgres. + +It stops containers and starts them again. Do not run it in parallel with smoke. +""" +import json +import subprocess +import time +import uuid +from datetime import datetime, timezone +from pathlib import Path + +from api import basic, bearer, request + +ROOT = Path(__file__).resolve().parents[1] +EVIDENCE = ROOT / 'evidence' + + +def docker(*args, check=True): + return subprocess.run(['docker', *args], cwd=ROOT, check=check, capture_output=True, text=True) + + +def wait_ready(base, timeout=60): + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + try: + status, _, payload = request('GET', '/health/ready', base=base, timeout=3) + if status == 200 and payload == {'status': 'ok'}: + return True + except Exception: + pass + time.sleep(0.5) + return False + + +def account(base): + username = 'dep_' + uuid.uuid4().hex[:8] + password = 'dep-password-1' + status, _, user = request('POST', '/api/v1/users', base=base, body={ + 'username': username, + 'display_name': 'Проверка', + 'password': password, + }) + if status != 201: + raise SystemExit('register failed: %s' % status) + status, _, session = request('POST', '/api/v1/auth/sessions', base=base, headers=basic(username, password)) + if status != 201: + raise SystemExit('login failed: %s' % status) + return user, session['token'], session['expires_at'] + + +def expect(name, method, path, code, base='http://127.0.0.1:8080', headers=None): + status, response_headers, payload = request(method, path, base=base, headers=headers, timeout=12) + if status != code: + raise SystemExit('%s: expected %s, got %s %s' % (name, code, status, payload)) + return { + 'name': name, + 'status': status, + 'code': None if payload is None else payload.get('error', {}).get('code'), + 'www_authenticate': response_headers.get('WWW-Authenticate'), + } + + +def redis_and_postgres(): + base = 'http://127.0.0.1:8080' + if not wait_ready(base): + raise SystemExit('API was not ready') + user, token, _ = account(base) + auth = bearer(token) + status, _, chat = request('POST', '/api/v1/chats', base=base, headers=auth, body={ + 'title': 'зависимость', + 'member_ids': [user['id']], + }) + if status != 201: + raise SystemExit('chat failed') + status, _, message = request( + 'POST', '/api/v1/chats/%s/messages' % chat['id'], + base=base, headers=auth, body={'text': 'до отказа'}, + ) + if status != 201: + raise SystemExit('message failed') + rows = [] + + docker('stop', 'mtusi-lab2-redis') + try: + rows.append(expect('redis down, no token', 'GET', '/api/v1/users/me', 401)) + rows.append(expect('redis down, bearer', 'GET', '/api/v1/users/me', 503, headers=auth)) + rows.append(expect('redis down, live', 'GET', '/health/live', 200)) + rows.append(expect('redis down, ready', 'GET', '/health/ready', 503)) + finally: + docker('start', 'mtusi-lab2-redis') + if not wait_ready(base): + raise SystemExit('API did not recover after redis start') + rows.append(expect('redis back, same token', 'GET', '/api/v1/users/me', 200, headers=auth)) + status, _, page = request('GET', '/api/v1/chats/%s/messages?limit=10' % chat['id'], headers=auth) + if status != 200 or page['items'] != [message]: + raise SystemExit('message lost across redis stop') + rows.append({'name': 'history after redis stop', 'status': 200, 'same_message': True}) + + docker('stop', 'mtusi-lab2-postgres') + try: + rows.append(expect('postgres down, no token', 'GET', '/api/v1/users/me', 401)) + rows.append(expect('postgres down, bearer', 'GET', '/api/v1/users/me', 503, headers=auth)) + rows.append(expect('postgres down, live', 'GET', '/health/live', 200)) + rows.append(expect('postgres down, ready', 'GET', '/health/ready', 503)) + finally: + docker('start', 'mtusi-lab2-postgres') + if not wait_ready(base, timeout=90): + raise SystemExit('API did not recover after postgres start') + rows.append(expect('postgres back, same token', 'GET', '/api/v1/users/me', 200, headers=auth)) + status, _, page = request('GET', '/api/v1/chats/%s/messages?limit=10' % chat['id'], headers=auth) + if status != 200 or page['items'] != [message]: + raise SystemExit('message lost across postgres stop') + rows.append({'name': 'history after postgres stop', 'status': 200, 'same_message': True}) + return rows + + +def short_ttl(): + subprocess.run( + ['docker', 'compose', '--env-file', '.env', '--profile', 'shortttl', 'up', '-d', 'api-short'], + cwd=ROOT, check=True, + ) + base = 'http://127.0.0.1:8081' + try: + if not wait_ready(base, timeout=90): + raise SystemExit('short TTL API was not ready') + _, token, expires_at = account(base) + expires = datetime.fromisoformat(expires_at.replace('Z', '+00:00')) + delta = (expires - datetime.now(timezone.utc)).total_seconds() + if not 0 < delta < 10: + raise SystemExit('expected a short session, delta=%s' % delta) + status, _, _ = request('GET', '/api/v1/users/me', base=base, headers=bearer(token)) + if status != 200: + raise SystemExit('fresh short session was rejected') + time.sleep(delta + 1.5) + status, headers, payload = request('GET', '/api/v1/users/me', base=base, headers=bearer(token), timeout=10) + if status != 401: + raise SystemExit('expired session returned %s' % status) + return { + 'ttl_window_seconds': round(delta, 3), + 'after_expiry': status, + 'www_authenticate': headers.get('WWW-Authenticate'), + 'error_code': payload['error']['code'], + } + finally: + docker('stop', 'mtusi-lab2-api-short', check=False) + + +def main(): + report = { + 'redis_and_postgres': redis_and_postgres(), + 'short_ttl': short_ttl(), + } + EVIDENCE.mkdir(exist_ok=True) + (EVIDENCE / 'dependencies.json').write_text( + json.dumps(report, ensure_ascii=False, indent=2) + '\n', + encoding='utf-8', + ) + print('PASS dependencies') + print(json.dumps(report, ensure_ascii=False, indent=2)) + + +if __name__ == '__main__': + main() diff --git a/student-tests/experiment_track2.py b/student-tests/experiment_track2.py new file mode 100644 index 0000000..b26ca6f --- /dev/null +++ b/student-tests/experiment_track2.py @@ -0,0 +1,517 @@ +"""Track 2: uneven history, two indexes, backup into a new Postgres volume. + +The bench database is not the API database. Scratch containers are removed at the end. +""" +import json +import platform +import subprocess +import sys +import time +import uuid +from datetime import datetime, timedelta, timezone +from pathlib import Path + +import psycopg + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'src')) +import db # noqa: E402 + +EVIDENCE = ROOT / 'evidence' +BACKUPS = ROOT / 'backups' +RESTORE_NAME = 'mtusi-lab2-restore' +RESTORE_VOLUME = 'mtusi-lab2-restore-data' + + +def load_env(): + env = {} + for line in (ROOT / '.env').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] = value + return env + + +def connect(url): + return psycopg.connect(url, connect_timeout=10) + + +def chat_sizes(): + sizes = [80000] + [4000] * 4 + [300] * 10 + [40] * 20 + [10] * 20 + [1] * 100 + if sum(sizes) < 100000: + raise SystemExit('fixture is smaller than 100000 messages') + return sizes + + +def reset_bench(admin_url): + with psycopg.connect(admin_url, autocommit=True) as conn: + conn.execute( + """ + SELECT pg_terminate_backend(pid) + FROM pg_stat_activity + WHERE datname = 'messenger_bench' AND pid <> pg_backend_pid() + """ + ) + conn.execute('DROP DATABASE IF EXISTS messenger_bench') + conn.execute('CREATE DATABASE messenger_bench') + + +def seed(url): + users = [] + with connect(url) as conn: + for name in ('bench_a', 'bench_b', 'bench_c'): + user_id = uuid.uuid4() + conn.execute( + """ + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES (%s, %s, %s, %s, %s) + """, + (user_id, name, 'Стенд ' + name, 'bench-not-a-login-hash', datetime.now(timezone.utc)), + ) + users.append(user_id) + conn.commit() + + sizes = chat_sizes() + chats = [] + for index, size in enumerate(sizes): + chat_id = uuid.uuid4() + conn.execute( + 'INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)', + (chat_id, 'чат %s' % index, datetime.now(timezone.utc)), + ) + member_ids = users if size >= 4000 else users[:1] + for ordinal, member_id in enumerate(member_ids): + conn.execute( + """ + INSERT INTO chat_members (chat_id, user_id, member_ord) + VALUES (%s, %s, %s) + """, + (chat_id, member_id, ordinal), + ) + chats.append((chat_id, size)) + conn.commit() + + samples = {} + base = datetime(2026, 1, 1, tzinfo=timezone.utc) + # Spread one chat's messages across the whole timeline. An index on + # created_at alone then has to skip other chats; (chat_id, created_at, id) does not. + chat_count = len(chats) + sender = users[0] + with conn.cursor() as cur: + with cur.copy( + 'COPY messages (id, chat_id, sender_id, body, created_at) FROM STDIN' + ) as copy: + for chat_index, (chat_id, size) in enumerate(chats): + for i in range(size): + message_id = uuid.uuid4() + created = base + timedelta(microseconds=i * chat_count + chat_index) + if i % 1000 == 0: + body = ('длинное-%s-' % i) + ('я' * 180) + else: + body = 'm-%s-%s' % (chat_index, i) + copy.write_row((message_id, chat_id, sender, body, created)) + mark = { + 'id': str(message_id), + 'chat_id': str(chat_id), + 'sender_id': str(sender), + 'body': body, + 'created_at': created.strftime('%Y-%m-%dT%H:%M:%S.%fZ'), + } + if chat_index == 0 and i == 0: + samples['huge_first'] = mark + elif chat_index == 0 and i == 40000: + samples['huge_middle'] = mark + elif chat_index == 0 and i == size - 1: + samples['huge_last'] = mark + elif chat_index == 1 and i == 2000: + samples['medium'] = mark + elif size == 1 and 'tiny' not in samples: + samples['tiny'] = mark + if chat_index % 20 == 0: + print('seeded chat %s/%s' % (chat_index + 1, len(chats)), flush=True) + conn.commit() + conn.execute('ANALYZE users, chats, chat_members, messages') + conn.commit() + huge_id = chats[0][0] + return { + 'sizes': sizes, + 'samples': samples, + 'huge_chat_id': str(huge_id), + 'sender_id': str(sender), + 'message_count': sum(sizes), + 'chat_count': len(sizes), + 'user_count': len(users), + } + + +def explain(conn, sql, params): + text = '' + for _ in range(2): + rows = conn.execute('EXPLAIN (ANALYZE, BUFFERS) ' + sql, params).fetchall() + text = '\n'.join(row[0] for row in rows) + return text + + +def summary_line(text, needle): + for line in text.splitlines(): + if needle in line: + return line.strip() + return '' + + +def plan_brief(text): + scan = '' + for line in text.splitlines(): + stripped = line.strip() + if 'Scan' in stripped or 'Seq Scan' in stripped: + scan = stripped + break + return { + 'scan': scan, + 'buffers': summary_line(text, 'Buffers:'), + 'execution_time': summary_line(text, 'Execution Time:'), + 'planning_time': summary_line(text, 'Planning Time:'), + } + + +KEYSET = """ +SELECT id, chat_id, sender_id, body, created_at +FROM messages +WHERE chat_id = %s + AND (created_at, id) > (%s, %s) +ORDER BY created_at, id +LIMIT 50 +""" + +OFFSET = """ +SELECT id, chat_id, sender_id, body, created_at +FROM messages +WHERE chat_id = %s +ORDER BY created_at, id +OFFSET 40000 +LIMIT 50 +""" + + +def _mark_params(mark): + created = datetime.strptime(mark['created_at'], '%Y-%m-%dT%H:%M:%S.%fZ').replace(tzinfo=timezone.utc) + return (uuid.UUID(mark['chat_id']), created, uuid.UUID(mark['id'])) + + +def plans(url, seeded): + # Page inside the 80k chat. Past the smaller chats this timestamp is mostly one chat, + # so the created_at-only index is judged on the 4k chat instead, where other chats still overlap. + huge_params = _mark_params(seeded['samples']['huge_middle']) + medium_params = _mark_params(seeded['samples']['medium']) + huge = uuid.UUID(seeded['huge_chat_id']) + with connect(url) as conn: + keyset = explain(conn, KEYSET, huge_params) + offset = explain(conn, OFFSET, (huge,)) + conn.execute('DROP INDEX messages_chat_history_idx') + conn.commit() + seqscan = explain(conn, KEYSET, medium_params) + conn.execute('CREATE INDEX messages_created_only_idx ON messages (created_at)') + conn.execute('ANALYZE messages') + conn.commit() + created_only = explain(conn, KEYSET, medium_params) + conn.execute('DROP INDEX messages_created_only_idx') + started = time.perf_counter() + conn.execute( + 'CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id)' + ) + conn.commit() + create_index_ms = (time.perf_counter() - started) * 1000 + conn.execute('ANALYZE messages') + conn.commit() + return { + 'keyset': keyset, + 'offset': offset, + 'seqscan': seqscan, + 'created_only': created_only, + 'create_index_ms': round(create_index_ms, 1), + } + + +def timed_insert(conn, chat_id, sender_id, n): + base = datetime(2027, 1, 1, tzinfo=timezone.utc) + started = time.perf_counter() + try: + with conn.cursor() as cur: + with cur.copy( + 'COPY messages (id, chat_id, sender_id, body, created_at) FROM STDIN' + ) as copy: + for i in range(n): + copy.write_row(( + uuid.uuid4(), + chat_id, + sender_id, + 'cost-%s' % i, + base + timedelta(microseconds=i), + )) + return (time.perf_counter() - started) * 1000 + finally: + conn.rollback() + + +def write_cost(url, seeded): + chat_id = uuid.UUID(seeded['huge_chat_id']) + sender_id = uuid.UUID(seeded['sender_id']) + with connect(url) as conn: + with_index = timed_insert(conn, chat_id, sender_id, 2000) + conn.execute('DROP INDEX messages_chat_history_idx') + conn.commit() + without_index = timed_insert(conn, chat_id, sender_id, 2000) + conn.execute( + 'CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id)' + ) + conn.commit() + return { + 'rows': 2000, + 'with_history_index_ms': round(with_index, 1), + 'without_secondary_index_ms': round(without_index, 1), + } + + +def counts(url): + with connect(url) as conn: + row = conn.execute( + """ + SELECT + (SELECT count(*) FROM users), + (SELECT count(*) FROM chats), + (SELECT count(*) FROM chat_members), + (SELECT count(*) FROM messages), + (SELECT version()), + (SELECT current_setting('synchronous_commit')), + (SELECT current_setting('fsync')), + (SELECT current_setting('shared_buffers')) + """ + ).fetchone() + return { + 'users': row[0], + 'chats': row[1], + 'chat_members': row[2], + 'messages': row[3], + 'version': row[4], + 'synchronous_commit': row[5], + 'fsync': row[6], + 'shared_buffers': row[7], + } + + +def fetch_sample(url, message_id): + with connect(url) as conn: + row = conn.execute( + """ + SELECT id::text, chat_id::text, sender_id::text, body, + to_char(created_at AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"') + FROM messages + WHERE id = %s + """, + (uuid.UUID(message_id),), + ).fetchone() + if row is None: + return None + return { + 'id': row[0], + 'chat_id': row[1], + 'sender_id': row[2], + 'body': row[3], + 'created_at': row[4], + } + + +def dump_bench(password): + started = time.perf_counter() + # pg_dump writes the custom archive to stdout. No TTY, so the bytes stay intact. + data = subprocess.check_output( + [ + 'docker', 'exec', 'mtusi-lab2-postgres', + 'pg_dump', '-U', 'messenger', '-d', 'messenger_bench', + '-Fc', '--no-owner', '--no-acl', + ] + ) + BACKUPS.mkdir(exist_ok=True) + path = BACKUPS / 'messenger_bench.dump' + path.write_bytes(data) + return path, round(time.perf_counter() - started, 3), len(data) + + +def image_of_source(): + return subprocess.check_output( + ['docker', 'inspect', '-f', '{{.Config.Image}}', 'mtusi-lab2-postgres'], + text=True, + ).strip() + + +def restore_into_new_volume(dump_path, password, image): + subprocess.run(['docker', 'rm', '-f', RESTORE_NAME], capture_output=True) + subprocess.run(['docker', 'volume', 'rm', RESTORE_VOLUME], capture_output=True) + subprocess.run( + [ + 'docker', 'run', '-d', '--name', RESTORE_NAME, + '-e', 'POSTGRES_USER=messenger', + '-e', 'POSTGRES_PASSWORD=' + password, + '-e', 'POSTGRES_DB=messenger', + '-p', '127.0.0.1:5433:5432', + '-v', RESTORE_VOLUME + ':/var/lib/postgresql/data', + image, + ], + check=True, + capture_output=True, + ) + deadline = time.monotonic() + 90 + while time.monotonic() < deadline: + probe = subprocess.run( + ['docker', 'exec', RESTORE_NAME, 'pg_isready', '-U', 'messenger', '-d', 'messenger'], + capture_output=True, + ) + if probe.returncode == 0: + break + time.sleep(1) + else: + raise SystemExit('restore postgres did not become ready') + subprocess.run( + ['docker', 'cp', str(dump_path), RESTORE_NAME + ':/tmp/bench.dump'], + check=True, + ) + started = time.perf_counter() + subprocess.run( + [ + 'docker', 'exec', RESTORE_NAME, + 'pg_restore', '-U', 'messenger', '-d', 'messenger', + '--no-owner', '--exit-on-error', '/tmp/bench.dump', + ], + check=True, + ) + return round(time.perf_counter() - started, 3) + + +def cleanup_restore(): + subprocess.run(['docker', 'rm', '-f', RESTORE_NAME], capture_output=True) + subprocess.run(['docker', 'volume', 'rm', RESTORE_VOLUME], capture_output=True) + + +def drop_bench(admin_url): + with psycopg.connect(admin_url, autocommit=True) as conn: + conn.execute( + """ + SELECT pg_terminate_backend(pid) + FROM pg_stat_activity + WHERE datname = 'messenger_bench' AND pid <> pg_backend_pid() + """ + ) + conn.execute('DROP DATABASE IF EXISTS messenger_bench') + + +def main(): + env = load_env() + password = env['POSTGRES_PASSWORD'] + admin_url = 'postgresql://messenger:%s@127.0.0.1:5432/messenger' % password + bench_url = 'postgresql://messenger:%s@127.0.0.1:5432/messenger_bench' % password + restored_url = 'postgresql://messenger:%s@127.0.0.1:5433/messenger' % password + EVIDENCE.mkdir(exist_ok=True) + try: + print('reset bench', flush=True) + reset_bench(admin_url) + print('migrate bench', flush=True) + applied = db.apply_migrations(bench_url) + print('applied %s' % applied, flush=True) + print('seed', flush=True) + started = time.perf_counter() + seeded = seed(bench_url) + seed_seconds = round(time.perf_counter() - started, 3) + print('seeded %s messages in %ss' % (seeded['message_count'], seed_seconds), flush=True) + print('explain', flush=True) + explained = plans(bench_url, seeded) + (EVIDENCE / 'explain-keyset.txt').write_text(explained['keyset'] + '\n', encoding='utf-8') + (EVIDENCE / 'explain-offset.txt').write_text(explained['offset'] + '\n', encoding='utf-8') + (EVIDENCE / 'explain-seqscan.txt').write_text(explained['seqscan'] + '\n', encoding='utf-8') + (EVIDENCE / 'explain-created-only.txt').write_text(explained['created_only'] + '\n', encoding='utf-8') + print('write cost', flush=True) + cost = write_cost(bench_url, seeded) + source_counts = counts(bench_url) + print('dump', flush=True) + dump_path, dump_seconds, dump_bytes = dump_bench(password) + image = image_of_source() + print('restore into %s' % image, flush=True) + restore_seconds = restore_into_new_volume(dump_path, password, image) + restored_counts = counts(restored_url) + compared = {} + for name, sample in seeded['samples'].items(): + got = fetch_sample(restored_url, sample['id']) + compared[name] = got == sample + if got != sample: + print('mismatch', name, file=sys.stderr) + print('expected', sample, file=sys.stderr) + print('got', got, file=sys.stderr) + with connect(restored_url) as conn: + conn.execute('ANALYZE messages') + conn.commit() + mark = seeded['samples']['huge_middle'] + created = datetime.strptime(mark['created_at'], '%Y-%m-%dT%H:%M:%S.%fZ').replace(tzinfo=timezone.utc) + restored_plan = explain(conn, KEYSET, ( + uuid.UUID(mark['chat_id']), created, uuid.UUID(mark['id']), + )) + (EVIDENCE / 'explain-restored.txt').write_text(restored_plan + '\n', encoding='utf-8') + indexes = [] + with connect(restored_url) as conn: + indexes = [row[0] for row in conn.execute( + "SELECT indexname FROM pg_indexes WHERE tablename = 'messages' ORDER BY 1" + ).fetchall()] + report = { + 'platform': platform.platform(), + 'processor': platform.processor(), + 'python': platform.python_version(), + 'seed_seconds': seed_seconds, + 'chat_sizes_head': seeded['sizes'][:8], + 'chat_count': seeded['chat_count'], + 'smallest_chat': min(seeded['sizes']), + 'largest_chat': max(seeded['sizes']), + 'source': {key: source_counts[key] for key in ( + 'users', 'chats', 'chat_members', 'messages', 'version', + 'synchronous_commit', 'fsync', 'shared_buffers', + )}, + 'restored': {key: restored_counts[key] for key in ( + 'users', 'chats', 'chat_members', 'messages', + )}, + 'counts_match': ( + source_counts['users'] == restored_counts['users'] + and source_counts['chats'] == restored_counts['chats'] + and source_counts['chat_members'] == restored_counts['chat_members'] + and source_counts['messages'] == restored_counts['messages'] + ), + 'samples_match': compared, + 'dump_seconds': dump_seconds, + 'dump_bytes': dump_bytes, + 'restore_seconds': restore_seconds, + 'create_index_ms': explained['create_index_ms'], + 'write_cost': cost, + 'keyset': plan_brief(explained['keyset']), + 'offset': plan_brief(explained['offset']), + 'seqscan': plan_brief(explained['seqscan']), + 'created_only': plan_brief(explained['created_only']), + 'restored_keyset': plan_brief(restored_plan), + 'restored_message_indexes': indexes, + 'dump_file': 'backups/messenger_bench.dump', + } + (EVIDENCE / 'track2.json').write_text( + json.dumps(report, ensure_ascii=False, indent=2) + '\n', + encoding='utf-8', + ) + print(json.dumps(report, ensure_ascii=False, indent=2)) + if not report['counts_match'] or not all(compared.values()): + raise SystemExit('restore comparison failed') + print('PASS track2') + finally: + cleanup_restore() + try: + drop_bench(admin_url) + except Exception as exc: + print('bench cleanup: %s' % type(exc).__name__, flush=True) + + +if __name__ == '__main__': + main() diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 0000000..f299bd3 --- /dev/null +++ b/student-tests/test_api.py @@ -0,0 +1,215 @@ +import subprocess +import threading +import unittest +import uuid +from urllib.parse import quote + +from api import basic, bearer, request + + +def psql(sql): + result = subprocess.run( + [ + 'docker', 'exec', '-i', 'mtusi-lab2-postgres', + 'psql', '-U', 'messenger', '-d', 'messenger', '-v', 'ON_ERROR_STOP=1', '-tAc', sql, + ], + check=True, + capture_output=True, + text=True, + ) + return result.stdout.strip() + + +def register(username, password, display_name='Студент'): + status, headers, payload = request('POST', '/api/v1/users', body={ + 'username': username, + 'display_name': display_name, + 'password': password, + }) + return status, headers, payload + + +class ApiTests(unittest.TestCase): + def test_lab1_edges_still_hold(self): + status, headers, payload = request( + 'POST', '/api/v1/users', + body={'username': 'not a user', 'display_name': 'Имя', 'password': 'long-enough-pass'}, + headers={'Content-Type': 'application/jsonx'}, + ) + self.assertEqual(status, 415) + self.assertEqual(payload['error']['code'], 'unsupported_media_type') + self.assertTrue(headers['X-Request-Id']) + + username = 'edge_' + uuid.uuid4().hex[:8] + password = 'edge-password-1' + status, _, user = register(username, password) + self.assertEqual(status, 201) + self.assertNotIn('password', user) + self.assertNotIn('password_hash', user) + status, _, session = request('POST', '/api/v1/auth/sessions', headers=basic(username, password)) + self.assertEqual(status, 201) + token = session['token'] + auth = bearer(token) + + status, _, chat = request('POST', '/api/v1/chats', headers=auth, body={ + 'title': 'края', + 'member_ids': [user['id']], + }) + self.assertEqual(status, 201) + path = '/api/v1/chats/' + chat['id'] + '/messages' + status, _, _ = request('GET', path + '?limit=999999999', headers=auth) + self.assertEqual(status, 400) + status, _, _ = request('GET', path + '?cursor=@@@', headers=auth) + self.assertEqual(status, 400) + status, _, _ = request('POST', '/api/v1/users', body={ + 'username': username, + 'display_name': 'Имя', + 'password': 'long-enough-pass', + 'extra': 1, + }) + self.assertEqual(status, 400) + + def test_password_hash_is_argon2id_and_quotes_stay_data(self): + username = 'hash_' + uuid.uuid4().hex[:8] + password = 'hash-password-1' + display = "a'; drop table users;--" + status, _, user = register(username, password, display) + self.assertEqual(status, 201) + stored_name = psql("SELECT display_name FROM users WHERE username = '%s'" % username) + self.assertEqual(stored_name, display) + prefix = psql("SELECT left(password_hash, 9) FROM users WHERE username = '%s'" % username) + self.assertEqual(prefix, '$argon2id') + leaked = psql( + "SELECT position('%s' in password_hash) FROM users WHERE username = '%s'" % (password, username) + ) + self.assertEqual(leaked, '0') + self.assertEqual(psql("SELECT to_regclass('public.users')"), 'users') + status, headers, _ = request( + 'POST', '/api/v1/auth/sessions', + headers=basic(username, 'wrong-password'), + ) + self.assertEqual(status, 401) + self.assertTrue(headers['WWW-Authenticate'].lower().startswith('basic')) + + def test_colon_in_password_and_logout(self): + username = 'colon_' + uuid.uuid4().hex[:8] + password = 'left:right:pass' + status, _, user = register(username, password) + self.assertEqual(status, 201) + status, _, session = request('POST', '/api/v1/auth/sessions', headers=basic(username, password)) + self.assertEqual(status, 201) + auth = bearer(session['token']) + status, _, me = request('GET', '/api/v1/users/me', headers=auth) + self.assertEqual(status, 200) + self.assertEqual(me['id'], user['id']) + status, _, me = request( + 'GET', '/api/v1/users/me', + headers={**auth, 'X-User-Id': str(uuid.uuid4())}, + ) + self.assertEqual(me['id'], user['id']) + status, headers, _ = request('GET', '/api/v1/users/me', headers={'X-User-Id': user['id']}) + self.assertEqual(status, 401) + self.assertTrue(headers['WWW-Authenticate'].lower().startswith('bearer')) + status, headers, _ = request('GET', '/api/v1/users/me', headers=basic(username, password)) + self.assertEqual(status, 401) + self.assertTrue(headers['WWW-Authenticate'].lower().startswith('bearer')) + status, _, raw = request('DELETE', '/api/v1/auth/sessions/current', headers=auth) + self.assertEqual(status, 204) + self.assertIsNone(raw) + status, _, _ = request('GET', '/api/v1/users/me', headers=auth) + self.assertEqual(status, 401) + status, _, _ = request('DELETE', '/api/v1/auth/sessions/current', headers=auth) + self.assertEqual(status, 401) + + def test_duplicate_username_race(self): + username = 'race_' + uuid.uuid4().hex[:8] + password = 'race-password-1' + barrier = threading.Barrier(8) + results = [] + lock = threading.Lock() + + def once(): + barrier.wait() + status, _, _ = register(username, password) + with lock: + results.append(status) + + threads = [threading.Thread(target=once) for _ in range(8)] + for thread in threads: + thread.start() + for thread in threads: + thread.join() + self.assertEqual(results.count(201), 1, results) + self.assertEqual(results.count(409), 7, results) + self.assertEqual(psql("SELECT count(*) FROM users WHERE username = '%s'" % username), '1') + + def test_chat_create_rolls_back(self): + username = 'roll_' + uuid.uuid4().hex[:8] + password = 'roll-password-1' + status, _, user = register(username, password) + self.assertEqual(status, 201) + status, _, session = request('POST', '/api/v1/auth/sessions', headers=basic(username, password)) + auth = bearer(session['token']) + title = 'rollback_' + uuid.uuid4().hex[:10] + missing = str(uuid.uuid4()) + before = psql('SELECT count(*) FROM chats') + status, _, _ = request('POST', '/api/v1/chats', headers=auth, body={ + 'title': title, + 'member_ids': [user['id'], missing], + }) + self.assertEqual(status, 400) + self.assertEqual(psql("SELECT count(*) FROM chats WHERE title = '%s'" % title), '0') + self.assertEqual(psql('SELECT count(*) FROM chats'), before) + + def test_read_after_write_and_pages(self): + username = 'page_' + uuid.uuid4().hex[:8] + password = 'page-password-1' + status, _, user = register(username, password) + status, _, session = request('POST', '/api/v1/auth/sessions', headers=basic(username, password)) + auth = bearer(session['token']) + status, _, chat = request('POST', '/api/v1/chats', headers=auth, body={ + 'title': 'страницы', + 'member_ids': [user['id']], + }) + sent = [] + for text in ('раз', 'два', 'три'): + status, _, message = request( + 'POST', '/api/v1/chats/%s/messages' % chat['id'], + headers=auth, + body={'text': text}, + ) + self.assertEqual(status, 201) + sent.append(message) + status, _, page = request( + 'GET', '/api/v1/chats/%s/messages?limit=2' % chat['id'], + headers=auth, + ) + self.assertEqual(page['items'], sent[:2]) + self.assertIsNotNone(page['next_cursor']) + status, _, rest = request( + 'GET', '/api/v1/chats/%s/messages?limit=2&cursor=%s' % ( + chat['id'], quote(page['next_cursor'], safe=''), + ), + headers=auth, + ) + self.assertEqual(rest['items'], sent[2:]) + self.assertIsNone(rest['next_cursor']) + + def test_migrations_do_not_duplicate(self): + before = psql('SELECT count(*) FROM users') + versions = psql('SELECT count(*) FROM schema_migrations') + self.assertEqual(versions, '1') + out = subprocess.check_output( + [ + 'docker', 'exec', 'mtusi-lab2-api', 'python', '-c', + "import sys; sys.path.insert(0, '/app/src'); import db; print(len(db.apply_migrations()))", + ], + text=True, + ) + self.assertEqual(out.strip(), '0') + self.assertEqual(psql('SELECT count(*) FROM users'), before) + self.assertEqual(psql("SELECT version FROM schema_migrations"), '001_init.sql') + + +if __name__ == '__main__': + unittest.main()