ЛР 2 — БПИ-2304 — Саламатин — на 4

This commit is contained in:
User name
2026-10-31 02:44:10 +03:00
parent 65003b6119
commit 376f1a9a10
63 changed files with 2739 additions and 117 deletions
+9 -20
View File
@@ -1,20 +1,9 @@
.git
.github
.env
.env.*
!.env.example
secrets
certs
volumes
data
backups
*.key
*.pem
*.p12
*.pfx
*.jks
.venv
__pycache__
node_modules
evidence
.DS_Store
*
!Dockerfile
!requirements.txt
!app/
!app/*.py
!migrations/
!migrations/*.sql
!contracts/
!contracts/openapi.json
+6 -11
View File
@@ -1,11 +1,6 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
# python scripts/init_local.py creates .env and random local secret files.
# Never commit .env or secrets/.
COMPOSE_PROJECT_NAME=mtusi-lab2
API_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
+2
View File
@@ -0,0 +1,2 @@
*.sh text eol=lf
/migrations/*.sql text eol=lf
+17 -18
View File
@@ -1,18 +1,17 @@
## Лабораторная 2
Автор / группа: TODO
Целевая оценка (3/4/5): TODO
Трек 5, если заявлен: TODO
Что реализовано и что перенесено: TODO
Команды запуска из чистого clone: TODO
Результаты проверок и ссылка на REPORT.md: TODO
Ограничения / известные ошибки: TODO
Источники и использование ИИ: TODO
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
- [ ] make check и make test выполнены; приложен реальный вывод.
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
## Лабораторная 2
Автор / группа: Саламатин, БПИ-2304.
Целевая оценка: **4**. Треки на 5 не заявляются.
Мессенджер из lab1 перенесён на PostgreSQL: пользователи, чаты, участники и сообщения сохраняются после рестарта. Добавлены миграция, scrypt, Basic-вход, Bearer-сессии Redis с TTL и AOF `appendfsync always`, logout и Compose с именованными volumes. Пагинация истории использует составной индекс и keyset-запрос.
Запуск: `python scripts/init_local.py`, затем `python scripts/verify.py`. Версии, отдельные команды и описание архитектуры — в [REPORT.md](../REPORT.md). Публичные smoke/persistence и 8 собственных интеграционных тестов проходят; EXPLAIN на 10 000 сообщениях подтверждает Index Scan для начала, середины и поздней страницы. Выводы сохранены в `evidence/`.
Стенд рассчитан на локальные синтетические данные. Нет репликации PostgreSQL/Redis и восстановления после потери volume/host. Источники: задание lab2, собственная lab1, документация Psycopg, PostgreSQL и Redis; ссылки приведены в отчёте.
- [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [x] Контракт и публичные тесты не ослаблены.
- [x] make check и make test выполнены; приложен реальный вывод.
- [x] Сценарии отказов/безопасности своего уровня воспроизведены.
- [x] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
+26
View File
@@ -0,0 +1,26 @@
name: application
on: [push, pull_request]
permissions:
contents: read
jobs:
application:
runs-on: ubuntu-latest
timeout-minutes: 12
steps:
- uses: actions/checkout@v7
with:
persist-credentials: false
- name: Build stack and run acceptance checks
run: python3 scripts/verify.py --published-base-url http://127.0.0.1:8080
- name: Save sanitized check results
if: always()
uses: actions/upload-artifact@v7
with:
name: lab2-evidence
path: evidence/
- name: Stop local test stack
if: always()
run: docker compose --env-file .env down
+27
View File
@@ -0,0 +1,27 @@
FROM docker:28.5.1-cli AS docker_cli
FROM python:3.13.15-slim-bookworm AS runtime
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 \
APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt \
&& useradd --uid 10001 --create-home messenger
COPY app ./app
COPY migrations ./migrations
COPY contracts/openapi.json ./contracts/openapi.json
USER messenger
EXPOSE 8080
HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=5 \
CMD python -c "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.getenv('APP_PORT', '8080') + '/health/ready', timeout=2)"
CMD ["python", "-m", "app"]
# Optional test operator. The API image does not contain the Docker client/socket.
FROM runtime AS checks
USER root
COPY --from=docker_cli /usr/local/bin/docker /usr/local/bin/docker
COPY --from=docker_cli /usr/local/libexec/docker/cli-plugins/docker-compose /usr/local/libexec/docker/cli-plugins/docker-compose
RUN apt-get update && apt-get install -y --no-install-recommends make \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /checks
CMD ["make", "test-student"]
+33 -26
View File
@@ -1,26 +1,33 @@
PYTHON ?= python3
BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
check:
$(PYTHON) scripts/check_contract.py
validate:
$(PYTHON) scripts/validate_openapi.py
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
PYTHON ?= python3
BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
check:
$(PYTHON) scripts/check_contract.py
validate:
$(PYTHON) scripts/validate_openapi.py
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
.PHONY: test-student explain
test-student:
$(PYTHON) -m unittest discover -s student-tests -v
explain:
$(PYTHON) scripts/explain_history.py
+126 -37
View File
@@ -1,37 +1,126 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
# Отчёт — лабораторная 2
- Автор: Саламатин, БПИ-2304.
- Целевая оценка: **4**, включая все требования уровня 3. Исследовательские треки на 5 не заявляются.
- Проверено 31 октября 2026 года, Europe/Moscow. В JSON и времени контейнеров используется UTC.
- Задание: [mtusi2026/mtusi2026lab2](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2), предоставленный архив, контракт 1.2.0. README задания, содержимое `contracts/` и публичные `tests/` сохранены.
- Основа: собственная lab1 из `Lab1_Highload`, commit `0a931edce3bcd3c1130093b3dd5259f7b208cf2e`. Перенесены HTTP-маршруты, строгие модели, формат ошибок, request ID, проверка доступа и идея подписанного cursor. In-memory Store полностью заменён PostgreSQL/Redis; регистрация и идентификация изменены по контракту lab2.
- Локальный commit сборки из чистого clone зафиксирован в `evidence/clean-source.json`. Публикация fork/ветки и оформление PR выполняются отдельно.
## Запуск из чистого clone
Нужны Docker Desktop с Linux containers, Docker Compose и Python 3.13 для локальных вспомогательных скриптов. API и все его Python-зависимости собираются в контейнере; локальная установка PostgreSQL/Redis не требуется. На Linux подходит Docker Engine с Compose.
Версии: Python `3.13.15-slim-bookworm`, PostgreSQL `17.6-bookworm`, Redis `7.4.5-bookworm`; тестовый Docker CLI `28.5.1-cli`. FastAPI 0.141.1, Pydantic 2.13.5, Uvicorn 0.53.0, Psycopg 3.2.10, pool 3.2.6, redis-py 6.4.0. Прямые и транзитивные Python-зависимости закреплены в `requirements.txt`. Образы закреплены тегами версий; фактические image ID записаны в доказательствах.
Из корня полученного clone, PowerShell:
```powershell
python scripts/init_local.py
python scripts/verify.py
```
На этой машине вместо `python` доступен `D:\Labs_Highload\.tools\bin\python3.13.exe`:
```powershell
& 'D:\Labs_Highload\.tools\bin\python3.13.exe' scripts/init_local.py
& 'D:\Labs_Highload\.tools\bin\python3.13.exe' scripts/verify.py
```
`init_local.py` создаёт `.env`, случайные пароли PostgreSQL/Redis, DSN и ключ подписи cursor в `secrets/`. Значения не печатаются. Повторный запуск сохраняет секреты и нормализует окончания строк для Linux. В `.env` только имя Compose-проекта, опубликованный порт, окружение и TTL. Пароли/DSN передаются как Compose secrets, а не в образе. Не удалять секреты существующего стенда при сохранённых volumes.
`verify.py` собирает API и тестовый образ, поднимает зависимости, ждёт readiness, запускает публичные и собственные тесты, полный restart, отдельную проверку TTL=2, EXPLAIN и повтор миграций. Результаты сохраняются в `evidence/`; основной стенд остаётся запущенным. Проверка управляет только сервисами данного Compose-проекта. Существующий контейнер с именем временного TTL-теста не удаляется автоматически.
Отдельные команды:
```powershell
docker compose --env-file .env config --quiet
docker compose --env-file .env build api checks
docker compose --env-file .env up -d --wait
docker compose --env-file .env run --rm --no-deps checks make check
docker compose --env-file .env run --rm --no-deps checks make test
docker compose --env-file .env run --rm --no-deps checks make test-student
docker compose --env-file .env run --rm --no-deps checks make test-persistence ACTION_SCRIPT=scripts/restart.sh
docker compose --env-file .env run --rm --no-deps checks make explain
```
На Linux после clone: `chmod +x scripts/restart.sh`. `verify.py` также выполняет chmod перед публичным persistence-тестом. Контейнер `checks` содержит GNU Make и Docker CLI: это позволяет выполнять неизменённый Linux hook и тесты на Windows. Для управления рестартом ему подключён локальный Docker socket; сервис относится к профилю `tools`, не запускается с обычным `up` и завершается после проверки. Runtime API работает от пользователя `messenger`, без Docker CLI/socket.
API публикуется только на loopback, по умолчанию `127.0.0.1:8080`; PostgreSQL и Redis не имеют опубликованных портов. На проверявшейся Windows-машине порт 8080 сбрасывал соединения, поэтому в локальном `.env` выбран `API_PORT=18080`: `http://127.0.0.1:18080`. На этом порту curl и публичный HTTP-клиент проверяют опубликованный API. Основные проверки также идут из отдельного клиента к API по Docker-сети. Для дополнительного smoke с хоста: `python scripts/verify.py --published-base-url http://127.0.0.1:18080`. `APP_HOST=0.0.0.0` и `APP_PORT=8080` заданы внутри контейнера; `API_PORT` меняет только внешний порт. `APP_ENV` влияет на стартовый лог, `SESSION_TTL_SECONDS` — на новые сессии. Внутри контейнеров `SESSION_STORE=redis`, DSN и ключ читаются через `DATABASE_URL_FILE`, `CACHE_URL_FILE`, `CURSOR_KEY_FILE`.
Остановка с сохранением данных:
```powershell
docker compose --env-file .env stop
# Либо удалить контейнеры и сеть, сохранив volumes:
docker compose --env-file .env down
```
Только для намеренного уничтожения всех данных этого учебного стенда: `docker compose --env-file .env down --volumes`. Эта команда не используется ни в одном restart-тесте.
Отдельный job сборки и acceptance-проверок подготовлен в `.github/workflows/application.yml`. Он использует изолированный runner, создаёт локальные секреты и сохраняет только `evidence/`. На площадке workflow не запускался; локальный эквивалент выполнен из чистого clone. GitHub workflow — дополнительная возможность, локальные проверки от площадки не зависят.
## Архитектура и решения
Клиент → Uvicorn/FastAPI → PostgreSQL для пользователей, чатов, членства и сообщений; Redis для серверных сессий. Схема и транзакционные границы описаны в [docs/DATABASE.md](docs/DATABASE.md).
Миграция `001_initial.sql` создаёт PK/FK, UNIQUE username, ограничения длины и индексы. Сервис `migrate` применяет её до API. Версии и SHA-256 находятся в `schema_migrations`; advisory lock сериализует запуск. Перед checksum окончания строк нормализуются к LF, чтобы Windows checkout не менял версию SQL. Повтор миграции не меняет данные, изменённый ранее применённый SQL отклоняется.
Отдельно на существующей БД повторно применены временные LF- и CRLF-копии одного SQL: обе распознаны как Unchanged, версия, checksum и applied_at не изменились. Результат — `evidence/migration-newlines.txt`.
Все значения SQL передаются параметрами. Пул PostgreSQL ограничен 10 соединениями и очередью 20 запросов. Ожидание пула 1 s, соединения 2 s, SQL 2 s, блокировки 1 s; keepalive и TCP_USER_TIMEOUT ограничивают сетевые зависания. У Redis максимум 10 соединений, connect/read timeout 1 s, повторов команд нет. Общий бюджет обработки HTTP — 5 s. Занятый/недоступный сервис даёт 503 без SQL, DSN и stack trace в ответе.
Регистрация сохраняет scrypt-хеш с независимой 128-битной солью: N=16384, r=8, p=1, выход 32 байта. Вычисление вынесено из event loop, одновременно выполняются максимум четыре KDF. UTF-8 пароль длиной 128 code points, включая двоеточие и многобайтовые символы, проверен без усечения. Basic используется только при входе. Отсутствующий пользователь и неверный пароль возвращают одинаковый 401 и Basic challenge.
Bearer содержит 256 случайных бит. В Redis хранится SHA-256 токена как ключ и UUID/абсолютное время окончания как значение. `PXAT` и дополнительная проверка срока в API не позволяют продлевать сессию чтением/рестартом. Logout удаляет ключ до 204. Неизвестный, истёкший и отозванный токены дают 401 с Bearer challenge; X-User-Id не влияет на личность.
Redis — единственное хранилище сессий, поэтому настроены volume, AOF и `appendfsync always`. TTL управляет сроком жизни, AOF — сохранностью. Кэширования истории нет: следующее чтение идёт в PostgreSQL и видит подтверждённую запись. При отказе Redis API не подменяет сессии локальной памятью. Для readiness критичны оба хранилища; liveness проверяет только процесс.
Запись сообщения блокирует строку своего чата до COMMIT. Новая метка не меньше текущего времени и предыдущей метки + 1 microsecond. Это сохраняет порядок commit в одном чате при совпадении/откате часов. История использует подписанный cursor, привязанный к чату, и keyset-условие `(created_at, id) > (...)`. Общего snapshot между страницами нет; поздние записи могут появиться на следующих страницах. После рестарта cursor остаётся действителен благодаря сохранённому ключу подписи.
## Доказательства критериев
| Критерий | Команда / сценарий | Наблюдение | Доказательство |
| --- | --- | --- | --- |
| Структура и публичный API | `make check`, `make test` в checks | PASS, Unicode, членство, пагинация, Basic/Bearer, logout | `contract-check.txt`, `smoke.txt`, `smoke-final.txt` |
| Реальные PostgreSQL/Redis, volume и полный restart | Неизменённый `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | Подтверждённое сообщение и прежняя сессия сохранились; перезапущены все 3 сервиса | `persistence.txt`, `restart.json` |
| Миграция с нуля и повторяемость | Старт migrate, затем повтор `compose run --rm --no-deps migrate` | 001 применена; повтор — Unchanged; количества строк совпали | `migrations-repeat.txt`, `verification.json`, `clean-source.json` |
| Password KDF, UTF-8, неверные credentials, logout | `make test-student` | Хеш проверен scrypt; пароль 128 code points без усечения; неверный пароль/Basic на бизнес-endpoint/отозванный токен — 401 | `student-tests.txt` |
| Redis реально хранит сессии с TTL/persistence | Интеграционный SIGKILL Redis и возврат со старым токеном | Сессия восстановилась из AOF, абсолютный expiry не изменился | `student-tests.txt`, `infra/redis.conf` |
| Гонка регистрации | 10 параллельных запросов одного username | 1 ответ 201, 9 ответов 409, 1 строка users | `student-tests.txt` |
| Rollback составной операции | Второй участник чата неизвестен; сравнение БД до/после | 400, число чатов/членств не изменилось, частичного чата нет | `student-tests.txt` |
| Сохранность конкурентных сообщений | 100 сообщений, 10 HTTP-клиентов, чтение всех страниц | 100 подтверждений, 100 уникальных UUID, все тексты на месте | `student-tests.txt` |
| Индекс истории ≥10 000 сообщений | `make explain` | Начало/середина/поздняя страница: Index Scan, LIMIT 51, без Seq Scan/OFFSET | `explain.json`, `explain.txt`, `explain-run.txt` |
| Expiry при коротком TTL | Отдельный API с TTL=2 | 200 сразу, 401 через 2.3 s; основной TTL не меняется | `expiry.json`, `expiry.txt` |
| Недоступность Redis/БД | Поочерёдный stop/start каждого хранилища | Live 200, ready и защищённый запрос 503 примерно за 1 s, анонимный X-User-Id 401; прежняя сессия работает после восстановления | `failures.json`, `student-tests.txt` |
| Сборка и повтор проверок из чистого clone | Отдельный Compose-проект и пустые volumes | Чистый commit, независимые secrets/volumes, повтор проверок | `clean-source.json`, `clean-verification.json`, `clean-build.txt` |
Имена файлов в таблице относятся к `evidence/`, если не указан иной каталог.
## Измерения и отказы
Стенд: Windows, Docker Desktop/WSL2 Linux containers, Intel Core i5-9600K, 6 физических/логических ядер, RAM 31.9 GiB. Лимиты: API 1 CPU/256 MiB, PostgreSQL 1 CPU/512 MiB, Redis 0.5 CPU/192 MiB; клиент проверок 1 CPU/256 MiB. Версии и фактические ограничения сохранены в JSON. Это функциональные проверки и локальный план SQL; максимальная пропускная способность/RPS/p95/p99 не измерялись и не заявляются.
Для плана создан отдельный чат с 10 000 синтетическими сообщениями, выполнен ANALYZE. Измерены первая страница и страницы после 5000-го/9900-го сообщения, по 50 элементов. Каждому HTTP-запросу соответствует `LIMIT 51`: лишняя строка нужна только для признака следующей страницы. Сохранены машинный JSON и текстовый EXPLAIN (ANALYZE, BUFFERS). Во всех трёх случаях используется `messages_chat_created_id_idx`, обрабатывается 51 строка. Во втором прогретом чтении время выполнения составляло около 0.03 ms и 3–4 shared buffer hits. Эти цифры относятся к SQL на прогретом локальном наборе, а не ко времени HTTP или дисковому чтению холодного стенда.
| Воздействие | Результат |
| --- | --- |
| Рестарт API + PostgreSQL + Redis | Те же данные и старый токен доступны после readiness; имена volumes сохранены |
| SIGKILL Redis | Сессия восстанавливается из AOF; абсолютный expiry не продлён |
| Stop Redis | Защищённый запрос 503 примерно за 1 s, live 200; после start работает старый токен |
| Stop PostgreSQL | Защищённый запрос 503 примерно за 1 s, live 200; пул восстанавливает соединения |
| Истечение TTL | Через 2.3 s сессия с TTL=2 отклонена с 401 |
| Неизвестный участник при создании чата | Вся SQL-транзакция откатилась |
## Ограничения
Один Docker-host, одна PostgreSQL и один Redis: рестарт выдерживается, потеря host/диска/volume — нет. Backup/restore, репликация и HA не реализованы. Redis flush уничтожает сессии. При потере SQL-соединения после отправки COMMIT клиент может получить неопределённый результат; идемпотентность сообщений относится к lab3. Общего snapshot между страницами нет. Записи одного очень активного чата сериализуются его row lock. Нет UI, TLS, лимита хранения истории и исследования уровня 5. HTTP разрешён только в локальном изолированном стенде с синтетическими паролями.
## Источники и разбор
- [Задание и контракт lab2](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2); локальные `README.md`, `contracts/README.md`, OpenAPI и публичные тесты.
- Собственная реализация lab1, указанный выше commit.
- [Psycopg connection pools](https://www.psycopg.org/psycopg3/docs/advanced/pool.html).
- [PostgreSQL EXPLAIN](https://www.postgresql.org/docs/17/using-explain.html), [транзакции](https://www.postgresql.org/docs/17/tutorial-transactions.html).
- [redis-py asyncio](https://redis.readthedocs.io/en/stable/examples/asyncio_examples.html), [Redis persistence](https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/).
- Объяснение схемы — [docs/DATABASE.md](docs/DATABASE.md); сценарий защиты и разбор решений — [docs/DEFENSE.md](docs/DEFENSE.md); порядок передачи файлов — [docs/SUBMISSION.md](docs/SUBMISSION.md).
+1
View File
@@ -0,0 +1 @@
"""Laboratory 1: a single-process, in-memory messenger."""
+17
View File
@@ -0,0 +1,17 @@
import logging
import os
import uvicorn
def main():
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logging.getLogger("psycopg.pool").setLevel(logging.CRITICAL)
logging.info("Starting lab2 environment=%s with PostgreSQL and Redis", os.getenv("APP_ENV", "lab"))
uvicorn.run("app.api:app", host=os.getenv("APP_HOST", "0.0.0.0"),
port=int(os.getenv("APP_PORT", "8080")), workers=1,
access_log=False, timeout_graceful_shutdown=5)
if __name__ == "__main__":
main()
+168
View File
@@ -0,0 +1,168 @@
import asyncio
from contextlib import asynccontextmanager
import json
import logging
from pathlib import Path
import re
from time import perf_counter
from uuid import uuid4
from fastapi import Depends, FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from fastapi.responses import Response
import psycopg
from psycopg_pool import PoolTimeout, TooManyRequests
from redis.exceptions import RedisError
from pydantic import ValidationError
from starlette.exceptions import HTTPException
from .config import Settings
from .errors import APIError, invalid, unavailable
from .models import CreateChat, CreateMessage, CreateUser
from .security import basic_credentials, identifier
from .store import Store
logger = logging.getLogger("messenger")
def error_response(request, status, code, message, headers=None):
return JSONResponse(status_code=status, headers=headers, content={"error": {
"code": code, "message": message, "request_id": request.state.request_id}})
async def body(request, model):
content_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower()
if content_type != "application/json":
raise APIError(415, "unsupported_media_type", "Use application/json")
try:
raw = (await request.body()).decode("utf-8")
def reject_constant(value):
raise ValueError("Nonstandard JSON constant")
data = json.loads(raw, parse_constant=reject_constant)
return model.model_validate(data)
except (ValueError, UnicodeError, ValidationError):
raise invalid("Body must be valid UTF-8 JSON with the required fields and types") from None
def pagination(request):
raw = request.query_params.get("limit", "50")
if re.fullmatch(r"[0-9]+", raw) is None or len(raw) > 3 or not 1 <= int(raw) <= 100:
raise invalid("Limit must be an integer from 1 to 100")
return int(raw), request.query_params.get("cursor")
def create_app(settings=None):
@asynccontextmanager
async def lifespan(app):
store = Store(settings or Settings.load())
app.state.store = store
try:
await store.open()
yield
finally:
await store.close()
app = FastAPI(title="Lab 2 messenger", docs_url=None, redoc_url=None,
openapi_url=None, redirect_slashes=False, lifespan=lifespan)
@app.middleware("http")
async def request_context(request, call_next):
request.state.request_id = str(uuid4())
start = perf_counter()
try:
async with asyncio.timeout(5):
response = await call_next(request)
except (psycopg.Error, PoolTimeout, TooManyRequests, RedisError, TimeoutError):
error = unavailable()
logger.warning("Storage unavailable request_id=%s", request.state.request_id)
response = error_response(request, error.status, error.code, error.message)
except Exception:
logger.error("Unhandled error request_id=%s", request.state.request_id)
response = error_response(request, 500, "internal_error", "Internal server error")
response.headers["X-Request-Id"] = request.state.request_id
logger.info("request_id=%s method=%s path=%s status=%s duration_ms=%.2f",
request.state.request_id, request.method, request.url.path,
response.status_code, (perf_counter() - start) * 1000)
return response
@app.exception_handler(APIError)
async def api_error(request, error):
return error_response(request, error.status, error.code, error.message, error.headers)
@app.exception_handler(RequestValidationError)
async def validation_error(request, error):
return error_response(request, 400, "invalid_request", "Invalid request parameters")
@app.exception_handler(HTTPException)
async def routing_error(request, error):
code = "not_found" if error.status_code == 404 else "invalid_request"
return error_response(request, error.status_code, code, "Unknown path or unsupported method")
async def current_user(request: Request):
user, token = await app.state.store.authenticate(request.headers.get("authorization"))
request.state.session_token = token
return user
@app.get("/health/live")
async def health():
return {"status": "ok"}
@app.get("/health/ready")
async def readiness():
await app.state.store.ready()
return {"status": "ok"}
@app.post("/api/v1/auth/sessions", status_code=201)
async def login(request: Request):
credentials = basic_credentials(request.headers.get("authorization"))
if await request.body():
raise invalid("Session creation does not accept a body")
return await app.state.store.login(*credentials)
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def logout(request: Request, user=Depends(current_user)):
await app.state.store.logout(request.state.session_token)
return Response(status_code=204)
@app.post("/api/v1/users", status_code=201)
async def create_user(request: Request):
return await app.state.store.create_user(await body(request, CreateUser))
@app.get("/api/v1/users/me")
async def me(user=Depends(current_user)):
return user
@app.post("/api/v1/chats", status_code=201)
async def create_chat(request: Request, user=Depends(current_user)):
return await app.state.store.create_chat(user["id"], await body(request, CreateChat))
@app.get("/api/v1/chats")
async def list_chats(request: Request, user=Depends(current_user)):
return await app.state.store.list_chats(user["id"], *pagination(request))
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(chat_id: str, user=Depends(current_user)):
return await app.state.store.get_chat(user["id"], identifier(chat_id))
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
async def create_message(chat_id: str, request: Request, user=Depends(current_user)):
chat_id = identifier(chat_id)
await app.state.store.get_chat(user["id"], chat_id)
return await app.state.store.create_message(user["id"], chat_id, await body(request, CreateMessage))
@app.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(chat_id: str, request: Request, user=Depends(current_user)):
chat_id = identifier(chat_id)
await app.state.store.get_chat(user["id"], chat_id)
return await app.state.store.list_messages(user["id"], chat_id, *pagination(request))
@app.get("/openapi.json", include_in_schema=False)
async def contract():
path = Path(__file__).resolve().parents[1] / "contracts" / "openapi.json"
return json.loads(path.read_text(encoding="utf-8"))
return app
app = create_app()
+28
View File
@@ -0,0 +1,28 @@
"""Runtime settings; credential values are never logged."""
from dataclasses import dataclass
import os
from pathlib import Path
def secret(name):
return Path(os.environ[name + "_FILE"]).read_text(encoding="utf-8").strip()
@dataclass(frozen=True)
class Settings:
database_url: str
cache_url: str
cursor_key: bytes
session_ttl: int
@classmethod
def load(cls):
ttl = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
if not 1 <= ttl <= 604800:
raise ValueError("SESSION_TTL_SECONDS must be in 1..604800")
if os.getenv("SESSION_STORE", "redis") != "redis":
raise ValueError("This deployment uses SESSION_STORE=redis")
key = secret("CURSOR_KEY").encode()
if len(key) < 32:
raise ValueError("Cursor key must contain at least 32 bytes")
return cls(secret("DATABASE_URL"), secret("CACHE_URL"), key, ttl)
+22
View File
@@ -0,0 +1,22 @@
class APIError(Exception):
def __init__(self, status: int, code: str, message: str, headers=None):
self.status = status
self.code = code
self.message = message
self.headers = headers or {}
super().__init__(message)
def invalid(message="Invalid request"):
return APIError(400, "invalid_request", message)
def unauthorized(basic=False):
challenge = ('Basic realm="messenger", charset="UTF-8"' if basic
else 'Bearer realm="messenger"')
return APIError(401, "unauthorized", "Valid credentials required",
{"WWW-Authenticate": challenge})
def unavailable():
return APIError(503, "unavailable", "Storage temporarily unavailable")
+37
View File
@@ -0,0 +1,37 @@
"""Apply numbered migrations atomically; safe to repeat and serialize."""
import hashlib
from pathlib import Path
import psycopg
from .config import secret
ROOT = Path(__file__).resolve().parents[1]
def migrate():
with psycopg.connect(secret("DATABASE_URL"), connect_timeout=2,
options="-c statement_timeout=10000 -c lock_timeout=5000") as conn:
conn.execute("SELECT pg_advisory_xact_lock(202602)")
conn.execute("""CREATE TABLE IF NOT EXISTS schema_migrations (
version text PRIMARY KEY, sha256 text NOT NULL,
applied_at timestamptz NOT NULL DEFAULT clock_timestamp())""")
for path in sorted((ROOT / "migrations").glob("[0-9]*.sql")):
# Git checkout may change LF to CRLF on Windows; SQL is unchanged.
content = path.read_text(encoding="utf-8").encode("utf-8")
checksum = hashlib.sha256(content).hexdigest()
row = conn.execute("SELECT sha256 FROM schema_migrations WHERE version=%s", (path.name,)).fetchone()
if row:
if row[0] != checksum:
raise RuntimeError("Applied migration checksum differs: " + path.name)
print("Unchanged:", path.name)
continue
conn.execute(content.decode("utf-8"))
conn.execute("INSERT INTO schema_migrations(version, sha256) VALUES (%s, %s)",
(path.name, checksum))
print("Applied:", path.name)
print("PASS: migrations committed")
if __name__ == "__main__":
migrate()
+50
View File
@@ -0,0 +1,50 @@
"""Strict request models; strings retain their original Unicode content."""
import re
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_validator
class Input(BaseModel):
model_config = ConfigDict(strict=True, extra="forbid")
@field_validator("*", check_fields=False)
@classmethod
def valid_text(cls, value):
if isinstance(value, str):
if not value.strip():
raise ValueError("A string must not be blank")
value.encode("utf-8")
if "\x00" in value:
raise ValueError("NUL is not supported")
return value
class CreateUser(Input):
username: str
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
@field_validator("username")
@classmethod
def username_format(cls, value):
if re.fullmatch(r"[a-z0-9_]{3,32}", value) is None:
raise ValueError("Invalid username")
return value
class CreateChat(Input):
title: str = Field(min_length=1, max_length=100)
member_ids: list[str] = Field(min_length=1, max_length=100)
@field_validator("member_ids")
@classmethod
def members(cls, values):
normalized = [str(UUID(value)) for value in values]
if len(set(normalized)) != len(normalized):
raise ValueError("Duplicate members")
return normalized
class CreateMessage(Input):
text: str = Field(min_length=1, max_length=4000)
+93
View File
@@ -0,0 +1,93 @@
"""scrypt passwords, strict Basic credentials and persistent signed cursors."""
import base64
from datetime import datetime, timezone
import hashlib
import hmac
import json
import re
import secrets
from uuid import UUID
from .errors import invalid, unauthorized
def password_hash(password, salt=None):
salt = salt or secrets.token_bytes(16)
digest = hashlib.scrypt(password.encode("utf-8"), salt=salt, n=16384,
r=8, p=1, dklen=32, maxmem=64 * 1024 * 1024)
return "scrypt$16384$8$1$" + salt.hex() + "$" + digest.hex()
def password_matches(password, encoded):
try:
algorithm, n, r, p, salt, digest = encoded.split("$")
if (algorithm, n, r, p) != ("scrypt", "16384", "8", "1"):
return False
actual = password_hash(password, bytes.fromhex(salt)).rsplit("$", 1)[1]
return hmac.compare_digest(actual, digest)
except (ValueError, UnicodeError):
return False
def basic_credentials(header):
try:
scheme, encoded = header.split(" ", 1)
if scheme.lower() != "basic" or len(encoded) > 2048:
raise ValueError
value = base64.b64decode(encoded, validate=True).decode("utf-8")
username, password = value.split(":", 1)
if re.fullmatch(r"[a-z0-9_]{3,32}", username) is None:
raise ValueError
if not 12 <= len(password) <= 128:
raise ValueError
return username, password
except (AttributeError, ValueError, UnicodeError):
raise unauthorized(basic=True) from None
def bearer(header):
try:
scheme, token = header.split(" ", 1)
if scheme.lower() != "bearer" or re.fullmatch(r"[A-Za-z0-9_-]{43}", token) is None:
raise ValueError
return token
except (AttributeError, ValueError):
raise unauthorized() from None
def identifier(value):
try:
return UUID(value)
except (ValueError, AttributeError, TypeError):
raise invalid("Invalid UUID") from None
def stamp(value):
return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
class Cursors:
def __init__(self, key):
self.key = key
def encode(self, scope, item):
payload = json.dumps([scope, item["created_at"], item["id"]], separators=(",", ":")).encode()
signature = hmac.digest(self.key, payload, hashlib.sha256)
return base64.urlsafe_b64encode(signature + payload).decode().rstrip("=")
def decode(self, scope, token):
try:
if not token or len(token) > 1024:
raise ValueError
raw = base64.b64decode(token + "=" * (-len(token) % 4), altchars=b"-_", validate=True)
signature, payload = raw[:32], raw[32:]
if not hmac.compare_digest(signature, hmac.digest(self.key, payload, hashlib.sha256)):
raise ValueError
parts = json.loads(payload)
if not isinstance(parts, list) or len(parts) != 3 or parts[0] != scope:
raise ValueError
if not all(isinstance(x, str) for x in parts) or not parts[1].endswith("Z"):
raise ValueError
return datetime.fromisoformat(parts[1].replace("Z", "+00:00")), UUID(parts[2])
except (ValueError, TypeError, UnicodeError):
raise invalid("Invalid cursor for this resource") from None
+211
View File
@@ -0,0 +1,211 @@
"""Persistent business data and durable Redis sessions; no local state cache."""
import asyncio
from datetime import datetime, timezone
import hashlib
import json
import secrets
from uuid import UUID, uuid4
from psycopg.errors import ForeignKeyViolation, UniqueViolation
from psycopg.rows import dict_row
from psycopg_pool import AsyncConnectionPool
import redis.asyncio as redis
from redis.asyncio.retry import Retry
from redis.backoff import NoBackoff
from .errors import APIError, invalid, unauthorized
from .security import Cursors, bearer, password_hash, password_matches, stamp
USER_COLUMNS = "id, username, display_name, created_at"
MESSAGE_COLUMNS = "id, chat_id, sender_id, text, created_at"
def public(row):
return {key: (str(value) if isinstance(value, UUID) else
stamp(value) if isinstance(value, datetime) else value)
for key, value in row.items()}
class Store:
def __init__(self, settings):
self.settings = settings
self.cursors = Cursors(settings.cursor_key)
self.kdf_slots = asyncio.Semaphore(4)
self.dummy_hash = password_hash("dummy-password-for-missing-user", b"0" * 16)
self.pool = AsyncConnectionPool(
settings.database_url, min_size=1, max_size=10, max_waiting=20,
timeout=1, open=False, reconnect_timeout=5,
check=AsyncConnectionPool.check_connection,
kwargs={"row_factory": dict_row, "connect_timeout": 2,
"keepalives": 1, "keepalives_idle": 2, "keepalives_interval": 1,
"keepalives_count": 2, "tcp_user_timeout": 2000,
"options": "-c timezone=UTC -c statement_timeout=2000 -c lock_timeout=1000"})
self.sessions = redis.Redis.from_url(
settings.cache_url, decode_responses=True, max_connections=10,
socket_connect_timeout=1, socket_timeout=1,
retry=Retry(NoBackoff(), 0), retry_on_timeout=False)
async def open(self):
await self.pool.open()
await self.pool.wait(timeout=10)
await self.sessions.ping()
async def close(self):
await self.sessions.aclose()
await self.pool.close()
async def ready(self):
async with self.pool.connection() as conn:
await conn.execute("SELECT 1")
await self.sessions.ping()
async def create_user(self, data):
async with self.kdf_slots:
encoded = await asyncio.to_thread(password_hash, data.password)
try:
async with self.pool.connection() as conn:
cur = await conn.execute(
"INSERT INTO users(id, username, display_name, password_hash) "
"VALUES (%s, %s, %s, %s) RETURNING " + USER_COLUMNS,
(uuid4(), data.username, data.display_name, encoded))
result = public(await cur.fetchone())
return result
except UniqueViolation:
raise APIError(409, "conflict", "Username is already taken") from None
async def login(self, username, password):
async with self.pool.connection() as conn:
cur = await conn.execute("SELECT " + USER_COLUMNS + ", password_hash FROM users WHERE username=%s",
(username,))
row = await cur.fetchone()
async with self.kdf_slots:
valid = await asyncio.to_thread(password_matches, password,
row["password_hash"] if row else self.dummy_hash)
if not valid or row is None:
raise unauthorized(basic=True)
row.pop("password_hash")
token = secrets.token_urlsafe(32)
expires_ms = int(datetime.now(timezone.utc).timestamp() * 1000) + self.settings.session_ttl * 1000
await self.sessions.set(self.session_key(token), json.dumps(
{"user_id": str(row["id"]), "expires_ms": expires_ms}), pxat=expires_ms)
return {"token": token, "token_type": "Bearer",
"expires_at": stamp(datetime.fromtimestamp(expires_ms / 1000, timezone.utc)),
"user": public(row)}
@staticmethod
def session_key(token):
return "session:" + hashlib.sha256(token.encode("ascii")).hexdigest()
async def authenticate(self, header):
token = bearer(header)
value = await self.sessions.get(self.session_key(token))
if value is None:
raise unauthorized()
session = json.loads(value)
if session["expires_ms"] <= int(datetime.now(timezone.utc).timestamp() * 1000):
raise unauthorized()
async with self.pool.connection() as conn:
cur = await conn.execute("SELECT " + USER_COLUMNS + " FROM users WHERE id=%s",
(UUID(session["user_id"]),))
row = await cur.fetchone()
if row is None:
raise unauthorized()
return public(row), token
async def logout(self, token):
await self.sessions.delete(self.session_key(token))
async def create_chat(self, actor, data):
if actor not in data.member_ids:
raise invalid("Members must include the current user")
try:
async with self.pool.connection() as conn:
cur = await conn.execute("INSERT INTO chats(id, title) VALUES (%s, %s) "
"RETURNING id, title, created_at", (uuid4(), data.title))
row = await cur.fetchone()
async with conn.cursor() as cur:
await cur.executemany("INSERT INTO chat_members(chat_id, user_id) VALUES (%s, %s)",
[(row["id"], UUID(member)) for member in data.member_ids])
result = public(row)
result["member_ids"] = sorted(data.member_ids)
return result
except ForeignKeyViolation:
raise invalid("All members must exist") from None
async def accessible_chat(self, conn, actor, chat_id):
cur = await conn.execute("""SELECT c.id, c.title, c.created_at FROM chats c
JOIN chat_members m ON m.chat_id=c.id
WHERE c.id=%s AND m.user_id=%s""", (chat_id, UUID(actor)))
row = await cur.fetchone()
if row is None:
raise APIError(404, "not_found", "Chat not found")
return row
async def get_chat(self, actor, chat_id):
async with self.pool.connection() as conn:
row = await self.accessible_chat(conn, actor, chat_id)
cur = await conn.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id", (chat_id,))
result = public(row)
result["member_ids"] = [str(x["user_id"]) for x in await cur.fetchall()]
return result
async def create_message(self, actor, chat_id, data):
async with self.pool.connection() as conn:
await self.accessible_chat(conn, actor, chat_id)
# Evaluate clock_timestamp AFTER obtaining the per-chat lock.
await conn.execute("SELECT id FROM chats WHERE id=%s FOR UPDATE", (chat_id,))
cur = await conn.execute("""UPDATE chats SET last_message_at=
greatest(clock_timestamp(), last_message_at + interval '1 microsecond')
WHERE id=%s RETURNING last_message_at""", (chat_id,))
created_at = (await cur.fetchone())["last_message_at"]
cur = await conn.execute("INSERT INTO messages(id, chat_id, sender_id, text, created_at) "
"VALUES (%s, %s, %s, %s, %s) RETURNING " + MESSAGE_COLUMNS,
(uuid4(), chat_id, UUID(actor), data.text, created_at))
result = public(await cur.fetchone())
return result
def page(self, rows, scope, limit):
items = rows[:limit]
return {"items": items, "next_cursor": self.cursors.encode(scope, items[-1])
if len(rows) > limit else None}
async def list_messages(self, actor, chat_id, limit, cursor):
scope = "messages:" + str(chat_id)
boundary = self.cursors.decode(scope, cursor) if cursor is not None else None
async with self.pool.connection() as conn:
await self.accessible_chat(conn, actor, chat_id)
query = "SELECT " + MESSAGE_COLUMNS + " FROM messages WHERE chat_id=%s"
params = [chat_id]
if boundary:
query += " AND (created_at, id) > (%s, %s)"
params.extend(boundary)
query += " ORDER BY created_at, id LIMIT %s"
params.append(limit + 1)
cur = await conn.execute(query, params)
rows = [public(row) for row in await cur.fetchall()]
return self.page(rows, scope, limit)
async def list_chats(self, actor, limit, cursor):
scope = "chats:" + actor
boundary = self.cursors.decode(scope, cursor) if cursor is not None else None
query = """SELECT c.id, c.title, c.created_at FROM chats c
JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s"""
params = [UUID(actor)]
if boundary:
query += " AND (c.created_at, c.id) > (%s, %s)"
params.extend(boundary)
query += " ORDER BY c.created_at, c.id LIMIT %s"
params.append(limit + 1)
async with self.pool.connection() as conn:
cur = await conn.execute(query, params)
rows = [public(row) for row in await cur.fetchall()]
if rows:
ids = [UUID(row["id"]) for row in rows]
cur = await conn.execute("SELECT chat_id, user_id FROM chat_members WHERE chat_id=ANY(%s) ORDER BY user_id",
(ids,))
members = {row["id"]: [] for row in rows}
for member in await cur.fetchall():
members[str(member["chat_id"])].append(str(member["user_id"]))
for row in rows:
row["member_ids"] = members[row["id"]]
return self.page(rows, scope, limit)
+118
View File
@@ -0,0 +1,118 @@
name: mtusi-lab2
x-app: &app
image: mtusi-messenger:lab2
build:
context: .
target: runtime
environment: &environment
APP_HOST: 0.0.0.0
APP_PORT: "8080"
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_STORE: redis
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
CURSOR_KEY_FILE: /run/secrets/cursor_key
secrets:
- database_url
- cache_url
- cursor_key
services:
postgres:
image: postgres:17.6-bookworm
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets:
- postgres_password
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: [CMD-SHELL, "pg_isready -U messenger -d messenger"]
interval: 3s
timeout: 2s
retries: 20
cpus: 1.0
mem_limit: 512m
stop_grace_period: 10s
redis:
image: redis:7.4.5-bookworm
command:
- sh
- -ec
- 'exec redis-server /usr/local/etc/redis/redis.conf --requirepass "$$(cat /run/secrets/redis_password)"'
secrets:
- redis_password
volumes:
- redis_data:/data
- ./infra/redis.conf:/usr/local/etc/redis/redis.conf:ro
healthcheck:
test: [CMD-SHELL, 'REDISCLI_AUTH="$$(cat /run/secrets/redis_password)" redis-cli ping | grep -q PONG']
interval: 3s
timeout: 2s
retries: 20
cpus: 0.5
mem_limit: 192m
stop_grace_period: 10s
migrate:
<<: *app
command: [python, -m, app.migrate]
depends_on:
postgres:
condition: service_healthy
restart: "no"
api:
<<: *app
depends_on:
migrate:
condition: service_completed_successfully
redis:
condition: service_healthy
ports:
- "127.0.0.1:${API_PORT:-8080}:8080"
cpus: 1.0
mem_limit: 256m
stop_grace_period: 8s
checks:
profiles: [tools]
image: mtusi-messenger:lab2-checks
build:
context: .
target: checks
environment:
<<: *environment
BASE_URL: http://api:8080
COMPOSE_PROJECT_NAME: ${COMPOSE_PROJECT_NAME:-mtusi-lab2}
CHECKS_PROJECT_DIR: /checks
secrets:
- database_url
- cache_url
- cursor_key
volumes:
- .:/checks
- /var/run/docker.sock:/var/run/docker.sock
cpus: 1.0
mem_limit: 256m
volumes:
postgres_data:
redis_data:
secrets:
postgres_password:
file: ./secrets/postgres_password
redis_password:
file: ./secrets/redis_password
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
cursor_key:
file: ./secrets/cursor_key
+33
View File
@@ -0,0 +1,33 @@
# Хранение и транзакции
Схема спроектирована для одного локального стенда: API → PostgreSQL для бизнес-данных; API → Redis для сессий. PostgreSQL и Redis — независимые источники истины для своих данных. История сообщений не кэшируется.
## Таблицы PostgreSQL
| Таблица | Назначение и ограничения |
| --- | --- |
| `schema_migrations` | Имя и SHA-256 применённой миграции; изменение уже применённого SQL запрещено |
| `users` | UUID PK, уникальный username, display_name, scrypt-хеш, время регистрации |
| `chats` | UUID PK, title, время создания, внутренняя последняя метка сообщения |
| `chat_members` | Составной PK `(chat_id, user_id)`, FK на чаты и пользователей |
| `messages` | UUID PK, chat_id, sender_id, text, created_at; составной FK `(chat_id, sender_id)` на членство |
Индекс `chat_members(user_id, chat_id)` выбирает доступные чаты. Индекс `messages(chat_id, created_at, id)` обслуживает равенство по чату, диапазон после курсора и сортировку. Следующая страница использует `(created_at, id) > (%s, %s)` и `LIMIT limit + 1`, без OFFSET и загрузки всей истории. Приложение запрашивает только нужную страницу.
## Границы транзакций
- Регистрация: один INSERT, уникальность обеспечивается БД, проигравшая конкурентная запись получает 409.
- Создание чата: INSERT чата и всех участников в одной транзакции. Неизвестный участник нарушает FK; вся операция откатывается, включая уже вставленный чат.
- Отправка: блокировка строки чата, проверка членства, назначение метки времени, обновление метки и INSERT сообщения в одной транзакции. COMMIT заканчивается до HTTP 201. Составной FK дополнительно запрещает сообщение неучастника.
- Чтение: READ COMMITTED. Между HTTP-страницами snapshot отсутствует. В одном чате запись сериализуется блокировкой строки: `max(clock_timestamp(), last_message_at + 1 microsecond)` сохраняет возрастающий порядок даже при совпадении времени или откате часов. Соседние чаты не делят эту блокировку. При откате часов логическое время может опережать часы. Параллельно создаваемые чаты сортируются по назначенному времени; общий snapshot их списка не обещается.
- Миграции: advisory lock, проверка контрольной суммы, SQL и регистрация версии в одной транзакции. Для checksum окончания строк приводятся к LF, поэтому checkout Windows не меняет версию миграции. Повторный запуск ничего не вставляет. Миграция запускается отдельным одноразовым сервисом до API.
## Сессии Redis
Клиент получает 32 случайных байта в URL-safe base64. Ключ Redis — `session:<sha256(token)>`, значение — UUID пользователя и абсолютное `expires_at`; исходный токен на сервере не сохраняется. `SET ... PXAT` назначает срок в момент создания, чтение его не продлевает. API дополнительно проверяет абсолютную дату. Logout удаляет ключ до ответа 204. При отказе Redis защищённый запрос получает 503, вход по X-User-Id или локальному запасному словарю отсутствует.
Redis использует именованный volume, AOF, `appendfsync always` и `maxmemory-policy noeviction`. Обычный рестарт и аварийное завершение Redis проверяются отдельно. Потеря/удаление volume не покрывается; PostgreSQL не содержит резервной копии сессий. Потеря любого источника истины делает readiness равным 503; liveness остаётся 200.
## Пределы ожидания
PostgreSQL: pool 1–10 соединений, очередь максимум 20, ожидание pool 1 s, connect 2 s, SQL 2 s, блокировка 1 s, TCP keepalive/TCP_USER_TIMEOUT. Redis: максимум 10 соединений, connect/read 1 s, без повторов команды. Общий бюджет HTTP-обработки 5 s. KDF выполняется вне event loop, не более четырёх параллельных вычислений. Секреты читаются из локальных файлов; в логах нет SQL, DSN, паролей, токенов и текстов сообщений.
+52
View File
@@ -0,0 +1,52 @@
# Защита лабораторной 2
Целевая оценка — 4. Основа первой работы сохранена: пользователи, чаты, участники, сообщения, проверки доступа и cursor-пагинация. Изменилось хранение и подтверждение личности.
## Суть решения за минуту
В первой работе всё лежало в RAM одного процесса и исчезало после рестарта. Теперь бизнес-данные хранятся в PostgreSQL на именованном volume. Redis хранит серверные сессии с TTL и AOF. Регистрация принимает пароль, scrypt сохраняет его хеш. Вход с Basic выдаёт случайный Bearer-токен. По токену сервер находит пользователя, затем отдельно проверяет его участие в чате.
## Демонстрация
Из папки проекта:
```powershell
python scripts/init_local.py
docker compose --env-file .env up -d --build --wait
docker compose --env-file .env build checks
python scripts/verify.py --skip-build
```
Команда проверки создаёт только синтетические данные. Она временно останавливает хранилища этого Compose-проекта, восстанавливает их и оставляет основной стенд запущенным. Её выполняют на учебном стенде.
1. Открыть `docs/DATABASE.md`: показать таблицы, FK, уникальный username и транзакцию создания чата.
2. Открыть `evidence/smoke.txt` и `evidence/student-tests.txt`: публичный сценарий, гонка регистрации, rollback, 100 сообщений из 10 клиентов.
3. Открыть `scripts/restart.sh`, `evidence/persistence.txt`, `evidence/restart.json`: перезапущены API, PostgreSQL и Redis; `StartedAt` изменился у всех трёх, имена volumes сохранились. Публичный тест использовал старый токен без повторного входа.
4. Показать `infra/redis.conf`: `appendonly yes`, `appendfsync always`. В тесте Redis выдерживает также SIGKILL; срок сессии не продлевается.
5. Показать `evidence/expiry.json`: отдельный API с TTL=2 возвращает 200 сразу и 401 после 2.3 s. Logout и неверный пароль покрыты интеграционными тестами.
6. Показать `evidence/failures.json`: readiness и защищённый запрос дают 503 при отказе каждого хранилища; liveness остаётся 200, X-User-Id не даёт доступ.
7. Показать `evidence/explain.txt`: 10 000 сообщений, индекс истории, начало/середина/конец. SQL читает 51 строку, API отдаёт 50 и формирует следующий cursor.
## Что понимать в коде
`app/api.py` обрабатывает HTTP, аутентификацию, валидацию, request ID и ошибки. `app/store.py` выполняет SQL и операции Redis. `app/security.py` содержит KDF, разбор Basic/Bearer и подпись курсоров. `app/migrate.py` применяет миграции; `migrations/001_initial.sql` задаёт схему.
- **COMMIT:** операция PostgreSQL завершена до HTTP 201. В стенде включены `synchronous_commit` и `fsync`; потеря самого диска или volume этим не покрывается.
- **Образ, контейнер, volume:** образ содержит код, контейнер запускает процесс, volume хранит данные независимо от жизни контейнера. `down` сохраняет volumes, `down --volumes` удаляет учебные данные.
- **Сессии:** Redis — источник истины для них. TTL отвечает за время жизни, AOF — за восстановление после рестарта. Flush/удаление volume уничтожит сессии; одного TTL недостаточно.
- **Basic и Bearer:** Basic передаёт username:password в base64 при входе. Bearer — случайный ключ действующей серверной сессии для остальных запросов. Base64 не шифрует пароль.
- **Аутентификация и доступ:** действительная сессия определяет пользователя, членство определяет доступ к конкретному чату. Чужой чат возвращает 404.
- **Хеш пароля:** scrypt использует соль и затраты CPU/RAM. SHA-256 токена допустим для уже случайного 256-битного значения, но быстрый SHA-256 не заменяет password KDF.
- **Гонка username:** проверка SELECT перед INSERT не гарантирует уникальность. Нужен UNIQUE в PostgreSQL; проигравший INSERT превращается в 409.
- **Rollback:** INSERT чата и участников выполняются вместе. Ошибка второго участника отменяет первый INSERT, что проверяется прямым подсчётом строк.
- **Keyset:** cursor хранит подписанную границу `(created_at, id)` и область чата. B-tree сразу переходит к нужному диапазону. OFFSET заставил бы пропускать предыдущие строки.
- **Конкурентная история:** блокировка одной строки чата упорядочивает записи этого чата; разные чаты пишут независимо. Между страницами общего snapshot нет.
- **Отказы:** ошибка зависимости даёт ограниченный 503, а не анонимный вход. Один Docker-host и одиночные хранилища не дают высокой доступности.
## Остановка после защиты
```powershell
docker compose --env-file .env stop
# Повторный запуск с прежними данными:
docker compose --env-file .env up -d --wait
```
+15
View File
@@ -0,0 +1,15 @@
# Передача работы на площадку
Рабочая папка — `mtusi2026lab2`. Исходное задание и публичные тесты оставлены в ней. Реализация и доказательства самодостаточны; соседняя первая лабораторная для запуска не нужна.
Перед публикацией проверить список файлов: в него входят `app/`, `migrations/`, `compose.yaml`, `Dockerfile`, `infra/redis.conf`, `scripts/`, `student-tests/`, `docs/`, `REPORT.md`, `requirements.txt`, `.env.example` и текстовые результаты `evidence/`. Папка `secrets/` и файл `.env` локальные и исключены через `.gitignore`. Volumes находятся в Docker, в репозитории их нет.
Копировать пароли и токены в описание PR не требуется. Файл `.github/pull_request_template.md` содержит готовое описание реализации и проверок. При переносе файлов в свой fork сохранить executable bit для `scripts/restart.sh`:
```sh
git add .
git update-index --chmod=+x scripts/restart.sh
git diff --cached --stat
```
Адрес fork, удалённую ветку и PR оформить на Gitea отдельно. Отчёт содержит фактические локальные результаты, оценка выставляется преподавателем после проверки и защиты.
+5 -5
View File
@@ -1,5 +1,5 @@
# Доказательства
Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки.
Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно.
# Доказательства
Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки.
Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно.
+58
View File
@@ -0,0 +1,58 @@
#1 [internal] load local bake definitions
#1 reading from stdin 994B 0.1s done
#1 DONE 0.1s
#2 [internal] load build definition from Dockerfile
#2 transferring dockerfile: 1.20kB done
#2 DONE 0.0s
#3 [internal] load metadata for docker.io/library/python:3.13.15-slim-bookworm
#3 DONE 0.0s
#4 [internal] load .dockerignore
#4 transferring context: 155B done
#4 DONE 0.0s
#5 [runtime 1/7] FROM docker.io/library/python:3.13.15-slim-bookworm@sha256:ed86c82274b3c69b52fb5820f358f0bd7df0b603332063cb5c6e32bd220c3e6e
#5 resolve docker.io/library/python:3.13.15-slim-bookworm@sha256:ed86c82274b3c69b52fb5820f358f0bd7df0b603332063cb5c6e32bd220c3e6e 0.0s done
#5 DONE 0.0s
#6 [internal] load build context
#6 transferring context: 144.46kB 0.0s done
#6 DONE 0.1s
#7 [runtime 2/7] WORKDIR /app
#7 CACHED
#8 [runtime 3/7] COPY requirements.txt .
#8 CACHED
#9 [runtime 4/7] RUN pip install --no-cache-dir -r requirements.txt && useradd --uid 10001 --create-home messenger
#9 CACHED
#10 [runtime 5/7] COPY app ./app
#10 DONE 0.1s
#11 [runtime 6/7] COPY migrations ./migrations
#11 DONE 0.1s
#12 [runtime 7/7] COPY contracts/openapi.json ./contracts/openapi.json
#12 DONE 0.1s
#13 exporting to image
#13 exporting layers
#13 exporting layers 0.2s done
#13 exporting manifest sha256:eabb6884a68e4d764d61d946a247e898543ffd0b0f83fadbffe9b0f51e402923 0.0s done
#13 exporting config sha256:b9bb26dbe47aeeaf9edf195d019c7fd878d2c385e9a8e49536df8b213b068991 0.0s done
#13 exporting attestation manifest sha256:69e5892af7011393aaa969ec7fc9c4b97b3daad4675ea8e646b3e405478b0db3 0.0s done
#13 exporting manifest list sha256:925ffec97353c6a6533ff61927bbce197e8b4a0ab26fe7e84c76d3ba3366a879 0.0s done
#13 naming to docker.io/library/mtusi-messenger:lab2
#13 naming to docker.io/library/mtusi-messenger:lab2 done
#13 unpacking to docker.io/library/mtusi-messenger:lab2
#13 unpacking to docker.io/library/mtusi-messenger:lab2 0.4s done
#13 DONE 0.7s
#14 resolving provenance for metadata file
#14 DONE 0.0s
Image mtusi-messenger:lab2 Building
Image mtusi-messenger:lab2 Built
+221
View File
@@ -0,0 +1,221 @@
#1 [internal] load local bake definitions
#1 reading from stdin 1.67kB 0.1s done
#1 DONE 0.1s
#2 [api internal] load build definition from Dockerfile
#2 transferring dockerfile: 1.23kB done
#2 DONE 0.0s
#3 [api internal] load metadata for docker.io/library/python:3.13.15-slim-bookworm
#3 DONE 0.0s
#4 [checks internal] load metadata for docker.io/library/docker:28.5.1-cli
#4 DONE 0.1s
#5 [api internal] load .dockerignore
#5 transferring context: 164B done
#5 DONE 0.0s
#6 [api internal] load build context
#6 transferring context: 95.03kB 0.0s done
#6 transferring context: 95.03kB 0.0s done
#6 DONE 0.1s
#7 [checks runtime 1/7] FROM docker.io/library/python:3.13.15-slim-bookworm@sha256:ed86c82274b3c69b52fb5820f358f0bd7df0b603332063cb5c6e32bd220c3e6e
#7 resolve docker.io/library/python:3.13.15-slim-bookworm@sha256:ed86c82274b3c69b52fb5820f358f0bd7df0b603332063cb5c6e32bd220c3e6e 0.1s done
#7 DONE 0.1s
#8 [checks docker_cli 1/1] FROM docker.io/library/docker:28.5.1-cli@sha256:9190b0613792e658a7783cf14b2d5ace5941bb68ede7276922ea36ee457d76ad
#8 resolve docker.io/library/docker:28.5.1-cli@sha256:9190b0613792e658a7783cf14b2d5ace5941bb68ede7276922ea36ee457d76ad 0.1s done
#8 CACHED
#9 [checks runtime 2/7] WORKDIR /app
#9 CACHED
#10 [api runtime 3/7] COPY requirements.txt .
#10 DONE 0.1s
#11 [checks runtime 4/7] RUN pip install --no-cache-dir -r requirements.txt && useradd --uid 10001 --create-home messenger
#11 1.859 Ignoring colorama: markers 'sys_platform == "win32"' don't match your environment
#11 2.149 Collecting annotated-doc==0.0.5 (from -r requirements.txt (line 1))
#11 7.503 Downloading annotated_doc-0.0.5-py3-none-any.whl.metadata (6.5 kB)
#11 7.565 Collecting annotated-types==0.8.0 (from -r requirements.txt (line 2))
#11 7.622 Downloading annotated_types-0.8.0-py3-none-any.whl.metadata (15 kB)
#11 7.710 Collecting anyio==4.15.1 (from -r requirements.txt (line 3))
#11 7.770 Downloading anyio-4.15.1-py3-none-any.whl.metadata (4.7 kB)
#11 7.847 Collecting click==8.5.0 (from -r requirements.txt (line 4))
#11 7.899 Downloading click-8.5.0-py3-none-any.whl.metadata (2.6 kB)
#11 8.059 Collecting fastapi==0.141.1 (from -r requirements.txt (line 6))
#11 8.109 Downloading fastapi-0.141.1-py3-none-any.whl.metadata (27 kB)
#11 8.195 Collecting h11==0.16.0 (from -r requirements.txt (line 7))
#11 8.246 Downloading h11-0.16.0-py3-none-any.whl.metadata (8.3 kB)
#11 8.312 Collecting idna==3.20 (from -r requirements.txt (line 8))
#11 8.363 Downloading idna-3.20-py3-none-any.whl.metadata (7.2 kB)
#11 8.594 Collecting pydantic==2.13.5 (from -r requirements.txt (line 9))
#11 8.646 Downloading pydantic-2.13.5-py3-none-any.whl.metadata (110 kB)
#11 9.596 Collecting pydantic-core==2.46.5 (from -r requirements.txt (line 10))
#11 9.647 Downloading pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.6 kB)
#11 9.717 Collecting starlette==1.6.0 (from -r requirements.txt (line 11))
#11 9.769 Downloading starlette-1.6.0-py3-none-any.whl.metadata (6.4 kB)
#11 9.831 Collecting typing-extensions==4.16.0 (from -r requirements.txt (line 12))
#11 9.882 Downloading typing_extensions-4.16.0-py3-none-any.whl.metadata (3.3 kB)
#11 9.939 Collecting typing-inspection==0.4.4 (from -r requirements.txt (line 13))
#11 9.989 Downloading typing_inspection-0.4.4-py3-none-any.whl.metadata (2.6 kB)
#11 10.06 Collecting uvicorn==0.53.0 (from -r requirements.txt (line 14))
#11 10.11 Downloading uvicorn-0.53.0-py3-none-any.whl.metadata (6.6 kB)
#11 10.17 Collecting psycopg==3.2.10 (from psycopg[binary]==3.2.10->-r requirements.txt (line 15))
#11 10.22 Downloading psycopg-3.2.10-py3-none-any.whl.metadata (4.6 kB)
#11 10.29 Collecting psycopg-pool==3.2.6 (from -r requirements.txt (line 16))
#11 10.35 Downloading psycopg_pool-3.2.6-py3-none-any.whl.metadata (2.6 kB)
#11 10.42 Collecting redis==6.4.0 (from -r requirements.txt (line 17))
#11 10.47 Downloading redis-6.4.0-py3-none-any.whl.metadata (10 kB)
#11 10.72 Collecting psycopg-binary==3.2.10 (from psycopg[binary]==3.2.10->-r requirements.txt (line 15))
#11 10.77 Downloading psycopg_binary-3.2.10-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (3.0 kB)
#11 10.82 Downloading annotated_doc-0.0.5-py3-none-any.whl (5.3 kB)
#11 10.88 Downloading annotated_types-0.8.0-py3-none-any.whl (13 kB)
#11 10.93 Downloading anyio-4.15.1-py3-none-any.whl (132 kB)
#11 11.02 Downloading click-8.5.0-py3-none-any.whl (125 kB)
#11 11.09 Downloading fastapi-0.141.1-py3-none-any.whl (131 kB)
#11 11.16 Downloading h11-0.16.0-py3-none-any.whl (37 kB)
#11 11.22 Downloading idna-3.20-py3-none-any.whl (69 kB)
#11 11.28 Downloading pydantic-2.13.5-py3-none-any.whl (472 kB)
#11 11.40 Downloading pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.1 MB)
#11 11.53 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 2.1/2.1 MB 17.4 MB/s 0:00:00
#11 11.58 Downloading starlette-1.6.0-py3-none-any.whl (75 kB)
#11 11.63 Downloading typing_extensions-4.16.0-py3-none-any.whl (45 kB)
#11 11.69 Downloading typing_inspection-0.4.4-py3-none-any.whl (14 kB)
#11 11.74 Downloading uvicorn-0.53.0-py3-none-any.whl (87 kB)
#11 11.80 Downloading psycopg-3.2.10-py3-none-any.whl (206 kB)
#11 11.86 Downloading psycopg_pool-3.2.6-py3-none-any.whl (38 kB)
#11 11.91 Downloading redis-6.4.0-py3-none-any.whl (279 kB)
#11 12.00 Downloading psycopg_binary-3.2.10-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (4.4 MB)
#11 12.16 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.4/4.4 MB 27.5 MB/s 0:00:00
#11 12.31 Installing collected packages: typing-extensions, redis, psycopg-binary, psycopg, idna, h11, click, annotated-types, annotated-doc, uvicorn, typing-inspection, pydantic-core, psycopg-pool, anyio, starlette, pydantic, fastapi
#11 13.78
#11 13.78 Successfully installed annotated-doc-0.0.5 annotated-types-0.8.0 anyio-4.15.1 click-8.5.0 fastapi-0.141.1 h11-0.16.0 idna-3.20 psycopg-3.2.10 psycopg-binary-3.2.10 psycopg-pool-3.2.6 pydantic-2.13.5 pydantic-core-2.46.5 redis-6.4.0 starlette-1.6.0 typing-extensions-4.16.0 typing-inspection-0.4.4 uvicorn-0.53.0
#11 13.78 WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning.
#11 13.78
#11 13.78 [notice] A new release of pip is available: 26.2.1 -> 26.2.2
#11 13.78 [notice] To update, run: pip install --upgrade pip
#11 DONE 15.2s
#11 [api runtime 4/7] RUN pip install --no-cache-dir -r requirements.txt && useradd --uid 10001 --create-home messenger
#11 DONE 15.2s
#12 [api runtime 5/7] COPY app ./app
#12 DONE 0.1s
#12 [checks runtime 5/7] COPY app ./app
#12 DONE 0.1s
#13 [api runtime 6/7] COPY migrations ./migrations
#13 DONE 0.1s
#13 [checks runtime 6/7] COPY migrations ./migrations
#13 DONE 0.1s
#14 [checks runtime 7/7] COPY contracts/openapi.json ./contracts/openapi.json
#14 DONE 0.1s
#14 [api runtime 7/7] COPY contracts/openapi.json ./contracts/openapi.json
#14 DONE 0.1s
#15 [api] exporting to image
#15 exporting layers
#15 ...
#16 [checks checks 1/4] COPY --from=docker_cli /usr/local/bin/docker /usr/local/bin/docker
#16 DONE 0.7s
#17 [checks checks 2/4] COPY --from=docker_cli /usr/local/libexec/docker/cli-plugins/docker-compose /usr/local/libexec/docker/cli-plugins/docker-compose
#17 DONE 0.4s
#15 [api] exporting to image
#15 exporting layers 1.9s done
#15 exporting manifest sha256:88629bd895cdfe4491719cd197009564003e40c7cc2bfb55a17ac03ddf0a6b5b 0.0s done
#15 exporting config sha256:469b05afaf80badba696a75e674adf0714ffc38f07a869cc88a5dcb17990d33d 0.0s done
#15 exporting attestation manifest sha256:f202ed4c417fa9a384abaf2228985367c07dff7c1d0a71bfb9ea9e3e93e7a2ac 0.0s done
#15 exporting manifest list sha256:dab3ec7c7d69de21873d119e07d6348bce002537737d1265baf0908c206fc29d 0.0s done
#15 naming to docker.io/library/mtusi-messenger:lab2 done
#15 unpacking to docker.io/library/mtusi-messenger:lab2
#15 unpacking to docker.io/library/mtusi-messenger:lab2 0.4s done
#15 DONE 2.4s
#18 [checks checks 3/4] RUN apt-get update && apt-get install -y --no-install-recommends make && rm -rf /var/lib/apt/lists/*
#18 0.680 Get:1 http://deb.debian.org/debian bookworm InRelease [151 kB]
#18 0.922 Get:2 http://deb.debian.org/debian bookworm-updates InRelease [55.4 kB]
#18 1.154 Get:3 http://deb.debian.org/debian-security bookworm-security InRelease [34.8 kB]
#18 ...
#19 [api] resolving provenance for metadata file
#19 DONE 0.0s
#18 [checks checks 3/4] RUN apt-get update && apt-get install -y --no-install-recommends make && rm -rf /var/lib/apt/lists/*
#18 1.704 Get:4 http://deb.debian.org/debian bookworm/main amd64 Packages [8790 kB]
#18 2.174 Get:5 http://deb.debian.org/debian bookworm-updates/main amd64 Packages [6924 B]
#18 2.500 Get:6 http://deb.debian.org/debian-security bookworm-security/main amd64 Packages [359 kB]
#18 2.917 Fetched 9398 kB in 3s (3541 kB/s)
#18 2.917 Reading package lists...
#18 3.394 Reading package lists...
#18 3.847 Building dependency tree...
#18 3.985 Reading state information...
#18 4.133 Suggested packages:
#18 4.133 make-doc
#18 4.160 The following NEW packages will be installed:
#18 4.160 make
#18 4.506 0 upgraded, 1 newly installed, 0 to remove and 7 not upgraded.
#18 4.506 Need to get 396 kB of archives.
#18 4.506 After this operation, 1630 kB of additional disk space will be used.
#18 4.506 Get:1 http://deb.debian.org/debian bookworm/main amd64 make amd64 4.3-4.1 [396 kB]
#18 4.624 debconf: delaying package configuration, since apt-utils is not installed
#18 4.652 Fetched 396 kB in 0s (1129 kB/s)
#18 4.680 Selecting previously unselected package make.
#18 4.680 (Reading database ...
(Reading database ... 5%
(Reading database ... 10%
(Reading database ... 15%
(Reading database ... 20%
(Reading database ... 25%
(Reading database ... 30%
(Reading database ... 35%
(Reading database ... 40%
(Reading database ... 45%
(Reading database ... 50%
(Reading database ... 55%
(Reading database ... 60%
(Reading database ... 65%
(Reading database ... 70%
(Reading database ... 75%
(Reading database ... 80%
(Reading database ... 85%
(Reading database ... 90%
(Reading database ... 95%
(Reading database ... 100%
(Reading database ... 6647 files and directories currently installed.)
#18 4.683 Preparing to unpack .../make_4.3-4.1_amd64.deb ...
#18 4.689 Unpacking make (4.3-4.1) ...
#18 4.773 Setting up make (4.3-4.1) ...
#18 DONE 6.3s
#20 [checks checks 4/4] WORKDIR /checks
#20 DONE 0.1s
#21 [checks] exporting to image
#21 exporting layers
#21 exporting layers 2.9s done
#21 exporting manifest sha256:49d6d008bb2c3cb03b97fe58083398e88721321a85a9aa84c8ea336b20c44762 0.0s done
#21 exporting config sha256:ddb92bb96530abdc7d8ec600f3cec2e343316c4264847262460e1821895ee1ab 0.0s done
#21 exporting attestation manifest sha256:697058f72f4a5bda4c65bbec5924e1f324bda75c8a159347ae5a8346cb153291 0.0s done
#21 exporting manifest list sha256:191de4b93466a8945a8e8653f764d4473d9ab919c8b925c86b902b7df5d9da7e 0.0s done
#21 naming to docker.io/library/mtusi-messenger:lab2-checks
#21 naming to docker.io/library/mtusi-messenger:lab2-checks done
#21 unpacking to docker.io/library/mtusi-messenger:lab2-checks
#21 unpacking to docker.io/library/mtusi-messenger:lab2-checks 0.7s done
#21 DONE 3.8s
#22 [checks] resolving provenance for metadata file
#22 DONE 0.0s
Image mtusi-messenger:lab2-checks Building
Image mtusi-messenger:lab2 Building
Image mtusi-messenger:lab2-checks Built
Image mtusi-messenger:lab2 Built
+7
View File
@@ -0,0 +1,7 @@
{
"session_ttl_seconds": 2,
"wait_seconds": 2.3,
"before_expiry_status": 200,
"after_expiry_status": 401,
"result": "PASS"
}
+29
View File
@@ -0,0 +1,29 @@
FIRST
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s ORDER BY created_at, id LIMIT %s
Limit (cost=0.29..4.29 rows=51 width=70) (actual time=0.010..0.023 rows=51 loops=1)
Buffers: shared hit=4
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..786.29 rows=10000 width=70) (actual time=0.010..0.019 rows=51 loops=1)
Index Cond: (chat_id = 'e430ecd3-d167-42cf-923e-9d8864aa454a'::uuid)
Buffers: shared hit=4
Planning Time: 0.057 ms
Execution Time: 0.032 ms
MIDDLE
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s
Limit (cost=0.29..5.65 rows=51 width=70) (actual time=0.013..0.022 rows=51 loops=1)
Buffers: shared hit=4
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..520.50 rows=4945 width=70) (actual time=0.012..0.019 rows=51 loops=1)
Index Cond: ((chat_id = 'e430ecd3-d167-42cf-923e-9d8864aa454a'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 21:47:47.309662+00'::timestamp with time zone, '09540584-a18b-4d60-8a4d-6090097999ba'::uuid)))
Buffers: shared hit=4
Planning Time: 0.055 ms
Execution Time: 0.033 ms
LATE
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s
Limit (cost=0.29..70.42 rows=51 width=70) (actual time=0.017..0.027 rows=51 loops=1)
Buffers: shared hit=3
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..135.06 rows=98 width=70) (actual time=0.017..0.023 rows=51 loops=1)
Index Cond: ((chat_id = 'e430ecd3-d167-42cf-923e-9d8864aa454a'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 21:47:47.314562+00'::timestamp with time zone, '6a60bce1-7a0f-45d3-9836-95b9d7797e39'::uuid)))
Buffers: shared hit=3
Planning Time: 0.072 ms
Execution Time: 0.041 ms
+14
View File
@@ -0,0 +1,14 @@
{
"redis": {
"ready_status": 503,
"protected_status": 503,
"elapsed_seconds": 2.002,
"anonymous_status": 401
},
"postgres": {
"ready_status": 503,
"protected_status": 503,
"elapsed_seconds": 1.004,
"anonymous_status": 401
}
}
+5
View File
@@ -0,0 +1,5 @@
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://api: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.
Container mtusi-lab2-clean-v2-checks-run-75cfed86c889 Creating
Container mtusi-lab2-clean-v2-checks-run-75cfed86c889 Created
+1
View File
@@ -0,0 +1 @@
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+68
View File
@@ -0,0 +1,68 @@
{
"before": {
"api": {
"id": "c999209e71f1e05cf73dd96ed6a8d332f1d7bdb81961b3fdf44656c54207ddb3",
"started_at": "2026-10-30T21:46:56.799081876Z",
"image_id": "sha256:dab3ec7c7d69de21873d119e07d6348bce002537737d1265baf0908c206fc29d",
"user": "messenger",
"volumes": [],
"memory_limit_bytes": 268435456,
"nano_cpus": 1000000000
},
"postgres": {
"id": "921d8a5c2d722009d9946de24218aad6ca7ab83dcb1b5e3291793830bf7dfd0b",
"started_at": "2026-10-30T21:47:18.268247786Z",
"image_id": "sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3",
"user": "",
"volumes": [
"mtusi-lab2-clean-v2_postgres_data"
],
"memory_limit_bytes": 536870912,
"nano_cpus": 1000000000
},
"redis": {
"id": "eee46ebafd47d00f403ef05b6630ce26559ffcb81f33414f2d08712149a3100d",
"started_at": "2026-10-30T21:47:21.369108706Z",
"image_id": "sha256:90e7a336d044f1abc9e9dbc05d65566850896d11453bbd1dd0fb7e5059f0e8fb",
"user": "",
"volumes": [
"mtusi-lab2-clean-v2_redis_data"
],
"memory_limit_bytes": 201326592,
"nano_cpus": 500000000
}
},
"after": {
"api": {
"id": "c999209e71f1e05cf73dd96ed6a8d332f1d7bdb81961b3fdf44656c54207ddb3",
"started_at": "2026-10-30T21:47:30.173918792Z",
"image_id": "sha256:dab3ec7c7d69de21873d119e07d6348bce002537737d1265baf0908c206fc29d",
"user": "messenger",
"volumes": [],
"memory_limit_bytes": 268435456,
"nano_cpus": 1000000000
},
"postgres": {
"id": "921d8a5c2d722009d9946de24218aad6ca7ab83dcb1b5e3291793830bf7dfd0b",
"started_at": "2026-10-30T21:47:30.087996017Z",
"image_id": "sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3",
"user": "",
"volumes": [
"mtusi-lab2-clean-v2_postgres_data"
],
"memory_limit_bytes": 536870912,
"nano_cpus": 1000000000
},
"redis": {
"id": "eee46ebafd47d00f403ef05b6630ce26559ffcb81f33414f2d08712149a3100d",
"started_at": "2026-10-30T21:47:29.894086274Z",
"image_id": "sha256:90e7a336d044f1abc9e9dbc05d65566850896d11453bbd1dd0fb7e5059f0e8fb",
"user": "",
"volumes": [
"mtusi-lab2-clean-v2_redis_data"
],
"memory_limit_bytes": 201326592,
"nano_cpus": 500000000
}
}
}
+18
View File
@@ -0,0 +1,18 @@
{
"commit": "3b65e93a4996f5093315ff935ccbd8ec53cddeb5",
"status_before": "",
"secrets_present_before": false,
"project": "mtusi-lab2-clean-v2",
"published_port": 18082,
"build_no_cache": true,
"sql_checkout_lf": true,
"result": "PASS",
"independent_secrets": true,
"restart_services": [
"api",
"postgres",
"redis"
],
"public_smoke_through_published_port": "PASS",
"source_clone": "local git clone --no-local"
}
+42
View File
@@ -0,0 +1,42 @@
Network mtusi-lab2-clean-v2_default Creating
Network mtusi-lab2-clean-v2_default Creating
Volume mtusi-lab2-clean-v2_redis_data Creating
Volume mtusi-lab2-clean-v2_redis_data Creating
Volume mtusi-lab2-clean-v2_postgres_data Creating
Volume mtusi-lab2-clean-v2_postgres_data Creating
Volume mtusi-lab2-clean-v2_postgres_data Created
Volume mtusi-lab2-clean-v2_postgres_data Created
Volume mtusi-lab2-clean-v2_redis_data Created
Volume mtusi-lab2-clean-v2_redis_data Created
Network mtusi-lab2-clean-v2_default Created
Network mtusi-lab2-clean-v2_default Created
Container mtusi-lab2-clean-v2-redis-1 Creating
Container mtusi-lab2-clean-v2-postgres-1 Creating
Container mtusi-lab2-clean-v2-redis-1 Created
Container mtusi-lab2-clean-v2-postgres-1 Created
Container mtusi-lab2-clean-v2-migrate-1 Creating
Container mtusi-lab2-clean-v2-migrate-1 Created
Container mtusi-lab2-clean-v2-api-1 Creating
Container mtusi-lab2-clean-v2-api-1 Created
Container mtusi-lab2-clean-v2-redis-1 Starting
Container mtusi-lab2-clean-v2-postgres-1 Starting
Container mtusi-lab2-clean-v2-redis-1 Started
Container mtusi-lab2-clean-v2-postgres-1 Started
Container mtusi-lab2-clean-v2-postgres-1 Waiting
Container mtusi-lab2-clean-v2-postgres-1 Healthy
Container mtusi-lab2-clean-v2-migrate-1 Starting
Container mtusi-lab2-clean-v2-migrate-1 Started
Container mtusi-lab2-clean-v2-migrate-1 Waiting
Container mtusi-lab2-clean-v2-redis-1 Waiting
Container mtusi-lab2-clean-v2-redis-1 Healthy
Container mtusi-lab2-clean-v2-migrate-1 Exited
Container mtusi-lab2-clean-v2-api-1 Starting
Container mtusi-lab2-clean-v2-api-1 Started
Container mtusi-lab2-clean-v2-api-1 Waiting
Container mtusi-lab2-clean-v2-postgres-1 Waiting
Container mtusi-lab2-clean-v2-redis-1 Waiting
Container mtusi-lab2-clean-v2-migrate-1 Waiting
Container mtusi-lab2-clean-v2-migrate-1 Exited
Container mtusi-lab2-clean-v2-redis-1 Healthy
Container mtusi-lab2-clean-v2-postgres-1 Healthy
Container mtusi-lab2-clean-v2-api-1 Healthy
+21
View File
@@ -0,0 +1,21 @@
python3 -m unittest discover -s student-tests -v
ROLLBACK: invalid second member left no chat or membership rows
CONCURRENCY: 10 clients, 100 confirmations, 100 unique messages
FAILURES: Redis/PostgreSQL -> bounded 503, live 200, anonymous 401, recovery with old session
REDIS CRASH: old session survived SIGKILL/AOF replay, expiry deadline unchanged
RACE: 10 requests, 1 created, 9 conflicts, 1 database row
Container mtusi-lab2-clean-v2-checks-run-05a68e33bccb Creating
Container mtusi-lab2-clean-v2-checks-run-05a68e33bccb Created
test_composite_chat_rollback (test_api.APITests.test_composite_chat_rollback) ... ok
test_concurrent_messages (test_api.APITests.test_concurrent_messages) ... ok
test_cursor_binding_and_chat_pages (test_api.APITests.test_cursor_binding_and_chat_pages) ... ok
test_dependency_failures (test_api.APITests.test_dependency_failures) ... ok
test_passwords_and_authentication (test_api.APITests.test_passwords_and_authentication) ... ok
test_redis_crash_durability (test_api.APITests.test_redis_crash_durability) ... ok
test_registration_race (test_api.APITests.test_registration_race) ... ok
test_validation_and_access (test_api.APITests.test_validation_and_access) ... ok
----------------------------------------------------------------------
Ran 8 tests in 12.384s
OK
+61
View File
@@ -0,0 +1,61 @@
{
"result": "PASS",
"utc": "2026-10-30T21:47:57.331317+00:00",
"checks": [
"contract",
"public_smoke",
"8_student_tests",
"all_stores_restart",
"short_expiry",
"explain_10000",
"migration_replay",
"final_smoke"
],
"versions": {
"python": "3.13.15",
"packages": {
"fastapi": "0.141.1",
"pydantic": "2.13.5",
"uvicorn": "0.53.0",
"psycopg": "3.2.10",
"psycopg-pool": "3.2.6",
"redis": "6.4.0"
}
},
"migration_counts_before": "27|12|10113",
"migration_counts_after": "27|12|10113",
"deployment": {
"api": {
"id": "c999209e71f1e05cf73dd96ed6a8d332f1d7bdb81961b3fdf44656c54207ddb3",
"started_at": "2026-10-30T21:47:30.173918792Z",
"image_id": "sha256:dab3ec7c7d69de21873d119e07d6348bce002537737d1265baf0908c206fc29d",
"user": "messenger",
"volumes": [],
"memory_limit_bytes": 268435456,
"nano_cpus": 1000000000
},
"postgres": {
"id": "921d8a5c2d722009d9946de24218aad6ca7ab83dcb1b5e3291793830bf7dfd0b",
"started_at": "2026-10-30T21:47:30.087996017Z",
"image_id": "sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3",
"user": "",
"volumes": [
"mtusi-lab2-clean-v2_postgres_data"
],
"memory_limit_bytes": 536870912,
"nano_cpus": 1000000000
},
"redis": {
"id": "eee46ebafd47d00f403ef05b6630ce26559ffcb81f33414f2d08712149a3100d",
"started_at": "2026-10-30T21:47:29.894086274Z",
"image_id": "sha256:90e7a336d044f1abc9e9dbc05d65566850896d11453bbd1dd0fb7e5059f0e8fb",
"user": "",
"volumes": [
"mtusi-lab2-clean-v2_redis_data"
],
"memory_limit_bytes": 201326592,
"nano_cpus": 500000000
}
},
"published_base_url": "http://127.0.0.1:18082"
}
+4
View File
@@ -0,0 +1,4 @@
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
Container mtusi-lab2-checks-run-b4e1706cc8d3 Creating
Container mtusi-lab2-checks-run-b4e1706cc8d3 Created
+7
View File
@@ -0,0 +1,7 @@
{
"session_ttl_seconds": 2,
"wait_seconds": 2.3,
"before_expiry_status": 200,
"after_expiry_status": 401,
"result": "PASS"
}
+3
View File
@@ -0,0 +1,3 @@
PASS: TTL=2s, initial 200, after 2.3s -> 401; normal API TTL unchanged
Container mtusi-lab2-checks-run-7bb72261a3d9 Creating
Container mtusi-lab2-checks-run-7bb72261a3d9 Created
+4
View File
@@ -0,0 +1,4 @@
python3 scripts/explain_history.py
PASS: 10000 messages, first/middle/late pages use history index; 51 SQL rows for 50 HTTP items
Container mtusi-lab2-checks-run-ce830e513aa3 Creating
Container mtusi-lab2-checks-run-ce830e513aa3 Created
+235
View File
@@ -0,0 +1,235 @@
{
"messages_in_chat": 10000,
"page_limit": 50,
"index": "messages_chat_created_id_idx",
"cases": {
"first": {
"after_message": 0,
"sql": "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s ORDER BY created_at, id LIMIT %s",
"plan": {
"Plan": {
"Node Type": "Limit",
"Parallel Aware": false,
"Async Capable": false,
"Startup Cost": 0.29,
"Total Cost": 5.58,
"Plan Rows": 51,
"Plan Width": 70,
"Actual Startup Time": 0.009,
"Actual Total Time": 0.017,
"Actual Rows": 51,
"Actual Loops": 1,
"Shared Hit Blocks": 3,
"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_chat_created_id_idx",
"Relation Name": "messages",
"Alias": "messages",
"Startup Cost": 0.29,
"Total Cost": 1038.88,
"Plan Rows": 10000,
"Plan Width": 70,
"Actual Startup Time": 0.008,
"Actual Total Time": 0.014,
"Actual Rows": 51,
"Actual Loops": 1,
"Index Cond": "(chat_id = '24b671da-2531-454f-9569-2d97c3d3b45e'::uuid)",
"Rows Removed by Index Recheck": 0,
"Shared Hit Blocks": 3,
"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": 107,
"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.214,
"Triggers": [],
"Execution Time": 0.036
}
},
"middle": {
"after_message": 5000,
"sql": "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s",
"plan": {
"Plan": {
"Node Type": "Limit",
"Parallel Aware": false,
"Async Capable": false,
"Startup Cost": 0.29,
"Total Cost": 7.15,
"Plan Rows": 51,
"Plan Width": 70,
"Actual Startup Time": 0.019,
"Actual Total Time": 0.029,
"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_chat_created_id_idx",
"Relation Name": "messages",
"Alias": "messages",
"Startup Cost": 0.29,
"Total Cost": 665.89,
"Plan Rows": 4945,
"Plan Width": 70,
"Actual Startup Time": 0.018,
"Actual Total Time": 0.025,
"Actual Rows": 51,
"Actual Loops": 1,
"Index Cond": "((chat_id = '24b671da-2531-454f-9569-2d97c3d3b45e'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 21:30:51.163748+00'::timestamp with time zone, '49e8083b-b366-420a-a42e-7dd94e84e990'::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": 0,
"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.044,
"Triggers": [],
"Execution Time": 0.05
}
},
"late": {
"after_message": 9900,
"sql": "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s",
"plan": {
"Plan": {
"Node Type": "Limit",
"Parallel Aware": false,
"Async Capable": false,
"Startup Cost": 0.29,
"Total Cost": 83.03,
"Plan Rows": 51,
"Plan Width": 70,
"Actual Startup Time": 0.006,
"Actual Total Time": 0.017,
"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_chat_created_id_idx",
"Relation Name": "messages",
"Alias": "messages",
"Startup Cost": 0.29,
"Total Cost": 159.29,
"Plan Rows": 98,
"Plan Width": 70,
"Actual Startup Time": 0.006,
"Actual Total Time": 0.014,
"Actual Rows": 51,
"Actual Loops": 1,
"Index Cond": "((chat_id = '24b671da-2531-454f-9569-2d97c3d3b45e'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 21:30:51.168648+00'::timestamp with time zone, '15bb3004-514a-4d41-b783-327659c3269a'::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": 0,
"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.032,
"Triggers": [],
"Execution Time": 0.025
}
}
}
}
+29
View File
@@ -0,0 +1,29 @@
FIRST
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s ORDER BY created_at, id LIMIT %s
Limit (cost=0.29..5.58 rows=51 width=70) (actual time=0.012..0.020 rows=51 loops=1)
Buffers: shared hit=3
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..1038.88 rows=10000 width=70) (actual time=0.011..0.017 rows=51 loops=1)
Index Cond: (chat_id = '24b671da-2531-454f-9569-2d97c3d3b45e'::uuid)
Buffers: shared hit=3
Planning Time: 0.053 ms
Execution Time: 0.030 ms
MIDDLE
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s
Limit (cost=0.29..7.15 rows=51 width=70) (actual time=0.011..0.021 rows=51 loops=1)
Buffers: shared hit=4
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..665.89 rows=4945 width=70) (actual time=0.011..0.017 rows=51 loops=1)
Index Cond: ((chat_id = '24b671da-2531-454f-9569-2d97c3d3b45e'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 21:30:51.163748+00'::timestamp with time zone, '49e8083b-b366-420a-a42e-7dd94e84e990'::uuid)))
Buffers: shared hit=4
Planning Time: 0.052 ms
Execution Time: 0.031 ms
LATE
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s
Limit (cost=0.29..83.03 rows=51 width=70) (actual time=0.008..0.020 rows=51 loops=1)
Buffers: shared hit=4
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..159.29 rows=98 width=70) (actual time=0.007..0.016 rows=51 loops=1)
Index Cond: ((chat_id = '24b671da-2531-454f-9569-2d97c3d3b45e'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 21:30:51.168648+00'::timestamp with time zone, '15bb3004-514a-4d41-b783-327659c3269a'::uuid)))
Buffers: shared hit=4
Planning Time: 0.043 ms
Execution Time: 0.029 ms
+14
View File
@@ -0,0 +1,14 @@
{
"redis": {
"ready_status": 503,
"protected_status": 503,
"elapsed_seconds": 1.003,
"anonymous_status": 401
},
"postgres": {
"ready_status": 503,
"protected_status": 503,
"elapsed_seconds": 1.003,
"anonymous_status": 401
}
}
+37
View File
@@ -0,0 +1,37 @@
{
"api_url": "http://127.0.0.1:18080",
"ready_status": 200,
"services": {
"api": {
"id": "d7b43b2f4a744721ee10aea864bb3defbb13c84e5c242e37cbf79956dc626261",
"started_at": "2026-10-30T21:48:46.355604781Z",
"image_id": "sha256:dab3ec7c7d69de21873d119e07d6348bce002537737d1265baf0908c206fc29d",
"user": "messenger",
"volumes": [],
"memory_limit_bytes": 268435456,
"nano_cpus": 1000000000
},
"postgres": {
"id": "d8375ea156feb08c83f85a4b94e192b60e61d6f3df09f671e9c50750b9f2b46e",
"started_at": "2026-10-30T21:35:48.155522719Z",
"image_id": "sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3",
"user": "",
"volumes": [
"mtusi-lab2_postgres_data"
],
"memory_limit_bytes": 536870912,
"nano_cpus": 1000000000
},
"redis": {
"id": "ddd6a9fad24efbcb9c3025fe4cd10ce2500772d417379bccb35c7c3a90bfee97",
"started_at": "2026-10-30T21:35:48.37486311Z",
"image_id": "sha256:90e7a336d044f1abc9e9dbc05d65566850896d11453bbd1dd0fb7e5059f0e8fb",
"user": "",
"volumes": [
"mtusi-lab2_redis_data"
],
"memory_limit_bytes": 201326592,
"nano_cpus": 500000000
}
}
}
+15
View File
@@ -0,0 +1,15 @@
{
"cpu": [
{
"Name": "Intel(R) Core(TM) i5-9600K CPU @ 3.70GHz",
"NumberOfCores": 6,
"NumberOfLogicalProcessors": 6
}
],
"memory_gib": 31.9,
"docker_server": "29.8.1",
"compose": "5.5.1",
"published_port": "127.0.0.1:18080",
"readiness": 200,
"default_port_8080": "Connection reset on this host; local API_PORT overridden to 18080"
}
+6
View File
@@ -0,0 +1,6 @@
Unchanged: 001_initial.sql
PASS: migrations committed
PASS: LF checkout kept migration ledger unchanged
Unchanged: 001_initial.sql
PASS: migrations committed
PASS: CRLF checkout kept migration ledger unchanged
+4
View File
@@ -0,0 +1,4 @@
Unchanged: 001_initial.sql
PASS: migrations committed
Container mtusi-lab2-migrate-run-ebe3f2f5eae7 Creating
Container mtusi-lab2-migrate-run-ebe3f2f5eae7 Created
+5
View File
@@ -0,0 +1,5 @@
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://api: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.
Container mtusi-lab2-checks-run-c6a8abec432a Creating
Container mtusi-lab2-checks-run-c6a8abec432a Created
+1
View File
@@ -0,0 +1 @@
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+68
View File
@@ -0,0 +1,68 @@
{
"before": {
"api": {
"id": "afbb0567726afe4b878da238a10d935f05860485b3b8d538303fe87ec8a09480",
"started_at": "2026-10-30T21:30:01.813974621Z",
"image_id": "sha256:fb326ae35c17b3e6e8eac43b314a198acc0cb35768a89afbbc1dad80089004c5",
"user": "messenger",
"volumes": [],
"memory_limit_bytes": 268435456,
"nano_cpus": 1000000000
},
"postgres": {
"id": "d8375ea156feb08c83f85a4b94e192b60e61d6f3df09f671e9c50750b9f2b46e",
"started_at": "2026-10-30T21:30:21.917882257Z",
"image_id": "sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3",
"user": "",
"volumes": [
"mtusi-lab2_postgres_data"
],
"memory_limit_bytes": 536870912,
"nano_cpus": 1000000000
},
"redis": {
"id": "ddd6a9fad24efbcb9c3025fe4cd10ce2500772d417379bccb35c7c3a90bfee97",
"started_at": "2026-10-30T21:30:25.782358865Z",
"image_id": "sha256:90e7a336d044f1abc9e9dbc05d65566850896d11453bbd1dd0fb7e5059f0e8fb",
"user": "",
"volumes": [
"mtusi-lab2_redis_data"
],
"memory_limit_bytes": 201326592,
"nano_cpus": 500000000
}
},
"after": {
"api": {
"id": "afbb0567726afe4b878da238a10d935f05860485b3b8d538303fe87ec8a09480",
"started_at": "2026-10-30T21:30:34.407753279Z",
"image_id": "sha256:fb326ae35c17b3e6e8eac43b314a198acc0cb35768a89afbbc1dad80089004c5",
"user": "messenger",
"volumes": [],
"memory_limit_bytes": 268435456,
"nano_cpus": 1000000000
},
"postgres": {
"id": "d8375ea156feb08c83f85a4b94e192b60e61d6f3df09f671e9c50750b9f2b46e",
"started_at": "2026-10-30T21:30:34.034926172Z",
"image_id": "sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3",
"user": "",
"volumes": [
"mtusi-lab2_postgres_data"
],
"memory_limit_bytes": 536870912,
"nano_cpus": 1000000000
},
"redis": {
"id": "ddd6a9fad24efbcb9c3025fe4cd10ce2500772d417379bccb35c7c3a90bfee97",
"started_at": "2026-10-30T21:30:34.206318985Z",
"image_id": "sha256:90e7a336d044f1abc9e9dbc05d65566850896d11453bbd1dd0fb7e5059f0e8fb",
"user": "",
"volumes": [
"mtusi-lab2_redis_data"
],
"memory_limit_bytes": 201326592,
"nano_cpus": 500000000
}
}
}
+4
View File
@@ -0,0 +1,4 @@
python3 tests/smoke.py --base-url "http://api:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
Container mtusi-lab2-checks-run-942aef800efa Creating
Container mtusi-lab2-checks-run-942aef800efa Created
+4
View File
@@ -0,0 +1,4 @@
python3 tests/smoke.py --base-url "http://api:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
Container mtusi-lab2-checks-run-b2982f811b3b Creating
Container mtusi-lab2-checks-run-b2982f811b3b Created
+16
View File
@@ -0,0 +1,16 @@
{
"result": "PASS",
"files_checked": 9,
"scope": "all original contracts and public tests",
"sha256": {
"contracts\\examples.json": "0A71CEC72903AF556DF85F939C7E347FC73A86A1A4FFC39FB9C8DED169B7DF45",
"contracts\\infrastructure.json": "7EFD8B1E6023DDC3FF9747D4F663EE772C1293B782BB9E74BD1C3FBCCA9C68D8",
"contracts\\openapi.json": "CFF3AA6B34855B573401B0AC393FDFE327B6A12DA51F315FBBD67168CE3762C4",
"contracts\\README.md": "72DF27A559F88FFA3FD8C3C79D3C32F6DB2C5986A0602677C51994C434A3FC4F",
"tests\\client.py": "8D50976FC7C7BBB81E88A152F613C61AB25EAF53DBA33C6A9DFAB19F868D546D",
"tests\\load.py": "6D3511EA719C7A7E841083E73D435C86DCBFD9F4E5C2A07D62EB9614B01D9933",
"tests\\README.md": "E0BFA7E196797F6A5BF6E44D8AD2FFEB82651927FF5D8484EB1C2DDA1EC7DEC5",
"tests\\resilience.py": "1F96663A174B3978D24EFF66F2741F5F8C9B788D3242261D37A972720C52788B",
"tests\\smoke.py": "52AC38EB343FF7D43E7543588E1DA58CA06C9FCE74B2B0D0BF0E4982BC23C1DB"
}
}
+24
View File
@@ -0,0 +1,24 @@
Container mtusi-lab2-postgres-1 Running
Container mtusi-lab2-redis-1 Running
Container mtusi-lab2-migrate-1 Recreate
Container mtusi-lab2-migrate-1 Recreated
Container mtusi-lab2-api-1 Recreate
Container mtusi-lab2-api-1 Recreated
Container mtusi-lab2-postgres-1 Waiting
Container mtusi-lab2-postgres-1 Healthy
Container mtusi-lab2-migrate-1 Starting
Container mtusi-lab2-migrate-1 Started
Container mtusi-lab2-migrate-1 Waiting
Container mtusi-lab2-redis-1 Waiting
Container mtusi-lab2-redis-1 Healthy
Container mtusi-lab2-migrate-1 Exited
Container mtusi-lab2-api-1 Starting
Container mtusi-lab2-api-1 Started
Container mtusi-lab2-api-1 Waiting
Container mtusi-lab2-postgres-1 Waiting
Container mtusi-lab2-redis-1 Waiting
Container mtusi-lab2-migrate-1 Waiting
Container mtusi-lab2-redis-1 Healthy
Container mtusi-lab2-migrate-1 Exited
Container mtusi-lab2-postgres-1 Healthy
Container mtusi-lab2-api-1 Healthy
+21
View File
@@ -0,0 +1,21 @@
python3 -m unittest discover -s student-tests -v
ROLLBACK: invalid second member left no chat or membership rows
CONCURRENCY: 10 clients, 100 confirmations, 100 unique messages
FAILURES: Redis/PostgreSQL -> bounded 503, live 200, anonymous 401, recovery with old session
REDIS CRASH: old session survived SIGKILL/AOF replay, expiry deadline unchanged
RACE: 10 requests, 1 created, 9 conflicts, 1 database row
Container mtusi-lab2-checks-run-7f723776bde2 Creating
Container mtusi-lab2-checks-run-7f723776bde2 Created
test_composite_chat_rollback (test_api.APITests.test_composite_chat_rollback) ... ok
test_concurrent_messages (test_api.APITests.test_concurrent_messages) ... ok
test_cursor_binding_and_chat_pages (test_api.APITests.test_cursor_binding_and_chat_pages) ... ok
test_dependency_failures (test_api.APITests.test_dependency_failures) ... ok
test_passwords_and_authentication (test_api.APITests.test_passwords_and_authentication) ... ok
test_redis_crash_durability (test_api.APITests.test_redis_crash_durability) ... ok
test_registration_race (test_api.APITests.test_registration_race) ... ok
test_validation_and_access (test_api.APITests.test_validation_and_access) ... ok
----------------------------------------------------------------------
Ran 8 tests in 12.538s
OK
+60
View File
@@ -0,0 +1,60 @@
{
"result": "PASS",
"utc": "2026-10-30T21:30:59.870582+00:00",
"checks": [
"contract",
"public_smoke",
"8_student_tests",
"all_stores_restart",
"short_expiry",
"explain_10000",
"migration_replay",
"final_smoke"
],
"versions": {
"python": "3.13.15",
"packages": {
"fastapi": "0.141.1",
"pydantic": "2.13.5",
"uvicorn": "0.53.0",
"psycopg": "3.2.10",
"psycopg-pool": "3.2.6",
"redis": "6.4.0"
}
},
"migration_counts_before": "27|12|10113",
"migration_counts_after": "27|12|10113",
"deployment": {
"api": {
"id": "afbb0567726afe4b878da238a10d935f05860485b3b8d538303fe87ec8a09480",
"started_at": "2026-10-30T21:30:34.407753279Z",
"image_id": "sha256:fb326ae35c17b3e6e8eac43b314a198acc0cb35768a89afbbc1dad80089004c5",
"user": "messenger",
"volumes": [],
"memory_limit_bytes": 268435456,
"nano_cpus": 1000000000
},
"postgres": {
"id": "d8375ea156feb08c83f85a4b94e192b60e61d6f3df09f671e9c50750b9f2b46e",
"started_at": "2026-10-30T21:30:34.034926172Z",
"image_id": "sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3",
"user": "",
"volumes": [
"mtusi-lab2_postgres_data"
],
"memory_limit_bytes": 536870912,
"nano_cpus": 1000000000
},
"redis": {
"id": "ddd6a9fad24efbcb9c3025fe4cd10ce2500772d417379bccb35c7c3a90bfee97",
"started_at": "2026-10-30T21:30:34.206318985Z",
"image_id": "sha256:90e7a336d044f1abc9e9dbc05d65566850896d11453bbd1dd0fb7e5059f0e8fb",
"user": "",
"volumes": [
"mtusi-lab2_redis_data"
],
"memory_limit_bytes": 201326592,
"nano_cpus": 500000000
}
}
}
+9
View File
@@ -0,0 +1,9 @@
bind 0.0.0.0
protected-mode yes
port 6379
dir /data
appendonly yes
appendfsync always
save ""
maxmemory 128mb
maxmemory-policy noeviction
+32
View File
@@ -0,0 +1,32 @@
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(),
last_message_at timestamptz NOT NULL DEFAULT '-infinity'
);
CREATE TABLE chat_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 chat_members_user_chat_idx ON chat_members(user_id, chat_id);
CREATE INDEX chats_created_id_idx 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,
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL,
FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members(chat_id, user_id)
);
CREATE INDEX messages_chat_created_id_idx ON messages(chat_id, created_at, id);
+17
View File
@@ -0,0 +1,17 @@
annotated-doc==0.0.5
annotated-types==0.8.0
anyio==4.15.1
click==8.5.0
colorama==0.4.6; sys_platform == 'win32'
fastapi==0.141.1
h11==0.16.0
idna==3.20
pydantic==2.13.5
pydantic-core==2.46.5
starlette==1.6.0
typing-extensions==4.16.0
typing-inspection==0.4.4
uvicorn==0.53.0
psycopg[binary]==3.2.10
psycopg-pool==3.2.6
redis==6.4.0
+35
View File
@@ -0,0 +1,35 @@
"""Run against a separate API configured with SESSION_TTL_SECONDS=2."""
from pathlib import Path
import json
import os
import sys
import time
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, check
def main():
c = Client(os.environ["EXPIRY_BASE_URL"])
deadline = time.monotonic() + 30
while True:
try:
c.call("GET", "/health/ready", schema="Health")
break
except AssertionError:
check(time.monotonic() < deadline, "TTL API did not become ready")
time.sleep(0.25)
actor = c.user("expiry")
c.call("GET", "/api/v1/users/me", actor=actor, schema="User")
time.sleep(2.3)
response = c.call("GET", "/api/v1/users/me", 401, actor=actor)
report = {"session_ttl_seconds": 2, "wait_seconds": 2.3,
"before_expiry_status": 200, "after_expiry_status": response["status"],
"result": "PASS"}
(ROOT / "evidence" / "expiry.json").write_text(json.dumps(report, indent=2) + "\n")
print("PASS: TTL=2s, initial 200, after 2.3s -> 401; normal API TTL unchanged")
if __name__ == "__main__":
main()
+76
View File
@@ -0,0 +1,76 @@
"""Seed an isolated synthetic chat, measure the actual keyset SQL, keep raw plans."""
from datetime import datetime, timedelta, timezone
import json
from pathlib import Path
import sys
from urllib.parse import quote
from uuid import UUID
import psycopg
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
sys.path.insert(0, str(ROOT / "tests"))
from app.config import secret
from app.security import Cursors, stamp
from client import Client, check
def walk(node):
yield node
for child in node.get("Plans", []):
yield from walk(child)
def main():
c = Client()
actor = c.user("explain")
chat = c.call("POST", "/api/v1/chats", 201, actor=actor,
body={"title": "EXPLAIN 10000", "member_ids": [actor["id"]]}, schema="Chat")["json"]
base = datetime.now(timezone.utc)
with psycopg.connect(secret("DATABASE_URL"), connect_timeout=2) as conn:
conn.execute("""INSERT INTO messages(id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), %s, %s, 'synthetic-' || i,
%s + i * interval '1 microsecond'
FROM generate_series(1, 10000) AS i""", (UUID(chat["id"]), UUID(actor["id"]), base))
conn.execute("UPDATE chats SET last_message_at=%s WHERE id=%s",
(base + timedelta(microseconds=10000), UUID(chat["id"])))
conn.execute("ANALYZE messages")
report = {"messages_in_chat": 10000, "page_limit": 50,
"index": "messages_chat_created_id_idx", "cases": {}}
text_plans = []
cursors = Cursors(secret("CURSOR_KEY").encode())
with psycopg.connect(secret("DATABASE_URL"), connect_timeout=2) as conn:
for label, offset in (("first", 0), ("middle", 5000), ("late", 9900)):
sql = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s"
params = [UUID(chat["id"])]
path = "/api/v1/chats/" + chat["id"] + "/messages?limit=50"
if offset:
boundary = conn.execute("SELECT created_at, id FROM messages WHERE chat_id=%s AND text=%s",
(UUID(chat["id"]), "synthetic-" + str(offset))).fetchone()
sql += " AND (created_at, id) > (%s, %s)"
params.extend(boundary)
token = cursors.encode("messages:" + chat["id"],
{"created_at": stamp(boundary[0]), "id": str(boundary[1])})
path += "&cursor=" + quote(token, safe="")
sql += " ORDER BY created_at, id LIMIT %s"
params.append(51)
data = conn.execute("EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) " + sql, params).fetchone()[0][0]
nodes = list(walk(data["Plan"]))
check(not any(x["Node Type"] == "Seq Scan" for x in nodes), "Unexpected full scan in keyset query")
check(any(x.get("Index Name") == report["index"] for x in nodes), "History index not used")
check(data["Plan"]["Actual Rows"] == 51, "LIMIT was not respected")
page = c.call("GET", path, actor=actor, schema="MessagePage")["json"]
check(len(page["items"]) == 50 and page["next_cursor"], "HTTP page differs from measured SQL")
expected = ["synthetic-" + str(i) for i in range(offset + 1, offset + 51)]
check([x["text"] for x in page["items"]] == expected, "HTTP keyset boundary differs")
report["cases"][label] = {"after_message": offset, "sql": sql, "plan": data}
text_plans.append(label.upper() + "\n" + sql + "\n" + "\n".join(
row[0] for row in conn.execute("EXPLAIN (ANALYZE, BUFFERS) " + sql, params).fetchall()))
(ROOT / "evidence" / "explain.json").write_text(json.dumps(report, indent=2) + "\n")
(ROOT / "evidence" / "explain.txt").write_text("\n\n".join(text_plans) + "\n")
print("PASS: 10000 messages, first/middle/late pages use history index; 51 SQL rows for 50 HTTP items")
if __name__ == "__main__":
main()
+35
View File
@@ -0,0 +1,35 @@
"""Create local synthetic credentials once without printing secret values."""
from pathlib import Path
import secrets
ROOT = Path(__file__).resolve().parents[1]
def main():
directory = ROOT / "secrets"
directory.mkdir(exist_ok=True)
for name in ("postgres_password", "redis_password", "cursor_key"):
path = directory / name
if not path.exists():
path.write_text(secrets.token_hex(32) + "\n", encoding="utf-8", newline="\n")
else:
# Shell command substitution on Linux must not retain a Windows CR.
value = path.read_text(encoding="utf-8").strip()
path.write_text(value + "\n", encoding="utf-8", newline="\n")
pg_password = (directory / "postgres_password").read_text().strip()
redis_password = (directory / "redis_password").read_text().strip()
for name, value in {
"database_url": f"postgresql://messenger:{pg_password}@postgres:5432/messenger",
"cache_url": f"redis://:{redis_password}@redis:6379/0",
}.items():
path = directory / name
if not path.exists():
path.write_text(value + "\n", encoding="utf-8", newline="\n")
env = ROOT / ".env"
if not env.exists():
env.write_bytes((ROOT / ".env.example").read_bytes())
print("PASS: local .env and secret files exist; existing values preserved")
if __name__ == "__main__":
main()
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart --timeout 5 api postgres redis
+114
View File
@@ -0,0 +1,114 @@
"""One reproducible local check: public tests, failures, expiry and SQL plans."""
import argparse
from datetime import datetime, timezone
import json
import os
from pathlib import Path
import subprocess
ROOT = Path(__file__).resolve().parents[1]
EVIDENCE = ROOT / "evidence"
def command(args, output=None, timeout=300):
result = subprocess.run(args, cwd=ROOT, capture_output=True, text=True,
encoding="utf-8", errors="replace", timeout=timeout)
if output:
(EVIDENCE / output).write_text(result.stdout + result.stderr, encoding="utf-8")
if result.returncode:
raise RuntimeError("Command failed; see " + (output or "local Docker status"))
return result.stdout.strip()
def compose(*args, **kwargs):
return command(["docker", "compose", "--env-file", ".env", *args], **kwargs)
def checks(*args, output):
return compose("run", "--rm", "--no-deps", "checks", *args, output=output)
def snapshot():
result = {}
for service in ("api", "postgres", "redis"):
identifier = compose("ps", "--all", "--quiet", service)
data = json.loads(command(["docker", "inspect", identifier]))[0]
result[service] = {"id": data["Id"], "started_at": data["State"]["StartedAt"],
"image_id": data["Image"], "user": data["Config"]["User"],
"volumes": [item["Name"] for item in data["Mounts"] if item["Type"] == "volume"],
"memory_limit_bytes": data["HostConfig"]["Memory"],
"nano_cpus": data["HostConfig"]["NanoCpus"]}
return result
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--skip-build", action="store_true")
parser.add_argument("--published-base-url", help="Optional host URL for a second public smoke through the published port")
args = parser.parse_args()
EVIDENCE.mkdir(exist_ok=True)
command([os.sys.executable, "scripts/init_local.py"])
compose("config", "--quiet")
if not args.skip_build:
print("Building runtime and check images", flush=True)
compose("build", "api", "checks", output="build.txt", timeout=600)
compose("up", "-d", "--wait", "--wait-timeout", "90", output="startup.txt", timeout=150)
print("Running contract, public smoke and student integration tests", flush=True)
checks("make", "check", output="contract-check.txt")
checks("make", "test", output="smoke.txt")
checks("make", "test-student", output="student-tests.txt")
print("Running unchanged public persistence test", flush=True)
before = snapshot()
checks("sh", "-ec", "chmod +x scripts/restart.sh; make test-persistence ACTION_SCRIPT=scripts/restart.sh",
output="persistence.txt")
after = snapshot()
for service in before:
assert before[service]["id"] == after[service]["id"], "Unexpected container replacement"
assert before[service]["started_at"] != after[service]["started_at"], "Service was not restarted"
assert before[service]["volumes"] == after[service]["volumes"], "Volumes changed"
(EVIDENCE / "restart.json").write_text(json.dumps({"before": before, "after": after}, indent=2) + "\n")
print("Testing short expiry in a separate API process", flush=True)
project = os.environ.get("COMPOSE_PROJECT_NAME", "mtusi-lab2")
# Read the configured project name from normalized compose metadata, not local paths.
project = json.loads(compose("config", "--format", "json"))["name"]
ttl_name = project + "-ttl-check"
existing = command(["docker", "ps", "-a", "--filter", "name=^/" + ttl_name + "$", "--format", "{{.ID}}"])
if existing:
raise RuntimeError("TTL test container name already exists; it was not removed")
created = False
try:
compose("run", "-d", "--no-deps", "--name", ttl_name, "-e", "SESSION_TTL_SECONDS=2", "api")
created = True
compose("run", "--rm", "--no-deps", "-e", "EXPIRY_BASE_URL=http://" + ttl_name + ":8080",
"checks", "python", "scripts/check_expiry.py", output="expiry.txt")
finally:
if created:
command(["docker", "stop", "--time", "5", ttl_name])
command(["docker", "rm", ttl_name])
print("Measuring first, middle and late history pages on 10000 messages", flush=True)
checks("make", "explain", output="explain-run.txt")
counts_before = compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-Atc",
"SELECT (SELECT count(*) FROM users),(SELECT count(*) FROM chats),(SELECT count(*) FROM messages)")
compose("run", "--rm", "--no-deps", "migrate", output="migrations-repeat.txt")
counts_after = compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-Atc",
"SELECT (SELECT count(*) FROM users),(SELECT count(*) FROM chats),(SELECT count(*) FROM messages)")
assert counts_before == counts_after, "Migration replay changed business data"
checks("make", "test", output="smoke-final.txt")
if args.published_base_url:
command([os.sys.executable, "tests/smoke.py", "--base-url", args.published_base_url],
output="published-smoke.txt")
versions = compose("exec", "-T", "api", "python", "-c",
"import importlib.metadata as m,json,platform; print(json.dumps({'python':platform.python_version(),"
"'packages':{p:m.version(p) for p in ['fastapi','pydantic','uvicorn','psycopg','psycopg-pool','redis']}}))")
summary = {"result": "PASS", "utc": datetime.now(timezone.utc).isoformat(),
"checks": ["contract", "public_smoke", "8_student_tests", "all_stores_restart", "short_expiry",
"explain_10000", "migration_replay", "final_smoke"],
"versions": json.loads(versions), "migration_counts_before": counts_before,
"migration_counts_after": counts_after, "deployment": after,
"published_base_url": args.published_base_url}
(EVIDENCE / "verification.json").write_text(json.dumps(summary, indent=2) + "\n")
print("PASS: all grade-4 checks; summaries saved under evidence/", flush=True)
if __name__ == "__main__":
main()
+215
View File
@@ -0,0 +1,215 @@
"""Integration tests against real HTTP, PostgreSQL and Redis on the local stack."""
from concurrent.futures import ThreadPoolExecutor
import base64
import hashlib
import json
from pathlib import Path
import subprocess
import sys
import time
import unittest
from urllib.parse import quote
from uuid import uuid4
import psycopg
import redis
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client
from app.config import secret
class APITests(unittest.TestCase):
def setUp(self):
self.c = Client(timeout=8)
self.alice = self.c.user("student")
self.bob = self.c.user("member")
self.chat = self.c.call("POST", "/api/v1/chats", 201, actor=self.alice,
body={"title": "Учебный чат", "member_ids": [self.alice["id"], self.bob["id"]]},
schema="Chat")["json"]
self.path = "/api/v1/chats/" + self.chat["id"]
def scalar(self, query, params=()):
with psycopg.connect(secret("DATABASE_URL"), connect_timeout=2) as conn:
return conn.execute(query, params).fetchone()[0]
def history(self, limit=17):
result, cursor = [], None
for _ in range(100):
path = self.path + "/messages?limit=" + str(limit)
if cursor:
path += "&cursor=" + quote(cursor, safe="")
page = self.c.call("GET", path, actor=self.alice, schema="MessagePage")["json"]
result.extend(page["items"])
cursor = page["next_cursor"]
if cursor is None:
return result
self.fail("Pagination did not terminate")
def test_registration_race(self):
registration = {"username": "race_" + uuid4().hex[:16], "display_name": "Гонка",
"password": "Synthetic-password-12345"}
def register(_):
return self.c.call("POST", "/api/v1/users", [201, 409], body=registration,
schema="User")["status"]
with ThreadPoolExecutor(max_workers=10) as pool:
statuses = list(pool.map(register, range(10)))
self.assertEqual(statuses.count(201), 1)
self.assertEqual(statuses.count(409), 9)
self.assertEqual(self.scalar("SELECT count(*) FROM users WHERE username=%s",
(registration["username"],)), 1)
print("RACE: 10 requests, 1 created, 9 conflicts, 1 database row", flush=True)
def test_composite_chat_rollback(self):
before = self.scalar("SELECT count(*) FROM chats")
memberships = self.scalar("SELECT count(*) FROM chat_members")
self.c.call("POST", "/api/v1/chats", 400, actor=self.alice,
body={"title": "Rollback", "member_ids": [self.alice["id"], str(uuid4())]})
self.assertEqual(self.scalar("SELECT count(*) FROM chats"), before)
self.assertEqual(self.scalar("SELECT count(*) FROM chat_members"), memberships)
self.assertEqual(self.scalar("SELECT count(*) FROM chats c WHERE NOT EXISTS "
"(SELECT 1 FROM chat_members m WHERE m.chat_id=c.id)"), 0)
print("ROLLBACK: invalid second member left no chat or membership rows", flush=True)
def test_concurrent_messages(self):
def send(index):
return self.c.message(self.alice, self.chat, "parallel-" + str(index))["json"]["id"]
with ThreadPoolExecutor(max_workers=10) as pool:
ids = list(pool.map(send, range(100)))
messages = self.history()
self.assertEqual(len(messages), 100)
self.assertEqual(len(set(ids)), 100)
self.assertEqual({row["id"] for row in messages}, set(ids))
self.assertEqual({row["text"] for row in messages}, {"parallel-" + str(i) for i in range(100)})
self.assertEqual(messages, sorted(messages, key=lambda row: (row["created_at"], row["id"])))
print("CONCURRENCY: 10 clients, 100 confirmations, 100 unique messages", flush=True)
def test_validation_and_access(self):
for payload in [b"{", b"null", b"[]", b"\xff", b'{"text":NaN}']:
self.c.call("POST", self.path + "/messages", 400, actor=self.alice, raw=payload,
headers={"Content-Type": "application/json"})
for body in [{"text": ""}, {"text": " \n\t"}, {"text": 123}, {"text": "x" * 4001},
{"text": "hello", "sender_id": self.bob["id"]}]:
self.c.call("POST", self.path + "/messages", 400, actor=self.alice, body=body)
outsider = self.c.user("outsider")
for suffix in ("", "/messages"):
self.c.call("GET", self.path + suffix, 404, actor=outsider)
self.c.call("POST", self.path + "/messages", 404, actor=outsider, body={"text": "hidden"})
for members in [[self.bob["id"]], [self.alice["id"], self.alice["id"]], ["bad"], []]:
self.c.call("POST", "/api/v1/chats", 400, actor=self.alice,
body={"title": "Invalid", "member_ids": members})
self.c.call("GET", "/api/v1/chats/not-uuid", 400, actor=self.alice)
for limit in ("0", "101", "1.1", "-1", "", "true"):
self.c.call("GET", self.path + "/messages?limit=" + limit, 400, actor=self.alice)
self.c.call("POST", "/api/v1/users", 409, body=self.alice["registration"])
for raw in (b"{}", b'{"username":123}', b'{"username":"ab","display_name":"x","password":"123456789012"}'):
self.c.call("POST", "/api/v1/users", 400, raw=raw, headers={"Content-Type": "application/json"})
def test_passwords_and_authentication(self):
registration = {"username": "unicode_" + uuid4().hex[:12], "display_name": "Имя 🧪",
"password": "я:🧪" + "密" * 125}
user = self.c.call("POST", "/api/v1/users", 201, body=registration, schema="User")["json"]
credential = base64.b64encode((registration["username"] + ":" + registration["password"]).encode()).decode()
session = self.c.call("POST", "/api/v1/auth/sessions", 201,
headers={"Authorization": "Basic " + credential}, schema="Session")["json"]
self.assertEqual(session["user"]["id"], user["id"])
encoded = self.scalar("SELECT password_hash FROM users WHERE id=%s", (user["id"],))
algorithm, n, r, p, salt, digest = encoded.split("$")
self.assertEqual(algorithm, "scrypt")
actual = hashlib.scrypt(registration["password"].encode(), salt=bytes.fromhex(salt),
n=int(n), r=int(r), p=int(p), dklen=32, maxmem=64 * 1024 * 1024).hex()
self.assertTrue(actual == digest)
self.assertNotIn("password", user)
for username in (registration["username"], "missing_" + uuid4().hex[:12]):
bad = base64.b64encode((username + ":wrong-password-123").encode()).decode()
response = self.c.call("POST", "/api/v1/auth/sessions", 401,
headers={"Authorization": "Basic " + bad})
self.assertEqual(response["headers"]["WWW-Authenticate"], 'Basic realm="messenger", charset="UTF-8"')
self.assertEqual(response["json"]["error"]["message"], "Valid credentials required")
self.c.call("GET", "/api/v1/users/me", 401, headers={"Authorization": "Basic " + credential})
self.c.call("GET", "/api/v1/users/me", 401, headers={"X-User-Id": user["id"]})
self.c.call("GET", "/api/v1/users/me", 401, headers={"Authorization": "Bearer " + "x" * 43})
actor = {"id": user["id"], "token": session["token"]}
self.c.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=actor)
self.c.call("GET", "/api/v1/users/me", 401, actor=actor)
self.c.call("DELETE", "/api/v1/auth/sessions/current", 401, actor=actor)
def test_cursor_binding_and_chat_pages(self):
sent = [self.c.message(self.alice, self.chat, "page-" + str(i))["json"] for i in range(7)]
self.assertEqual(self.history(limit=2), sent)
page = self.c.call("GET", self.path + "/messages?limit=2", actor=self.alice, schema="MessagePage")["json"]
cursor = page["next_cursor"]
other = self.c.call("POST", "/api/v1/chats", 201, actor=self.alice,
body={"title": "Other", "member_ids": [self.alice["id"]]}, schema="Chat")["json"]
self.c.call("GET", "/api/v1/chats/" + other["id"] + "/messages?cursor=" + quote(cursor), 400, actor=self.alice)
for token in ("bad", "", cursor[:-3] + "xxx"):
self.c.call("GET", self.path + "/messages?cursor=" + quote(token), 400, actor=self.alice)
later = self.c.message(self.alice, self.chat, "later")["json"]
continued = self.c.call("GET", self.path + "/messages?limit=100&cursor=" + quote(cursor),
actor=self.alice, schema="MessagePage")["json"]
self.assertEqual(continued["items"], sent[2:] + [later])
first = self.c.call("GET", "/api/v1/chats?limit=1", actor=self.alice, schema="ChatPage")["json"]
second = self.c.call("GET", "/api/v1/chats?limit=100&cursor=" + quote(first["next_cursor"]),
actor=self.alice, schema="ChatPage")["json"]
self.assertEqual([row["id"] for row in first["items"] + second["items"]],
[self.chat["id"], other["id"]])
def compose(self, *args):
result = subprocess.run(["docker", "compose", "--env-file", ".env", *args], cwd=ROOT,
capture_output=True, text=True, timeout=45)
if result.returncode:
self.fail("Compose action failed: " + " ".join(args[:2]))
def wait_ready(self):
deadline = time.monotonic() + 40
while time.monotonic() < deadline:
try:
self.c.call("GET", "/health/ready", schema="Health")
return
except AssertionError:
time.sleep(0.25)
self.fail("Stack did not recover")
def test_dependency_failures(self):
report = {}
for service in ("redis", "postgres"):
self.compose("stop", "--timeout", "2", service)
try:
self.c.call("GET", "/health/live", schema="Health")
ready = self.c.call("GET", "/health/ready", 503)
started = time.monotonic()
response = self.c.call("GET", "/api/v1/users/me", 503, actor=self.alice)
elapsed = time.monotonic() - started
self.assertEqual(response["json"]["error"]["code"], "unavailable")
self.assertLess(elapsed, 6)
self.c.call("GET", "/api/v1/users/me", 401, headers={"X-User-Id": self.alice["id"]})
report[service] = {"ready_status": ready["status"], "protected_status": response["status"],
"elapsed_seconds": round(elapsed, 3), "anonymous_status": 401}
finally:
self.compose("start", service)
self.wait_ready()
self.c.call("GET", "/api/v1/users/me", actor=self.alice, schema="User")
self.c.message(self.alice, self.chat, "after-" + service)
(ROOT / "evidence" / "failures.json").write_text(json.dumps(report, indent=2) + "\n")
print("FAILURES: Redis/PostgreSQL -> bounded 503, live 200, anonymous 401, recovery with old session", flush=True)
def test_redis_crash_durability(self):
client = redis.Redis.from_url(secret("CACHE_URL"), decode_responses=True)
try:
self.assertEqual(client.config_get("appendonly")["appendonly"], "yes")
self.assertEqual(client.config_get("appendfsync")["appendfsync"], "always")
key = "session:" + hashlib.sha256(self.alice["token"].encode()).hexdigest()
deadline_before = client.pexpiretime(key)
self.compose("kill", "--signal", "SIGKILL", "redis")
self.compose("start", "redis")
self.wait_ready()
self.c.call("GET", "/api/v1/users/me", actor=self.alice, schema="User")
self.assertEqual(client.pexpiretime(key), deadline_before)
finally:
client.close()
print("REDIS CRASH: old session survived SIGKILL/AOF replay, expiry deadline unchanged", flush=True)
if __name__ == "__main__":
unittest.main()