ЛР 2 — БПИ2303 — Мартинес — на 4 #192

Open
Mirariel wants to merge 1 commits from Mirariel/mtusi2026lab2:solution/bpi2303-martines into master
31 changed files with 1381 additions and 19 deletions
+1
View File
@@ -15,6 +15,7 @@ backups
*.jks
.venv
__pycache__
**/__pycache__
node_modules
evidence
.DS_Store
+5
View File
@@ -0,0 +1,5 @@
*.sh text eol=lf
*.py text eol=lf
*.sql text eol=lf
*.yaml text eol=lf
Dockerfile text eol=lf
+23
View File
@@ -0,0 +1,23 @@
name: Application acceptance
on: [push, pull_request]
permissions:
contents: read
jobs:
acceptance:
runs-on: ubuntu-latest
timeout-minutes: 15
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.12'
- run: python scripts/bootstrap.py
- run: docker compose up -d --build --wait
- run: python scripts/verify.py
- uses: actions/upload-artifact@v4
if: always()
with:
name: acceptance-evidence
path: evidence/
- run: docker compose down
if: always()
+14
View File
@@ -0,0 +1,14 @@
FROM python:3.12.8-slim-bookworm
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt && useradd --uid 10001 --create-home app
COPY src/ src/
COPY migrations/ migrations/
COPY scripts/ scripts/
COPY tests/ tests/
COPY contracts/ contracts/
COPY lab.json .
ENV PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1
USER app
EXPOSE 8080
CMD ["sh", "-c", "python -m src.db && exec gunicorn --bind 0.0.0.0:8080 --workers 2 --threads 4 --timeout 30 src.app:app"]
+38
View File
@@ -0,0 +1,38 @@
# ЛР 2 — БПИ2303 — Мартинес — на 4
Автор / группа: Мартинес Анастасия / БПИ2303.
Целевая оценка: 4. Трек 5 не заявлен.
Реализован REST-мессенджер по контракту lab2: PostgreSQL с миграциями,
атомарным созданием чата и keyset-пагинацией; Argon2id, Basic-вход,
opaque Bearer-сессии с expiry/logout. Данные и сессии сохраняются после рестарта.
Redis кэширует неизменяемые профили с TTL, отказ кэша даёт fallback в БД.
Пул и время обращения к зависимостям ограничены, включая DNS кэша.
Отдельный проект lab1 не предоставлялся; текстовый API реализован с нуля с
объявленным переходом lab2. Чужие студенческие решения не переносились.
Запуск из чистого clone:
```sh
python scripts/bootstrap.py
docker compose up -d --build --wait
python -X utf8 scripts/verify.py
```
Проверены публичные smoke/persistence, гонка регистрации, rollback, строгая
валидация, пагинация, expiry/logout, отказы Redis/PostgreSQL и повторные миграции.
EXPLAIN на 12 000 сообщениях использует messages_history и читает 51 строку.
Команды, результаты, нагрузочный замер и ограничения: [REPORT.md](REPORT.md),
сырые доказательства — [evidence/](evidence/).
Ограничения: один PostgreSQL/host, нет TLS/backup/HA/rate limiting;
HTTP опубликован только на loopback. Источники — skeleton и библиотеки из
requirements.txt. Codex использован для реализации, тестов и отчёта.
- [x] Обязательный минимум сохранён с объявленным переходом аутентификации.
- [x] Контракт и публичные тесты не ослаблены.
- [x] Выполнены Python-команды, эквивалентные make check/test; приложен вывод.
- [x] Сценарии сохранности и отказов уровня 4 воспроизведены.
- [x] Секреты вне Git, токены в evidence не записываются.
- [x] README задания сохранён, REPORT.md содержит инструкцию решения.
+145 -19
View File
@@ -1,37 +1,163 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
Автор: Мартинес Анастасия, БПИ2303. Целевая оценка: **4**; трек 5 не заявлен.
Ветка: `solution/bpi2303-martines`. Публикация PR ожидает доступа к fork.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Git, Python 3.9+ и работающий Docker Engine с Compose v2.
На Windows — Docker Desktop в режиме Linux containers. Все команды выполняются
из корня этого репозитория; соседние лабы и внешняя БД не нужны.
```sh
python scripts/bootstrap.py
docker compose config --quiet
docker compose up -d --build --wait
python -X utf8 scripts/verify.py
```
Bootstrap генерирует локальные случайные credentials и создаёт игнорируемые
`secrets/db_password`, `secrets/database_url`, `.env`. Повторный запуск
их не перезаписывает. Не коммитить эти файлы. API: http://127.0.0.1:8080,
готовность: /health/ready. Библиотеки на хост для этих проверок не нужны.
Стенд использует только синтетические тестовые данные.
Версии: Python 3.12.8 slim-bookworm, PostgreSQL 16.6 bookworm, Redis 7.4.1
bookworm. Все Python-зависимости закреплены в requirements.txt.
Gunicorn: 2 worker × 4 thread. Миграции выполняются до запуска API.
Отдельные проверки:
```sh
python scripts/check_contract.py
python tests/smoke.py --base-url http://127.0.0.1:8080
python tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080
python student-tests/acceptance.py
docker compose exec -T api python scripts/explain.py
```
В Windows для persistence использовать `scripts/restart.cmd`; verify.py
выбирает hook автоматически. restart.sh хранится с executable bit.
GNU Make запускает те же проверки: `make check`,
`make test BASE_URL=http://127.0.0.1:8080`,
`make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8080`.
Полная OpenAPI-валидация: установить requirements-dev.txt в отдельный venv,
затем `python scripts/validate_openapi.py`.
Остановка с сохранением данных: `docker compose down`.
Намеренное удаление **всех учебных данных этой лабы**: `docker compose down -v`.
Hook перезапуска volumes не удаляет. Новый запуск после удаления volume создаёт
пустую схему; прежние пользователи и токены не восстанавливаются.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Клиент → Flask/Gunicorn → PostgreSQL; Redis кэширует публичный профиль.
Схема, ограничения, индексы и границы транзакций: [docs/design.md](docs/design.md).
Реализованы текстовые endpoint lab1 с переходом lab2 на password/Basic/Bearer.
Отдельный исходный проект lab1 не предоставлялся: код написан с нуля по контракту
lab2, чужие студенческие решения не переносились. Контракт и публичные tests
остались без изменений.
PostgreSQL — источник истины для пользователей, чатов, членства, сообщений,
сессий; данные сохраняются в именованном pgdata. Пароли — Argon2id (19 MiB,
2 прохода, parallelism=1), opaque-токены — 32 случайных байта, в БД только SHA-256.
SESSION_TTL_SECONDS задаёт абсолютный expiry, по умолчанию 3600. Logout удаляет
текущую сессию; рестарт не продлевает её срок.
Redis хранит неизменяемый публичный профиль `profile:v1:<uuid>` на 60 с.
Редактирования профиля в API нет: инвалидация по TTL и версии ключа; при добавлении
редактирования понадобится отдельная стратегия. Сессии и история не кэшируются.
Каждый защищённый запрос проверяет PostgreSQL, поэтому тёплый кэш не отменяет
logout/expiry. Подтверждённые сообщения сразу видны новому чтению истории.
Redis persistence не нужен: потеря кэша вызывает чтение из PostgreSQL.
Пул: максимум 8 соединений на worker, суммарно 16; очередь до 32 на worker.
Pool/connect/statement timeout 3 с, lock timeout 2 с. Redis socket timeout 0.2 с;
wall timeout операции 0.25 с также ограничивает ожидание DNS. Фоновых операций
кэша максимум две на worker, очереди нет; при исчерпании слотов кэш пропускается.
SQL параметризован. Составные операции выполняются в транзакциях, 201 — после COMMIT.
Сопоставление .env.example: DATABASE_URL_FILE используется напрямую;
CACHE_URL_FILE поддерживается загрузчиком, Compose задаёт несекретный CACHE_URL;
SESSION_STORE=postgres фиксирован архитектурой. APP_HOST/APP_PORT заменены
явным bind Gunicorn 0.0.0.0:8080; хостовый порт только 127.0.0.1. APP_ENV
не влияет на поведение. Секреты и volumes исключены из Git и build context.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
Общий воспроизводимый запуск: `python -X utf8 scripts/verify.py`.
PASS учитывается только после завершения соответствующей команды;
сырые результаты сохраняются в evidence/.
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Критерий | Сценарий | Доказательство |
| --- | --- | --- |
| Контракт и текстовый API | Публичный smoke | evidence/smoke.txt |
| Сохранность данных и прежнего токена | Публичный persistence, restart api/db/redis | evidence/persistence.txt, evidence/restart.json |
| PK/FK/UNIQUE и атомарность | FK-ошибка второго участника; число чатов/участников не меняется | migrations/001_initial.sql, evidence/student-tests.json |
| Гонка регистрации | 8 одновременных запросов: один 201, семь 409 | evidence/student-tests.json |
| Повторяемые миграции | Повторное применение; число пользователей/версий не меняется | evidence/student-tests.json |
| KDF, expiry, logout | Unicode/двоеточие в пароле, неверный пароль, TTL=2, тёплый кэш | src/app.py, evidence/student-tests.json |
| Реальное использование Redis | TTL профиля ≤60, остановка и восстановление | evidence/student-tests.json |
| Пул/таймауты/отказы | Остановка БД: ограниченный 503, live=200, затем прежняя сессия | src/db.py, evidence/student-tests.json |
| Индекс на ≥10 000 сообщений | EXPLAIN ANALYZE BUFFERS на 12 000 сообщений | evidence/query-plan.json |
| Keyset и доступ | Изменение limit, чужой cursor, совпадение timestamp, чужой чат | evidence/student-tests.json |
| Структура skeleton | check_contract.py | evidence/contract.txt |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Гипотеза: индекс (chat_id,created_at,id) позволяет читать позднюю страницу
без сканирования всей истории. scripts/explain.py создаёт 12 000 сообщений,
делает ANALYZE, выбирает pivot после 10 000 строк и выполняет реальный запрос
API с LIMIT 51. OFFSET используется только при выборе экспериментального
pivot, в API его нет. Фикстуры откатываются после измерения. JSON содержит
actual rows/time и buffers; это эксперимент уровня 4, сравнение индексов
и backup/restore уровня 5 не заявлены.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
Наблюдение: Index Scan по messages_history, actual rows=51, shared hit blocks=4,
shared read blocks=0, Execution Time=0.278 мс. Прогретые страницы находились
в памяти; время не характеризует холодный диск. Полного Seq Scan/Sort в плане нет.
## Ограничения и следующие шаги
Нагрузка: один closed-loop запуск, 30 с, concurrency=4, POST сообщений,
без прозрачных retry и без отдельного фиксированного прогрева. Стенд перед
замером уже выполнял functional tests; история нагрузочного чата растёт.
evidence/load.json содержит successes/errors, RPS, p50/p95/p99.
CPU/RAM снимаются во время нагрузки в evidence/resources.json.
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Результат 19.11.2026: 6843 успешных запроса за 30.141 с, ошибок 0,
227.033 успешных RPS; p50=16 мс, p95=32 мс, p99=47 мс.
По семи выборкам Docker stats: API до 129.85% CPU и 198.5 MiB RAM,
PostgreSQL до 36.85% CPU и 39.2 MiB, Redis до 0.49% CPU и 8.312 MiB.
100% в Docker stats соответствует одному логическому CPU; выборки не являются
непрерывным измерением пиков. В нагрузочном чате создано 6843 сообщения.
Хост: Windows, около 15.75 GiB доступной ОС физической RAM (16 GiB номинально);
CPU/ОС — evidence/environment.json. Docker Engine 26.1.4, Compose 2.27.1.
Лимиты: API 2 CPU/512 MiB, PostgreSQL 1 CPU/512 MiB, Redis 0.5 CPU/128 MiB.
| Воздействие | Ожидание | Проверка |
| --- | --- | --- |
| Перезапуск API, БД, Redis | Прежний токен читает прежнее сообщение | persistence и StartedAt всех трёх контейнеров |
| Остановка Redis | Fallback в БД, ready=200, анонимный запрос не получает профиль | acceptance, затем start redis |
| Остановка PostgreSQL | 503 для me/ready, live=200; восстановление с прежним токеном | acceptance, затем start db |
| TTL=2 | После ожидания 401 даже с тёплым кэшем | Отдельный временный API на 8081 |
В первом прогоне отказ Redis выявил, что socket timeout не ограничивает
разрешение Docker DNS. Добавлен wall timeout с ограниченным executor;
окончательные evidence соответствуют успешному повторному прогону исправления.
Один нагрузочный повтор на ноутбуке не измеряет максимум производительности:
closed-loop страдает coordinated omission, latency учитывает успешные запросы.
## Ограничения и источники
Один host и один PostgreSQL не обеспечивают HA. Проверяется перезапуск
с сохранением диска, а не потеря узла/volume. Нет backup, TLS, rate limiting,
автоматической очистки истёкших сессий и ротации секретов.
Cursor не фиксирует snapshot между запросами: поздний COMMIT с ранним timestamp
может оказаться позади cursor; детали — docs/design.md.
Источники: контракт/публичные проверки skeleton; Flask, Gunicorn, Psycopg,
Redis-py, argon2-cffi; материалы по PostgreSQL и Redis из README задания.
Помощь ИИ: Codex подготовил код, инфраструктуру, собственные тесты, выполнение
проверок и отчёт. Автору необходимо понимать решение для защиты;
памятка: [docs/defense.md](docs/defense.md).
+48
View File
@@ -0,0 +1,48 @@
name: vp-lab2
services:
api:
build: .
ports:
- "127.0.0.1:8080:8080"
environment:
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL: redis://redis:6379/0
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
secrets: [database_url]
depends_on:
db:
condition: service_healthy
healthcheck:
test: [CMD, python, -c, "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready', timeout=5)"]
interval: 5s
timeout: 6s
retries: 12
mem_limit: 512m
cpus: 2
db:
image: postgres:16.6-bookworm
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/db_password
secrets: [db_password]
volumes: [pgdata:/var/lib/postgresql/data]
healthcheck:
test: [CMD-SHELL, "pg_isready -U messenger -d messenger"]
interval: 3s
timeout: 3s
retries: 20
mem_limit: 512m
cpus: 1
redis:
image: redis:7.4.1-bookworm
command: [redis-server, --maxmemory, 64mb, --maxmemory-policy, allkeys-lru, --save, "", --appendonly, "no"]
mem_limit: 128m
cpus: 0.5
volumes:
pgdata:
secrets:
db_password:
file: ./secrets/db_password
database_url:
file: ./secrets/database_url
+48
View File
@@ -0,0 +1,48 @@
# Коротко для защиты
## Что реализовано
REST-мессенджер без интерфейса: регистрация, вход, чаты, сообщения, история,
выход. Flask принимает HTTP, PostgreSQL хранит данные, Redis ускоряет чтение
публичного профиля. Контракт лабораторной 2 сохранён.
## Основные вопросы
**Почему PostgreSQL, а не словарь в Python?** Словарь пропадёт при перезапуске
и будет разным у разных процессов. PostgreSQL сохраняет подтверждённые записи
в WAL; именованный Docker volume сохраняет файлы при пересоздании контейнера.
**Что означает COMMIT?** Транзакция завершена. При стандартных fsync=on и
synchronous_commit=on PostgreSQL ждёт записи WAL. Это не резервная копия:
потеря диска/volume или всего компьютера всё ещё может уничтожить данные.
**Аутентификация и авторизация?** Bearer-сессия отвечает «кто ты», членство в
чате — «доступен ли тебе этот чат». Чужой чат возвращает 404, чтобы не выдавать
его существование. Переданный X-User-Id игнорируется.
**Что хранится вместо пароля?** Argon2id с солью, 19 MiB памяти, два прохода,
parallelism=1. Соль хранится в кодированной строке вместе с параметрами.
SHA-256 здесь непригоден для пароля: слишком быстро перебирается.
Для случайного токена с 256 битами энтропии SHA-256 допустим.
**Почему Basic только при входе?** Basic передаёт кодированный username:password.
После входа клиент получает случайный Bearer token. Ни Basic, ни Bearer сами
по себе не шифруют сеть; стенд слушает только loopback, вне ноутбука нужен TLS.
**Что при flush или остановке Redis?** Исчезает только кэш профилей. Проверка
сессии и её expiry идёт в PostgreSQL на каждом запросе. Профиль читается из БД.
Сессии не становятся бессрочными, отозванный токен не оживает.
**Зачем составной индекс?** WHERE ограничивает chat_id; далее индекс уже
упорядочен по created_at,id. Можно начать после cursor и прочитать 51 запись,
вместо пропуска тысяч строк через OFFSET. UUID разрешает совпадения времени.
**Почему создание чата атомарно?** Вставка чата и всех членов находится в одной
транзакции. Ошибка последнего FK откатывает также чат и предыдущих членов.
**Что обеспечивает гонку регистрации?** UNIQUE(username) в БД. Проверка
SELECT перед INSERT сама по себе была бы недостаточна: два потока могли бы
одновременно увидеть отсутствие имени. Один INSERT проходит, остальные — 409.
**Что ещё не production-ready?** Нет HA БД, backup, rate limiting, очистки
истёкших сессий, TLS и ротации секретов. Это предмет следующих улучшений.
+38
View File
@@ -0,0 +1,38 @@
# Схема и границы транзакций
План до реализации SQL: пользователи → участники ← чаты → сообщения;
пользователи → сессии. PostgreSQL — источник истины всех этих данных.
UUID назначает приложение, UTC-время — PostgreSQL. Пароль — Argon2id;
сессия содержит только SHA-256 случайного 256-битного токена и абсолютный expiry.
Ограничения: PK у объектов, UNIQUE username, составной PK членства,
FK сообщений на чат и членство отправителя, NOT NULL и ограничения длины.
Индексы: members(user_id,chat_id) для списка чатов;
messages(chat_id,created_at,id) для истории; sessions(token_hash) для входа.
Транзакции: регистрация; создание сессии; отзыв сессии; создание чата вместе
со всеми участниками; запись сообщения. Ответ 201 формируется после COMMIT.
Ошибка FK участника откатывает чат и уже вставленных участников.
Уникальность username разрешает гонку на уровне БД, проигравший получает 409.
Миграции сериализованы advisory lock, версия и checksum сохраняются в БД.
История: keyset `(created_at,id) > (...)`, LIMIT n+1, без OFFSET. Cursor содержит
область запроса (чат либо пользователь списка чатов), время и UUID. Cursor не
предоставляет права доступа. Каждое чтение повторно проверяет членство.
READ COMMITTED не даёт snapshot между страницами: поздно завершившаяся вставка
с более ранним временем может оказаться позади cursor. Подтверждённые записи
видны новому чтению с начала истории; часы не заменяют уникальность UUID.
Redis кэширует только публичный неизменяемый профиль на 60 секунд. В API нет
редактирования профиля: инвалидация по TTL и версии ключа `profile:v1`.
Если добавить редактирование, понадобится отдельная стратегия инвалидации.
Авторизация всегда проверяет PostgreSQL, даже при cache hit. Logout удаляет
сессию из БД; кэш профиля не является доказательством входа. Redis не требует
persistence: cache miss/рестарт/отказ дают чтение из PostgreSQL. Socket timeout
Redis 0.2 с. Дополнительно wall timeout 0.25 с на GET/SET включает зависание DNS:
не более двух фоновых операций на worker, без очереди. При занятых слотах
кэш пропускается. История сообщений не кэшируется.
Пул: максимум 8 соединений на worker, 2 worker, очередь до 32 на worker,
ожидание до 3 секунд. connect/statement timeout 3 секунды, lock timeout 2.
Недоступная БД — 503, readiness — 503, liveness остаётся 200.
+1
View File
@@ -0,0 +1 @@
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+7
View File
@@ -0,0 +1,7 @@
{
"observed_at": "2026-11-19T07:45:37.469958+00:00",
"platform": "Windows-11-10.0.26200-SP0",
"cpu": "Intel64 Family 6 Model 186 Stepping 2, GenuineIntel",
"logical_cpus": 16,
"python": "3.12.3"
}
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.141,
"concurrency": 4,
"successful_requests": 6843,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 227.033,
"successful_latency_ms": {
"p50": 16.0,
"p95": 32.0,
"p99": 47.0
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.141,
"concurrency": 4,
"successful_requests": 6843,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 227.033,
"successful_latency_ms": {
"p50": 16.0,
"p95": 32.0,
"p99": 47.0
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+2
View File
@@ -0,0 +1,2 @@
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
+79
View File
@@ -0,0 +1,79 @@
{
"dataset_messages": 12000,
"cursor_position": 10001,
"page_size_with_lookahead": 51,
"plan": [
{
"Plan": {
"Node Type": "Limit",
"Parallel Aware": false,
"Async Capable": false,
"Startup Cost": 0.29,
"Total Cost": 9.88,
"Plan Rows": 51,
"Plan Width": 69,
"Actual Startup Time": 0.034,
"Actual Total Time": 0.07,
"Actual Rows": 51,
"Actual Loops": 1,
"Shared Hit Blocks": 4,
"Shared Read Blocks": 0,
"Shared Dirtied Blocks": 0,
"Shared Written Blocks": 0,
"Local Hit Blocks": 0,
"Local Read Blocks": 0,
"Local Dirtied Blocks": 0,
"Local Written Blocks": 0,
"Temp Read Blocks": 0,
"Temp Written Blocks": 0,
"Plans": [
{
"Node Type": "Index Scan",
"Parent Relationship": "Outer",
"Parallel Aware": false,
"Async Capable": false,
"Scan Direction": "Forward",
"Index Name": "messages_history",
"Relation Name": "messages",
"Alias": "messages",
"Startup Cost": 0.29,
"Total Cost": 376.82,
"Plan Rows": 2002,
"Plan Width": 69,
"Actual Startup Time": 0.031,
"Actual Total Time": 0.055,
"Actual Rows": 51,
"Actual Loops": 1,
"Index Cond": "((chat_id = 'eae5d1d7-e003-4d8c-a4c1-f37ad80710a2'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:00.010001+00'::timestamp with time zone, 'f0612713-b9fe-4956-aa1c-cf82a0a2b6d1'::uuid)))",
"Rows Removed by Index Recheck": 0,
"Shared Hit Blocks": 4,
"Shared Read Blocks": 0,
"Shared Dirtied Blocks": 0,
"Shared Written Blocks": 0,
"Local Hit Blocks": 0,
"Local Read Blocks": 0,
"Local Dirtied Blocks": 0,
"Local Written Blocks": 0,
"Temp Read Blocks": 0,
"Temp Written Blocks": 0
}
]
},
"Planning": {
"Shared Hit Blocks": 6,
"Shared Read Blocks": 0,
"Shared Dirtied Blocks": 0,
"Shared Written Blocks": 0,
"Local Hit Blocks": 0,
"Local Read Blocks": 0,
"Local Dirtied Blocks": 0,
"Local Written Blocks": 0,
"Temp Read Blocks": 0,
"Temp Written Blocks": 0
},
"Planning Time": 0.444,
"Triggers": [],
"Execution Time": 0.278
}
]
}
+30
View File
@@ -0,0 +1,30 @@
[
{
"at": "2026-11-19T07:45:07.042984+00:00",
"stats": "vp-lab2-api-1: CPU=51.83% RAM=191.3MiB / 512MiB\nvp-lab2-db-1: CPU=30.30% RAM=36.62MiB / 512MiB\nvp-lab2-redis-1: CPU=0.35% RAM=8.184MiB / 128MiB"
},
{
"at": "2026-11-19T07:45:11.716348+00:00",
"stats": "vp-lab2-api-1: CPU=129.85% RAM=191.4MiB / 512MiB\nvp-lab2-db-1: CPU=31.61% RAM=36.92MiB / 512MiB\nvp-lab2-redis-1: CPU=0.30% RAM=8.309MiB / 128MiB"
},
{
"at": "2026-11-19T07:45:16.440752+00:00",
"stats": "vp-lab2-api-1: CPU=120.48% RAM=198.5MiB / 512MiB\nvp-lab2-db-1: CPU=28.59% RAM=37.76MiB / 512MiB\nvp-lab2-redis-1: CPU=0.30% RAM=8.18MiB / 128MiB"
},
{
"at": "2026-11-19T07:45:21.214682+00:00",
"stats": "vp-lab2-api-1: CPU=116.05% RAM=194.3MiB / 512MiB\nvp-lab2-db-1: CPU=36.85% RAM=38.11MiB / 512MiB\nvp-lab2-redis-1: CPU=0.34% RAM=8.312MiB / 128MiB"
},
{
"at": "2026-11-19T07:45:26.096036+00:00",
"stats": "vp-lab2-api-1: CPU=110.50% RAM=194.3MiB / 512MiB\nvp-lab2-db-1: CPU=32.46% RAM=38.22MiB / 512MiB\nvp-lab2-redis-1: CPU=0.46% RAM=8.184MiB / 128MiB"
},
{
"at": "2026-11-19T07:45:30.786451+00:00",
"stats": "vp-lab2-api-1: CPU=106.21% RAM=194.3MiB / 512MiB\nvp-lab2-db-1: CPU=25.58% RAM=39.02MiB / 512MiB\nvp-lab2-redis-1: CPU=0.49% RAM=8.184MiB / 128MiB"
},
{
"at": "2026-11-19T07:45:35.469509+00:00",
"stats": "vp-lab2-api-1: CPU=97.16% RAM=194.4MiB / 512MiB\nvp-lab2-db-1: CPU=25.32% RAM=39.2MiB / 512MiB\nvp-lab2-redis-1: CPU=0.35% RAM=8.184MiB / 128MiB"
}
]
+42
View File
@@ -0,0 +1,42 @@
{
"before": [
{
"name": "/vp-lab2-api-1",
"id": "51df1ca0997fb8365713bda1153f7b7ebef1318d8fe7ae6114cc4279bd83114f",
"started_at": "2026-11-19T07:44:22.242015528Z",
"image": "vp-lab2-api"
},
{
"name": "/vp-lab2-db-1",
"id": "a4de1828985dbb6c23694508e62dbd58e8fac0c8227dbee0b86af55b7f6d7296",
"started_at": "2026-11-19T07:40:10.782456786Z",
"image": "postgres:16.6-bookworm"
},
{
"name": "/vp-lab2-redis-1",
"id": "cdd92a6517e3be5377b268f66e5ddf3ac650e3e60c87ef091555f25dc25e7440",
"started_at": "2026-11-19T07:41:58.069227011Z",
"image": "redis:7.4.1-bookworm"
}
],
"after": [
{
"name": "/vp-lab2-api-1",
"id": "51df1ca0997fb8365713bda1153f7b7ebef1318d8fe7ae6114cc4279bd83114f",
"started_at": "2026-11-19T07:44:33.62888078Z",
"image": "vp-lab2-api"
},
{
"name": "/vp-lab2-db-1",
"id": "a4de1828985dbb6c23694508e62dbd58e8fac0c8227dbee0b86af55b7f6d7296",
"started_at": "2026-11-19T07:44:33.00388505Z",
"image": "postgres:16.6-bookworm"
},
{
"name": "/vp-lab2-redis-1",
"id": "cdd92a6517e3be5377b268f66e5ddf3ac650e3e60c87ef091555f25dc25e7440",
"started_at": "2026-11-19T07:44:33.018097101Z",
"image": "redis:7.4.1-bookworm"
}
]
}
+1
View File
@@ -0,0 +1 @@
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+42
View File
@@ -0,0 +1,42 @@
[
{
"test": "concurrent registration: one 201, seven 409",
"result": "PASS"
},
{
"test": "foreign-key failure rolls back chat and first member",
"result": "PASS"
},
{
"test": "strict payload validation and authentication before resource access",
"result": "PASS"
},
{
"test": "keyset pagination, changing limit, cross-chat cursor rejection",
"result": "PASS"
},
{
"test": "equal timestamps use UUID tie breaker",
"result": "PASS"
},
{
"test": "Unicode/colon password, wrong password, cache TTL and logout with warm cache",
"result": "PASS"
},
{
"test": "Redis outage falls back safely and cache recovers",
"result": "PASS"
},
{
"test": "DB outage fails closed with 503; same session works after recovery",
"result": "PASS"
},
{
"test": "SESSION_TTL_SECONDS=2 expires a warm-cache session",
"result": "PASS"
},
{
"test": "migrations are repeatable without duplicate data",
"result": "PASS"
}
]
+10
View File
@@ -0,0 +1,10 @@
PASS: concurrent registration: one 201, seven 409
PASS: foreign-key failure rolls back chat and first member
PASS: strict payload validation and authentication before resource access
PASS: keyset pagination, changing limit, cross-chat cursor rejection
PASS: equal timestamps use UUID tie breaker
PASS: Unicode/colon password, wrong password, cache TTL and logout with warm cache
PASS: Redis outage falls back safely and cache recovers
PASS: DB outage fails closed with 503; same session works after recovery
PASS: SESSION_TTL_SECONDS=2 expires a warm-cache session
PASS: migrations are repeatable without duplicate data
+34
View File
@@ -0,0 +1,34 @@
CREATE TABLE users (
id uuid PRIMARY KEY,
username varchar(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name varchar(100) NOT NULL CHECK (length(trim(display_name)) > 0),
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title varchar(100) NOT NULL CHECK (length(trim(title)) > 0),
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 INDEX chats_history ON chats(created_at, id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id),
sender_id uuid NOT NULL REFERENCES users(id),
text varchar(4000) NOT NULL CHECK (length(trim(text)) > 0),
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 char(64) PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users(id),
expires_at timestamptz NOT NULL
);
CREATE INDEX sessions_expiry ON sessions(expires_at);
+19
View File
@@ -0,0 +1,19 @@
Flask==3.1.0
gunicorn==23.0.0
psycopg[binary,pool]==3.2.3
redis==5.2.1
argon2-cffi==23.1.0
# Transitive dependencies pinned to the verified Linux/Python 3.12 environment.
argon2-cffi-bindings==26.2.0
blinker==1.9.0
cffi==2.1.1
click==8.5.1
itsdangerous==2.2.0
Jinja2==3.1.6
MarkupSafe==3.0.4
packaging==26.3
psycopg-binary==3.2.3
psycopg-pool==3.3.3
pycparser==3.12
typing_extensions==4.16.0
Werkzeug==3.1.9
+21
View File
@@ -0,0 +1,21 @@
"""Create local synthetic secrets once; never overwrite existing credentials."""
import secrets
from pathlib import Path
root = Path(__file__).resolve().parents[1]
directory = root / 'secrets'
directory.mkdir(exist_ok=True)
password_file = directory / 'db_password'
if not password_file.exists():
with password_file.open('x', encoding='utf-8') as file:
file.write(secrets.token_urlsafe(32))
password = password_file.read_text(encoding='utf-8').strip()
url_file = directory / 'database_url'
if not url_file.exists():
with url_file.open('x', encoding='utf-8') as file:
file.write('postgresql://messenger:' + password + '@db:5432/messenger')
env = root / '.env'
if not env.exists():
with env.open('x', encoding='utf-8') as file:
file.write('SESSION_TTL_SECONDS=3600\n')
print('Local configuration ready; credentials are not printed.')
+30
View File
@@ -0,0 +1,30 @@
"""Real query-plan experiment with 12,000 messages; transaction rolls back fixtures."""
import json
import sys
import uuid
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from src.db import make_pool
pool = make_pool()
with pool.connection() as conn:
user_id, chat_id = uuid.uuid4(), uuid.uuid4()
conn.execute('INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s)',
(user_id, 'plan_' + uuid.uuid4().hex[:20], 'Synthetic EXPLAIN', 'no-login'))
conn.execute('INSERT INTO chats(id,title) VALUES (%s,%s)', (chat_id, 'EXPLAIN dataset'))
conn.execute('INSERT INTO members VALUES (%s,%s)', (chat_id, user_id))
conn.execute("INSERT INTO messages(id,chat_id,sender_id,text,created_at) "
"SELECT gen_random_uuid(),%s,%s,'message ' || n, "
"'2026-01-01'::timestamptz + n * interval '1 microsecond' "
"FROM generate_series(1,12000) n", (chat_id, user_id))
conn.execute('ANALYZE messages')
pivot = conn.execute('SELECT created_at,id FROM messages WHERE chat_id=%s '
'ORDER BY created_at,id OFFSET 10000 LIMIT 1', (chat_id,)).fetchone()
plan = conn.execute('EXPLAIN (ANALYZE,BUFFERS,FORMAT JSON) SELECT * FROM messages '
'WHERE chat_id=%s AND (created_at,id)>(%s,%s) '
'ORDER BY created_at,id LIMIT 51',
(chat_id, pivot['created_at'], pivot['id'])).fetchone()['QUERY PLAN']
print(json.dumps({'dataset_messages': 12000, 'cursor_position': 10001,
'page_size_with_lookahead': 51, 'plan': plan}, indent=2, default=str))
conn.rollback()
pool.close()
+3
View File
@@ -0,0 +1,3 @@
@echo off
cd /d "%~dp0.."
docker compose restart api db redis
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose restart api db redis
+77
View File
@@ -0,0 +1,77 @@
"""Run acceptance evidence on the local Compose stack; no secrets in artifacts."""
import json
import os
import platform
import subprocess
import sys
import time
from datetime import datetime, timezone
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
EVIDENCE = ROOT / 'evidence'
ENV = {**os.environ, 'PYTHONUTF8': '1',
'BASE_URL': os.environ.get('BASE_URL', 'http://127.0.0.1:8080')}
def run(args, artifact=None):
result = subprocess.run(args, cwd=ROOT, text=True, encoding='utf-8', errors='replace',
capture_output=True, env=ENV)
output = result.stdout + result.stderr
print(output, end='', flush=True)
if artifact:
(EVIDENCE / artifact).write_text(output, encoding='utf-8')
if result.returncode:
raise SystemExit(result.returncode)
return result.stdout
def containers():
ids = run(['docker', 'compose', 'ps', '-q']).split()
result = subprocess.run(['docker', 'inspect', *ids], cwd=ROOT, text=True,
capture_output=True, check=True)
return [{'name': item['Name'], 'id': item['Id'],
'started_at': item['State']['StartedAt'], 'image': item['Config']['Image']}
for item in json.loads(result.stdout)]
def main():
run([sys.executable, 'scripts/check_contract.py'], 'contract.txt')
run([sys.executable, 'tests/smoke.py'], 'smoke.txt')
before = containers()
hook = 'scripts/restart.cmd' if os.name == 'nt' else 'scripts/restart.sh'
run([sys.executable, 'tests/resilience.py', '--mode', 'persistence',
'--action-script', hook], 'persistence.txt')
after = containers()
prior = {item['id']: item for item in before}
assert len(after) == 3 and all(item['id'] in prior and
item['started_at'] != prior[item['id']]['started_at']
for item in after), 'All three containers must really restart'
(EVIDENCE / 'restart.json').write_text(json.dumps({'before': before, 'after': after}, indent=2), encoding='utf-8')
run([sys.executable, 'student-tests/acceptance.py'], 'student-tests.txt')
run(['docker', 'compose', 'exec', '-T', 'api', 'python', 'scripts/explain.py'], 'query-plan.json')
process = subprocess.Popen([sys.executable, 'tests/load.py', '--duration', '30', '--concurrency', '4',
'--output', 'evidence/load.json'], cwd=ROOT,
stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
text=True, encoding='utf-8', env=ENV)
ids = [item['id'] for item in after]
samples = []
while process.poll() is None:
stats = subprocess.run(['docker', 'stats', '--no-stream', '--format',
'{{.Name}}: CPU={{.CPUPerc}} RAM={{.MemUsage}}', *ids],
capture_output=True, text=True, check=True)
samples.append({'at': datetime.now(timezone.utc).isoformat(), 'stats': stats.stdout.strip()})
time.sleep(2)
output = process.communicate()[0]
print(output, end='', flush=True)
(EVIDENCE / 'load.txt').write_text(output, encoding='utf-8')
(EVIDENCE / 'resources.json').write_text(json.dumps(samples, indent=2), encoding='utf-8')
if process.returncode:
raise SystemExit(process.returncode)
system = {'observed_at': datetime.now(timezone.utc).isoformat(), 'platform': platform.platform(),
'cpu': platform.processor(), 'logical_cpus': os.cpu_count(), 'python': platform.python_version()}
(EVIDENCE / 'environment.json').write_text(json.dumps(system, indent=2), encoding='utf-8')
if __name__ == '__main__':
main()
View File
+369
View File
@@ -0,0 +1,369 @@
"""Lab 2 API: PostgreSQL is authoritative; Redis caches immutable public profiles."""
import base64
import binascii
import hashlib
import json
import os
import re
import secrets
import uuid
from concurrent.futures import ThreadPoolExecutor, TimeoutError as FutureTimeout
from datetime import datetime
from threading import BoundedSemaphore
import psycopg
import redis
from argon2 import PasswordHasher
from argon2.exceptions import VerificationError
from flask import Flask, g, jsonify, request
from psycopg_pool import PoolTimeout, TooManyRequests
from werkzeug.exceptions import HTTPException
from src.db import make_pool, setting
app = Flask(__name__)
app.config['MAX_CONTENT_LENGTH'] = 65536
pool = make_pool()
cache = redis.Redis.from_url(setting('CACHE_URL'), socket_connect_timeout=0.2,
socket_timeout=0.2, decode_responses=True)
cache_executor = ThreadPoolExecutor(max_workers=2, thread_name_prefix='cache')
cache_slots = BoundedSemaphore(2)
hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
dummy_hash = hasher.hash(secrets.token_urlsafe(32))
SESSION_TTL = int(os.getenv('SESSION_TTL_SECONDS', '3600'))
if SESSION_TTL < 1:
raise ValueError('SESSION_TTL_SECONDS must be positive')
USER_FIELDS = 'id, username, display_name, created_at'
class APIError(Exception):
def __init__(self, status, code, message, challenge=None):
self.status, self.code, self.message, self.challenge = status, code, message, challenge
def invalid():
raise APIError(400, 'invalid_request', 'Invalid request')
def unauthorized(basic=False):
challenge = 'Basic realm="messenger", charset="UTF-8"' if basic else 'Bearer realm="messenger"'
raise APIError(401, 'unauthorized', 'Authentication required', challenge)
def serial(value):
if isinstance(value, dict):
return {key: serial(item) for key, item in value.items()}
if isinstance(value, list):
return [serial(item) for item in value]
if isinstance(value, uuid.UUID):
return str(value)
if isinstance(value, datetime):
return value.isoformat().replace('+00:00', 'Z')
return value
def response(value, status=200):
return jsonify(serial(value)), status
@app.before_request
def identify_request():
g.request_id = uuid.uuid4().hex
@app.after_request
def headers(result):
result.headers['X-Request-Id'] = g.request_id
result.headers['Cache-Control'] = 'no-store'
return result
@app.errorhandler(Exception)
def error(exc):
if isinstance(exc, APIError):
problem = exc
elif isinstance(exc, psycopg.errors.UniqueViolation):
problem = APIError(409, 'conflict', 'Username already exists')
elif isinstance(exc, psycopg.errors.ForeignKeyViolation):
problem = APIError(400, 'invalid_request', 'Invalid member list')
elif isinstance(exc, (psycopg.OperationalError, PoolTimeout, TooManyRequests,
psycopg.errors.QueryCanceled, psycopg.errors.LockNotAvailable)):
problem = APIError(503, 'unavailable', 'Database temporarily unavailable')
elif isinstance(exc, HTTPException):
status = exc.code if exc.code in (400, 404, 413, 415) else 400
code = {400: 'invalid_request', 404: 'not_found', 413: 'payload_too_large',
415: 'unsupported_media_type'}[status]
problem = APIError(status, code, 'Request cannot be processed')
else:
app.logger.error('Unhandled error type=%s request_id=%s', type(exc).__name__, g.request_id)
problem = APIError(500, 'internal_error', 'Internal error')
result = jsonify(error={'code': problem.code, 'message': problem.message,
'request_id': g.request_id})
result.status_code = problem.status
if problem.challenge:
result.headers['WWW-Authenticate'] = problem.challenge
return result
def body(fields):
if request.mimetype != 'application/json':
raise APIError(415, 'unsupported_media_type', 'Expected application/json')
value = request.get_json()
if not isinstance(value, dict) or set(value) != set(fields):
invalid()
return value
def string(value, minimum, maximum):
if not isinstance(value, str) or not minimum <= len(value) <= maximum or not value.strip():
invalid()
try:
value.encode('utf-8')
except UnicodeError:
invalid()
if '\x00' in value:
invalid()
return value
def uid(value):
try:
if not isinstance(value, str) or not re.fullmatch(
r'[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}', value):
invalid()
return uuid.UUID(value)
except ValueError:
invalid()
def cached_operation(operation, *args, **kwargs):
# Socket timeouts do not bound DNS resolution when a Compose service is down.
# At most two background operations per worker, no unbounded queue.
if not cache_slots.acquire(blocking=False):
return None
future = cache_executor.submit(operation, *args, **kwargs)
future.add_done_callback(lambda _: cache_slots.release())
try:
return future.result(timeout=0.25)
except (redis.RedisError, FutureTimeout):
return None
def profile(conn, user_id):
key = 'profile:v1:' + str(user_id)
cached = cached_operation(cache.get, key)
if cached:
try:
return json.loads(cached)
except ValueError:
pass
user = serial(conn.execute('SELECT ' + USER_FIELDS + ' FROM users WHERE id=%s',
(user_id,)).fetchone())
if user is None:
unauthorized()
cached_operation(cache.set, key, json.dumps(user), ex=60)
return user
def actor(conn):
auth = request.headers.get('Authorization', '').split()
if len(auth) != 2 or auth[0].lower() != 'bearer' or len(auth[1]) > 256:
unauthorized()
digest = hashlib.sha256(auth[1].encode()).hexdigest()
session = conn.execute('SELECT user_id FROM sessions WHERE token_hash=%s '
'AND expires_at > clock_timestamp()', (digest,)).fetchone()
if not session:
unauthorized()
g.token_hash = digest
return session['user_id']
def chat_access(conn, chat_id, user_id):
chat = 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 not chat:
raise APIError(404, 'not_found', 'Resource not found')
return chat
def chat_members(conn, chat):
chat['member_ids'] = [row['user_id'] for row in conn.execute(
'SELECT user_id FROM members WHERE chat_id=%s ORDER BY user_id', (chat['id'],))]
return chat
def page_args(scope):
limit = request.args.get('limit', '50')
if not re.fullmatch(r'[0-9]{1,3}', limit) or not 1 <= int(limit) <= 100:
invalid()
cursor = request.args.get('cursor')
after = None
if cursor is not None:
try:
if len(cursor) > 1024:
invalid()
data = json.loads(base64.b64decode(cursor, altchars=b'-_', validate=True))
if not isinstance(data, list) or len(data) != 3 or data[0] != scope:
invalid()
date = datetime.fromisoformat(data[1])
if date.tzinfo is None:
invalid()
after = (date, uid(data[2]))
except (ValueError, TypeError, binascii.Error):
invalid()
return int(limit), after
def page(rows, limit, scope):
more = len(rows) > limit
items = rows[:limit]
cursor = None
if more:
last = serial(items[-1])
cursor = base64.urlsafe_b64encode(json.dumps(
[scope, last['created_at'], last['id']]).encode()).decode()
return {'items': items, 'next_cursor': cursor}
@app.get('/health/live')
def live():
return response({'status': 'ok'})
@app.get('/health/ready')
def ready():
with pool.connection() as conn:
conn.execute('SELECT 1 FROM schema_migrations LIMIT 1')
return response({'status': 'ok'})
@app.post('/api/v1/users')
def register():
data = body(('username', 'display_name', 'password'))
name = string(data['username'], 3, 32)
if not re.fullmatch('[a-z0-9_]{3,32}', name):
invalid()
display = string(data['display_name'], 1, 100)
password = string(data['password'], 12, 128)
encoded = hasher.hash(password)
with pool.connection() as conn:
user = conn.execute('INSERT INTO users (id,username,display_name,password_hash) '
'VALUES (%s,%s,%s,%s) RETURNING ' + USER_FIELDS,
(uuid.uuid4(), name, display, encoded)).fetchone()
return response(user, 201)
@app.post('/api/v1/auth/sessions')
def login():
auth = request.headers.get('Authorization', '').split()
if len(auth) != 2 or auth[0].lower() != 'basic' or len(auth[1]) > 2048:
unauthorized(True)
try:
name, password = base64.b64decode(auth[1], validate=True).decode('utf-8').split(':', 1)
except (ValueError, UnicodeError, binascii.Error):
unauthorized(True)
if not re.fullmatch('[a-z0-9_]{3,32}', name) or not 12 <= len(password) <= 128:
unauthorized(True)
if request.get_data():
invalid()
with pool.connection() as conn:
user = conn.execute('SELECT * FROM users WHERE username=%s', (name,)).fetchone()
try:
hasher.verify(user['password_hash'] if user else dummy_hash, password)
except VerificationError:
unauthorized(True)
if not user:
unauthorized(True)
token = secrets.token_urlsafe(32)
with pool.connection() as conn:
expiry = conn.execute('INSERT INTO sessions VALUES (%s,%s,clock_timestamp() '
'+ %s * interval \'1 second\') RETURNING expires_at',
(hashlib.sha256(token.encode()).hexdigest(), user['id'],
SESSION_TTL)).fetchone()['expires_at']
user.pop('password_hash')
return response({'token': token, 'token_type': 'Bearer', 'expires_at': expiry, 'user': user}, 201)
@app.delete('/api/v1/auth/sessions/current')
def logout():
with pool.connection() as conn:
actor(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:
user = profile(conn, actor(conn))
return response(user)
@app.post('/api/v1/chats')
def create_chat():
with pool.connection() as conn:
user = actor(conn)
data = body(('title', 'member_ids'))
title = string(data['title'], 1, 100)
if not isinstance(data['member_ids'], list) or not 1 <= len(data['member_ids']) <= 100:
invalid()
members = [uid(item) for item in data['member_ids']]
if len(set(members)) != len(members) or user not in members:
invalid()
chat = conn.execute('INSERT INTO chats(id,title) VALUES (%s,%s) RETURNING *',
(uuid.uuid4(), title)).fetchone()
for member in members:
conn.execute('INSERT INTO members VALUES (%s,%s)', (chat['id'], member))
chat['member_ids'] = sorted(members)
return response(chat, 201)
@app.get('/api/v1/chats')
def list_chats():
with pool.connection() as conn:
user = actor(conn)
scope = 'chats:' + str(user)
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'
params = [user]
if after:
sql += ' AND (c.created_at,c.id) > (%s,%s)'
params.extend(after)
rows = conn.execute(sql + ' ORDER BY c.created_at,c.id LIMIT %s', params + [limit+1]).fetchall()
result = page(rows, limit, scope)
for chat in result['items']:
chat_members(conn, chat)
return response(result)
@app.get('/api/v1/chats/<chat_id>')
def get_chat(chat_id):
with pool.connection() as conn:
user = actor(conn)
result = chat_members(conn, chat_access(conn, uid(chat_id), user))
return response(result)
@app.route('/api/v1/chats/<chat_id>/messages', methods=['GET', 'POST'])
def messages(chat_id):
with pool.connection() as conn:
user = actor(conn)
chat_id = uid(chat_id)
chat_access(conn, chat_id, user)
if request.method == 'POST':
text = string(body(('text',))['text'], 1, 4000)
result = conn.execute('INSERT INTO messages(id,chat_id,sender_id,text) '
'VALUES (%s,%s,%s,%s) RETURNING *',
(uuid.uuid4(), chat_id, user, text)).fetchone()
status = 201
else:
scope = 'messages:' + str(chat_id)
limit, after = page_args(scope)
sql = 'SELECT * FROM messages WHERE chat_id=%s'
params = [chat_id]
if after:
sql += ' AND (created_at,id) > (%s,%s)'
params.extend(after)
rows = conn.execute(sql + ' ORDER BY created_at,id LIMIT %s', params + [limit+1]).fetchall()
result, status = page(rows, limit, scope), 200
return response(result, status)
+52
View File
@@ -0,0 +1,52 @@
"""Bounded PostgreSQL pool and serialized, versioned migrations."""
import hashlib
import os
import time
from pathlib import Path
import psycopg
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
def setting(name):
path = os.getenv(name + '_FILE')
return Path(path).read_text().strip() if path else os.environ[name]
def migrate():
with psycopg.connect(setting('DATABASE_URL'), connect_timeout=3) as conn:
conn.execute('SELECT pg_advisory_xact_lock(202602)')
conn.execute('CREATE TABLE IF NOT EXISTS schema_migrations '
'(version text PRIMARY KEY, checksum text NOT NULL)')
for file in sorted(Path('migrations').glob('*.sql')):
sql = file.read_text(encoding='utf-8')
digest = hashlib.sha256(sql.encode()).hexdigest()
row = conn.execute('SELECT checksum FROM schema_migrations WHERE version=%s',
(file.name,)).fetchone()
if row:
if row[0] != digest:
raise RuntimeError('Applied migration changed')
continue
conn.execute(sql)
conn.execute('INSERT INTO schema_migrations VALUES (%s,%s)', (file.name, digest))
def make_pool():
return ConnectionPool(setting('DATABASE_URL'), min_size=1, max_size=8,
timeout=3, max_waiting=32,
check=ConnectionPool.check_connection,
kwargs={'connect_timeout': 3, 'row_factory': dict_row,
'options': '-c statement_timeout=3000 -c lock_timeout=2000'})
if __name__ == '__main__':
for attempt in range(30):
try:
migrate()
break
except psycopg.OperationalError:
if attempt == 29:
raise RuntimeError('Database did not become available') from None
time.sleep(2)
print('Migrations applied successfully')
+164
View File
@@ -0,0 +1,164 @@
"""Additional black-box checks. Run against this repository's synthetic stack."""
import base64
import json
import subprocess
import sys
import time
import uuid
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, check
def docker(*args, input=None):
result = subprocess.run(['docker', 'compose', *args], cwd=ROOT, input=input,
text=True, capture_output=True, timeout=120)
check(result.returncode == 0, 'Docker operation failed: ' + ' '.join(args[:2]))
return result.stdout.strip()
def sql(query):
return docker('exec', '-T', 'db', 'psql', '-U', 'messenger', '-d', 'messenger',
'-At', '-v', 'ON_ERROR_STOP=1', input=query)
def wait_ready(client):
end = time.monotonic() + 90
while time.monotonic() < end:
try:
client.call('GET', '/health/ready', schema='Health')
return
except Exception:
time.sleep(0.5)
raise AssertionError('API did not recover')
def main():
c = Client()
results = []
def passed(name):
results.append({'test': name, 'result': 'PASS'})
print('PASS:', name, flush=True)
alice, bob, eve, chat = c.bootstrap()
endpoint = '/api/v1/chats/' + chat['id'] + '/messages'
registration = {'username': 'race_' + uuid.uuid4().hex[:16],
'display_name': 'Гонка', 'password': 'Synthetic:пароль-1234'}
def register(_):
return Client().call('POST', '/api/v1/users', [201, 409], body=registration)['status']
with ThreadPoolExecutor(max_workers=8) as executor:
codes = list(executor.map(register, range(8)))
check(codes.count(201) == 1 and codes.count(409) == 7, 'Registration race')
passed('concurrent registration: one 201, seven 409')
before = sql('SELECT (SELECT count(*) FROM chats), (SELECT count(*) FROM members);')
c.call('POST', '/api/v1/chats', 400, actor=alice,
body={'title': 'Rollback', 'member_ids': [alice['id'], str(uuid.uuid4())]})
after = sql('SELECT (SELECT count(*) FROM chats), (SELECT count(*) FROM members);')
check(before == after, 'Partial chat or membership committed')
passed('foreign-key failure rolls back chat and first member')
for bad in ({'text': ' '}, {'text': 42}, {'text': 'x', 'sender_id': eve['id']},
{'text': 'x' * 4001}):
c.call('POST', endpoint, 400, actor=alice, body=bad)
c.call('POST', endpoint, 400, actor=alice, raw=b'{broken',
headers={'Content-Type': 'application/json'})
c.call('POST', endpoint, 415, actor=alice, raw=b'text',
headers={'Content-Type': 'text/plain'})
c.call('GET', '/api/v1/chats/bad/messages', 401)
c.call('GET', '/api/v1/chats/bad/messages', 400, actor=alice)
c.call('POST', endpoint, 404, actor=eve, body={'text': 'hidden'})
passed('strict payload validation and authentication before resource access')
messages = [c.message(alice, chat, 'Пагинация ' + str(i))['json'] for i in range(7)]
first = c.call('GET', endpoint + '?limit=2', actor=bob, schema='MessagePage')['json']
other = c.call('POST', '/api/v1/chats', 201, actor=alice,
body={'title': 'Другой', 'member_ids': [alice['id']]}, schema='Chat')['json']
from urllib.parse import quote
cursor = quote(first['next_cursor'], safe='')
c.call('GET', '/api/v1/chats/' + other['id'] + '/messages?cursor=' + cursor, 400, actor=alice)
collected = first['items']
while first['next_cursor']:
first = c.call('GET', endpoint + '?limit=3&cursor=' + quote(first['next_cursor'], safe=''),
actor=bob, schema='MessagePage')['json']
collected.extend(first['items'])
check(collected == messages, 'Pagination duplicated or skipped data')
passed('keyset pagination, changing limit, cross-chat cursor rejection')
# Identical timestamps exercise UUID as the second ordering component.
sql("UPDATE messages SET created_at='2026-01-01T00:00:00Z' WHERE chat_id='" + chat['id'] + "';")
current, collected = endpoint + '?limit=2', []
while current:
chunk = c.call('GET', current, actor=alice, schema='MessagePage')['json']
collected.extend(chunk['items'])
current = endpoint + '?limit=2&cursor=' + quote(chunk['next_cursor'], safe='') if chunk['next_cursor'] else None
check([x['id'] for x in collected] == sorted(x['id'] for x in messages), 'Timestamp tie pagination')
passed('equal timestamps use UUID tie breaker')
basic = base64.b64encode((registration['username'] + ':' + registration['password']).encode()).decode()
c.call('POST', '/api/v1/auth/sessions', 201, headers={'Authorization': 'Basic ' + basic}, schema='Session')
bad = base64.b64encode((registration['username'] + ':wrong-password-long').encode()).decode()
c.call('POST', '/api/v1/auth/sessions', 401, headers={'Authorization': 'Basic ' + bad})
c.call('GET', '/api/v1/users/me', actor=alice, schema='User')
ttl = int(docker('exec', '-T', 'redis', 'redis-cli', 'TTL', 'profile:v1:' + alice['id']))
check(0 < ttl <= 60, 'Redis profile cache has no bounded TTL')
c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=alice)
c.call('GET', '/api/v1/users/me', 401, actor=alice)
passed('Unicode/colon password, wrong password, cache TTL and logout with warm cache')
try:
docker('stop', 'redis')
start = time.monotonic()
c.call('GET', '/api/v1/users/me', actor=bob, schema='User')
check(time.monotonic() - start < 5, 'Unbounded Redis failure')
c.call('GET', '/api/v1/users/me', 401)
c.call('GET', '/health/ready', schema='Health')
finally:
docker('start', 'redis')
c.call('GET', '/api/v1/users/me', actor=bob, schema='User')
passed('Redis outage falls back safely and cache recovers')
try:
docker('stop', 'db')
start = time.monotonic()
c.call('GET', '/api/v1/users/me', 503, actor=bob)
check(time.monotonic() - start < 8, 'Unbounded DB failure')
c.call('GET', '/health/ready', 503)
c.call('GET', '/health/live', schema='Health')
finally:
docker('start', 'db')
wait_ready(c)
c.call('GET', '/api/v1/users/me', actor=bob, schema='User')
passed('DB outage fails closed with 503; same session works after recovery')
# A separate short-TTL process leaves the normal API configuration unchanged.
container = docker('run', '--rm', '-d', '--no-deps', '-p', '127.0.0.1:8081:8080',
'-e', 'SESSION_TTL_SECONDS=2', 'api')
try:
short = Client('http://127.0.0.1:8081')
wait_ready(short)
actor = short.user('expiry')
short.call('GET', '/api/v1/users/me', actor=actor, schema='User')
time.sleep(2.2)
short.call('GET', '/api/v1/users/me', 401, actor=actor)
finally:
subprocess.run(['docker', 'stop', container], check=True, capture_output=True, timeout=30)
passed('SESSION_TTL_SECONDS=2 expires a warm-cache session')
counts = sql('SELECT (SELECT count(*) FROM users), (SELECT count(*) FROM schema_migrations);')
docker('exec', '-T', 'api', 'python', '-m', 'src.db')
check(counts == sql('SELECT (SELECT count(*) FROM users), (SELECT count(*) FROM schema_migrations);'),
'Repeated migration changed data')
passed('migrations are repeatable without duplicate data')
(ROOT / 'evidence' / 'student-tests.json').write_text(
json.dumps(results, ensure_ascii=False, indent=2) + '\n', encoding='utf-8')
if __name__ == '__main__':
main()