выполнение лр2 на 4 #21

Closed
Iicon18 wants to merge 3 commits from Iicon18/mtusi2026lab2:solution/bvt2304-koshelev into master
34 changed files with 2483 additions and 15 deletions
+3
View File
@@ -9,3 +9,6 @@ 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
SESSION_CACHE_MAX_SECONDS=300
DB_POOL_MAX=10
SHORT_TTL_PORT=8081
+526
View File
@@ -0,0 +1,526 @@
# Демонстрация лабораторной 2 на защите
Сценарий повторяет раздел «Сценарий защиты» из README: стек поднимается с нуля на пустом volume, затем показываются сессии, сохранность после рестарта, роль Valkey, план SQL и отказы зависимостей.
**Важно:** выполняйте команды по порядку **в одном окне терминала**. Переменные `B`, `S`, `ALICE`, `BOB`, `CAROL`, `CHAT`, `TA`, `TB`, `TC` и функции `j`, `pg`, `vk` живут только в этом окне.
---
## 0. Подготовка: чистый clone
Если запущен рабочий стенд, останавливаем его. Volume при этом сохраняется, порт 8080 освобождается:
```bash
(cd ~/Desktop/вуз/ВНП/lab2/mtusi2026lab2 && docker compose --profile ttl-test down)
```
Скачиваем решение в новую папку:
```bash
git clone -b solution/bvt2304-koshelev ssh://git@gitea.privcloud.tech:2222/Iicon18/mtusi2026lab2.git ~/Desktop/lab2-demo
```
```bash
cd ~/Desktop/lab2-demo
```
Отдельное имя compose-проекта даёт отдельные контейнеры и **новый пустой volume**:
```bash
export COMPOSE_PROJECT_NAME=lab2-demo
```
```bash
cp .env.example .env
```
Если порт 8080 или 8081 занят, поменяйте `APP_PORT` / `SHORT_TTL_PORT` в `.env`, следующая команда сама подхватит новые значения.
```bash
B=http://127.0.0.1:$(sed -n 's/^APP_PORT=//p' .env); S=http://127.0.0.1:$(sed -n 's/^SHORT_TTL_PORT=//p' .env); echo "$B $S"
```
Вспомогательные функции: достать поле из JSON, выполнить SQL, выполнить команду Valkey.
```bash
j() { python3 -c 'import sys,json;print(json.load(sys.stdin)[sys.argv[1]])' "$1"; }
pg() { docker compose exec -T postgres psql -U messenger -d messenger -c "$1"; }
vk() { docker compose exec -T valkey sh -c 'valkey-cli --no-auth-warning -a "$(sed -n "s/^requirepass //p" /run/secrets/valkey_conf)" "$@"' valkey-cli "$@"; }
```
> **Сказать:** «Это свежий clone моей ветки в отдельный compose-проект, база будет пустой. `.env` и секреты не хранятся в Git, создаю их локально».
---
## 1. Секреты
```bash
make secrets
```
```bash
ls -l secrets/
```
```bash
git check-ignore -v secrets/database_url .env
```
> **Сказать:**
> - «`scripts/init-secrets.sh` генерирует случайные пароли PostgreSQL и Valkey в папку `secrets/`. Она в `.gitignore`, поэтому в репозиторий не попадает».
> - «В контейнеры пароли приходят как compose secrets, файлами в `/run/secrets/...`, а не переменными окружения. Поэтому их не видно в `docker inspect`».
> - «Приложение читает `DATABASE_URL_FILE` и `CACHE_URL_FILE`, то есть путь к файлу, а не сам пароль».
---
## 2. Запуск стека и миграции
```bash
cat compose.yaml
```
> **Сказать:**
> - «Четыре сервиса: `postgres` — источник истины, `valkey` — кэш сессий, `migrate` — одноразовый запуск миграций, `api` — приложение».
> - «Версии образов закреплены: `postgres:17.6-alpine3.22`, `valkey/valkey:8.1.4-alpine3.22`; `latest` нигде нет».
> - «`depends_on` с условиями: api стартует, только когда postgres `healthy`, а migrate завершился с кодом 0».
> - «Данные PostgreSQL лежат в именованном volume `pgdata`».
> - «Порт api опубликован только на `127.0.0.1`, порты БД и Valkey наружу не публикуются».
```bash
make up
```
```bash
docker compose ps --all
```
```bash
docker compose logs migrate
```
```bash
curl -si "$B/health/ready"
```
> **Сказать:**
> - «`make up` = `docker compose up -d --build --wait`, ждёт, пока healthcheck api станет healthy. Healthcheck api проверяет `/health/ready`, а readiness делает `SELECT 1` в PostgreSQL».
> - «`migrate` в статусе `Exited (0)`: применил `0001_init` на пустую базу (`1 applied now, 0 before`)».
---
## 3. Схема БД
```bash
pg '\dt'
```
```bash
pg '\d messages'
```
```bash
pg 'SELECT * FROM schema_migrations'
```
> **Сказать:**
> - «Таблицы `users`, `chats`, `chat_members`, `messages`, `sessions` и служебная `schema_migrations`, где записаны применённые миграции».
> - «`UNIQUE(username)`, CHECK на формат и длины».
> - «Внешний ключ `messages (chat_id, sender_id) → chat_members`: база сама не даст записать сообщение от не-участника».
> - «Индекс `messages_chat_history_idx (chat_id, created_at, id)` повторяет запрос истории, обоснование в шаге 12».
> - «Миграции версионируются. Раннер берёт `pg_advisory_lock` и пропускает уже применённые версии, поэтому повторный запуск безопасен».
---
## 4. Публичный тест
```bash
make check
```
```bash
make test BASE_URL="$B"
```
> **Сказать:** «Это публичный smoke-тест преподавателя для lab2: регистрация с паролем, вход через Basic, работа по Bearer, чаты, сообщения, пагинация, ошибки и logout».
---
## 5. Регистрация, вход, общий чат
Регистрация теперь требует `password` (12–128 символов):
```bash
ALICE=$(curl -s -X POST "$B/api/v1/users" -H 'Content-Type: application/json' -d '{"username":"alice","display_name":"Алиса","password":"Alice-demo-pass-1"}' | tee /dev/stderr | j id)
```
```bash
BOB=$(curl -s -X POST "$B/api/v1/users" -H 'Content-Type: application/json' -d '{"username":"bob","display_name":"Боб 🚀","password":"Bob-demo-pass-123"}' | tee /dev/stderr | j id)
```
```bash
CAROL=$(curl -s -X POST "$B/api/v1/users" -H 'Content-Type: application/json' -d '{"username":"carol","display_name":"Кэрол","password":"Carol:with:colons"}' | tee /dev/stderr | j id)
```
> **Сказать:** «В ответе нет ни пароля, ни хеша, только `id`, `username`, `display_name`, `created_at`. Время назначает PostgreSQL».
Пароль в базе хранится только как хеш:
```bash
pg "SELECT username, left(password_hash, 40) AS hash FROM users WHERE username IN ('alice','bob','carol')"
```
> **Сказать:** «Хеш Argon2id, строка начинается с `$argon2id$v=19$m=65536,t=3,p=4`: 64 МБ памяти и 3 прохода на одну проверку. Соль своя у каждого пароля, поэтому одинаковые пароли дают разные хеши».
Вход: Basic только на `POST /auth/sessions`. `curl -u` сам собирает заголовок `Authorization: Basic base64(username:password)`:
```bash
curl -si -X POST -u 'carol:Carol:with:colons' "$B/api/v1/auth/sessions"
```
```bash
TA=$(curl -s -X POST -u 'alice:Alice-demo-pass-1' "$B/api/v1/auth/sessions" | j token); TB=$(curl -s -X POST -u 'bob:Bob-demo-pass-123' "$B/api/v1/auth/sessions" | j token); TC=$(curl -s -X POST -u 'carol:Carol:with:colons' "$B/api/v1/auth/sessions" | j token); echo "длина токена: ${#TA}"
```
> **Сказать:**
> - «Ответ 201: `token`, `token_type: Bearer`, `expires_at`, `user`. Двоеточие в пароле допустимо, потому что строка делится по **первому** `:`».
> - «Токен — `secrets.token_urlsafe(32)`, 256 случайных бит. Он непрозрачный: внутри нет ни id, ни username, это не JWT».
> - «Срок жизни из `SESSION_TTL_SECONDS` (по умолчанию 3600 с), `expires_at` считает база».
В базе лежит не сам токен, а его sha256:
```bash
pg "SELECT encode(token_hash,'hex') AS token_hash, expires_at, revoked_at FROM sessions ORDER BY created_at DESC LIMIT 3"
```
> **Сказать:** «Если украдут дамп БД, войти по нему не получится: из sha256 токен не восстановить. Медленный KDF для токена не нужен: он случайный, 2^256 вариантов не перебрать. Пароль же выбирает человек, его можно перебрать по словарю, поэтому для пароля нужен медленный Argon2id».
Алиса создаёт чат с Бобом, оба пишут:
```bash
CHAT=$(curl -s -X POST "$B/api/v1/chats" -H 'Content-Type: application/json' -H "Authorization: Bearer $TA" -d "{\"title\":\"Проект по ВНП\",\"member_ids\":[\"$ALICE\",\"$BOB\"]}" | tee /dev/stderr | j id)
```
```bash
curl -s -X POST "$B/api/v1/chats/$CHAT/messages" -H 'Content-Type: application/json' -H "Authorization: Bearer $TA" -d '{"text":"Привет, Боб! 👋"}'
```
```bash
curl -s -X POST "$B/api/v1/chats/$CHAT/messages" -H 'Content-Type: application/json' -H "Authorization: Bearer $TB" -d '{"text":"Привет, Алиса!"}'
```
```bash
curl -s "$B/api/v1/chats/$CHAT/messages" -H "Authorization: Bearer $TB" | python3 -m json.tool --no-ensure-ascii
```
> **Сказать:**
> - «Чат и участники создаются **одной транзакцией**. Если участник неизвестен, FK срабатывает внутри транзакции, вставка чата откатывается и клиент получает 400. Полупустого чата не остаётся (проверяет `db_integrity_test.py`)».
> - «`sender_id` сервер берёт из сессии. Сообщение вставляется одним запросом `INSERT … WHERE EXISTS (участник)`: проверка доступа и запись атомарны».
Кэрол аутентифицирована, но не участник чата:
```bash
curl -i "$B/api/v1/chats/$CHAT/messages" -H "Authorization: Bearer $TC"
```
> **Сказать:** «Аутентификация отвечает на вопрос "кто ты": токен Кэрол валиден. Доступ отвечает на вопрос "можно ли тебе в этот чат": нельзя, поэтому 404, а не 403, чтобы не раскрывать, что такой чат существует».
---
## 6. Ошибки аутентификации
Неверный пароль и несуществующий пользователь дают одинаковый 401 с вызовом `Basic`:
```bash
curl -i -X POST -u 'alice:wrong-password-1' "$B/api/v1/auth/sessions"
```
```bash
curl -i -X POST -u 'nobody:wrong-password-1' "$B/api/v1/auth/sessions"
```
> **Сказать:** «Ответы одинаковые, поэтому подобрать существующие username не выйдет. Для несуществующего пользователя всё равно проверяется фиктивный хеш, чтобы время ответа тоже было одинаковым».
Basic на бизнес-endpoint даёт 401 с вызовом `Bearer`:
```bash
curl -i -u 'alice:Alice-demo-pass-1' "$B/api/v1/users/me"
```
`X-User-Id` из lab1 больше ничего не значит:
```bash
curl -i "$B/api/v1/users/me" -H "X-User-Id: $ALICE"
```
```bash
curl -s "$B/api/v1/users/me" -H "Authorization: Bearer $TC" -H "X-User-Id: $ALICE"
```
> **Сказать:** «Без токена `X-User-Id` даёт 401. С токеном Кэрол и `X-User-Id` Алисы ответ — Кэрол: заголовок просто игнорируется».
Короткий пароль при регистрации даёт 400:
```bash
curl -i -X POST "$B/api/v1/users" -H 'Content-Type: application/json' -d '{"username":"dave","display_name":"Дэйв","password":"short"}'
```
---
## 7. Роль Valkey: кэш сессий
Все ключи сессий: сколько секунд осталось жить и значение.
```bash
for k in $(vk --scan --pattern 'session:*'); do echo "$(vk TTL "$k")s $(vk GET "$k" | cut -c1-70)"; done
```
> **Сказать:**
> - «Строки `{"user": …}` — закэшированные живые сессии. Строки `revoked` — tombstone'ы после logout, например от smoke-теста в шаге 4 (подробно в шаге 9)».
> - «**Источник истины — PostgreSQL**. Valkey только кэширует проверку токена, чтобы не ходить в БД на каждом запросе. `/users/me` вообще обслуживается из кэша».
> - «Ключ — `session:` + sha256 токена, значение — пользователь и `expires_at`».
> - «TTL записи = min(остаток сессии, 300 с). При чтении из кэша `expires_at` сравнивается ещё раз, поэтому просроченная сессия из кэша не пройдёт».
> - «Persistence у Valkey выключена (`save ""`, `appendonly no`). После flush или рестарта кэш просто пуст: следующий запрос проверит токен в PostgreSQL и снова положит его в кэш. Данные при этом не теряются».
---
## 8. Сохранность: рестарт API и всех хранилищ
```bash
cat scripts/restart.sh
```
```bash
docker compose ps --format 'table {{.Service}}\t{{.Status}}'
```
```bash
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL="$B"
```
```bash
docker compose ps --format 'table {{.Service}}\t{{.Status}}'
```
> **Сказать:** «Тест держит токен только в памяти, вызывает мой `restart.sh` (остановить api, valkey и postgres, затем поднять заново, volume не трогается) и тем же токеном читает те же данные. По `Up N seconds` видно, что все три контейнера действительно перезапускались».
Проверим руками тем же токеном Алисы:
```bash
vk DBSIZE
```
```bash
curl -s "$B/api/v1/chats/$CHAT/messages" -H "Authorization: Bearer $TA" | python3 -m json.tool --no-ensure-ascii
```
```bash
docker compose logs migrate | tail -1
```
> **Сказать:**
> - «Прежний токен работает, сообщения на месте. Сессия пережила рестарт, потому что хранится в PostgreSQL. Срок не продлился: `expires_at` записан в базе».
> - «Старые записи кэша пропали вместе с рестартом Valkey. Те несколько ключей, что видны в `DBSIZE`, заново положили проверочные запросы теста после рестарта: кэш наполняется сам из PostgreSQL».
> - «Миграции при рестарте прогнались ещё раз: `0 applied now, 1 before`, без дублирования».
> - «Ответ на вопрос "что подтверждает COMMIT": запись попала в WAL и сброшена на диск (`fsync=on`, `synchronous_commit=on` по умолчанию). Поэтому 201 после COMMIT означает, что сообщение переживёт и падение PostgreSQL. Если выключить `synchronous_commit`, последние подтверждённые транзакции можно потерять».
---
## 9. Logout
```bash
curl -i -X DELETE "$B/api/v1/auth/sessions/current" -H "Authorization: Bearer $TC"
```
```bash
curl -i "$B/api/v1/users/me" -H "Authorization: Bearer $TC"
```
```bash
curl -i -X DELETE "$B/api/v1/auth/sessions/current" -H "Authorization: Bearer $TC"
```
```bash
for k in $(vk --scan --pattern 'session:*'); do echo "$k => $(vk GET "$k" | cut -c1-40)"; done
```
> **Сказать:**
> - «Logout даёт 204 без тела. После него тот же токен получает 401, повторный logout тоже 401».
> - «Порядок такой: сначала `revoked_at` в PostgreSQL (источник истины), потом в Valkey пишется **tombstone** `revoked`, а не простое удаление ключа».
> - «Зачем tombstone: параллельный запрос мог прочитать сессию из БД **до** logout и положить её в кэш **после**. Кэш заполняется через `SET NX` и не перезапишет tombstone, поэтому отозванная сессия не воскреснет».
---
## 10. Истечение сессии (короткий TTL)
Поднимаем второй экземпляр того же образа с `SESSION_TTL_SECONDS=2`:
```bash
docker compose --profile ttl-test up -d --wait api-short-ttl
```
Вход и обе проверки одной строкой: окно в 2 секунды слишком короткое, чтобы успеть вставить отдельные команды.
```bash
TD=$(curl -s -X POST -u 'bob:Bob-demo-pass-123' "$S/api/v1/auth/sessions" | tee /dev/stderr | j token); echo; curl -s -o /dev/null -w 'сразу: %{http_code}\n' "$S/api/v1/users/me" -H "Authorization: Bearer $TD"; sleep 3; curl -si "$S/api/v1/users/me" -H "Authorization: Bearer $TD"
```
```bash
docker compose --profile ttl-test stop api-short-ttl
```
> **Сказать:** «`expires_at` всего через 2 секунды после входа. Сразу 200, через 3 секунды 401 с `WWW-Authenticate: Bearer`, хотя запись была и в кэше. Обычный api работает с TTL 3600, так как smoke требует не меньше 300».
---
## 11. Отказы зависимостей
### Valkey недоступен — API работает без кэша
```bash
docker compose stop valkey
```
```bash
curl -si "$B/health/ready"
```
```bash
time curl -s "$B/api/v1/users/me" -H "Authorization: Bearer $TA"
```
```bash
curl -s -o /dev/null -w '%{http_code}\n' "$B/api/v1/users/me" -H "Authorization: Bearer $TC"
```
```bash
docker compose logs --tail 3 api
```
```bash
docker compose start valkey
```
> **Сказать:**
> - «Readiness 200: Valkey для API не критичен».
> - «Запросы идут напрямую в PostgreSQL, ответ за миллисекунды. Остановленный контейнер сразу отказывает в соединении. Если бы сеть зависла, сработал бы таймаут 0.3 с. После первой ошибки circuit breaker 5 секунд вообще не обращается к Valkey, поэтому задержка не копится. В логе предупреждение `bypassing cache`».
> - «Отозванный токен Кэрол по-прежнему 401: отзыв записан в БД».
### PostgreSQL недоступен — ограниченная ошибка, анонимного доступа нет
Заранее берём новый токен Боба. Проверок по нему ещё не было, поэтому в кэше его нет:
```bash
TB2=$(curl -s -X POST -u 'bob:Bob-demo-pass-123' "$B/api/v1/auth/sessions" | j token)
```
```bash
docker compose stop postgres
```
```bash
curl -si "$B/health/live"; echo; curl -si "$B/health/ready"
```
```bash
curl -si "$B/api/v1/chats" -H "Authorization: Bearer $TA"
```
```bash
curl -s -o /dev/null -w '%{http_code}\n' "$B/api/v1/users/me" -H "Authorization: Bearer $TB2"; curl -s -o /dev/null -w '%{http_code}\n' "$B/api/v1/users/me"
```
> **Сказать:**
> - «Liveness 200: процесс жив. Readiness 503: обслуживать запросы безопасно нельзя».
> - «Бизнес-запрос даёт `503 unavailable` мгновенно, без SQL и стектрейсов в теле. Pool ограничен 10 соединениями, таймауты подключения, захвата соединения и команды — 3, 3 и 5 с, так что зависнуть запрос не может».
> - «Токен, который проверить негде (в кэше его нет, БД лежит), получает **503, а не 200**: непроверенный запрос не считается аутентифицированным. Без токена — по-прежнему 401».
```bash
docker compose start postgres
```
```bash
until curl -s -o /dev/null -w '%{http_code}' "$B/health/ready" | grep -q 200; do sleep 0.5; done; echo ready
```
```bash
curl -s "$B/api/v1/users/me" -H "Authorization: Bearer $TB2"
```
> **Сказать:** «API восстановился сам, без своего рестарта: pool переподключается к базе по требованию».
---
## 12. Индекс истории и EXPLAIN
```bash
make explain
```
```bash
cat evidence/explain_history.txt
```
> **Сказать:**
> - «Скрипт засевает 70 000 синтетических сообщений, 20 000 из них в одном чате, и выполняет **тот же запрос, что в коде**, как prepared statement: `WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT 51`».
> - «С индексом `(chat_id, created_at, id)`: `Index Scan`, условие по курсору уходит прямо в `Index Cond`, читается 4 буфера, около 0.03 мс. Даже на глубокой странице после 15 000-го сообщения работа та же».
> - «Без индекса (DROP INDEX внутри транзакции и ROLLBACK): `Seq Scan` по всей таблице и `Sort`, 940 буферов, 3–4 мс, и время растёт вместе с таблицей».
> - «Keyset против OFFSET: `OFFSET 15000` заставил бы прочитать и выбросить 15 000 строк на каждой странице. Курсор сразу прыгает в нужное место индекса».
---
## 13. Уровень 4: свои тесты одной командой
```bash
make test-student BASE_URL="$B" SHORT_TTL_URL="$S"
```
> **Сказать:**
> - **own_tests.py**, **concurrency_test.py** — перенесены из lab1: битый JSON, чужой чат, пустое сообщение, пагинация; 100 параллельных сообщений от 10 клиентов.
> - **auth_test.py** — неверный пароль, Basic и `X-User-Id` на бизнес-endpoint, пароль с `:` и UTF-8, logout только текущего токена, истечение при TTL=2 с.
> - **db_integrity_test.py**:
> - 20 параллельных регистраций одного username → ровно один 201 и девятнадцать 409. Гонку решает `UNIQUE` в БД, а не проверка "SELECT, потом INSERT";
> - rollback создания чата;
> - Argon2id в базе;
> - повторные миграции ничего не меняют.
> - **dependency_test.py** — роль Valkey (кэш, TTL, tombstone), остановка Valkey, остановка PostgreSQL и восстановление.
> - **sigterm_test.sh** — `docker compose stop api` → код выхода 0, а не 137.
---
## 14. Остановка и удаление данных
Обычная остановка: данные остаются в volume.
```bash
docker compose --profile ttl-test down
```
```bash
docker volume ls | grep lab2-demo
```
Намеренное удаление учебных данных демо-стенда (необратимо):
```bash
docker compose --profile ttl-test down -v
```
> **Сказать:** «`down` удаляет контейнеры, но не volume, поэтому данные переживут и это. Только `down -v` удаляет volume. В `restart.sh` и тестах `-v` не используется нигде».
---
## Короткие ответы на вопросы из README
- **Что подтверждает COMMIT и от чего зависят гарантии.**
- COMMIT значит, что транзакция записана в WAL и, при `synchronous_commit=on` и `fsync=on` (по умолчанию), сброшена на диск. Такая запись переживает падение процесса и рестарт ОС.
- С `synchronous_commit=off` последние подтверждённые транзакции можно потерять. С `fsync=off` после сбоя питания можно повредить базу.
- Потерю самого диска или хоста COMMIT не покрывает: нужны реплики и бэкапы.
- **Где хранятся сессии и что будет после flush или рестарта Redis.**
- Сессии хранятся в PostgreSQL, в таблице `sessions` (`sha256(token)`, `expires_at`, `revoked_at`). Valkey только кэш.
- После flush кэш пуст, первая проверка токена идёт в БД. Ни одна сессия не теряется и не воскрешается: отзыв тоже записан в БД. Поэтому persistence у Valkey не нужна.
- **Аутентификация против доступа к чату.**
- Аутентификация устанавливает, кто ты: валидный Bearer-токен, иначе 401.
- Доступ (авторизация) решает, можно ли этому пользователю к этому ресурсу: участник ли он чата. Если нет — 404, а не 403, чтобы не раскрывать существование чата.
- **Hash пароля против быстрого checksum.**
- Быстрый хеш (sha256) нужен для целостности и для индексации случайных значений: так мы храним токены.
- Пароль низкоэнтропийный, его подбирают по словарю. Для него нужен медленный KDF с солью и затратами памяти (Argon2id), чтобы каждая попытка подбора была дорогой даже на GPU.
+23
View File
@@ -0,0 +1,23 @@
FROM python:3.12.8-slim-bookworm
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app ./app
COPY migrations ./migrations
RUN useradd --system --no-create-home --uid 10001 appuser
USER appuser
ENV APP_HOST=0.0.0.0 \
APP_PORT=8080 \
PYTHONUNBUFFERED=1
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD python -c "import os,urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:'+os.environ.get('APP_PORT','8080')+'/health/ready',timeout=2).status==200 else 1)"
CMD ["sh", "-c", "exec uvicorn app.main:app --host ${APP_HOST} --port ${APP_PORT} --timeout-graceful-shutdown 8"]
+16 -1
View File
@@ -4,7 +4,7 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence
.PHONY: help check validate test load test-persistence secrets up down test-student explain
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -24,3 +24,18 @@ 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)
secrets:
sh scripts/init-secrets.sh
up: secrets
docker compose up -d --build --wait
down:
docker compose --profile ttl-test down
test-student:
BASE_URL="$(BASE_URL)" sh student-tests/run_all.sh
explain:
sh student-tests/explain_history.sh
+125 -14
View File
@@ -1,37 +1,148 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Целевая оценка: **4** (трек 5 не заявлен)
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Использованные источники, библиотеки и помощь ИИ: FastAPI, uvicorn, pydantic, asyncpg, redis-py (клиент к Valkey), argon2-cffi; документация PostgreSQL (transactions, EXPLAIN), Valkey persistence, RFC 7617. Код lab1 перенесён из собственного решения. При переносе на PostgreSQL, написании тестов и отчёта использовался ИИ-ассистент Claude (Anthropic); решения проверены и объяснимы автором.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Требования: Docker Engine с Compose v2 (проверено: Docker 28.0.1, Compose 2.33.1), Python 3.9+ для тестов (проверено на 3.14), `make`.
| Роль | Образ | Версия |
| --- | --- | --- |
| api / migrate | `mtusi-messenger:lab2`, сборка из `Dockerfile` | `python:3.12.8-slim-bookworm`, зависимости закреплены в `requirements.txt` |
| postgres | `postgres:17.6-alpine3.22` | PostgreSQL 17.6 |
| valkey | `valkey/valkey:8.1.4-alpine3.22` | Valkey 8.1.4 |
```sh
cp .env.example .env # при занятом 8080 поменять APP_PORT
make secrets # scripts/init-secrets.sh: случайные пароли в ./secrets (в .gitignore)
docker compose --env-file .env config --quiet
make up # docker compose up -d --build --wait: postgres -> migrate -> api; ждёт healthcheck /health/ready
make check
make test BASE_URL=http://localhost:8080
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8080
make test-student BASE_URL=http://localhost:8080 # собственные тесты; останавливает/запускает контейнеры
make explain # засев 70 000 синтетических сообщений + EXPLAIN
```
- Миграции: отдельный одноразовый сервис `migrate` (`python -m app.migrate`). API стартует только после его успешного завершения. Повторный запуск безопасен (`schema_migrations` + `pg_advisory_lock`).
- Безопасная остановка без потери данных: `make down` (= `docker compose --profile ttl-test down`, volume `pgdata` сохраняется).
- **Намеренное удаление учебных данных:** `docker compose --profile ttl-test down -v` (удаляет volume `messenger-lab2_pgdata`; необратимо).
- Действия оператора: только `make secrets` перед первым запуском. Секреты в образ и Git не попадают.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
клиент ──HTTP──> api (FastAPI/uvicorn, 1 процесс)
├──> postgres : источник истины — users, chats, chat_members, messages, sessions
└──> valkey : кэш поиска сессии (только ускорение, может пропасть в любой момент)
migrate (one-shot) ──> postgres : применение migrations/*.sql
```
**Перенесено из lab1:** модели pydantic, формат ошибок и `X-Request-Id`, keyset-курсор, привязанный к ресурсу, проверки контракта (пустой текст, дубликаты участников, 404 на чужой чат), Dockerfile (non-root, graceful SIGTERM). In-memory `Store` заменён на репозиторий PostgreSQL (`app/storage.py`).
**Изменено по контракту lab2:** `password` при регистрации, `POST /auth/sessions` через Basic, Bearer на всех бизнес-endpoint, `DELETE /auth/sessions/current`. `X-User-Id` не читается вообще.
### Схема БД (`migrations/0001_init.sql`)
| Таблица | Ключи и ограничения | Индексы |
| --- | --- | --- |
| users | PK id; `UNIQUE(username)`; CHECK формата username и длины display_name | уникальный по username |
| chats | PK id; CHECK длины title | — |
| chat_members | PK (chat_id, user_id); FK на chats и users; `position` хранит порядок member_ids | `(user_id, chat_id)` для списка чатов пользователя |
| messages | PK id; **FK (chat_id, sender_id) → chat_members**: отправитель обязан быть участником на уровне БД; CHECK длины текста | `(chat_id, created_at, id)` для истории |
| sessions | PK token_hash (sha256 токена, сам токен не хранится); FK user_id; expires_at, revoked_at | `(expires_at)` |
Время (`created_at`, `expires_at`) назначает PostgreSQL (`clock_timestamp()`), в API выдаётся RFC 3339 UTC с микросекундами. Порядок `(created_at, id)`; сравнение uuid в PostgreSQL побайтовое и совпадает с порядком UUID-int в тестах.
### Транзакционные границы
- **Создание чата** — одна транзакция: `INSERT chats` + `INSERT chat_members … FROM unnest($2::uuid[])`. Неизвестный участник отлавливает FK внутри транзакции → `ROLLBACK` → 400. Предварительного SELECT нет, поэтому откат реально выполняется (тест `db_integrity_test.py`).
- **Регистрация** — один `INSERT`; гонку одинаковых username решает `UNIQUE` (`UniqueViolationError` → 409), а не проверка «SELECT, потом INSERT».
- **Отправка сообщения** — одна инструкция `INSERT … SELECT … WHERE EXISTS(участник)`: проверка доступа и запись атомарны.
- **Logout** — `UPDATE sessions SET revoked_at` (истина), затем надгробие в Valkey.
- `COMMIT` подтверждает запись в WAL; при настройках по умолчанию (`fsync=on`, `synchronous_commit=on`) подтверждённое сообщение переживает падение процесса PostgreSQL. Ответ 201 отправляется только после COMMIT.
### Аутентификация и сессии
- Пароль: **Argon2id** (argon2-cffi, профиль RFC 9106 low-memory: t=3, m=64 MiB, p=4). Хеширование в thread pool, не более 4 одновременно (`PASSWORD_HASH_CONCURRENCY`), чтобы ограничить RAM. Для несуществующего username проверяется фиктивный хеш, поэтому время ответа одинаковое.
- Basic разбирается строго: base64 → UTF-8 → разделение по **первому** `:` (двоеточие в пароле допустимо), username только ASCII, пароль 12–128 code points. Любая ошибка даёт одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`.
- Токен — `secrets.token_urlsafe(32)` (256 бит). В БД и кэше хранится только `sha256(token)`. Быстрый хеш здесь уместен: токен случайный, перебирать его бессмысленно, в отличие от человеческого пароля, которому нужен медленный KDF.
- Срок жизни `SESSION_TTL_SECONDS` (по умолчанию 3600) задаётся в БД как `expires_at`, поэтому рестарт его не продлевает.
### Роль Valkey (уровень 4): кэш сессий
- **Источник истины — PostgreSQL.** Valkey хранит `session:<sha256 hex>` → `{user, expires_at}`, чтобы не ходить в БД на каждом запросе; `/users/me` обслуживается вообще без БД.
- **Expiry:** TTL записи = `min(остаток сессии, SESSION_CACHE_MAX_SECONDS=300)`, плюс при чтении из кэша сравнивается `expires_at`. Просроченная сессия не принимается ни из кэша, ни из БД.
- **Инвалидация:** при logout сначала `revoked_at` в PostgreSQL, затем в Valkey пишется **надгробие** `revoked` (а не DEL). Заполнение кэша идёт через `SET NX`, поэтому параллельный запрос, прочитавший БД до отзыва, не сможет вернуть сессию в кэш.
- **Сбой записи tombstone (исправлено по замечанию к PR):** раньше ошибка записи в Valkey проглатывалась и logout отвечал 204, хотя в кэше оставалась действующая запись сессии; после восстановления Valkey отозванный токен снова получал 200 до 5 минут. Теперь:
- logout отвечает **503** («не подтверждён»), если tombstone не записан; сессия в PostgreSQL при этом уже отозвана;
- хеш токена запоминается в процессе как «отзыв ожидает записи», и запись из кэша для него игнорируется: проверка идёт в PostgreSQL → 401;
- фоновая задача раз в секунду повторяет запись tombstone, пока Valkey не ответит, но не дольше `SESSION_CACHE_MAX_SECONDS` (за это время устаревшая запись истекла бы сама).
- **Persistence не нужна и выключена** (`save ""`, `appendonly no`): после flush или рестарта Valkey первая проверка идёт в PostgreSQL. Потеря кэша ничего не ломает, это подтверждает тест сохранности, где Valkey тоже перезапускается.
- **Отказ Valkey:** таймаут 0.3 с, затем circuit breaker на 5 с, в течение которых кэш не используется. Readiness при этом остаётся 200: Valkey не критичен.
- Конфигурация с `requirepass` лежит в секрете `secrets/valkey.conf`, порт наружу не публикуется.
### Устойчивость к отказам
- asyncpg pool: `max_size=10`, таймауты подключения 3 с, захвата соединения 3 с, команды 5 с. `min_size=0` позволяет API стартовать при недоступной БД (тогда readiness = 503).
- Недоступность или рестарт PostgreSQL (`OSError`, `PostgresConnectionError`, `InterfaceError`, `TooManyConnections`, admin shutdown, statement timeout) превращается в `503 unavailable` без деталей. Без токена по-прежнему 401. Токен, который нельзя проверить (нет в кэше, БД недоступна), получает 503 и **никогда** не считается аутентифицированным.
- Readiness: 200 только при успешном `SELECT 1` в PostgreSQL. Liveness всегда 200.
- Все SQL-запросы параметризованы (`$1…`), строк, склеенных из пользовательского ввода, нет.
### Переменные `.env.example` → реальная конфигурация
| Переменная | Где используется |
| --- | --- |
| APP_HOST / APP_PORT | uvicorn внутри контейнера слушает 0.0.0.0:8080; `APP_PORT` в `.env` — порт хоста (`127.0.0.1:${APP_PORT}`) |
| APP_ENV | передаётся в контейнер, логики не меняет |
| SESSION_TTL_SECONDS | срок сессии; у `api-short-ttl` = 2 |
| DATABASE_URL_FILE | `/run/secrets/database_url` (compose secret из `secrets/database_url`) |
| SESSION_STORE=postgres | сессии хранятся в PostgreSQL |
| CACHE_URL_FILE | `/run/secrets/cache_url`, URL Valkey; без него кэш отключён |
| SESSION_CACHE_MAX_SECONDS, DB_POOL_MAX, SHORT_TTL_PORT | добавлены этой работой (см. выше) |
## Доказательства критериев
Файлы в `evidence/` сняты 2026-10-07 (explain_history), 2026-10-08 UTC (основные) и 2026-10-15 UTC (logout_cache_failure, на отдельном стенде с портом 18280) на MacBook (Apple Silicon, Docker Desktop, без CPU/RAM-лимитов в compose).
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke | `make check`, `make test` | PASS обоих | `evidence/smoke.txt` |
| 3: данные и сессии переживают рестарт API **и хранилищ** | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS; `StartedAt` api/postgres/valkey изменились, volume тот же, тот же токен читает данные | `evidence/persistence.txt` |
| 3: миграции с нуля и повторно | `docker compose -p lab2-clean up` на пустом volume, затем ещё `run migrate` | `1 applied now, 0 before`, затем `0 applied now, 1 before`; smoke PASS на новом стенде | `evidence/fresh_migrations.txt` |
| 3: PK/FK, UNIQUE username, атомарное создание чата | `student-tests/db_integrity_test.py` | чат с неизвестным участником → 400, в `chats` 0 строк с этим title и 0 чатов без участников | `evidence/student_tests.txt` |
| 3: Basic только на /auth/sessions, Bearer, X-User-Id игнорируется, logout, KDF | `auth_test.py`, smoke, `db_integrity_test.py` | Basic/X-User-Id на бизнес-endpoint → 401; повторный logout → 401; hash начинается с `$argon2id$` | `evidence/student_tests.txt` |
| 3: secrets/volumes не в Git | `git status`, `.gitignore` (`secrets/`, `.env`) | секреты только в `./secrets`, в репозитории нет | `.gitignore` |
| 4: Valkey реально используется, TTL, инвалидация | `dependency_test.py` | ключи `session:*` с TTL ≤ 300, после logout значение `revoked` | `evidence/student_tests.txt` |
| 4: параметризованные запросы, ограниченный pool, таймауты | код `app/storage.py`, `app/config.py` | `$n`-параметры, `max_size=10`, таймауты 3/3/5 с | — |
| 4: гонка регистрации | `db_integrity_test.py` | 20 параллельных запросов → 1×201, 19×409, 1 строка | `evidence/student_tests.txt` |
| 4: rollback составной операции | `db_integrity_test.py` | см. строку «атомарное создание чата» | `evidence/student_tests.txt` |
| 4: индекс истории + EXPLAIN на ≥10 000 | `make explain` | 70 000 сообщений, в чате 20 000; с индексом Index Scan, 4 буфера, 0.03 мс на первой и глубокой (#15000) странице; без индекса Seq Scan + Sort, 940 буферов, 3–4 мс | `evidence/explain_history.txt` |
| 4: expiry при коротком TTL | `auth_test.py` против `api-short-ttl` (TTL=2) | через 3 с → 401 (и из кэша) | `evidence/student_tests.txt` |
| 4: logout, неверный пароль | `auth_test.py` | неверный пароль и неизвестный user дают одинаковый 401 | `evidence/student_tests.txt` |
| 4: logout при сбое записи в кэш | `dependency_test.py` (`docker compose pause valkey` во время logout) | до исправления: 204 и отозванный токен → 200 из кэша; после: 503, токен → 401, tombstone дописан после `unpause` | `evidence/logout_cache_failure.txt` |
| 4: недоступность Redis/БД | `dependency_test.py` | Valkey stop: ready=200, запросы ~4 мс; PostgreSQL stop: live=200, ready и бизнес-запросы 503 мгновенно, непроверенный токен → 503, без токена 401; после start всё восстанавливается без рестарта API | `evidence/student_tests.txt` |
| Graceful shutdown (из lab1) | `sigterm_test.sh` | `docker compose stop api` → exit 0 за < 1 с | `evidence/student_tests.txt` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `scripts/restart.sh`: stop api, valkey, postgres → up | данные и сессия на месте, токен тот же | PASS, кэш пустой, сессии берутся из PostgreSQL | ~11 с весь hook / потерь нет |
| `docker compose stop valkey` | API работает без кэша | 200, ~4 мс на запрос (breaker), revoked-токен 401 | мгновенно / потерь нет (кэш) |
| `docker compose pause valkey` во время logout | logout не сообщает об успехе, отозванный токен не принимается | 503; после `unpause` токен → 401, tombstone записан фоновой задачей | ~1 с после восстановления Valkey / потерь нет |
| `docker compose stop postgres` | 503 без зависаний, анонимный доступ не появляется | ready 503, бизнес 503, live 200, всё за < 0.1 с | API восстанавливается сам после `start postgres`, без своего рестарта; подтверждённые данные целы |
| SIGTERM api | graceful exit 0 | exit 0, «Application shutdown complete» | `docker compose up -d --wait api` |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Один Docker-host, по одному PostgreSQL и Valkey, без репликации: потеря host или диска = потеря сервиса (бэкапы не настроены, это трек 2 пятёрки).
- Защита от устаревшей записи после неудачного logout живёт в памяти процесса API. Если сам API перезапустится до того, как Valkey снова станет доступен, или (с lab3) запрос придёт на другую реплику, устаревшая запись может приниматься до `SESSION_CACHE_MAX_SECONDS` (≤ 5 мин). Клиент при этом получил 503, а не 204. Для нескольких реплик нужен общий механизм, например версия сессии в кэше или pub/sub-инвалидация.
- Просроченные строки `sessions` не удаляются автоматически (есть индекс `expires_at` для будущей периодической очистки).
- `/health/ready` не проверяет Valkey намеренно.
- Тело запроса проверяется до аутентификации: на неавторизованный запрос с битым JSON вернётся 400, а не 401 (особенность FastAPI). Это не раскрывает данных.
- `make test` создаёт синтетических пользователей при каждом запуске; удаления в API нет.
- Нагрузочное измерение (`make load`) не делалось: для уровня 4 не требуется.
View File
+113
View File
@@ -0,0 +1,113 @@
from __future__ import annotations
import asyncio
import base64
import binascii
import hashlib
import secrets
from datetime import datetime, timezone
from typing import Optional, Tuple
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
from starlette.concurrency import run_in_threadpool
from app import config
from app.cache import REVOKED, SessionCache
from app.errors import BASIC_CHALLENGE, ApiError, unauthorized
from app.storage import Store, fmt_ts, user_row
_hasher = PasswordHasher()
_hash_slots = asyncio.Semaphore(config.PASSWORD_HASH_CONCURRENCY)
_DUMMY_HASH = _hasher.hash("dummy-password-for-timing")
async def hash_password(password: str) -> str:
async with _hash_slots:
return await run_in_threadpool(_hasher.hash, password)
async def verify_password(password_hash: str, password: str) -> bool:
def verify() -> bool:
try:
return _hasher.verify(password_hash, password)
except (VerificationError, InvalidHashError):
return False
async with _hash_slots:
return await run_in_threadpool(verify)
def token_digest(token: str) -> bytes:
return hashlib.sha256(token.encode("ascii")).digest()
def parse_basic(header: Optional[str]) -> Tuple[str, str]:
bad = unauthorized("invalid credentials", BASIC_CHALLENGE)
if not header:
raise bad
scheme, _, value = header.partition(" ")
if scheme.lower() != "basic" or not value.strip():
raise bad
try:
decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError):
raise bad from None
username, sep, password = decoded.partition(":")
if not sep or not username.isascii() or not 12 <= len(password) <= 128:
raise bad
return username, password
def parse_bearer(header: Optional[str]) -> str:
if not header:
raise unauthorized("bearer token required")
scheme, _, token = header.partition(" ")
token = token.strip()
if scheme.lower() != "bearer" or not token or not token.isascii() or len(token) > 256:
raise unauthorized("bearer token required")
return token
async def login(store: Store, header: Optional[str]) -> dict:
username, password = parse_basic(header)
row = await store.get_credentials(username)
if row is None:
await verify_password(_DUMMY_HASH, password)
raise unauthorized("invalid credentials", BASIC_CHALLENGE)
if not await verify_password(row["password_hash"], password):
raise unauthorized("invalid credentials", BASIC_CHALLENGE)
token = secrets.token_urlsafe(32)
expires_at = await store.create_session(token_digest(token), row["id"], config.SESSION_TTL_SECONDS)
return {"token": token, "token_type": "Bearer", "expires_at": fmt_ts(expires_at), "user": user_row(row)}
async def authenticate(store: Store, cache: SessionCache, header: Optional[str]) -> dict:
digest = token_digest(parse_bearer(header))
cached = await cache.get(digest)
if cached == REVOKED:
raise unauthorized("session expired or revoked")
if isinstance(cached, dict):
expires_at = datetime.fromisoformat(cached["expires_at"].replace("Z", "+00:00"))
if expires_at > datetime.now(timezone.utc):
return cached["user"]
raise unauthorized("session expired or revoked")
row = await store.find_session(digest)
if row is None:
raise unauthorized("session expired or revoked")
user = user_row(row)
remaining = int((row["expires_at"] - datetime.now(timezone.utc)).total_seconds())
await cache.put(digest, {"user": user, "expires_at": fmt_ts(row["expires_at"])}, remaining)
return user
async def logout(store: Store, cache: SessionCache, header: Optional[str]) -> None:
await authenticate(store, cache, header)
digest = token_digest(parse_bearer(header))
expires_at = await store.revoke_session(digest)
if expires_at is None:
raise unauthorized("session expired or revoked")
remaining = int((expires_at - datetime.now(timezone.utc)).total_seconds()) + 1
if not await cache.revoke(digest, remaining):
raise ApiError(503, "unavailable", "logout not confirmed by session cache, retry later")
+125
View File
@@ -0,0 +1,125 @@
from __future__ import annotations
import asyncio
import json
import logging
import time
from typing import Dict, Optional, Set, Union
import redis.asyncio as redis
from redis.exceptions import RedisError
from app import config
logger = logging.getLogger("messenger.cache")
REVOKED = "revoked"
class SessionCache:
def __init__(self, url: Optional[str]):
self._client: Optional[redis.Redis] = None
self._down_until = 0.0
self._pending_revokes: Dict[bytes, float] = {}
self._retry_tasks: Set[asyncio.Task] = set()
if url:
pool = redis.BlockingConnectionPool.from_url(
url,
max_connections=config.CACHE_POOL_MAX,
timeout=config.CACHE_TIMEOUT,
socket_timeout=config.CACHE_TIMEOUT,
socket_connect_timeout=config.CACHE_TIMEOUT,
decode_responses=True,
)
self._client = redis.Redis(connection_pool=pool)
@property
def enabled(self) -> bool:
return self._client is not None
def _usable(self) -> bool:
return self._client is not None and time.monotonic() >= self._down_until
def _failed(self, op: str, exc: Exception) -> None:
self._down_until = time.monotonic() + config.CACHE_RETRY_AFTER
logger.warning("cache %s failed (%s); bypassing cache for %.0fs", op, type(exc).__name__, config.CACHE_RETRY_AFTER)
@staticmethod
def _key(token_hash: bytes) -> str:
return "session:" + token_hash.hex()
def _revoke_pending(self, token_hash: bytes) -> bool:
deadline = self._pending_revokes.get(token_hash)
if deadline is None:
return False
if time.monotonic() >= deadline:
self._pending_revokes.pop(token_hash, None)
return False
return True
async def get(self, token_hash: bytes) -> Union[dict, str, None]:
if not self._usable() or self._revoke_pending(token_hash):
return None
try:
raw = await self._client.get(self._key(token_hash))
except (RedisError, OSError) as exc:
self._failed("get", exc)
return None
if raw is None or raw == REVOKED:
return raw
try:
return json.loads(raw)
except ValueError:
return None
async def put(self, token_hash: bytes, entry: dict, ttl_seconds: int) -> None:
ttl = min(ttl_seconds, config.SESSION_CACHE_MAX_SECONDS)
if ttl <= 0 or not self._usable():
return
try:
await self._client.set(self._key(token_hash), json.dumps(entry), ex=ttl, nx=True)
except (RedisError, OSError) as exc:
self._failed("set", exc)
async def _write_tombstone(self, token_hash: bytes, ttl_seconds: int) -> bool:
try:
await self._client.set(self._key(token_hash), REVOKED, ex=max(1, min(ttl_seconds, config.SESSION_CACHE_MAX_SECONDS)))
return True
except (RedisError, OSError) as exc:
self._failed("revoke", exc)
return False
async def revoke(self, token_hash: bytes, ttl_seconds: int) -> bool:
if self._client is None:
return True
if await self._write_tombstone(token_hash, ttl_seconds):
return True
deadline = time.monotonic() + config.SESSION_CACHE_MAX_SECONDS + 1
self._pending_revokes[token_hash] = deadline
task = asyncio.create_task(self._retry_revoke(token_hash, ttl_seconds, deadline))
self._retry_tasks.add(task)
task.add_done_callback(self._retry_tasks.discard)
return False
async def _retry_revoke(self, token_hash: bytes, ttl_seconds: int, deadline: float) -> None:
while time.monotonic() < deadline:
await asyncio.sleep(1)
remaining = int(deadline - time.monotonic())
if remaining > 0 and await self._write_tombstone(token_hash, min(ttl_seconds, remaining)):
logger.info("revocation tombstone written after cache recovery")
break
self._pending_revokes.pop(token_hash, None)
async def ping(self) -> bool:
if self._client is None:
return False
try:
return bool(await self._client.ping())
except (RedisError, OSError):
return False
async def close(self) -> None:
for task in list(self._retry_tasks):
task.cancel()
if self._client is not None:
await self._client.aclose()
+41
View File
@@ -0,0 +1,41 @@
from __future__ import annotations
import os
from typing import Optional
def _secret(name: str) -> Optional[str]:
value = os.environ.get(name)
if value:
return value.strip()
path = os.environ.get(name + "_FILE")
if path and os.path.exists(path):
with open(path, encoding="utf-8") as fh:
return fh.read().strip() or None
return None
def _int(name: str, default: int) -> int:
return int(os.environ.get(name, default))
def _float(name: str, default: float) -> float:
return float(os.environ.get(name, default))
DATABASE_URL = _secret("DATABASE_URL")
CACHE_URL = _secret("CACHE_URL")
SESSION_TTL_SECONDS = _int("SESSION_TTL_SECONDS", 3600)
SESSION_CACHE_MAX_SECONDS = _int("SESSION_CACHE_MAX_SECONDS", 300)
DB_POOL_MAX = _int("DB_POOL_MAX", 10)
DB_CONNECT_TIMEOUT = _float("DB_CONNECT_TIMEOUT", 3)
DB_ACQUIRE_TIMEOUT = _float("DB_ACQUIRE_TIMEOUT", 3)
DB_COMMAND_TIMEOUT = _float("DB_COMMAND_TIMEOUT", 5)
CACHE_TIMEOUT = _float("CACHE_TIMEOUT", 0.3)
CACHE_POOL_MAX = _int("CACHE_POOL_MAX", 20)
CACHE_RETRY_AFTER = _float("CACHE_RETRY_AFTER", 5)
PASSWORD_HASH_CONCURRENCY = _int("PASSWORD_HASH_CONCURRENCY", 4)
+23
View File
@@ -0,0 +1,23 @@
from __future__ import annotations
from typing import Dict, Optional
BEARER_CHALLENGE = 'Bearer realm="messenger"'
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
class ApiError(Exception):
def __init__(self, status_code: int, code: str, message: str, headers: Optional[Dict[str, str]] = None):
super().__init__(message)
self.status_code = status_code
self.code = code
self.message = message
self.headers = headers or {}
def unauthorized(message: str, challenge: str = BEARER_CHALLENGE) -> ApiError:
return ApiError(401, "unauthorized", message, {"WWW-Authenticate": challenge})
def unavailable() -> ApiError:
return ApiError(503, "unavailable", "service temporarily unavailable")
+203
View File
@@ -0,0 +1,203 @@
from __future__ import annotations
import logging
import uuid
from contextlib import asynccontextmanager
from typing import Optional
import asyncpg
from fastapi import Depends, FastAPI, Query, Request, Response
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from starlette.exceptions import HTTPException as StarletteHTTPException
from app import auth, config
from app.cache import SessionCache
from app.errors import ApiError
from app.models import Chat, ChatPage, CreateChat, CreateMessage, CreateUser, Health, Message, MessagePage, Session, User
from app.storage import Store
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("messenger")
store = Store()
cache = SessionCache(config.CACHE_URL)
@asynccontextmanager
async def lifespan(_app: FastAPI):
if not config.DATABASE_URL:
raise RuntimeError("DATABASE_URL or DATABASE_URL_FILE is required")
await store.open()
logger.info("session cache: %s", "valkey" if cache.enabled else "disabled")
yield
await cache.close()
await store.close()
app = FastAPI(title="MTUSI Messenger — lab2", lifespan=lifespan)
DB_UNAVAILABLE = (
OSError,
asyncpg.PostgresConnectionError,
asyncpg.InterfaceError,
asyncpg.TooManyConnectionsError,
asyncpg.exceptions.OperatorInterventionError,
asyncpg.exceptions.QueryCanceledError,
)
def error_body(code: str, message: str, request_id: str) -> dict:
return {"error": {"code": code, "message": message, "request_id": request_id}}
def error_response(request: Request, status: int, code: str, message: str, headers: Optional[dict] = None) -> JSONResponse:
request_id = getattr(request.state, "request_id", "")
return JSONResponse(status_code=status, content=error_body(code, message, request_id), headers=headers)
@app.middleware("http")
async def request_id_middleware(request: Request, call_next):
request_id = uuid.uuid4().hex
request.state.request_id = request_id
try:
response = await call_next(request)
except Exception:
logger.exception("unhandled error for request_id=%s", request_id)
response = JSONResponse(status_code=500, content=error_body("internal_error", "internal error", request_id))
response.headers["X-Request-Id"] = request_id
return response
@app.exception_handler(ApiError)
async def api_error_handler(request: Request, exc: ApiError):
return error_response(request, exc.status_code, exc.code, exc.message, exc.headers)
@app.exception_handler(RequestValidationError)
async def validation_error_handler(request: Request, exc: RequestValidationError):
return error_response(request, 400, "invalid_request", "request failed validation")
@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
code = {404: "not_found", 405: "invalid_request", 415: "unsupported_media_type"}.get(exc.status_code, "invalid_request")
message = exc.detail if isinstance(exc.detail, str) else "request failed"
return error_response(request, exc.status_code, code, message)
async def db_unavailable_handler(request: Request, exc: Exception):
logger.warning("database unavailable for request_id=%s: %s", request.state.request_id, type(exc).__name__)
return error_response(request, 503, "unavailable", "service temporarily unavailable")
for _exc in DB_UNAVAILABLE:
app.add_exception_handler(_exc, db_unavailable_handler)
async def current_user(request: Request) -> dict:
return await auth.authenticate(store, cache, request.headers.get("Authorization"))
def parse_uuid(value: str, field: str) -> uuid.UUID:
try:
return uuid.UUID(value)
except ValueError:
raise ApiError(400, "invalid_request", f"{field} is not a valid UUID") from None
def not_found() -> ApiError:
return ApiError(404, "not_found", "chat not found")
@app.get("/health/live", response_model=Health)
async def liveness():
return Health()
@app.get("/health/ready", response_model=Health)
async def readiness():
try:
await store.ping()
except DB_UNAVAILABLE:
raise ApiError(503, "unavailable", "database is not available") from None
return Health()
@app.post("/api/v1/users", response_model=User, status_code=201)
async def register_user(body: CreateUser):
if not body.display_name.strip() or not body.password.strip():
raise ApiError(400, "invalid_request", "display_name and password must not be blank")
password_hash = await auth.hash_password(body.password)
return await store.create_user(body.username, body.display_name, password_hash)
@app.get("/api/v1/users/me", response_model=User)
async def current_user_endpoint(user: dict = Depends(current_user)):
return user
@app.post("/api/v1/auth/sessions", response_model=Session, status_code=201)
async def create_session(request: Request):
return await auth.login(store, request.headers.get("Authorization"))
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def delete_session(request: Request):
await auth.logout(store, cache, request.headers.get("Authorization"))
return Response(status_code=204)
@app.post("/api/v1/chats", response_model=Chat, status_code=201)
async def create_chat(body: CreateChat, user: dict = Depends(current_user)):
if not body.title.strip():
raise ApiError(400, "invalid_request", "title must not be blank")
if len(set(body.member_ids)) != len(body.member_ids):
raise ApiError(400, "invalid_request", "member_ids must not contain duplicates")
if uuid.UUID(user["id"]) not in body.member_ids:
raise ApiError(400, "invalid_request", "caller must be a member of the chat")
return await store.create_chat(body.title, list(body.member_ids))
@app.get("/api/v1/chats", response_model=ChatPage)
async def list_chats(
user: dict = Depends(current_user),
limit: int = Query(default=50, ge=1, le=100),
cursor: Optional[str] = Query(default=None, min_length=1),
):
return await store.list_chats(uuid.UUID(user["id"]), limit, cursor)
@app.get("/api/v1/chats/{chat_id}", response_model=Chat)
async def get_chat(chat_id: str, user: dict = Depends(current_user)):
chat = await store.get_chat_for_member(parse_uuid(chat_id, "chat_id"), uuid.UUID(user["id"]))
if chat is None:
raise not_found()
return chat
@app.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=201)
async def create_message(chat_id: str, body: CreateMessage, user: dict = Depends(current_user)):
chat_uuid = parse_uuid(chat_id, "chat_id")
if not body.text.strip():
if not await store.is_member(chat_uuid, uuid.UUID(user["id"])):
raise not_found()
raise ApiError(400, "invalid_request", "text must not be blank")
message = await store.create_message(chat_uuid, uuid.UUID(user["id"]), body.text)
if message is None:
raise not_found()
return message
@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage)
async def list_messages(
chat_id: str,
user: dict = Depends(current_user),
limit: int = Query(default=50, ge=1, le=100),
cursor: Optional[str] = Query(default=None, min_length=1),
):
chat_uuid = parse_uuid(chat_id, "chat_id")
if not await store.is_member(chat_uuid, uuid.UUID(user["id"])):
raise not_found()
return await store.list_messages(chat_uuid, limit, cursor)
+63
View File
@@ -0,0 +1,63 @@
from __future__ import annotations
import asyncio
import logging
import sys
from pathlib import Path
import asyncpg
from app import config
logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
logger = logging.getLogger("migrate")
MIGRATIONS_DIR = Path(__file__).resolve().parents[1] / "migrations"
LOCK_ID = 2026_0002
async def connect_with_retry(attempts: int = 30) -> asyncpg.Connection:
for attempt in range(1, attempts + 1):
try:
return await asyncpg.connect(config.DATABASE_URL, timeout=config.DB_CONNECT_TIMEOUT)
except (OSError, asyncpg.PostgresError, asyncpg.InterfaceError) as exc:
logger.warning("database not reachable (attempt %d/%d): %s", attempt, attempts, type(exc).__name__)
await asyncio.sleep(1)
raise SystemExit("database is not reachable")
async def migrate() -> int:
if not config.DATABASE_URL:
raise SystemExit("DATABASE_URL or DATABASE_URL_FILE is required")
conn = await connect_with_retry()
applied_now = 0
try:
await conn.execute("SELECT pg_advisory_lock($1)", LOCK_ID)
await conn.execute(
"""
CREATE TABLE IF NOT EXISTS schema_migrations (
version text PRIMARY KEY,
applied_at timestamptz NOT NULL DEFAULT now()
)
"""
)
done = {r["version"] for r in await conn.fetch("SELECT version FROM schema_migrations")}
for path in sorted(MIGRATIONS_DIR.glob("*.sql")):
version = path.stem
if version in done:
continue
logger.info("applying %s", version)
async with conn.transaction():
await conn.execute(path.read_text(encoding="utf-8"))
await conn.execute("INSERT INTO schema_migrations (version) VALUES ($1)", version)
applied_now += 1
logger.info("migrations up to date: %d applied now, %d before", applied_now, len(done))
finally:
await conn.execute("SELECT pg_advisory_unlock($1)", LOCK_ID)
await conn.close()
return applied_now
if __name__ == "__main__":
asyncio.run(migrate())
sys.exit(0)
+72
View File
@@ -0,0 +1,72 @@
from __future__ import annotations
import uuid
from typing import List, Optional
from pydantic import BaseModel, ConfigDict, Field
USERNAME_PATTERN = r"^[a-z0-9_]{3,32}$"
class CreateUser(BaseModel):
model_config = ConfigDict(extra="forbid")
username: str = Field(pattern=USERNAME_PATTERN)
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
class User(BaseModel):
id: uuid.UUID
username: str
display_name: str
created_at: str
class CreateChat(BaseModel):
model_config = ConfigDict(extra="forbid")
title: str = Field(min_length=1, max_length=100)
member_ids: List[uuid.UUID] = Field(min_length=1, max_length=100)
class Chat(BaseModel):
id: uuid.UUID
title: str
member_ids: List[uuid.UUID]
created_at: str
class ChatPage(BaseModel):
items: List[Chat]
next_cursor: Optional[str] = None
class CreateMessage(BaseModel):
model_config = ConfigDict(extra="forbid")
text: str = Field(max_length=4000)
class Message(BaseModel):
id: uuid.UUID
chat_id: uuid.UUID
sender_id: uuid.UUID
text: str
created_at: str
class MessagePage(BaseModel):
items: List[Message]
next_cursor: Optional[str] = None
class Session(BaseModel):
token: str
token_type: str = "Bearer"
expires_at: str
user: User
class Health(BaseModel):
status: str = "ok"
+264
View File
@@ -0,0 +1,264 @@
from __future__ import annotations
import base64
import json
import uuid
from datetime import datetime, timezone
from typing import List, Optional, Tuple
import asyncpg
from app import config
from app.errors import ApiError
def fmt_ts(value: datetime) -> str:
return value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def user_row(row: asyncpg.Record) -> dict:
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": fmt_ts(row["created_at"]),
}
def chat_row(row: asyncpg.Record) -> dict:
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": [str(m) for m in row["member_ids"]],
"created_at": fmt_ts(row["created_at"]),
}
def message_row(row: asyncpg.Record) -> dict:
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": fmt_ts(row["created_at"]),
}
def encode_cursor(resource: str, created_at: str, item_id: str) -> str:
payload = json.dumps({"r": resource, "t": created_at, "i": item_id}, separators=(",", ":"))
return base64.urlsafe_b64encode(payload.encode("utf-8")).decode("ascii").rstrip("=")
def decode_cursor(resource: str, cursor: str) -> Tuple[datetime, uuid.UUID]:
try:
padded = cursor + "=" * (-len(cursor) % 4)
payload = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")).decode("utf-8"))
if payload.get("r") != resource:
raise ValueError("cursor belongs to a different resource")
created_at = datetime.fromisoformat(payload["t"].replace("Z", "+00:00"))
if created_at.tzinfo is None:
raise ValueError("cursor time has no timezone")
return created_at, uuid.UUID(payload["i"])
except Exception as exc:
raise ApiError(400, "invalid_request", "invalid cursor") from exc
def page_of(items: List[dict], resource: str, limit: int) -> dict:
page = items[:limit]
next_cursor = None
if len(items) > limit:
last = page[-1]
next_cursor = encode_cursor(resource, last["created_at"], last["id"])
return {"items": page, "next_cursor": next_cursor}
class Store:
def __init__(self):
self.pool: Optional[asyncpg.Pool] = None
async def open(self) -> None:
self.pool = await asyncpg.create_pool(
config.DATABASE_URL,
min_size=0,
max_size=config.DB_POOL_MAX,
timeout=config.DB_CONNECT_TIMEOUT,
command_timeout=config.DB_COMMAND_TIMEOUT,
max_inactive_connection_lifetime=60,
)
async def close(self) -> None:
if self.pool is not None:
await self.pool.close()
def acquire(self):
return self.pool.acquire(timeout=config.DB_ACQUIRE_TIMEOUT)
async def ping(self) -> bool:
async with self.acquire() as conn:
return await conn.fetchval("SELECT 1") == 1
async def create_user(self, username: str, display_name: str, password_hash: str) -> dict:
async with self.acquire() as conn:
try:
row = await conn.fetchrow(
"""
INSERT INTO users (id, username, display_name, password_hash)
VALUES ($1, $2, $3, $4)
RETURNING id, username, display_name, created_at
""",
uuid.uuid4(), username, display_name, password_hash,
)
except asyncpg.UniqueViolationError:
raise ApiError(409, "conflict", "username already taken") from None
return user_row(row)
async def get_credentials(self, username: str) -> Optional[asyncpg.Record]:
async with self.acquire() as conn:
return await conn.fetchrow(
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = $1",
username,
)
async def create_session(self, token_hash: bytes, user_id: uuid.UUID, ttl_seconds: int) -> datetime:
async with self.acquire() as conn:
return await conn.fetchval(
"""
INSERT INTO sessions (token_hash, user_id, expires_at)
VALUES ($1, $2, clock_timestamp() + make_interval(secs => $3))
RETURNING expires_at
""",
token_hash, user_id, float(ttl_seconds),
)
async def find_session(self, token_hash: bytes) -> Optional[asyncpg.Record]:
async with self.acquire() as conn:
return await conn.fetchrow(
"""
SELECT s.expires_at, u.id, u.username, u.display_name, u.created_at
FROM sessions s JOIN users u ON u.id = s.user_id
WHERE s.token_hash = $1 AND s.revoked_at IS NULL AND s.expires_at > clock_timestamp()
""",
token_hash,
)
async def revoke_session(self, token_hash: bytes) -> Optional[datetime]:
async with self.acquire() as conn:
return await conn.fetchval(
"""
UPDATE sessions SET revoked_at = clock_timestamp()
WHERE token_hash = $1 AND revoked_at IS NULL AND expires_at > clock_timestamp()
RETURNING expires_at
""",
token_hash,
)
async def create_chat(self, title: str, member_ids: List[uuid.UUID]) -> dict:
chat_id = uuid.uuid4()
async with self.acquire() as conn:
try:
async with conn.transaction():
row = await conn.fetchrow(
"INSERT INTO chats (id, title) VALUES ($1, $2) RETURNING id, title, created_at",
chat_id, title,
)
await conn.execute(
"""
INSERT INTO chat_members (chat_id, user_id, position)
SELECT $1, m.user_id, m.ord - 1
FROM unnest($2::uuid[]) WITH ORDINALITY AS m(user_id, ord)
""",
chat_id, member_ids,
)
except asyncpg.ForeignKeyViolationError:
raise ApiError(400, "invalid_request", "unknown member in member_ids") from None
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": [str(m) for m in member_ids],
"created_at": fmt_ts(row["created_at"]),
}
async def get_chat_for_member(self, chat_id: uuid.UUID, user_id: uuid.UUID) -> Optional[dict]:
async with self.acquire() as conn:
row = await conn.fetchrow(
"""
SELECT c.id, c.title, c.created_at,
array_agg(m.user_id ORDER BY m.position) AS member_ids
FROM chats c JOIN chat_members m ON m.chat_id = c.id
WHERE c.id = $1
AND EXISTS (SELECT 1 FROM chat_members me WHERE me.chat_id = c.id AND me.user_id = $2)
GROUP BY c.id
""",
chat_id, user_id,
)
return chat_row(row) if row else None
async def list_chats(self, user_id: uuid.UUID, limit: int, cursor: Optional[str]) -> dict:
after_t, after_i = decode_cursor("chats", cursor) if cursor else (None, None)
async with self.acquire() as conn:
rows = await conn.fetch(
"""
SELECT c.id, c.title, c.created_at,
array_agg(m.user_id ORDER BY m.position) AS member_ids
FROM chat_members me
JOIN chats c ON c.id = me.chat_id
JOIN chat_members m ON m.chat_id = c.id
WHERE me.user_id = $1
AND ($2::timestamptz IS NULL OR (c.created_at, c.id) > ($2, $3::uuid))
GROUP BY c.id
ORDER BY c.created_at, c.id
LIMIT $4
""",
user_id, after_t, after_i, limit + 1,
)
return page_of([chat_row(r) for r in rows], "chats", limit)
async def is_member(self, chat_id: uuid.UUID, user_id: uuid.UUID) -> bool:
async with self.acquire() as conn:
return bool(await conn.fetchval(
"SELECT EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)",
chat_id, user_id,
))
async def create_message(self, chat_id: uuid.UUID, sender_id: uuid.UUID, text: str) -> Optional[dict]:
async with self.acquire() as conn:
row = await conn.fetchrow(
"""
INSERT INTO messages (id, chat_id, sender_id, text)
SELECT $1, $2, $3, $4
WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3)
RETURNING id, chat_id, sender_id, text, created_at
""",
uuid.uuid4(), chat_id, sender_id, text,
)
return message_row(row) if row else None
async def list_messages(self, chat_id: uuid.UUID, limit: int, cursor: Optional[str]) -> dict:
resource = str(chat_id)
async with self.acquire() as conn:
if cursor:
after_t, after_i = decode_cursor(resource, cursor)
rows = await conn.fetch(
"""
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
ORDER BY created_at, id
LIMIT $4
""",
chat_id, after_t, after_i, limit + 1,
)
else:
rows = await conn.fetch(
"""
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = $1
ORDER BY created_at, id
LIMIT $2
""",
chat_id, limit + 1,
)
return page_of([message_row(r) for r in rows], resource, limit)
+93
View File
@@ -0,0 +1,93 @@
name: messenger-lab2
x-api: &api
build: .
image: mtusi-messenger:lab2
environment: &api-env
APP_HOST: 0.0.0.0
APP_PORT: "8080"
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_STORE: postgres
SESSION_CACHE_MAX_SECONDS: ${SESSION_CACHE_MAX_SECONDS:-300}
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
DB_POOL_MAX: ${DB_POOL_MAX:-10}
secrets: [database_url, cache_url]
depends_on:
postgres:
condition: service_healthy
valkey:
condition: service_started
migrate:
condition: service_completed_successfully
stop_grace_period: 10s
restart: unless-stopped
services:
postgres:
image: postgres:17.6-alpine3.22
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets: [postgres_password]
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 2s
timeout: 3s
retries: 30
stop_grace_period: 30s
restart: unless-stopped
valkey:
image: valkey/valkey:8.1.4-alpine3.22
command: ["valkey-server", "/run/secrets/valkey_conf"]
secrets: [valkey_conf]
healthcheck:
test: ["CMD-SHELL", "valkey-cli ping 2>&1 | grep -qE 'PONG|NOAUTH'"]
interval: 2s
timeout: 3s
retries: 30
restart: unless-stopped
migrate:
build: .
image: mtusi-messenger:lab2
command: ["python", "-m", "app.migrate"]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
secrets: [database_url]
depends_on:
postgres:
condition: service_healthy
restart: "no"
api:
<<: *api
ports:
- "127.0.0.1:${APP_PORT:-8080}:8080"
api-short-ttl:
<<: *api
profiles: [ttl-test]
environment:
<<: *api-env
SESSION_TTL_SECONDS: "2"
ports:
- "127.0.0.1:${SHORT_TTL_PORT:-8081}:8080"
volumes:
pgdata:
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
valkey_conf:
file: ./secrets/valkey.conf
+74
View File
@@ -0,0 +1,74 @@
# EXPLAIN evidence for message history pagination
# date: 2026-10-09T09:35:29Z commit: e914e38
# postgres: 17.6
# messages total: 70006, in measured chat: 20000
PREPARE
PREPARE
=== 1. WITH index messages_chat_history_idx: first page (limit 50 + 1) ===
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..7.37 rows=51 width=78) (actual time=0.017..0.022 rows=51 loops=1)
Buffers: shared hit=4
-> Index Scan using messages_chat_history_idx on messages (cost=0.42..2712.54 rows=19884 width=78) (actual time=0.016..0.019 rows=51 loops=1)
Index Cond: (chat_id = '00000000-0000-4000-8000-000000000100'::uuid)
Buffers: shared hit=4
Planning:
Buffers: shared hit=106
Planning Time: 0.287 ms
Execution Time: 0.035 ms
(9 rows)
=== 2. WITH index: deep page, cursor after message #15000 of 20000 ===
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..54.50 rows=51 width=78) (actual time=0.016..0.021 rows=51 loops=1)
Buffers: shared hit=4
-> Index Scan using messages_chat_history_idx on messages (cost=0.42..1492.33 rows=1407 width=78) (actual time=0.016..0.019 rows=51 loops=1)
Index Cond: ((chat_id = '00000000-0000-4000-8000-000000000100'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 04:10:00+00'::timestamp with time zone, '47ba2a9c-d238-4807-2008-6ea72cb0f95c'::uuid)))
Buffers: shared hit=4
Planning:
Buffers: shared hit=42
Planning Time: 0.286 ms
Execution Time: 0.039 ms
(9 rows)
BEGIN
DROP INDEX
=== 3. WITHOUT index: first page ===
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------
Limit (cost=2472.45..2472.58 rows=51 width=78) (actual time=4.141..4.146 rows=51 loops=1)
Buffers: shared hit=940
-> Sort (cost=2472.45..2522.16 rows=19884 width=78) (actual time=4.141..4.143 rows=51 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 31kB
Buffers: shared hit=940
-> Seq Scan on messages (cost=0.00..1809.08 rows=19884 width=78) (actual time=0.004..3.157 rows=20000 loops=1)
Filter: (chat_id = '00000000-0000-4000-8000-000000000100'::uuid)
Rows Removed by Filter: 50006
Buffers: shared hit=934
Planning:
Buffers: shared hit=16
Planning Time: 0.091 ms
Execution Time: 4.167 ms
(14 rows)
=== 4. WITHOUT index: deep page ===
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=2206.05..2206.17 rows=51 width=78) (actual time=2.882..2.886 rows=51 loops=1)
Buffers: shared hit=934
-> Sort (cost=2206.05..2209.56 rows=1407 width=78) (actual time=2.881..2.883 rows=51 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 31kB
Buffers: shared hit=934
-> Seq Scan on messages (cost=0.00..2159.11 rows=1407 width=78) (actual time=0.628..2.654 rows=5000 loops=1)
Filter: ((chat_id = '00000000-0000-4000-8000-000000000100'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 04:10:00+00'::timestamp with time zone, '47ba2a9c-d238-4807-2008-6ea72cb0f95c'::uuid)))
Rows Removed by Filter: 65006
Buffers: shared hit=934
Planning Time: 0.059 ms
Execution Time: 2.898 ms
(12 rows)
ROLLBACK
+20
View File
@@ -0,0 +1,20 @@
# Fresh volume: migrations from scratch + public smoke
# date: 2026-10-08T21:04:06Z
$ docker compose -p lab2-clean up -d --wait
Container lab2-clean-api-1 Created
Container lab2-clean-api-1 Healthy
Container lab2-clean-migrate-1 Created
Container lab2-clean-migrate-1 Exited
Container lab2-clean-postgres-1 Created
Container lab2-clean-postgres-1 Healthy
Container lab2-clean-valkey-1 Created
Container lab2-clean-valkey-1 Healthy
Network lab2-clean_default Created
Volume "lab2-clean_pgdata" Created
$ docker compose -p lab2-clean logs migrate
INFO migrate: applying 0001_init
INFO migrate: migrations up to date: 1 applied now, 0 before
$ make test
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
$ docker compose -p lab2-clean run --rm migrate # second run
INFO migrate: migrations up to date: 0 applied now, 1 before
+16
View File
@@ -0,0 +1,16 @@
# Logout while the session cache cannot be written (PR feedback)
# date: 2026-10-15T10:56:08Z base commit: 13fa185 + fix in app/cache.py, app/auth.py
# scenario: live session cached -> docker compose pause valkey -> DELETE /auth/sessions/current -> unpause -> wait 6s -> GET /users/me
# before fix: logout 204, revoked token -> 200 from stale cache
$ python3 student-tests/dependency_test.py
ok - Valkey caches sessions with TTL<=300s and keeps logout tombstones
ok - Valkey stopped: ready=200, reads/writes OK, revoked token 401, 2 ms/request
ok - tombstone write failed during logout -> 503, cached session never accepted again, tombstone repaired
ok - PostgreSQL stopped: live=200, ready/business=503 in 0.0s total, unverified token not trusted
ok - PostgreSQL started again: API recovers without restart, data intact
PASS: 5 checks
$ docker compose logs api | grep -E "revoke|tombstone"
WARNING:messenger.cache:cache revoke failed (TimeoutError); bypassing cache for 5s
INFO:messenger.cache:revocation tombstone written after cache recovery
+20
View File
@@ -0,0 +1,20 @@
# Persistence: API + PostgreSQL + Valkey restarted, volume kept, same token
# date: 2026-10-08T21:04:36Z
## containers BEFORE
api 2026-10-08T21:04:21.524285049Z running restarts=0
postgres 2026-10-08T21:04:18.312105839Z running restarts=0
valkey 2026-10-08T21:04:18.312749256Z running restarts=0
volume messenger-lab2_pgdata
$ make test-persistence ACTION_SCRIPT=scripts/restart.sh
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
## containers AFTER (StartedAt changed for all three)
api 2026-10-08T21:04:41.315237919Z running restarts=0
postgres 2026-10-08T21:04:38.136785584Z running restarts=0
valkey 2026-10-08T21:04:38.136211584Z running restarts=0
volume messenger-lab2_pgdata
$ docker compose logs migrate | tail -1
INFO migrate: migrations up to date: 0 applied now, 1 before
+5
View File
@@ -0,0 +1,5 @@
# date: 2026-10-08T21:04:36Z
$ make check
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
$ make test
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+43
View File
@@ -0,0 +1,43 @@
# date: 2026-10-08T21:04:47Z
$ make test-student
== own_tests.py
ok - malformed JSON -> 400 invalid_request
ok - foreign chat access -> 404 (no leak)
ok - empty/whitespace message text -> 400
ok - duplicate username -> 409, original user intact
ok - multi-page pagination traversal: 4 pages, 7 messages, no dup/loss
ok - cursor from another chat -> 400 (cursor is bound to its resource)
PASS: 6/6 student checks
== concurrency_test.py
PASS: 100 unique messages written and read back from 10 concurrent clients
== auth_test.py
ok - wrong password / unknown user -> identical 401 Basic
ok - missing / malformed / non-Basic login -> 401
ok - UTF-8 password containing ':' -> 201
ok - password shorter than 12 / missing -> 400
ok - Basic / X-User-Id / unknown token on business endpoint -> 401
ok - logout revokes only the current token; repeat logout -> 401
ok - session with TTL=2s is rejected after 3s (cache entry included)
PASS: 7 checks
== db_integrity_test.py
ok - 20 concurrent registrations of one username -> 1x201, 19x409, 1 row
ok - chat with unknown member -> 400 and transaction rolled back (no orphan chat)
ok - password stored as $argon2id$..., sessions keep only sha256(token)
ok - migrations run twice more: schema_migrations and data unchanged (1:113)
PASS: 4 checks
== dependency_test.py
ok - Valkey caches sessions with TTL<=300s and keeps logout tombstones
ok - Valkey stopped: ready=200, reads/writes OK, revoked token 401, 3 ms/request
ok - PostgreSQL stopped: live=200, ready/business=503 in 0.0s total, unverified token not trusted
ok - PostgreSQL started again: API recovers without restart, data intact
PASS: 4 checks
== sigterm_test.sh
api stopped in 1s, exit code 0 (0 = graceful, 137 = SIGKILL)
PASS: graceful SIGTERM shutdown, api restarted
ALL STUDENT TESTS PASSED
+49
View File
@@ -0,0 +1,49 @@
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL,
display_name text NOT NULL,
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT users_username_key UNIQUE (username),
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100)
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id),
user_id uuid NOT NULL REFERENCES users (id),
position smallint NOT NULL,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL,
sender_id uuid NOT NULL,
text text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT messages_sender_member_fk FOREIGN KEY (chat_id, sender_id)
REFERENCES chat_members (chat_id, user_id),
CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000)
);
CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id);
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
expires_at timestamptz NOT NULL,
revoked_at timestamptz
);
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
+6
View File
@@ -0,0 +1,6 @@
fastapi==0.142.2
uvicorn[standard]==0.54.0
pydantic==2.13.5
asyncpg==0.32.0
redis==8.1.0
argon2-cffi==25.1.0
+28
View File
@@ -0,0 +1,28 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
mkdir -p secrets
gen() { python3 -c 'import secrets; print(secrets.token_hex(24))'; }
if [ ! -f secrets/postgres_password ]; then
gen > secrets/postgres_password
echo "created secrets/postgres_password"
fi
PG_PASS=$(cat secrets/postgres_password)
printf 'postgresql://messenger:%s@postgres:5432/messenger\n' "$PG_PASS" > secrets/database_url
if [ ! -f secrets/valkey.conf ]; then
{
printf 'requirepass %s\n' "$(gen)"
printf 'save ""\nappendonly no\n'
printf 'maxmemory 64mb\nmaxmemory-policy volatile-lru\n'
} > secrets/valkey.conf
echo "created secrets/valkey.conf"
fi
VK_PASS=$(sed -n 's/^requirepass //p' secrets/valkey.conf)
printf 'redis://:%s@valkey:6379/0\n' "$VK_PASS" > secrets/cache_url
chmod 644 secrets/*
echo "secrets ready in ./secrets (not tracked by git)"
+9
View File
@@ -0,0 +1,9 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose stop api
docker compose stop valkey postgres
docker compose up -d --no-build --wait api
docker compose ps --all --format 'table {{.Service}}\t{{.Status}}'
+62
View File
@@ -0,0 +1,62 @@
#!/usr/bin/env python3
import base64
import time
import uuid
from stack import BASE_URL, SHORT_TTL_URL, Client, check, main_wrapper, ok
def basic(username, password):
return {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode("utf-8")).decode()}
def main():
c = Client(BASE_URL)
alice = c.user("auth")
reg = alice["registration"]
r1 = c.call("POST", "/api/v1/auth/sessions", 401, headers=basic(reg["username"], "wrong-password-123"))
r2 = c.call("POST", "/api/v1/auth/sessions", 401, headers=basic("nobody_" + uuid.uuid4().hex[:8], "wrong-password-123"))
check(r1["json"]["error"]["message"] == r2["json"]["error"]["message"], "unknown user must look like a wrong password")
ok("wrong password / unknown user -> identical 401 Basic")
c.call("POST", "/api/v1/auth/sessions", 401)
c.call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": "Basic !!!not-base64"})
c.call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": "Bearer " + alice["token"]})
ok("missing / malformed / non-Basic login -> 401")
tricky = "пароль:с:двоеточием-" + uuid.uuid4().hex[:6]
user = c.call("POST", "/api/v1/users", 201, body={"username": "u_colon_" + uuid.uuid4().hex[:8], "display_name": "Двоеточие", "password": tricky}, schema="User")["json"]
c.call("POST", "/api/v1/auth/sessions", 201, headers=basic(user["username"], tricky), schema="Session")
ok("UTF-8 password containing ':' -> 201")
c.call("POST", "/api/v1/users", 400, body={"username": "u_short_" + uuid.uuid4().hex[:8], "display_name": "x", "password": "short-11ch"})
c.call("POST", "/api/v1/users", 400, body={"username": "u_nopass_" + uuid.uuid4().hex[:8], "display_name": "x"})
ok("password shorter than 12 / missing -> 400")
me = c.call("GET", "/api/v1/users/me", 401, headers=basic(reg["username"], reg["password"]))
check(me["headers"].get("WWW-Authenticate", "").startswith("Bearer"), "Bearer challenge expected")
c.call("GET", "/api/v1/users/me", 401, headers={"X-User-Id": alice["id"]})
c.call("GET", "/api/v1/users/me", 401, headers={"Authorization": "Bearer " + uuid.uuid4().hex * 2})
ok("Basic / X-User-Id / unknown token on business endpoint -> 401")
session = c.call("POST", "/api/v1/auth/sessions", 201, headers=basic(reg["username"], reg["password"]), schema="Session")["json"]
check(session["token"] != alice["token"], "every login must issue a new token")
second = dict(alice, token=session["token"])
c.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=alice)
c.call("GET", "/api/v1/users/me", 401, actor=alice)
c.call("DELETE", "/api/v1/auth/sessions/current", 401, actor=alice)
c.call("GET", "/api/v1/users/me", 200, actor=second, schema="User")
ok("logout revokes only the current token; repeat logout -> 401")
s = Client(SHORT_TTL_URL)
bob = s.user("ttl")
s.call("GET", "/api/v1/users/me", 200, actor=bob, schema="User")
time.sleep(3)
s.call("GET", "/api/v1/users/me", 401, actor=bob)
s.call("DELETE", "/api/v1/auth/sessions/current", 401, actor=bob)
ok("session with TTL=2s is rejected after 3s (cache entry included)")
if __name__ == "__main__":
main_wrapper(main)
+56
View File
@@ -0,0 +1,56 @@
#!/usr/bin/env python3
import sys
import urllib.parse
import concurrent.futures
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, check
def main():
base_url = sys.argv[1] if len(sys.argv) > 1 else "http://localhost:8080"
n_messages = 100
n_clients = 10
c = Client(base_url)
users = [c.user("race%d" % i) for i in range(n_clients)]
chat = c.call(
"POST", "/api/v1/chats", 201, actor=users[0],
body={"title": "race", "member_ids": [u["id"] for u in users]},
schema="Chat",
)["json"]
path = "/api/v1/chats/" + chat["id"] + "/messages"
def send(i):
actor = users[i % n_clients]
return c.message(actor, chat, "race-%d" % i)["json"]["id"]
with concurrent.futures.ThreadPoolExecutor(max_workers=n_clients) as pool:
ids = list(pool.map(send, range(n_messages)))
check(len(ids) == n_messages, "expected %d responses" % n_messages)
check(len(set(ids)) == n_messages, "expected %d unique message ids, got %d" % (n_messages, len(set(ids))))
seen = []
cursor = None
while True:
qs = "?limit=25" + ("&cursor=" + urllib.parse.quote(cursor, safe="") if cursor else "")
page = c.call("GET", path + qs, actor=users[0], schema="MessagePage")["json"]
seen.extend(page["items"])
cursor = page["next_cursor"]
if not cursor:
break
check(len(seen) == n_messages, "expected to read back %d messages, got %d" % (n_messages, len(seen)))
check(len({m["id"] for m in seen}) == n_messages, "readback contains duplicates")
print("PASS: %d unique messages written and read back from %d concurrent clients" % (n_messages, n_clients))
if __name__ == "__main__":
try:
main()
except AssertionError as exc:
print("FAIL:", exc)
raise SystemExit(1)
+47
View File
@@ -0,0 +1,47 @@
#!/usr/bin/env python3
import concurrent.futures
import uuid
from stack import BASE_URL, Client, check, compose, main_wrapper, ok, psql
def main():
c = Client(BASE_URL)
username = "u_race_" + uuid.uuid4().hex[:10]
body = {"username": username, "display_name": "Гонка", "password": "Race-password-123"}
def register(_):
return c.call("POST", "/api/v1/users", [201, 409], body=body)["status"]
with concurrent.futures.ThreadPoolExecutor(max_workers=20) as pool:
statuses = list(pool.map(register, range(20)))
check(statuses.count(201) == 1, "exactly one registration must win, got %s" % statuses)
check(statuses.count(409) == 19, "all others must get 409, got %s" % statuses)
check(psql("SELECT count(*) FROM users WHERE username = '%s'" % username) == "1", "exactly one row expected")
ok("20 concurrent registrations of one username -> 1x201, 19x409, 1 row")
alice = c.user("rb")
title = "rollback-" + uuid.uuid4().hex
c.call("POST", "/api/v1/chats", 400, actor=alice, body={"title": title, "member_ids": [alice["id"], str(uuid.uuid4())]})
check(psql("SELECT count(*) FROM chats WHERE title = '%s'" % title) == "0", "failed chat creation left a chat row")
check(psql("SELECT count(*) FROM chats c WHERE NOT EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id)") == "0",
"chat without members exists")
ok("chat with unknown member -> 400 and transaction rolled back (no orphan chat)")
stored = psql("SELECT password_hash FROM users WHERE username = '%s'" % username)
check(stored.startswith("$argon2id$") and "Race-password-123" not in stored, "password must be an Argon2id hash")
check(psql("SELECT count(*) FROM information_schema.columns WHERE table_name = 'sessions' AND column_name = 'token'") == "0",
"raw tokens must not be stored")
ok("password stored as $argon2id$..., sessions keep only sha256(token)")
before = psql("SELECT (SELECT count(*) FROM schema_migrations) || ':' || (SELECT count(*) FROM users)")
compose("run", "--rm", "--no-deps", "migrate")
compose("run", "--rm", "--no-deps", "migrate")
after = psql("SELECT (SELECT count(*) FROM schema_migrations) || ':' || (SELECT count(*) FROM users)")
check(before == after, "migrations changed data on re-run: %s -> %s" % (before, after))
ok("migrations run twice more: schema_migrations and data unchanged (%s)" % after)
if __name__ == "__main__":
main_wrapper(main)
+100
View File
@@ -0,0 +1,100 @@
#!/usr/bin/env python3
import hashlib
import time
from stack import BASE_URL, Client, Failure, check, compose, main_wrapper, ok, valkey
def wait_ready(c, seconds=60):
deadline = time.monotonic() + seconds
while time.monotonic() < deadline:
try:
c.call("GET", "/health/ready", 200)
return
except Failure:
time.sleep(0.5)
raise Failure("API did not become ready")
def main():
c = Client(BASE_URL, timeout=10)
alice, bob, _eve, chat = c.bootstrap()
history = "/api/v1/chats/" + chat["id"] + "/messages"
before = int(valkey("DBSIZE"))
c.call("GET", "/api/v1/users/me", actor=alice, schema="User")
keys = valkey("--scan", "--pattern", "session:*").split()
check(len(keys) >= 1 and int(valkey("DBSIZE")) >= before, "session lookups must be cached in Valkey")
ttl = int(valkey("TTL", keys[0]))
check(0 < ttl <= 300, "cache entries must expire (TTL %d)" % ttl)
temp = c.user("tomb")
c.call("GET", "/api/v1/users/me", actor=temp, schema="User")
c.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=temp)
tombstones = [k for k in valkey("--scan", "--pattern", "session:*").split() if valkey("GET", k) == "revoked"]
check(tombstones, "logout must leave a 'revoked' tombstone in the cache")
ok("Valkey caches sessions with TTL<=300s and keeps logout tombstones")
try:
compose("stop", "valkey")
c.call("GET", "/health/ready", 200)
c.call("GET", "/api/v1/users/me", actor=alice, schema="User")
c.message(bob, chat, "без кэша")
c.call("GET", "/api/v1/users/me", 401, actor=temp)
start = time.monotonic()
for _ in range(10):
c.call("GET", history + "?limit=1", actor=alice, schema="MessagePage")
per_request = (time.monotonic() - start) / 10
check(per_request < 0.5, "cache bypass must be fast (%.3fs per request)" % per_request)
ok("Valkey stopped: ready=200, reads/writes OK, revoked token 401, %.0f ms/request" % (per_request * 1000))
finally:
compose("start", "valkey")
paused = c.user("pause")
key = "session:" + hashlib.sha256(paused["token"].encode("ascii")).hexdigest()
deadline = time.monotonic() + 15
while not valkey("GET", key).startswith("{"):
check(time.monotonic() < deadline, "live session must be cached before the failure")
c.call("GET", "/api/v1/users/me", actor=paused, schema="User")
time.sleep(0.5)
try:
compose("pause", "valkey")
status = c.call("DELETE", "/api/v1/auth/sessions/current", [204, 503], actor=paused)["status"]
finally:
compose("unpause", "valkey")
check(status == 503, "logout must not report success while the cache still holds the live session (got %d)" % status)
time.sleep(6)
c.call("GET", "/api/v1/users/me", 401, actor=paused)
deadline = time.monotonic() + 10
while valkey("GET", key) != "revoked":
check(time.monotonic() < deadline, "tombstone must be written once Valkey is back")
time.sleep(0.5)
c.call("GET", "/api/v1/users/me", 401, actor=paused)
c.call("DELETE", "/api/v1/auth/sessions/current", 401, actor=paused)
ok("tombstone write failed during logout -> 503, cached session never accepted again, tombstone repaired")
fresh = c.user("dbdown")
try:
compose("stop", "postgres")
c.call("GET", "/health/live", 200)
start = time.monotonic()
r = c.call("GET", "/health/ready", 503)
check(r["json"]["error"]["code"] == "unavailable", "readiness must report unavailable")
c.call("GET", "/api/v1/chats", 503, actor=alice)
c.call("POST", history, 503, actor=alice, body={"text": "в никуда"})
c.call("GET", "/api/v1/users/me", 503, actor=fresh)
c.call("GET", "/api/v1/users/me", 401)
elapsed = time.monotonic() - start
check(elapsed < 20, "errors must be bounded in time (%.1fs)" % elapsed)
ok("PostgreSQL stopped: live=200, ready/business=503 in %.1fs total, unverified token not trusted" % elapsed)
finally:
compose("start", "postgres")
wait_ready(c)
c.call("GET", "/api/v1/users/me", actor=fresh, schema="User")
page = c.call("GET", history + "?limit=100", actor=alice, schema="MessagePage")["json"]
check(any(m["text"] == "без кэша" for m in page["items"]), "message written without cache must persist")
ok("PostgreSQL started again: API recovers without restart, data intact")
if __name__ == "__main__":
main_wrapper(main)
+74
View File
@@ -0,0 +1,74 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
OUT="${OUT:-evidence/explain_history.txt}"
PSQL="docker compose exec -T postgres psql -U messenger -d messenger -X -v ON_ERROR_STOP=1"
$PSQL -q <<'SQL'
INSERT INTO users (id, username, display_name, password_hash) VALUES
('00000000-0000-4000-8000-000000000001', 'seed_explain_a', 'Seed A', 'not-a-login'),
('00000000-0000-4000-8000-000000000002', 'seed_explain_b', 'Seed B', 'not-a-login')
ON CONFLICT DO NOTHING;
INSERT INTO chats (id, title, created_at)
SELECT ('00000000-0000-4000-8000-' || lpad((100 + g)::text, 12, '0'))::uuid, 'explain ' || g, now()
FROM generate_series(0, 50) g
ON CONFLICT DO NOTHING;
INSERT INTO chat_members (chat_id, user_id, position)
SELECT c.id, u.id, u.pos
FROM chats c
CROSS JOIN (VALUES ('00000000-0000-4000-8000-000000000001'::uuid, 0),
('00000000-0000-4000-8000-000000000002'::uuid, 1)) AS u(id, pos)
WHERE c.title LIKE 'explain %'
ON CONFLICT DO NOTHING;
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT md5('explain-' || c.n || '-' || g)::uuid,
('00000000-0000-4000-8000-' || lpad((100 + c.n)::text, 12, '0'))::uuid,
CASE WHEN g % 2 = 0 THEN '00000000-0000-4000-8000-000000000001'::uuid
ELSE '00000000-0000-4000-8000-000000000002'::uuid END,
'synthetic message ' || g,
timestamptz '2026-01-01' + (g * interval '1 second') + (c.n * interval '1 millisecond')
FROM (SELECT n, CASE WHEN n = 0 THEN 20000 ELSE 1000 END AS cnt FROM generate_series(0, 50) n) c
CROSS JOIN LATERAL generate_series(1, c.cnt) g
ON CONFLICT DO NOTHING;
ANALYZE users; ANALYZE chats; ANALYZE chat_members; ANALYZE messages;
SQL
{
echo "# EXPLAIN evidence for message history pagination"
echo "# date: $(date -u +%Y-%m-%dT%H:%M:%SZ) commit: $(git rev-parse --short HEAD 2>/dev/null || echo n/a)"
echo "# postgres: $($PSQL -tA -c 'SHOW server_version')"
$PSQL -tA -c "SELECT '# messages total: ' || count(*) || ', in measured chat: ' || count(*) FILTER (WHERE chat_id = '00000000-0000-4000-8000-000000000100') FROM messages"
echo
$PSQL <<'SQL'
PREPARE first_page(uuid, int) AS
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = $1 ORDER BY created_at, id LIMIT $2;
PREPARE next_page(uuid, timestamptz, uuid, int) AS
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT $4;
\echo '=== 1. WITH index messages_chat_history_idx: first page (limit 50 + 1) ==='
EXPLAIN (ANALYZE, BUFFERS) EXECUTE first_page('00000000-0000-4000-8000-000000000100', 51);
\echo '=== 2. WITH index: deep page, cursor after message #15000 of 20000 ==='
EXPLAIN (ANALYZE, BUFFERS) EXECUTE next_page('00000000-0000-4000-8000-000000000100',
timestamptz '2026-01-01' + interval '15000 seconds', md5('explain-0-15000')::uuid, 51);
BEGIN;
DROP INDEX messages_chat_history_idx;
\echo '=== 3. WITHOUT index: first page ==='
EXPLAIN (ANALYZE, BUFFERS) EXECUTE first_page('00000000-0000-4000-8000-000000000100', 51);
\echo '=== 4. WITHOUT index: deep page ==='
EXPLAIN (ANALYZE, BUFFERS) EXECUTE next_page('00000000-0000-4000-8000-000000000100',
timestamptz '2026-01-01' + interval '15000 seconds', md5('explain-0-15000')::uuid, 51);
ROLLBACK;
SQL
} > "$OUT"
echo "written $OUT"
grep -E '^===|Index|Seq Scan|Sort|Buffers|Execution Time' "$OUT"
+103
View File
@@ -0,0 +1,103 @@
#!/usr/bin/env python3
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, check
PASSED = 0
def ok(label):
global PASSED
PASSED += 1
print("ok -", label)
def raw_call(base, method, path, data=None, headers=None):
h = {"Accept": "application/json"}
h.update(headers or {})
req = urllib.request.Request(base + path, data=data, headers=h, method=method)
try:
resp = urllib.request.urlopen(req, timeout=10)
except urllib.error.HTTPError as exc:
resp = exc
with resp:
return resp.code, resp.read()
def main():
base_url = sys.argv[1] if len(sys.argv) > 1 else "http://localhost:8080"
c = Client(base_url)
alice, bob, eve, chat = c.bootstrap()
path = "/api/v1/chats/" + chat["id"]
status, body = raw_call(
base_url, "POST", "/api/v1/users",
data=b'{"username": "broken", "display_name": ',
headers={"Content-Type": "application/json", "X-User-Id": alice["id"]},
)
check(status == 400, "malformed JSON must yield 400, got %d" % status)
parsed = json.loads(body)
check(parsed["error"]["code"] == "invalid_request", "malformed JSON must report invalid_request")
ok("malformed JSON -> 400 invalid_request")
c.call("GET", path, 404, actor=eve)
c.call("GET", path + "/messages", 404, actor=eve)
ok("foreign chat access -> 404 (no leak)")
c.call("POST", path + "/messages", 400, actor=alice, body={"text": ""})
c.call("POST", path + "/messages", 400, actor=alice, body={"text": " "})
ok("empty/whitespace message text -> 400")
c.call("POST", "/api/v1/users", 409, body=alice["registration"])
me = c.call("GET", "/api/v1/users/me", actor=alice, schema="User")["json"]
check(me == alice["user"], "existing user must be unaffected by a rejected duplicate registration")
ok("duplicate username -> 409, original user intact")
sent = [c.message(alice, chat, "page-msg-%d" % i)["json"] for i in range(7)]
collected = []
cursor = None
pages = 0
while True:
qs = "?limit=2" + ("&cursor=" + urllib.parse.quote(cursor, safe="") if cursor else "")
page = c.call("GET", path + "/messages" + qs, actor=bob, schema="MessagePage")["json"]
pages += 1
check(len(page["items"]) <= 2, "page must respect limit")
collected.extend(page["items"])
cursor = page["next_cursor"]
if not cursor:
break
check(pages < 50, "pagination did not terminate")
ids_seen = [m["id"] for m in collected]
check(len(ids_seen) == len(set(ids_seen)), "pagination must not repeat messages")
check({m["id"] for m in sent}.issubset(set(ids_seen)), "pagination must not drop messages")
tail = [m for m in collected if m["id"] in {s["id"] for s in sent}]
check(tail == sorted(tail, key=lambda m: (m["created_at"], m["id"])), "pagination must stay ordered")
ok("multi-page pagination traversal: %d pages, %d messages, no dup/loss" % (pages, len(collected)))
first_page = c.call("GET", path + "/messages?limit=1", actor=alice, schema="MessagePage")["json"]
check(first_page["next_cursor"], "need a non-null cursor to test cross-chat reuse")
chat2 = c.call(
"POST", "/api/v1/chats", 201, actor=alice,
body={"title": "second chat", "member_ids": [alice["id"], bob["id"]]}, schema="Chat",
)["json"]
c.message(alice, chat2, "unrelated message")
foreign_cursor = urllib.parse.quote(first_page["next_cursor"], safe="")
c.call("GET", "/api/v1/chats/" + chat2["id"] + "/messages?limit=1&cursor=" + foreign_cursor, 400, actor=alice)
ok("cursor from another chat -> 400 (cursor is bound to its resource)")
print("PASS: %d/%d student checks" % (PASSED, 6))
if __name__ == "__main__":
try:
main()
except AssertionError as exc:
print("FAIL:", exc)
raise SystemExit(1)
+21
View File
@@ -0,0 +1,21 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
PY="${PYTHON:-python3}"
export BASE_URL="${BASE_URL:-http://localhost:8080}"
export SHORT_TTL_URL="${SHORT_TTL_URL:-http://localhost:8081}"
docker compose --profile ttl-test up -d --no-build --wait api-short-ttl >/dev/null 2>&1
for t in own_tests.py concurrency_test.py auth_test.py db_integrity_test.py dependency_test.py; do
echo "== $t"
"$PY" "student-tests/$t" "$BASE_URL"
echo
done
echo "== sigterm_test.sh"
sh student-tests/sigterm_test.sh
docker compose --profile ttl-test stop api-short-ttl >/dev/null 2>&1
echo
echo "ALL STUDENT TESTS PASSED"
+17
View File
@@ -0,0 +1,17 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
CID=$(docker compose ps -q api)
[ -n "$CID" ] || { echo "FAIL: api is not running"; exit 1; }
START=$(date +%s)
docker compose stop api >/dev/null 2>&1
ELAPSED=$(( $(date +%s) - START ))
EXIT_CODE=$(docker inspect -f '{{.State.ExitCode}}' "$CID")
echo "api stopped in ${ELAPSED}s, exit code ${EXIT_CODE} (0 = graceful, 137 = SIGKILL)"
docker compose logs --since 30s api 2>&1 | grep -q "Application shutdown complete" || { echo "FAIL: no graceful shutdown line"; exit 1; }
[ "$ELAPSED" -le 10 ] && [ "$EXIT_CODE" -eq 0 ] || { docker compose up -d --wait api; echo "FAIL: not graceful"; exit 1; }
docker compose up -d --no-build --wait api >/dev/null 2>&1
echo "PASS: graceful SIGTERM shutdown, api restarted"
+43
View File
@@ -0,0 +1,43 @@
import os
import subprocess
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, Failure, check
BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080")
SHORT_TTL_URL = os.environ.get("SHORT_TTL_URL", "http://localhost:8081")
PASSED = []
def ok(label):
PASSED.append(label)
print("ok -", label)
def compose(*args, check_rc=True):
proc = subprocess.run(["docker", "compose", *args], cwd=ROOT, capture_output=True, text=True)
if check_rc and proc.returncode != 0:
raise Failure("docker compose %s failed: %s" % (args[0], proc.stderr.strip()[-300:]))
return proc.stdout
def psql(sql):
return compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-tAX", "-c", sql).strip()
def valkey(*args):
cmd = 'valkey-cli --no-auth-warning -a "$(sed -n "s/^requirepass //p" /run/secrets/valkey_conf)" "$@"'
return compose("exec", "-T", "valkey", "sh", "-c", cmd, "valkey-cli", *args).strip()
def main_wrapper(main):
try:
main()
except (AssertionError, Failure) as exc:
print("FAIL:", exc)
raise SystemExit(1)
print("PASS: %d checks" % len(PASSED))