ЛР 2 — БВТ2301 — Парамонов — на 5 #62
@@ -0,0 +1,3 @@
|
||||
* text=auto eol=lf
|
||||
*.png binary
|
||||
*.jpg binary
|
||||
@@ -1,18 +1,11 @@
|
||||
## Лабораторная 2
|
||||
|
||||
Автор / группа: TODO
|
||||
Целевая оценка (3/4/5): TODO
|
||||
Трек 5, если заявлен: TODO
|
||||
Парамонов Глеб, БВТ2301. Цель: 5, трек 2 «План запроса и восстановление».
|
||||
|
||||
Что реализовано и что перенесено: TODO
|
||||
Команды запуска из чистого clone: TODO
|
||||
Результаты проверок и ссылка на REPORT.md: TODO
|
||||
Ограничения / известные ошибки: TODO
|
||||
Источники и использование ИИ: TODO
|
||||
Перенесён собственный API ЛР1 в PostgreSQL: транзакции и миграции, Argon2id, Basic → opaque Bearer, expiry/logout, Valkey-кэш профилей. Источник истины — PostgreSQL; отказ кэша допускается, отказ БД возвращает ограниченную ошибку.
|
||||
|
||||
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
|
||||
- [ ] Контракт и публичные тесты не ослаблены.
|
||||
- [ ] make check и make test выполнены; приложен реальный вывод.
|
||||
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
|
||||
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
|
||||
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
|
||||
Проверено: public smoke/persistence, гонка регистрации (1×201,7×409), rollback чата, 100 конкурентных сообщений, короткий TTL, logout, cache/DB down и восстановление. На 120000 сообщений сравнены 3 индекса × 2 запроса и стоимость INSERT; backup восстановлен в новый volume со сверкой counts,20 сообщений и всей истории. Keyset+compound:0.049мс против19.717мс; цена записи5000:140.445мс против112.982мс. HTTP:136.35RPS,0% ошибок, p95=122.238мс.
|
||||
|
||||
Запуск: `python3 scripts/bootstrap.py && docker compose up -d --build --wait`; затем `make test`, `make verify`, `make experiment` (зависимости/Windows-команды в REPORT.md).
|
||||
|
||||
[Отчёт и доказательства](../src/branch/solution/bvt2301-paramonov/REPORT.md). Ограничения: один host/БД, HTTP только локально, backup без PITR, короткие closed-loop измерения. Исходные контракты/tests сохранены. Использована помощь OpenAI Codex; данные измерены реальным запуском.
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
# План хранения и транзакций
|
||||
|
||||
PostgreSQL — источник истины для пользователей, сессий, чатов, членства и сообщений.
|
||||
Данные пользователей неизменяемы в обязательном API. Valkey кэширует именно их
|
||||
публичное представление на 60 секунд; действительность сессии проверяется в PostgreSQL
|
||||
при каждом запросе. Поэтому отказ кэша не отменяет logout/expiry и не даёт доступ
|
||||
анонимному клиенту. При отказе PostgreSQL защищённые запросы получают 503.
|
||||
|
||||
users: UUID PK, UNIQUE username, display_name, password_hash (Argon2id), created_at.
|
||||
sessions: SHA-256 случайного 256-битного токена PK, user FK, expires_at, created_at.
|
||||
chats: UUID PK, title, created_at.
|
||||
members: (chat_id, user_id) PK и внешние ключи на chats/users.
|
||||
messages: UUID PK, chat FK, sender FK, text, created_at; составной FK на members
|
||||
не позволяет записать отправителя вне чата даже при ошибке в приложении.
|
||||
|
||||
Создание чата и всех его участников — одна транзакция. Создание сообщения — одна
|
||||
транзакция после проверки доступа. Регистрация защищена UNIQUE, гонка завершается
|
||||
одним 201 и остальными 409. Logout удаляет сессию в транзакции; Valkey не хранит
|
||||
разрешение на вход. Ранее начавшийся запрос может завершиться одновременно с logout.
|
||||
|
||||
История: индекс (chat_id, created_at, id), keyset по (created_at,id), LIMIT n+1.
|
||||
Отдельный индекс members(user_id,chat_id) ускоряет список доступных чатов. Часы БД
|
||||
единые, но страницы между запросами не являются snapshot: конкурентная незавершённая
|
||||
транзакция может стать видимой позднее курсора. Для неизменной истории пропусков нет.
|
||||
|
||||
Пул ограничен 5 соединениями, ожидание 2 секунды; statement_timeout=2s,
|
||||
lock_timeout=1s. KDF ограничен четырьмя параллельными задачами. Cursor подписан
|
||||
общим локально генерируемым секретом, который сохраняется при рестарте.
|
||||
|
||||
Миграции нумеруются, учитываются в schema_migrations, защищены advisory lock.
|
||||
Отдельный одноразовый сервис migrate запускается до API. Повторный запуск проверяет
|
||||
хеши применённых миграций, не пересоздаёт таблицы и не seed-ит данные.
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
# Google public mirror of the official Docker Python image; immutable digest.
|
||||
FROM mirror.gcr.io/library/python@sha256:34386ef0cb081344d7ec1c103ba398e6e9f64e9ab3a1509accc92a4e24a07258
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 PYTHONUTF8=1 \
|
||||
APP_HOST=0.0.0.0 APP_PORT=8080
|
||||
WORKDIR /app
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt && \
|
||||
groupadd --gid 10001 messenger && useradd --uid 10001 --gid 10001 --no-create-home messenger
|
||||
COPY src ./src
|
||||
COPY migrations ./migrations
|
||||
USER 10001:10001
|
||||
EXPOSE 8080
|
||||
STOPSIGNAL SIGTERM
|
||||
HEALTHCHECK --interval=5s --timeout=2s --start-period=5s --retries=3 \
|
||||
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=1)"
|
||||
CMD ["python", "-m", "src"]
|
||||
@@ -24,3 +24,19 @@ load:
|
||||
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: up down verify experiment
|
||||
up:
|
||||
$(PYTHON) scripts/bootstrap.py
|
||||
docker compose up -d --build --wait
|
||||
|
||||
down:
|
||||
docker compose down
|
||||
|
||||
verify:
|
||||
$(PYTHON) scripts/verify_stack.py
|
||||
|
||||
experiment:
|
||||
$(PYTHON) scripts/index_experiment.py
|
||||
$(PYTHON) scripts/load_experiment.py
|
||||
$(PYTHON) scripts/plot_experiment.py
|
||||
|
||||
@@ -1,37 +1,87 @@
|
||||
# Отчёт — лабораторная 2
|
||||
# Лабораторная 2 — PostgreSQL, сессии и Valkey
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
Автор: **Парамонов Глеб, БВТ2301**. Цель: **5**, трек 2 «План запроса и восстановление».
|
||||
Ветка: `solution/bvt2301-paramonov`. Код собственной ЛР1 перенесён и переработан для SQL и Bearer. Работа подготовлена с помощью OpenAI Codex (реализация, тесты, диагностика и оформление); измерения получены запуском реального стенда, не моделированием результатов. README, COURSE, обязательные contracts и публичные tests сохранены.
|
||||
|
||||
## Запуск из чистого clone
|
||||
## Чистый запуск
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Нужны Docker Engine с Linux containers, Compose v2, Python 3.12+; для make-целей GNU Make. На Windows используется Docker Desktop/WSL2, команды Python запускать с `-X utf8`. Команды выполняются из корня этого репозитория; соседние лабораторные не нужны.
|
||||
|
||||
## Архитектура и решения
|
||||
```sh
|
||||
python3 -m venv .venv
|
||||
.venv/bin/python -m pip install -r requirements-test.txt -r requirements-dev.txt
|
||||
python3 scripts/bootstrap.py
|
||||
docker compose config --quiet
|
||||
docker compose up -d --build --wait
|
||||
make check validate test PYTHON=.venv/bin/python
|
||||
make test-persistence PYTHON=.venv/bin/python ACTION_SCRIPT=scripts/restart.sh
|
||||
make verify PYTHON=.venv/bin/python
|
||||
make experiment PYTHON=.venv/bin/python
|
||||
```
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Windows: вместо `.venv/bin/python` используйте `.venv/Scripts/python.exe -X utf8`. `python scripts/verify_stack.py` сам создаёт временный Windows hook для неизменённого public persistence test. На Linux используется исполняемый `scripts/restart.sh`. Тесты создают только синтетические данные и на короткое время останавливают зависимости учебного стенда.
|
||||
|
||||
## Доказательства критериев
|
||||
Bootstrap один раз создаёт `.env` с случайным паролем БД и HMAC-secret, при повторе сохраняет существующий файл. Переменные из исходного `.env.example` сопоставлены так: `DATABASE_URL_FILE` → локальный `DATABASE_URL`, `CACHE_URL_FILE` → `REDIS_URL`, `SESSION_STORE=postgres` соответствует фактическому источнику сессий. `SESSION_TTL_SECONDS` используется прямо; `APP_HOST/APP_PORT` задаются Dockerfile. Файловые secrets в этой лабораторной не реализованы. `.env`, backups и volumes исключены из Git. `docker compose config` без `--quiet` может показать секреты — не публикуйте его вывод.
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
Остановка с сохранением данных: `docker compose down`. **Намеренный сброс только учебного стенда**, если данные больше не нужны: `docker compose down -v`. Удалять volume для проверки сохранности нельзя.
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
Python 3.12.15, PostgreSQL 17.11, Valkey 8.1 (точные образы закреплены digest в Dockerfile/compose). Docker Hub на машине возвращал 403, поэтому используется публичное зеркало официальных образов `mirror.gcr.io`. Python-зависимости закреплены в requirements.txt. API запускается непривилегированным UID 10001 с read-only FS и без capabilities; порт опубликован только на 127.0.0.1:8080. PostgreSQL и Valkey доступны только в Docker-сети.
|
||||
|
||||
## Эксперименты и отказы
|
||||
## Архитектура и гарантии
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Клиент → FastAPI/Uvicorn (1 процесс) → PostgreSQL; Valkey хранит кэш **неизменяемого публичного профиля пользователя** на 60 секунд. Пользователи/чаты/участники/сообщения/сессии — только PostgreSQL. Перед каждым cache lookup проверяется сессия SQL-запросом; наличие профиля в кэше не даёт доступ после logout/expiry. История не кэшируется: подтверждённый COMMIT виден следующему чтению. Потеря кэша допустима, потеря БД возвращает 503. Readiness зависит от БД, liveness — от процесса.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
Схема и транзакционные решения предварительно описаны в [ARCHITECTURE.md](ARCHITECTURE.md). PK/FK/UNIQUE/CHECK защищают целостность. Чат и все его участники записываются в одной транзакции; ошибка FK откатывает чат. Миграции выполняются отдельным сервисом до API, сериализованы advisory lock, имя и SHA-256 применённого SQL фиксируются; изменение уже применённой миграции запрещено.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
Argon2id: memory_cost=32768 KiB, time_cost=2, parallelism=1; одновременно до четырёх KDF в отдельных потоках. Пароль UTF-8 не усекается. Basic применяется только при входе, Bearer — на бизнес-маршрутах. Токен — 32 случайных байта; в БД хранится SHA-256, не сам токен. Expiry проверяется по времени БД, TTL не продлевается при чтении/рестарте. Logout удаляет строку сессии. Полные токены, пароли, тела и SQL не выводятся в журналы приложения.
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Пул: 1–5 соединений, ожидание 2 с, очередь до 32; connect 3 с, SQL statement 2 с, lock 1 с. HTTP deadline 8 с, inflight 32, body 32 KiB; Valkey connect/read 0.2 с. При отказе ограничены очередь и время ожидания. SQL параметризован. Динамические SQL-имена есть только в локальном эксперименте с фиксированными таблицами/сгенерированной БД.
|
||||
|
||||
Keyset `(created_at,id)` опирается на индекс `(chat_id,created_at,id)`. HMAC cursor общий и связан с ресурсом. На неизменной истории нет повторов. Между HTTP-страницами нет общего snapshot: поздно завершённая конкурентная транзакция с более ранним timestamp может оказаться перед уже выданным cursor; часы не считаются уникальным ID.
|
||||
|
||||
## Проверки критериев
|
||||
|
||||
| Критерий | Команда / наблюдение | Доказательство |
|
||||
|---|---|---|
|
||||
| Контракт и API | `make check validate test`: структура, OpenAPI, публичный smoke | `evidence/checks.txt`, `integration.json` |
|
||||
| PostgreSQL, миграции с нуля/повторно | Compose migrate; повтор сообщает Already applied | `migrations/001_initial.sql`, `integration.json` |
|
||||
| Сохранность всех данных/действующей сессии | public persistence перезапускает api, db, cache без удаления volumes; тот же token читает те же данные | `integration.json`, `restart-processes.json` с изменившимися StartedAt всех трёх процессов |
|
||||
| KDF, Basic/Bearer/expiry/logout | неправильный пароль и X-User-Id →401; отдельный API TTL2: 200, затем401 через2.2с; logout204, затем401 | `scripts/verify_stack.py`, `integration.json` |
|
||||
| Составная транзакция/гонка username | неизвестный участник400 и неизменное число чатов; 8 конкурентных регистраций: одна201, семь409 | `integration.json` |
|
||||
| Конкурентные записи/пагинация | 100 сообщений/10 потоков, прочитаны все 100 уникальных ID страницами по17 | `integration.json` |
|
||||
| Осмысленный Valkey/TTL/отказ | 5 повторных обращений дали +5 cache hits; при stop cache запрос200 за0.211с | `integration.json`, `src/store.py` |
|
||||
| SQL pool/timeouts/отказ БД | при stop db запрос503 за0.009с, без credentials401; после start сессия снова работает | `integration.json` |
|
||||
| Индекс и EXPLAIN ≥10000 | 120000 сообщений; все EXPLAIN ANALYZE BUFFERS сохранены | `index-restore.json` |
|
||||
| Трек5: ≥2 индекса, запись, backup/new store | три варианта индекса × два запроса, пять повторов, restore в новый volume | `index-restore.json`, `indexes.png` |
|
||||
|
||||
## Эксперимент: планы и восстановление
|
||||
|
||||
Гипотеза: compound index позволяет читать глубокую страницу без перебора предыдущих строк; поддержка индекса повышает цену INSERT. `python scripts/index_experiment.py` создаёт отдельную synthetic database (основные таблицы приложения не меняются). 120000 сообщений: чаты 100000/15000/5000, текст около160 символов. Сравнивается страница 70001–70050 большого чата. Keyset использует сохранённый tuple предыдущей строки; OFFSET пропускает70000. Два прогрева + пять EXPLAIN на каждую комбинацию, тёплый cache. Для записи пять **зафиксированных** INSERT по5000, очистка только добавленных synthetic rows и VACUUM между повторами. Полные планы, buffers и каждый замер в JSON.
|
||||
|
||||
| Индекс истории | Keyset, медиана мс | OFFSET, медиана мс | INSERT5000+COMMIT, медиана мс |
|
||||
|---|---:|---:|---:|
|
||||
| Только PK(id) | 19.717 | 171.559 | 112.982 |
|
||||
| (chat_id) | 14.577 | 172.957 | 134.971 |
|
||||
| (chat_id,created_at,id) | 0.049 | 14.827 | 140.445 |
|
||||
|
||||
Выбран compound+keyset: примерно402× быстрее primary-only keyset в этом тёплом SQL-микротесте, при +24.3% медианной стоимости пакетной записи. Это не402× ускорение всего HTTP API: сеть, авторизация и сериализация здесь не измеряются. Простого chat_id недостаточно для упорядоченной глубокой страницы. Последовательный порядок вариантов и один ноутбук ограничивают причинные выводы; холодный cache и большие рабочие наборы не исследовались.
|
||||
|
||||

|
||||
|
||||
`pg_dump -Fc` дал3592366 байт за1.247с. `pg_restore --exit-on-error` в **отдельный PostgreSQL-контейнер и новый именованный volume**:4.026с включая ожидание старта. Совпали counts пользователей1/чатов3/участников3/сообщений120000/сессий0,20 выбранных сообщений и агрегатный digest всех сообщений. Dump лежит локально в ignored `backups/`; restore-контейнер и его synthetic volume удаляются самим экспериментом, исходная synthetic database остаётся для осмотра. Это snapshot логической копии: записи после snapshot могут быть потеряны, WAL/PITR и репликация не настроены. MD5 здесь только проверка равенства синтетических строк, не защита паролей или подпись.
|
||||
|
||||
## Нагрузка и ресурсы
|
||||
|
||||
Машина: Windows10/WSL2/Docker28.0.1, i5-11400H,8GB RAM, WSL4CPU/3GB RAM. Лимиты: API1CPU/256MiB, PostgreSQL1CPU/256MiB (shared_buffers64MB,max_connections30), Valkey0.25CPU/64MiB (cache32MB). Restore1CPU/256MiB запускался отдельно от HTTP нагрузки.
|
||||
|
||||
`python scripts/load_experiment.py`: прогрев2с,10 клиентов,10.033с, closed-loop — одна запись1000 символов, затем четыре чтения истории по50 сообщений. 1368 запросов:1088×200 и280×201,136.35 успешных RPS,0% ошибок; p50/p95/p99=66.607/122.238/181.218мс. Тест создаёт отдельный чат,120000 SQL-строк исследовательской БД не подмешиваются к HTTP-набору. Raw: `http-load.csv`, `http-summary.json`, `http-resources.json`.
|
||||
|
||||
Docker stats: API максимум100.05% CPU и47.89MiB, БД23.73%/25.43MiB, cache2.53%/8.289MiB. Это три дискретных отсчёта working set, не непрерывные максимумы/RSS всей VM. Генератор на том же host, closed-loop скрывает coordinated omission; один10-секундный запуск не определяет production capacity.
|
||||
|
||||
## Ограничения
|
||||
|
||||
Один Docker-host/одна БД — SPOF; backup не обеспечивает непрерывную доступность. Локальный HTTP разрешён только для synthetic данных. DB-role учебно имеет права миграций (разделение ролей — следующий этап). Expired sessions перестают авторизовывать, но фоновая очистка строк пока не реализована. Кэш профилей не демонстрирует ускорение истории и не заявляется как трек1. Idempotency-Key и несколько реплик появятся в ЛР3; здесь повтор POST после неизвестного исхода может создать дубликат. Все результаты относятся к указанному стенду.
|
||||
|
||||
## Повтор из чистого clone
|
||||
|
||||
Коммит be6f10f собран в отдельном каталоге .setup/clean-lab2 с новым volume и новыми локальными секретами. Полная интеграционная проверка повторно прошла: 100/100 сообщений, гонка регистрации, cache hit +5, отказы cache/DB, expiry, logout, повтор миграции и persistence с прежней сессией. Результаты: evidence/clean-clone-verification.json, реальные времена рестартов: evidence/clean-clone-restart.json.
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
x-app: &app
|
||||
build: .
|
||||
image: mtusi-messenger:lab2
|
||||
env_file: .env
|
||||
cpus: 1.0
|
||||
mem_limit: 256m
|
||||
pids_limit: 64
|
||||
read_only: true
|
||||
cap_drop: [ALL]
|
||||
security_opt: [no-new-privileges:true]
|
||||
stop_grace_period: 8s
|
||||
logging:
|
||||
driver: json-file
|
||||
options: {max-size: 5m, max-file: "2"}
|
||||
services:
|
||||
db:
|
||||
image: mirror.gcr.io/library/postgres@sha256:3645570cccdfa447589da9f57dd740faa29b30938e861289a5574b6ca6b03826
|
||||
environment:
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Run python scripts/bootstrap.py}
|
||||
command: [postgres, -c, shared_buffers=64MB, -c, max_connections=30]
|
||||
volumes: [pgdata:/var/lib/postgresql/data]
|
||||
cpus: 1.0
|
||||
mem_limit: 256m
|
||||
healthcheck:
|
||||
test: [CMD-SHELL, "pg_isready -U messenger -d messenger"]
|
||||
interval: 2s
|
||||
timeout: 2s
|
||||
retries: 20
|
||||
cache:
|
||||
image: mirror.gcr.io/valkey/valkey@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507
|
||||
command: [valkey-server, --maxmemory, 32mb, --maxmemory-policy, allkeys-lru, --save, "", --appendonly, "no"]
|
||||
cpus: 0.25
|
||||
mem_limit: 64m
|
||||
healthcheck:
|
||||
test: [CMD, valkey-cli, ping]
|
||||
interval: 2s
|
||||
timeout: 1s
|
||||
retries: 20
|
||||
migrate:
|
||||
<<: *app
|
||||
command: [python, -m, src.migrate]
|
||||
healthcheck: {disable: true}
|
||||
depends_on:
|
||||
db: {condition: service_healthy}
|
||||
api:
|
||||
<<: *app
|
||||
ports: ["127.0.0.1:8080:8080"]
|
||||
depends_on:
|
||||
migrate: {condition: service_completed_successfully}
|
||||
cache: {condition: service_healthy}
|
||||
volumes:
|
||||
pgdata:
|
||||
@@ -0,0 +1,4 @@
|
||||
python -X utf8 scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
python -X utf8 scripts/validate_openapi.py
|
||||
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
|
||||
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"before": {
|
||||
"api": "2026-10-16T12:26:12.421719826Z",
|
||||
"db": "2026-10-16T12:27:19.188705708Z",
|
||||
"cache": "2026-10-16T12:27:17.815782719Z"
|
||||
},
|
||||
"after": {
|
||||
"api": "2026-10-16T12:27:34.893221429Z",
|
||||
"db": "2026-10-16T12:27:34.36080408Z",
|
||||
"cache": "2026-10-16T12:27:34.173884108Z"
|
||||
},
|
||||
"volumes_removed": false
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
{
|
||||
"public_smoke": "PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.",
|
||||
"authentication_negative": "wrong password, Basic on protected route, X-User-Id: 401",
|
||||
"registration_race": [
|
||||
201,
|
||||
409,
|
||||
409,
|
||||
409,
|
||||
409,
|
||||
409,
|
||||
409,
|
||||
409
|
||||
],
|
||||
"rollback": "missing member: 400; chats count unchanged",
|
||||
"concurrent_messages": {
|
||||
"sent": 100,
|
||||
"read": 100,
|
||||
"page_size": 17
|
||||
},
|
||||
"cache_hit_delta": 5,
|
||||
"cache_down": {
|
||||
"status": 200,
|
||||
"seconds": 0.209
|
||||
},
|
||||
"database_down": {
|
||||
"status": 503,
|
||||
"seconds": 0.006
|
||||
},
|
||||
"logout": "204 then 401",
|
||||
"short_ttl": "SESSION_TTL_SECONDS=2: 200 then 401 after 2.2s",
|
||||
"migration_repeat": "Already applied: 001_initial.sql",
|
||||
"public_persistence": "Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.\nPASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.",
|
||||
"passed": true
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,110 @@
|
||||
[
|
||||
{
|
||||
"elapsed_s": 1.946,
|
||||
"BlockIO": "0B / 0B",
|
||||
"CPUPerc": "91.99%",
|
||||
"Container": "708c0b14bcabe0bb0be47442021e3d8ec55216233ab670f9b65f29ebe87e86fd",
|
||||
"ID": "708c0b14bcab",
|
||||
"MemPerc": "18.54%",
|
||||
"MemUsage": "47.47MiB / 256MiB",
|
||||
"Name": "mtusi2026lab2-api-1",
|
||||
"NetIO": "3.03MB / 2.85MB",
|
||||
"PIDs": "3"
|
||||
},
|
||||
{
|
||||
"elapsed_s": 1.946,
|
||||
"BlockIO": "0B / 0B",
|
||||
"CPUPerc": "2.44%",
|
||||
"Container": "ac5c6c65019c906f0a2284b60a2bd70967d8a7e43525195fcaece09eef0c72d9",
|
||||
"ID": "ac5c6c65019c",
|
||||
"MemPerc": "12.76%",
|
||||
"MemUsage": "8.164MiB / 64MiB",
|
||||
"Name": "mtusi2026lab2-cache-1",
|
||||
"NetIO": "52.7kB / 82kB",
|
||||
"PIDs": "6"
|
||||
},
|
||||
{
|
||||
"elapsed_s": 1.946,
|
||||
"BlockIO": "0B / 0B",
|
||||
"CPUPerc": "19.95%",
|
||||
"Container": "85dd609cc3ea3334e57ca89675de2511a61335046299ec29594c78ad72cedec0",
|
||||
"ID": "85dd609cc3ea",
|
||||
"MemPerc": "9.77%",
|
||||
"MemUsage": "25MiB / 256MiB",
|
||||
"Name": "mtusi2026lab2-db-1",
|
||||
"NetIO": "483kB / 2.76MB",
|
||||
"PIDs": "11"
|
||||
},
|
||||
{
|
||||
"elapsed_s": 5.872,
|
||||
"BlockIO": "0B / 0B",
|
||||
"CPUPerc": "97.06%",
|
||||
"Container": "708c0b14bcabe0bb0be47442021e3d8ec55216233ab670f9b65f29ebe87e86fd",
|
||||
"ID": "708c0b14bcab",
|
||||
"MemPerc": "18.71%",
|
||||
"MemUsage": "47.89MiB / 256MiB",
|
||||
"Name": "mtusi2026lab2-api-1",
|
||||
"NetIO": "32MB / 31.7MB",
|
||||
"PIDs": "3"
|
||||
},
|
||||
{
|
||||
"elapsed_s": 5.872,
|
||||
"BlockIO": "0B / 0B",
|
||||
"CPUPerc": "2.53%",
|
||||
"Container": "ac5c6c65019c906f0a2284b60a2bd70967d8a7e43525195fcaece09eef0c72d9",
|
||||
"ID": "ac5c6c65019c",
|
||||
"MemPerc": "12.95%",
|
||||
"MemUsage": "8.289MiB / 64MiB",
|
||||
"Name": "mtusi2026lab2-cache-1",
|
||||
"NetIO": "135kB / 218kB",
|
||||
"PIDs": "6"
|
||||
},
|
||||
{
|
||||
"elapsed_s": 5.872,
|
||||
"BlockIO": "0B / 0B",
|
||||
"CPUPerc": "22.76%",
|
||||
"Container": "85dd609cc3ea3334e57ca89675de2511a61335046299ec29594c78ad72cedec0",
|
||||
"ID": "85dd609cc3ea",
|
||||
"MemPerc": "9.89%",
|
||||
"MemUsage": "25.31MiB / 256MiB",
|
||||
"Name": "mtusi2026lab2-db-1",
|
||||
"NetIO": "1.14MB / 24MB",
|
||||
"PIDs": "11"
|
||||
},
|
||||
{
|
||||
"elapsed_s": 9.786,
|
||||
"BlockIO": "0B / 0B",
|
||||
"CPUPerc": "100.05%",
|
||||
"Container": "708c0b14bcabe0bb0be47442021e3d8ec55216233ab670f9b65f29ebe87e86fd",
|
||||
"ID": "708c0b14bcab",
|
||||
"MemPerc": "18.68%",
|
||||
"MemUsage": "47.83MiB / 256MiB",
|
||||
"Name": "mtusi2026lab2-api-1",
|
||||
"NetIO": "58.7MB / 58.4MB",
|
||||
"PIDs": "3"
|
||||
},
|
||||
{
|
||||
"elapsed_s": 9.786,
|
||||
"BlockIO": "0B / 0B",
|
||||
"CPUPerc": "1.82%",
|
||||
"Container": "ac5c6c65019c906f0a2284b60a2bd70967d8a7e43525195fcaece09eef0c72d9",
|
||||
"ID": "ac5c6c65019c",
|
||||
"MemPerc": "12.95%",
|
||||
"MemUsage": "8.289MiB / 64MiB",
|
||||
"Name": "mtusi2026lab2-cache-1",
|
||||
"NetIO": "189kB / 303kB",
|
||||
"PIDs": "6"
|
||||
},
|
||||
{
|
||||
"elapsed_s": 9.786,
|
||||
"BlockIO": "0B / 0B",
|
||||
"CPUPerc": "23.73%",
|
||||
"Container": "85dd609cc3ea3334e57ca89675de2511a61335046299ec29594c78ad72cedec0",
|
||||
"ID": "85dd609cc3ea",
|
||||
"MemPerc": "9.93%",
|
||||
"MemUsage": "25.43MiB / 256MiB",
|
||||
"Name": "mtusi2026lab2-db-1",
|
||||
"NetIO": "1.89MB / 50MB",
|
||||
"PIDs": "11"
|
||||
}
|
||||
]
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"warmup_s": 2,
|
||||
"duration_s": 10.033,
|
||||
"concurrency": 10,
|
||||
"profile": "closed-loop: 1 write then 4 history reads per worker; 1000-character messages",
|
||||
"requests": 1368,
|
||||
"success_rps": 136.35,
|
||||
"error_fraction": 0.0,
|
||||
"p50_ms": 66.607,
|
||||
"p95_ms": 122.238,
|
||||
"p99_ms": 181.218,
|
||||
"statuses": {
|
||||
"200": 1088,
|
||||
"201": 280
|
||||
},
|
||||
"resource_source": "Docker stats samples; CPU percent is host-core percentage, memory is cgroup working set"
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
Binary file not shown.
|
After Width: | Height: | Size: 79 KiB |
File diff suppressed because it is too large
Load Diff
|
After Width: | Height: | Size: 71 KiB |
@@ -0,0 +1,34 @@
|
||||
{
|
||||
"public_smoke": "PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.",
|
||||
"authentication_negative": "wrong password, Basic on protected route, X-User-Id: 401",
|
||||
"registration_race": [
|
||||
201,
|
||||
409,
|
||||
409,
|
||||
409,
|
||||
409,
|
||||
409,
|
||||
409,
|
||||
409
|
||||
],
|
||||
"rollback": "missing member: 400; chats count unchanged",
|
||||
"concurrent_messages": {
|
||||
"sent": 100,
|
||||
"read": 100,
|
||||
"page_size": 17
|
||||
},
|
||||
"cache_hit_delta": 5,
|
||||
"cache_down": {
|
||||
"status": 200,
|
||||
"seconds": 0.211
|
||||
},
|
||||
"database_down": {
|
||||
"status": 503,
|
||||
"seconds": 0.009
|
||||
},
|
||||
"logout": "204 then 401",
|
||||
"short_ttl": "SESSION_TTL_SECONDS=2: 200 then 401 after 2.2s",
|
||||
"migration_repeat": "Already applied: 001_initial.sql",
|
||||
"public_persistence": "Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.\nPASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.",
|
||||
"passed": true
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"before": {
|
||||
"api": "2026-10-16T12:03:16.324917557Z",
|
||||
"db": "2026-10-16T12:06:50.396973657Z",
|
||||
"cache": "2026-10-16T12:06:47.794944116Z"
|
||||
},
|
||||
"after": {
|
||||
"api": "2026-10-16T12:07:04.752894207Z",
|
||||
"db": "2026-10-16T12:07:04.023045701Z",
|
||||
"cache": "2026-10-16T12:07:03.931354369Z"
|
||||
},
|
||||
"volumes_removed": false
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
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 sessions (
|
||||
token_hash text PRIMARY KEY,
|
||||
user_id uuid NOT NULL REFERENCES users(id),
|
||||
expires_at timestamptz NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE INDEX sessions_expiry ON sessions(expires_at);
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE TABLE members (
|
||||
chat_id uuid NOT NULL REFERENCES chats(id),
|
||||
user_id uuid NOT NULL REFERENCES users(id),
|
||||
PRIMARY KEY(chat_id,user_id)
|
||||
);
|
||||
CREATE INDEX members_user_chat ON members(user_id,chat_id);
|
||||
CREATE INDEX chats_order ON chats(created_at,id);
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats(id),
|
||||
sender_id uuid NOT NULL REFERENCES users(id),
|
||||
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
FOREIGN KEY(chat_id,sender_id) REFERENCES members(chat_id,user_id)
|
||||
);
|
||||
CREATE INDEX messages_history ON messages(chat_id,created_at,id);
|
||||
@@ -0,0 +1,3 @@
|
||||
-r requirements.txt
|
||||
httpx==0.28.1
|
||||
matplotlib==3.10.8
|
||||
@@ -0,0 +1,23 @@
|
||||
annotated-doc==0.0.5
|
||||
annotated-types==0.8.0
|
||||
anyio==4.15.1
|
||||
argon2-cffi==25.1.0
|
||||
argon2-cffi-bindings==26.1.0
|
||||
cffi==2.1.1
|
||||
click==8.5.0
|
||||
fastapi==0.143.2
|
||||
h11==0.16.0
|
||||
idna==3.20
|
||||
opentelemetry-api==1.45.1
|
||||
psycopg==3.3.6
|
||||
psycopg-binary==3.3.6
|
||||
psycopg-pool==3.3.3
|
||||
pycparser==3.11
|
||||
pydantic==2.14.1
|
||||
pydantic_core==2.50.1
|
||||
redis==8.1.0
|
||||
starlette==1.8.0
|
||||
typing-inspection==0.4.4
|
||||
typing_extensions==4.16.0
|
||||
tzdata==2026.5
|
||||
uvicorn==0.54.0
|
||||
@@ -0,0 +1,15 @@
|
||||
"""Generate local synthetic credentials once. Never prints their values."""
|
||||
from pathlib import Path
|
||||
import secrets
|
||||
|
||||
root=Path(__file__).resolve().parents[1]
|
||||
target=root/'.env'
|
||||
if target.exists():
|
||||
print('Existing .env preserved')
|
||||
else:
|
||||
password=secrets.token_hex(24)
|
||||
content=f'POSTGRES_PASSWORD={password}\nDATABASE_URL=postgresql://messenger:{password}@db:5432/messenger\nREDIS_URL=redis://cache:6379/0\nCURSOR_SECRET={secrets.token_hex(32)}\nSESSION_TTL_SECONDS=3600\n'
|
||||
with target.open('x',encoding='utf-8') as f: f.write(content)
|
||||
try: target.chmod(0o600)
|
||||
except OSError: pass
|
||||
print('Created local .env; values not displayed')
|
||||
@@ -0,0 +1,109 @@
|
||||
"""120k skewed messages: query plans/write cost + real fresh-volume restore.
|
||||
|
||||
Host orchestrates Docker; --inside runs synthetic SQL in an isolated database.
|
||||
No production table is changed and no credentials are printed.
|
||||
"""
|
||||
import hashlib
|
||||
from datetime import datetime
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import statistics
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
|
||||
def inside(dbname):
|
||||
import psycopg
|
||||
with psycopg.connect(os.environ['DATABASE_URL'],autocommit=True) as admin:
|
||||
admin.execute(psycopg.sql.SQL('CREATE DATABASE {}').format(psycopg.sql.Identifier(dbname)))
|
||||
with psycopg.connect(os.environ['DATABASE_URL'],dbname=dbname,autocommit=True) as c:
|
||||
c.execute(Path('/app/migrations/001_initial.sql').read_text())
|
||||
c.execute("INSERT INTO users(id,username,display_name,password_hash) VALUES ('00000000-0000-0000-0000-000000000001','benchmark','Synthetic','not-a-login-hash')")
|
||||
c.execute("INSERT INTO chats(id,title) SELECT md5('chat'||n)::uuid,'chat'||n FROM generate_series(1,3) n")
|
||||
c.execute("INSERT INTO members SELECT id,'00000000-0000-0000-0000-000000000001'::uuid FROM chats")
|
||||
c.execute("INSERT INTO messages SELECT md5('message'||n)::uuid,md5('chat'||CASE WHEN n<=100000 THEN 1 WHEN n<=115000 THEN 2 ELSE 3 END)::uuid,'00000000-0000-0000-0000-000000000001'::uuid,repeat('payload-',20)||n,'2026-01-01'::timestamptz+n*interval '1 millisecond' FROM generate_series(1,120000) n")
|
||||
c.execute('DROP INDEX messages_history')
|
||||
c.execute('VACUUM ANALYZE messages')
|
||||
cursor=c.execute("SELECT created_at,id FROM messages WHERE chat_id=md5('chat1')::uuid ORDER BY created_at,id OFFSET 69999 LIMIT 1").fetchone()
|
||||
keyset="SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id=md5('chat1')::uuid AND (created_at,id)>(%s,%s) ORDER BY created_at,id LIMIT 50"
|
||||
offset="SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id=md5('chat1')::uuid ORDER BY created_at,id OFFSET 70000 LIMIT 50"
|
||||
result={'version':c.execute('SELECT version()').fetchone()[0],'rows':120000,'chat_sizes':[100000,15000,5000],'repeats':5,'plans':[],'writes':[]}
|
||||
for variant,ddl in [('primary_only',None),('chat_index','CREATE INDEX experiment_idx ON messages(chat_id)'),('compound','CREATE INDEX experiment_idx ON messages(chat_id,created_at,id)')]:
|
||||
if ddl: c.execute(ddl)
|
||||
c.execute('ANALYZE messages')
|
||||
for query_name,query,args in [('keyset',keyset,cursor),('offset',offset,())]:
|
||||
for _ in range(2): c.execute(query,args).fetchall()
|
||||
plans=[c.execute('EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) '+query,args).fetchone()[0][0] for _ in range(5)]
|
||||
result['plans'].append({'index':variant,'query':query_name,'execution_ms':[p['Execution Time'] for p in plans],'median_ms':statistics.median(p['Execution Time'] for p in plans),'plans':plans})
|
||||
# Five real committed batches, then remove only those synthetic rows.
|
||||
measurements=[]
|
||||
for rep in range(5):
|
||||
start=time.perf_counter()
|
||||
c.execute("INSERT INTO messages SELECT md5('write'||n)::uuid,md5('chat1')::uuid,'00000000-0000-0000-0000-000000000001'::uuid,repeat('payload-',20)||n,'2027-01-01'::timestamptz+n*interval '1 millisecond' FROM generate_series(1,5000) n")
|
||||
measurements.append(round((time.perf_counter()-start)*1000,3))
|
||||
c.execute("DELETE FROM messages WHERE created_at>='2027-01-01'")
|
||||
c.execute('VACUUM ANALYZE messages')
|
||||
result['writes'].append({'index':variant,'batch_rows':5000,'committed_ms':measurements,'median_ms':statistics.median(measurements)})
|
||||
if ddl: c.execute('DROP INDEX experiment_idx')
|
||||
c.execute('CREATE INDEX messages_history ON messages(chat_id,created_at,id)')
|
||||
result['snapshot']=snapshot(c)
|
||||
print(json.dumps(result,default=str))
|
||||
|
||||
def snapshot(c):
|
||||
counts={table:c.execute('SELECT count(*) FROM '+table).fetchone()[0] for table in ('users','chats','members','messages','sessions')}
|
||||
selected=c.execute('SELECT id,chat_id,sender_id,text,created_at FROM messages ORDER BY id LIMIT 20').fetchall()
|
||||
digest=c.execute("SELECT md5(string_agg(id::text||chat_id::text||sender_id::text||text||created_at::text,'' ORDER BY id)) FROM messages").fetchone()[0]
|
||||
return {'counts':counts,'selected':[[str(v) for v in row] for row in selected],'all_messages_digest':digest}
|
||||
|
||||
def host():
|
||||
root=Path(__file__).resolve().parents[1]
|
||||
def run(*args,input=None):
|
||||
return subprocess.run(['docker',*args],cwd=root,input=input,stdout=subprocess.PIPE,stderr=subprocess.PIPE,check=True).stdout
|
||||
unique=uuid.uuid4().hex[:10]; dbname='experiment_'+unique
|
||||
cid=run('compose','ps','-q','db').decode().strip()
|
||||
source=Path(__file__).read_bytes()
|
||||
result=json.loads(run('compose','exec','-T','api','python','-','--inside',dbname,input=source))
|
||||
start=time.perf_counter()
|
||||
dump=run('exec',cid,'pg_dump','-U','messenger','-Fc',dbname)
|
||||
result['backup']={'seconds':round(time.perf_counter()-start,3),'bytes':len(dump),'sha256':hashlib.sha256(dump).hexdigest()}
|
||||
backup=root/'backups'/f'{dbname}.dump'; backup.parent.mkdir(exist_ok=True); backup.write_bytes(dump)
|
||||
# Distinct container and brand-new named volume: no restore onto source storage.
|
||||
image=run('inspect','--format','{{.Config.Image}}',cid).decode().strip()
|
||||
volume='lab2-restore-'+unique; target='lab2-restore-'+unique
|
||||
run('volume','create',volume)
|
||||
try:
|
||||
run('run','-d','--name',target,'--cpus','1','--memory','256m','-e','POSTGRES_USER=messenger','-e','POSTGRES_DB=messenger','-e','POSTGRES_HOST_AUTH_METHOD=trust','-v',volume+':/var/lib/postgresql/data',image)
|
||||
start=time.perf_counter()
|
||||
for _ in range(100):
|
||||
try: run('exec',target,'pg_isready','-U','messenger'); break
|
||||
except subprocess.CalledProcessError: time.sleep(.2)
|
||||
else: raise AssertionError('restore PostgreSQL did not become ready')
|
||||
run('exec','-i',target,'pg_restore','-U','messenger','-d','messenger','--exit-on-error',input=dump)
|
||||
result['restore']={'seconds_including_startup':round(time.perf_counter()-start,3),'fresh_volume':volume,'published_ports':False}
|
||||
# pg_restore schema/data includes all constraints and indexes.
|
||||
query="SELECT json_build_object('users',(SELECT count(*) FROM users),'chats',(SELECT count(*) FROM chats),'members',(SELECT count(*) FROM members),'messages',(SELECT count(*) FROM messages),'sessions',(SELECT count(*) FROM sessions))"
|
||||
counts=json.loads(run('exec',target,'psql','-U','messenger','-Atc',query))
|
||||
digest=run('exec',target,'psql','-U','messenger','-Atc',"SELECT md5(string_agg(id::text||chat_id::text||sender_id::text||text||created_at::text,'' ORDER BY id)) FROM messages").decode().strip()
|
||||
selected=json.loads(run('exec',target,'psql','-U','messenger','-Atc',"SELECT json_agg(row_to_json(t)) FROM (SELECT id,chat_id,sender_id,text,created_at::text FROM messages ORDER BY id LIMIT 20) t"))
|
||||
selected=[[str(row[k]) for k in ('id','chat_id','sender_id','text','created_at')] for row in selected]
|
||||
# Normalize equivalent precision/offset rendering, preserving actual instants.
|
||||
for rows in (selected,result['snapshot']['selected']):
|
||||
for row in rows: row[-1]=datetime.fromisoformat(row[-1]).isoformat(timespec='microseconds')
|
||||
assert counts==result['snapshot']['counts']
|
||||
assert digest==result['snapshot']['all_messages_digest']
|
||||
assert selected==result['snapshot']['selected']
|
||||
result['restore'].update(counts=counts,all_messages_digest=digest,selected_20_match=True,verified=True)
|
||||
finally:
|
||||
run('rm','-f',target)
|
||||
run('volume','rm',volume)
|
||||
result['limitations']='Warm-cache serial variants on one local host; logical backup snapshot, no WAL/PITR; synthetic DB retained for inspection.'
|
||||
result['database']=dbname
|
||||
(root/'evidence').mkdir(exist_ok=True)
|
||||
(root/'evidence/index-restore.json').write_text(json.dumps(result,ensure_ascii=False,indent=2)+'\n',encoding='utf-8')
|
||||
print(json.dumps({k:v for k,v in result.items() if k not in ('plans','snapshot')},indent=2))
|
||||
|
||||
if __name__=='__main__':
|
||||
if '--inside' in sys.argv: inside(sys.argv[-1])
|
||||
else: host()
|
||||
@@ -0,0 +1,59 @@
|
||||
"""Bounded closed-loop HTTP load, raw latency and Docker resource samples."""
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
import csv
|
||||
import json
|
||||
import math
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
import httpx
|
||||
|
||||
ROOT=Path(__file__).resolve().parents[1]
|
||||
def docker(*args):
|
||||
return subprocess.check_output(['docker',*args],cwd=ROOT,text=True,encoding='utf-8').strip()
|
||||
rows=[]; samples=[]; done=threading.Event()
|
||||
def sample():
|
||||
while not done.is_set():
|
||||
data=docker('stats','--no-stream','--format','{{json .}}',*docker('compose','ps','-q').splitlines())
|
||||
samples.extend({'elapsed_s':round(time.perf_counter()-start,3),**json.loads(line)} for line in data.splitlines())
|
||||
done.wait(1)
|
||||
with httpx.Client(base_url='http://127.0.0.1:8080',timeout=10) as c:
|
||||
body={'username':'load_'+uuid.uuid4().hex[:18],'display_name':'Load','password':'synthetic-password-123'}
|
||||
user=c.post('/api/v1/users',json=body).json()
|
||||
auth=c.post('/api/v1/auth/sessions',auth=(body['username'],body['password'])).json()
|
||||
headers={'Authorization':'Bearer '+auth['token']}
|
||||
chat=c.post('/api/v1/chats',headers=headers,json={'title':'load','member_ids':[user['id']]}).json()
|
||||
path='/api/v1/chats/'+chat['id']+'/messages'
|
||||
# Warm up the pool/cache for 2 seconds, outside measurement.
|
||||
deadline=time.perf_counter()+2
|
||||
while time.perf_counter()<deadline: c.get(path,headers=headers)
|
||||
start=time.perf_counter(); deadline=start+10
|
||||
sampler=threading.Thread(target=sample,daemon=True); sampler.start()
|
||||
def work(worker):
|
||||
i=0
|
||||
while time.perf_counter()<deadline:
|
||||
now=time.perf_counter(); method='POST' if i%5==0 else 'GET'; status=0
|
||||
try:
|
||||
r=c.request(method,path,headers=headers,**({'json':{'text':'synthetic '*100}} if method=='POST' else {'params':{'limit':50}}))
|
||||
status=r.status_code
|
||||
except httpx.HTTPError: pass
|
||||
rows.append({'worker':worker,'method':method,'elapsed_s':round(now-start,6),'latency_ms':round((time.perf_counter()-now)*1000,3),'status':status})
|
||||
i+=1
|
||||
with ThreadPoolExecutor(max_workers=10) as pool: list(pool.map(work,range(10)))
|
||||
duration=time.perf_counter()-start
|
||||
done.set(); sampler.join(10)
|
||||
success=sum(r['status'] in (200,201) for r in rows)
|
||||
latencies=sorted(r['latency_ms'] for r in rows)
|
||||
summary={'warmup_s':2,'duration_s':round(duration,3),'concurrency':10,'profile':'closed-loop: 1 write then 4 history reads per worker; 1000-character messages',
|
||||
'requests':len(rows),'success_rps':round(success/duration,2),'error_fraction':1-success/len(rows),
|
||||
**{f'p{p}_ms':latencies[math.ceil(len(latencies)*p/100)-1] for p in (50,95,99)},
|
||||
'statuses':{str(s):sum(r['status']==s for r in rows) for s in {r['status'] for r in rows}},'resource_source':'Docker stats samples; CPU percent is host-core percentage, memory is cgroup working set'}
|
||||
out=ROOT/'evidence'; out.mkdir(exist_ok=True)
|
||||
with (out/'http-load.csv').open('w',newline='',encoding='utf-8') as f:
|
||||
writer=csv.DictWriter(f,fieldnames=list(rows[0])); writer.writeheader(); writer.writerows(rows)
|
||||
(out/'http-resources.json').write_text(json.dumps(samples,indent=2)+'\n',encoding='utf-8')
|
||||
(out/'http-summary.json').write_text(json.dumps(summary,indent=2)+'\n',encoding='utf-8')
|
||||
print(json.dumps(summary,indent=2))
|
||||
assert success==len(rows),'Unexpected failed requests'
|
||||
@@ -0,0 +1,28 @@
|
||||
"""Plot recorded medians; all five plans/samples remain in JSON."""
|
||||
import json
|
||||
from pathlib import Path
|
||||
import matplotlib
|
||||
matplotlib.use('Agg')
|
||||
import matplotlib.pyplot as plt
|
||||
|
||||
root=Path(__file__).resolve().parents[1]/'evidence'
|
||||
data=json.loads((root/'index-restore.json').read_text(encoding='utf-8'))
|
||||
labels=['Primary only','Chat index','Compound index']
|
||||
fig,axes=plt.subplots(1,2,figsize=(11,4.5),layout='constrained')
|
||||
for name,offset,color in [('keyset',-.18,'#087f5b'),('offset',.18,'#d9480f')]:
|
||||
values=[p['median_ms'] for p in data['plans'] if p['query']==name]
|
||||
bars=axes[0].bar([i+offset for i in range(3)],values,width=.35,label=name,color=color)
|
||||
axes[0].bar_label(bars,fmt='%.3f',padding=3,fontsize=8)
|
||||
axes[0].set_yscale('log'); axes[0].set_ylim(.01,1000)
|
||||
axes[0].set_ylabel('Median execution, ms (log scale)'); axes[0].legend()
|
||||
axes[0].set_title('Page 70,001–70,050 of the 100k chat')
|
||||
bars=axes[1].bar(range(3),[v['median_ms'] for v in data['writes']],color='#4263eb')
|
||||
axes[1].bar_label(bars,fmt='%.1f',padding=3)
|
||||
axes[1].set_ylim(0,max(v['median_ms'] for v in data['writes'])*1.25)
|
||||
axes[1].set_ylabel('Median commit time, ms'); axes[1].set_title('Insert 5,000 messages (5 repetitions)')
|
||||
for ax in axes:
|
||||
ax.set_xticks(range(3),labels); ax.grid(axis='y',alpha=.2); ax.set_axisbelow(True)
|
||||
fig.suptitle('Lab 2 · PostgreSQL 17.11 · 120,000 skewed messages · 1 CPU / 256 MiB')
|
||||
fig.savefig(root/'indexes.png',dpi=160)
|
||||
fig.savefig(root/'indexes.svg')
|
||||
p=root/'indexes.svg'; p.write_text('\n'.join(line.rstrip() for line in p.read_text(encoding='utf-8').splitlines())+'\n',encoding='utf-8')
|
||||
@@ -0,0 +1,20 @@
|
||||
"""Restart all three services without deleting volumes; record actual start times."""
|
||||
import json
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
|
||||
ROOT=Path(__file__).resolve().parents[1]
|
||||
def command(*args):
|
||||
return subprocess.check_output(['docker',*args],cwd=ROOT,text=True,encoding='utf-8').strip()
|
||||
def snapshot():
|
||||
result={}
|
||||
for service in ('api','db','cache'):
|
||||
cid=command('compose','ps','-q',service)
|
||||
result[service]=json.loads(command('inspect','--format','{{json .State}}',cid))['StartedAt']
|
||||
return result
|
||||
before=snapshot()
|
||||
command('compose','restart','api','db','cache')
|
||||
after=snapshot()
|
||||
assert all(before[k]!=after[k] for k in before)
|
||||
(ROOT/'evidence').mkdir(exist_ok=True)
|
||||
(ROOT/'evidence/restart-processes.json').write_text(json.dumps({'before':before,'after':after,'volumes_removed':False},indent=2)+'\n',encoding='utf-8')
|
||||
Executable
+4
@@ -0,0 +1,4 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
python3 scripts/restart.py
|
||||
@@ -0,0 +1,123 @@
|
||||
"""Integration checks against real Compose services; no mocked dependencies."""
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import uuid
|
||||
import httpx
|
||||
|
||||
ROOT=Path(__file__).resolve().parents[1]
|
||||
OUT=ROOT/'evidence'
|
||||
OUT.mkdir(exist_ok=True)
|
||||
evidence={}
|
||||
def docker(*args):
|
||||
return subprocess.check_output(['docker',*args],cwd=ROOT,text=True,encoding='utf-8',stderr=subprocess.PIPE).strip()
|
||||
def sql(query):
|
||||
return docker('compose','exec','-T','db','psql','-U','messenger','-d','messenger','-Atc',query)
|
||||
def wait_ready(client):
|
||||
deadline=time.monotonic()+60
|
||||
while time.monotonic()<deadline:
|
||||
try:
|
||||
if client.get('/health/ready').status_code==200: return
|
||||
except httpx.HTTPError: pass
|
||||
time.sleep(.3)
|
||||
raise AssertionError('readiness timeout')
|
||||
def register(client):
|
||||
name='v_'+uuid.uuid4().hex[:20]
|
||||
body={'username':name,'display_name':'Проверка','password':'correct-horse-test-123'}
|
||||
r=client.post('/api/v1/users',json=body); assert r.status_code==201,r.text
|
||||
return body,r.json()
|
||||
def login(client,body):
|
||||
r=client.post('/api/v1/auth/sessions',auth=(body['username'],body['password']))
|
||||
assert r.status_code==201,r.text
|
||||
return {'Authorization':'Bearer '+r.json()['token']}
|
||||
|
||||
with httpx.Client(base_url='http://127.0.0.1:8080',timeout=12) as c:
|
||||
wait_ready(c)
|
||||
smoke=subprocess.check_output([sys.executable,'-X','utf8','tests/smoke.py'],cwd=ROOT,text=True,encoding='utf-8')
|
||||
evidence['public_smoke']=smoke.strip()
|
||||
body,user=register(c); headers=login(c,body)
|
||||
bad=c.post('/api/v1/auth/sessions',auth=(body['username'],'definitely-wrong-password'))
|
||||
assert bad.status_code==401
|
||||
assert c.get('/api/v1/users/me',headers={'X-User-Id':user['id']}).status_code==401
|
||||
assert c.get('/api/v1/users/me',auth=(body['username'],body['password'])).status_code==401
|
||||
evidence['authentication_negative']='wrong password, Basic on protected route, X-User-Id: 401'
|
||||
race={'username':'race_'+uuid.uuid4().hex[:18],'display_name':'Race','password':body['password']}
|
||||
with ThreadPoolExecutor(max_workers=8) as pool:
|
||||
statuses=list(pool.map(lambda _:c.post('/api/v1/users',json=race).status_code,range(8)))
|
||||
assert statuses.count(201)==1 and statuses.count(409)==7,statuses
|
||||
evidence['registration_race']=statuses
|
||||
before=sql('SELECT count(*) FROM chats')
|
||||
bad=c.post('/api/v1/chats',headers=headers,json={'title':'rollback','member_ids':[user['id'],str(uuid.uuid4())]})
|
||||
assert bad.status_code==400,bad.text
|
||||
assert before==sql('SELECT count(*) FROM chats')
|
||||
evidence['rollback']='missing member: 400; chats count unchanged'
|
||||
chat=c.post('/api/v1/chats',headers=headers,json={'title':'parallel','member_ids':[user['id']]}).json()
|
||||
path='/api/v1/chats/'+chat['id']+'/messages'
|
||||
with ThreadPoolExecutor(max_workers=10) as pool:
|
||||
replies=list(pool.map(lambda n:c.post(path,headers=headers,json={'text':f'parallel {n}'}),range(100)))
|
||||
assert all(r.status_code==201 for r in replies),[r.status_code for r in replies]
|
||||
records=[]; cursor=None
|
||||
while True:
|
||||
page=c.get(path,headers=headers,params={'limit':17,**({'cursor':cursor} if cursor else {})}).json()
|
||||
records+=page['items']; cursor=page['next_cursor']
|
||||
if cursor is None: break
|
||||
assert len(records)==100 and len({r['id'] for r in records})==100
|
||||
assert {r['id'] for r in records}=={r.json()['id'] for r in replies}
|
||||
evidence['concurrent_messages']={'sent':100,'read':len(records),'page_size':17}
|
||||
def hits():
|
||||
stats=docker('compose','exec','-T','cache','valkey-cli','INFO','stats')
|
||||
return int(next(line.split(':')[1] for line in stats.splitlines() if line.startswith('keyspace_hits:')))
|
||||
hits_before=hits()
|
||||
for _ in range(5): assert c.get('/api/v1/users/me',headers=headers).status_code==200
|
||||
evidence['cache_hit_delta']=hits()-hits_before
|
||||
assert evidence['cache_hit_delta']>=5
|
||||
docker('compose','stop','cache')
|
||||
try:
|
||||
start=time.perf_counter()
|
||||
r=c.get('/api/v1/users/me',headers=headers)
|
||||
evidence['cache_down']={'status':r.status_code,'seconds':round(time.perf_counter()-start,3)}
|
||||
assert r.status_code==200
|
||||
assert c.get('/api/v1/users/me',headers={'Authorization':'Bearer '+'x'*43}).status_code==401
|
||||
finally: docker('compose','start','cache')
|
||||
docker('compose','stop','db')
|
||||
try:
|
||||
start=time.perf_counter(); r=c.get('/api/v1/users/me',headers=headers)
|
||||
evidence['database_down']={'status':r.status_code,'seconds':round(time.perf_counter()-start,3)}
|
||||
assert r.status_code==503 and time.perf_counter()-start<10
|
||||
assert c.get('/api/v1/users/me').status_code==401
|
||||
finally: docker('compose','start','db')
|
||||
wait_ready(c)
|
||||
assert c.get('/api/v1/users/me',headers=headers).status_code==200
|
||||
assert c.delete('/api/v1/auth/sessions/current',headers=headers).status_code==204
|
||||
assert c.get('/api/v1/users/me',headers=headers).status_code==401
|
||||
evidence['logout']='204 then 401'
|
||||
|
||||
# A separate API process with short TTL uses the same persistent dependencies.
|
||||
name='lab2-expiry-'+uuid.uuid4().hex[:8]
|
||||
docker('compose','run','-d','--no-deps','--name',name,'-p','127.0.0.1::8080','-e','SESSION_TTL_SECONDS=2','api')
|
||||
try:
|
||||
binding=docker('port',name,'8080/tcp').split(':')[-1]
|
||||
with httpx.Client(base_url='http://127.0.0.1:'+binding,timeout=10) as c:
|
||||
wait_ready(c); body,user=register(c); headers=login(c,body)
|
||||
assert c.get('/api/v1/users/me',headers=headers).status_code==200
|
||||
time.sleep(2.2)
|
||||
assert c.get('/api/v1/users/me',headers=headers).status_code==401
|
||||
evidence['short_ttl']='SESSION_TTL_SECONDS=2: 200 then 401 after 2.2s'
|
||||
finally: docker('rm','-f',name)
|
||||
|
||||
evidence['migration_repeat']=docker('compose','run','--rm','--no-deps','migrate')
|
||||
if os.name=='nt':
|
||||
with tempfile.TemporaryDirectory(prefix='lab2-hook-') as tmp:
|
||||
hook=Path(tmp)/'restart.cmd'
|
||||
hook.write_text('@echo off\n"'+sys.executable+'" "'+str(ROOT/'scripts/restart.py')+'"\n',encoding='utf-8')
|
||||
evidence['public_persistence']=subprocess.check_output([sys.executable,'-X','utf8','tests/resilience.py','--mode','persistence','--action-script',str(hook)],cwd=ROOT,text=True,encoding='utf-8').strip()
|
||||
else:
|
||||
evidence['public_persistence']=subprocess.check_output([sys.executable,'tests/resilience.py','--mode','persistence','--action-script','scripts/restart.sh'],cwd=ROOT,text=True).strip()
|
||||
evidence['passed']=True
|
||||
(OUT/'integration.json').write_text(json.dumps(evidence,ensure_ascii=False,indent=2)+'\n',encoding='utf-8')
|
||||
print(json.dumps(evidence,ensure_ascii=False,indent=2))
|
||||
@@ -0,0 +1,9 @@
|
||||
import logging
|
||||
import os
|
||||
import uvicorn
|
||||
|
||||
logging.basicConfig(level=logging.INFO, format='%(message)s')
|
||||
uvicorn.run('src.app:app', host=os.environ.get('APP_HOST', '0.0.0.0'),
|
||||
port=int(os.environ.get('APP_PORT', '8080')), workers=1,
|
||||
access_log=False, server_header=False, timeout_keep_alive=2,
|
||||
timeout_graceful_shutdown=5, backlog=64, h11_max_incomplete_event_size=16384)
|
||||
+173
@@ -0,0 +1,173 @@
|
||||
import asyncio
|
||||
import base64
|
||||
from contextlib import asynccontextmanager
|
||||
from dataclasses import dataclass
|
||||
import os
|
||||
import re
|
||||
import secrets
|
||||
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import VerificationError, InvalidHashError
|
||||
from fastapi import FastAPI, Request, Response
|
||||
import psycopg
|
||||
from psycopg_pool import PoolTimeout, TooManyRequests
|
||||
from starlette.exceptions import HTTPException
|
||||
|
||||
from .common import ApiError, invalid, json_body, object_fields, pagination, string, uuid_value
|
||||
from .http import Boundaries, error_response
|
||||
from .store import Store, clean
|
||||
|
||||
|
||||
@dataclass
|
||||
class Settings:
|
||||
database_url: str
|
||||
redis_url: str
|
||||
cursor_secret: str
|
||||
session_ttl_seconds: int = 3600
|
||||
db_pool_size: int = 5
|
||||
max_body_bytes: int = 32768
|
||||
max_inflight: int = 32
|
||||
request_timeout: int = 8
|
||||
write_rps: int = 100
|
||||
write_burst: int = 100
|
||||
|
||||
@classmethod
|
||||
def environment(cls):
|
||||
result=cls(database_url=os.environ['DATABASE_URL'],redis_url=os.environ['REDIS_URL'],cursor_secret=os.environ['CURSOR_SECRET'],
|
||||
**{name:int(os.environ.get(name.upper(),field.default)) for name,field in cls.__dataclass_fields__.items() if field.type is int})
|
||||
if len(result.cursor_secret)<32 or any(getattr(result,name)<=0 for name,field in cls.__dataclass_fields__.items() if field.type is int):
|
||||
raise ValueError('Invalid configuration')
|
||||
return result
|
||||
|
||||
|
||||
def create_app(settings=None):
|
||||
cfg=settings or Settings.environment()
|
||||
store=Store(cfg)
|
||||
hasher=PasswordHasher(time_cost=2,memory_cost=32768,parallelism=1)
|
||||
dummy_hash=hasher.hash(secrets.token_urlsafe(32))
|
||||
kdf_slots=asyncio.Semaphore(4)
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(api):
|
||||
await store.open()
|
||||
try: yield
|
||||
finally: await store.close()
|
||||
|
||||
api=FastAPI(lifespan=lifespan,openapi_url=None,docs_url=None,redoc_url=None)
|
||||
api.state.store=store
|
||||
|
||||
@api.exception_handler(ApiError)
|
||||
async def api_error(request,exc): return error_response(exc,request.state.request_id)
|
||||
|
||||
@api.exception_handler(HTTPException)
|
||||
async def http_error(request,exc):
|
||||
return error_response(ApiError(404,'not_found','Route not found'),request.state.request_id)
|
||||
|
||||
async def database_error(request,exc):
|
||||
return error_response(ApiError(503,'unavailable','Database unavailable',{'Retry-After':'1'}),request.state.request_id)
|
||||
for exception in (psycopg.Error,PoolTimeout,TooManyRequests): api.add_exception_handler(exception,database_error)
|
||||
|
||||
@api.exception_handler(psycopg.DataError)
|
||||
async def data_error(request,exc):
|
||||
return error_response(ApiError(400,'invalid_request','Unsupported field value'),request.state.request_id)
|
||||
|
||||
def unauthorized(basic=False):
|
||||
scheme='Basic realm="messenger", charset="UTF-8"' if basic else 'Bearer realm="messenger"'
|
||||
return ApiError(401,'unauthorized','Invalid credentials',{'WWW-Authenticate':scheme})
|
||||
|
||||
def bearer(request):
|
||||
value=request.headers.get('authorization','')
|
||||
parts=value.split()
|
||||
if len(parts)!=2 or parts[0].lower()!='bearer' or not re.fullmatch(r'[A-Za-z0-9_-]{43}',parts[1]):
|
||||
raise unauthorized()
|
||||
return parts[1]
|
||||
|
||||
async def actor(request): return await store.authenticate(bearer(request))
|
||||
|
||||
@api.get('/health/live')
|
||||
async def live(): return {'status':'ok'}
|
||||
|
||||
@api.get('/health/ready')
|
||||
async def ready():
|
||||
await store.ready()
|
||||
return {'status':'ok'}
|
||||
|
||||
@api.post('/api/v1/users',status_code=201)
|
||||
async def register(request:Request):
|
||||
body=object_fields(await json_body(request),('username','display_name','password'))
|
||||
username=string(body['username'],32)
|
||||
if not re.fullmatch(r'[a-z0-9_]{3,32}',username): invalid('Invalid username')
|
||||
name=string(body['display_name'],100)
|
||||
password=string(body['password'],128)
|
||||
if len(password)<12: invalid('Password must contain 12..128 code points')
|
||||
async with kdf_slots: hashed=await asyncio.to_thread(hasher.hash,password)
|
||||
return await store.register(username,name,hashed)
|
||||
|
||||
@api.post('/api/v1/auth/sessions',status_code=201)
|
||||
async def login(request:Request):
|
||||
try:
|
||||
scheme,encoded=request.headers.get('authorization','').split(' ',1)
|
||||
if scheme.lower()!='basic': raise ValueError()
|
||||
username,password=base64.b64decode(encoded,validate=True).decode('utf-8').split(':',1)
|
||||
if not re.fullmatch(r'[a-z0-9_]{3,32}',username) or not 12<=len(password)<=128: raise ValueError()
|
||||
except (ValueError,UnicodeError): raise unauthorized(True) from None
|
||||
if await request.body(): invalid('Session login does not accept a body')
|
||||
row=await store.credentials(username)
|
||||
try:
|
||||
async with kdf_slots: await asyncio.to_thread(hasher.verify,row['password_hash'] if row else dummy_hash,password)
|
||||
except (VerificationError,InvalidHashError): raise unauthorized(True) from None
|
||||
if not row: raise unauthorized(True)
|
||||
token=secrets.token_urlsafe(32)
|
||||
expires=await store.create_session(row['id'],token)
|
||||
return {'token':token,'token_type':'Bearer','expires_at':expires,
|
||||
'user':clean({k:v for k,v in row.items() if k!='password_hash'})}
|
||||
|
||||
@api.delete('/api/v1/auth/sessions/current',status_code=204)
|
||||
async def logout(request:Request):
|
||||
await actor(request)
|
||||
await store.logout(bearer(request))
|
||||
return Response(status_code=204)
|
||||
|
||||
@api.get('/api/v1/users/me')
|
||||
async def me(request:Request): return await actor(request)
|
||||
|
||||
@api.post('/api/v1/chats',status_code=201)
|
||||
async def create_chat(request:Request):
|
||||
user=await actor(request)
|
||||
body=object_fields(await json_body(request),('title','member_ids'))
|
||||
title=string(body['title'],100)
|
||||
if not isinstance(body['member_ids'],list) or not 1<=len(body['member_ids'])<=100: invalid('Invalid members')
|
||||
members=[uuid_value(v) for v in body['member_ids']]
|
||||
if len(set(members))!=len(members): invalid('Duplicate member')
|
||||
return await store.create_chat(user['id'],title,members)
|
||||
|
||||
@api.get('/api/v1/chats')
|
||||
async def list_chats(request:Request):
|
||||
user=await actor(request)
|
||||
limit,cursor=pagination(request,'chats:'+user['id'],store.secret)
|
||||
return await store.page(user['id'],None,limit,cursor)
|
||||
|
||||
@api.get('/api/v1/chats/{chat_id}')
|
||||
async def get_chat(chat_id:str,request:Request):
|
||||
user=await actor(request)
|
||||
return await store.chat(user['id'],uuid_value(chat_id))
|
||||
|
||||
@api.get('/api/v1/chats/{chat_id}/messages')
|
||||
async def list_messages(chat_id:str,request:Request):
|
||||
user=await actor(request); chat_id=uuid_value(chat_id)
|
||||
await store.chat(user['id'],chat_id)
|
||||
limit,cursor=pagination(request,'messages:'+chat_id,store.secret)
|
||||
return await store.page(user['id'],chat_id,limit,cursor)
|
||||
|
||||
@api.post('/api/v1/chats/{chat_id}/messages',status_code=201)
|
||||
async def create_message(chat_id:str,request:Request):
|
||||
user=await actor(request); chat_id=uuid_value(chat_id)
|
||||
await store.chat(user['id'],chat_id)
|
||||
body=object_fields(await json_body(request),('text',))
|
||||
return await store.create_message(user['id'],chat_id,string(body['text'],4000))
|
||||
|
||||
api.add_middleware(Boundaries,settings=cfg)
|
||||
return api
|
||||
|
||||
|
||||
app=create_app()
|
||||
+101
@@ -0,0 +1,101 @@
|
||||
"""Strict contract validation and resource-bound cursors."""
|
||||
import base64
|
||||
import binascii
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
import re
|
||||
from datetime import datetime, timezone
|
||||
from uuid import UUID
|
||||
|
||||
|
||||
class ApiError(Exception):
|
||||
def __init__(self, status, code, message, headers=None):
|
||||
self.status, self.code, self.message = status, code, message
|
||||
self.headers = headers or {}
|
||||
|
||||
|
||||
def invalid(message='Invalid request'):
|
||||
raise ApiError(400, 'invalid_request', message)
|
||||
|
||||
|
||||
def uuid_value(value):
|
||||
if not isinstance(value, str) or not re.fullmatch(
|
||||
r'[0-9a-fA-F]{8}-(?:[0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}', value
|
||||
):
|
||||
invalid('Invalid UUID')
|
||||
return str(UUID(value))
|
||||
|
||||
|
||||
def string(value, maximum, *, blank=False):
|
||||
if not isinstance(value, str) or len(value) > maximum or (not blank and not value.strip()):
|
||||
invalid('Invalid string')
|
||||
# JSON can encode unpaired surrogates; they are not Unicode scalar values.
|
||||
try:
|
||||
value.encode('utf-8')
|
||||
except UnicodeError:
|
||||
invalid('Invalid Unicode')
|
||||
return value
|
||||
|
||||
|
||||
def object_fields(value, required, optional=()):
|
||||
if not isinstance(value, dict) or not set(required) <= value.keys() or value.keys() - set(required) - set(optional):
|
||||
invalid('Invalid fields')
|
||||
return value
|
||||
|
||||
|
||||
def timestamp():
|
||||
return datetime.now(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z')
|
||||
|
||||
|
||||
def encode_cursor(resource, key, secret):
|
||||
data = json.dumps([resource, *key], separators=(',', ':')).encode()
|
||||
return base64.urlsafe_b64encode(data + hmac.digest(secret, data, 'sha256')).decode().rstrip('=')
|
||||
|
||||
|
||||
def decode_cursor(value, resource, secret):
|
||||
try:
|
||||
if len(value) > 1024 or not re.fullmatch(r'[A-Za-z0-9_-]+', value):
|
||||
raise ValueError()
|
||||
raw = base64.b64decode(value + '=' * (-len(value) % 4), altchars=b'-_', validate=True)
|
||||
data, signature = raw[:-32], raw[-32:]
|
||||
if not hmac.compare_digest(hmac.digest(secret, data, 'sha256'), signature):
|
||||
raise ValueError()
|
||||
scope, created, identifier = json.loads(data)
|
||||
if scope != resource or not isinstance(created, str) or not created.endswith('Z'):
|
||||
raise ValueError()
|
||||
datetime.fromisoformat(created.replace('Z', '+00:00'))
|
||||
UUID(identifier)
|
||||
return created, identifier
|
||||
except (ValueError, TypeError, binascii.Error, UnicodeError):
|
||||
invalid('Invalid cursor')
|
||||
|
||||
|
||||
def pagination(request, resource, secret):
|
||||
if any(len(request.query_params.getlist(k)) != 1 for k in request.query_params):
|
||||
invalid('Duplicate query parameter')
|
||||
if set(request.query_params) - {'limit', 'cursor'}:
|
||||
invalid('Unknown query parameter')
|
||||
value = request.query_params.get('limit', '50')
|
||||
if not re.fullmatch(r'[0-9]{1,3}', value) or not 1 <= int(value) <= 100:
|
||||
invalid('Limit must be 1..100')
|
||||
cursor = request.query_params.get('cursor')
|
||||
return int(value), decode_cursor(cursor, resource, secret) if cursor is not None else None
|
||||
|
||||
|
||||
async def json_body(request):
|
||||
if request.headers.get('content-type', '').split(';')[0].strip().lower() != 'application/json':
|
||||
raise ApiError(415, 'unsupported_media_type', 'Expected application/json')
|
||||
def unique_pairs(pairs):
|
||||
result = {}
|
||||
for key, value in pairs:
|
||||
if key in result:
|
||||
raise ValueError('duplicate key')
|
||||
result[key] = value
|
||||
return result
|
||||
def no_constant(value):
|
||||
raise ValueError('non-finite number')
|
||||
try:
|
||||
return json.loads((await request.body()).decode('utf-8'), object_pairs_hook=unique_pairs, parse_constant=no_constant)
|
||||
except (ValueError, UnicodeError, RecursionError):
|
||||
invalid('Invalid JSON')
|
||||
+85
@@ -0,0 +1,85 @@
|
||||
import asyncio
|
||||
import json
|
||||
import logging
|
||||
import time
|
||||
from uuid import uuid4
|
||||
from starlette.responses import JSONResponse
|
||||
from .common import ApiError
|
||||
logger=logging.getLogger("messenger")
|
||||
|
||||
def error_response(exc, request_id):
|
||||
return JSONResponse({'error': {'code': exc.code, 'message': exc.message, 'request_id': request_id}},
|
||||
status_code=exc.status, headers={'X-Request-Id': request_id, **exc.headers})
|
||||
|
||||
|
||||
class Boundaries:
|
||||
"""Admission before body buffering; no unbounded application waiting queue."""
|
||||
def __init__(self, app, settings):
|
||||
self.app, self.cfg = app, settings
|
||||
self.active, self.tokens, self.updated = 0, float(settings.write_burst), time.monotonic()
|
||||
|
||||
async def __call__(self, scope, receive, send):
|
||||
if scope['type'] != 'http':
|
||||
return await self.app(scope, receive, send)
|
||||
request_id, started, status = uuid4().hex, time.monotonic(), 500
|
||||
scope.setdefault('state', {})['request_id'] = request_id
|
||||
started_response = False
|
||||
async def tracked_send(message):
|
||||
nonlocal status, started_response
|
||||
if message['type'] == 'http.response.start':
|
||||
status, started_response = message['status'], True
|
||||
message['headers'] = [(k, v) for k, v in message.get('headers', []) if k.lower() != b'x-request-id'] + [(b'x-request-id', request_id.encode())]
|
||||
await send(message)
|
||||
admitted = False
|
||||
try:
|
||||
if self.active >= self.cfg.max_inflight:
|
||||
raise ApiError(503, 'unavailable', 'Too many in-flight requests', {'Retry-After': '1'})
|
||||
now = time.monotonic()
|
||||
self.tokens = min(self.cfg.write_burst, self.tokens + (now - self.updated) * self.cfg.write_rps)
|
||||
self.updated = now
|
||||
if scope['method'] in ('POST', 'PUT', 'PATCH'):
|
||||
if self.tokens < 1:
|
||||
raise ApiError(429, 'rate_limited', 'Write rate exceeded', {'Retry-After': '1'})
|
||||
self.tokens -= 1
|
||||
self.active += 1
|
||||
admitted = True
|
||||
chunks, total = bytearray(), 0
|
||||
async with asyncio.timeout(self.cfg.request_timeout):
|
||||
while True:
|
||||
message = await receive()
|
||||
if message['type'] == 'http.disconnect':
|
||||
return
|
||||
chunk = message.get('body', b'')
|
||||
total += len(chunk)
|
||||
if total > self.cfg.max_body_bytes:
|
||||
raise ApiError(413, 'payload_too_large', 'Request body exceeds byte limit')
|
||||
chunks.extend(chunk)
|
||||
if not message.get('more_body', False):
|
||||
break
|
||||
body = bytes(chunks)
|
||||
delivered = False
|
||||
async def replay():
|
||||
nonlocal delivered
|
||||
if delivered:
|
||||
return await receive()
|
||||
delivered = True
|
||||
return {'type': 'http.request', 'body': body, 'more_body': False}
|
||||
await self.app(scope, replay, tracked_send)
|
||||
except TimeoutError:
|
||||
if not started_response:
|
||||
await error_response(ApiError(503, 'unavailable', 'Request timed out'), request_id)(scope, receive, tracked_send)
|
||||
except ApiError as exc:
|
||||
if not started_response:
|
||||
await error_response(exc, request_id)(scope, receive, tracked_send)
|
||||
except Exception as exc:
|
||||
logger.error(json.dumps({'event': 'unexpected_error', 'request_id': request_id, 'type': type(exc).__name__}))
|
||||
if not started_response:
|
||||
await error_response(ApiError(500, 'internal_error', 'Internal error'), request_id)(scope, receive, tracked_send)
|
||||
finally:
|
||||
if admitted:
|
||||
self.active -= 1
|
||||
# No query, body, headers, usernames, or message content in logs.
|
||||
route = scope.get('route')
|
||||
logger.info(json.dumps({'event': 'http', 'request_id': request_id, 'method': scope['method'],
|
||||
'route': getattr(route, 'path', 'unmatched'), 'status': status,
|
||||
'duration_ms': round((time.monotonic() - started) * 1000, 3)}))
|
||||
@@ -0,0 +1,28 @@
|
||||
"""Versioned, transactional migrations, serialized across deployers."""
|
||||
import hashlib
|
||||
import os
|
||||
from pathlib import Path
|
||||
import psycopg
|
||||
|
||||
|
||||
def main():
|
||||
with psycopg.connect(os.environ['DATABASE_URL'],autocommit=True,connect_timeout=5) as conn:
|
||||
conn.execute('SELECT pg_advisory_lock(23012026)')
|
||||
try:
|
||||
conn.execute('CREATE TABLE IF NOT EXISTS schema_migrations (name text PRIMARY KEY, sha256 text NOT NULL, applied_at timestamptz NOT NULL DEFAULT clock_timestamp())')
|
||||
for file in sorted((Path(__file__).resolve().parents[1]/'migrations').glob('*.sql')):
|
||||
data=file.read_bytes(); digest=hashlib.sha256(data).hexdigest()
|
||||
row=conn.execute('SELECT sha256 FROM schema_migrations WHERE name=%s',(file.name,)).fetchone()
|
||||
if row:
|
||||
if row[0]!=digest: raise RuntimeError('An applied migration was modified: '+file.name)
|
||||
print('Already applied:',file.name,flush=True)
|
||||
continue
|
||||
with conn.transaction():
|
||||
conn.execute(data.decode('utf-8'))
|
||||
conn.execute('INSERT INTO schema_migrations(name,sha256) VALUES (%s,%s)',(file.name,digest))
|
||||
print('Applied:',file.name,flush=True)
|
||||
finally:
|
||||
conn.execute('SELECT pg_advisory_unlock(23012026)')
|
||||
|
||||
|
||||
if __name__=='__main__': main()
|
||||
+130
@@ -0,0 +1,130 @@
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
from uuid import uuid4
|
||||
|
||||
import psycopg
|
||||
from psycopg.rows import dict_row
|
||||
from psycopg_pool import AsyncConnectionPool
|
||||
from redis.asyncio import Redis
|
||||
from redis.exceptions import RedisError
|
||||
|
||||
from .common import ApiError, encode_cursor, invalid
|
||||
|
||||
|
||||
def clean(row):
|
||||
if row is None: return None
|
||||
result={}
|
||||
for k,v in row.items():
|
||||
if hasattr(v,'isoformat'): v=v.isoformat(timespec='microseconds').replace('+00:00','Z')
|
||||
elif isinstance(v,list): v=[str(x) for x in v]
|
||||
elif type(v).__name__=='UUID': v=str(v)
|
||||
result[k]=v
|
||||
return result
|
||||
|
||||
|
||||
class Store:
|
||||
def __init__(self,cfg):
|
||||
self.cfg=cfg
|
||||
self.secret=cfg.cursor_secret.encode()
|
||||
self.pool=AsyncConnectionPool(cfg.database_url,min_size=1,max_size=cfg.db_pool_size,
|
||||
timeout=2,max_waiting=32,open=False,
|
||||
kwargs={'row_factory':dict_row,'connect_timeout':3,
|
||||
'options':'-c statement_timeout=2000 -c lock_timeout=1000 -c timezone=UTC'})
|
||||
self.cache=Redis.from_url(cfg.redis_url,socket_timeout=.2,socket_connect_timeout=.2,
|
||||
max_connections=8,decode_responses=True)
|
||||
|
||||
async def open(self): await self.pool.open(wait=True,timeout=20)
|
||||
async def close(self):
|
||||
await self.cache.aclose()
|
||||
await self.pool.close()
|
||||
|
||||
async def ready(self):
|
||||
async with self.pool.connection() as c: await c.execute('SELECT 1')
|
||||
|
||||
async def register(self,username,display_name,password_hash):
|
||||
try:
|
||||
async with self.pool.connection() as c:
|
||||
row=await (await c.execute('INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING id,username,display_name,created_at',
|
||||
(uuid4(),username,display_name,password_hash))).fetchone()
|
||||
return clean(row)
|
||||
except psycopg.errors.UniqueViolation:
|
||||
raise ApiError(409,'conflict','Username already exists') from None
|
||||
|
||||
async def credentials(self,username):
|
||||
async with self.pool.connection() as c:
|
||||
return await (await c.execute('SELECT * FROM users WHERE username=%s',(username,))).fetchone()
|
||||
|
||||
async def create_session(self,user_id,token):
|
||||
async with self.pool.connection() as c:
|
||||
row=await (await c.execute("INSERT INTO sessions(token_hash,user_id,expires_at) VALUES (%s,%s,clock_timestamp()+%s*interval '1 second') RETURNING expires_at",
|
||||
(hashlib.sha256(token.encode()).hexdigest(),user_id,self.cfg.session_ttl_seconds))).fetchone()
|
||||
return clean(row)['expires_at']
|
||||
|
||||
async def authenticate(self,token):
|
||||
async with self.pool.connection() as c:
|
||||
session=await (await c.execute('SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at>clock_timestamp()',
|
||||
(hashlib.sha256(token.encode()).hexdigest(),))).fetchone()
|
||||
if session is None: raise ApiError(401,'unauthorized','Invalid session',{'WWW-Authenticate':'Bearer realm="messenger"'})
|
||||
key='user:'+str(session['user_id'])
|
||||
try:
|
||||
cached=await self.cache.get(key)
|
||||
if cached: return json.loads(cached)
|
||||
except (RedisError,ValueError):
|
||||
logging.getLogger('messenger').warning('{"event":"cache_bypass"}')
|
||||
row=await (await c.execute('SELECT id,username,display_name,created_at FROM users WHERE id=%s',(session['user_id'],))).fetchone()
|
||||
user=clean(row)
|
||||
try: await self.cache.set(key,json.dumps(user),ex=60)
|
||||
except RedisError: pass
|
||||
return user
|
||||
|
||||
async def logout(self,token):
|
||||
async with self.pool.connection() as c:
|
||||
await c.execute('DELETE FROM sessions WHERE token_hash=%s',(hashlib.sha256(token.encode()).hexdigest(),))
|
||||
|
||||
async def _chat(self,c,actor,chat_id):
|
||||
row=await (await c.execute('SELECT c.id,c.title,c.created_at,ARRAY(SELECT user_id FROM members WHERE chat_id=c.id ORDER BY user_id) AS member_ids FROM chats c JOIN members m ON m.chat_id=c.id WHERE c.id=%s AND m.user_id=%s',(chat_id,actor))).fetchone()
|
||||
if row is None: raise ApiError(404,'not_found','Object not found')
|
||||
return clean(row)
|
||||
|
||||
async def chat(self,actor,chat_id):
|
||||
async with self.pool.connection() as c: return await self._chat(c,actor,chat_id)
|
||||
|
||||
async def create_chat(self,actor,title,members):
|
||||
if actor not in members: invalid('Members must include the current user')
|
||||
try:
|
||||
async with self.pool.connection() as c:
|
||||
cid=uuid4()
|
||||
await c.execute('INSERT INTO chats(id,title) VALUES (%s,%s)',(cid,title))
|
||||
async with c.cursor() as cur:
|
||||
await cur.executemany('INSERT INTO members(chat_id,user_id) VALUES (%s,%s)',[(cid,m) for m in members])
|
||||
return await self._chat(c,actor,cid)
|
||||
except psycopg.errors.ForeignKeyViolation:
|
||||
invalid('All members must exist')
|
||||
|
||||
async def create_message(self,actor,chat_id,text):
|
||||
async with self.pool.connection() as c:
|
||||
await self._chat(c,actor,chat_id)
|
||||
row=await (await c.execute('INSERT INTO messages(id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING id,chat_id,sender_id,text,created_at',
|
||||
(uuid4(),chat_id,actor,text))).fetchone()
|
||||
return clean(row)
|
||||
|
||||
async def page(self,actor,chat_id,limit,cursor):
|
||||
async with self.pool.connection() as c:
|
||||
if chat_id:
|
||||
await self._chat(c,actor,chat_id)
|
||||
query='SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id=%s'
|
||||
args=[chat_id]; resource='messages:'+chat_id
|
||||
if cursor:
|
||||
query+=' AND (created_at,id)>(%s::timestamptz,%s::uuid)'; args.extend(cursor)
|
||||
query+=' ORDER BY created_at,id LIMIT %s'; args.append(limit+1)
|
||||
else:
|
||||
query='SELECT c.id,c.title,c.created_at,ARRAY(SELECT user_id FROM members WHERE chat_id=c.id ORDER BY user_id) AS member_ids FROM chats c JOIN members m ON m.chat_id=c.id WHERE m.user_id=%s'
|
||||
args=[actor]; resource='chats:'+actor
|
||||
if cursor:
|
||||
query+=' AND (c.created_at,c.id)>(%s::timestamptz,%s::uuid)'; args.extend(cursor)
|
||||
query+=' ORDER BY c.created_at,c.id LIMIT %s'; args.append(limit+1)
|
||||
rows=[clean(row) for row in await (await c.execute(query,args)).fetchall()]
|
||||
selected=rows[:limit]
|
||||
next_cursor=encode_cursor(resource,(selected[-1]['created_at'],selected[-1]['id']),self.secret) if len(rows)>limit else None
|
||||
return {'items':selected,'next_cursor':next_cursor}
|
||||
Reference in New Issue
Block a user