ЛР 2 — БВТ2302 — Карпова — на 5 #148

Open
Nadya_Karpovaa wants to merge 1 commits from Nadya_Karpovaa/mtusi2026lab2:solution/bvt2302-karpova into master
40 changed files with 4208 additions and 20 deletions
+76
View File
@@ -0,0 +1,76 @@
# Разбор решения перед защитой
Не заучивайте ответы без проверки: откройте указанные файлы, найдите запросы, запустите тесты и попробуйте объяснить своими словами.
## Как проходит запрос
Клиент (например публичный tests/smoke.py) отправляет HTTP-запрос → Gunicorn принимает его → Flask выбирает обработчик в src/app.py → обработчик берёт соединение из пула → выполняет параметризованный SQL в PostgreSQL → транзакция завершается → клиент получает JSON. Все постоянные данные хранятся в PostgreSQL, файлы БД — в именованном Docker volume. Сам API можно пересоздать, данные останутся.
## Регистрация, вход и доступ — разные действия
1. `POST /api/v1/users`: создаёт пользователя. Пароль проходит Argon2id — медленную, требовательную к памяти функцию. В БД записывается hash с солью и параметрами, исходный пароль не сохраняется и не возвращается.
2. `POST /api/v1/auth/sessions`: клиент присылает `Authorization: Basic …`. Base64 содержит `username:password`; это кодирование, его легко обратить, поэтому для реальной удалённой работы нужен HTTPS. API проверяет пароль через Argon2id и создаёт случайный токен из 32 случайных байт (256 бит).
3. Ответ содержит Bearer-токен. Последующие запросы присылают `Authorization: Bearer …`. В PostgreSQL хранится только SHA-256 токена, user_id и expires_at. Быстрый SHA-256 подходит для случайного токена с высокой энтропией, но не для пароля человека.
4. Сессия действительна, пока найдена её запись и expires_at позже часов PostgreSQL. Рестарт не обновляет expires_at.
5. Logout удаляет запись сессии, повторный запрос с этим токеном получает 401.
6. Успешная аутентификация ещё не даёт доступ ко всем чатам. Таблица members проверяет членство. Чужой и отсутствующий чат оба дают 404, чтобы не раскрывать наличие чужого чата. `X-User-Id` вообще не участвует в выборе пользователя.
Найдите функции register, login, authenticate, chat и logout. Объясните, чем они отличаются.
## Таблицы
- users: UUID, уникальный username, имя, password_hash и время.
- chats: UUID, заголовок и время.
- members: составной первичный ключ (chat_id,user_id); дубли членства невозможны.
- messages: UUID, чат, автор, текст и время. Составной внешний ключ требует, чтобы автор состоял в чате.
- sessions: hash токена, пользователь и абсолютный срок действия.
- schema_migrations: какие версии миграций уже применены.
Первичный ключ идентифицирует строку, UNIQUE не допускает повторов username, FOREIGN KEY не допускает ссылок на несуществующие записи. Проверки в Python удобны для понятной ошибки, ограничения БД защищают данные и при гонках.
## Транзакции
`with pool.connection() as conn:` завершается COMMIT при успехе и ROLLBACK при исключении. Создание чата и всех строк members происходит в одном таком блоке: нельзя получить половину чата после ошибки. Если ошибётся SQL вставки участника, вставка самого чата тоже откатится. Публичные ошибки наружу не содержат SQL.
COMMIT означает, что PostgreSQL зафиксировал транзакцию. При стандартных fsync=on и synchronous_commit=on WAL сброшен в устойчивое хранилище до подтверждения. Это зависит от честности диска/виртуализации. Volume сохраняет файлы после удаления контейнера, но не защищает от потери компьютера или удаления самого volume. Этот стенд не имеет репликации и резервного копирования.
Миграции создают таблицы с нуля. Версия хранится в schema_migrations, advisory lock сериализует одновременные запуски миграций. Повтор уже применённой версии пропускается. Применённые SQL-файлы не редактируют: добавляют следующую миграцию.
## История и пагинация
SQL сортирует по `(created_at,id)`. При следующей странице условие `(created_at,id) > (время,UUID из cursor)`. Это keyset pagination: последняя строка страницы не повторяется. Индекс `(chat_id,created_at,id)` соответствует фильтру и порядку. Читаем limit+1 строку, чтобы понять, есть ли продолжение. Если лишней строки нет, next_cursor=null.
Cursor — base64 от JSON с областью запроса, временем и UUID. Он непрозрачен по контракту для клиента, но не зашифрован и не подписан. Это не секрет и не разрешение доступа: членство проверяется заново при любом cursor. Cursor другого чата отвергается.
Между страницами нет общего snapshot. Времена назначает PostgreSQL; при конкурирующих транзакциях запись с более ранним временем может стать видимой позже, поэтому обход не обещает включить все конкурентные вставки. Неизменная история обходится без повторов. Часы не используются как уникальный идентификатор — есть UUID.
## Где Redis и почему его потеря безопасна
Redis кэширует только неизменяемый публичный профиль пользователя. Источник истины — users в PostgreSQL. На каждом защищённом запросе сначала проверяется сессия в PostgreSQL. Затем берётся профиль из Redis (ключ profile:v1:UUID), при промахе — из users с SETEX на 60 секунд. Кэш не хранит password_hash, Bearer-токен или право доступа к чату.
При flush/restart Redis профили исчезнут, но действующие сессии и все сообщения останутся. Следующие запросы заново заполнят кэш. TTL кэша 60 секунд и TTL сессии 3600 секунд — разные вещи. Logout сразу удаляет сессию в PostgreSQL; сохранённый профиль в Redis не позволяет войти повторно. Профили в обязательном API не меняются. Если добавить редактирование имени, понадобится инвалидация ключа при изменении; прямое ручное изменение БД может показывать старое имя до TTL.
Redis не критичен для ready: при отказе читаем PostgreSQL. Ошибка БД даёт 503: нельзя принять кэш за действительную сессию. Для Redis заданы таймауты 0,2 с и отключены retries, дополнительно общий бюджет операции 0,25 с (включая DNS), два фоновых worker и circuit breaker 2 с. Поэтому отключённый кэш не занимает все HTTP-потоки надолго. Фоновый результат не влияет на аутентификацию.
## Что исследовано на 5
Откройте RESEARCH.md и evidence/query-study.json. В отдельной БД 120 000 сообщений: один чат 100 000, второй 19 000, сто чатов по 10. Сравниваются B-tree (created_at,id) и (chat_id,created_at,id) при одинаковом SQL. В первом варианте PostgreSQL может читать/фильтровать много чужих сообщений или делать seq scan и sort. Во втором сначала выбирается нужный chat_id, затем упорядоченный диапазон. EXPLAIN ANALYZE показывает фактическое время/строки, BUFFERS — работу с буферами, shared hit не равен физическому чтению с диска.
Более широкий индекс занимает место и обслуживается при INSERT. Нельзя обещать, что он ускоряет любой запрос или не имеет цены записи: сравните реальные результаты трёх раундов. Измерены SQL roundtrip и вставка 5000 строк, не максимальные HTTP RPS. Вставка затем откатывается, чтобы каждый вариант начинал с одинакового объёма; COMMIT в её время не входит.
Backup делается pg_dump -Fc, восстанавливается pg_restore в отдельный PostgreSQL и новый volume. Сравниваются количества строк, выбранные сообщения и SHA-256 всех 120 000 сообщений в порядке UUID. Это сильнее проверки «контейнер запустился». Но оба volume на одном Docker-host: пожар/потеря диска затронет оба. Без WAL archiving backup не восстанавливает более поздние записи; RPO зависит от интервала между backup. Измеренное время включает старт нового контейнера, но не заменяет production RTO.
## Как показать работу
1. `docker compose ps` — три сервиса healthy.
2. `make test` — создаёт пользователей, чат, сообщения, проверяет историю и запрет чужого доступа, logout.
3. `make test-persistence ACTION_SCRIPT=scripts/restart.sh` — создаёт новые данные и сохраняет токен в памяти теста, перезапускает API, PostgreSQL и Redis, читает старые данные тем же токеном.
4. `python3 student-tests/security.py` — негативные сценарии и гонка username.
5. `python3 student-tests/level4.py` — Redis hit/TTL, отказ кэша, logout при отказе и rollback после искусственной ошибки INSERT участника.
6. `python3 student-tests/infrastructure.py` — подробный повтор persistence, сроки запусков контейнеров/БД, повтор миграций, короткий TTL и отказ БД. Требует Docker, свободного порта 8081 и отсутствия контейнера lab2-expiry. Останавливает БД только этого учебного Compose-проекта.
7. `python3 student-tests/research.py` — полный индексный эксперимент, backup/restore и сверка в новом хранилище. Выполнять после функциональных тестов, не одновременно с рестартом/пересборкой API.
## Попробуйте ответить сами
Почему два одновременных INSERT с одним username не создают двух пользователей? Почему возврат HTTP 201 выполняется после выхода из транзакции? Почему остановка PostgreSQL даёт 503, а не «пользователя без проверки»? Почему Basic нельзя использовать вместо Bearer на /users/me? Почему `down -v` ломает сохранность, а обычный `down` — нет? Где проходит граница транзакции создания чата? Найдите ответы в коде, не только в этом файле.
+14
View File
@@ -0,0 +1,14 @@
# syntax=docker/dockerfile:1
FROM python:3.12.12-slim-bookworm
WORKDIR /app
COPY requirements.txt .
RUN --mount=type=secret,id=proxy_ca \
if [ -f /run/secrets/proxy_ca ]; then export PIP_CERT=/run/secrets/proxy_ca; fi; \
pip install --no-cache-dir -r requirements.txt
COPY src ./src
COPY migrations ./migrations
COPY contracts ./contracts
RUN chmod -R a+rX /app && useradd --uid 10001 --create-home app
USER app
EXPOSE 8080
CMD ["sh", "-c", "python src/migrate.py && exec gunicorn --chdir src --bind 0.0.0.0:8080 --workers 1 --threads 4 --timeout 30 --access-logfile - app:app"]
+168
View File
@@ -0,0 +1,168 @@
# Как запустить и сдать лабораторную
Это решение с целевой оценкой 5: все требования уровней 3–4 и исследовательский трек 2. Окончательную оценку ставит преподаватель после проверки и защиты. Сначала прочитайте REPORT.md и DEFENSE.md. Не сдавайте решение, которое не можете объяснить. Возможности вашей lab1 сравнены, собственные тесты адаптированы к новой авторизации. В LAB1_TRANSITION.md описано, что сохранено и изменено.
## 1. Аккаунт и своя копия на Gitea
1. Откройте https://gitea.privcloud.tech в браузере.
2. Нажмите «Регистрация» / Register. Если этой кнопки нет, спросите преподавателя, как получить аккаунт: самостоятельно включить регистрацию нельзя.
3. Введите свой логин, почту и придумайте пароль. Пароль и коды подтверждения никому не отправляйте, включая чат с ИИ. Если пришло письмо, подтвердите почту.
4. Войдите. Откройте https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2 .
5. Нажмите «Fork» / «Создать ответвление» вверху страницы. Владельцем выберите свой аккаунт. Не создавайте вместо fork пустой независимый репозиторий: тогда оформить запрос на слияние труднее.
6. В своей копии нажмите «Код» / Code и скопируйте HTTPS-адрес. Он будет вида `https://gitea.privcloud.tech/ВАШ_ЛОГИН/mtusi2026lab2.git`.
Названия кнопок зависят от языка и версии Gitea. Сюда загружен ZIP, поэтому в нём нет истории Git и нет связи с вашим аккаунтом. Историю нужно взять из fork.
## 2. Программы на компьютере
Понадобятся Git, Python 3.9+ для публичных тестов и Docker с Compose v2. На Windows установите Git for Windows, Python и Docker Desktop с Linux containers/WSL2. После установки откройте Docker Desktop и дождитесь запуска движка. В установщике Python включите добавление Python в PATH.
Дальнейшие команды на Windows выполняйте в Git Bash (пункт «Git Bash Here» в папке). На Linux/macOS — в терминале. Для Windows, если `python3` не найден, заменяйте его на `python`; для Makefile используйте `make test PYTHON=python` либо приведённую ниже команду без make. На Linux требуется доступ пользователя к Docker согласно инструкции вашей ОС; не меняйте права сокета на 777.
Если у вас **Mac**, установите Docker Desktop для своего процессора (Apple Silicon для M1/M2/M3/M4, Intel для старых Intel Mac) и запустите его из «Программы». Откройте приложение «Терминал». Проверьте `python3 --version` и `git --version`; при предложении macOS установить Command Line Tools согласитесь. Основные команды ниже подходят для терминала macOS. Python и Git при необходимости установите из официальных дистрибутивов. Если make недоступен, для функционального run_all всё же нужен make (обычно входит в Command Line Tools); сначала завершите установку инструментов.
Проверьте:
```sh
git --version
python3 --version
docker --version
docker compose version
docker info
```
Если `docker info` пишет, что не может подключиться к daemon, сначала запустите Docker Desktop. Не переходите к тестам с неработающим Docker.
## 3. Ветка и файлы
Откройте терминал в папке, где хотите хранить работу:
```sh
git clone https://gitea.privcloud.tech/ВАШ_ЛОГИН/mtusi2026lab2.git
cd mtusi2026lab2
git switch -c solution/bvi2302-karpova
```
Ветка уже названа для вашей группы и фамилии. Для clone замените только ВАШ_ЛОГИН на логин вашего аккаунта Gitea.
Распакуйте архив решения В ДРУГУЮ папку. Скопируйте из него файлы и папки внутрь только что клонированного репозитория. Вложенной папки `mtusi2026lab2/mtusi2026lab2` получиться не должно: `compose.yaml`, `REPORT.md` и `Makefile` должны лежать рядом.
Никогда не копируйте чужую папку `.git`, `.env`, `secrets`, `.venv` или данные БД. В выданном архиве решения их нет. Исходный README преподавателя, contracts и публичные tests сохранены. ФИО и группа уже внесены: Карпова Надежда Сергеевна, БВИ2302. После создания запроса останется вписать ссылку на него в REPORT.md. Помощь ИИ указана, ваша lab1 учтена.
## 4. Запуск
Все команды выполняются из папки с `compose.yaml`:
```sh
python3 scripts/init-local.py
docker compose config --quiet
docker compose up -d --build --wait
```
Первая команда создаёт случайные локальные учебные пароли в `secrets/`; она не печатает их и не меняет уже существующие. Эти файлы не отправляются в Git. При обычном запуске `.env` не обязателен: TTL по умолчанию 3600 секунд.
На первом запуске Docker скачает образы и зависимости. Дождитесь завершения команды. Проверьте:
```sh
docker compose ps
curl http://localhost:8080/health/ready
```
Ожидается `{"status":"ok"}`. Это REST API, отдельного красивого сайта/интерфейса у него нет — по заданию он не нужен.
Если порт 8080 занят, остановите своё приложение, которое его использует, либо измените только левый порт в `127.0.0.1:8080:8080` и передавайте тестам новый BASE_URL. Если контейнер unhealthy:
```sh
docker compose logs --tail 80 api db
```
Не публикуйте полный лог без проверки на секреты. Если ошибка `password authentication failed` после самостоятельной замены secrets, в старом volume остался прежний пароль. Верните исходные локальные секреты. Не удаляйте volume с нужными данными.
## 5. Проверки и доказательства
В решении уже приложены реальные результаты проверок облачного стенда. Перед сдачей повторите проверки у себя; это поможет на защите. Текстовые результаты подходят по заданию, скриншоты необязательны.
```sh
python3 scripts/capture.py evidence/check-local.txt -- python3 scripts/check_contract.py
python3 scripts/capture.py evidence/smoke-local.txt -- python3 tests/smoke.py
python3 scripts/capture.py evidence/security-local.txt -- python3 student-tests/security.py
```
Сохранность данных и прежней сессии:
```sh
chmod +x scripts/restart.sh
docker compose ps
python3 scripts/capture.py evidence/persistence-local.txt -- python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh
docker compose ps
```
На Windows для persistence рекомендуется WSL2 с Git и Python внутри WSL: Windows Python может не запустить shell-script hook. Откройте папку через терминал WSL и повторите команды там.
Если установлен make, эквивалентные обязательные команды: `make check`, `make test`, `make test-persistence ACTION_SCRIPT=scripts/restart.sh`. Скрипт перезапускает API, PostgreSQL и Redis; не удаляет volume.
При скриншотах покажите команду, PASS и состояния контейнеров, не раскрывайте пароли/токены. Сохраните небольшие изображения в `evidence/` и добавьте ссылки в REPORT.md. Не заменяйте проваленный результат словом PASS.
### Полная проверка на 5
После запуска трёх healthy-сервисов выполните ПОСЛЕДОВАТЕЛЬНО, не одновременно:
```sh
python3 scripts/capture.py evidence/grade5-functional-local.txt -- python3 student-tests/run_all.py
python3 scripts/capture.py evidence/grade5-study-local.txt -- python3 student-tests/research.py
```
Первая команда включает публичные и собственные проверки, перенесённые тесты lab1, Redis/БД-отказы, rollback и полный restart. Она временно останавливает только сервисы этого учебного проекта. Не запускайте её против чужой или production БД. Требуются свободный порт 8081 и отсутствие контейнера lab2-expiry.
Вторая создаёт отдельную исследовательскую БД с 120 000 синтетических сообщений, сравнивает индексы, измеряет записи, делает backup и восстановление в НОВЫЙ PostgreSQL-контейнер и НОВЫЙ volume. Нужны свободные ресурсы Docker (ориентировочно 1–2 ГБ дополнительного диска). Скрипт использует образ PostgreSQL из задания и локальный secrets/db_password, секреты не печатает. Рабочую messenger не удаляет. Не останавливайте/пересобирайте API и БД до завершения эксперимента.
Ожидайте PASS обоих запусков. Исследовательский скрипт обновляет evidence/query-study.json реальными измерениями вашего компьютера. Таблица в RESEARCH.md описывает приложенный облачный прогон — если заменяете JSON своими данными, обновите и таблицу либо сохраните собственный JSON отдельно перед повтором. Не называйте облачные цифры измерениями вашего ноутбука.
После исследования временный recovery-контейнер удаляется, исходная исследовательская БД и новый volume остаются для осмотра. Их случайные имена выводятся/пишутся в evidence/query-study.json. Новый запуск использует новые имена. Для уборки удаляйте только перечисленные исследовательские объекты, когда они больше не нужны; основной postgres_data не трогайте. Обычный `docker compose down -v` не удаляет отдельный исследовательский volume.
## 6. Отправка в свой fork
```sh
git status --short
git diff -- README.md contracts tests
```
Последняя команда должна ничего не вывести: материалы преподавателя не менялись. Проверьте, что среди добавляемых файлов нет `.env`, `secrets/`, токенов и дампов. Затем:
```sh
git add src migrations student-tests scripts/init-local.py scripts/capture.py scripts/restart.sh Dockerfile compose.yaml requirements.txt REPORT.md HOW_TO_SUBMIT.md DEFENSE.md MR_DESCRIPTION.md LAB1_TRANSITION.md RESEARCH.md evidence
git diff --cached --stat
git diff --cached
```
Просмотрите изменения. В отчёте должны быть ваши ФИО, группа, результаты, использование ИИ. Если всё правильно:
```sh
git commit -m "Реализовать lab2: PostgreSQL и постоянные Bearer-сессии"
git push -u origin solution/bvi2302-karpova
```
Если Git просит представиться, один раз в этом репозитории выполните `git config user.name "Ваше имя"` и `git config user.email "Ваша почта"`, затем повторите commit. Если Gitea требует токен вместо пароля, создайте его в настройках своего аккаунта по инструкции Gitea и используйте только в окне авторизации Git/менеджере учётных данных. Не вставляйте токен в URL, код, отчёт или чат.
## 7. Запрос на слияние (PR / merge request)
1. Откройте свой fork в браузере.
2. Нажмите предложение создать Pull Request после push либо вкладку «Запросы на слияние» → «Новый запрос».
3. Базовый репозиторий: `mtusi2026/mtusi2026lab2`, базовая ветка: исходная ветка преподавателя (в скачанном архиве она названа master; проверьте в интерфейсе).
4. Репозиторий-источник: ваш fork; ветка-источник: `solution/…`.
5. Посмотрите сравнение: должны быть исходники, инфраструктура, ваши тесты, отчёт, RESEARCH.md и evidence. Контракт/публичные тесты не должны изменяться.
6. Заголовок: `ЛР 2 — БВИ2302 — Карпова — на 5`.
7. В описание вставьте MR_DESCRIPTION.md, добавив фактические результаты проверок на своём компьютере. Не отмечайте непроверенные пункты.
8. Нажмите «Создать запрос». **Не нажимайте Merge/«Слить» самостоятельно**: запрос проверяет преподаватель.
9. Скопируйте ссылку на запрос в REPORT.md, сделайте ещё commit и push в ту же ветку.
10. При замечаниях меняйте эту же ветку и делайте commit/push: запрос обновится. Новую заявку на каждую правку создавать не нужно.
Создание запроса означает готовность сдавать. Сначала добейтесь проходящих тестов и разберитесь в коде.
## Остановка
```sh
docker compose down
```
Данные остаются в именованном volume. Следующий `docker compose up -d --wait` их восстановит. Команда `docker compose down -v` **намеренно удаляет все данные рабочего PostgreSQL** (отдельные исследовательские volumes остаются); не используйте её во время проверки сохранности и не запускайте, если данные нужны.
+26
View File
@@ -0,0 +1,26 @@
# Переход собственной lab1 → lab2
Автор: **Карпова Надежда Сергеевна, БВИ2302**. Группа взята из актуального сообщения автора; в старом REPORT.md архива была запись БВТ2302.
Изучен предоставленный lab1_karpova.zip: main.py на FastAPI/Pydantic, requirements.txt, Dockerfile, REPORT.md, собственные tests/own_tests.py, tests/concurrency.py, benchmark_track1.py и материалы задания. Старые .git/.env/venv/кэши/скриншоты с персональными данными не переносятся в lab2. Предыдущие измерения не используются как доказательства новой лабораторной.
| Возможность lab1 | Решение lab2 | Проверка |
| --- | --- | --- |
| Регистрация username/display_name, UNIQUE | таблица users, UNIQUE, Argon2id password | public smoke, security.py |
| Выбор пользователя X-User-Id | объявленный переход: password при регистрации, Basic login, Bearer | public smoke; X-User-Id не даёт доступа |
| Чаты с явными участниками | chats + members, одна SQL-транзакция | public smoke, level4.py rollback |
| Чужой чат скрывается 404 | проверка members в PostgreSQL | public smoke, адаптированный lab1_own_tests.py |
| Сообщения и автор из запроса идентификации | sender_id из действительной сессии, FK к members | public smoke, lab1_concurrency.py |
| Unicode, строгие поля, malformed JSON 400 | jsonschema по неизменённому контракту lab2 | security.py, lab1_own_tests.py |
| Cursor по времени/UUID и scope | keyset SQL + messages_history B-tree | public smoke, lab1_own_tests.py, query-study.json |
| RLock и словари одного процесса | транзакции, ограничения, общий PostgreSQL | гонка username, 100 сообщений/10 клиентов |
| In-memory sorted_messages_cache | индекс PostgreSQL, история без Redis-кэша | EXPLAIN на 120000 сообщений |
| Health, request_id, общий JSON ошибок | Flask hooks/handlers, live/ready | public smoke, отказы БД/Redis |
| Non-root Docker, graceful stop | UID 10001, Gunicorn, Compose healthchecks | Docker сборка/запуск; полный restart |
| Потеря состояния после рестарта | объявленное улучшение lab2: данные и сессии сохраняются | persistence с рестартом трёх сервисов |
HTTP-обработчики main.py архитектурно переработаны: FastAPI/Pydantic → Flask/jsonschema, in-memory state → PostgreSQL. Старый main.py не копируется как второй конкурирующий сервер. Язык Python и обязательное поведение сохранены, внешние различия — предусмотренная курсом новая аутентификация и сохранность.
Два собственных сценария lab1 перенесены в student-tests/lab1_own_tests.py и student-tests/lab1_concurrency.py с добавлением password, Basic login и Bearer. Публичные tests/ и contracts/ текущей lab2 не заменены старыми версиями. Оригинальные assertions на неверный JSON, дубликат username, ACL, пробельный текст, обход страниц, ошибочный scope cursor, 100 успешных записей и 100 уникальных ID сохранены. Текущий реальный вывод — evidence/grade5-functional.txt.
Помощь ИИ при адаптации и новой реализации раскрыта в REPORT.md; это не отменяет необходимости понимать код и уметь изменить его на защите.
+25
View File
@@ -0,0 +1,25 @@
## Лабораторная 2
Автор / группа: **Карпова Надежда Сергеевна, БВТ2302**
Целевая оценка: **5**
Трек: **2 — План запроса и восстановление**
Реализован REST API с PostgreSQL, версионируемыми миграциями, параметризованными SQL, ограниченным пулом/таймаутами, Argon2id и постоянными Bearer-сессиями с expiry/logout. Redis используется как TTL-кэш неизменяемых публичных профилей; сессии и ACL всегда проверяются в PostgreSQL. Отказ кэша допускает ограниченный fallback, отказ БД даёт 503. Compose запускает три сервиса. README задания, контракт и публичные тесты сохранены.
Собственная lab1 получена из lab1_karpova.zip и сопоставлена с текущим решением. Сохранены обязательные возможности, own_tests и concurrency адаптированы к password/Basic/Bearer. Подробно: LAB1_TRANSITION.md. Обработчики архитектурно переписаны при замене in-memory состояния на SQL; прежние исследовательские цифры не использованы для lab2.
Трек 2: 120000 синтетических сообщений с распределением 100000 + 19000 + 100×10, сравнение двух индексов в трёх раундах, реальные EXPLAIN (ANALYZE, BUFFERS), измерение стоимости записи. Настоящий pg_dump восстановлен в отдельный PostgreSQL-контейнер с новым volume; проверены количества строк, выбранные сообщения и SHA-256 всей истории. Методика, результаты и ограничения: RESEARCH.md; raw evidence: evidence/query-study.json.
Запуск: `python3 scripts/init-local.py`, затем `docker compose up -d --build --wait`.
Проверки последовательно: `python3 student-tests/run_all.py`, затем `python3 student-tests/research.py`.
Отчёт: REPORT.md. Пошаговая инструкция: HOW_TO_SUBMIT.md. Облачные результаты: evidence/grade5-functional.txt и evidence/grade5-study.txt. Перед сдачей повторить на собственном стенде и добавить реальные результаты/ссылку на PR.
Помощь: при подготовке кода, тестов, инфраструктуры, экспериментов и документации использован OpenAI Codex; использованы skeleton преподавателя и библиотеки из requirements.txt. Ограничения: один Docker-host, локальный HTTP, нет PITR/off-site backup/HA; сравнение индексов не является обещанием промышленной производительности.
Перед открытием PR автору проверить:
- [ ] Понимаю реализацию и могу объяснить измерения и ограничения.
- [ ] Повторила make check, make test, persistence и собственные проверки; приложен реальный вывод.
- [ ] Проверила соответствие своей lab1 и переходов COURSE.md.
- [ ] Нет секретов, .env, tokens, dumps и volumes в Git.
- [ ] REPORT.md соответствует сдаваемому commit; ссылка на PR будет добавлена после создания.
+118 -20
View File
@@ -1,37 +1,135 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: **Карпова Надежда Сергеевна, БВТ2302**.
- Целевая оценка: **5**, трек 2 «План запроса и восстановление» (уровни 3 и 4 включены).
- Commit/PR: **ВПИСАТЬ после публикации в собственный fork Gitea**. Текущая поставка — ZIP, без Git-истории.
- Источники: README.md, COURSE.md, contracts/openapi.json, contracts/README.md, tests/README.md и остальные Markdown skeleton преподавателя; документация PostgreSQL, Flask, psycopg, Argon2-cffi, Docker Compose. Использованы Python, Flask, Gunicorn, psycopg, argon2-cffi, jsonschema, redis-py.
- Помощь ИИ: реализация, инфраструктура, дополнительные тесты, выполнение облачных проверок и текст отчёта подготовлены с помощью OpenAI Codex. Студент должен самостоятельно проверить решение и понимать код перед защитой.
- Собственная lab1 получена в архиве lab1_karpova.zip. Проверены main.py, REPORT.md, собственные тесты и структура. Сохранены обязательные возможности: пользователи, чаты, участники, сообщения, ACL, Unicode, keyset pagination, общий формат ошибок, health, non-root. HTTP-обработчики переписаны с FastAPI на Flask при замене in-memory словарей на SQL; это архитектурная переработка собственной работы, а не заявление о прямом переносе неизменённого main.py. Собственные own_tests.py и concurrency.py адаптированы в student-tests/lab1_*.py: регистрация с password и Basic → Bearer. Публичные tests/ и contracts/ взяты только из skeleton lab2. Старое исследование lab1 и его цифры не выдаются за результаты lab2.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker Engine/Compose v2, Python 3.9+ и Git; для make-команд также GNU make. На Windows restart hook следует выполнять из WSL2. Полная пошаговая инструкция, включая установку инструментов, fork и PR: [HOW_TO_SUBMIT.md](HOW_TO_SUBMIT.md).
## Архитектура и решения
Все команды — из корня репозитория:
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```sh
python3 scripts/init-local.py
docker compose config --quiet
docker compose up -d --build --wait
make check
make test
chmod +x scripts/restart.sh
make test-persistence ACTION_SCRIPT=scripts/restart.sh
python3 student-tests/security.py
python3 student-tests/infrastructure.py
# Все функциональные проверки последовательно (включая перечисленные):
python3 student-tests/run_all.py
# Исследование 5, отдельные синтетические БД и новый volume:
python3 student-tests/research.py
```
`init-local.py` создаёт локальные случайные credentials в ignored secrets/; повтор не меняет их. `.env` не обязателен, SESSION_TTL_SECONDS по умолчанию 3600. Миграции автоматически выполняются перед стартом Gunicorn; повтор безопасен. Готовность — GET /health/ready, ответ 200 с status=ok. API доступен только на loopback:8080. Для локальной проверки — синтетические данные; удалённый HTTP с реальными паролями не предназначен для использования.
Пример отдельной проверки TTL: инфраструктурный тест поднимает второй API на 8081 с SESSION_TTL_SECONDS=2, проверяет 200 до и 401 после истечения и удаляет только свой временный контейнер lab2-expiry. Обычная сессия основного API сохраняет TTL=3600.
Остановка с сохранением данных: `docker compose down`. Повтор: `docker compose up -d --wait`. **Разрушительный сброс учебных данных**: `docker compose down -v`; применять только намеренно, никогда не в persistence-сценарии.
### Образы, сервисы и настройки
| Роль | Service / версия | Готовность | Постоянные данные | Доступ / credentials |
| --- | --- | --- | --- | --- |
| API | api; Python 3.12.12-slim-bookworm; Flask 3.1.2; Gunicorn 23.0.0 | /health/ready, запрос к PostgreSQL | собственных нет | 127.0.0.1:8080; DATABASE_URL_FILE — Compose secret |
| Redis | cache; redis:7.4.6-bookworm; redis-py 6.4.0 | redis-cli ping, необязателен для /ready | ephemeral cache; maxmemory 64mb, allkeys-lru, persistence выключен | только сеть Compose; нет внешнего опубликованного порта |
| PostgreSQL | db; postgres:17.6-bookworm | pg_isready; функциональные тесты API | postgres_data:/var/lib/postgresql/data | только сеть Compose; POSTGRES_PASSWORD_FILE — Compose secret |
Версии прямых Python-зависимостей закреплены в requirements.txt. Транзитивные зависимости не зафиксированы отдельным lockfile. Общая сеть — автоматически создаваемая Compose default bridge. Redis используется только для кэша неизменяемых публичных профилей; сессии и права доступа всегда проверяются в PostgreSQL.
Соответствие .env.example: SESSION_TTL_SECONDS и DATABASE_URL_FILE используются; фактические адрес и порт API заданы Gunicorn в Dockerfile (0.0.0.0:8080 внутри контейнера). APP_HOST/APP_PORT/APP_ENV не читаются; SESSION_STORE фактически всегда postgres; CACHE_URL_FILE поддерживается при явном задании, иначе используется CACHE_URL=redis://cache:6379/0 из Compose. Секретные значения в .env не требуются, используется secrets/. Исходный .env.example преподавателя сохранён без изменений.
В облачной среде сборка выполнялась с публичным CA bundle, переданным через BuildKit secret (в образ не копируется):
```sh
docker build --secret id=proxy_ca,src=/etc/ssl/certs/ca-certificates.crt -t mtusi2026lab2-api .
docker compose up -d --no-build --wait
```
Обычному компьютеру без учебного proxy достаточно стандартного `docker compose up -d --build --wait`.
## Архитектура, схема и транзакции
Клиент → Gunicorn/Flask → PostgreSQL. PostgreSQL — единственный источник истины для пользователей, чатов, членства, сообщений и сессий. Redis — восстанавливаемый cache-aside публичного профиля пользователя. Авторизация не зависит от содержимого кэша. Пул ограничен 8 соединениями, ожидание пула 3 с, connect_timeout 3 с, statement_timeout 3 с, lock_timeout 2 с. Один worker с четырьмя threads, без preload. Параметризованные SQL-запросы, пользовательские строки не интерполируются в SQL.
Схема и ограничения описаны в [migrations/001_initial.sql](migrations/001_initial.sql): PK UUID; UNIQUE username; FK членства к chats/users; составной FK сообщения к членству автора; CHECK длины и username. Индексы: members(user_id,chat_id), messages(chat_id,created_at,id), sessions(expires_at); PK/UNIQUE также создают индексы. Индекс истории соответствует фильтру chat_id, порядку и условию следующей страницы.
Создание чата и всех участников — одна транзакция в create_chat. Проверка известных пользователей выполняется до вставки; ошибка внутри блока приводит к ROLLBACK всей операции. Регистрация и отправка сообщения фиксируются до возврата 201. Login фиксирует сессию до выдачи токена, logout удаляет её транзакционно. Миграции версионируются в schema_migrations и сериализуются advisory transaction lock; одна версия применяется один раз.
Пароли: библиотечный Argon2id с солью, memory_cost=65536 KiB, time_cost=3, parallelism=2. Пароль и hash не входят в публичный User. Сессии: opaque token из 32 случайных байт, в PostgreSQL — SHA-256 токена и абсолютное expires_at. SHA-256 не используется для паролей. Logout удаляет запись. Истечение проверяется на каждом запросе по clock_timestamp PostgreSQL; рестарт срок не продлевает. Истёкшие строки пока не очищаются автоматически, но авторизовать пользователя не могут.
Basic принимается только при входе, Bearer — на защищённых endpoint. X-User-Id игнорируется. При чужом/несуществующем чате ответ одинаковый 404; отсутствие сессии — 401 с соответствующим WWW-Authenticate. Все ответы имеют X-Request-Id; ошибки — общий JSON без SQL/stack trace.
История и список чатов используют keyset по (created_at,id), limit+1 определяет наличие продолжения. Cursor содержит scope запроса и отклоняется для другого чата; доступ проверяется независимо от cursor. Cursor — base64 JSON, без шифрования и подписи, не является credential. Для неизменной истории нет повторов. Между страницами нет snapshot; конкурентная транзакция с более ранним created_at может стать видимой после уже прочитанной страницы. Read-after-write подтверждённой записи обеспечивается чтением PostgreSQL без кэша истории, однако гарантии не распространяются на обход всех конкурентных записей.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
Проверки выполнены 5 ноября 2026 по Москве (UTC-метки в приложенных файлах — 4 ноября). Исходная поставка — ZIP преподавателя, commit неизвестен; нельзя выдавать его за конкретный upstream commit. Контракт, README задания и публичные тесты сверены побайтово с загруженным ZIP. Реальный вывод с exit code сохранён, токены/пароли не печатались.
| Критерий | Команда / сценарий | Наблюдение | Доказательство |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Воспроизводимый Compose-запуск | docker compose up -d --build --wait | сборка и оба сервиса healthy; облачный прогон использовал валидный кэш зависимости после CA-сборки | [build.txt](evidence/build.txt) |
| Полная валидация контракта | make validate PYTHON=/tmp/lab2-validation/bin/python | PASS OpenAPI 3.1 и JSON Schema | [openapi.txt](evidence/openapi.txt) |
| Структура и Python-синтаксис | make check | PASS, отдельно от проверки API | [grade5-functional.txt](evidence/grade5-functional.txt) |
| Обязательный API, Unicode, доступ, история, logout | make test | PASS сквозного сценария lab2 | [grade5-functional.txt](evidence/grade5-functional.txt) |
| PostgreSQL вместо SQLite | compose.yaml; реальные контейнеры; pg_postmaster_start_time | PostgreSQL 17.6, API использует его | [grade5-functional.txt](evidence/grade5-functional.txt) |
| Данные и старая сессия после полного рестарта | make test-persistence ACTION_SCRIPT=scripts/restart.sh | PASS, токен сохранён только в памяти теста | [grade5-functional.txt](evidence/grade5-functional.txt) |
| Hook реально перезапускает API, PostgreSQL и Redis | docker inspect StartedAt и pg_postmaster_start_time до/после | метки запуска всех трёх контейнеров и postmaster изменились; volume не удалялся | [grade5-functional.txt](evidence/grade5-functional.txt) |
| Повторные миграции | два запуска src/migrate.py после рестарта | Already applied; количества users/chats/messages/sessions/migrations не изменились | [grade5-functional.txt](evidence/grade5-functional.txt) |
| PK/FK/UNIQUE и атомарное создание чата | миграция; несуществующий участник; сравнение списка до/после; гонка username | нет частичного чата; 1×201 и 3×409 при гонке | [grade5-functional.txt](evidence/grade5-functional.txt) |
| Password KDF и безопасные сессии | исходники register/login/authenticate; public smoke | Argon2id, случайный токен; неправильный пароль 401, Basic/X-User-Id не дают бизнес-доступ | [app.py](src/app.py), [grade5-functional.txt](evidence/grade5-functional.txt) |
| Абсолютный expiry и отзыв | student-tests/expiry.py при TTL=2; public logout | 200 до expiry, 401 через 3 с; 401 после logout | [grade5-functional.txt](evidence/grade5-functional.txt), [grade5-functional.txt](evidence/grade5-functional.txt) |
| Валидация и cursor | student-tests/security.py | PASS invalid JSON/fields/types/blank/limit; чужой cursor 400 | [grade5-functional.txt](evidence/grade5-functional.txt) |
| Поведение при отказе БД | stop db → запросы → start db | live 200; ready и защищённый запрос 503; после восстановления прежняя сессия работает | [grade5-functional.txt](evidence/grade5-functional.txt) |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
### Дополнительные критерии 4 и трек 5
## Эксперименты и отказы
| Критерий | Проверка | Доказательство |
| --- | --- | --- |
| Реальное использование Redis, TTL и восстановление | профиль в Redis, TTL, рост hits, stop/start cache | [grade5-functional.txt](evidence/grade5-functional.txt) |
| Параметризованные запросы, bounded pool и timeout | параметры execute, ConnectionPool, Redis budget/circuit breaker | [app.py](src/app.py), [grade5-functional.txt](evidence/grade5-functional.txt) |
| Гонка username и настоящий ROLLBACK | 4 регистрации; scoped trigger ломает INSERT участника после INSERT чата | [grade5-functional.txt](evidence/grade5-functional.txt) |
| Индекс/план на ≥10000 сообщений | EXPLAIN ANALYZE BUFFERS на 120000; keyset LIMIT 51 | [query-study.json](evidence/query-study.json) |
| Expiry, logout, wrong password, Redis/БД outage | полный функциональный прогон | [grade5-functional.txt](evidence/grade5-functional.txt) |
| Трек 2: ≥100000, skew, ≥2 индекса и цена записи | 120000, 102 чата, 3 раунда; 5000 INSERT/вариант | [RESEARCH.md](RESEARCH.md), [query-study.json](evidence/query-study.json) |
| Backup → новое хранилище → сверка | pg_dump/pg_restore, отдельный PostgreSQL+volume; counts, samples, full SHA256 | [grade5-study.txt](evidence/grade5-study.txt) |
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
## Уровень 4: Redis, ограничения и отказ
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
На каждом защищённом запросе SELECT sessions в PostgreSQL проверяет token_hash и абсолютный expires_at. Только затем по user_id читается ключ `profile:v1:<UUID>` в Redis. Значение — публичный User, без password_hash и сессии. На cache miss профиль читается из users и пишется SETEX на **60 секунд**. Это экономит чтение users и сериализацию стабильного профиля, но не SELECT сессии: кэш не является самостоятельным доказательством личности.
## Ограничения и следующие шаги
В обязательном API профили не редактируются и не удаляются, поэтому они неизменяемы; ручное изменение users вне API потребует DEL соответствующего profile key либо ожидания TTL ≤60 с. При появлении endpoint изменения профиля понадобится транзакционно согласованная инвалидация. История/списки чатов не кэшируются, подтверждённая запись сразу читается из PostgreSQL. Logout и expiry проверяются даже при cache hit. Redis persistence намеренно выключен: потеря кэша допустима, сессии находятся в PostgreSQL. После рестарта кэш заполняется заново.
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Redis: connect/read timeout 0,2 с, max_connections=8, автоматические повторы отключены (`Retry(NoBackoff(),0)`). Поскольку DNS может ждать дольше socket timeout, полный cache call ограничен ожиданием 0,25 с; фоновых операций не более двух, без очереди накопления; после ошибки circuit breaker пропускает кэш 2 с. Авторизация выполняется до этих операций в PostgreSQL. При RedisError API читает PostgreSQL; Redis не критичен для ready. При отказе PostgreSQL запрос не получает доверенную личность из кэша: возвращает 503. Пул PostgreSQL и SQL-параметризация описаны выше.
[grade5-functional.txt](evidence/grade5-functional.txt) содержит реальный последовательный прогон: public smoke; строгая валидация и гонка username (один 201, три 409); перенесённые проверки lab1; 100 записей от 10 клиентов; проверка содержимого профиля, TTL и Redis hits; остановка Redis с ограниченным fallback и проверкой 401 для отсутствующих/невалидных/отозванных токенов; восстановление кэша; искусственная ошибка INSERT участника после INSERT чата с доказанным ROLLBACK; полный рестарт API/БД/Redis с прежней сессией; повтор миграций; expiry=2; отказ/восстановление PostgreSQL. Тестовый trigger для ошибки создаётся только на уникальном синтетическом title и удаляется в finally. Код API не содержит тестового обхода авторизации или rollback.
## Уровень 5: трек 2 «План запроса и восстановление»
Полная методика, фактические таблицы измерений и выводы: [RESEARCH.md](RESEARCH.md). Машиночитаемые результаты, все отдельные замеры и EXPLAIN (ANALYZE, BUFFERS): [query-study.json](evidence/query-study.json). Вывод запуска и backup/restore: [grade5-study.txt](evidence/grade5-study.txt).
Гипотеза: для истории конкретного чата индекс `(chat_id,created_at,id)` снижает объём чтения по сравнению с `(created_at,id)` особенно для редких чатов в неравномерном наборе. Более широкий индекс требует больше места и может менять стоимость записи; измерение должно показать обе стороны.
Исследование использует отдельную БД `lab2_study_<случайный суффикс>`, созданную с нуля теми же миграциями; рабочая messenger не меняется. Всего **120 000 сообщений**, распределение **100 000 + 19 000 + 100×10** по 102 чатам, разный размер синтетического текста. Сравниваются два реальных B-tree индекса при одинаковом SQL и наборе данных. Три раунда с чередованием порядка вариантов, три запроса, 3 прогрева и 20 измеряемых чтений; реальные вставки 5000 сообщений с FK/индексами и последующим rollback для равного объёма всех вариантов. VACUUM ANALYZE между вариантами. Измеряется SQL roundtrip внутри Docker network, не HTTP RPS и не максимальная производительность. В планах производственного индекса проверяются фактические строки, buffers и отсутствие сканирования всей истории на страницу.
После исследования выбирается производственный индекс. Создаётся настоящий `pg_dump -Fc`. Восстановление выполняется **в отдельный PostgreSQL-контейнер с новым именованным volume**, а не поверх рабочей БД. Сравниваются количества строк всех таблиц, три выбранных сообщения и SHA-256 упорядоченного полного содержимого всех 120 000 сообщений. Backup удаляется после проверки и в Git не попадает. Исследовательская исходная БД и восстановленный volume оставлены для инспекции; временный recovery-контейнер остановлен и удалён. Повтор исследования создаёт новые уникальные объекты, старые не перезаписывает.
## Ограничения
Это учебный стенд, окончательную оценку выставляет преподаватель на проверке и защите. Один API, одна рабочая БД и Redis на одном Docker-host не защищают от потери host/диска. /live проверяет процесс, /ready — PostgreSQL; отказ кэша допускает работу, отказ БД ограничивает API до 503. HTTP — только локальные синтетические данные.
Backup — согласованный логический snapshot. Проверка проводилась без конкурентных записей в исследовательскую БД; это не PITR, не непрерывная репликация и не измерение production RTO. После snapshot новые COMMIT в dump не попадут: без WAL archiving потенциальная потеря ограничена временем от snapshot до аварии, то есть интервалом между backup. Новый volume расположен на том же физическом Docker-host и не является off-site копией. Время восстановления отдельно включает bootstrap нового контейнера, передача/pg_restore; сверка считается отдельно. Работающие токены в backup исследования не создавались: после полного рестарта сохранность настоящей сессии проверена отдельным persistence-тестом.
fsync=on и synchronous_commit=on проверены, гарантии зависят от реального хранилища. PostgreSQL-роль учебного стенда имеет права владельца/создания БД для эксперимента; минимальные production-привилегии не настроены. Нет rate limiting входа, HTTPS, автоматической уборки истёкших сессий и возможностей lab3–7. Кэш не защищён отдельной Redis ACL внутри приватной сети учебного стенда. Публичные и собственные тесты не являются доказательством отсутствия всех ошибок.
Нагрузочные RPS/percentiles приложения не заявлены. Измерения индексов ограничены этим распределением, warm-cache режимом, тремя раундами и ресурсами облачного хоста; цифры нельзя переносить на другой компьютер без повтора. Аппаратные сведения и версии: [environment.txt](evidence/environment.txt). Контейнерам не задавались отдельные CPU/RAM-лимиты; ресурсы разделяются с остальной задачей.
Перед сдачей повторить проверки на своём компьютере и добавить ссылку на PR. ФИО/группа внесены по сообщению автора: Карпова Надежда Сергеевна, **БВИ2302** (в старом отчёте lab1 была другая запись группы, она не копировалась).
+102
View File
@@ -0,0 +1,102 @@
# Исследование: план запроса и восстановление
**Карпова Надежда Сергеевна, БВИ2302. Лабораторная 2, цель — 5, трек 2.**
## Гипотеза и воспроизводимость
Для истории конкретного чата B-tree `(chat_id,created_at,id)` должен читать меньше чужих строк, чем `(created_at,id)`, особенно при сильно разных размерах чатов. Цена — более широкий индекс и обслуживание при записи. Гипотеза проверяет чтение, отдельно измеряется цена записи; улучшение любого возможного workload не обещается.
Команды из корня после `python3 scripts/init-local.py` и `docker compose up -d --build --wait`:
```sh
python3 scripts/capture.py evidence/grade5-functional-local.txt -- python3 student-tests/run_all.py
python3 scripts/capture.py evidence/grade5-study-local.txt -- python3 student-tests/research.py
```
Запускать последовательно. Исследование создаёт отдельные БД/volume со случайными именами; рабочие данные messenger не удаляет и индексы рабочей БД не меняет. Для нового опыта сохраняйте предыдущий query-study.json отдельно: скрипт пишет текущий результат в этот файл. Все данные синтетические; пароли/токены не печатаются.
Исходный код эксперимента: [research.py](student-tests/research.py), [research_worker.py](student-tests/research_worker.py). Фактический stdout: [grade5-study.txt](evidence/grade5-study.txt). Полный JSON с 360 отдельными измеряемыми чтениями, планами и backup fingerprints: [query-study.json](evidence/query-study.json). Ресурсы и версии: [environment.txt](evidence/environment.txt).
## Набор данных и методика
- PostgreSQL 17.6, схемы/PK/FK/CHECK из migrations/001_initial.sql; одна исследовательская учётная запись без рабочего password hash и сессий.
- 102 чата, **120000 сообщений**: один 100000, один 19000, остальные 100 чатов по 10. Длина текста меняется: синтетический префикс и 64..575 символов наполнения. Время детерминированно увеличивается на 1 мкс, UUID детерминированны из синтетических меток. Это не равномерный production traffic.
- Два варианта индекса: `messages_global(created_at,id)` и производственный `messages_history(chat_id,created_at,id)`. Остальные PK/FK-индексы одинаковы. Не применяются enable_seqscan=off и другие принуждения планировщика.
- Три раунда; порядок global→chat_first, chat_first→global, global→chat_first. Для каждого — пересоздание индекса и ANALYZE. Три профиля запросов, 3 прогрева и 20 измеряемых SELECT на профиль. Чтения последовательные, concurrency=1. В таблице ниже — медиана трёх медиан по 20 запросам. Raw_ms и p95 каждого раунда сохранены, p95 при таком числе запросов имеет низкую статистическую устойчивость.
- Измерение perf_counter вокруг execute+fetchall внутри API-контейнера по Docker network: включает SQL roundtrip и получение результата, не включает HTTP, authentication и Argon2id. EXPLAIN ANALYZE выполняется отдельно после измеряемых чтений, его Execution Time может отличаться от roundtrip.
- Стоимость записи: настоящий INSERT 5000 строк с FK/PK и текущим вторичным индексом, затем ROLLBACK, чтобы не менять базовые 120000 сообщений. Время включает SQL/FK/индексную работу, **не включает COMMIT/fsync подтверждения клиенту**. Между вариантами VACUUM ANALYZE удаляет dead tuples. Это сравнение стоимости statement, не полного end-to-end write latency.
- Замеры warm-cache: Shared Read Blocks в показанных планах равны 0. Планировщик может использовать parallel scan; доступные CPU/RAM разделяются с облачной задачей. Отдельных лимитов на контейнеры не задавали.
Измеряемый SQL совпадает с ключевой частью GET истории API:
```sql
SELECT * FROM messages
WHERE chat_id = $1
AND (created_at,id) > ($2,$3)
ORDER BY created_at,id
LIMIT 51;
```
API получает limit+1, чтобы определить next_cursor. Индекс сначала ограничивает конкретный chat_id, затем диапазон keyset, OFFSET не применяется. В API до SQL истории отдельно проверяются сессия и членство.
## Фактические результаты чтения
Дата: 5 ноября 2026 по Москве; UTC-метка полного исследования: `2026-11-04T22:04:18.889913+00:00`.
| Профиль | (created_at,id), мс | (chat_id,created_at,id), мс | Отношение времени global/chat_first |
| --- | ---: | ---: | ---: |
| Большой чат, продолжение после 50000 | 0.322 | 0.335 | 0.96× |
| Чат 19000, первая страница | 22.437 | 0.276 | 81.28× |
| Чат 10, первая страница | 27.168 | 0.142 | 191.74× |
Для большого чата продолжение и так попадает в плотный диапазон глобального индекса: преимущества выбранного индекса в этих измерениях нет, небольшая разница сопоставима с разбросом. Для среднего и редкого чата гипотеза подтверждена в данном warm-cache наборе: значительно меньше прочитанных/отфильтрованных чужих строк. Полученные отношения нельзя называть ускорением всего API или переносить на другие распределения.
### Почему изменился план
В первом раунде global для среднего чата выполняет Index Scan messages_global с фильтром chat_id, отбрасывает **100000** чужих строк и использует **8359 shared hit blocks**, чтобы вернуть 51 строку. Производственный messages_history возвращает 51 строку при **6 shared hit blocks**, chat_id входит в Index Cond.
Для редкого чата global выбирает Gather Merge → Sort → parallel Seq Scan: фактически просматривает всю таблицу, Shared Hit Blocks верхнего узла **6360**. Внутри parallel plan Actual Rows/Rows Removed by Filter приведены в среднем за loop и округлены — их нельзя бездумно складывать как точный общий счётчик. messages_history выбирает Index Scan, возвращает все 10 строк при **13 shared hit blocks**. Полного scan истории в выбранном варианте на этих страницах нет.
Большой чат: оба варианта читают только 51 строку по индексу, соответственно 7 и 8 shared hit blocks первого раунда. Это объясняет отсутствие выигрыша для этого профиля. Shared hits — логические обращения к буферам PostgreSQL, а не количество физических дисковых операций. Полные деревья всех раундов доступны в JSON.
## Цена записи и размер индекса
| Вариант | INSERT 5000, мс по трём раундам | Медиана, мс | Размер индекса первого раунда, байт |
| --- | --- | ---: | ---: |
| global | 68.552, 62.403, 91.077 | 68.552 | 5087232 |
| chat_first | 70.005, 65.643, 78.178 | 70.005 | 7618560 |
Производственный индекс шире примерно на 50% в этом прогоне. Медианная стоимость INSERT немного выше, но диапазоны трёх наблюдений перекрываются: **доказать статистически устойчивое замедление записи по этим трём точкам нельзя**. Утверждение «чтение улучшилось бесплатно» также неверно: ширина и место индекса реально увеличились. Index build_ms каждого раунда сохранён в JSON, но сборка индекса не является обычной ценой одного сообщения.
## Настоящий backup и восстановление в новое хранилище
1. После сравнения восстановлен production index messages_history в исследовательской БД. Создан `pg_dump -Fc` этой БД.
2. Создан **новый именованный volume**, запущен отдельный `postgres:17.6-bookworm` с отдельной БД; доступ только через внутреннюю Docker network. Исходная рабочая БД не заменялась.
3. Сохранённый dump передан pg_restore через pipe. Проверены exit status и pg_dump/pg_restore; бинарные bytes не выводились в логи.
4. После восстановления проверены количества всех таблиц, три выбранных сообщения (начало, граница большого чата, последнее) и SHA-256 сериализованного полного содержимого **всех 120000 сообщений**, отсортированных по UUID. Это проверяет реальные данные, а не только число строк или открытый порт.
5. Dump удалён после проверки, recovery-контейнер остановлен/удалён. Новый volume сохранён для осмотра, имя зафиксировано в JSON. Ни dump, ни credential-файлы в архив решения не включены.
| Показатель | Фактическое значение |
| --- | --- |
| pg_dump | 0.679 с |
| Bootstrap нового PostgreSQL + передача + pg_restore | 6.288 с |
| Полная сверка после восстановления | 2.288 с |
| Размер backup | 4100912 байт |
| Counts source = restored | users=1, chats=102, members=102, messages=120000, sessions=0, schema_migrations=1 |
| Сверка трёх выбранных сообщений | полное совпадение всех полей |
| SHA-256 всех сообщений (одинаковый source/restored) | `fcc7a69c6f3fe35cabe5eab0645a7ace6774fca5a120541a4ccb92edbb58d9b8` |
| Новый volume | `lab2-recovery-d495852d11-data` |
## Границы результата и потери данных
Backup — согласованный логический snapshot pg_dump; в эксперименте после заполнения не было конкурентных писателей. Данные на момент snapshot восстановлены без обнаруженной потери и без повторного seed. После snapshot новые COMMIT автоматически в dump не добавляются. Без WAL archiving/PITR потенциальный RPO — интервал от последнего backup до аварии; для нового backup нужен новый запуск, а не обещание «потери всегда нулевые».
Время около шести секунд — bootstrap и restore маленького сжатого синтетического набора на этом же Docker-host. Сверка заняла дополнительное время. Это не SLA и не production RTO: не учитываются обнаружение аварии, сеть удалённого backup, оператор, существенно больший объём или восстановление всего host. Новый volume логически отдельный, но физический host тот же: off-site защиту такое размещение не даёт.
Три раунда не дают строгого доверительного интервала. Очередность вариантов частично чередуется, кэш не сбрасывается и распределение времени намеренно кластеризует большие чаты. Это усиливает эффект глобального индекса для поздних/малых чатов; при равномерно перемешанных данных цифры изменятся. Исследование подтверждает выбор индекса для выбранной модели, а не универсальный рекорд.
Отдельно от backup-исследования сохранность действующих сессий и подтверждённых сообщений после рестарта API, PostgreSQL и Redis проверена публичным persistence-сценарием в [grade5-functional.txt](evidence/grade5-functional.txt). В самом исследовательском dump сессий нет.
## Вывод
Для истории конкретного чата выбран `(chat_id,created_at,id)`: он убирает чтение чужой истории в исследованных страницах и резко сокращает работу для маленьких/средних чатов. Для плотного большого чата преимущества не обнаружено; индекс занимает больше места, цена записи требует дальнейших повторов. Восстановление в новый PostgreSQL и новый volume подтверждено сверкой всех 120000 сообщений, но границы backup snapshot и общий физический host остаются ограничениями.
+49
View File
@@ -0,0 +1,49 @@
services:
db:
image: postgres:17.6-bookworm
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/db_password
secrets:
- db_password
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: [CMD-SHELL, 'pg_isready -U messenger -d messenger']
interval: 2s
timeout: 3s
retries: 30
cache:
image: redis:7.4.6-bookworm
command: [redis-server, --save, "", --appendonly, "no", --maxmemory, 64mb, --maxmemory-policy, allkeys-lru]
healthcheck:
test: [CMD, redis-cli, ping]
interval: 2s
timeout: 3s
retries: 30
api:
build: .
environment:
CACHE_URL: redis://cache:6379/0
DATABASE_URL_FILE: /run/secrets/database_url
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
secrets:
- database_url
ports:
- '127.0.0.1:8080:8080'
depends_on:
db:
condition: service_healthy
healthcheck:
test: [CMD, python, -c, 'import urllib.request; urllib.request.urlopen("http://127.0.0.1:8080/health/ready", timeout=3)']
interval: 2s
timeout: 4s
retries: 30
secrets:
db_password:
file: ./secrets/db_password
database_url:
file: ./secrets/database_url
volumes:
postgres_data:
+15
View File
@@ -3,3 +3,18 @@
Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки.
Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно.
## Результаты решения Карповой Н. С., БВИ2302 — на 5
Это реальные обезличенные результаты облачного стенда, дата по Москве — 5 ноября 2026. UTC-метки в файлах — 4 ноября. Поставка из ZIP, upstream commit неизвестен; точные исходники фиксирует source-sha256.txt.
- [grade5-functional.txt](grade5-functional.txt): проверки уровней 3–4, перенесённые own/concurrency lab1, cache TTL/hits/outage, rollback, restart всех трёх сервисов, expiry и отказ/восстановление БД.
- [grade5-study.txt](grade5-study.txt): исследование 120000 сообщений, два индекса и реальный backup/restore в новый PostgreSQL с новым volume.
- [query-study.json](query-study.json): все замеры, EXPLAIN (ANALYZE, BUFFERS), стоимость записи, fingerprints и времена восстановления.
- [environment.txt](environment.txt): ресурсы, версии, fsync/synchronous_commit и контейнеры.
- [build.txt](build.txt): финальная Compose-сборка и готовность сервисов.
- [openapi.txt](openapi.txt): полная валидация OpenAPI/JSON Schema.
- [skeleton-integrity.txt](skeleton-integrity.txt): сверка с ZIP преподавателя.
- [source-sha256.txt](source-sha256.txt): контрольные суммы поставляемого кода.
Методика, агрегаты, ограничения и объяснение результатов: [RESEARCH.md](../RESEARCH.md); соответствие критериям: [REPORT.md](../REPORT.md). Скриншоты не подделывались: по заданию допускаются текстовые доказательства команд и наблюдений.
+76
View File
@@ -0,0 +1,76 @@
UTC: 2026-11-04T22:04:55.006926+00:00
Command: docker compose up -d --build --wait
#1 [internal] load local bake definitions
#1 reading from stdin 699B done
#1 DONE 0.0s
#2 [internal] load build definition from Dockerfile
#2 transferring dockerfile: 626B done
#2 DONE 0.0s
#3 resolve image config for docker-image://docker.io/docker/dockerfile:1
#3 DONE 0.2s
#4 docker-image://docker.io/docker/dockerfile:1@sha256:4edf897a3ffa55b89f906fc8cc78afdb3f1834cc9c7083565e611a8a7d5fe99e
#4 CACHED
#5 [internal] load metadata for docker.io/library/python:3.12.12-slim-bookworm
#5 DONE 0.2s
#6 [internal] load .dockerignore
#6 transferring context: 196B done
#6 DONE 0.0s
#7 [stage-0 1/8] FROM docker.io/library/python:3.12.12-slim-bookworm@sha256:593bd06efe90efa80dc4eee3948be7c0fde4134606dd40d8dd8dbcade98e669c
#7 DONE 0.0s
#8 [internal] load build context
#8 transferring context: 404B done
#8 DONE 0.0s
#9 [stage-0 4/8] RUN --mount=type=secret,id=proxy_ca if [ -f /run/secrets/proxy_ca ]; then export PIP_CERT=/run/secrets/proxy_ca; fi; pip install --no-cache-dir -r requirements.txt
#9 CACHED
#10 [stage-0 5/8] COPY src ./src
#10 CACHED
#11 [stage-0 6/8] COPY migrations ./migrations
#11 CACHED
#12 [stage-0 2/8] WORKDIR /app
#12 CACHED
#13 [stage-0 3/8] COPY requirements.txt .
#13 CACHED
#14 [stage-0 7/8] COPY contracts ./contracts
#14 CACHED
#15 [stage-0 8/8] RUN chmod -R a+rX /app && useradd --uid 10001 --create-home app
#15 CACHED
#16 exporting to image
#16 exporting layers done
#16 writing image sha256:30613bcdeff20685a51df3a0bdd45e560991ac73bbb33e933e434489b482f6c0 done
#16 naming to docker.io/library/mtusi2026lab2-api done
#16 DONE 0.0s
#17 resolving provenance for metadata file
#17 DONE 0.0s
mtusi2026lab2-api Built
Container mtusi2026lab2-db-1 Running
Container mtusi2026lab2-api-1 Recreate
Container mtusi2026lab2-cache-1 Running
Container mtusi2026lab2-api-1 Recreated
Container mtusi2026lab2-db-1 Waiting
Container mtusi2026lab2-db-1 Healthy
Container mtusi2026lab2-api-1 Starting
Container mtusi2026lab2-api-1 Started
Container mtusi2026lab2-db-1 Waiting
Container mtusi2026lab2-cache-1 Waiting
Container mtusi2026lab2-api-1 Waiting
Container mtusi2026lab2-cache-1 Healthy
Container mtusi2026lab2-db-1 Healthy
Container mtusi2026lab2-api-1 Healthy
Exit code: 0
+5
View File
@@ -0,0 +1,5 @@
UTC: 2026-11-04T22:38:59.847637+00:00
Command: python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
Exit code: 0
+25
View File
@@ -0,0 +1,25 @@
UTC: 2026-11-04T22:06:31.893524+00:00
Client date: 2026-11-05 Europe/Moscow
Kernel: Linux-6.18.57-x86_64-with-glibc2.41
CPU logical cores visible: 5
/sys/fs/cgroup/memory.max: 34359738368
/sys/fs/cgroup/cpu.max: 400000 100000
Command: docker version --format client={{.Client.Version}} server={{.Server.Version}}
client=29.9.2 server=29.9.2
Command: docker compose version
Docker Compose version v2.40.3
Command: docker compose exec -T db psql -U messenger -d messenger -Atc select version(); show fsync; show synchronous_commit;
PostgreSQL 17.6 (Debian 17.6-2.pgdg12+1) on x86_64-pc-linux-gnu, compiled by gcc (Debian 12.2.0-14+deb12u1) 12.2.0, 64-bit
on
on
Command: docker compose exec -T cache redis-cli INFO server
redis_version:7.4.6
redis_mode:standalone
arch_bits:64
Command: docker compose exec -T api id
uid=10001(app) gid=10001(app) groups=10001(app)
Command: docker compose ps
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab2-api-1 mtusi2026lab2-api "sh -c 'python src/m…" api About a minute ago Up About a minute (healthy) 127.0.0.1:8080->8080/tcp
mtusi2026lab2-cache-1 redis:7.4.6-bookworm "docker-entrypoint.s…" cache 9 minutes ago Up 2 minutes (healthy) 6379/tcp
mtusi2026lab2-db-1 postgres:17.6-bookworm "docker-entrypoint.s…" db 20 minutes ago Up 2 minutes (healthy) 5432/tcp
+54
View File
@@ -0,0 +1,54 @@
UTC: 2026-11-04T22:39:51.907732+00:00
Command: python3 student-tests/run_all.py
RUN: make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
RUN: make test
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
RUN: /Library/Developer/CommandLineTools/usr/bin/python3 student-tests/security.py
PASS: malformed JSON, strict fields/types, whitespace, limits, cursor resource binding, invalid chat atomicity, concurrent username uniqueness
RUN: /Library/Developer/CommandLineTools/usr/bin/python3 student-tests/lab1_own_tests.py
PASS: own negative, access-control and multi-page tests
RUN: /Library/Developer/CommandLineTools/usr/bin/python3 student-tests/lab1_concurrency.py
PASS: 10 concurrent clients -> 100 successful messages -> 100 unique messages
RUN: /Library/Developer/CommandLineTools/usr/bin/python3 student-tests/level4.py
PASS: actual cached public profile, TTL <=60 seconds, at least 3 Redis cache hits
Container mtusi2026lab2-cache-1 Stopping
Container mtusi2026lab2-cache-1 Stopped
Cache outage diagnostic: profile_matches=True elapsed_seconds=0.204
PASS: Redis down: PostgreSQL fallback 0.204s, ready=200, invalid/absent/revoked sessions=401
Container mtusi2026lab2-cache-1 Starting
Container mtusi2026lab2-cache-1 Started
PASS: ephemeral Redis restart: cache is rebuilt; no session source of truth lost
PASS: injected failure AFTER chat INSERT: HTTP 503, transaction rolled back chat and members
PASS: same API remains usable after rollback
RUN: /Library/Developer/CommandLineTools/usr/bin/python3 student-tests/infrastructure.py
Before full restart:
api 28fbeae97d23eca5e256d399d79848f1d981bc78294f72a7539a3958c38b420a 2026-11-04T22:39:09.243190426Z 0
db dbee5490f591813b35c71f4b10be9450f26196ffaa97272b9d51c9e54cbba55c 2026-11-04T22:39:08.499371509Z 0
cache 7f2b559ca9eb198a44bbdd00a2e91c1d6f0b2e41a861c47570606082fa0e68d2 2026-11-04T22:39:37.450518717Z 0
DB postmaster: 2026-11-04 22:39:08.553299+00
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
After full restart:
api 28fbeae97d23eca5e256d399d79848f1d981bc78294f72a7539a3958c38b420a 2026-11-04T22:39:42.159768302Z 0
db dbee5490f591813b35c71f4b10be9450f26196ffaa97272b9d51c9e54cbba55c 2026-11-04T22:39:41.091549593Z 0
cache 7f2b559ca9eb198a44bbdd00a2e91c1d6f0b2e41a861c47570606082fa0e68d2 2026-11-04T22:39:41.155934302Z 0
DB postmaster: 2026-11-04 22:39:41.187536+00
Already applied 001_initial.sql
Already applied 001_initial.sql
PASS: two migration reruns; users/chats/messages/sessions/migrations counts unchanged: 36|13|113|31|1
Container lab2-expiry Creating
Container lab2-expiry Created
PASS: a real short-lived session authenticates before expiry and returns 401 after expiry
Container mtusi2026lab2-db-1 Stopping
Container mtusi2026lab2-db-1 Stopped
PASS: DB down: live=200, ready=503, authenticated request=503; no anonymous fallback
Container mtusi2026lab2-db-1 Starting
Container mtusi2026lab2-db-1 Started
PASS: DB recovered; same session works
PASS: all required functional checks completed
Exit code: 0
+52
View File
@@ -0,0 +1,52 @@
UTC: 2026-11-04T22:03:47.272430+00:00
Command: python3 student-tests/run_all.py
RUN: make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
RUN: make test
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
RUN: /opt/codex/runtimes/codex-primary-runtime/dependencies/python/bin/python3 student-tests/security.py
PASS: malformed JSON, strict fields/types, whitespace, limits, cursor resource binding, invalid chat atomicity, concurrent username uniqueness
RUN: /opt/codex/runtimes/codex-primary-runtime/dependencies/python/bin/python3 student-tests/lab1_own_tests.py
PASS: own negative, access-control and multi-page tests
RUN: /opt/codex/runtimes/codex-primary-runtime/dependencies/python/bin/python3 student-tests/lab1_concurrency.py
PASS: 10 concurrent clients -> 100 successful messages -> 100 unique messages
RUN: /opt/codex/runtimes/codex-primary-runtime/dependencies/python/bin/python3 student-tests/level4.py
PASS: actual cached public profile, TTL <=60 seconds, at least 3 Redis cache hits
Container mtusi2026lab2-cache-1 Stopping
Container mtusi2026lab2-cache-1 Stopped
Cache outage diagnostic: profile_matches=True elapsed_seconds=0.007
PASS: Redis down: PostgreSQL fallback 0.007s, ready=200, invalid/absent/revoked sessions=401
Container mtusi2026lab2-cache-1 Starting
Container mtusi2026lab2-cache-1 Started
PASS: ephemeral Redis restart: cache is rebuilt; no session source of truth lost
PASS: injected failure AFTER chat INSERT: HTTP 503, transaction rolled back chat and members
PASS: same API remains usable after rollback
RUN: /opt/codex/runtimes/codex-primary-runtime/dependencies/python/bin/python3 student-tests/infrastructure.py
Before full restart:
api 9ae2e8de18d5a000eb0bef30af317c67e92bc0ee1db5455e646a29262aec9e1a 2026-11-04T22:01:53.486440398Z 0
db 9714c57601ade4f1458923203e668eee6ae1f45cf97382a1fc669f564da39317 2026-11-04T21:48:09.56075614Z 0
cache 438fe5a917be32774249ad31467c43ec1309c28a6fd7e9c50955384fcee3838b 2026-11-04T22:03:30.50288512Z 0
DB postmaster: 2026-11-04 21:48:09.71223+00
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
After full restart:
api 9ae2e8de18d5a000eb0bef30af317c67e92bc0ee1db5455e646a29262aec9e1a 2026-11-04T22:03:37.04495913Z 0
db 9714c57601ade4f1458923203e668eee6ae1f45cf97382a1fc669f564da39317 2026-11-04T22:03:36.308873498Z 0
cache 438fe5a917be32774249ad31467c43ec1309c28a6fd7e9c50955384fcee3838b 2026-11-04T22:03:36.096145205Z 0
DB postmaster: 2026-11-04 22:03:36.469068+00
Already applied 001_initial.sql
Already applied 001_initial.sql
PASS: two migration reruns; users/chats/messages/sessions/migrations counts unchanged: 83|27|327|74|1
PASS: a real short-lived session authenticates before expiry and returns 401 after expiry
Container mtusi2026lab2-db-1 Stopping
Container mtusi2026lab2-db-1 Stopped
PASS: DB down: live=200, ready=503, authenticated request=503; no anonymous fallback
Container mtusi2026lab2-db-1 Starting
Container mtusi2026lab2-db-1 Started
PASS: DB recovered; same session works
PASS: all required functional checks completed
Exit code: 0
+18
View File
@@ -0,0 +1,18 @@
UTC: 2026-11-04T22:40:12.450298+00:00
Command: python3 student-tests/research.py
Fresh isolated databases: lab2_study_73b956d721 lab2_study_73b956d721_restored
Seeded 120000 synthetic messages: 100000 + 19000 + 100*10
PASS: 2 indexes, 3 rounds, 3 query profiles, 20 measured reads/profile, real 5000-row writes with rollback
PASS: pg_dump -> NEW PostgreSQL container + NEW volume -> table counts + ALL 120000 messages SHA256 + selected messages match
Backup 0.319s; restore 1.750s; verification 0.930s; dump 4100901 bytes
global 5000-row insert ms: [24.202, 23.839, 23.957]
global hot-middle median ms per round: [0.116, 0.111, 0.112]
global medium-first median ms per round: [5.131, 4.756, 4.722]
global tiny-first median ms per round: [5.662, 5.719, 5.748]
chat_first 5000-row insert ms: [24.617, 24.58, 24.879]
chat_first hot-middle median ms per round: [0.111, 0.115, 0.117]
chat_first medium-first median ms per round: [0.111, 0.111, 0.117]
chat_first tiny-first median ms per round: [0.063, 0.062, 0.06]
Research source database and recovered volume retained for inspection; recovery process stopped; no dump/credentials included in evidence.
Exit code: 0
+18
View File
@@ -0,0 +1,18 @@
UTC: 2026-11-04T22:04:19.320899+00:00
Command: python3 student-tests/research.py
Fresh isolated databases: lab2_study_d495852d11 lab2_study_d495852d11_restored
Seeded 120000 synthetic messages: 100000 + 19000 + 100*10
PASS: 2 indexes, 3 rounds, 3 query profiles, 20 measured reads/profile, real 5000-row writes with rollback
PASS: pg_dump -> NEW PostgreSQL container + NEW volume -> table counts + ALL 120000 messages SHA256 + selected messages match
Backup 0.679s; restore 6.288s; verification 2.288s; dump 4100912 bytes
global 5000-row insert ms: [68.552, 62.403, 91.077]
global hot-middle median ms per round: [0.322, 0.292, 0.504]
global medium-first median ms per round: [22.437, 22.073, 23.842]
global tiny-first median ms per round: [26.97, 27.168, 27.924]
chat_first 5000-row insert ms: [70.005, 65.643, 78.178]
chat_first hot-middle median ms per round: [0.445, 0.335, 0.303]
chat_first medium-first median ms per round: [0.249, 0.276, 0.282]
chat_first tiny-first median ms per round: [0.123, 0.147, 0.142]
Research source database and recovered volume retained for inspection; recovery process stopped; no dump/credentials included in evidence.
Exit code: 0
+13
View File
@@ -0,0 +1,13 @@
User-provided lab1 archive SHA256: 956c17391860b6b432173ba2763ff7204d4b03c7a44e0422919b70b994377c1f
Source identity supplied by user: Карпова Надежда Сергеевна, БВИ2302
Original source files (not copied over lab2 contracts/public tests):
eb41f004c3bbd1e4ae33f97b66369c280957648f8d7aa5d63557f6ec0d522deb lab1/main.py
10e085dbfb4e67b58418a5cb2a12ed6ad06c7c76c99543b63028711ffa6eb8fa lab1/REPORT.md
213debb6d7bd76a5ed7043e6ab8e29af4415a7db3ef3dd39b47917736ce8551b lab1/tests/own_tests.py
0fd715e787877d20ceb4119424d123855076be12d199b2163050f05cba600101 lab1/tests/concurrency.py
d2c40189937c3a965593b95a38e98037122c1a3b9213a41eb07fd5f6efafac4a lab1/tests/benchmark_track1.py
Adapted test files:
2503ff8f91d802dd29a83f94ff247cf0978b8b7fa9ea1dd7a6885771404b5ca4 student-tests/lab1_own_tests.py
10e46adcffd8b97aa80aa41670d8e78f016735fb5ad59f9c5346ffa9fc57d792 student-tests/lab1_concurrency.py
Changes to tests: add password to synthetic registrations, Basic login, Bearer headers; original assertions retained.
Application handlers rewritten for PostgreSQL/Redis/Flask; do not claim original main.py was copied unchanged.
+6
View File
@@ -0,0 +1,6 @@
UTC: 2026-11-04T21:50:01.263099+00:00
Command: make validate PYTHON=/tmp/lab2-validation/bin/python
/tmp/lab2-validation/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
Exit code: 0
+6
View File
@@ -0,0 +1,6 @@
UTC: 2026-11-04T22:39:09.887252+00:00
Command: python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
Exit code: 0
File diff suppressed because it is too large Load Diff
+5
View File
@@ -0,0 +1,5 @@
UTC: 2026-11-04T22:39:00.863381+00:00
Command: python3 student-tests/security.py
PASS: malformed JSON, strict fields/types, whitespace, limits, cursor resource binding, invalid chat atomicity, concurrent username uniqueness
Exit code: 0
+31
View File
@@ -0,0 +1,31 @@
Original teacher ZIP SHA256: 8a5f58dfc8b2a176e84aa13e2a54d0d27e3d6f8f8d78bd3bd83755912e1b492d
Changed original files: REPORT.md (filled report), evidence/README.md (appended evidence index).
All other original files are byte-for-byte unchanged:
.dockerignore
.env.example
.github/pull_request_template.md
.github/workflows/contracts.yml
.gitignore
CONTRIBUTING.md
COURSE.md
Dockerfile.example
MAINTAINERS.md
Makefile
README.md
compose.example.yaml
contracts/README.md
contracts/examples.json
contracts/infrastructure.json
contracts/openapi.json
examples/requests.http
infra/README.md
lab.json
requirements-dev.txt
scripts/check_contract.py
scripts/restart.example.sh
scripts/validate_openapi.py
tests/README.md
tests/client.py
tests/load.py
tests/resilience.py
tests/smoke.py
+5
View File
@@ -0,0 +1,5 @@
UTC: 2026-11-04T22:39:00.388888+00:00
Command: python3 tests/smoke.py
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
Exit code: 0
+21
View File
@@ -0,0 +1,21 @@
961a72eea39d30fde2f04441337703cdbfb7f0c2011b1d7e6cc4c7f687ca6891 Dockerfile
0d7e46e04e877cbac7d19e25de18d7e1f1f03584a821b30e9e8fa070f90fc0e3 compose.yaml
67bbcdf029a6b100b6385e2f35a31b4ee7db42d763a1c0dc71d4da58bdbe250a migrations/001_initial.sql
fc8f9d5866863123e6ab7aa42b92d59752b23b995c1157bf67d67d4597f7715f requirements.txt
fc0d9a9330b62d6182c302a16c07e9ea26dee1c3cbbaab8be09ce0943fe3e040 scripts/capture.py
7c4402c2a6ab80d3b4676e1866d6ecc87b6daea14c080bcb9be9a7e8b959d671 scripts/check_contract.py
3a812bcb0e481c83fb059844556968ad1af5d45c67d43c2cbae51f9ba421b1e7 scripts/init-local.py
0328246ba75defbced992104e986fde973f63e3830d83251eced5953263e944b scripts/restart.example.sh
4f5f7aafbdef689a1b804dfb21f072e40010b126dc7dfe6dce8b8d99642e2c88 scripts/restart.sh
4e981acbfc10dac58817bf922d5896e996798551fedc1b2385130e1cddb13d54 scripts/validate_openapi.py
36636d23ef3167a8e73b455f6127c89e87ae846031b380c3f8ab8a957f3f1468 src/app.py
62b0cf236fd5633b640c92d5f587bf5621990ea3d3b55a9c8cacc13a353f1f88 src/migrate.py
a4e10d1ea8d7c9ccdf9483d89ac7be7f4822530bf5569227821ff88099efc973 student-tests/expiry.py
127fe75d0d835c37a1adb55eaccfd455e831fefd09e70f78072fc7f7c7e30ec1 student-tests/infrastructure.py
10e46adcffd8b97aa80aa41670d8e78f016735fb5ad59f9c5346ffa9fc57d792 student-tests/lab1_concurrency.py
2503ff8f91d802dd29a83f94ff247cf0978b8b7fa9ea1dd7a6885771404b5ca4 student-tests/lab1_own_tests.py
ff018b991dfb699575faccafcf26ca1c79279dbb721bdb1cbf5c6238c446e674 student-tests/level4.py
7632d25b51ad2be9f7d05f59b8479f1e44c75c2952b5cee2be66ca322ffc4c68 student-tests/research.py
a535c111539b8edde88345622067e316fdf26f282a8b5cbf87e7005d127e4a09 student-tests/research_worker.py
2d3123ed5b459deaa888ad86bf0acbaa4df53307d29585340ee4572fb085ca4e student-tests/run_all.py
c358a5e3c8fbf74e2485ce22f4e17564c84eb7402a5204c4d9029b3c88bf173d student-tests/security.py
+26
View File
@@ -0,0 +1,26 @@
CREATE TABLE users (
id uuid PRIMARY KEY, username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100),
password_hash text NOT NULL, created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE chats (
id uuid PRIMARY KEY, title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE members (
chat_id uuid NOT NULL REFERENCES chats(id), user_id uuid NOT NULL REFERENCES users(id),
PRIMARY KEY(chat_id,user_id)
);
CREATE INDEX members_user_chat ON members(user_id,chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY, chat_id uuid NOT NULL REFERENCES chats(id),
sender_id uuid NOT NULL, text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
FOREIGN KEY(chat_id,sender_id) REFERENCES members(chat_id,user_id)
);
CREATE INDEX messages_history ON messages(chat_id,created_at,id);
CREATE TABLE sessions (
token_hash text PRIMARY KEY, user_id uuid NOT NULL REFERENCES users(id),
expires_at timestamptz NOT NULL
);
CREATE INDEX sessions_expiry ON sessions(expires_at);
+6
View File
@@ -0,0 +1,6 @@
Flask==3.1.2
gunicorn==23.0.0
psycopg[binary,pool]==3.2.10
argon2-cffi==25.1.0
jsonschema==4.25.1
redis==6.4.0
+11
View File
@@ -0,0 +1,11 @@
"""Save real command output, preserving the exit code. Do not use with secret-printing commands."""
import datetime,subprocess,sys
from pathlib import Path
if len(sys.argv)<4 or sys.argv[2]!='--':
raise SystemExit('Usage: python3 scripts/capture.py evidence/name.txt -- command args...')
command=sys.argv[3:]
p=subprocess.run(command,stdout=subprocess.PIPE,stderr=subprocess.STDOUT,text=True)
text='UTC: '+datetime.datetime.now(datetime.timezone.utc).isoformat()+'\nCommand: '+' '.join(command)+'\n'+p.stdout+'\nExit code: '+str(p.returncode)+'\n'
Path(sys.argv[1]).write_text(text)
print(text,end='')
raise SystemExit(p.returncode)
+16
View File
@@ -0,0 +1,16 @@
"""Create local synthetic credentials without printing or replacing existing ones."""
import secrets
from pathlib import Path
root=Path(__file__).resolve().parents[1]
folder=root/'secrets'
folder.mkdir(mode=0o700,exist_ok=True)
p=folder/'db_password'; d=folder/'database_url'
if p.exists()!=d.exists():
raise SystemExit('Incomplete secrets: restore the missing file; existing credentials were not changed')
if not p.exists():
password=secrets.token_hex(32)
# Docker secret source directory is private; files must be readable by container UIDs.
p.write_text(password+'\n')
d.write_text('postgresql://messenger:'+password+'@db:5432/messenger\n')
p.chmod(0o644); d.chmod(0o644)
print('Local secret files ready (values hidden). Do not commit secrets/.')
+5
View File
@@ -0,0 +1,5 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
# Restart all three services and retain the named PostgreSQL volume.
docker compose restart db cache api
+342
View File
@@ -0,0 +1,342 @@
"""Lab2 API. PostgreSQL is the sole source of truth, including sessions."""
import base64
import hashlib
import json
import os
import re
import secrets
import uuid
import threading
import time
from concurrent.futures import ThreadPoolExecutor, TimeoutError as FutureTimeout
from datetime import datetime, timezone
from pathlib import Path
from argon2 import PasswordHasher
from argon2.exceptions import VerificationError, InvalidHashError
from flask import Flask, g, jsonify, request
from jsonschema import Draft202012Validator, FormatChecker, ValidationError
from psycopg import Error as DatabaseError
from psycopg.errors import UniqueViolation
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool, PoolTimeout
from redis import Redis
from redis.exceptions import RedisError
from redis.retry import Retry
from redis.backoff import NoBackoff
from werkzeug.exceptions import HTTPException
ROOT = Path(__file__).resolve().parents[1]
app = Flask(__name__)
app.config['MAX_CONTENT_LENGTH'] = 65536
passwords = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=2)
dummy_hash = passwords.hash(secrets.token_urlsafe(32))
ttl = int(os.environ.get('SESSION_TTL_SECONDS', '3600'))
if ttl < 1:
raise ValueError('SESSION_TTL_SECONDS must be positive')
dsn = Path(os.environ['DATABASE_URL_FILE']).read_text().strip() if os.environ.get('DATABASE_URL_FILE') else os.environ['DATABASE_URL']
pool = ConnectionPool(dsn, min_size=1, max_size=8, timeout=3,
kwargs={'row_factory': dict_row, 'connect_timeout': 3,
'options': '-c statement_timeout=3000 -c lock_timeout=2000'})
# Cache only immutable public profiles, never sessions or authorization decisions.
cache_url = Path(os.environ['CACHE_URL_FILE']).read_text().strip() if os.environ.get('CACHE_URL_FILE') else os.environ.get('CACHE_URL', 'redis://cache:6379/0')
cache = Redis.from_url(cache_url, socket_connect_timeout=0.2, socket_timeout=0.2,
max_connections=8, decode_responses=True,
retry=Retry(NoBackoff(), 0), retry_on_timeout=False)
PROFILE_CACHE_TTL = 60
# Socket timeouts do not bound DNS resolution. Limit the complete optional-cache
# operation, bound outstanding work and skip calls briefly after a failure.
cache_workers = ThreadPoolExecutor(max_workers=2, thread_name_prefix='profile-cache')
cache_slots = threading.BoundedSemaphore(2)
cache_breaker_lock = threading.Lock()
cache_retry_after = 0.0
def cache_call(method, *args):
global cache_retry_after
with cache_breaker_lock:
if time.monotonic() < cache_retry_after:
raise RedisError('Optional cache circuit open')
if not cache_slots.acquire(blocking=False):
raise RedisError('Optional cache busy')
try:
future = cache_workers.submit(getattr(cache, method), *args)
except Exception:
cache_slots.release()
raise
future.add_done_callback(lambda _: cache_slots.release())
try:
return future.result(timeout=0.25)
except (RedisError, FutureTimeout):
with cache_breaker_lock:
cache_retry_after = time.monotonic() + 2
raise RedisError('Optional cache unavailable') from None
schemas = json.loads((ROOT/'contracts/openapi.json').read_text())['components']['schemas']
class APIError(Exception):
def __init__(self, status, code, message):
self.status, self.code, self.message = status, code, message
def invalid(message='Invalid request'):
raise APIError(400, 'invalid_request', message)
def unauthorized():
raise APIError(401, 'unauthorized', 'Authentication required')
@app.before_request
def request_id():
g.request_id = uuid.uuid4().hex
@app.after_request
def headers(response):
response.headers['X-Request-Id'] = g.request_id
response.headers['Cache-Control'] = 'no-store'
if response.status_code == 401:
response.headers['WWW-Authenticate'] = ('Basic realm="messenger", charset="UTF-8"'
if request.path == '/api/v1/auth/sessions' else 'Bearer realm="messenger"')
return response
@app.errorhandler(Exception)
def error(exc):
if isinstance(exc, APIError):
status, code, message = exc.status, exc.code, exc.message
elif isinstance(exc, UniqueViolation):
status, code, message = 409, 'conflict', 'Username already registered'
elif isinstance(exc, (DatabaseError, PoolTimeout)):
status, code, message = 503, 'unavailable', 'Storage temporarily unavailable'
elif isinstance(exc, HTTPException):
status = exc.code
code = {400:'invalid_request',404:'not_found',405:'not_found',413:'payload_too_large',415:'unsupported_media_type'}.get(status,'invalid_request')
message = 'Request rejected'
else:
app.logger.error('Unhandled exception class=%s request_id=%s', type(exc).__name__, g.request_id)
status, code, message = 500, 'internal_error', 'Internal error'
return jsonify(error={'code':code,'message':message,'request_id':g.request_id}), status
def wire(row):
return {k: (str(v) if isinstance(v, uuid.UUID) else
v.astimezone(timezone.utc).isoformat().replace('+00:00','Z') if isinstance(v,datetime) else v)
for k,v in row.items()}
def body(schema):
if not request.is_json:
raise APIError(415,'unsupported_media_type','Expected application/json')
data = request.get_json()
try:
Draft202012Validator(schemas[schema], format_checker=FormatChecker()).validate(data)
except ValidationError:
invalid()
for value in data.values():
if isinstance(value,str) and not value.strip():
invalid('Blank strings are not allowed')
return data
def uid(value):
try:
return str(uuid.UUID(value))
except (ValueError,TypeError,AttributeError):
invalid('Invalid UUID')
def token_digest(token):
return hashlib.sha256(token.encode()).hexdigest()
def authenticate(conn):
auth = request.headers.get('Authorization','').split()
if len(auth)!=2 or auth[0].lower()!='bearer' or len(auth[1])>256:
unauthorized()
g.token_hash = token_digest(auth[1])
session = conn.execute('SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at>clock_timestamp()', (g.token_hash,)).fetchone()
if session is None:
unauthorized()
user_id = str(session['user_id'])
key = 'profile:v1:' + user_id
try:
encoded = cache_call('get', key)
if encoded:
profile = json.loads(encoded)
Draft202012Validator(schemas['User'], format_checker=FormatChecker()).validate(profile)
if profile['id'] == user_id:
return profile
except (RedisError, ValueError, ValidationError):
pass # PostgreSQL remains authoritative and is never bypassed for sessions.
row = conn.execute('SELECT id,username,display_name,created_at FROM users WHERE id=%s', (user_id,)).fetchone()
if row is None:
unauthorized()
profile = wire(row)
try:
cache_call('setex', key, PROFILE_CACHE_TTL, json.dumps(profile))
except RedisError:
pass
return profile
def chat(conn, chat_id, user_id):
row = conn.execute('SELECT c.* FROM chats c JOIN members m ON m.chat_id=c.id WHERE c.id=%s AND m.user_id=%s',(chat_id,user_id)).fetchone()
if row is None:
raise APIError(404,'not_found','Object not found')
result = wire(row)
result['member_ids'] = [str(x['user_id']) for x in conn.execute('SELECT user_id FROM members WHERE chat_id=%s ORDER BY user_id',(chat_id,))]
return result
def page_args(scope):
if set(request.args)-{'limit','cursor'} or any(len(request.args.getlist(k))!=1 for k in request.args):
invalid()
value = request.args.get('limit','50')
if not re.fullmatch(r'[0-9]{1,3}',value) or not 1<=int(value)<=100:
invalid('Invalid limit')
after = None
if 'cursor' in request.args:
try:
encoded=request.args['cursor']
if len(encoded)>1024: invalid()
cursor=json.loads(base64.b64decode(encoded,altchars=b'-_',validate=True))
if len(cursor)!=3 or cursor[0]!=scope: invalid()
stamp=datetime.fromisoformat(cursor[1].replace('Z','+00:00'))
if stamp.tzinfo is None: invalid()
after=(stamp,uid(cursor[2]))
except (ValueError,TypeError,KeyError,IndexError):
invalid('Invalid cursor')
return int(value), after
def page(rows,limit,scope):
items=rows[:limit]
cursor=None
if len(rows)>limit:
last=items[-1]
cursor=base64.urlsafe_b64encode(json.dumps([scope,last['created_at'],last['id']]).encode()).decode()
return jsonify(items=items,next_cursor=cursor)
@app.get('/health/live')
def live():
return jsonify(status='ok')
@app.get('/health/ready')
def ready():
with pool.connection() as conn:
conn.execute('SELECT 1 FROM schema_migrations LIMIT 1')
return jsonify(status='ok')
@app.post('/api/v1/users')
def register():
data=body('CreateUser')
hashed=passwords.hash(data['password'])
with pool.connection() as conn:
row=conn.execute('INSERT INTO users(id,username,display_name,password_hash) VALUES(%s,%s,%s,%s) RETURNING id,username,display_name,created_at',
(uuid.uuid4(),data['username'],data['display_name'],hashed)).fetchone()
return jsonify(wire(row)),201
@app.post('/api/v1/auth/sessions')
def login():
if request.get_data(): invalid('Login has no request body')
auth=request.headers.get('Authorization','').split()
try:
if len(auth)!=2 or auth[0].lower()!='basic': unauthorized()
username,password=base64.b64decode(auth[1],validate=True).decode('utf-8').split(':',1)
except (ValueError,UnicodeError):
unauthorized()
with pool.connection() as conn:
row=conn.execute('SELECT * FROM users WHERE username=%s',(username,)).fetchone()
try:
valid=passwords.verify(row['password_hash'] if row else dummy_hash,password)
except (VerificationError,InvalidHashError):
valid=False
if not valid or row is None: unauthorized()
token=secrets.token_urlsafe(32)
session=conn.execute("INSERT INTO sessions(token_hash,user_id,expires_at) VALUES(%s,%s,clock_timestamp()+(%s * interval '1 second')) RETURNING expires_at",(token_digest(token),row['id'],ttl)).fetchone()
user=wire({k:v for k,v in row.items() if k!='password_hash'})
return jsonify(token=token,token_type='Bearer',expires_at=wire(session)['expires_at'],user=user),201
@app.delete('/api/v1/auth/sessions/current')
def logout():
with pool.connection() as conn:
authenticate(conn)
conn.execute('DELETE FROM sessions WHERE token_hash=%s',(g.token_hash,))
return '',204
@app.get('/api/v1/users/me')
def me():
with pool.connection() as conn:
result=wire(authenticate(conn))
return jsonify(result)
@app.post('/api/v1/chats')
def create_chat():
with pool.connection() as conn:
actor=authenticate(conn)
data=body('CreateChat')
ids=[uid(x) for x in data['member_ids']]
if len(set(ids))!=len(ids) or str(actor['id']) not in ids: invalid()
known=conn.execute('SELECT id FROM users WHERE id=ANY(%s::uuid[])',(ids,)).fetchall()
if len(known)!=len(ids): invalid('Unknown member')
chat_id=uuid.uuid4()
conn.execute('INSERT INTO chats(id,title) VALUES(%s,%s)',(chat_id,data['title']))
for member in ids:
conn.execute('INSERT INTO members(chat_id,user_id) VALUES(%s,%s)',(chat_id,member))
result=chat(conn,chat_id,actor['id'])
return jsonify(result),201
@app.get('/api/v1/chats')
def chats():
with pool.connection() as conn:
actor=authenticate(conn)
scope='chats:'+str(actor['id'])
limit,after=page_args(scope)
sql='SELECT c.* FROM chats c JOIN members m ON m.chat_id=c.id WHERE m.user_id=%s'
args=[actor['id']]
if after:
sql+=' AND (c.created_at,c.id)>(%s,%s)'; args.extend(after)
sql+=' ORDER BY c.created_at,c.id LIMIT %s'; args.append(limit+1)
rows=[chat(conn,x['id'],actor['id']) for x in conn.execute(sql,args).fetchall()]
return page(rows,limit,scope)
@app.get('/api/v1/chats/<chat_id>')
def get_chat(chat_id):
with pool.connection() as conn:
actor=authenticate(conn)
result=chat(conn,uid(chat_id),actor['id'])
return jsonify(result)
@app.route('/api/v1/chats/<chat_id>/messages',methods=['GET','POST'])
def messages(chat_id):
with pool.connection() as conn:
actor=authenticate(conn)
chat_id=uid(chat_id)
chat(conn,chat_id,actor['id'])
if request.method=='POST':
data=body('CreateMessage')
row=conn.execute('INSERT INTO messages(id,chat_id,sender_id,text) VALUES(%s,%s,%s,%s) RETURNING *',(uuid.uuid4(),chat_id,actor['id'],data['text'])).fetchone()
result=wire(row)
else:
scope='messages:'+chat_id
limit,after=page_args(scope)
sql='SELECT * FROM messages WHERE chat_id=%s'; args=[chat_id]
if after:
sql+=' AND (created_at,id)>(%s,%s)'; args.extend(after)
sql+=' ORDER BY created_at,id LIMIT %s'; args.append(limit+1)
rows=[wire(x) for x in conn.execute(sql,args).fetchall()]
return (jsonify(result),201) if request.method=='POST' else page(rows,limit,scope)
+15
View File
@@ -0,0 +1,15 @@
"""Transactional, serialized, versioned migrations. Safe to run repeatedly."""
from pathlib import Path
from app import pool, ROOT
with pool.connection() as conn:
conn.execute('SELECT pg_advisory_xact_lock(2026002)')
conn.execute('CREATE TABLE IF NOT EXISTS schema_migrations(version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT clock_timestamp())')
for path in sorted((ROOT/'migrations').glob('*.sql')):
if not conn.execute('SELECT 1 FROM schema_migrations WHERE version=%s',(path.name,)).fetchone():
conn.execute(path.read_text())
conn.execute('INSERT INTO schema_migrations(version) VALUES(%s)',(path.name,))
print('Applied',path.name)
else:
print('Already applied',path.name)
pool.close()
+14
View File
@@ -0,0 +1,14 @@
"""Run against a separate API with SESSION_TTL_SECONDS=2."""
import sys,time
from pathlib import Path
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'tests'))
from client import Client,run
def main():
c=Client('http://localhost:8081')
a=c.user('expiry')
c.call('GET','/api/v1/users/me',actor=a,schema='User')
time.sleep(3)
c.call('GET','/api/v1/users/me',401,actor=a)
print('PASS: a real short-lived session authenticates before expiry and returns 401 after expiry')
if __name__=='__main__': run(main)
+58
View File
@@ -0,0 +1,58 @@
"""Real Docker restart evidence plus repeated migrations, expiry, DB failure."""
import json,subprocess,sys,time,urllib.request,urllib.error
from pathlib import Path
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'tests'))
from client import Client,check,run
ROOT=Path(__file__).resolve().parents[1]
def command(*args):
return subprocess.check_output(args,cwd=ROOT,text=True).strip()
def snapshot():
for service in ('api','db','cache'):
container=command('docker','compose','ps','-q',service)
value=command('docker','inspect','--format','{{.Id}} {{.State.StartedAt}} {{.RestartCount}}',container)
print(service,value,flush=True)
print('DB postmaster:',command('docker','compose','exec','-T','db','psql','-U','messenger','-d','messenger','-Atc','select pg_postmaster_start_time()'),flush=True)
def wait_ready(url):
for _ in range(90):
try:
if urllib.request.urlopen(url,timeout=2).status==200: return
except (OSError,urllib.error.URLError): pass
time.sleep(1)
raise AssertionError('Readiness timeout')
def main():
print('Before full restart:',flush=True); snapshot()
subprocess.run(['make','test-persistence','ACTION_SCRIPT=scripts/restart.sh'],cwd=ROOT,check=True)
print('After full restart:',flush=True); snapshot()
sql='select (select count(*) from users),(select count(*) from chats),(select count(*) from messages),(select count(*) from sessions),(select count(*) from schema_migrations)'
def counts(): return command('docker','compose','exec','-T','db','psql','-U','messenger','-d','messenger','-Atc',sql)
before=counts()
for _ in range(2):
print(command('docker','compose','exec','-T','api','python','src/migrate.py'),flush=True)
check(before==counts(),'Migration rerun changed counts')
print('PASS: two migration reruns; users/chats/messages/sessions/migrations counts unchanged:',before,flush=True)
# Separate short-TTL process, same database, isolated port; no change to normal API TTL.
subprocess.run(['docker','compose','run','-d','--no-deps','--name','lab2-expiry','-e','SESSION_TTL_SECONDS=2','-p','127.0.0.1:8081:8080','api'],cwd=ROOT,check=True,stdout=subprocess.DEVNULL)
try:
wait_ready('http://localhost:8081/health/ready')
subprocess.run([sys.executable,'student-tests/expiry.py'],cwd=ROOT,check=True)
finally:
subprocess.run(['docker','rm','-f','lab2-expiry'],check=True,stdout=subprocess.DEVNULL)
c=Client(timeout=10)
actor=c.user('db_failure')
subprocess.run(['docker','compose','stop','db'],cwd=ROOT,check=True)
try:
c.call('GET','/health/live',schema='Health')
c.call('GET','/health/ready',503)
c.call('GET','/api/v1/users/me',503,actor=actor)
print('PASS: DB down: live=200, ready=503, authenticated request=503; no anonymous fallback',flush=True)
finally:
subprocess.run(['docker','compose','start','db'],cwd=ROOT,check=True)
wait_ready('http://localhost:8080/health/ready')
c.call('GET','/api/v1/users/me',actor=actor,schema='User')
print('PASS: DB recovered; same session works',flush=True)
if __name__=='__main__': run(main)
+93
View File
@@ -0,0 +1,93 @@
"""Adapted from Karpova lab1 archive: password + Basic/Bearer transition only."""
"""100 concurrent message writes from 10 client identities."""
import base64
import json
import os
import uuid
from concurrent.futures import ThreadPoolExecutor, as_completed
from urllib.error import HTTPError
from urllib.parse import quote
from urllib.request import Request, urlopen
BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/")
def call(method, path, *, body=None, actor=None):
headers = {"Accept": "application/json", "Content-Type": "application/json"}
if actor:
headers["Authorization"] = "Bearer " + actor["token"]
raw = json.dumps(body, ensure_ascii=False).encode("utf-8") if body is not None else None
request = Request(BASE_URL + path, data=raw, headers=headers, method=method)
try:
response = urlopen(request, timeout=10)
status = response.status
data = response.read()
except HTTPError as error:
status = error.code
data = error.read()
payload = json.loads(data) if data else None
return status, payload
def create_user(label):
status, payload = call(
"POST",
"/api/v1/users",
body={
"username": "c_" + label + "_" + uuid.uuid4().hex[:8],
"display_name": "Client " + label, "password": "Synthetic-lab1-port-123",
},
)
assert status == 201, (status, payload)
basic = base64.b64encode((payload['username']+':Synthetic-lab1-port-123').encode()).decode()
req = Request(BASE_URL+'/api/v1/auth/sessions', method='POST', headers={'Authorization':'Basic '+basic})
with urlopen(req, timeout=10) as response:
payload['token'] = json.load(response)['token']
return payload
def main():
clients = [create_user(str(i)) for i in range(10)]
status, chat = call(
"POST",
"/api/v1/chats",
actor=clients[0],
body={"title": "Concurrent test", "member_ids": [x["id"] for x in clients]},
)
assert status == 201, (status, chat)
def send(client_index):
actor = clients[client_index]
status, payload = call(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
actor=actor,
body={"text": f"concurrent-client-{client_index}-message-{uuid.uuid4().hex}"},
)
return status, payload
results = []
with ThreadPoolExecutor(max_workers=10) as pool:
futures = [pool.submit(send, i % 10) for i in range(100)]
for future in as_completed(futures):
results.append(future.result())
statuses = [status for status, _ in results]
assert all(status == 201 for status in statuses), f"unexpected statuses: {statuses}"
status, page = call(
"GET",
f"/api/v1/chats/{chat['id']}/messages?limit=100",
actor=clients[0],
)
assert status == 200, (status, page)
ids = [item["id"] for item in page["items"]]
assert len(ids) == 100, f"expected 100 messages, got {len(ids)}"
assert len(set(ids)) == 100, "message IDs are not unique"
assert page["next_cursor"] is None, "100 messages should fit one page"
print("PASS: 10 concurrent clients -> 100 successful messages -> 100 unique messages")
if __name__ == "__main__":
main()
+164
View File
@@ -0,0 +1,164 @@
"""Adapted from Karpova lab1 archive: password + Basic/Bearer transition only."""
"""Student tests for MTUSI Lab1 level 4 requirements."""
import base64
import json
import os
import uuid
from urllib.error import HTTPError
from urllib.parse import quote
from urllib.request import Request, urlopen
BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/")
def call(method, path, *, body=None, actor=None, raw=None, content_type=None):
headers = {"Accept": "application/json"}
if actor:
headers["Authorization"] = "Bearer " + actor["token"]
if body is not None:
raw = json.dumps(body, ensure_ascii=False).encode("utf-8")
content_type = "application/json"
if content_type:
headers["Content-Type"] = content_type
req = Request(BASE_URL + path, data=raw, headers=headers, method=method)
try:
response = urlopen(req, timeout=5)
status = response.status
data = response.read()
headers = response.headers
except HTTPError as error:
status = error.code
data = error.read()
headers = error.headers
payload = None
if headers.get_content_type() == "application/json" and data:
payload = json.loads(data)
return status, headers, payload
def expect(status, actual, label):
assert actual == status, f"{label}: expected {status}, got {actual}"
def create_user(label, username=None):
username = username or ("t_" + label + "_" + uuid.uuid4().hex[:10])
status, headers, payload = call(
"POST",
"/api/v1/users",
body={"username": username, "display_name": "Тест " + label, "password": "Synthetic-lab1-port-123"},
)
expect(201, status, "create user")
basic = base64.b64encode((payload['username']+':Synthetic-lab1-port-123').encode()).decode()
req = Request(BASE_URL+'/api/v1/auth/sessions', method='POST', headers={'Authorization':'Basic '+basic})
with urlopen(req, timeout=10) as response:
payload['token'] = json.load(response)['token']
return payload
def main():
# 1) malformed JSON must be 400, not FastAPI's default 422.
status, headers, payload = call(
"POST",
"/api/v1/users",
raw=b'{"username":',
content_type="application/json",
)
expect(400, status, "malformed JSON")
assert payload["error"]["code"] == "invalid_request"
assert headers.get("X-Request-Id") == payload["error"]["request_id"]
# 2) Duplicate username must be 409.
username = "dup_" + uuid.uuid4().hex[:8]
create_user("one", username=username)
status, _, payload = call(
"POST",
"/api/v1/users",
body={"username": username, "display_name": "Дубликат", "password": "Synthetic-lab1-port-123"},
)
expect(409, status, "duplicate username")
assert payload["error"]["code"] == "conflict"
alice = create_user("alice")
bob = create_user("bob")
eve = create_user("eve")
# 3) Create a private chat for Alice + Bob. Eve must not see it.
status, _, chat = call(
"POST",
"/api/v1/chats",
actor=alice,
body={"title": "Private test", "member_ids": [alice["id"], bob["id"]]},
)
expect(201, status, "create chat")
status, _, _ = call("GET", f"/api/v1/chats/{chat['id']}", actor=eve)
expect(404, status, "outsider chat access")
# 4) Blank message must be 400.
status, _, payload = call(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
actor=alice,
body={"text": " "},
)
expect(400, status, "blank message")
assert payload["error"]["code"] == "invalid_request"
# 5) Send 3 messages and walk multiple pages using cursor.
message_ids = []
for i in range(3):
status, _, message = call(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
actor=alice if i % 2 == 0 else bob,
body={"text": f"page-{i} Привет 👋"},
)
expect(201, status, "create message")
message_ids.append(message["id"])
seen = []
cursor = None
while True:
path = f"/api/v1/chats/{chat['id']}/messages?limit=1"
if cursor:
path += "&cursor=" + quote(cursor, safe="")
status, _, payload = call("GET", path, actor=bob)
expect(200, status, "message page")
seen.extend(x["id"] for x in payload["items"])
cursor = payload["next_cursor"]
if cursor is None:
break
assert len(seen) == 3, f"pagination returned {len(seen)} messages"
assert len(set(seen)) == 3, "pagination duplicated a message"
assert set(seen) == set(message_ids), "pagination lost a message"
# A messages cursor from another resource is invalid.
status, _, payload = call("GET", "/api/v1/chats?limit=1", actor=bob)
expect(200, status, "chat list")
bad_cursor = payload["next_cursor"]
if bad_cursor is None:
# Create enough chats to get a cursor.
for i in range(2):
call(
"POST",
"/api/v1/chats",
actor=bob,
body={"title": f"Extra {i}", "member_ids": [bob["id"]]},
)
status, _, payload = call("GET", "/api/v1/chats?limit=1", actor=bob)
expect(200, status, "chat list second try")
bad_cursor = payload["next_cursor"]
status, _, err = call(
"GET",
f"/api/v1/chats/{chat['id']}/messages?limit=1&cursor={quote(bad_cursor, safe='')}",
actor=bob,
)
expect(400, status, "cursor from another resource")
assert err["error"]["code"] == "invalid_request"
print("PASS: own negative, access-control and multi-page tests")
if __name__ == "__main__":
main()
+73
View File
@@ -0,0 +1,73 @@
"""Exercise Redis cache, safe fallback and real post-insert transactional rollback."""
import json,subprocess,sys,time,uuid
from pathlib import Path
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'tests'))
from client import Client,check,run
ROOT=Path(__file__).resolve().parents[1]
def cmd(*args):
return subprocess.check_output(args,cwd=ROOT,text=True).strip()
def sql(statement):
return cmd('docker','compose','exec','-T','db','psql','-v','ON_ERROR_STOP=1','-U','messenger','-d','messenger','-Atc',statement)
def redis(*args):
return cmd('docker','compose','exec','-T','cache','redis-cli','--raw',*args)
def main():
c=Client(timeout=10); actor=c.user('cache')
key='profile:v1:'+actor['id']
c.call('GET','/api/v1/users/me',actor=actor,schema='User')
cached=json.loads(redis('GET',key))
check(cached==actor['user'],'profile not actually cached')
remaining=int(redis('TTL',key)); check(0<remaining<=60,'profile cache TTL missing')
def hits():
return int(next(line.split(':')[1] for line in redis('INFO','stats').splitlines() if line.startswith('keyspace_hits:')))
before=hits()
for _ in range(3): c.call('GET','/api/v1/users/me',actor=actor,schema='User')
check(hits()>=before+3,'API did not read Redis')
print('PASS: actual cached public profile, TTL <=60 seconds, at least 3 Redis cache hits',flush=True)
subprocess.run(['docker','compose','stop','cache'],cwd=ROOT,check=True)
try:
start=time.monotonic()
result=c.call('GET','/api/v1/users/me',actor=actor,schema='User')['json']
elapsed=time.monotonic()-start
print('Cache outage diagnostic: profile_matches=%s elapsed_seconds=%.3f'%(result==actor['user'],elapsed),flush=True)
check(result==actor['user'] and elapsed<3,'cache fallback incorrect or unbounded')
c.call('GET','/api/v1/users/me',401)
c.call('GET','/api/v1/users/me',401,headers={'Authorization':'Bearer random-invalid-token'})
c.call('GET','/health/ready',schema='Health')
c.call('DELETE','/api/v1/auth/sessions/current',204,actor=actor)
c.call('GET','/api/v1/users/me',401,actor=actor)
print('PASS: Redis down: PostgreSQL fallback %.3fs, ready=200, invalid/absent/revoked sessions=401'%elapsed,flush=True)
finally:
subprocess.run(['docker','compose','start','cache'],cwd=ROOT,check=True)
for _ in range(30):
try:
if redis('PING')=='PONG': break
except subprocess.CalledProcessError: pass
time.sleep(1)
check(redis('EXISTS',key)=='0','cache unexpectedly persisted test key')
actor=c.user('cache_recovery')
for _ in range(5):
c.call('GET','/api/v1/users/me',actor=actor,schema='User')
if redis('EXISTS','profile:v1:'+actor['id'])=='1': break
time.sleep(1)
check(redis('EXISTS','profile:v1:'+actor['id'])=='1','cache did not recover')
print('PASS: ephemeral Redis restart: cache is rebuilt; no session source of truth lost',flush=True)
# Inject a scoped storage failure on member INSERT, after the chat INSERT.
title='rollback_'+uuid.uuid4().hex
function='lab2_test_'+uuid.uuid4().hex
trigger=function+'_trigger'
sql("CREATE FUNCTION "+function+"() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF EXISTS (SELECT 1 FROM chats WHERE id=NEW.chat_id AND title='"+title+"') THEN RAISE EXCEPTION 'synthetic member insert failure' USING ERRCODE='23514'; END IF; RETURN NEW; END $$; CREATE TRIGGER "+trigger+" BEFORE INSERT ON members FOR EACH ROW EXECUTE FUNCTION "+function+"();")
try:
c.call('POST','/api/v1/chats',503,actor=actor,body={'title':title,'member_ids':[actor['id']]})
check(sql("SELECT count(*) FROM chats WHERE title='"+title+"'")=='0','partial chat survived failed member INSERT')
check(sql('SELECT count(*) FROM members m LEFT JOIN chats c ON c.id=m.chat_id WHERE c.id IS NULL')=='0','orphan membership')
print('PASS: injected failure AFTER chat INSERT: HTTP 503, transaction rolled back chat and members',flush=True)
finally:
sql('DROP TRIGGER '+trigger+' ON members; DROP FUNCTION '+function+'();')
c.call('POST','/api/v1/chats',201,actor=actor,body={'title':'after rollback','member_ids':[actor['id']]},schema='Chat')
print('PASS: same API remains usable after rollback',flush=True)
if __name__=='__main__': run(main)
+75
View File
@@ -0,0 +1,75 @@
"""Track 2: isolated 120k-row study, actual pg_dump/restore and content verification."""
import datetime,json,subprocess,time,uuid
from pathlib import Path
ROOT=Path(__file__).resolve().parents[1]
def worker(mode,database,host=None):
r=subprocess.run(['docker','compose','exec','-T','api','python','-',mode,database]+([host] if host else []),cwd=ROOT,input=(ROOT/'student-tests/research_worker.py').read_text(),stdout=subprocess.PIPE,text=True,check=True)
return json.loads(r.stdout)
def main():
suffix=uuid.uuid4().hex[:10]; source='lab2_study_'+suffix; restored=source+'_restored'
print('Fresh isolated databases:',source,restored,flush=True)
prepared=worker('prepare',source)
print('Seeded',prepared['messages'],'synthetic messages:',prepared['distribution'],flush=True)
result=worker('benchmark',source)
dump='/tmp/'+source+'.dump'
recovery='lab2-recovery-'+suffix; volume=recovery+'-data'
container=subprocess.check_output(['docker','compose','ps','-q','api'],cwd=ROOT,text=True).strip()
network=next(iter(json.loads(subprocess.check_output(['docker','inspect','--format','{{json .NetworkSettings.Networks}}',container],text=True))))
subprocess.run(['docker','volume','create',volume],check=True,stdout=subprocess.DEVNULL)
started=False
def db(*args):
subprocess.run(['docker','compose','exec','-T','db',*args],cwd=ROOT,check=True)
try:
start=time.perf_counter();db('pg_dump','-U','messenger','-d',source,'-Fc','-f',dump); backup_s=time.perf_counter()-start
start=time.perf_counter()
subprocess.run(['docker','run','-d','--name',recovery,'--network',network,
'-e','POSTGRES_DB='+restored,'-e','POSTGRES_USER=messenger',
'-e','POSTGRES_PASSWORD_FILE=/run/secrets/db_password',
'--mount','type=bind,src='+str(ROOT/'secrets/db_password')+',dst=/run/secrets/db_password,readonly',
'--mount','type=volume,src='+volume+',dst=/var/lib/postgresql/data',
'postgres:17.6-bookworm'],check=True,stdout=subprocess.DEVNULL)
started=True
for _ in range(60):
probe=subprocess.run(['docker','exec',recovery,'pg_isready','-U','messenger','-d',restored],stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
if probe.returncode==0:
break
time.sleep(1)
# Wait until final server accepts TCP inside the default network.
for _ in range(60):
probe=subprocess.run(['docker','exec',recovery,'pg_isready','-h','127.0.0.1','-U','messenger','-d',restored],stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
if probe.returncode==0: break
time.sleep(1)
else: raise RuntimeError('Restoration server did not become ready')
producer=subprocess.Popen(['docker','compose','exec','-T','db','cat',dump],cwd=ROOT,stdout=subprocess.PIPE)
try:
consumer=subprocess.run(['docker','exec','-i',recovery,'pg_restore','-U','messenger','-d',restored,'--exit-on-error','--no-owner'],stdin=producer.stdout)
producer.stdout.close()
code=producer.wait()
if code or consumer.returncode: raise RuntimeError('Backup stream or restore failed')
finally:
if producer.poll() is None: producer.kill();producer.wait()
restore_s=time.perf_counter()-start
start=time.perf_counter();actual=worker('verify',restored,recovery);verify_s=time.perf_counter()-start
expected=result.pop('fingerprint')
if actual!=expected: raise AssertionError('Restored counts, full message digest or samples differ')
size=int(subprocess.check_output(['docker','compose','exec','-T','db','stat','-c','%s',dump],cwd=ROOT,text=True))
result['backup_restore']={'backup_s':backup_s,'fresh_container_bootstrap_and_restore_s':restore_s,'verification_s':verify_s,'dump_bytes':size,'expected':expected,'restored':actual,'identical':True,'source_database':source,'restored_database':restored,'new_volume':volume,'recovery_container':recovery,'limitation':'logical snapshot; no PITR or concurrent writes; separate PostgreSQL instance and fresh named volume on the same physical Docker host'}
result['utc']=datetime.datetime.now(datetime.timezone.utc).isoformat()
(ROOT/'evidence/query-study.json').write_text(json.dumps(result,indent=2,ensure_ascii=False)+'\n')
print('PASS: 2 indexes, 3 rounds, 3 query profiles, 20 measured reads/profile, real 5000-row writes with rollback',flush=True)
print('PASS: pg_dump -> NEW PostgreSQL container + NEW volume -> table counts + ALL 120000 messages SHA256 + selected messages match',flush=True)
print('Backup %.3fs; restore %.3fs; verification %.3fs; dump %d bytes'%(backup_s,restore_s,verify_s,size),flush=True)
for variant in ['global','chat_first']:
rows=[r for r in result['results'] if r['variant']==variant]
print(variant,'5000-row insert ms:',[round(r['insert_5000_ms'],3) for r in rows],flush=True)
for scenario in ['hot-middle','medium-first','tiny-first']:
print(variant,scenario,'median ms per round:',[round(q['median_ms'],3) for r in rows for q in r['queries'] if q['scenario']==scenario],flush=True)
finally:
# Only objects created by this run; main messenger database and named volume are never removed.
db('rm','-f',dump)
if started: subprocess.run(['docker','rm','-f',recovery],check=True,stdout=subprocess.DEVNULL)
print('Research source database and recovered volume retained for inspection; recovery process stopped; no dump/credentials included in evidence.',flush=True)
if __name__=='__main__': main()
+85
View File
@@ -0,0 +1,85 @@
"""Executed inside API container by research.py, only in fresh research databases."""
import hashlib,json,os,statistics,sys,time,uuid
from pathlib import Path
import psycopg
from psycopg.conninfo import make_conninfo
from psycopg.rows import dict_row
mode,dbname=sys.argv[1:3]
if not dbname.startswith('lab2_study_') or not dbname.replace('_','').isalnum():
raise ValueError('Expected isolated study database name')
base=Path(os.environ['DATABASE_URL_FILE']).read_text().strip()
dsn=make_conninfo(base,dbname=dbname, **({"host":sys.argv[3]} if len(sys.argv)>3 else {}))
def fingerprint(conn):
counts={t:conn.execute('SELECT count(*) AS n FROM '+t).fetchone()['n'] for t in ['users','chats','members','messages','sessions','schema_migrations']}
digest=hashlib.sha256()
with conn.cursor(name='verify_messages') as cur:
cur.execute('SELECT id,chat_id,sender_id,text,created_at FROM messages ORDER BY id')
for row in cur:
digest.update(json.dumps(row,sort_keys=True,default=str,ensure_ascii=False).encode()+b'\n')
samples=conn.execute("SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE id IN (md5('message-1')::uuid,md5('message-100000')::uuid,md5('message-120000')::uuid) ORDER BY id").fetchall()
return {'counts':counts,'messages_sha256':digest.hexdigest(),'samples':samples}
if mode=='prepare':
with psycopg.connect(base,autocommit=True) as admin:
from psycopg import sql
admin.execute(sql.SQL('CREATE DATABASE {}').format(sql.Identifier(dbname)))
with psycopg.connect(dsn,row_factory=dict_row) as conn:
conn.execute('CREATE TABLE schema_migrations(version text PRIMARY KEY,applied_at timestamptz NOT NULL DEFAULT clock_timestamp())')
for path in sorted(Path('/app/migrations').glob('*.sql')):
conn.execute(path.read_text());conn.execute('INSERT INTO schema_migrations(version) VALUES(%s)',(path.name,))
conn.execute("INSERT INTO users(id,username,display_name,password_hash) VALUES(md5('research-user')::uuid,'research_user','Synthetic benchmark user','not-a-login-account')")
conn.execute("INSERT INTO chats(id,title) SELECT md5('chat-'||n)::uuid,'Synthetic chat '||n FROM generate_series(0,101) n")
conn.execute("INSERT INTO members(chat_id,user_id) SELECT id,md5('research-user')::uuid FROM chats")
conn.execute("""INSERT INTO messages(id,chat_id,sender_id,text,created_at)
SELECT md5('message-'||n)::uuid,
md5('chat-'||(CASE WHEN n<=100000 THEN 0 WHEN n<=119000 THEN 1 ELSE 2+(n-119001)%100 END))::uuid,
md5('research-user')::uuid,'synthetic-'||n||'-'||repeat('x',64+n%512),
timestamptz '2026-01-01 00:00:00+00'+ n * interval '1 microsecond'
FROM generate_series(1,120000) n""")
conn.execute('ANALYZE messages')
print(json.dumps({'created':dbname,'messages':120000,'distribution':'100000 + 19000 + 100*10','synthetic_only':True}))
elif mode=='benchmark':
query='SELECT * FROM messages WHERE chat_id=%s AND (created_at,id)>(%s,%s) ORDER BY created_at,id LIMIT 51'
specs=[('hot-middle',0,'2026-01-01T00:00:00.050000Z'),('medium-first',1,'2026-01-01T00:00:00Z'),('tiny-first',101,'2026-01-01T00:00:00Z')]
output={'messages':120000,'warmup':3,'measured_reads':20,'rounds':3,'write_batch':5000,'results':[],'query':query}
with psycopg.connect(dsn,row_factory=dict_row) as conn:
for round_no in range(3):
# Alternate order to reduce systematic warmup/order bias.
variants=['global','chat_first'] if round_no%2==0 else ['chat_first','global']
for variant in variants:
conn.execute('DROP INDEX IF EXISTS messages_history');conn.execute('DROP INDEX IF EXISTS messages_global')
definition=('CREATE INDEX messages_history ON messages(chat_id,created_at,id)' if variant=='chat_first' else 'CREATE INDEX messages_global ON messages(created_at,id)')
start=time.perf_counter();conn.execute(definition);conn.commit();build_ms=(time.perf_counter()-start)*1000
conn.execute('ANALYZE messages');conn.commit()
record={'round':round_no+1,'variant':variant,'definition':definition,'index_build_ms':build_ms,'queries':[]}
for name,chat_no,stamp in specs:
args=(str(uuid.UUID(hashlib.md5(('chat-'+str(chat_no)).encode()).hexdigest())),stamp,str(uuid.UUID(int=0)))
for _ in range(3):conn.execute(query,args).fetchall()
times=[]
for _ in range(20):
start=time.perf_counter();rows=conn.execute(query,args).fetchall();times.append((time.perf_counter()-start)*1000)
plan=conn.execute('EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) '+query,args).fetchone()['QUERY PLAN'][0]
record['queries'].append({'scenario':name,'rows':len(rows),'median_ms':statistics.median(times),'p95_ms':sorted(times)[18],'raw_ms':times,'explain':plan})
conn.commit()
# Real inserts, full constraints/index maintenance, then rollback to keep all variants at 120k rows.
start=time.perf_counter()
conn.execute("""INSERT INTO messages(id,chat_id,sender_id,text,created_at)
SELECT md5('write-cost-'||n)::uuid,md5('chat-0')::uuid,md5('research-user')::uuid,
'synthetic-write-'||n,timestamptz '2026-01-02 00:00:00+00'+n*interval '1 microsecond'
FROM generate_series(1,5000) n""")
record['insert_5000_ms']=(time.perf_counter()-start)*1000
conn.rollback()
# Clean up dead tuples from rollback, without changing measured data volume.
with psycopg.connect(dsn,autocommit=True) as vacuum: vacuum.execute('VACUUM ANALYZE messages')
record['index_bytes']=conn.execute("SELECT pg_relation_size(%s) AS bytes",('messages_history' if variant=='chat_first' else 'messages_global',)).fetchone()['bytes']
conn.commit();output['results'].append(record)
conn.execute('DROP INDEX IF EXISTS messages_global');conn.execute('DROP INDEX IF EXISTS messages_history')
conn.execute('CREATE INDEX messages_history ON messages(chat_id,created_at,id)');conn.commit()
output['fingerprint']=fingerprint(conn)
print(json.dumps(output,default=str,ensure_ascii=False))
elif mode=='verify':
with psycopg.connect(dsn,row_factory=dict_row) as conn:
print(json.dumps(fingerprint(conn),default=str,ensure_ascii=False))
else: raise ValueError('Unknown study mode')
+16
View File
@@ -0,0 +1,16 @@
"""Sequential required functional checks; failures preserve nonzero status."""
import subprocess,sys
from pathlib import Path
root=Path(__file__).resolve().parents[1]
commands=[
['make','check'],['make','test'],
[sys.executable,'student-tests/security.py'],
[sys.executable,'student-tests/lab1_own_tests.py'],
[sys.executable,'student-tests/lab1_concurrency.py'],
[sys.executable,'student-tests/level4.py'],
[sys.executable,'student-tests/infrastructure.py'],
]
for command in commands:
print('RUN: '+' '.join(command),flush=True)
subprocess.run(command,cwd=root,check=True)
print('PASS: all required functional checks completed',flush=True)
+35
View File
@@ -0,0 +1,35 @@
"""Additional API checks; tokens and passwords are never printed."""
import sys
import uuid
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'tests'))
from client import Client, check, run
def main():
c=Client()
a,b,e,room=c.bootstrap()
path='/api/v1/chats/'+room['id']
for data in [ {'text':' '}, {'text':'ok','sender_id':e['id']}, {'text':123}, {'text':'x'*4001} ]:
c.call('POST',path+'/messages',400,actor=a,body=data)
c.call('POST',path+'/messages',400,actor=a,raw=b'{broken',headers={'Content-Type':'application/json'})
c.call('GET',path+'/messages?cursor=broken',400,actor=a)
c.message(a,room,'page 1'); c.message(a,room,'page 2')
page=c.call('GET',path+'/messages?limit=1',actor=a,schema='MessagePage')['json']
other=c.call('POST','/api/v1/chats',201,actor=a,body={'title':'Other','member_ids':[a['id']]},schema='Chat')['json']
from urllib.parse import quote
c.call('GET','/api/v1/chats/'+other['id']+'/messages?cursor='+quote(page['next_cursor'],safe=''),400,actor=a)
before=c.call('GET','/api/v1/chats?limit=100',actor=a,schema='ChatPage')['json']
c.call('POST','/api/v1/chats',400,actor=a,body={'title':'must not exist','member_ids':[a['id'],str(uuid.uuid4())]})
after=c.call('GET','/api/v1/chats?limit=100',actor=a,schema='ChatPage')['json']
check(before==after,'invalid chat left state behind')
body={'username':'race_'+uuid.uuid4().hex[:12],'display_name':'Race','password':'Synthetic-password-123'}
def register(_):
return Client().call('POST','/api/v1/users',[201,409],body=body)['status']
with ThreadPoolExecutor(max_workers=4) as executor:
codes=sorted(executor.map(register,range(4)))
check(codes==[201,409,409,409],'registration race was not atomic')
print('PASS: malformed JSON, strict fields/types, whitespace, limits, cursor resource binding, invalid chat atomicity, concurrent username uniqueness')
if __name__=='__main__': run(main)