реализация второй лабы

This commit is contained in:
Ванек
2026-10-22 17:16:01 +03:00
parent 9961362555
commit 0dfbfe35f8
43 changed files with 5114 additions and 337 deletions
+4
View File
@@ -3,5 +3,9 @@
!requirements.txt
!src/
!src/**
!migrations/
!migrations/**
!research/
!research/**
**/__pycache__/
**/*.py[cod]
+3 -5
View File
@@ -1,11 +1,9 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
# Local synthetic environment. init_local.py creates secrets; never commit .env or secrets/.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
HOST_PORT=8080
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
SESSION_STORE=valkey
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
+28 -14
View File
@@ -1,18 +1,32 @@
## Лабораторная 2
## ЛР 2 — целевая оценка: 5
Автор / группа: TODO
Целевая оценка (3/4/5): TODO
Трек 5, если заявлен: TODO
Трек 5: **2 — план запроса и восстановление**.
Что реализовано и что перенесено: TODO
Команды запуска из чистого clone: TODO
Результаты проверок и ссылка на REPORT.md: TODO
Ограничения / известные ошибки: TODO
Источники и использование ИИ: TODO
Перенесены API и проверки lab1 с переходом на PostgreSQL и Basic → Bearer. Добавлены версионируемые миграции, PK/FK/UNIQUE, атомарное создание чата, параметризованный SQL, ограниченный пул и таймауты. Пароли хешируются Argon2id; сессии находятся в Valkey с TTL, AOF appendfsync always и постоянным volume. X-User-Id доступа не даёт.
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
- [ ] make check и make test выполнены; приложен реальный вывод.
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
Compose запускает API, PostgreSQL и Valkey. Собственные скрипты создают локальные secrets, собирают и запускают стенд, перезапускают все сервисы с сохранением данных. Сохранены non-root, healthcheck, безопасные логи и проверка SIGTERM из первой работы.
Как проверить:
```sh
python3 -m venv .venv
.venv/bin/python -m pip install -r requirements.txt
./scripts/check-docker.sh
./scripts/research.sh
```
Публичные smoke и persistence, 23 собственных теста, гонка username и 100 сообщений от 10 клиентов прошли. Проверены rollback чата, повтор миграций, logout, неверный пароль, TTL=2 и отказы Valkey/PostgreSQL с восстановлением прежней сессии.
Трек 5: 100000 сообщений с размерами чатов 70000/20000/9000/1000, два индекса, три повтора, планы ANALYZE/BUFFERS и стоимость записи. Медиана SQL-чтения в сохранённом прогоне: 1.685 мс → 0.226 мс; размер индекса и WAL выросли. Backup восстановлен в другой контейнер с новым volume: все счётчики, 12 записей и SHA-256 всей истории совпали. Отдельно показана потеря одной записи после снимка backup.
Методика, запуск, ограничения и источники: REPORT.md. Реальные результаты: evidence/docker-checks.txt, evidence/research.txt, evidence/research.json, evidence/query-plans.json. Workflow приложения запускает оба сценария; успешный удалённый CI пока не заявлен.
Ограничения: один host, нет HA; исследование последовательное и на прогретых данных; SQL dump не включает сессии Valkey и последующие COMMIT. Помощь Codex и использование HTTP-клиента преподавателя указаны в отчёте.
- [x] Обязательные возможности lab1 сохранены с переходом API lab2.
- [x] Контракты, публичные tests и README задания сохранены.
- [x] Smoke, persistence, собственные тесты и отказы воспроизведены.
- [x] Трек 5 завершён измерениями и восстановлением в новое хранилище.
- [x] .env, secrets, volumes и dump-файлы исключены из Git.
- [x] REPORT.md содержит команды и ссылки на реальные доказательства.
+8 -3
View File
@@ -6,7 +6,7 @@ permissions:
jobs:
docker:
runs-on: ubuntu-latest
timeout-minutes: 15
timeout-minutes: 20
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
@@ -15,8 +15,13 @@ jobs:
- run: python -m venv .venv
- run: .venv/bin/python -m pip install -r requirements.txt
- run: ./scripts/check-docker.sh
- run: ./scripts/research.sh
- uses: actions/upload-artifact@v4
if: always()
with:
name: docker-checks
path: evidence/docker-checks.txt
name: lab2-evidence
path: |
evidence/docker-checks.txt
evidence/research.txt
evidence/research.json
evidence/query-plans.json
+2
View File
@@ -15,6 +15,8 @@ RUN groupadd --gid 10001 app \
&& useradd --uid 10001 --gid app --no-create-home app
COPY src/ ./src/
COPY migrations/ ./migrations/
COPY research/ ./research/
USER 10001:10001
EXPOSE 8080
+187 -22
View File
@@ -1,37 +1,202 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Савельев Иван БВТ2304
- Целевая оценка: **5**, уровень 3 + весь уровень 4 + **трек 2 «План запроса и восстановление»**.
- Commit/PR: TODO после публикации. Сохранённые проверки относятся к рабочим изменениям поверх коммита, указанного в evidence.
- Стек: Python 3.11.15 в образе, FastAPI 0.142.4, Uvicorn 0.54.0, Pydantic 2.13.5, Psycopg 3.3.6, PostgreSQL 17.6, Valkey 8.1.3, Argon2id. Прямые и транзитивные зависимости приложения закреплены в requirements.txt.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker Engine с Compose v2, Python 3.11, Bash и make. Для demo.sh также нужны curl и jq. Все компоненты запускаются из этого репозитория. Команды выполнять из корня:
## Архитектура и решения
```sh
python3 -m venv .venv
.venv/bin/python -m pip install -r requirements.txt
./scripts/start.sh
./scripts/check.sh
./scripts/demo.sh
```
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
start.sh создаёт .env и secrets через scripts/init_local.py, собирает API, запускает PostgreSQL и Valkey, затем ждёт готовности API. Пустая БД мигрируется при старте приложения. POST /users теперь требует password; бизнес-запросы принимают Authorization: Bearer. Адрес по умолчанию — http://localhost:8080.
## Доказательства критериев
Локальный пароль PostgreSQL создаётся случайно и сохраняется в secrets/postgres_password; URL соединений — в secrets/database_url и secrets/cache_url. Значения не печатаются. Существующие файлы не перезаписываются. Каталог secrets имеет права 0700; файлы 0444, чтобы непривилегированный пользователь контейнера мог читать примонтированные secrets. Содержимое каталога исключено из Git. .env содержит настройки и пути к secrets. Его и .venv в образе нет.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Настройка | Использование |
| --- | --- |
| APP_HOST, APP_PORT | Адрес Uvicorn; внутри контейнера оставить 0.0.0.0:8080 |
| HOST_PORT | Порт публикации на 127.0.0.1 компьютера |
| SESSION_TTL_SECONDS | Срок новой сессии; по умолчанию 3600 секунд |
| SESSION_STORE | В этой реализации valkey |
| DATABASE_URL_FILE | Файл с PostgreSQL DSN |
| CACHE_URL_FILE | Файл с URL Valkey, который хранит сессии |
| APP_ENV | Метка учебного окружения; поведение API не переключает |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Другой внешний порт и команды управления:
## Эксперименты и отказы
```sh
HOST_PORT=8081 ./scripts/start.sh
BASE_URL=http://localhost:8081 ./scripts/check.sh
BASE_URL=http://localhost:8081 ./scripts/demo.sh
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
docker compose logs --tail 30 api
./scripts/migrate.sh # повторное применение безопасно
./scripts/restart.sh # перезапускает API, PostgreSQL и Valkey
./scripts/stop.sh # удаляет контейнеры и сеть, сохраняет volumes
```
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
Для рестарта с нестандартным внешним портом передать то же HOST_PORT или записать его в .env. Команда `docker compose down --volumes` намеренно удаляет учебные данные текущего Compose project, включая сессии; для обычной остановки она не нужна. scripts/run-local.sh вызывает start.sh: локальный стенд lab2 включает все три сервиса.
## Ограничения и следующие шаги
PostgreSQL и Valkey не публикуют порты на хост. API запускается от UID/GID 10001 и является PID 1. Лимиты: API — 1 CPU / 256 MiB, PostgreSQL — 1 CPU / 512 MiB, Valkey — 0.5 CPU / 128 MiB. Именованные volumes: postgres_data и valkey_data. Секреты API примонтированы файлами, состояние в API-контейнере не хранится.
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
## Архитектура и транзакции
Сохранены обработчики и модель пользователей/чатов/сообщений из lab1, строгая валидация, единые ошибки, X-Request-Id, пагинация и проверки доступа. Вместо словарей используется PostgreSQL, вместо X-User-Id — Bearer. Контракт, публичные tests, README и COURSE второй работы не изменялись.
Схема спроектирована перед SQL-реализацией в [docs/schema.md](docs/schema.md). Миграция — migrations/001_initial.sql:
| Таблица | Содержимое и ограничения |
| --- | --- |
| users | UUID PK, username UNIQUE, display_name, password_hash, created_at |
| chats | UUID PK, title, created_at |
| chat_members | PK (chat_id, user_id); FK на пользователей и чаты |
| messages | UUID PK; chat_id; sender_id; text; created_at; составной FK на участника чата |
| schema_migrations | Версия, SHA-256 и время применения миграции |
Одна функция записи в storage.py — одна транзакция. Контекст соединения делает COMMIT при успехе и ROLLBACK при исключении. Ответ 201 формируется после выхода из транзакции. Уникальность username гарантирует ограничение PostgreSQL. Создание чата сначала вставляет чат, затем всех участников: FK violation откатывает и чат, и уже вставленных участников. Проверка доступа и запись сообщения находятся в одной транзакции; составной FK дополнительно требует членства отправителя.
Все значения клиента передаются параметрами `%s`, без подстановки в SQL. Динамические имена индексов в исследовании выбираются только из фиксированных вариантов программы. Пул API: от 1 до 5 соединений, не более 20 ожидающих; ожидание пула — 2 с, connect_timeout — 2 с, statement_timeout — 3 с, lock_timeout — 2 с, idle_in_transaction_session_timeout — 5 с. При недоступности PostgreSQL возвращается общий 503.
Миграции выполняются в транзакции под advisory lock. Повторная версия пропускается, checksum обнаруживает редактирование уже применённого SQL. Повторный запуск не создаёт новые пользовательские данные. Новое изменение схемы оформляется следующим SQL-файлом.
## Пароли и сессии
password имеет длину 12–128 Unicode code points и не возвращается в User. В БД сохраняется Argon2id с собственной случайной солью: memory_cost=19456 KiB, time_cost=2, parallelism=1. Это конфигурация 19 MiB / 2 / 1 из [OWASP Password Storage](https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html). Не более двух вычислений хеша одновременно ограничивают расход памяти.
POST /api/v1/auth/sessions принимает только Basic без тела. Пароль декодируется как UTF-8; разделение по первому двоеточию позволяет использовать двоеточие в пароле. Неверный пароль и неизвестное имя дают одинаковый 401 с WWW-Authenticate: Basic. Бизнес-запросы требуют Bearer и при 401 возвращают WWW-Authenticate: Bearer. X-User-Id игнорируется и сам по себе доступа не даёт.
Токен содержит 32 случайных байта, представленных непрозрачной строкой. Valkey хранит session:SHA256(token) → user_id и expires_at с TTL. Токен не является username/UUID; его исходное значение не сохраняется в ключе. Чтение сессии не продлевает срок. Абсолютный expires_at дополнительно проверяется приложением. DELETE /auth/sessions/current удаляет только текущую сессию, возвращает пустой 204; повторное использование — 401.
Valkey — источник истины для сессий. Включены AOF, appendfsync always, постоянный volume и noeviction. Поэтому обычный рестарт не сбрасывает ещё действующие сессии. При недоступности Valkey возвращается 503, перехода на доверие к X-User-Id или анонимному запросу нет. Ошибка подключения ограничена таймаутом 0.5 с, автоматические повторы отключены. Истечение TTL и logout не требуют инвалидации отдельного кэша.
/health/live показывает доступность процесса; /health/ready проверяет PostgreSQL и Valkey. Docker healthcheck проверяет HTTP 200 и JSON status=ok. При остановке зависимости live остаётся 200, ready возвращает 503.
## Пагинация и индекс истории
Запрос истории выбирает из БД только `limit + 1` записей после пары `(created_at, id)`, упорядоченных по той же паре. Индекс messages_history_idx(chat_id, created_at, id) соответствует равенству по чату и диапазону по ключу. Наличие опорной записи курсора проверяется отдельным индексным запросом; полная история в Python не загружается.
Курсор содержит scope, время и UUID в Base64. Scope привязан к чату или списку чатов пользователя. Чужой, повреждённый или несуществующий anchor даёт 400. limit — 1..100, по умолчанию 50; изменение limit при продолжении допустимо. Неучастник и отсутствующий чат возвращают одинаковый 404.
Каждая страница отражает отдельное чтение. Общего snapshot между HTTP-запросами нет. Неизменная история обходится без повторов; конкурентная запись с ключом меньше уже выданного курсора может не попасть на следующие страницы. Время берётся из часов PostgreSQL, поэтому остаётся ограничение при переводе системных часов назад.
## Проверки уровней 3 и 4
```sh
# На работающем стенде: структура, публичный smoke и 23 собственных теста
./scripts/check.sh
# Явный persistence-тест с прежним токеном; сохраняет volumes
make test-persistence PYTHON=.venv/bin/python ACTION_SCRIPT=scripts/restart.sh
# Полный прогон в отдельном временном Compose project, включая отказы и короткий TTL
./scripts/check-docker.sh
# Полная валидация исходного OpenAPI
.venv/bin/python -m pip install -r requirements-dev.txt
make validate PYTHON=.venv/bin/python
```
check-docker.sh собирает образ и запускает student-tests/docker_lifecycle.py. Проверка использует случайный порт и свой Compose project; в конце удаляет только его контейнеры и тестовые volumes. Пользовательский стенд не перезапускается. Вывод автоматически сохраняется в evidence/docker-checks.txt; вывод сборки остаётся в терминале.
| Критерий | Наблюдение | Доказательство |
| --- | --- | --- |
| API lab2 и объявленный переход от lab1 | Публичный smoke прошёл; Basic/Bearer, Unicode, доступ и ошибки проверены | evidence/docker-checks.txt |
| Собственные отрицательные тесты и пагинация | 23 теста прошли, включая неверный JSON, поля, страницы и чужой cursor | evidence/docker-checks.txt |
| Конкурентная запись | 10 клиентов × 10 сообщений; ровно 100 уникальных подтверждённых записей | evidence/docker-checks.txt |
| Гонка регистрации | Одинаковый username: одна 201, девять 409 | test_concurrency.py, evidence/docker-checks.txt |
| Откат составной операции | После FK violation нет строки chats с проверяемым title | evidence/docker-checks.txt |
| Миграции с нуля и повторно | Пустой volume; повторный запуск дважды, одна версия и прежнее число сообщений | evidence/docker-checks.txt |
| Полный рестарт с прежней сессией | Публичный persistence прошёл; StartedAt изменился у всех трёх сервисов | evidence/docker-checks.txt |
| Срок сессии, logout, неверный пароль | 2-секундная сессия истекла; отзыв одной сессии не затронул другую; Basic с неверным паролем — 401 | test_sessions.py, evidence/docker-checks.txt |
| Недоступность Valkey и PostgreSQL | Доверенный запрос — 503, анонимный — 401, live 200 / ready 503; после восстановления прежний токен работает | evidence/docker-checks.txt |
| Индекс истории на ≥10000 сообщений | EXPLAIN на 100000: Index Scan по составному индексу, без полного сканирования каждой страницы | evidence/query-plans.json |
| Условия Docker из lab1 | non-root, PID 1, healthcheck, логи без паролей/токенов/сообщений; завершение по SIGTERM <10 с | evidence/docker-checks.txt |
SIGTERM проверяется с незавершённым HTTP-запросом. Новые соединения должны перестать приниматься до выхода процесса. Uvicorn ждёт текущие запросы до 5 с; весь тест требует <10 с. Конкретные времена сохранены в evidence и зависят от машины.
## Трек 5: план запроса и восстановление
**Гипотеза.** Индекс только по chat_id не обеспечивает порядок истории: PostgreSQL приходится отбирать и сортировать множество записей. Индекс (chat_id, created_at, id) позволяет сразу перейти к anchor и прочитать небольшую страницу; ожидаем выигрыш чтения ценой большего индекса и дополнительных затрат записи.
Повторить весь эксперимент:
```sh
./scripts/research.sh
```
Никакой соседний репозиторий и подготовленная БД не требуются. Скрипт создаёт отдельный Compose project с двумя PostgreSQL-контейнерами и разными новыми volumes. Основной стенд и его данные не используются. SQL-измерения выполняет research/benchmark.py внутри API-образа; управление контейнерами, backup и restore — research/run.py. Прямой запуск benchmark требует специальной отметки из драйвера и пустой БД.
Методика:
1. Создать схему из миграции, 10 синтетических пользователей, 4 чата и 100000 сообщений с распределением **70000 / 20000 / 9000 / 1000**. Данные и UUID детерминированы; хеш пароля синтетических аккаунтов создаётся Argon2id, пароль не выводится.
2. Сравнить индекс A `(chat_id)` и индекс B `(chat_id, created_at, id)`. PK сообщений и остальные ограничения одинаковы. В каждом из трёх повторов таблица сообщений очищается только в исследовательской БД, затем индекс создаётся до записи. Порядок A/B чередуется.
3. Измерить один INSERT SELECT на 100000 строк с COMMIT, объём WAL и размер исследуемого индекса. Генерация UUID, текстов и проверки FK входят в стоимость записи обоих вариантов.
4. После VACUUM ANALYZE для каждого чата прочитать страницы около 10%, 50% и 90% истории. На каждый случай — один прогрев и пять измерений; страница 51 строка, как API для limit=50 с проверкой продолжения. Всего 180 измерений на вариант. SQL параметризован, OFFSET в исследуемом запросе нет.
5. Сохранить EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) для 24 случаев первого повтора и времена остальных повторов.
6. Сделать pg_dump в custom format. После завершения dump записать ещё одно сообщение в источник. Восстановить backup через pg_restore --exit-on-error --single-transaction в другой контейнер с новым volume.
7. Сравнить счётчики всех таблиц, 12 выбранных сообщений и SHA-256 всех полей всех 100000 сообщений в порядке UUID. Подтвердить отсутствие записи, сделанной после backup.
### Результаты реального прогона
Проверено 22.10.2026: macOS arm64, Docker Engine 29.0.1, Linux/aarch64, PostgreSQL 17.6. Docker VM: 10 CPU, 8217448448 байт RAM. Для каждой БД установлен одинаковый лимит 1 CPU / 512 MiB, для Python-клиента — 1 CPU / 256 MiB. Нагрузка — последовательные SQL-запросы с concurrency=1 и прогретыми страницами. Ошибок измеряемых запросов — 0.
| Метрика | Только chat_id | chat_id, created_at, id |
| --- | ---: | ---: |
| p50 чтения, мс | 1.685 | 0.226 |
| p95 чтения, мс | 7.566 | 0.297 |
| p99 чтения, мс | 46.402 | 0.338 |
| Медиана записи 100000, мс | 1386.76 | 1404.49 |
| Размер индекса, байт | 671744 | 7315456 |
| Медиана WAL записи, байт | 38822560 | 43108512 |
| Успешных последовательных SQL/с | 282.0 | 4322.8 |
Медиана чтения уменьшилась примерно в 7.45 раза. Время массовой записи отличается на 1.28% в этом прогоне; трёх повторов недостаточно для универсального вывода о стоимости записи. Составной индекс заметно больше, и WAL записи также увеличился.
Для чата на 70000 сообщений около середины истории план A использовал Parallel Seq Scan и сортировку, 2443 shared hit blocks; план B — Index Scan messages_history_idx, 6 shared hit blocks. Время EXPLAIN было 7.042 мс против 0.019 мс. Это отдельный пример плана, а не медиана всех измерений.
В research.json сохранён снимок docker stats после SQL-измерений: PostgreSQL занимал около 63.24 MiB из 512 MiB. Это посленагрузочный снимок, не измерение пикового потребления. p50/p95/p99 объединяют страницы разных размеров чатов и позиций; подробные значения сохранены отдельно. successful_sql_rps вычислен по сумме времени успешных последовательных SQL-запросов, без прогревов и EXPLAIN: это не HTTP throughput и не предел производительности системы.
### Backup и восстановление
Custom dump размером 3067615 байт создан за 0.54 с. pg_restore завершился за 0.68 с; запуск проверки восстановленных данных и сверка заняли ещё 2.34 с. Весь сценарий, включая создание исследовательских контейнеров и SQL-измерения, до cleanup занял 22.90 с.
Источник и приёмник имели разные container ID и разные volume, что записано в research.json. Восстановлены 10 пользователей, 4 чата, 8 участников, 100000 сообщений и одна миграция. Совпали все счётчики, все поля 12 образцов и SHA-256 всей истории. В источнике после backup было 100001 сообщение; дополнительная запись отсутствует в восстановленной БД, как и ожидается для снимка.
Граница потери данных: pg_dump сохраняет согласованный снимок на момент начала backup. Записи после этого снимка без WAL-архива/репликации не восстанавливаются. Показанная потеря одной последующей записи — явный пример этой границы. COMMIT и стандартные fsync/synchronous_commit PostgreSQL обеспечивают локальную фиксацию в пределах гарантий диска и Docker VM; один host не даёт защиты от потери самого host.
Измеренное время pg_restore относится к уже работающему пустому PostgreSQL. Полный RTO включает также создание среды, проверки и переключение API. Переключение рабочего API на восстановленную БД в эксперименте не выполнялось. Сессии находятся в отдельном Valkey AOF-volume и не входят в SQL dump; для полного аварийного восстановления сервиса их резервирование требуется отдельно. Проверка обычного рестарта Valkey с сохранённым volume выполнена в основном прогоне.
### Файлы доказательств и повторяемость
- evidence/docker-checks.txt — автоматически перезаписывается check-docker.sh; публичные и собственные тесты, рестарты, отказы, TTL и SIGTERM.
- evidence/research.txt — краткий реальный stdout исследования, автоматически перезаписывается research.sh.
- evidence/research.json — все повторы, латентности, стоимость записи, счётчики, SHA-256, ID контейнеров/volumes и времена backup/restore.
- evidence/query-plans.json — реальные JSON-планы PostgreSQL.
- backups/*.dump — локальные dump-файлы, исключённые из Git; содержат только синтетическую исследовательскую БД. Контейнеры и volumes временного research project удаляются в finally. Рабочие volumes обычного стенда сохраняются.
При повторе числа могут измениться. PostgreSQL работает в Docker VM, исследуются прогретые данные на одной машине. Холодный старт диска, сетевые задержки между машинами, высокая конкуренция и другие распределения данных не измерялись. Гипотеза подтверждена для проверенных страниц и распределения, универсального ускорения для любых запросов не заявляется.
## CI и дальнейшее развитие
Исходный workflow contracts.yml проверяет контракт. application.yml собирает приложение, выполняет check-docker.sh и research.sh, затем сохраняет evidence как артефакт. Локальные команды выполнены; успешный удалённый запуск CI не заявлен без отдельного результата GitHub Actions.
Код остаётся разделён по назначению: app.py — HTTP, models.py — поля, storage.py — SQL, db.py — пул, auth.py — сессии, passwords.py — Argon2id, pagination.py — курсор, migrate.py — миграции. Исследование находится отдельно в research/. HTTP-контракт и публичные проверки не ослаблялись.
Ограничения: одна API-реплика, один PostgreSQL и один Valkey без HA; нет лимита количества сообщений; сессии теряются при намеренном удалении их volume; сроки жизни зависят от системных часов. Для следующих лабораторных можно сохранить SQL-хранилище, сессии и API, добавляя требуемые контрактом возможности.
## Источники
- [Пул и транзакции Psycopg](https://www.psycopg.org/psycopg3/docs/advanced/pool.html).
- [Составные индексы PostgreSQL](https://www.postgresql.org/docs/17/indexes-multicolumn.html).
- [Согласованный SQL dump и восстановление PostgreSQL](https://www.postgresql.org/docs/17/backup-dump.html).
- [Valkey persistence](https://valkey.io/topics/persistence/) и [TTL](https://valkey.io/commands/expire/).
- [Argon2-cffi](https://argon2-cffi.readthedocs.io/en/stable/howto.html) и [параметры password KDF OWASP](https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html).
+66
View File
@@ -0,0 +1,66 @@
name: mtusi-lab2
x-postgres: &postgres
image: postgres:17.6-bookworm
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets: [postgres_password]
cpus: 1
mem_limit: 512m
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 2s
timeout: 3s
retries: 30
services:
postgres:
<<: *postgres
volumes: [postgres_data:/var/lib/postgresql/data]
valkey:
image: valkey/valkey:8.1.3
command: ["valkey-server", "--appendonly", "yes", "--appendfsync", "always", "--save", "", "--maxmemory", "64mb", "--maxmemory-policy", "noeviction"]
volumes: [valkey_data:/data]
cpus: 0.5
mem_limit: 128m
healthcheck:
test: ["CMD", "valkey-cli", "ping"]
interval: 2s
timeout: 3s
retries: 30
api:
image: mtusi-messenger:lab2
build: .
env_file: .env
environment:
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
secrets: [database_url, cache_url]
ports: ["127.0.0.1:${HOST_PORT:-8080}:8080"]
cpus: 1
mem_limit: 256m
depends_on:
postgres: {condition: service_healthy}
valkey: {condition: service_healthy}
stop_grace_period: 10s
postgres-restore:
<<: *postgres
profiles: [research]
volumes: [restore_data:/var/lib/postgresql/data]
volumes:
postgres_data:
valkey_data:
restore_data:
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
+22
View File
@@ -0,0 +1,22 @@
# Схема и транзакции lab2
Архитектура: HTTP → FastAPI → PostgreSQL; Bearer-сессии находятся в Valkey.
Выбран трек 2 на оценку 5: план запроса и восстановление.
| Таблица PostgreSQL | Назначение и ограничения |
| --- | --- |
| users | UUID PK; username UNIQUE; display_name; password_hash Argon2id; created_at timestamptz |
| chats | UUID PK; title; created_at timestamptz |
| chat_members | PK (chat_id, user_id); FK на chats и users |
| messages | UUID PK; FK chat_id на chats; составной FK (chat_id, sender_id) на chat_members; text; created_at timestamptz |
| schema_migrations | Имя и SHA-256 применённой SQL-миграции; время применения |
Индексы: users(username) создаётся UNIQUE-ограничением; chat_members(user_id, chat_id) нужен для списка чатов пользователя; messages(chat_id, created_at, id) нужен для истории с keyset cursor. PK служат индексами поиска по UUID.
Каждая операция хранилища выполняется в одной транзакции: контекст соединения Psycopg делает COMMIT при успехе и ROLLBACK при исключении. Создание чата сначала вставляет chats, затем участников. Неизвестный участник вызывает FK violation и откатывает весь чат. Проверка уникальности username выполняется ограничением БД, включая конкурентные запросы. Создание сообщения проверяет доступ и записывает сообщение в одной транзакции; составной FK дополнительно запрещает автора вне чата.
Миграции выполняются под advisory transaction lock. Повторное применение пропускает уже записанную версию, изменение применённого SQL выявляется по checksum. Схема и запись версии фиксируются вместе.
Valkey — источник истины только для сессий: ключ session:SHA256(token), значение — user_id и абсолютное expires_at, TTL задаётся SESSION_TTL_SECONDS. Сырой токен выдаётся клиенту один раз и не записывается в логи. Включены AOF, appendfsync always и именованный volume. Logout удаляет ключ; исчезнувшая или просроченная сессия даёт 401. При недоступности Valkey — 503 без обхода аутентификации. При потере PostgreSQL — 503. /health/live остаётся доступным, /health/ready проверяет оба сервиса.
Для трека 5 отдельно исследуются индекс только по chat_id и составной индекс на одинаковых 100000 сообщениях с распределением 70000/20000/9000/1000. Измеряются чтение страниц, стоимость записи и размер индекса. Backup восстанавливается в другой контейнер PostgreSQL с новым volume; сравниваются счётчики, выбранные записи и контрольная сумма всей истории.
+66
View File
@@ -0,0 +1,66 @@
UTC: 2026-10-22T11:17:22.562634+00:00
Host: Darwin arm64 Python 3.11.9
Docker: 29.0.1 aarch64 CPUs=10 RAM=8217448448
Commit: 9961362 + working tree
Command: ./scripts/check-docker.sh; project: lab2-check-ae280d00db
PASS: start.sh built and started the stack, readiness reached
api image=sha256:0b3dc5056cced642eea5ade11d235dce9f69f0d9e6d63956ce9479f2deaa10a0 started=2026-10-22T11:17:27.057932632Z memory=268435456 nano_cpus=1000000000
postgres image=sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3 started=2026-10-22T11:17:24.411773881Z memory=536870912 nano_cpus=1000000000
valkey image=sha256:fea8b3e67b15729d4bb70589eb03367bab9ad1ee89c876f54327fc7c6e618571 started=2026-10-22T11:17:24.406509756Z memory=134217728 nano_cpus=500000000
PASS: non-root UID 10001; Python PID 1; healthcheck; named volumes; no API data volume
Проверяем сервер: http://127.0.0.1:61900
/Users/vanek/Desktop/VNPlabs/VNPlab2/mtusi2026lab2/.venv/bin/python scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
/Users/vanek/Desktop/VNPlabs/VNPlab2/mtusi2026lab2/.venv/bin/python tests/smoke.py --base-url "http://127.0.0.1:61900"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
test_chat_access (test_api.ApiTests.test_chat_access) ... ok
test_chat_pagination_and_cursor_owner (test_api.ApiTests.test_chat_pagination_and_cursor_owner) ... ok
test_cursor_cannot_be_used_for_another_chat_or_changed (test_api.ApiTests.test_cursor_cannot_be_used_for_another_chat_or_changed) ... ok
test_default_page_size (test_api.ApiTests.test_default_page_size) ... ok
test_duplicate_username (test_api.ApiTests.test_duplicate_username) ... ok
test_framework_errors_and_request_ids (test_api.ApiTests.test_framework_errors_and_request_ids) ... ok
test_identification_and_authentication_order (test_api.ApiTests.test_identification_and_authentication_order) ... ok
test_invalid_chat_members (test_api.ApiTests.test_invalid_chat_members) ... ok
test_invalid_chat_title (test_api.ApiTests.test_invalid_chat_title) ... ok
test_invalid_limits_and_cursors (test_api.ApiTests.test_invalid_limits_and_cursors) ... ok
test_invalid_message_fields (test_api.ApiTests.test_invalid_message_fields) ... ok
test_invalid_user_fields (test_api.ApiTests.test_invalid_user_fields) ... ok
test_malformed_json_and_encoding (test_api.ApiTests.test_malformed_json_and_encoding) ... ok
test_message_pagination_and_changing_limit (test_api.ApiTests.test_message_pagination_and_changing_limit) ... ok
test_unicode_and_text_preservation (test_api.ApiTests.test_unicode_and_text_preservation) ... ok
test_wrong_content_type (test_api.ApiTests.test_wrong_content_type) ... ok
test_simultaneous_registration_of_one_username (test_concurrency.ConcurrencyTests.test_simultaneous_registration_of_one_username) ... ok
test_ten_clients_send_one_hundred_messages (test_concurrency.ConcurrencyTests.test_ten_clients_send_one_hundred_messages) ... ok
test_logout_revokes_only_one_session (test_sessions.SessionTests.test_logout_revokes_only_one_session) ... ok
test_password_validation (test_sessions.SessionTests.test_password_validation) ... ok
test_sql_like_message_is_plain_text (test_sessions.SessionTests.test_sql_like_message_is_plain_text) ... ok
test_unicode_password_with_colon_and_private_response (test_sessions.SessionTests.test_unicode_password_with_colon_and_private_response) ... ok
test_wrong_password_and_basic_only_for_login (test_sessions.SessionTests.test_wrong_password_and_basic_only_for_login) ... ok
----------------------------------------------------------------------
Ran 23 tests in 5.743s
OK
PASS: 10 clients sent 100 messages; history contains exactly 100 unique messages.
PASS: demo.sh registered users, logged in and read two messages
PASS: Argon2id in PostgreSQL; logs do not contain message text, passwords or session tokens
PASS: failed membership insert rolled back chat; migrations run twice without duplicate data
/Users/vanek/Desktop/VNPlabs/VNPlab2/mtusi2026lab2/.venv/bin/python tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://127.0.0.1:61900"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
Restart api 2026-10-22T11:17:27.057932632Z -> 2026-10-22T11:17:45.460071626Z
Restart postgres 2026-10-22T11:17:24.411773881Z -> 2026-10-22T11:17:44.637353001Z
Restart valkey 2026-10-22T11:17:24.406509756Z -> 2026-10-22T11:17:44.670095293Z
PASS: API, PostgreSQL and Valkey really restarted; previous token still works
PASS: valkey unavailable -> 503 in 0.11s; anonymous -> 401; readiness 503, liveness 200
API ready
PASS: valkey recovered without a new login
PASS: postgres unavailable -> 503 in 2.01s; anonymous -> 401; readiness 503, liveness 200
API ready
PASS: postgres recovered without a new login
API ready
PASS: SESSION_TTL_SECONDS=2; valid token expires without logout
PASS: SIGTERM with unfinished request: 5.54s; new requests refused after 0.16s; exit=0; OOM=false
PASS: all lab2 Docker checks completed
PASS: stop.sh removed containers and preserved named volumes
Removed only temporary Compose project and its test volumes: lab2-check-ae280d00db
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+32
View File
@@ -0,0 +1,32 @@
Research project: lab2-research-85021a09d9
Measuring two indexes on the same 100000 messages, three repeats...
{
"chat_only": {
"insert_100000_median_ms": 1386.7587500000127,
"index_bytes": 671744,
"wal_bytes_median": 38822560,
"queries": 180,
"errors": 0,
"concurrency": 1,
"p50_ms": 1.6852079999978287,
"p95_ms": 7.566457999985232,
"p99_ms": 46.40233399999261,
"successful_sql_rps": 282.01364182715855
},
"history": {
"insert_100000_median_ms": 1404.4910420000178,
"index_bytes": 7315456,
"wal_bytes_median": 43108512,
"queries": 180,
"errors": 0,
"concurrency": 1,
"p50_ms": 0.22610399997802233,
"p95_ms": 0.29704099995342403,
"p99_ms": 0.3384169999662845,
"successful_sql_rps": 4322.810483886352
}
}
PASS: backup 0.54s; restore 0.68s; 100000 messages, all hashes and 12 samples match
PASS: restored into a different container and fresh volume; one post-backup commit is absent as expected
Results: evidence/research.json, evidence/query-plans.json; dump stays outside Git in backups/
Removed only temporary research project: lab2-research-85021a09d9
+30
View File
@@ -0,0 +1,30 @@
CREATE TABLE users (
id uuid PRIMARY KEY,
username varchar(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name varchar(100) NOT NULL CHECK (char_length(display_name) >= 1),
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title varchar(100) NOT NULL CHECK (char_length(title) >= 1),
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users(id),
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id uuid NOT NULL,
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000 AND text !~ '^\s*$'),
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members(chat_id, user_id)
);
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
+12
View File
@@ -15,3 +15,15 @@ pydantic-core==2.46.5
starlette==1.7.0
typing-extensions==4.16.0
typing-inspection==0.4.4
# PostgreSQL, сессии и Argon2id
psycopg[binary,pool]==3.3.6
redis==8.1.0
argon2-cffi==25.1.0
# Транзитивные зависимости новых библиотек
psycopg-binary==3.3.6
psycopg-pool==3.3.3
argon2-cffi-bindings==26.1.0
cffi==2.1.1
pycparser==3.11
+12
View File
@@ -0,0 +1,12 @@
# Трек 2 на оценку 5
Запуск из корня: `./scripts/research.sh`. Нужны Docker Compose, Python 3 и интернет для первой сборки. Скрипт собирает API-образ и использует отдельный Compose project с новыми volumes. Текущий стенд не участвует.
- run.py управляет контейнерами, pg_dump, pg_restore, файлами evidence и cleanup.
- benchmark.py выполняет SQL и сверку внутри API-образа. Перед заполнением требует пустую БД. Исследовательский флаг устанавливает только драйвер.
Датасет: 100000 сообщений в 4 чатах (70000/20000/9000/1000). Сравниваются индекс chat_id и индекс (chat_id,created_at,id), по 3 повтора с одинаковыми ограничениями и записями. На каждый чат — страницы около 10/50/90%, один прогрев и пять измерений, 51 строка. Измеряется INSERT SELECT с COMMIT, WAL и размер индекса. EXPLAIN и основные цифры сохраняются в evidence.
После dump создаётся ещё одно сообщение. Backup восстанавливается в другой контейнер и свежий volume. Сравниваются все счётчики, 12 полных записей и SHA-256 всех сообщений. Последующая запись ожидаемо отсутствует в восстановленном снимке.
Файлы research.json, query-plans.json и research.txt обновляются автоматически. Dump остаётся в игнорируемом backups/. Временные исследовательские volumes удаляются после проверки. Методика, фактические результаты и ограничения описаны в REPORT.md.
View File
+168
View File
@@ -0,0 +1,168 @@
"""SQL-эксперимент запускается только в отдельном research Compose project."""
from datetime import datetime, timedelta, timezone
import hashlib
import json
import os
import secrets
import statistics
import sys
import time
from uuid import UUID
import psycopg
from psycopg.conninfo import make_conninfo
from psycopg.rows import dict_row
from src import db, migrate, passwords
from src.config import secret
SIZES = [70000, 20000, 9000, 1000]
START = datetime(2026, 1, 1, tzinfo=timezone.utc)
QUERY = """SELECT * FROM messages WHERE chat_id=%s AND (created_at, id)>(%s, %s)
ORDER BY created_at, id LIMIT %s"""
def identifier(value):
return UUID(hashlib.md5(value.encode(), usedforsecurity=False).hexdigest())
def connect(restored=False):
url = secret("DATABASE_URL")
if restored:
url = make_conninfo(url, host="postgres-restore")
return psycopg.connect(url, autocommit=True, row_factory=dict_row,
options="-c timezone=UTC -c statement_timeout=120000")
def snapshot(conn):
counts = {}
for table in ("users", "chats", "chat_members", "messages", "schema_migrations"):
# Имена таблиц — фиксированный список выше, не входные данные клиента.
counts[table] = conn.execute("SELECT count(*) AS n FROM " + table).fetchone()["n"]
digest = hashlib.sha256()
for row in conn.execute("SELECT * FROM messages ORDER BY id"):
digest.update((json.dumps(row, default=str, sort_keys=True, ensure_ascii=False) + "\n").encode())
samples = []
offset = 0
for size in SIZES:
for number in (offset + 1, offset + size // 2, offset + size):
row = conn.execute("SELECT * FROM messages WHERE id=%s", (identifier(f"message:{number}"),)).fetchone()
samples.append(json.loads(json.dumps(row, default=str, sort_keys=True, ensure_ascii=False)))
offset += size
return {"counts": counts, "messages_sha256": digest.hexdigest(), "samples": samples}
def benchmark():
db.pool.open(wait=True, timeout=15)
try:
migrate.apply()
finally:
db.pool.close()
results, plans = [], []
with connect() as conn:
assert conn.execute("SELECT count(*) AS n FROM users").fetchone()["n"] == 0, "Research requires an empty database"
encoded = passwords.hash_password(secrets.token_urlsafe(24))
for n in range(1, 11):
conn.execute("INSERT INTO users(id,username,display_name,password_hash) VALUES(%s,%s,%s,%s)",
(identifier(f"user:{n}"), f"research_{n}", "Synthetic research user", encoded))
for n in range(4):
chat = identifier(f"chat:{n}")
conn.execute("INSERT INTO chats(id,title) VALUES(%s,%s)", (chat, f"Research chat {n}"))
for user in (1, 2):
conn.execute("INSERT INTO chat_members(chat_id,user_id) VALUES(%s,%s)", (chat, identifier(f"user:{user}")))
variants = [("chat_only", "chat_id"), ("history", "chat_id, created_at, id")]
for repeat in range(3):
order = variants if repeat % 2 == 0 else variants[::-1]
for variant, columns in order:
conn.execute("TRUNCATE messages")
conn.execute("DROP INDEX IF EXISTS messages_history_idx")
conn.execute("DROP INDEX IF EXISTS messages_chat_idx")
index = "messages_history_idx" if variant == "history" else "messages_chat_idx"
conn.execute("CREATE INDEX " + index + " ON messages (" + columns + ")")
lsn = conn.execute("SELECT pg_current_wal_insert_lsn() AS lsn").fetchone()["lsn"]
started = time.perf_counter()
conn.execute("""INSERT INTO messages(id,chat_id,sender_id,text,created_at)
SELECT md5('message:'||n)::uuid,
md5('chat:'||(CASE WHEN n<=70000 THEN 0 WHEN n<=90000 THEN 1 WHEN n<=99000 THEN 2 ELSE 3 END))::uuid,
md5('user:'||(1+n%2))::uuid,
'Synthetic message '||n||' '||repeat('x',80),
timestamptz '2026-01-01 00:00:00+00' + n*interval '1 microsecond'
FROM generate_series(1,100000) AS n""")
insert_ms = (time.perf_counter() - started) * 1000
wal = conn.execute("SELECT pg_wal_lsn_diff(pg_current_wal_insert_lsn(), %s) AS bytes", (lsn,)).fetchone()["bytes"]
conn.execute("VACUUM (ANALYZE) messages")
index_bytes = conn.execute("SELECT pg_relation_size(%s::regclass) AS bytes", (index,)).fetchone()["bytes"]
result = {"variant": variant, "repeat": repeat + 1, "insert_100000_ms": insert_ms,
"wal_bytes": int(wal), "index_bytes": index_bytes, "queries": []}
offset = 0
for chat, size in enumerate(SIZES):
for fraction in (0.1, 0.5, 0.9):
number = offset + int(size * fraction)
params = (identifier(f"chat:{chat}"), START + timedelta(microseconds=number), identifier(f"message:{number}"), 51)
conn.execute(QUERY, params).fetchall() # один прогрев именно этой страницы
times = []
for _ in range(5):
started = time.perf_counter()
rows = conn.execute(QUERY, params).fetchall()
times.append((time.perf_counter() - started) * 1000)
assert len(rows) == 51
plan = conn.execute("EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) " + QUERY, params).fetchone()["QUERY PLAN"][0]
result["queries"].append({"chat_size": size, "position": fraction, "latency_ms": times,
"explain_execution_ms": plan["Execution Time"]})
if repeat == 0:
plans.append({"variant": variant, "chat_size": size, "position": fraction, "plan": plan})
offset += size
results.append(result)
# Последняя итерация заканчивается production-индексом history.
assert conn.execute("SELECT to_regclass('messages_history_idx') AS name").fetchone()["name"]
baseline = snapshot(conn)
assert baseline["counts"]["messages"] == 100000
summary = {}
for variant, _ in variants:
trials = [row for row in results if row["variant"] == variant]
latencies = sorted(t for row in trials for q in row["queries"] for t in q["latency_ms"])
summary[variant] = {
"insert_100000_median_ms": statistics.median(row["insert_100000_ms"] for row in trials),
"index_bytes": trials[-1]["index_bytes"],
"wal_bytes_median": statistics.median(row["wal_bytes"] for row in trials),
"queries": len(latencies), "errors": 0, "concurrency": 1,
"p50_ms": statistics.median(latencies),
"p95_ms": latencies[int(0.95 * (len(latencies) - 1))],
"p99_ms": latencies[int(0.99 * (len(latencies) - 1))],
"successful_sql_rps": len(latencies) / (sum(latencies) / 1000),
}
return {"postgres": conn.execute("SELECT version() AS version").fetchone()["version"],
"messages": 100000, "chat_sizes": SIZES, "repeats": 3, "warmup_per_case": 1,
"measurements_per_case": 5, "page_size": 51, "query": QUERY,
"summary": summary, "trials": results, "plans": plans, "snapshot": baseline}
def after_backup():
with connect() as conn:
message_id = identifier("after-backup")
conn.execute("INSERT INTO messages(id,chat_id,sender_id,text) VALUES(%s,%s,%s,%s)",
(message_id, identifier("chat:0"), identifier("user:1"), "Committed AFTER backup"))
return {"id": str(message_id), "source_messages": conn.execute("SELECT count(*) AS n FROM messages").fetchone()["n"]}
def verify():
expected = json.load(sys.stdin)
with connect(restored=True) as restored, connect() as source:
actual = snapshot(restored)
assert actual == expected, "Restored data differs from the snapshot"
marker = (identifier("after-backup"),)
assert restored.execute("SELECT 1 FROM messages WHERE id=%s", marker).fetchone() is None
assert source.execute("SELECT 1 FROM messages WHERE id=%s", marker).fetchone() is not None
return {"counts": actual["counts"], "messages_sha256": actual["messages_sha256"],
"samples_verified": len(actual["samples"]), "all_messages_match": True,
"after_backup_message_missing_in_restore": True,
"source_messages": source.execute("SELECT count(*) AS n FROM messages").fetchone()["n"]}
if __name__ == "__main__":
if os.environ.get("LAB2_RESEARCH") != "1":
raise SystemExit("Use ./scripts/research.sh: an isolated research database is required")
operation = sys.argv[1] if len(sys.argv) > 1 else "benchmark"
result = {"benchmark": benchmark, "after-backup": after_backup, "verify": verify}[operation]()
print(json.dumps(result, ensure_ascii=False, default=str))
+99
View File
@@ -0,0 +1,99 @@
"""Создаёт изолированный стенд, измеряет SQL, делает dump и restore; пишет реальные результаты."""
from datetime import datetime, timezone
import json
import os
from pathlib import Path
import platform
import subprocess
import sys
import time
from uuid import uuid4
ROOT = Path(__file__).resolve().parents[1]
project = "lab2-research-" + uuid4().hex[:10]
env = dict(os.environ, COMPOSE_PROJECT_NAME=project)
command = ["docker", "compose", "--profile", "research"]
def compose(*args, stdin=None, stdout=subprocess.PIPE):
return subprocess.run([*command, *args], cwd=ROOT, env=env, input=stdin,
stdout=stdout, stderr=subprocess.PIPE, check=True, timeout=600)
def run_module(operation, stdin=None):
result = compose("run", "--rm", "--no-deps", "-T", "-e", "LAB2_RESEARCH=1", "api", "python", "-m", "research.benchmark", operation, stdin=stdin)
return json.loads(result.stdout)
def wait_database(service):
for _ in range(60):
cid = compose("ps", "-q", service).stdout.decode().strip()
state = subprocess.run(["docker", "inspect", "--format", "{{.State.Health.Status}}", cid], capture_output=True, text=True, check=True)
if state.stdout.strip() == "healthy":
return
time.sleep(1)
raise RuntimeError(service + " did not become healthy")
def main():
evidence = ROOT / "evidence"
evidence.mkdir(exist_ok=True)
backups = ROOT / "backups"
backups.mkdir(exist_ok=True)
dump = backups / (project + ".dump")
metadata = {"utc": datetime.now(timezone.utc).isoformat(), "project": project,
"command": "./scripts/research.sh", "host": platform.system() + " " + platform.machine(),
"commit": subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=ROOT, capture_output=True, text=True).stdout.strip() + " + working tree",
"postgres_limits": {"cpus": 1, "memory_mib": 512}, "api_runner_limits": {"cpus": 1, "memory_mib": 256}}
started = time.perf_counter()
try:
print("Research project:", project, flush=True)
compose("up", "-d", "postgres", "postgres-restore")
wait_database("postgres")
wait_database("postgres-restore")
print("Measuring two indexes on the same 100000 messages, three repeats...", flush=True)
result = run_module("benchmark")
plans = result.pop("plans")
(evidence / "query-plans.json").write_text(json.dumps(plans, ensure_ascii=False, indent=2))
source_id = compose("ps", "-q", "postgres").stdout.decode().strip()
restore_id = compose("ps", "-q", "postgres-restore").stdout.decode().strip()
assert source_id != restore_id
for label, cid in (("source", source_id), ("restored", restore_id)):
inspected = json.loads(subprocess.run(["docker", "inspect", cid], capture_output=True, check=True).stdout)[0]
metadata[label] = {"container": cid, "image": inspected["Image"],
"volumes": [m["Name"] for m in inspected["Mounts"] if m["Type"] == "volume"]}
assert metadata["source"]["volumes"] != metadata["restored"]["volumes"]
metadata["docker"] = subprocess.run(["docker", "info", "--format", "{{.ServerVersion}} {{.Architecture}} CPUs={{.NCPU}} RAM={{.MemTotal}}"], capture_output=True, text=True, check=True).stdout.strip()
metadata["stats_after_queries"] = subprocess.run(["docker", "stats", "--no-stream", "--format", "{{json .}}", source_id], capture_output=True, text=True, check=True).stdout.strip()
backup_started = time.perf_counter()
with dump.open("wb") as output:
compose("exec", "-T", "postgres", "pg_dump", "-U", "messenger", "-d", "messenger", "--format=custom", stdout=output)
backup_seconds = time.perf_counter() - backup_started
marker = run_module("after-backup")
restore_started = time.perf_counter()
# Dump подаётся через stdin, без вывода данных или credentials в журнал.
with dump.open("rb") as input_file:
subprocess.run([*command, "exec", "-T", "postgres-restore", "pg_restore", "-U", "messenger", "-d", "messenger",
"--exit-on-error", "--single-transaction", "--no-owner"], cwd=ROOT, env=env, stdin=input_file,
stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, check=True, timeout=300)
restore_seconds = time.perf_counter() - restore_started
verification_started = time.perf_counter()
verification = run_module("verify", stdin=json.dumps(result["snapshot"]).encode())
result.update(metadata)
result["backup"] = {"file": "backups/" + dump.name, "bytes": dump.stat().st_size, "seconds": backup_seconds}
result["restore"] = {"seconds": restore_seconds, "verification_seconds": time.perf_counter() - verification_started,
"verification": verification, "post_backup_insert": marker}
result["total_seconds"] = time.perf_counter() - started
(evidence / "research.json").write_text(json.dumps(result, ensure_ascii=False, indent=2))
print(json.dumps(result["summary"], ensure_ascii=False, indent=2), flush=True)
print(f"PASS: backup {backup_seconds:.2f}s; restore {restore_seconds:.2f}s; 100000 messages, all hashes and 12 samples match", flush=True)
print("PASS: restored into a different container and fresh volume; one post-backup commit is absent as expected", flush=True)
print("Results: evidence/research.json, evidence/query-plans.json; dump stays outside Git in backups/", flush=True)
finally:
compose("down", "--volumes", "--timeout", "10")
print("Removed only temporary research project:", project, flush=True)
if __name__ == "__main__":
main()
+3 -2
View File
@@ -1,5 +1,6 @@
#!/usr/bin/env bash
set -euo pipefail
project_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
docker build --tag "${IMAGE_NAME:-mtusi-messenger:lab2}" "$@" "$project_dir"
cd "$project_dir"
python3 scripts/init_local.py
docker compose build "$@" api
+2 -7
View File
@@ -1,16 +1,11 @@
#!/usr/bin/env bash
set -euo pipefail
project_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$project_dir"
if [[ ! -x .venv/bin/python ]]; then
echo "Не хватает .venv" >&2
echo "python3 -m venv .venv" >&2
echo ".venv/bin/python -m pip install -r requirements.txt" >&2
echo "Создай .venv и установи requirements.txt по REPORT.md" >&2
exit 1
fi
./scripts/build.sh
mkdir -p evidence
.venv/bin/python -u student-tests/docker_lifecycle.py \
--image "${IMAGE_NAME:-mtusi-messenger:lab2}" 2>&1 | tee evidence/docker-checks.txt
.venv/bin/python -u student-tests/docker_lifecycle.py 2>&1 | tee evidence/docker-checks.txt
+22 -37
View File
@@ -1,42 +1,27 @@
#!/usr/bin/env bash
set -euo pipefail
if ! command -v jq >/dev/null; then
echo "Для demo.sh нужен jq" >&2
exit 1
fi
base_url="${BASE_URL:-http://localhost:8080}"
base_url="${base_url%/}"
suffix="$(date +%s)_$RANDOM"
post_json() {
local path="$1"
local body="$2"
shift 2
curl --fail --silent --show-error --connect-timeout 5 --max-time 10 \
-H "Content-Type: application/json" --data "$body" "$@" "$base_url$path"
# Только синтетические пароли; токены остаются в памяти shell и не выводятся.
password="Demo-password-$suffix"
register() {
local username="$1" display_name="$2"
jq -nc --arg u "$username" --arg d "$display_name" --arg p "$password" \
'{username:$u, display_name:$d, password:$p}' |
curl -fsS -H 'Content-Type: application/json' --data-binary @- "$base_url/api/v1/users" | jq -er '.id'
}
echo "Создаём Алису и Боба"
alice_body="$(jq -nc --arg name "alice_$suffix" '{username: $name, display_name: "Алиса"}')"
bob_body="$(jq -nc --arg name "bob_$suffix" '{username: $name, display_name: "Боб"}')"
alice_id="$(post_json /api/v1/users "$alice_body" | jq -er '.id')"
bob_id="$(post_json /api/v1/users "$bob_body" | jq -er '.id')"
echo "Создаём общий чат"
chat_body="$(jq -nc --arg alice "$alice_id" --arg bob "$bob_id" \
'{title: "Учебный чат", member_ids: [$alice, $bob]}')"
chat_id="$(post_json /api/v1/chats "$chat_body" -H "X-User-Id: $alice_id" | jq -er '.id')"
path="/api/v1/chats/$chat_id/messages"
echo "Отправляем сообщение от Алисы"
post_json "$path" '{"text":"Привет, Боб! 👋"}' -H "X-User-Id: $alice_id" | jq .
echo "Отправляем ответ от Боба"
post_json "$path" '{"text":"Привет, Алиса!"}' -H "X-User-Id: $bob_id" | jq .
echo "Читаем общую историю от имени Алисы"
curl --fail --silent --show-error --connect-timeout 5 --max-time 10 \
-H "X-User-Id: $alice_id" "$base_url$path?limit=50" | jq .
login() {
curl -fsS -X POST -u "$1:$password" "$base_url/api/v1/auth/sessions" | jq -er '.token'
}
alice_id="$(register "alice_$suffix" Алиса)"
bob_id="$(register "bob_$suffix" Боб)"
alice_token="$(login "alice_$suffix")"
bob_token="$(login "bob_$suffix")"
chat_id="$(jq -nc --arg a "$alice_id" --arg b "$bob_id" '{title:"Учебный чат",member_ids:[$a,$b]}' |
curl -fsS -H "Authorization: Bearer $alice_token" -H 'Content-Type: application/json' \
--data-binary @- "$base_url/api/v1/chats" | jq -er '.id')"
for token in "$alice_token" "$bob_token"; do
curl -fsS -H "Authorization: Bearer $token" -H 'Content-Type: application/json' \
-d '{"text":"Привет из lab2! 👋"}' "$base_url/api/v1/chats/$chat_id/messages" | jq .
done
curl -fsS -H "Authorization: Bearer $bob_token" "$base_url/api/v1/chats/$chat_id/messages" | jq .
+29
View File
@@ -0,0 +1,29 @@
"""Создаёт локальное окружение и secrets; существующие значения сохраняет."""
from pathlib import Path
import secrets
import shutil
from urllib.parse import quote
root = Path(__file__).resolve().parents[1]
if not (root / ".env").exists():
shutil.copyfile(root / ".env.example", root / ".env")
directory = root / "secrets"
directory.mkdir(exist_ok=True, mode=0o700)
directory.chmod(0o700)
password_file = directory / "postgres_password"
if not password_file.exists():
password_file.write_text(secrets.token_hex(24))
password = password_file.read_text().strip()
values = {
"database_url": f"postgresql://messenger:{quote(password, safe='')}@postgres:5432/messenger",
"cache_url": "redis://valkey:6379/0",
}
for name, value in values.items():
path = directory / name
if not path.exists():
path.write_text(value)
# Каталог 0700 защищает файлы на хосте; 0444 позволяет USER 10001 читать bind-mounted secret.
for name in ("postgres_password", "database_url", "cache_url"):
(directory / name).chmod(0o444)
print("Local .env and secrets are ready; values are not printed")
+5
View File
@@ -0,0 +1,5 @@
#!/usr/bin/env bash
set -euo pipefail
project_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$project_dir"
docker compose exec -T api python -m src.migrate
+7
View File
@@ -0,0 +1,7 @@
#!/usr/bin/env bash
set -euo pipefail
project_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$project_dir"
./scripts/build.sh
mkdir -p evidence
python3 -u research/run.py 2>&1 | tee evidence/research.txt
+6
View File
@@ -0,0 +1,6 @@
#!/usr/bin/env bash
set -euo pipefail
project_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$project_dir"
docker compose restart --timeout 10 postgres valkey api
./scripts/wait-ready.sh
+2 -12
View File
@@ -1,15 +1,5 @@
#!/usr/bin/env bash
set -euo pipefail
# В lab2 локальный запуск включает API, PostgreSQL и Valkey.
project_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$project_dir"
if [[ ! -x .venv/bin/python ]]; then
echo "Не хватает .venv" >&2
echo "python3 -m venv .venv" >&2
echo ".venv/bin/python -m pip install -r requirements.txt" >&2
exit 1
fi
exec .venv/bin/python -m src
exec "$project_dir/scripts/start.sh"
+4 -16
View File
@@ -1,19 +1,7 @@
#!/usr/bin/env bash
set -euo pipefail
project_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
container="${CONTAINER_NAME:-mtusi-messenger-lab2}"
port="${HOST_PORT:-8080}"
if [[ ! -f "$project_dir/.env" ]]; then
cp "$project_dir/.env.example" "$project_dir/.env"
fi
docker run --detach --name "$container" --label mtusi.lab=2 \
--cpus 1 --memory 256m \
--publish "127.0.0.1:$port:8080" \
--env-file "$project_dir/.env" \
"${IMAGE_NAME:-mtusi-messenger:lab2}"
"$project_dir/scripts/wait-ready.sh" "$container"
echo "API: http://localhost:$port"
cd "$project_dir"
python3 scripts/init_local.py
docker compose up -d --build api
./scripts/wait-ready.sh
+4 -10
View File
@@ -1,12 +1,6 @@
#!/usr/bin/env bash
set -euo pipefail
container="${CONTAINER_NAME:-mtusi-messenger-lab2}"
if [[ "$(docker inspect --format '{{index .Config.Labels "mtusi.lab"}}' "$container")" != 2 ]]; then
echo "У $container нет метки mtusi.lab=2; остановка отменена" >&2
exit 1
fi
docker stop --time 10 "$container"
docker rm "$container"
echo "Контейнер удалён"
project_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$project_dir"
docker compose down --timeout 10
echo "Контейнеры удалены; именованные volumes сохранены"
+5 -11
View File
@@ -1,19 +1,13 @@
#!/usr/bin/env bash
set -euo pipefail
container="${1:-mtusi-messenger-lab2}"
project_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$project_dir"
for ((attempt = 0; attempt < 60; attempt++)); do
running="$(docker inspect --format '{{.State.Running}}' "$container")"
health="$(docker inspect --format '{{.State.Health.Status}}' "$container")"
if [[ "$running" != true || "$health" == unhealthy ]]; then
echo "Контейнер $container не готов. Посмотри: docker logs $container" >&2
exit 1
fi
if [[ "$health" == healthy ]]; then
echo "$container: healthy"
if docker compose exec -T api python -m src.healthcheck >/dev/null 2>&1; then
echo "API ready"
exit 0
fi
sleep 1
done
echo "Контейнер $container не стал готов за 60 секунд" >&2
echo "API не готов за 60 секунд. Проверь docker compose logs api" >&2
exit 1
+39 -11
View File
@@ -1,21 +1,32 @@
"""HTTP-адреса, определение пользователя и обработка запросов"""
from contextlib import asynccontextmanager
import json
import logging
from time import perf_counter
from uuid import UUID, uuid4
from fastapi import FastAPI, Request
from fastapi import FastAPI, Request, Response
from starlette.concurrency import run_in_threadpool
from fastapi.exceptions import RequestValidationError
from starlette.exceptions import HTTPException
from src import storage
from src import auth, db, migrate, passwords, storage
from src.errors import ApiError, error_response
from src.models import CreateChat, CreateMessage, CreateUser
from src.pagination import make_page
app = FastAPI(title="Учебный мессенджер", redirect_slashes=False)
@asynccontextmanager
async def lifespan(app):
await run_in_threadpool(db.pool.open, wait=True, timeout=15)
try:
await run_in_threadpool(migrate.apply)
yield
finally:
await run_in_threadpool(db.pool.close)
app = FastAPI(title="Учебный мессенджер", redirect_slashes=False, lifespan=lifespan)
logger = logging.getLogger("uvicorn.error")
@@ -26,9 +37,14 @@ async def handle_request(request: Request, call_next):
path = request.url.path
try:
is_registration = request.method == "POST" and path == "/api/v1/users"
if path.startswith("/api/v1/") and not is_registration:
request.state.user = storage.current_user(request.headers.get("X-User-Id"))
if request.method == "POST" and path.startswith("/api/v1/"):
is_login = request.method == "POST" and path == "/api/v1/auth/sessions"
if is_login:
request.state.user = await run_in_threadpool(auth.basic_user, request.headers.get("Authorization"))
if await request.body():
raise ApiError(400, "invalid_request", "Вход через Basic не принимает тело запроса")
elif path.startswith("/api/v1/") and not is_registration:
request.state.user = await run_in_threadpool(auth.current_user, request.headers.get("Authorization"))
if request.method == "POST" and path.startswith("/api/v1/") and not is_login:
content_type = request.headers.get("Content-Type", "").split(";", 1)[0].strip().lower()
if content_type != "application/json":
raise ApiError(415, "unsupported_media_type", "Ожидается application/json")
@@ -80,12 +96,14 @@ def health_live():
@app.get("/health/ready")
def health_ready():
db.ready()
auth.ready()
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
def create_user(data: CreateUser):
return storage.create_user(data.username, data.display_name)
return storage.create_user(data.username, data.display_name, passwords.hash_password(data.password))
@app.get("/api/v1/users/me")
@@ -101,7 +119,7 @@ def create_chat(request: Request, data: CreateChat):
@app.get("/api/v1/chats")
def list_chats(request: Request, limit: str = "50", cursor: str | None = None):
user_id = request.state.user["id"]
return make_page(storage.list_chats(user_id), "chats:" + user_id, limit, cursor)
return storage.list_chats(user_id, limit, cursor)
@app.get("/api/v1/chats/{chat_id}")
@@ -116,5 +134,15 @@ def create_message(request: Request, chat_id: UUID, data: CreateMessage):
@app.get("/api/v1/chats/{chat_id}/messages")
def list_messages(request: Request, chat_id: UUID, limit: str = "50", cursor: str | None = None):
items = storage.list_messages(request.state.user["id"], str(chat_id))
return make_page(items, "messages:" + str(chat_id), limit, cursor)
return storage.list_messages(request.state.user["id"], str(chat_id), limit, cursor)
@app.post("/api/v1/auth/sessions", status_code=201)
def create_session(request: Request):
return auth.create_session(request.state.user)
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def delete_session(request: Request):
auth.logout(request.headers.get("Authorization"))
return Response(status_code=204)
+95
View File
@@ -0,0 +1,95 @@
"""Basic только для входа; Bearer-сессии с TTL и AOF находятся в Valkey."""
import base64
import binascii
from contextlib import contextmanager
from datetime import datetime, timedelta, timezone
import hashlib
import json
import secrets
import redis
from src import passwords, storage
from src.config import SESSION_TTL, secret
from src.errors import ApiError
sessions = redis.Redis.from_url(
secret("CACHE_URL"), decode_responses=True,
socket_connect_timeout=0.5, socket_timeout=0.5, max_connections=10,
retry=redis.retry.Retry(redis.backoff.NoBackoff(), 0),
)
@contextmanager
def available():
try:
yield
except redis.RedisError:
raise ApiError(503, "unavailable", "Valkey временно недоступен") from None
def unauthorized(basic=False):
challenge = 'Basic realm="messenger", charset="UTF-8"' if basic else 'Bearer realm="messenger"'
return ApiError(401, "unauthorized", "Неверная или отсутствующая идентификация", {"WWW-Authenticate": challenge})
def credential(header, scheme):
parts = (header or "").split()
if len(parts) != 2 or parts[0].lower() != scheme.lower():
raise unauthorized(scheme == "Basic")
return parts[1]
def basic_user(header):
value = credential(header, "Basic")
try:
decoded = base64.b64decode(value, validate=True).decode("utf-8")
username, password = decoded.split(":", 1)
except (ValueError, UnicodeError, binascii.Error):
raise unauthorized(True) from None
user = storage.find_login(username)
if user is None or not passwords.matches(user["password_hash"], password):
raise unauthorized(True)
return storage.public_user(user)
def session_key(token):
return "session:" + hashlib.sha256(token.encode()).hexdigest()
def create_session(user):
token = secrets.token_urlsafe(32)
expires = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL)
value = {"user_id": user["id"], "expires_at": storage.utc(expires)}
with available():
sessions.set(session_key(token), json.dumps(value), ex=SESSION_TTL)
return {"token": token, "token_type": "Bearer", "expires_at": value["expires_at"], "user": user}
def current_user(header):
token = credential(header, "Bearer")
with available():
value = sessions.get(session_key(token))
if value is None:
raise unauthorized()
data = json.loads(value)
if datetime.fromisoformat(data["expires_at"].replace("Z", "+00:00")) <= datetime.now(timezone.utc):
raise unauthorized()
user = storage.find_user(data["user_id"])
if user is None:
raise unauthorized()
return user
def logout(header):
token = credential(header, "Bearer")
with available():
removed = sessions.delete(session_key(token))
if not removed:
raise unauthorized()
def ready():
with available():
sessions.ping()
+14
View File
@@ -0,0 +1,14 @@
"""Настройки и чтение локальных Docker secrets."""
import os
from pathlib import Path
def secret(name):
return Path(os.environ[name + "_FILE"]).read_text().strip()
SESSION_TTL = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
if SESSION_TTL < 1:
raise ValueError("SESSION_TTL_SECONDS должен быть положительным")
if os.environ.get("SESSION_STORE", "valkey") != "valkey":
raise ValueError("В этой реализации SESSION_STORE=valkey")
+35
View File
@@ -0,0 +1,35 @@
"""Ограниченный пул; каждый with connection() — отдельная транзакция."""
from contextlib import contextmanager
import psycopg
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool, PoolTimeout, TooManyRequests
from src.config import secret
from src.errors import ApiError
pool = ConnectionPool(
conninfo=secret("DATABASE_URL"), open=False,
min_size=1, max_size=5, max_waiting=20, timeout=2,
check=ConnectionPool.check_connection,
kwargs={
"row_factory": dict_row,
"connect_timeout": 2,
"options": "-c timezone=UTC -c statement_timeout=3000 -c lock_timeout=2000 -c idle_in_transaction_session_timeout=5000",
},
)
@contextmanager
def connection():
try:
with pool.connection() as conn:
yield conn
except (psycopg.OperationalError, PoolTimeout, TooManyRequests):
raise ApiError(503, "unavailable", "PostgreSQL временно недоступен") from None
def ready():
with connection() as conn:
conn.execute("SELECT 1")
+3 -2
View File
@@ -5,11 +5,12 @@ from fastapi.responses import JSONResponse
class ApiError(Exception):
def __init__(self, status: int, code: str, message: str):
def __init__(self, status: int, code: str, message: str, headers=None):
super().__init__(message)
self.status = status
self.code = code
self.message = message
self.headers = headers or {}
def error_response(request: Request, error: ApiError):
@@ -22,5 +23,5 @@ def error_response(request: Request, error: ApiError):
"request_id": request.state.request_id,
}
},
headers={"X-Request-Id": request.state.request_id},
headers={"X-Request-Id": request.state.request_id, **error.headers},
)
+39
View File
@@ -0,0 +1,39 @@
"""Версионируемые миграции с проверкой checksum и блокировкой."""
import hashlib
from pathlib import Path
from src import db
DIRECTORY = Path(__file__).resolve().parents[1] / "migrations"
def apply():
applied = []
with db.connection() as conn:
conn.execute("SELECT pg_advisory_xact_lock(202602)")
conn.execute("""
CREATE TABLE IF NOT EXISTS schema_migrations (
version text PRIMARY KEY, checksum text NOT NULL,
applied_at timestamptz NOT NULL DEFAULT clock_timestamp()
)
""")
for path in sorted(DIRECTORY.glob("*.sql")):
checksum = hashlib.sha256(path.read_bytes()).hexdigest()
existing = conn.execute("SELECT checksum FROM schema_migrations WHERE version=%s", (path.name,)).fetchone()
if existing:
if existing["checksum"] != checksum:
raise RuntimeError("Изменена применённая миграция: " + path.name)
continue
conn.execute(path.read_text(), prepare=False)
conn.execute("INSERT INTO schema_migrations(version, checksum) VALUES (%s, %s)", (path.name, checksum))
applied.append(path.name)
return applied
if __name__ == "__main__":
db.pool.open(wait=True, timeout=15)
try:
print("Migrations:", ", ".join(apply()) or "already applied")
finally:
db.pool.close()
+1
View File
@@ -21,6 +21,7 @@ class RequestModel(BaseModel):
class CreateUser(RequestModel):
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
class CreateChat(RequestModel):
+23 -37
View File
@@ -1,53 +1,39 @@
"""выдача страниц через курсор"""
"""Курсор — scope, время и UUID; сами страницы выбирает PostgreSQL."""
import base64
import binascii
from datetime import datetime
import json
import re
from uuid import UUID
from src.errors import ApiError
def item_key(item):
return item["created_at"], item["id"]
def read_cursor(cursor: str, scope: str, items: list):
try:
decoded = base64.b64decode(cursor, altchars=b"-_", validate=True)
data = json.loads(decoded.decode("utf-8"))
if not isinstance(data, dict) or set(data) != {"scope", "created_at", "id"}:
raise ValueError
if data["scope"] != scope:
raise ValueError
for item in items:
if item["id"] == data["id"] and item["created_at"] == data["created_at"]:
return item_key(item)
except (ValueError, UnicodeError, binascii.Error, RecursionError):
pass
raise ApiError(400, "invalid_request", "Неверный cursor")
def make_page(items: list, scope: str, limit: str, cursor: str | None):
def parameters(limit, cursor, scope):
try:
if not re.fullmatch(r"[0-9]+", limit):
raise ValueError
size = int(limit)
if not 1 <= size <= 100:
raise ValueError
except ValueError:
raise ApiError(400, "invalid_request", "limit должен быть целым числом от 1 до 100")
anchor = None
if cursor is not None:
raw = base64.b64decode(cursor, altchars=b"-_", validate=True)
data = json.loads(raw.decode("utf-8"))
if not isinstance(data, dict) or set(data) != {"scope", "created_at", "id"}:
raise ValueError
if data["scope"] != scope or not isinstance(data["created_at"], str) or not data["created_at"].endswith("Z"):
raise ValueError
anchor = (datetime.fromisoformat(data["created_at"].replace("Z", "+00:00")), UUID(data["id"]))
return size, anchor
except (ValueError, TypeError, AttributeError, binascii.Error, RecursionError):
raise ApiError(400, "invalid_request", "Неверный limit или cursor") from None
ordered = sorted(items, key=item_key)
if cursor is not None:
last_key = read_cursor(cursor, scope, ordered)
ordered = [item for item in ordered if item_key(item) > last_key]
page = ordered[:size]
next_cursor = None
if len(ordered) > size:
last = page[-1]
data = {"scope": scope, "created_at": last["created_at"], "id": last["id"]}
next_cursor = base64.urlsafe_b64encode(json.dumps(data).encode("utf-8")).decode("ascii")
return {"items": page, "next_cursor": next_cursor}
def page(items, size, scope):
cursor = None
if len(items) > size:
last = items[size - 1]
value = {"scope": scope, "created_at": last["created_at"], "id": last["id"]}
cursor = base64.urlsafe_b64encode(json.dumps(value).encode()).decode()
return {"items": items[:size], "next_cursor": cursor}
+22
View File
@@ -0,0 +1,22 @@
"""Argon2id. Одновременно считаются не более двух хешей."""
from threading import Semaphore
from argon2 import PasswordHasher
from argon2.exceptions import VerificationError
hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
slots = Semaphore(2)
def hash_password(password):
with slots:
return hasher.hash(password)
def matches(encoded, password):
with slots:
try:
return hasher.verify(encoded, password)
except VerificationError:
return False
+96 -65
View File
@@ -1,90 +1,121 @@
"""словари, списки и блокировка для одновременных запросов"""
from datetime import datetime, timezone
from threading import Lock
"""Параметризованный SQL. Одна функция записи — одна транзакция."""
from uuid import UUID, uuid4
from psycopg.errors import ForeignKeyViolation, UniqueViolation
from src import db, pagination
from src.errors import ApiError
users = {} # id -> пользователь
usernames = {} # username -> id, для проверки уникальности
chats = {} # id -> чат
messages = {} # id чата -> список сообщений
lock = Lock()
def utc(value):
return value.isoformat(timespec="microseconds").replace("+00:00", "Z")
def new_record():
return {
"id": str(uuid4()),
"created_at": datetime.now(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z"),
}
def public_user(row):
return {"id": str(row["id"]), "username": row["username"],
"display_name": row["display_name"], "created_at": utc(row["created_at"])}
def create_user(username: str, display_name: str):
with lock:
if username in usernames:
raise ApiError(409, "conflict", "Имя пользователя уже занято")
user = new_record()
user.update(username=username, display_name=display_name)
users[user["id"]] = user
usernames[username] = user["id"]
return user
def public_chat(row):
return {"id": str(row["id"]), "title": row["title"],
"member_ids": [str(value) for value in row["member_ids"]], "created_at": utc(row["created_at"])}
def current_user(user_id: str | None):
if not user_id:
raise ApiError(401, "unauthorized", "Укажите существующего пользователя в X-User-Id")
def public_message(row):
return {"id": str(row["id"]), "chat_id": str(row["chat_id"]), "sender_id": str(row["sender_id"]),
"text": row["text"], "created_at": utc(row["created_at"])}
def create_user(username, display_name, password_hash):
try:
user_id = str(UUID(user_id))
except ValueError:
raise ApiError(400, "invalid_request", "X-User-Id должен быть UUID")
with lock:
if user_id not in users:
raise ApiError(401, "unauthorized", "Пользователь не найден")
return users[user_id]
with db.connection() as conn:
row = conn.execute("""INSERT INTO users(id, username, display_name, password_hash)
VALUES (%s, %s, %s, %s) RETURNING *""", (uuid4(), username, display_name, password_hash)).fetchone()
result = public_user(row)
return result
except UniqueViolation:
raise ApiError(409, "conflict", "Имя пользователя уже занято") from None
def create_chat(user_id: str, title: str, member_ids: list[str]):
with lock:
if user_id not in member_ids:
raise ApiError(400, "invalid_request", "Создатель должен входить в member_ids")
if any(member_id not in users for member_id in member_ids):
raise ApiError(400, "invalid_request", "Все участники должны существовать")
chat = new_record()
chat.update(title=title, member_ids=member_ids.copy())
chats[chat["id"]] = chat
messages[chat["id"]] = []
return chat
def find_login(username):
with db.connection() as conn:
return conn.execute("SELECT * FROM users WHERE username=%s", (username,)).fetchone()
def accessible_chat(user_id: str, chat_id: str):
chat = chats.get(chat_id)
if chat is None or user_id not in chat["member_ids"]:
def find_user(user_id):
with db.connection() as conn:
row = conn.execute("SELECT * FROM users WHERE id=%s", (UUID(user_id),)).fetchone()
return public_user(row) if row else None
def create_chat(user_id, title, member_ids):
if user_id not in member_ids:
raise ApiError(400, "invalid_request", "Создатель должен входить в member_ids")
try:
with db.connection() as conn:
row = conn.execute("INSERT INTO chats(id, title) VALUES (%s, %s) RETURNING *", (uuid4(), title)).fetchone()
with conn.cursor() as cur:
cur.executemany("INSERT INTO chat_members(chat_id, user_id) VALUES (%s, %s)",
[(row["id"], UUID(member)) for member in member_ids])
row["member_ids"] = member_ids
result = public_chat(row)
return result
except ForeignKeyViolation:
raise ApiError(400, "invalid_request", "Все участники должны существовать") from None
def require_member(conn, user_id, chat_id):
row = conn.execute("SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s", (UUID(chat_id), UUID(user_id))).fetchone()
if row is None:
raise ApiError(404, "not_found", "Чат не найден")
return chat
def get_chat(user_id: str, chat_id: str):
with lock:
return accessible_chat(user_id, chat_id)
def get_chat(user_id, chat_id):
with db.connection() as conn:
require_member(conn, user_id, chat_id)
row = conn.execute("""SELECT c.*, ARRAY(SELECT user_id FROM chat_members WHERE chat_id=c.id ORDER BY user_id) AS member_ids
FROM chats c WHERE c.id=%s""", (UUID(chat_id),)).fetchone()
return public_chat(row)
def list_chats(user_id: str):
with lock:
return [chat for chat in chats.values() if user_id in chat["member_ids"]]
def list_chats(user_id, limit, cursor):
scope = "chats:" + user_id
size, anchor = pagination.parameters(limit, cursor, scope)
with db.connection() as conn:
if anchor:
found = conn.execute("""SELECT 1 FROM chats c JOIN chat_members m ON m.chat_id=c.id
WHERE m.user_id=%s AND (c.created_at, c.id)=(%s, %s)""", (UUID(user_id), *anchor)).fetchone()
if not found:
raise ApiError(400, "invalid_request", "Неверный cursor")
condition = "AND (c.created_at, c.id) > (%s, %s)" if anchor else ""
params = (UUID(user_id), *(anchor or ()), size + 1)
rows = conn.execute("""WITH selected AS (
SELECT c.* FROM chats c JOIN chat_members own ON own.chat_id=c.id
WHERE own.user_id=%s """ + condition + """ ORDER BY c.created_at, c.id LIMIT %s
) SELECT c.*, ARRAY(SELECT user_id FROM chat_members WHERE chat_id=c.id ORDER BY user_id) AS member_ids
FROM selected c ORDER BY c.created_at, c.id""", params).fetchall()
return pagination.page([public_chat(row) for row in rows], size, scope)
def create_message(user_id: str, chat_id: str, text: str):
with lock:
accessible_chat(user_id, chat_id)
message = new_record()
message.update(chat_id=chat_id, sender_id=user_id, text=text)
messages[chat_id].append(message)
return message
def create_message(user_id, chat_id, text):
with db.connection() as conn:
require_member(conn, user_id, chat_id)
row = conn.execute("""INSERT INTO messages(id, chat_id, sender_id, text) VALUES (%s, %s, %s, %s)
RETURNING *""", (uuid4(), UUID(chat_id), UUID(user_id), text)).fetchone()
result = public_message(row)
return result
def list_messages(user_id: str, chat_id: str):
with lock:
accessible_chat(user_id, chat_id)
return messages[chat_id].copy()
def list_messages(user_id, chat_id, limit, cursor):
scope = "messages:" + chat_id
size, anchor = pagination.parameters(limit, cursor, scope)
with db.connection() as conn:
require_member(conn, user_id, chat_id)
if anchor:
found = conn.execute("SELECT 1 FROM messages WHERE chat_id=%s AND (created_at, id)=(%s, %s)", (UUID(chat_id), *anchor)).fetchone()
if not found:
raise ApiError(400, "invalid_request", "Неверный cursor")
condition = "AND (created_at, id) > (%s, %s)" if anchor else ""
rows = conn.execute("SELECT * FROM messages WHERE chat_id=%s " + condition +
" ORDER BY created_at, id LIMIT %s", (UUID(chat_id), *(anchor or ()), size + 1)).fetchall()
return pagination.page([public_message(row) for row in rows], size, scope)
+125 -77
View File
@@ -1,12 +1,11 @@
"""Проверки докера во временном контейнере"""
import argparse
"""Полный прогон lab2 в собственном Compose project; основные данные не затрагивает."""
from datetime import datetime, timezone
import json
import os
import platform
import socket
import subprocess
import sys
import time
from urllib.error import URLError
from urllib.request import urlopen
@@ -16,18 +15,13 @@ from helpers import Client, ROOT
def docker(*args):
result = subprocess.run(["docker", *args], check=True, capture_output=True, text=True, timeout=60)
return result.stdout.strip()
return subprocess.run(["docker", *args], check=True, capture_output=True, text=True, timeout=120).stdout.strip()
def inspect(container):
return json.loads(docker("inspect", container))[0]
def wait_ready(container):
subprocess.run([str(ROOT / "scripts/wait-ready.sh"), container], check=True, timeout=70)
def check_shutdown(container, base_url, port):
with socket.create_connection(("127.0.0.1", port), timeout=2) as pending:
pending.sendall(
@@ -68,85 +62,139 @@ def check_shutdown(container, base_url, port):
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--image", default="mtusi-messenger:lab2")
args = parser.parse_args()
container = "mtusi-messenger-lab2-check-" + uuid4().hex[:12]
created = False
with socket.socket() as sock:
sock.bind(("127.0.0.1", 0))
port = sock.getsockname()[1]
project = "lab2-check-" + uuid4().hex[:10]
env = dict(os.environ, COMPOSE_PROJECT_NAME=project, HOST_PORT=str(port), SESSION_TTL_SECONDS="3600")
base_url = f"http://127.0.0.1:{port}"
def compose(*args, capture=True, stdin=None):
return subprocess.run(["docker", "compose", *args], cwd=ROOT, env=env, input=stdin,
text=True, capture_output=capture, check=True, timeout=180)
def ready():
subprocess.run([str(ROOT / "scripts/start.sh")], cwd=ROOT, env=env,
check=True, capture_output=True, text=True, timeout=180)
print("PASS: start.sh built and started the stack, readiness reached")
def states():
return {service: inspect(compose("ps", "-q", service).stdout.strip()) for service in ("api", "postgres", "valkey")}
def scalar(query, params=()):
code = """import json,sys
from src import db
data=json.load(sys.stdin)
db.pool.open(wait=True,timeout=15)
try:
with db.connection() as conn:
row=conn.execute(data['query'], data['params']).fetchone()
print(json.dumps(next(iter(row.values()))))
finally:
db.pool.close()
"""
return json.loads(compose("exec", "-T", "api", "python", "-c", code,
stdin=json.dumps({"query": query, "params": params})).stdout)
print("UTC:", datetime.now(timezone.utc).isoformat())
print("Host:", platform.system(), platform.machine(), "Python", platform.python_version())
print("Docker:", docker("info", "--format", "{{.ServerVersion}} {{.Architecture}} CPUs={{.NCPU}} RAM={{.MemTotal}}"))
revision = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=ROOT, capture_output=True, text=True)
print("Base commit:", revision.stdout.strip() or "source snapshot", "(working tree may include final uncommitted changes)")
print("Command: ./scripts/check-docker.sh")
print("Container limits: 1 CPU, 256 MiB; no volumes; one API process")
print("Commit:", subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=ROOT, capture_output=True, text=True).stdout.strip(), "+ working tree")
print("Command: ./scripts/check-docker.sh; project:", project)
try:
docker("run", "--detach", "--name", container, "--label", "mtusi.lab=2",
"--cpus", "1", "--memory", "256m", "--publish", "127.0.0.1::8080", args.image)
created = True
wait_ready(container)
before = inspect(container)
port = int(before["NetworkSettings"]["Ports"]["8080/tcp"][0]["HostPort"])
base_url = f"http://127.0.0.1:{port}"
print("Image:", before["Image"])
print("Python in image:", docker("exec", container, "python", "--version"))
assert before["Mounts"] == [], "Обнаружены подключённые хранилища"
assert before["HostConfig"]["Memory"] == 256 * 1024 * 1024
assert before["HostConfig"]["NanoCpus"] == 1_000_000_000
uid = docker("exec", container, "id", "-u")
assert uid == "10001", "Сервер должен работать от непривилегированного пользователя"
pid1 = docker("exec", container, "python", "-c",
"from pathlib import Path; print(Path('/proc/1/cmdline').read_bytes().replace(b'\\0', b' ').decode().strip())")
assert pid1 == "python -m src", pid1
print("PASS: UID=10001; PID 1=python -m src; Docker health=healthy")
files = json.loads(docker("exec", container, "python", "-c",
"import json; from pathlib import Path; print(json.dumps(sorted(p.name for p in Path('/app').iterdir())))"))
assert files == ["requirements.txt", "src"], files
failed_health = subprocess.run(["docker", "exec", "-e", "APP_PORT=1", container,
"python", "-m", "src.healthcheck"], capture_output=True, timeout=10)
assert failed_health.returncode == 1
print("PASS: image contains only sources and requirements; failed healthcheck returns 1")
env = dict(os.environ, BASE_URL=base_url)
subprocess.run([str(ROOT / "scripts/check.sh")], cwd=ROOT, env=env, check=True, timeout=120)
ready()
before = states()
for service, info in before.items():
print(service, "image=" + info["Image"], "started=" + info["State"]["StartedAt"],
"memory=" + str(info["HostConfig"]["Memory"]), "nano_cpus=" + str(info["HostConfig"]["NanoCpus"]))
api = compose("ps", "-q", "api").stdout.strip()
assert docker("exec", api, "id", "-u") == "10001"
assert before["api"]["Config"]["Cmd"] == ["python", "-m", "src"]
for service in ("postgres", "valkey"):
assert any(mount["Type"] == "volume" for mount in before[service]["Mounts"])
assert all(mount["Destination"].startswith("/run/secrets/") for mount in before["api"]["Mounts"])
bad_health = subprocess.run(["docker", "exec", "-e", "APP_PORT=1", api, "python", "-m", "src.healthcheck"], capture_output=True)
assert bad_health.returncode == 1
print("PASS: non-root UID 10001; Python PID 1; healthcheck; named volumes; no API data volume")
subprocess.run([str(ROOT / "scripts/check.sh")], cwd=ROOT, env=dict(env, BASE_URL=base_url), check=True, timeout=240)
demo = subprocess.run([str(ROOT / "scripts/demo.sh")], cwd=ROOT, env=dict(env, BASE_URL=base_url),
check=True, capture_output=True, text=True, timeout=30)
assert "Привет из lab2!" in demo.stdout
print("PASS: demo.sh registered users, logged in and read two messages")
client = Client(base_url)
alice, bob, eve, chat = client.bootstrap()
marker = "private-message-" + uuid4().hex
first = client.message(alice, chat, marker)["json"]
second = client.message(bob, chat, "Ответ второго участника")["json"]
path = "/api/v1/chats/" + chat["id"]
history = client.call("GET", path + "/messages", actor=alice, schema="MessagePage")["json"]
assert {item["id"] for item in history["items"]} == {first["id"], second["id"]}
client.call("GET", path, 404, actor=eve)
result = subprocess.run(["docker", "logs", container], capture_output=True, text=True, check=True, timeout=10)
logs = result.stdout + result.stderr
assert marker not in logs and second["text"] not in logs
assert "request_id=" in logs and "duration_ms=" in logs
print("PASS: two members exchanged messages; outsider gets 404; logs contain no message text")
marker = "private-" + uuid4().hex
client.message(alice, chat, marker)
logs = docker("logs", api)
assert marker not in logs and alice["token"] not in logs and alice["registration"]["password"] not in logs
logs_result = subprocess.run(["docker", "logs", api], capture_output=True, text=True, check=True)
assert "request_id=" in logs_result.stderr + logs_result.stdout
assert marker not in logs_result.stderr + logs_result.stdout
assert alice["token"] not in logs_result.stderr + logs_result.stdout
assert alice["registration"]["password"] not in logs_result.stderr + logs_result.stdout
assert scalar("SELECT bool_and(password_hash LIKE %s) FROM users", ("$argon2id$%",))
print("PASS: Argon2id in PostgreSQL; logs do not contain message text, passwords or session tokens")
docker("restart", "--time", "10", container)
wait_ready(container)
after = inspect(container)
assert after["Image"] == before["Image"]
assert after["State"]["StartedAt"] != before["State"]["StartedAt"]
title = "rollback_" + uuid4().hex
client.call("POST", "/api/v1/chats", 400, actor=alice,
body={"title": title, "member_ids": [alice["id"], str(uuid4())]})
assert scalar("SELECT count(*) FROM chats WHERE title=%s", (title,)) == 0
count = scalar("SELECT count(*) FROM messages")
compose("exec", "-T", "api", "python", "-m", "src.migrate")
compose("exec", "-T", "api", "python", "-m", "src.migrate")
assert scalar("SELECT count(*) FROM schema_migrations") == 1
assert scalar("SELECT count(*) FROM messages") == count
print("PASS: failed membership insert rolled back chat; migrations run twice without duplicate data")
port = int(after["NetworkSettings"]["Ports"]["8080/tcp"][0]["HostPort"])
base_url = f"http://127.0.0.1:{port}"
client = Client(base_url)
client.call("GET", "/api/v1/users/me", 401, actor=alice)
fresh = client.user("after_restart")
client.call("GET", path, 404, actor=fresh)
print("PASS: real restart with same image; old user gets 401; old chat gets 404")
print("StartedAt before:", before["State"]["StartedAt"])
print("StartedAt after: ", after["State"]["StartedAt"])
before = states()
subprocess.run(["make", "test-persistence", "PYTHON=" + sys.executable,
"ACTION_SCRIPT=scripts/restart.sh", "BASE_URL=" + base_url], cwd=ROOT, env=env, check=True, timeout=240)
after = states()
for service in before:
assert before[service]["State"]["StartedAt"] != after[service]["State"]["StartedAt"]
print("Restart", service, before[service]["State"]["StartedAt"], "->", after[service]["State"]["StartedAt"])
client.call("GET", "/api/v1/users/me", actor=alice, schema="User")
print("PASS: API, PostgreSQL and Valkey really restarted; previous token still works")
check_shutdown(container, base_url, port)
print("PASS: all Docker and API checks completed")
for service in ("valkey", "postgres"):
try:
compose("stop", "--timeout", "10", service)
started = time.monotonic()
client.call("GET", "/api/v1/users/me", 503, actor=alice)
elapsed = time.monotonic() - started
assert elapsed < 6, elapsed
client.call("GET", "/api/v1/users/me", 401)
client.call("GET", "/health/ready", 503)
client.call("GET", "/health/live", schema="Health")
print(f"PASS: {service} unavailable -> 503 in {elapsed:.2f}s; anonymous -> 401; readiness 503, liveness 200")
finally:
compose("start", service)
subprocess.run([str(ROOT / "scripts/wait-ready.sh")], cwd=ROOT, env=env, check=True, timeout=90)
client.call("GET", "/api/v1/users/me", actor=alice, schema="User")
print("PASS:", service, "recovered without a new login")
env["SESSION_TTL_SECONDS"] = "2"
compose("up", "-d", "--force-recreate", "api")
subprocess.run([str(ROOT / "scripts/wait-ready.sh")], cwd=ROOT, env=env, check=True, timeout=90)
short = client.user("short_ttl")
client.call("GET", "/api/v1/users/me", actor=short, schema="User")
time.sleep(2.2)
client.call("GET", "/api/v1/users/me", 401, actor=short)
print("PASS: SESSION_TTL_SECONDS=2; valid token expires without logout")
api = compose("ps", "-q", "api").stdout.strip()
check_shutdown(api, base_url, port)
print("PASS: all lab2 Docker checks completed")
finally:
if created:
docker("rm", "--force", container)
print("Temporary test container removed")
try:
subprocess.run([str(ROOT / "scripts/stop.sh")], cwd=ROOT, env=env,
check=True, capture_output=True, text=True, timeout=90)
volumes = docker("volume", "ls", "--quiet", "--filter", "label=com.docker.compose.project=" + project)
if volumes:
print("PASS: stop.sh removed containers and preserved named volumes")
finally:
compose("down", "--volumes", "--timeout", "10")
print("Removed only temporary Compose project and its test volumes:", project)
if __name__ == "__main__":
+7 -5
View File
@@ -25,6 +25,8 @@ class ApiTests(ApiTestCase):
{"username": "valid_name", "display_name": "Имя", "extra": 1},
]
for body in invalid_bodies:
if isinstance(body, dict):
body = {**body, "password": "Synthetic-password-123"}
with self.subTest(body=body):
self.assert_error("POST", "/api/v1/users", 400, "invalid_request",
raw=json.dumps(body).encode(), headers={"Content-Type": "application/json"})
@@ -47,13 +49,13 @@ class ApiTests(ApiTestCase):
def test_identification_and_authentication_order(self):
self.assert_error("GET", "/api/v1/users/me", 401, "unauthorized")
self.assert_error("GET", "/api/v1/users/me", 401, "unauthorized",
headers={"X-User-Id": str(uuid4())})
self.assert_error("GET", "/api/v1/users/me", 400, "invalid_request",
headers={"X-User-Id": "not-a-uuid"})
headers={"X-User-Id": self.alice["id"]})
self.assert_error("GET", "/api/v1/users/me", 401, "unauthorized",
headers={"Authorization": "Bearer unknown-session"})
self.assert_error("POST", self.path + "/messages", 401, "unauthorized",
raw=b'{', headers={"Content-Type": "application/json"})
me = self.client.call("GET", "/api/v1/users/me", schema="User",
headers={"X-User-Id": self.alice["id"].upper()})["json"]
me = self.client.call("GET", "/api/v1/users/me", schema="User", actor=self.alice,
headers={"X-User-Id": self.bob["id"]})["json"]
self.assertEqual(me, self.alice["user"])
def test_invalid_chat_members(self):
+1 -1
View File
@@ -39,7 +39,7 @@ class ConcurrencyTests(ApiTestCase):
client = Client()
barrier.wait(timeout=10)
return client.call("POST", "/api/v1/users", [201, 409],
body={"username": username, "display_name": f"Клиент {worker}"})["status"]
body={"username": username, "display_name": f"Клиент {worker}", "password": "Synthetic-password-123"})["status"]
with ThreadPoolExecutor(max_workers=10) as pool:
statuses = list(pool.map(register, range(10)))
+51
View File
@@ -0,0 +1,51 @@
import base64
from uuid import uuid4
from helpers import ApiTestCase
class SessionTests(ApiTestCase):
def basic(self, username, password):
value = base64.b64encode((username + ":" + password).encode()).decode()
return {"Authorization": "Basic " + value}
def test_wrong_password_and_basic_only_for_login(self):
registration = self.alice["registration"]
self.assert_error("POST", "/api/v1/auth/sessions", 401, "unauthorized",
headers=self.basic(registration["username"], "wrong-password"))
self.assert_error("POST", "/api/v1/auth/sessions", 401, "unauthorized")
self.assert_error("POST", "/api/v1/auth/sessions", 401, "unauthorized",
headers={"Authorization": "Basic not-base64!"})
self.assert_error("GET", "/api/v1/users/me", 401, "unauthorized",
headers=self.basic(registration["username"], registration["password"]))
def test_logout_revokes_only_one_session(self):
registration = self.alice["registration"]
second = self.client.call("POST", "/api/v1/auth/sessions", 201, schema="Session",
headers=self.basic(registration["username"], registration["password"]))["json"]
self.client.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=self.alice)
self.assert_error("GET", "/api/v1/users/me", 401, "unauthorized", actor=self.alice)
self.assert_error("DELETE", "/api/v1/auth/sessions/current", 401, "unauthorized", actor=self.alice)
self.client.call("GET", "/api/v1/users/me", schema="User", headers={"Authorization": "Bearer " + second["token"]})
def test_password_validation(self):
for password in ("short", "x" * 129, 123, None, " " * 12):
body = {"username": "pw_" + uuid4().hex[:20], "display_name": "Пароль", "password": password}
self.assert_error("POST", "/api/v1/users", 400, "invalid_request", body=body)
def test_unicode_password_with_colon_and_private_response(self):
username = "pw_" + uuid4().hex[:20]
password = "Пароль:с:двоеточием-123"
user = self.client.call("POST", "/api/v1/users", 201, schema="User",
body={"username": username, "display_name": "Пароль", "password": password})["json"]
session = self.client.call("POST", "/api/v1/auth/sessions", 201, schema="Session",
headers=self.basic(username, password))["json"]
self.assertEqual(session["user"], user)
self.assertEqual(set(user), {"id", "username", "display_name", "created_at"})
self.assertGreaterEqual(len(session["token"]), 32)
def test_sql_like_message_is_plain_text(self):
text = "'; DROP TABLE messages; -- Привет"
message = self.client.message(self.alice, self.chat, text)["json"]
self.assertEqual(message["text"], text)
self.assertEqual(self.read_all(self.path + "/messages", self.bob, "MessagePage"), [message])