50 changed files with 3389 additions and 15 deletions
+20
View File
@@ -9,3 +9,23 @@ 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
# --- Реализация lab2: сервер и деградация (перенесено из lab1) ---
GRACEFUL_TIMEOUT=8
MAX_INFLIGHT_REQUESTS=64
MAX_BODY_BYTES=65536
MAX_RSS_MB=0
# --- Реализация lab2: PostgreSQL ---
DB_POOL_MIN=1
DB_POOL_MAX=10
DB_POOL_TIMEOUT=3
DB_CONNECT_TIMEOUT=3
DB_STATEMENT_TIMEOUT_MS=5000
DB_OP_TIMEOUT=6
REQUEST_TIMEOUT=8
DB_READY_TIMEOUT=1.5
# --- Реализация lab2: кэш сессий в Valkey ---
SESSION_CACHE_TTL_SECONDS=30
SESSION_SWEEP_SECONDS=60
# Надгробие отозванной сессии в кэше: не меньше SESSION_CACHE_TTL_SECONDS + REQUEST_TIMEOUT
SESSION_REVOKED_TTL_SECONDS=60
CACHE_TIMEOUT=0.2
+39
View File
@@ -0,0 +1,39 @@
name: Application
on: [push, pull_request]
permissions:
contents: read
jobs:
app:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.12'
- name: Bootstrap local env and secrets
run: make bootstrap
- name: Start stack
run: docker compose --env-file .env up -d --build
- name: Wait for readiness
run: |
for i in $(seq 1 60); do
if curl -fsS http://localhost:8080/health/ready; then exit 0; fi
sleep 2
done
docker compose --env-file .env ps
docker compose --env-file .env logs --tail=200
exit 1
- name: Migrations are idempotent
run: docker compose --env-file .env run --rm migrate
- name: Public smoke
run: make test PYTHON=python
- name: Own checks
run: make test-custom PYTHON=python
- name: Persistence with restart hook
run: make test-persistence ACTION_SCRIPT=scripts/restart.sh PYTHON=python
- name: Logs on failure
if: failure()
run: docker compose --env-file .env logs --tail=200
- name: Tear down
if: always()
run: docker compose --env-file .env down -v
+31
View File
@@ -0,0 +1,31 @@
FROM python:3.12.8-slim-bookworm@sha256:2199a62885a12290dc9c5be3ca0681d367576ab7bf037da120e564723292a2f0
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1 \
PIP_DISABLE_PIP_VERSION_CHECK=1 \
PIP_DEFAULT_TIMEOUT=120 \
PIP_RETRIES=10
RUN groupadd --system --gid 10001 app \
&& useradd --system --uid 10001 --gid app --home-dir /app --shell /usr/sbin/nologin app
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-deps -r requirements.txt
COPY app/ app/
COPY migrations/ migrations/
COPY scripts/migrate.py scripts/migrate.py
USER 10001:10001
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=10s --retries=3 \
CMD ["python", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).status == 200 else 1)"]
STOPSIGNAL SIGTERM
CMD ["sh", "-c", "exec uvicorn app.main:app --host \"${APP_HOST:-0.0.0.0}\" --port \"${APP_PORT:-8080}\" --timeout-graceful-shutdown \"${GRACEFUL_TIMEOUT:-8}\""]
+53 -1
View File
@@ -4,10 +4,16 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence
COMPOSE ?= docker compose --env-file .env
.PHONY: help check validate test load test-persistence bootstrap build up down logs ps migrate psql test-custom expiry dependency outages explain track2 evidence
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "bootstrap: local .env and secrets; build/up/down: compose stack; migrate: apply SQL migrations"
@echo "test-custom: own level-4 checks; expiry: short-TTL instance; dependency: cache and database outages"
@echo "outages: revocation vs cache restart, hung database; evidence: full run into evidence/"
@echo "explain: history query plan on 10k rows; track2: grade-5 experiment; test-persistence: restart hook"
check:
$(PYTHON) scripts/check_contract.py
@@ -24,3 +30,49 @@ 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)
bootstrap:
sh scripts/bootstrap.sh
build:
$(COMPOSE) build
up:
$(COMPOSE) up -d --build
down:
$(COMPOSE) down
logs:
$(COMPOSE) logs --tail=100 api
ps:
$(COMPOSE) ps
migrate:
$(COMPOSE) run --rm migrate
psql:
$(COMPOSE) exec postgres psql -U messenger -d messenger
test-custom:
$(PYTHON) student-tests/test_auth_sessions.py --base-url "$(BASE_URL)"
$(PYTHON) student-tests/test_storage_rules.py --base-url "$(BASE_URL)"
expiry:
sh student-tests/expiry.sh
dependency:
sh student-tests/dependency.sh
outages:
$(PYTHON) student-tests/test_outages.py --base-url "$(BASE_URL)"
explain:
sh student-tests/explain.sh
track2:
TOTAL=$(or $(TOTAL),120000) sh student-tests/track2.sh
evidence:
sh student-tests/evidence.sh
+173 -14
View File
@@ -1,37 +1,196 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Курлова Алёна Алексеевна, БВТ2301
- Целевая оценка; выбранный трек 5: 5, трек 2 «План запроса и восстановление»
- Commit/PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/68
- Использованные источники, библиотеки и помощь ИИ: FastAPI 0.115.6, Uvicorn 0.34.0, psycopg 3.3.6 (+psycopg-pool), valkey-py 6.2.0, argon2-cffi 25.1.0 — документация перечисленных библиотек; документация PostgreSQL 17 (transactions, EXPLAIN, pg_dump/pg_restore, типы данных), Valkey persistence, RFC 7617, RFC 9106. Реализация, свои тесты и стенд эксперимента написаны с помощью ИИ-ассистента (Claude Code); все прогоны и доказательства выполнены автором. Отдельно просмотрены публичные ревью преподавателя к PR других студентов этой же лабораторной и проверено, закрыты ли названные там случаи в этой работе: сохранение NUL в тексте, отзыв сессии против возврата кэша, зависшая БД, тело запроса на входе, Unicode-пробелы. Четыре из них требовали правок, остальные уже работали; на каждый добавлен свой тест.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker (проверено 29.7.2) с плагином Compose (v5.5.1), `make`, Python 3.9+ на хосте (только для публичных и своих тестов) и свободный порт 8080. Образы закреплены по digest, Python-зависимости — по версиям в `requirements.txt`.
```sh
make bootstrap # создаёт локальный .env и secrets/ (пароль генерируется на месте)
make up # build + postgres + valkey + миграции + api
curl -i http://localhost:8080/health/ready
make test # публичный smoke
make test-custom # свои проверки уровня 4
```
`make bootstrap` создаёт `.env` из `.env.example` и три файла в `secrets/`: `postgres_password` (случайный), `database_url`, `cache_url`. Каталоги `secrets/`, `backups/` и `.env` закрыты `.gitignore`; в репозиторий попадают только пути к секретам, не значения.
Миграции применяет отдельный одноразовый сервис `migrate` (`python scripts/migrate.py`), от которого `api` зависит через `service_completed_successfully`. Повторный запуск (`make migrate`) печатает `skip 0001_init` и ничего не меняет: применённые версии и их sha256 лежат в таблице `schema_migrations`, при изменении уже применённого файла запуск падает с ошибкой. Выполняется под advisory lock, поэтому одновременный запуск двух runner-ов безопасен.
Все проверки и эксперименты одной командой — она пересоздаёт стенд с нуля и складывает вывод каждого шага в `evidence/`:
```sh
make evidence
```
Те же сценарии по отдельности:
```sh
make test-persistence ACTION_SCRIPT=scripts/restart.sh # рестарт API и всех хранилищ
make expiry # истечение сессии при TTL=2 с
make outages # отзыв сессии против рестарта кэша, зависшая БД
make dependency # отказ Valkey, затем отказ PostgreSQL
make explain # план истории на таблице не меньше 10 000 сообщений
TOTAL=120000 make track2 # трек 5: индексы + backup/restore
python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load-cache.json
# тот же прогон при остановленном Valkey даёт вторую точку сравнения:
docker compose --env-file .env stop valkey
python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load-nocache.json
docker compose --env-file .env start valkey
```
Безопасная остановка: `make down` (том `pgdata` сохраняется, данные остаются). Намеренное удаление учебных данных: `docker compose --env-file .env down -v` — удаляет том базы вместе со всеми данными; дополнительно `rm -rf backups/` удаляет локальные дампы. `student-tests/track2.sh` сам удаляет свой временный контейнер и том восстановления (`KEEP=1` оставляет их для осмотра). `TOTAL` задаёт целевой размер истории: засев добивает таблицу до этого числа и при повторном запуске не добавляет ничего, поэтому прогоны воспроизводимы.
Переменные `.env.example` соответствуют реальной конфигурации: `APP_HOST/APP_PORT/GRACEFUL_TIMEOUT` читает команда uvicorn в `Dockerfile`, остальные — `app/config.py`. `DATABASE_URL_FILE` и `CACHE_URL_FILE` в контейнере указывают на docker secrets (`/run/secrets/...`), которые compose монтирует из `secrets/`.
| Переменная | Что задаёт | Значение по умолчанию |
| --- | --- | --- |
| `SESSION_TTL_SECONDS` | срок жизни сессии | 3600 |
| `SESSION_CACHE_TTL_SECONDS` | срок жизни записи в кэше сессий | 30 |
| `SESSION_SWEEP_SECONDS` | период удаления истёкших сессий из БД | 60 |
| `SESSION_REVOKED_TTL_SECONDS` | срок жизни надгробия отозванной сессии в кэше | 60 |
| `SESSION_STORE` | источник истины для сессий | postgres |
| `DB_POOL_MIN`, `DB_POOL_MAX` | границы пула соединений | 1, 10 |
| `DB_POOL_TIMEOUT`, `DB_CONNECT_TIMEOUT` | ожидание свободного соединения и подключения, с | 3, 3 |
| `DB_STATEMENT_TIMEOUT_MS` | `statement_timeout` и `lock_timeout` на сервере | 5000 |
| `DB_OP_TIMEOUT` | клиентский лимит на один SQL-запрос, с | 6 |
| `DB_READY_TIMEOUT` | лимит проверки готовности БД, с | 1.5 |
| `REQUEST_TIMEOUT` | потолок на обработку всего HTTP-запроса, с | 8 |
| `CACHE_TIMEOUT` | таймаут на операцию с Valkey, с | 0.2 |
| `MAX_INFLIGHT_REQUESTS` | одновременных запросов, сверх — 429 | 64 |
| `MAX_BODY_BYTES` | размер тела, сверх — 413 | 65536 |
| `MAX_RSS_MB` | лимит памяти процесса, сверх — 503 на запись (0 — выключен) | 0 |
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
клиент → uvicorn/FastAPI (app/) ──► PostgreSQL 17.7 (источник истины: users, chats, chat_members, messages, sessions)
└─► Valkey 8.1 (кэш сессий с TTL, намеренно без persistence)
migrate (одноразовый) ──► PostgreSQL (versioned SQL из migrations/)
```
**Источник истины.** Все обязательные данные и сессии лежат в PostgreSQL на томе `pgdata`. Valkey — кэш: он ускоряет проверку токена, но не хранит ничего, чего нет в базе. Поэтому потеря Valkey не теряет данные, а только замедляет работу; `SESSION_STORE=postgres` фиксирует это решение в конфигурации.
**Кэш сессий намеренно без persistence.** У Valkey выключены и RDB (`--save ""`), и AOF (`--appendonly no`). Это не упущение, а требование безопасности: если кэш переживает рестарт, он может воскресить запись об уже отозванной сессии и вернуть доступ по мёртвому токену. С volatile-кэшом после любого рестарта таблица сессий в PostgreSQL остаётся единственным источником правды, и каждый токен проверяется заново. Persistence кэша обязателен только если он единственное хранилище сессий — у нас это не так.
**Отзыв сессии устойчив к кэшу и к гонке.** `DELETE /auth/sessions/current` сначала пишет в Valkey надгробие — значение `revoked` с собственным TTL — и только потом удаляет строку из PostgreSQL. Простого удаления ключа недостаточно: между удалением ключа и удалением строки параллельный запрос успевает прочитать ещё живую строку и заново положить ключ, и тогда после подтверждённого 204 токен продолжает работать до истечения кэша. Надгробие закрывает это окно, потому что наполнение кэша после промаха выполняется условно (`SET … NX`) и не может перезаписать надгробие, а `resolve` трактует это значение как «сессии нет» без похода в базу. TTL надгробия не меньше суммы срока жизни кэша и потолка запроса, поэтому ни один начатый до отзыва запрос не успеет положить устаревшую копию. Если кэш недоступен, logout возвращает 503 и сессию не удаляет: выход не подтверждается, пока нельзя гарантировать, что кэш больше не отдаст токен. Проверено тестами `logout_is_not_confirmed_while_cache_is_down` и `revoked_session_cannot_be_resurrected_by_a_race` — второй удерживает строку сессии под `SELECT … FOR UPDATE`, чтобы гонка воспроизводилась детерминированно.
**Схема и ограничения** (`migrations/0001_init.sql`). `users.username` — `UNIQUE` плюс `CHECK (username ~ '^[a-z0-9_]{3,32}$')`, так что уникальность username гарантирует база, а не только проверка в коде. `chat_members` — таблица связи с `PRIMARY KEY (chat_id, user_id)` и внешними ключами на `chats` и `users`. `messages` ссылается на `chats` и `users`. `sessions` хранит `token_hash bytea PRIMARY KEY`, `user_id`, `created_at`, `expires_at`.
**Почему текст хранится в `bytea`.** `display_name`, `title` и `messages.text` — `bytea` с UTF-8 байтами, а не `text`. Причина: контракт разрешает в тексте любые Unicode code points, включая U+0000, а тип `text` в PostgreSQL физически не может содержать нулевой байт — попытка записи даёт `invalid byte sequence for encoding "UTF8": 0x00`, то есть 500 на валидном по контракту запросе. Хранение байтами даёт точный round-trip любой строки; длину в code points проверяет приложение (1..100 для имён и заголовков, 1..4000 для текста), а база дополнительно ограничивает `octet_length`. Цена решения — SQL-запросы к этим столбцам нельзя сравнивать как текст: в своих скриптах используются `convert_to`, `position` и `encode`, а не `LIKE` по `convert_from` (последний падает как раз на строках с NUL).
**Транзакционные границы.** Соединения работают в autocommit, то есть один запрос — одна транзакция. Явная транзакция открывается там, где составная операция должна быть атомарной: создание чата вставляет строку в `chats` и строки в `chat_members` одним `BEGIN ... COMMIT`. Участники добавляются `INSERT ... SELECT u.id FROM users WHERE u.id = ANY(%s)`, и если вставилось меньше строк, чем запрошено, значит кто-то из `member_ids` не существует — поднимается исключение, транзакция откатывается, клиент получает 400, а в базе не остаётся чата без участников. Отправка сообщения — один оператор `INSERT ... SELECT ... WHERE EXISTS (SELECT 1 FROM chat_members ...)`: проверка членства и запись атомарны, отдельного запроса на проверку доступа нет, посторонний получает 404 (0 строк).
**Индекс истории.** `messages_history_idx (chat_id, created_at, id)` повторяет порядок сортировки контракта, поэтому страница читается диапазонным сканом индекса без сортировки. Keyset-пагинация сравнивает кортеж: `(created_at, id) > (:ts, :id)`. Цена страницы не зависит от её номера — измерения в разделе эксперимента.
**Пагинация и курсор.** Курсор перенесён из lab1: base64 от `{scope, created_at, id}`, где scope — `messages:<chat_id>` или `chats:<user_id>`. Курсор проверяется строго (формат времени с микросекундами, UUID, совпадение с заново закодированным значением), поэтому изменённый вручную курсор и курсор другого чата дают 400. Пустая строка в `cursor` или `limit` — это именно неверное значение, а не отсутствие параметра: такой запрос получает 400. Повторов и пропусков при обходе неизменной истории нет; snapshot между HTTP-запросами не гарантируется. Время ставит сервер (`clock_timestamp()`, микросекунды), порядок внутри одной микросекунды разводится по `id`.
**Аутентификация.** `POST /api/v1/users` принимает `password` (12–128 code points) и хеширует его Argon2id (`argon2-cffi`, `time_cost=2, memory_cost=19456 KiB, parallelism=1`). Хеширование и проверка выполняются в threadpool, чтобы KDF не блокировал event loop. `POST /api/v1/auth/sessions` принимает только Basic и не принимает тело: любой непустой body даёт 400. Вход выдаёт opaque-токен `secrets.token_urlsafe(32)` — 256 бит энтропии; в базу пишется только `sha256(token)`, самого токена сервер не хранит. Остальные endpoint принимают только Bearer; Basic на них — 401 с `WWW-Authenticate: Bearer`, `X-User-Id` игнорируется полностью. Неверный пароль и несуществующий пользователь дают один и тот же 401: при отсутствии пользователя проверка выполняется против фиктивного хеша, чтобы ответ не отличался ни телом, ни временем. Повреждённый UTF-8 в теле или в Basic-строке не «исправляется» заменой символов, а отклоняется (400 и 401 соответственно).
**Валидация входа.** Тело читается потоком с лимитом `MAX_BODY_BYTES` (413), `Content-Type` обязателен (415 на любой другой), лишние и недостающие поля — 400. Некорректный JSON, в том числе битые числа (`1e999`, `NaN`), обрезанное тело и глубокая вложенность, вызывающая `RecursionError`, дают 400, а не 500. Обязательные строки не могут состоять только из пробельных символов, причём к пробельным приравнены и невидимые `U+200B..U+200D`, `U+2060`, `U+FEFF`.
**Кэш сессий.** Ключ `session:<sha256-hex>` — коллизий между пользователями быть не может, значение — публичные поля владельца токена, TTL = `min(SESSION_CACHE_TTL_SECONDS, остаток до expires_at)`. Промах читает `sessions JOIN users` с условием `expires_at > now()` и снова наполняет кэш, причём публичный вид пользователя и при входе, и при промахе строит одна функция `repo.public_user`, поэтому тело ответа не зависит от того, откуда оно пришло. Сериализация значения выполняется до сетевого вызова: иначе ошибка сериализации попадала бы в тот же `except`, что и недоступность кэша, и выглядела бы как обычный сбой сети, хотя кэш при этом не наполнялся бы никогда. Истёкшие строки убирает фоновая задача раз в `SESSION_SWEEP_SECONDS`; TTL абсолютный, рестарт его не продлевает.
**Пул и таймауты.** `AsyncConnectionPool` с `min_size=1`, `max_size=10`, ожиданием свободного соединения 3 с, `connect_timeout=3`; на каждом соединении выставлены `statement_timeout=5000`, `lock_timeout=5000`, `idle_in_transaction_session_timeout=10000`. Серверных таймаутов недостаточно: если процесс БД заморожен, он не успеет их применить, поэтому каждый SQL-запрос дополнительно обёрнут клиентским лимитом `DB_OP_TIMEOUT`, а весь HTTP-запрос — потолком `REQUEST_TIMEOUT` в middleware. Соединение, на котором сработал клиентский таймаут, закрывается, чтобы пул заменил его, а не выдал следующему запросу. Все запросы параметризованы psycopg (`%s`), конкатенации пользовательских данных в SQL нет.
**Деградация.** `OperationalError`, `InterfaceError`, таймаут пула и клиентские таймауты превращаются в 503 `unavailable` с `Retry-After` — недоступность зависимости не маскируется под 500. `/health/live` отвечает 200, пока жив процесс; `/health/ready` выполняет `SELECT 1` с отдельным лимитом и отдаёт 503, если база недоступна. Valkey в readiness не входит сознательно: без кэша сервис работоспособен. Ошибки кэша считаются в счётчике и логируются не чаще одного раза на 50 отказов.
**Что перенесено из lab1:** структура приложения и обработка ошибок, единый формат `{"error":{code,message,request_id}}`, `X-Request-Id` в каждом ответе, строгая валидация полей и курсора, потоковое чтение тела с лимитом (413), лимит одновременных запросов (429), graceful shutdown по SIGTERM с режимом drain, запуск от uid 10001.
**Объявленные переходы относительно lab1:** `X-User-Id` больше не аутентифицирует — вместо него Bearer-сессия; состояние ушло из памяти процесса в PostgreSQL, поэтому требование «ровно один процесс API» снято; счётчики `MAX_USERS/MAX_CHATS/MAX_MESSAGES` из lab1 убраны — они требовали бы `COUNT(*)` на каждый запрос, их роль теперь выполняют том базы и квоты СУБД; `MAX_RSS_MB` сохранён, но по умолчанию выключен (`0`), так как данные больше не живут в памяти.
**Решения по инфраструктуре.** Образы закреплены по digest: `postgres:17.7-alpine@sha256:bb377b72…`, `valkey/valkey:8.1-alpine@sha256:081c2f5c…`. У Valkey политика `allkeys-lru` и нет томов — это допустимо именно потому, что это кэш, а не хранилище истины. Пароль PostgreSQL и строки подключения передаются docker secrets, в `environment` лежат только пути к файлам. Порт API опубликован на `127.0.0.1:8080`, внутрь контейнера сервер слушает `0.0.0.0` (иначе проброшенный порт не дошёл бы до процесса). CI (`.github/workflows/app.yml`) поднимает стек, проверяет повторный запуск миграций и гоняет smoke, свои тесты и persistence.
## Доказательства критериев
Окружение: Apple M4, 10 ядер, 16 ГБ RAM, Docker Desktop (лимит 10 CPU / 7.7 ГБ), macOS Darwin 25.6.0 arm64, Docker 29.7.2, Compose v5.5.1, PostgreSQL 17.7 (aarch64, musl), Valkey 8.1.10, образ API — python 3.12.8-slim, хост-Python 3.9.6, 2026-10-23. Полный состав стенда, версии и строка старта API с действующими лимитами — в `evidence/stand.txt`. Все числа ниже получены одним прогоном `make evidence`, начатым с удаления тома базы, поэтому относятся к одному и тому же состоянию стенда.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/smoke.txt` |
| Данные и действующие сессии переживают рестарт API и хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` (hook: `docker compose restart postgres valkey api`) | `PASS: persistence preserved confirmed data and existing session`; тот же токен читает ту же историю | `evidence/persistence.txt` (состояние контейнеров до и после, логи postgres о перезапуске) |
| PostgreSQL содержит users/chats/members/messages, есть PK/FK, уникальность username, миграции с нуля | `make up` на пустом томе, затем `make migrate` | `apply 0001_init`, повторный запуск — `skip 0001_init`; в `schema_migrations` одна версия с checksum `4fd0a8c6…` | `evidence/migrations.txt` (включая `\d+ messages`) |
| Составная операция создания чата атомарна | `test_storage_rules.py::unknown_member_rolls_chat_back` | 400 на неизвестного участника, чат в списке отсутствует | `evidence/level4-tests.txt` |
| Basic только на `POST /auth/sessions`, остальное — Bearer; `X-User-Id` не даёт доступа | `test_auth_sessions.py` | 9/9 PASS, в том числе Basic на `/users/me` → 401 Bearer, вход с телом → 400, повреждённый UTF-8 → 400/401 | `evidence/level4-tests.txt` |
| Срок жизни сессии и отзыв | `make expiry` (TTL=2 с) | 3/3 PASS: истёкший токен → 401, запись истёкшим → 401, `expires_at` соответствует TTL | `evidence/expiry.txt` |
| Отозванная сессия не возвращается вместе с кэшом | `make outages` | 8/8 PASS; после 204 и `restart valkey` токен даёт 401 | `evidence/outages.txt` |
| Отзыв сессии выдерживает гонку с параллельным запросом | `make outages::revoked_session_cannot_be_resurrected_by_a_race` | строка сессии удерживается `SELECT … FOR UPDATE`, параллельный `/users/me` наполняет кэш во время logout; после 204 токен даёт 401 на чтение и на список чатов | `evidence/outages.txt` |
| Кэш наполняется после промаха, а не только при входе | `make outages::cache_is_repopulated_after_a_miss`, `::cache_survives_its_own_restart` | после удаления ключа `session:<sha256(token)>` ответ 200 из PostgreSQL совпадает с кэшированным телом, ключ восстановлен с TTL; после рестарта Valkey кэш пуст и снова наполняется | `evidence/outages.txt` |
| Пароли хешируются password KDF | `app/passwords.py`, формат хеша в БД | `$argon2id$v=19$m=19456,t=2,p=1$…`, в API пароль не возвращается | `evidence/level4-tests.txt` |
| Любая строка Unicode сохраняется без искажений | `test_storage_rules.py::nul_and_unicode_text_round_trips`, `::text_length_limit_counts_code_points` | `a\u0000b`, одиночный `\u0000`, emoji с ZWJ, комбинирующие и RTL, 4000 code points — 201 и точный round-trip; 4001 — 400 | `evidence/level4-tests.txt` |
| Secrets/volumes не попадают в Git | `git status --porcelain`, `git check-ignore -v` | `.env`, `secrets/`, `backups/` игнорируются; в рабочем дереве только код, тесты и `evidence/` | `evidence/git-hygiene.txt` |
| Redis/Valkey реально используется для сессий с TTL | `tests/load.py` с кэшем и без него | 1276.0 RPS / p95 4.34 мс против 498.2 RPS / p95 11.46 мс, `failed_requests: 0` в обоих прогонах | `evidence/load-cache.json`, `evidence/load-nocache.json`, `evidence/load.txt` |
| Параметризованные запросы, ограниченный пул и таймауты | `test_storage_rules.py` целиком — 12/12 PASS, в том числе `::sql_injection_is_not_executed`, `::content_type_is_required`, `::broken_json_does_not_break_the_api`; настройки в `app/db.py` | SQL-пробы → 400, текст с кавычками сохраняется дословно, битый JSON → 400; пул 1..10, `statement_timeout=5000`, клиентский лимит 6 с, потолок запроса 8 с | `evidence/level4-tests.txt` |
| Гонка регистрации одинакового username | `test_storage_rules.py::duplicate_username_race_creates_one_user` (12 потоков) | один 201, одиннадцать 409 | `evidence/level4-tests.txt` |
| Индекс истории обоснован EXPLAIN на ≥10 000 сообщениях, пагинация без полного скана | `make explain` (53 293 сообщения в таблице) | keyset, первая страница: 24 буфера, 0.021 мс; keyset на глубине 90 %: 53 буфера, 0.032 мс; OFFSET той же глубины: 34 920 буферов, 4.48 мс (34 513 строк пройдено ради 50) | `evidence/explain-10k.txt` |
| Проверка expiry, logout, неверного пароля и недоступности Redis/БД | `make dependency`, `make outages` | без Valkey 3/3 PASS (кэш обойдён, ошибок нет); без PostgreSQL 4/4 PASS: `/health/ready` 503, запись 503, неизвестный токен не становится доверенным; зависшая БД (`pause`) отвечает 503 быстрее 10 с | `evidence/dependency.txt`, `evidence/outages.txt` |
| Переменные `.env.example` соответствуют реальной конфигурации | `make bootstrap` на существующем `.env`, затем сверка ключей | отсутствующие переменные дописываются из `.env.example`, расхождений по ключам нет | `evidence/stand.txt` (строка `cache_ttl` в логе старта API) |
| Трек 5 (трек 2): ≥100 000 сообщений, ≥2 индекса, цена записи, backup → restore → сверка | `TOTAL=120000 make track2` | 120 000 сообщений в 68 чатах; варианты A/B/C сравнены; md5 истории источника и копии совпали; маркер после бэкапа в копии отсутствует | `evidence/track2/run.txt` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Проверка инфраструктурного hook: `scripts/restart.sh` выполняет `docker compose --env-file .env restart postgres valkey api`, то есть перезапускаются и API, и PostgreSQL, и Valkey; тома не удаляются. Подтверждение — состояние контейнеров до и после в `evidence/persistence.txt` (у всех трёх сервисов новое время старта) плюс строки `database system was shut down` → `database system is ready to accept connections` в логах postgres из того же файла.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
### Трек 2, часть 1: план запроса и цена индекса
**Гипотеза.** Для keyset-пагинации по контракту (`ORDER BY created_at, id` внутри одного чата) составной индекс `(chat_id, created_at, id)` даёт цену страницы, не зависящую от её глубины, а индекс только по `chat_id` вынуждает поднимать из heap всю историю чата на каждую страницу. Покрывающий индекс с `INCLUDE (sender_id, text)` должен убрать обращения к heap, но увеличить размер индекса и цену записи.
**Методика.** Стенд описан выше, PostgreSQL запущен с `shared_buffers=128MB`, `work_mem=8MB`, `track_io_timing=on`. Данные: `student-tests/seed.sql` добивает историю до заданного размера, распределяя сообщения по 50 чатам с перекосом `power(random(), 3)`; поверх лежат чаты публичного smoke, своих тестов и нагрузочных прогонов. В этом прогоне засев дописал 66 707 строк до ровно 120 000 сообщений в 68 чатах. Размеры чатов неравномерны: 38 293 строки в самом большом, 14 955 во втором, затем 25, 5 и 3 — разброс в четыре порядка. Точка измерения — страница на глубине 90 % истории самого большого чата. Каждый вариант индекса создаётся внутри транзакции и откатывается (`BEGIN … ROLLBACK`), поэтому рабочая схема не меняется и порядок вариантов не влияет на результат. Для каждого варианта снимаются: план `EXPLAIN (ANALYZE, BUFFERS)` одной страницы, время 100 последовательных страниц с разными курсорами (коррелированный `LATERAL`: без зависимости от номера итерации планировщик выполняет подзапрос один раз и измерение обнуляется — так и произошло в первой версии скрипта), размер индекса и время вставки 10 000 строк при этом наборе индексов. Прогрев: засев и `ANALYZE` выполняются до измерений, кэш БД тёплый.
| Вариант индекса | План страницы на глубине 90 % | Буферы | Время одной страницы | 100 страниц | Размер индекса | Вставка 10 000 строк |
| --- | --- | --- | --- | --- | --- | --- |
| A `(chat_id, created_at, id)` — рабочий | `Index Scan using messages_history_idx` | 53 | 0.047 мс | 1.08 мс | 11 МБ | 0.085 с |
| B `(chat_id)` | `Bitmap Heap Scan` + `Sort`, `Rows Removed by Filter: 34 464` | 510 | 2.06 мс | 2529 мс | 856 кБ | 0.081 с |
| C `(chat_id, created_at, id) INCLUDE (sender_id, text)` | `Index Only Scan`, `Heap Fetches: 0` | 4 | 0.027 мс | 0.73 мс | 14 МБ | 0.086 с |
**Что наблюдали.** Вариант B на каждой странице поднимает из heap почти весь чат и отбрасывает фильтром 34 464 строки ради 50 нужных; на серии из 100 страниц он медленнее A примерно в 2350 раз (2529 мс против 1.08 мс), и отставание растёт вместе с размером чата, а не фиксировано. Вариант C не ходит в heap вообще (`Heap Fetches: 0`, 4 буфера против 53) и на серии страниц быстрее A примерно на треть (0.73 мс против 1.08 мс); по одной странице времена A и C различать нельзя — 0.047 и 0.027 мс лежат в пределах разброса единичного замера, поэтому вывод делается по серии и по числу буферов. Цена C — индекс 14 МБ против 11 МБ; разницы во времени вставки между A и C на этих данных не видно (0.086 с против 0.085 с). B пишет быстрее всех (0.081 с) просто потому, что его индекс меньше.
**Вывод.** В схему взят вариант A: постоянная цена страницы при умеренном размере индекса. C даёт измеримый выигрыш по буферам и по серии страниц и остаётся кандидатом, если история читается существенно чаще, чем пишется; прежде чем переключаться, его цену записи нужно перемерять на длинных текстах, где дублирование текста в индексе должно проявиться. Переключение — одна миграция.
### Трек 2, часть 2: бэкап и восстановление в новое хранилище
**Гипотеза.** `pg_dump -Fc` даёт согласованный снимок на момент начала дампа; восстановление в чистое хранилище воспроизводит данные точно, а всё подтверждённое после снимка теряется — это и есть граница потери данных при такой схеме бэкапа.
**Методика.** `student-tests/track2.sh`: снимок `pg_dump -Fc` → запись маркерного сообщения уже после дампа → поднятие отдельного контейнера PostgreSQL 17.7 на новом томе `mtusi-lab2-restore-data` с новой базой `messenger_restored` → `pg_restore --exit-on-error` → сверка. Сверяются количество строк в каждой таблице, количество строк и md5 конкатенации `(id, created_at, encode(text,'hex'))` в порядке `(created_at, id)` для самого большого чата, первые три сообщения этого чата и наличие маркера. Сверка идёт по `encode`, а не по `convert_from`, потому что в истории есть сообщения с реальным NUL — на них перевод bytea в text падает. Время бэкапа и восстановления снимается внешним таймером с точностью до миллисекунды и включает накладные расходы `docker exec`.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `pg_dump -Fc` базы с 120 000 сообщений | согласованный дамп | файл 5.7 МБ | бэкап 0.743 с |
| `pg_restore` в новый том и новую базу | совпадение количества и содержимого | users 78/78, chats 68/68, chat_members 1036/1036, messages 120 000/120 000, sessions 45/45; md5 истории большого чата (38 293 строки) `f18725746ed1acbdda044e804cdc4c7c` в обеих базах; первые три сообщения совпали | восстановление 0.354 с; потерь на момент снимка нет |
| Запись после снимка (маркерное сообщение) | в копии отсутствует | в источнике 1 маркер, в восстановленной копии 0 | потеряно всё, подтверждённое после начала дампа |
| Рестарт API и обоих хранилищ с сохранением томов | данные и действующая сессия живы | `PASS` публичного persistence-теста: тот же токен читает ту же историю, дублей нет | простой до readiness < 10 с, потерь нет |
| Остановка Valkey под нагрузкой | кэш обходится, ошибок нет | 498.2 RPS против 1276.0 RPS, p95 11.46 мс против 4.34 мс, `failed_requests: 0` | потерь нет, деградация по скорости ×2.6 |
| Остановка PostgreSQL | ограниченная ошибка, доверия нет | `/health/ready` 503, регистрация 503, неизвестный токен → 503/401, анонимный → 401, `/health/live` 200 | запись недоступна полностью до возврата БД |
| Заморозка PostgreSQL (`docker compose pause`) | быстрый 503, а не зависший запрос | 503 быстрее 10 с при потолке запроса 8 с; после `unpause` доступ восстановился | потерь нет |
| Рестарт Valkey после подтверждённого logout | отозванный токен остаётся мёртвым | 401 после рестарта кэша | потерь нет |
| Гонка logout и параллельного чтения | подтверждённый отзыв нельзя отменить наполнением кэша | до правки токен жил ещё 30 с после 204; после правки — 401 сразу | потерь нет |
| Неудавшийся logout при замороженной базе | кэш не отказывает сессии, которая ещё жива в базе | 503 клиенту, надгробие снято, ответ API совпадает с наличием строки в базе | потерь нет |
| Удаление ключа сессии из кэша | ответ из PostgreSQL совпадает с кэшированным, ключ восстановлен с TTL | тело идентично, `EXISTS` = 1, TTL 30 с | потерь нет |
**Нагрузочный профиль** (для контекста, не доказательство ёмкости): `tests/load.py`, closed loop, concurrency 4, длительность 30 с, по одному прогону на точку. С кэшем: 38 293 успешных POST, 0 ошибок, 1275.960 RPS, p50 2.933 / p95 4.335 / p99 7.548 мс. С остановленным Valkey: 14 955 успешных POST, 0 ошибок, 498.216 RPS, p50 7.457 / p95 11.462 / p99 14.472 мс. Разница — цена похода в PostgreSQL за сессией на каждом запросе; ноль ошибок в обоих прогонах показывает, что отказ кэша обходится, а не ломает запись. Это пропускная способность HTTP-подтверждений, а не счётчик COMMIT: закрытый контур страдает coordinated omission, клиент и сервер работают на одной машине, поэтому абсолютные числа занижены относительно отдельного стенда.
**Ограничения измерений.** Всё измерено на одной машине, с тёплым кэшом БД, по одному прогону на точку, без фиксации частоты CPU и без контроля троттлинга; потребление CPU и RAM по контейнерам не снималось. По одной странице времена вариантов A и C неразличимы, поэтому для них опорой служат серия из 100 страниц и число буферов. Размер индекса измеряется внутри откатываемой транзакции, поэтому при повторных запусках скрипта к индексу добавляются мёртвые записи до `VACUUM` — сравнивать размеры корректно только внутри одного прогона. Два самых больших чата сформированы нагрузочными прогонами, поэтому тексты в них короткие и однотипные: на длинных текстах разрыв между A и C по размеру индекса и цене записи будет больше. Прогон без кэша выполнялся на уже подросшей таблице, поэтому отношение RPS показывает направление и порядок эффекта, а не точный коэффициент. Числа p50/p95/p99 относятся только к успешным запросам.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
**Какие отказы выдерживаются.** Перезапуск API, PostgreSQL и Valkey с сохранением томов: подтверждённые данные и ещё действующие сессии остаются, TTL не продлевается, а уже отозванные сессии не оживают. Полная потеря Valkey: сервис продолжает работать, читая сессии из PostgreSQL, цена — падение пропускной способности примерно в 2.6 раза. Потеря соединения с БД: запросы получают 503 с `Retry-After`, пул переподключается сам, readiness честно показывает недоступность. Заморозка БД: клиентский лимит и потолок запроса не дают запросу зависнуть.
**Какие отказы не выдерживаются.** PostgreSQL — единственная точка истины без реплики: при потере тома `pgdata` данные восстанавливаются только из дампа, то есть теряется всё после последнего `pg_dump`. WAL-архивирование и PITR не настроены, непрерывного бэкапа нет. API — один экземпляр, балансировщика нет (это тема lab3), поэтому его перезапуск — простой сервиса, а не бесшовное переключение. Rate limiting по пользователю и HTTPS в объём lab2 не входят.
**Учебные упрощения.** Кэш сессий намеренно volatile: это снимает риск воскрешения отозванной сессии, но после каждого рестарта Valkey первые запросы идут в базу. Logout при недоступном кэше возвращает 503 и не отзывает сессию — выход нужно повторить; альтернатива (удалить строку в БД и надеяться, что кэш очистится) давала бы окно, в котором мёртвый токен работает. Надгробие живёт в кэше дольше самой записи о сессии — это сознательная плата за то, чтобы отзыв нельзя было отменить гонкой. Если удаление строки в базе не удалось, надгробие снимается обратно, поэтому кэш не отказывает сессии, которая в базе ещё существует. При этом клиентский таймаут не означает, что запрос не выполнился: после 503 исход отзыва честно неизвестен, и оба ответа на следующий запрос этим токеном законны. Тест `failed_logout_leaves_cache_and_database_consistent` поэтому проверяет не конкретный код ответа, а согласованность: смотрит, есть ли строка сессии в базе, и требует от API ровно соответствующего ей ответа. Параметры Argon2id (19 МБ, t=2, p=1) выбраны по RFC 9106 как второй рекомендуемый профиль и снижены относительно умолчаний библиотеки (64 МБ), чтобы одновременные входы не съедали память контейнера. Хранение текста в `bytea` усложняет SQL-запросы к этим столбцам — это осознанная цена за точный round-trip Unicode. Данные экспериментов (`load_*` пользователи, `load chat *`) лежат в той же базе, что и smoke-данные: отдельного стенда для экспериментов нет, поэтому два самых больших чата в выборке — это чаты нагрузочных прогонов.
**Что подтверждено, а что пока гипотеза.** Подтверждено измерениями: постоянная цена keyset-страницы на 120 тысячах сообщений, деградация варианта B на глубине примерно в 2350 раз, выигрыш покрывающего индекса по буферам (4 против 53) и по серии страниц, выигрыш кэша сессий по RPS и p95 при нулевом числе ошибок, полное совпадение восстановленной копии с источником и отсутствие в ней записей, подтверждённых после снимка, корректная деградация при остановке и при заморозке каждого из хранилищ, устойчивость отзыва сессии к рестарту кэша. Гипотезы, не проверенные здесь: что покрывающий индекс C дороже в записи — на этих данных разница с A укладывается в шум (0.086 с против 0.085 с), и проверять это нужно на текстах, близких к 4000 символов; что C окажется выгоднее на холодном кэше и при большом числе параллельных читателей; что `max_size=10` в пуле — оптимум (значение взято с запасом под `max_connections=50`, но под нагрузкой не подбиралось).
**Следующие шаги.** Настроить WAL-архивирование и проверить PITR с восстановлением на момент времени; добавить реплику PostgreSQL и измерить переключение; подобрать `DB_POOL_MAX` и профиль Argon2id под целевой p95; перенести эксперименты на отдельную базу; в lab3 добавить балансировщик и идемпотентность записи.
## Ответы на вопросы защиты
- **Что подтверждает COMMIT и от какой настройки durability это зависит.** COMMIT подтверждает, что изменения записаны в WAL и сброшены на диск, поэтому после аварии они будут восстановлены. Зависит от `synchronous_commit` (у нас `on`) и `fsync` (включён): при `synchronous_commit=off` ответ клиенту приходит раньше фактического fsync, и последние транзакции можно потерять при потере питания.
- **Где хранятся сессии и что будет после flush/restart Valkey.** Источник истины — таблица `sessions` в PostgreSQL; в Valkey только кэш с TTL и без persistence. После `FLUSHALL` или рестарта Valkey сессии продолжают работать: первый запрос промахивается, читает строку из базы и снова наполняет кэш. Важнее обратное: именно потому, что кэш не переживает рестарт, отозванная сессия не может вернуться вместе с кэшом — это проверено тестом.
- **Чем аутентификация отличается от доступа к конкретному чату.** Аутентификация отвечает на вопрос «кто это»: действителен ли Bearer-токен и не истёк ли он; её провал — 401. Доступ отвечает на вопрос «можно ли этому пользователю именно этот чат»: есть ли строка в `chat_members`; её провал — 404, а не 403, чтобы не раскрывать существование чужого чата.
- **Почему hash пароля и быстрый checksum решают разные задачи.** Пароль человек выбирает из небольшого множества, поэтому его хеш должен быть намеренно медленным и требовательным к памяти (Argon2id), чтобы перебор был дорогим. Токен сессии — 256 случайных бит, перебирать его бессмысленно, поэтому для него достаточно быстрого SHA-256: он нужен лишь для того, чтобы в базе не лежал сам токен и утечка таблицы не давала доступа.
- **Почему текст лежит в `bytea`, а не в `text`.** Потому что контракт разрешает любые Unicode code points, а `text` в PostgreSQL не может содержать U+0000: такой запрос либо падает с 500, либо строку приходится молча портить. Байты сохраняют её точно, а длину в code points проверяет приложение.
View File
+47
View File
@@ -0,0 +1,47 @@
import os
import socket
def _int(name, default):
value = os.environ.get(name)
return int(value) if value not in (None, "") else default
def _float(name, default):
value = os.environ.get(name)
return float(value) if value not in (None, "") else default
def _secret(name, default=""):
path = os.environ.get(name + "_FILE")
if path:
with open(path, encoding="utf-8") as handle:
return handle.read().strip()
return os.environ.get(name, default)
DATABASE_URL = _secret("DATABASE_URL")
CACHE_URL = _secret("CACHE_URL")
SESSION_STORE = os.environ.get("SESSION_STORE", "postgres")
SESSION_TTL_SECONDS = _int("SESSION_TTL_SECONDS", 3600)
SESSION_CACHE_TTL_SECONDS = _int("SESSION_CACHE_TTL_SECONDS", 30)
SESSION_SWEEP_SECONDS = _int("SESSION_SWEEP_SECONDS", 60)
DB_POOL_MIN = _int("DB_POOL_MIN", 1)
DB_POOL_MAX = _int("DB_POOL_MAX", 10)
DB_POOL_TIMEOUT = _float("DB_POOL_TIMEOUT", 3.0)
DB_CONNECT_TIMEOUT = _int("DB_CONNECT_TIMEOUT", 3)
DB_STATEMENT_TIMEOUT_MS = _int("DB_STATEMENT_TIMEOUT_MS", 5000)
DB_OP_TIMEOUT = _float("DB_OP_TIMEOUT", 6.0)
REQUEST_TIMEOUT = _float("REQUEST_TIMEOUT", 8.0)
DB_READY_TIMEOUT = _float("DB_READY_TIMEOUT", 1.5)
CACHE_TIMEOUT = _float("CACHE_TIMEOUT", 0.2)
MAX_INFLIGHT_REQUESTS = _int("MAX_INFLIGHT_REQUESTS", 64)
MAX_BODY_BYTES = _int("MAX_BODY_BYTES", 65536)
MAX_RSS_MB = _int("MAX_RSS_MB", 0)
PASSWORD_MIN = 12
PASSWORD_MAX = 128
SESSION_REVOKED_TTL_SECONDS = max(
_int("SESSION_REVOKED_TTL_SECONDS", 60),
SESSION_CACHE_TTL_SECONDS + int(REQUEST_TIMEOUT) + 5,
)
INSTANCE_ID = os.environ.get("INSTANCE_ID") or socket.gethostname()
+43
View File
@@ -0,0 +1,43 @@
import base64
import json
import re
import uuid
from datetime import datetime, timezone
TS_RE = re.compile(r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z")
TS_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
class BadCursor(Exception):
pass
def fmt(ts: datetime) -> str:
return ts.astimezone(timezone.utc).strftime(TS_FORMAT)
def encode_cursor(scope: str, created_at: str, item_id: str) -> str:
raw = json.dumps({"s": scope, "t": created_at, "i": item_id}, separators=(",", ":")).encode()
return base64.urlsafe_b64encode(raw).decode().rstrip("=")
def decode_cursor(scope: str, cursor: str):
try:
raw = base64.urlsafe_b64decode(cursor + "=" * (-len(cursor) % 4))
data = json.loads(raw)
except Exception:
raise BadCursor() from None
if not isinstance(data, dict) or set(data) != {"s", "t", "i"} or data["s"] != scope:
raise BadCursor()
ts, item_id = data["t"], data["i"]
if not isinstance(ts, str) or not TS_RE.fullmatch(ts) or not isinstance(item_id, str):
raise BadCursor()
try:
parsed = datetime.strptime(ts, TS_FORMAT).replace(tzinfo=timezone.utc)
if str(uuid.UUID(item_id)) != item_id:
raise BadCursor()
except ValueError:
raise BadCursor() from None
if encode_cursor(scope, ts, item_id) != cursor:
raise BadCursor()
return parsed, item_id
+99
View File
@@ -0,0 +1,99 @@
import asyncio
from contextlib import asynccontextmanager
import psycopg
from psycopg.rows import dict_row
from psycopg_pool import AsyncConnectionPool, PoolTimeout
from app import config
from app.errors import unavailable
BROKEN = (psycopg.OperationalError, psycopg.InterfaceError, PoolTimeout)
async def discard(conn) -> None:
try:
await conn.close()
except Exception:
pass
class Guarded:
def __init__(self, conn, timeout: float):
self.conn = conn
self.timeout = timeout
async def execute(self, *args, **kwargs):
try:
return await asyncio.wait_for(self.conn.execute(*args, **kwargs), self.timeout)
except asyncio.TimeoutError:
await discard(self.conn)
raise unavailable("Хранилище не ответило за отведённое время") from None
def transaction(self):
return self.conn.transaction()
class Database:
def __init__(self) -> None:
options = "-c statement_timeout=%d -c lock_timeout=%d -c idle_in_transaction_session_timeout=%d" % (
config.DB_STATEMENT_TIMEOUT_MS,
config.DB_STATEMENT_TIMEOUT_MS,
config.DB_STATEMENT_TIMEOUT_MS * 2,
)
self.pool = AsyncConnectionPool(
conninfo=config.DATABASE_URL,
min_size=config.DB_POOL_MIN,
max_size=config.DB_POOL_MAX,
timeout=config.DB_POOL_TIMEOUT,
max_lifetime=600.0,
open=False,
kwargs={
"autocommit": True,
"row_factory": dict_row,
"connect_timeout": config.DB_CONNECT_TIMEOUT,
"options": options,
},
)
async def open(self) -> None:
await self.pool.open(wait=False)
async def close(self) -> None:
await self.pool.close()
@asynccontextmanager
async def connection(self):
try:
async with self.pool.connection(timeout=config.DB_POOL_TIMEOUT) as conn:
yield Guarded(conn, config.DB_OP_TIMEOUT)
except BROKEN:
raise unavailable("Хранилище недоступно") from None
@asynccontextmanager
async def transaction(self):
async with self.connection() as conn:
async with conn.transaction():
yield conn
async def in_transaction(self, action):
async def run():
async with self.transaction() as conn:
return await action(conn)
try:
return await asyncio.wait_for(run(), config.DB_OP_TIMEOUT)
except asyncio.TimeoutError:
raise unavailable("Хранилище не ответило за отведённое время") from None
async def ready(self) -> bool:
try:
async with self.pool.connection(timeout=config.DB_READY_TIMEOUT) as conn:
try:
await asyncio.wait_for(conn.execute("SELECT 1"), config.DB_READY_TIMEOUT)
except asyncio.TimeoutError:
await discard(conn)
return False
return True
except Exception:
return False
+37
View File
@@ -0,0 +1,37 @@
from typing import Optional
from fastapi.responses import JSONResponse
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
class ApiError(Exception):
def __init__(self, status: int, code: str, message: str, headers: Optional[dict] = None):
self.status, self.code, self.message, self.headers = status, code, message, headers or {}
def bad(message: str) -> ApiError:
return ApiError(400, "invalid_request", message)
def unauthorized(scheme: str = "Bearer") -> ApiError:
challenge = BASIC_CHALLENGE if scheme == "Basic" else BEARER_CHALLENGE
message = "Нужны имя пользователя и пароль" if scheme == "Basic" else "Нужна действующая сессия"
return ApiError(401, "unauthorized", message, {"WWW-Authenticate": challenge})
def not_found() -> ApiError:
return ApiError(404, "not_found", "Объект не найден")
def unavailable(message: str) -> ApiError:
return ApiError(503, "unavailable", message, {"Retry-After": "1"})
def error_body(rid: str, instance: str, status: int, code: str, message: str, headers: Optional[dict] = None) -> JSONResponse:
return JSONResponse(
status_code=status,
content={"error": {"code": code, "message": message, "request_id": rid}},
headers={"X-Request-Id": rid, "X-Instance-Id": instance, **(headers or {})},
)
+391
View File
@@ -0,0 +1,391 @@
import asyncio
import base64
import binascii
import json
import logging
import os
import re
import resource
import signal
import sys
import uuid
from contextlib import asynccontextmanager
from typing import List, Optional, Tuple
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, Response
from starlette.concurrency import run_in_threadpool
from app import config, passwords, repo
from app.cursor import BadCursor, decode_cursor, encode_cursor
from app.db import Database
from app.errors import ApiError, bad, error_body, not_found, unauthorized, unavailable
from app.sessions import SessionStore
logging.basicConfig(stream=sys.stdout, level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
log = logging.getLogger("messenger")
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
ZERO_WIDTH = str.maketrans({char: None for char in "\u200b\u200c\u200d\u2060\ufeff"})
EXEMPT_PATHS = ("/health/live", "/health/ready")
PAGE_SIZE = os.sysconf("SC_PAGE_SIZE") if hasattr(os, "sysconf") else 4096
db = Database()
sessions = SessionStore(db)
state = {"draining": False, "inflight": 0, "rejected": {}}
def rss_mb() -> float:
try:
with open("/proc/self/statm") as handle:
return int(handle.read().split()[1]) * PAGE_SIZE / 1048576
except OSError:
peak = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
return peak / 1048576 if sys.platform == "darwin" else peak / 1024
def count_rejection(code: str) -> None:
state["rejected"][code] = state["rejected"].get(code, 0) + 1
async def sweeper() -> None:
while True:
await asyncio.sleep(config.SESSION_SWEEP_SECONDS)
try:
removed = await sessions.sweep()
if removed:
log.info("sessions_expired removed=%d", removed)
except Exception:
log.warning("session sweep skipped: storage unavailable")
@asynccontextmanager
async def lifespan(_app: FastAPI):
previous = {}
def on_signal(signum, frame):
if not state["draining"]:
state["draining"] = True
log.info("signal %s: draining, new requests get 503", signal.Signals(signum).name)
handler = previous.get(signum)
if callable(handler):
handler(signum, frame)
for sig in (signal.SIGTERM, signal.SIGINT):
previous[sig] = signal.getsignal(sig)
signal.signal(sig, on_signal)
await db.open()
await sessions.open()
task = asyncio.create_task(sweeper())
log.info(
"started: instance=%s session_store=%s session_ttl=%d cache_ttl=%d pool=%d..%d max_inflight=%d max_body=%d",
config.INSTANCE_ID, config.SESSION_STORE, config.SESSION_TTL_SECONDS, config.SESSION_CACHE_TTL_SECONDS,
config.DB_POOL_MIN, config.DB_POOL_MAX, config.MAX_INFLIGHT_REQUESTS, config.MAX_BODY_BYTES,
)
yield
task.cancel()
await sessions.close()
await db.close()
log.info("stopped: cache=%s rejected=%s", sessions.stats, state["rejected"])
app = FastAPI(lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None)
@app.middleware("http")
async def guard(request: Request, call_next):
rid = uuid.uuid4().hex
request.state.rid = rid
exempt = request.url.path in EXEMPT_PATHS
if state["draining"] and request.url.path != "/health/live":
count_rejection("draining")
return error_body(rid, config.INSTANCE_ID, 503, "unavailable", "Сервер завершает работу", {"Retry-After": "1", "Connection": "close"})
if not exempt and state["inflight"] >= config.MAX_INFLIGHT_REQUESTS:
count_rejection("inflight")
return error_body(rid, config.INSTANCE_ID, 429, "rate_limited", "Слишком много одновременных запросов", {"Retry-After": "1"})
state["inflight"] += 1
try:
response = await asyncio.wait_for(call_next(request), config.REQUEST_TIMEOUT)
except asyncio.TimeoutError:
count_rejection("request_timeout")
log.warning("request timeout request_id=%s method=%s path=%s", rid, request.method, request.url.path)
response = error_body(
rid, config.INSTANCE_ID, 503, "unavailable",
"Запрос не удалось обработать за отведённое время", {"Retry-After": "1"},
)
except Exception:
log.exception("unhandled error request_id=%s", rid)
response = error_body(rid, config.INSTANCE_ID, 500, "internal_error", "Внутренняя ошибка сервера")
finally:
state["inflight"] -= 1
response.headers["X-Request-Id"] = rid
response.headers["X-Instance-Id"] = config.INSTANCE_ID
return response
@app.exception_handler(ApiError)
async def api_error_handler(request: Request, exc: ApiError):
if exc.status in (413, 429, 503):
count_rejection(exc.code)
return error_body(request.state.rid, config.INSTANCE_ID, exc.status, exc.code, exc.message, exc.headers)
def parse_uuid(value: object) -> Optional[str]:
if not isinstance(value, str):
return None
try:
return str(uuid.UUID(value))
except ValueError:
return None
def non_blank(value: object, max_len: int) -> bool:
if not isinstance(value, str) or not 1 <= len(value) <= max_len:
return False
return value.translate(ZERO_WIDTH).strip() != ""
async def read_json(request: Request, fields: Tuple[str, ...]) -> dict:
if request.headers.get("content-type", "").split(";")[0].strip().lower() != "application/json":
raise ApiError(415, "unsupported_media_type", "Ожидается application/json")
too_large = ApiError(413, "payload_too_large", "Тело запроса слишком большое", {"Connection": "close"})
declared = request.headers.get("content-length")
if declared and declared.isdigit() and int(declared) > config.MAX_BODY_BYTES:
raise too_large
raw = bytearray()
async for chunk in request.stream():
raw += chunk
if len(raw) > config.MAX_BODY_BYTES:
raise too_large
try:
body = json.loads(bytes(raw).decode("utf-8"))
except (UnicodeDecodeError, ValueError, RecursionError):
raise bad("Некорректный JSON") from None
if not isinstance(body, dict):
raise bad("Ожидается JSON-объект")
if set(body) - set(fields):
raise bad("Лишние поля в запросе")
if set(fields) - set(body):
raise bad("Отсутствуют обязательные поля")
return body
def ensure_capacity() -> None:
if config.MAX_RSS_MB and rss_mb() > config.MAX_RSS_MB:
raise unavailable("Достигнут лимит памяти процесса, запись недоступна")
def bearer_token(request: Request) -> str:
scheme, _, value = request.headers.get("authorization", "").partition(" ")
token = value.strip()
if scheme.lower() != "bearer" or not token:
raise unauthorized()
return token
async def actor(request: Request) -> dict:
user = await sessions.resolve(bearer_token(request))
if user is None:
raise unauthorized()
return user
def basic_credentials(request: Request) -> Tuple[str, str]:
scheme, _, value = request.headers.get("authorization", "").partition(" ")
if scheme.lower() != "basic" or not value.strip():
raise unauthorized("Basic")
try:
decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8")
except (binascii.Error, ValueError, UnicodeDecodeError):
raise unauthorized("Basic") from None
username, separator, password = decoded.partition(":")
if not separator:
raise unauthorized("Basic")
return username, password
async def member_chat(user: dict, chat_id: str) -> dict:
cid = parse_uuid(chat_id)
if cid is None:
raise bad("chat_id должен быть UUID")
async with db.connection() as conn:
chat = await repo.chat_for_member(conn, cid, user["id"])
if chat is None:
raise not_found()
return chat
def page_params(request: Request) -> Tuple[int, Optional[str]]:
query = request.query_params
limit = 50
if "limit" in query:
if not re.fullmatch(r"[0-9]{1,3}", query["limit"]) or not 1 <= int(query["limit"]) <= 100:
raise bad("limit должен быть целым 1..100")
limit = int(query["limit"])
cursor = query.get("cursor")
if cursor is not None and cursor == "":
raise bad("Некорректный cursor")
return limit, cursor
def keyset(scope: str, cursor: Optional[str]):
if cursor is None:
return None
try:
return decode_cursor(scope, cursor)
except BadCursor:
raise bad("Некорректный cursor") from None
def page(scope: str, items: List[dict], has_more: bool) -> JSONResponse:
next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if has_more and items else None
return JSONResponse({"items": items, "next_cursor": next_cursor})
@app.get("/health/live")
async def live():
return {"status": "ok"}
@app.get("/health/ready")
async def ready():
if not await db.ready():
raise unavailable("База данных недоступна")
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
async def create_user(request: Request):
body = await read_json(request, ("username", "display_name", "password"))
if not isinstance(body["username"], str) or not USERNAME_RE.fullmatch(body["username"]):
raise bad("username должен соответствовать [a-z0-9_]{3,32}")
if not non_blank(body["display_name"], 100):
raise bad("display_name: 1..100 символов, не только пробелы")
password = body["password"]
if not isinstance(password, str) or not config.PASSWORD_MIN <= len(password) <= config.PASSWORD_MAX:
raise bad("password: %d..%d символов" % (config.PASSWORD_MIN, config.PASSWORD_MAX))
ensure_capacity()
password_hash = await run_in_threadpool(passwords.hash_password, password)
async with db.connection() as conn:
user = await repo.create_user(conn, body["username"], body["display_name"], password_hash)
if user is None:
raise ApiError(409, "conflict", "username уже занят")
log.info("user_created id=%s", user["id"])
return JSONResponse(user, status_code=201)
@app.post("/api/v1/auth/sessions", status_code=201)
async def login(request: Request):
if await request.body():
raise bad("POST /auth/sessions не принимает тело запроса")
username, password = basic_credentials(request)
row = None
if USERNAME_RE.fullmatch(username) and config.PASSWORD_MIN <= len(password) <= config.PASSWORD_MAX:
async with db.connection() as conn:
row = await repo.credentials(conn, username)
stored = row["password_hash"] if row else passwords.DUMMY_HASH
matches = await run_in_threadpool(passwords.verify_password, stored, password)
if row is None or not matches:
log.info("login_failed username_known=%s", row is not None)
raise unauthorized("Basic")
user = repo.public_user(row)
token, expires_at = await sessions.create(user)
log.info("session_created user=%s", user["id"])
return JSONResponse({"token": token, "token_type": "Bearer", "expires_at": expires_at, "user": user}, status_code=201)
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def logout(request: Request):
token = bearer_token(request)
user = await sessions.resolve(token)
if user is None:
raise unauthorized()
await sessions.revoke(token)
log.info("session_revoked user=%s", user["id"])
return Response(status_code=204)
@app.get("/api/v1/users/me")
async def me(request: Request):
return await actor(request)
@app.post("/api/v1/chats", status_code=201)
async def create_chat(request: Request):
user = await actor(request)
body = await read_json(request, ("title", "member_ids"))
if not non_blank(body["title"], 100):
raise bad("title: 1..100 символов, не только пробелы")
raw_ids = body["member_ids"]
if not isinstance(raw_ids, list) or not 1 <= len(raw_ids) <= 100:
raise bad("member_ids: массив из 1..100 UUID")
ids: List[str] = []
for value in raw_ids:
parsed = parse_uuid(value)
if parsed is None:
raise bad("member_ids содержит некорректный UUID")
ids.append(parsed)
if len(set(ids)) != len(ids):
raise bad("member_ids содержит дубликаты")
if user["id"] not in ids:
raise bad("Создатель должен входить в member_ids")
ensure_capacity()
async def insert(conn):
return await repo.create_chat(conn, body["title"], ids)
try:
chat = await db.in_transaction(insert)
except repo.UnknownMember:
raise bad("member_ids содержит неизвестного пользователя") from None
log.info("chat_created id=%s members=%d", chat["id"], len(ids))
return JSONResponse(chat, status_code=201)
@app.get("/api/v1/chats")
async def list_chats(request: Request):
user = await actor(request)
limit, cursor = page_params(request)
scope = "chats:" + user["id"]
after = keyset(scope, cursor)
async with db.connection() as conn:
items, has_more = await repo.list_chats(conn, user["id"], limit, after)
return page(scope, items, has_more)
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(chat_id: str, request: Request):
return await member_chat(await actor(request), chat_id)
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
async def create_message(chat_id: str, request: Request):
user = await actor(request)
cid = parse_uuid(chat_id)
if cid is None:
raise bad("chat_id должен быть UUID")
body = await read_json(request, ("text",))
if not non_blank(body["text"], 4000):
raise bad("text: 1..4000 символов, не только пробелы")
ensure_capacity()
async with db.connection() as conn:
message = await repo.create_message(conn, cid, user["id"], body["text"])
if message is None:
raise not_found()
return JSONResponse(message, status_code=201)
@app.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(chat_id: str, request: Request):
chat = await member_chat(await actor(request), chat_id)
limit, cursor = page_params(request)
scope = "messages:" + chat["id"]
after = keyset(scope, cursor)
async with db.connection() as conn:
items, has_more = await repo.list_messages(conn, chat["id"], limit, after)
return page(scope, items, has_more)
@app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "PATCH", "DELETE"])
async def fallback(request: Request):
raise not_found()
+16
View File
@@ -0,0 +1,16 @@
from argon2 import PasswordHasher
from argon2.exceptions import Argon2Error, VerifyMismatchError
HASHER = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
DUMMY_HASH = HASHER.hash("there-is-no-such-user-password")
def hash_password(password: str) -> str:
return HASHER.hash(password)
def verify_password(stored: str, password: str) -> bool:
try:
return HASHER.verify(stored, password)
except (VerifyMismatchError, Argon2Error, ValueError):
return False
+132
View File
@@ -0,0 +1,132 @@
from typing import List, Optional, Tuple
import psycopg
from app.cursor import fmt
MESSAGE_COLUMNS = "id, chat_id, sender_id, text, created_at"
CHAT_QUERY = (
"SELECT c.id, c.title, c.created_at,"
" ARRAY(SELECT m2.user_id FROM chat_members m2 WHERE m2.chat_id = c.id ORDER BY m2.user_id) AS member_ids"
)
class UnknownMember(Exception):
pass
def decoded(value) -> str:
return bytes(value).decode("utf-8")
def public_user(row) -> dict:
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": decoded(row["display_name"]),
"created_at": fmt(row["created_at"]),
}
def _chat(row) -> dict:
return {
"id": str(row["id"]),
"title": decoded(row["title"]),
"member_ids": [str(value) for value in row["member_ids"]],
"created_at": fmt(row["created_at"]),
}
def _message(row) -> dict:
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": decoded(row["text"]),
"created_at": fmt(row["created_at"]),
}
async def create_user(conn, username: str, display_name: str, password_hash: str) -> Optional[dict]:
try:
cur = await conn.execute(
"INSERT INTO users (id, username, display_name, password_hash, created_at)"
" VALUES (gen_random_uuid(), %s, %s, %s, clock_timestamp())"
" RETURNING id, username, display_name, created_at",
(username, display_name.encode("utf-8"), password_hash),
)
except psycopg.errors.UniqueViolation:
return None
return public_user(await cur.fetchone())
async def credentials(conn, username: str):
cur = await conn.execute(
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
(username,),
)
return await cur.fetchone()
async def create_chat(conn, title: str, member_ids: List[str]) -> dict:
cur = await conn.execute(
"INSERT INTO chats (id, title, created_at)"
" VALUES (gen_random_uuid(), %s, clock_timestamp())"
" RETURNING id, title, created_at",
(title.encode("utf-8"),),
)
chat = await cur.fetchone()
cur = await conn.execute(
"INSERT INTO chat_members (chat_id, user_id) SELECT %s, u.id FROM users u WHERE u.id = ANY(%s::uuid[])",
(chat["id"], member_ids),
)
if cur.rowcount != len(member_ids):
raise UnknownMember()
chat["member_ids"] = list(member_ids)
return _chat(chat)
async def chat_for_member(conn, chat_id: str, user_id: str) -> Optional[dict]:
cur = await conn.execute(
CHAT_QUERY + " FROM chats c JOIN chat_members m ON m.chat_id = c.id AND m.user_id = %s WHERE c.id = %s",
(user_id, chat_id),
)
row = await cur.fetchone()
return _chat(row) if row else None
async def list_chats(conn, user_id: str, limit: int, after) -> Tuple[List[dict], bool]:
ts, last_id = after if after else (None, None)
cur = await conn.execute(
CHAT_QUERY
+ " FROM chats c JOIN chat_members m ON m.chat_id = c.id"
" WHERE m.user_id = %s AND (%s::timestamptz IS NULL OR (c.created_at, c.id) > (%s::timestamptz, %s::uuid))"
" ORDER BY c.created_at, c.id LIMIT %s",
(user_id, ts, ts, last_id, limit + 1),
)
rows = await cur.fetchall()
return [_chat(row) for row in rows[:limit]], len(rows) > limit
async def create_message(conn, chat_id: str, sender_id: str, text: str) -> Optional[dict]:
cur = await conn.execute(
"INSERT INTO messages (id, chat_id, sender_id, text, created_at)"
" SELECT gen_random_uuid(), %s, %s, %s, clock_timestamp()"
" WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s)"
" RETURNING " + MESSAGE_COLUMNS,
(chat_id, sender_id, text.encode("utf-8"), chat_id, sender_id),
)
row = await cur.fetchone()
return _message(row) if row else None
async def list_messages(conn, chat_id: str, limit: int, after) -> Tuple[List[dict], bool]:
ts, last_id = after if after else (None, None)
cur = await conn.execute(
"SELECT " + MESSAGE_COLUMNS + " FROM messages"
" WHERE chat_id = %s AND (%s::timestamptz IS NULL OR (created_at, id) > (%s::timestamptz, %s::uuid))"
" ORDER BY created_at, id LIMIT %s",
(chat_id, ts, ts, last_id, limit + 1),
)
rows = await cur.fetchall()
return [_message(row) for row in rows[:limit]], len(rows) > limit
+154
View File
@@ -0,0 +1,154 @@
import hashlib
import json
import logging
import secrets
from datetime import datetime, timedelta, timezone
from typing import Optional
import valkey.asyncio as valkey
from app import config, repo
from app.cursor import fmt
from app.errors import unavailable
log = logging.getLogger("messenger.sessions")
REVOKED = "revoked"
class SessionStore:
def __init__(self, db) -> None:
self.db = db
self.client = None
self.stats = {"hits": 0, "misses": 0, "errors": 0}
async def open(self) -> None:
if not config.CACHE_URL:
log.info("session cache disabled: CACHE_URL is empty")
return
self.client = valkey.Valkey.from_url(
config.CACHE_URL,
socket_timeout=config.CACHE_TIMEOUT,
socket_connect_timeout=config.CACHE_TIMEOUT,
decode_responses=True,
)
async def close(self) -> None:
if self.client is not None:
await self.client.aclose()
self.client = None
@staticmethod
def digest(token: str) -> bytes:
return hashlib.sha256(token.encode("utf-8")).digest()
@staticmethod
def key(digest: bytes) -> str:
return "session:" + digest.hex()
async def create(self, user: dict) -> tuple:
token = secrets.token_urlsafe(32)
digest = self.digest(token)
expires_at = datetime.now(timezone.utc) + timedelta(seconds=config.SESSION_TTL_SECONDS)
async with self.db.connection() as conn:
await conn.execute(
"INSERT INTO sessions (token_hash, user_id, created_at, expires_at)"
" VALUES (%s, %s, clock_timestamp(), %s)",
(digest, user["id"], expires_at),
)
await self._cache_put(digest, user, expires_at)
return token, fmt(expires_at)
async def resolve(self, token: str) -> Optional[dict]:
digest = self.digest(token)
cached = await self._cache_get(digest)
if cached == REVOKED:
self.stats["hits"] += 1
return None
if cached is not None:
self.stats["hits"] += 1
return cached
self.stats["misses"] += 1
async with self.db.connection() as conn:
cur = await conn.execute(
"SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at"
" FROM sessions s JOIN users u ON u.id = s.user_id"
" WHERE s.token_hash = %s AND s.expires_at > now()",
(digest,),
)
row = await cur.fetchone()
if row is None:
return None
user = repo.public_user(row)
await self._cache_put(digest, user, row["expires_at"])
return user
async def revoke(self, token: str) -> None:
digest = self.digest(token)
await self._cache_revoke(digest)
try:
async with self.db.connection() as conn:
await conn.execute("DELETE FROM sessions WHERE token_hash = %s", (digest,))
except Exception:
await self._cache_release(digest)
raise
async def sweep(self) -> int:
async with self.db.connection() as conn:
cur = await conn.execute("DELETE FROM sessions WHERE expires_at <= now()")
return cur.rowcount
def _cache_ttl(self, expires_at: datetime) -> int:
remaining = int((expires_at - datetime.now(timezone.utc)).total_seconds())
return min(config.SESSION_CACHE_TTL_SECONDS, remaining)
async def _cache_get(self, digest: bytes) -> Optional[dict]:
if self.client is None:
return None
try:
raw = await self.client.get(self.key(digest))
except Exception:
self._cache_failed("get")
return None
if not raw:
return None
if raw == REVOKED:
return REVOKED
try:
return json.loads(raw)
except ValueError:
return None
async def _cache_put(self, digest: bytes, user: dict, expires_at: datetime) -> None:
if self.client is None:
return
ttl = self._cache_ttl(expires_at)
if ttl <= 0:
return
payload = json.dumps(user)
try:
await self.client.set(self.key(digest), payload, ex=ttl, nx=True)
except Exception:
self._cache_failed("set")
async def _cache_release(self, digest: bytes) -> None:
if self.client is None:
return
try:
await self.client.delete(self.key(digest))
except Exception:
self._cache_failed("release")
async def _cache_revoke(self, digest: bytes) -> None:
if self.client is None:
return
try:
await self.client.set(self.key(digest), REVOKED, ex=config.SESSION_REVOKED_TTL_SECONDS)
except Exception:
self._cache_failed("revoke")
raise unavailable("Кэш сессий недоступен, выход из сессии не подтверждён") from None
def _cache_failed(self, operation: str) -> None:
self.stats["errors"] += 1
if self.stats["errors"] % 50 == 1:
log.warning("session cache %s failed, falling back to postgres (errors=%d)", operation, self.stats["errors"])
+101
View File
@@ -0,0 +1,101 @@
name: mtusi-lab2
services:
postgres:
image: postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
POSTGRES_INITDB_ARGS: --data-checksums
command:
- postgres
- -c
- synchronous_commit=on
- -c
- shared_buffers=128MB
- -c
- work_mem=8MB
- -c
- max_connections=50
- -c
- track_io_timing=on
secrets:
- postgres_password
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 20
start_period: 10s
restart: unless-stopped
valkey:
image: valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507
command:
- valkey-server
- --save
- ""
- --appendonly
- "no"
- --maxmemory
- 128mb
- --maxmemory-policy
- allkeys-lru
healthcheck:
test: ["CMD", "valkey-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
start_period: 5s
restart: unless-stopped
migrate:
build:
context: .
image: mtusi-messenger:lab2
command: ["python", "scripts/migrate.py"]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
secrets:
- database_url
depends_on:
postgres:
condition: service_healthy
restart: "no"
api:
build:
context: .
image: mtusi-messenger:lab2
env_file:
- .env
environment:
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
secrets:
- database_url
- cache_url
ports:
- "127.0.0.1:8080:8080"
depends_on:
postgres:
condition: service_healthy
valkey:
condition: service_healthy
migrate:
condition: service_completed_successfully
restart: unless-stopped
volumes:
pgdata:
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
+29
View File
@@ -0,0 +1,29 @@
=== 1. Останавливаю кэш сессий (valkey) ===
Container mtusi-lab2-valkey-1 Stopping
Container mtusi-lab2-valkey-1 Stopped
api Up 40 seconds (healthy)
postgres Up 46 seconds (unhealthy)
PASS login_and_read_work_without_cache
PASS unknown_token_is_still_rejected
PASS readiness_ignores_the_cache
3/3 checks passed
Container mtusi-lab2-valkey-1 Starting
Container mtusi-lab2-valkey-1 Started
=== 2. Останавливаю PostgreSQL ===
Container mtusi-lab2-postgres-1 Stopping
Container mtusi-lab2-postgres-1 Stopped
api Up 41 seconds (healthy)
valkey Up Less than a second (health: starting)
PASS readiness_reports_the_outage
PASS writes_fail_with_503
PASS unknown_token_never_becomes_trusted
PASS login_fails_closed
4/4 checks passed
Container mtusi-lab2-postgres-1 Starting
Container mtusi-lab2-postgres-1 Started
=== 3. Состояние восстановлено ===
api Up 44 seconds (healthy)
postgres Up Less than a second (health: starting)
valkey Up 3 seconds (health: starting)
+5
View File
@@ -0,0 +1,5 @@
Поднимаю отдельный API с SESSION_TTL_SECONDS=2 на порту 8081 (сеть mtusi-lab2_default)
PASS session_expires_after_ttl
PASS expired_session_cannot_write_or_logout
PASS expires_at_matches_configured_ttl
3/3 checks passed
+88
View File
@@ -0,0 +1,88 @@
sh student-tests/explain.sh
=== Стенд ===
api mtusi-messenger:lab2 Up About a minute (healthy)
postgres postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2 Up About a minute (healthy)
valkey valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507 Up Less than a second (health: starting)
=== Засев 10000 сообщений с неравномерными чатами ===
seed_duration | seeded_rows | target_total | messages_total
-----------------+-------------+--------------+----------------
00:00:00.001099 | 0 | 10000 | 53293
(1 row)
=== План запроса истории ===
postgres_version
-----------------------------------------------------------------------------------------------
PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 15.2.0, 64-bit
(1 row)
messages_total | chats_with_messages | table_size | indexes_size
----------------+---------------------+------------+--------------
53293 | 14 | 5320 kB | 7152 kB
(1 row)
--- распределение истории по чатам: 5 самых больших и 5 самых маленьких ---
chat_id | rows
--------------------------------------+-------
69ee7d45-68b4-4606-befe-efaeecdedd32 | 38293
e95dc135-101e-442f-baf7-b21f0ed7edaf | 14955
20948a76-f794-4765-9fcc-7a9ebccafd2e | 25
b2bd268f-f9b6-40fb-8039-1bde44c0f9ee | 5
f4d3517a-4afa-4461-a4fc-16c6302f3d7c | 3
(5 rows)
chat_id | rows
--------------------------------------+------
6dbc6664-e048-4858-9ce5-f507afb9fd7c | 1
ac1c8e3d-4e29-44fc-b770-d3ef6f2351ae | 1
5a65b658-2555-4ac9-b10a-9a081f81f37b | 1
17c53c09-19a0-4c0c-87f8-2f8c66468119 | 1
451812c7-05dc-4b1d-9ddb-3679c4ccd15f | 1
(5 rows)
--- A. keyset, первая страница самого большого чата ---
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.41..5.43 rows=50 width=67) (actual time=0.005..0.013 rows=50 loops=1)
Buffers: shared hit=24
-> Index Scan using messages_history_idx on messages (cost=0.41..3813.50 rows=38014 width=67) (actual time=0.005..0.010 rows=50 loops=1)
Index Cond: (chat_id = '69ee7d45-68b4-4606-befe-efaeecdedd32'::uuid)
Buffers: shared hit=24
Planning:
Buffers: shared hit=8
Planning Time: 0.036 ms
Execution Time: 0.021 ms
(9 rows)
--- B. keyset, страница на глубине 90% истории (так работает cursor API) ---
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.41..8.31 rows=50 width=67) (actual time=0.006..0.013 rows=50 loops=1)
Buffers: shared hit=53
-> Index Scan using messages_history_idx on messages (cost=0.41..2141.23 rows=13555 width=67) (actual time=0.006..0.011 rows=50 loops=1)
Index Cond: ((chat_id = '69ee7d45-68b4-4606-befe-efaeecdedd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-23 20:11:34.584521+00'::timestamp with time zone, 'aa6010bb-02c6-4d17-986b-0f5103547576'::uuid)))
Buffers: shared hit=53
Planning Time: 0.023 ms
Execution Time: 0.032 ms
(7 rows)
--- C. OFFSET на той же глубине (так API не делает: цена растёт со страницей) ---
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=3457.31..3462.32 rows=50 width=67) (actual time=4.463..4.470 rows=50 loops=1)
Buffers: shared hit=34920
-> Index Scan using messages_history_idx on messages (cost=0.41..3813.50 rows=38014 width=67) (actual time=0.005..3.799 rows=34513 loops=1)
Index Cond: (chat_id = '69ee7d45-68b4-4606-befe-efaeecdedd32'::uuid)
Buffers: shared hit=34920
Planning Time: 0.016 ms
Execution Time: 4.476 ms
(7 rows)
--- индексы таблицы messages ---
index | size | scans
----------------------+---------+-------
messages_history_idx | 4832 kB | 12
messages_pkey | 2320 kB | 0
(2 rows)
+21
View File
@@ -0,0 +1,21 @@
M .env.example
MM REPORT.md
M app/config.py
MM app/sessions.py
MM evidence/dependency.txt
MM evidence/explain-10k.txt
MM evidence/git-hygiene.txt
MM evidence/load-cache.json
MM evidence/load-nocache.json
MM evidence/load.txt
MM evidence/migrations.txt
MM evidence/outages.txt
MM evidence/persistence.txt
MM evidence/stand.txt
MM evidence/track2/run.txt
MM student-tests/test_outages.py
--- правила игнорирования ---
.gitignore:2:.env .env
.gitignore:5:secrets/ secrets/database_url
.gitignore:5:secrets/ secrets/postgres_password
.gitignore:15:backups/ backups
+24
View File
@@ -0,0 +1,24 @@
PASS wrong_password_gives_same_401
PASS basic_is_rejected_on_business_endpoints
PASS x_user_id_does_not_authenticate
PASS logout_revokes_only_its_own_token
PASS token_is_opaque_and_unique
PASS short_password_is_rejected
PASS password_is_never_returned
PASS login_rejects_a_request_body
PASS broken_utf8_credentials_are_rejected
9/9 checks passed
PASS duplicate_username_race_creates_one_user
PASS unknown_member_rolls_chat_back
PASS keyset_pagination_is_complete
PASS cursor_is_bound_to_its_chat
PASS limit_bounds_are_enforced
PASS sql_injection_is_not_executed
PASS malformed_requests_are_rejected
PASS nul_and_unicode_text_round_trips
PASS text_length_limit_counts_code_points
PASS unicode_blanks_are_rejected
PASS broken_json_does_not_break_the_api
PASS content_type_is_required
12/12 checks passed
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.011,
"concurrency": 4,
"successful_requests": 38293,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 1275.96,
"successful_latency_ms": {
"p50": 2.933,
"p95": 4.335,
"p99": 7.548
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.017,
"concurrency": 4,
"successful_requests": 14955,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 498.216,
"successful_latency_ms": {
"p50": 7.457,
"p95": 11.462,
"p99": 14.472
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+34
View File
@@ -0,0 +1,34 @@
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.011,
"concurrency": 4,
"successful_requests": 38293,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 1275.96,
"successful_latency_ms": {
"p50": 2.933,
"p95": 4.335,
"p99": 7.548
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.017,
"concurrency": 4,
"successful_requests": 14955,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 498.216,
"successful_latency_ms": {
"p50": 7.457,
"p95": 11.462,
"p99": 14.472
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+35
View File
@@ -0,0 +1,35 @@
--- первый запуск (из логов сервиса migrate) ---
migrate-1 | apply 0001_init
migrate-1 | migrations complete: 1 file(s)
--- повторный запуск ---
Container mtusi-lab2-postgres-1 Running
Container mtusi-lab2-postgres-1 Waiting
Container mtusi-lab2-postgres-1 Healthy
Container mtusi-lab2-migrate-run-003b830c021a Creating
Container mtusi-lab2-migrate-run-003b830c021a Created
skip 0001_init
migrations complete: 1 file(s)
--- схема ---
Table "public.messages"
Column | Type | Collation | Nullable | Default | Storage | Compression | Stats target | Description
------------+--------------------------+-----------+----------+---------+----------+-------------+--------------+-------------
id | uuid | | not null | | plain | | |
chat_id | uuid | | not null | | plain | | |
sender_id | uuid | | not null | | plain | | |
text | bytea | | not null | | extended | | |
created_at | timestamp with time zone | | not null | | plain | | |
Indexes:
"messages_pkey" PRIMARY KEY, btree (id)
"messages_history_idx" btree (chat_id, created_at, id)
Check constraints:
"messages_text_size" CHECK (octet_length(text) >= 1 AND octet_length(text) <= 16000)
Foreign-key constraints:
"messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
"messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id) ON DELETE RESTRICT
Access method: heap
version | checksum | applied_at
-----------+------------------------------------------------------------------+-------------------------------
0001_init | 4fd0a8c68a5cffd3ae67a21646eb1928477d18b8716e68c1220469d858ccb9c1 | 2026-10-23 20:10:21.263237+00
(1 row)
+9
View File
@@ -0,0 +1,9 @@
PASS revoked_session_stays_revoked_after_cache_restart
PASS logout_is_not_confirmed_while_cache_is_down
PASS cached_sessions_do_not_cross_users
PASS cache_is_repopulated_after_a_miss
PASS cache_survives_its_own_restart
PASS revoked_session_cannot_be_resurrected_by_a_race
PASS failed_logout_leaves_cache_and_database_consistent
PASS hung_database_fails_fast
8/8 checks passed
+18
View File
@@ -0,0 +1,18 @@
--- состояние контейнеров до рестарта ---
api Up 44 seconds (healthy)
postgres Up Less than a second (health: starting)
valkey Up 3 seconds (health: starting)
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
--- состояние контейнеров после рестарта ---
api Up Less than a second (health: starting)
postgres Up Less than a second (health: starting)
valkey Up Less than a second (health: starting)
--- логи postgres о перезапуске ---
postgres-1 | 2026-10-23 20:11:06.649 UTC [1] LOG: starting PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 15.2.0, 64-bit
postgres-1 | 2026-10-23 20:11:06.649 UTC [1] LOG: listening on IPv4 address "0.0.0.0", port 5432
postgres-1 | 2026-10-23 20:11:06.649 UTC [1] LOG: listening on IPv6 address "::", port 5432
postgres-1 | 2026-10-23 20:11:06.650 UTC [1] LOG: listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432"
postgres-1 | 2026-10-23 20:11:06.652 UTC [29] LOG: database system was shut down at 2026-10-23 20:11:06 UTC
postgres-1 | 2026-10-23 20:11:06.654 UTC [1] LOG: database system is ready to accept connections
+2
View File
@@ -0,0 +1,2 @@
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+16
View File
@@ -0,0 +1,16 @@
Darwin arm64
Docker version 29.7.2, build a7dcaa6
Docker Compose version v5.5.1
api mtusi-messenger:lab2 Up 1 second (health: starting)
postgres postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2 Up 7 seconds (healthy)
valkey valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507 Up 7 seconds (healthy)
PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 15.2.0, 64-bit
Valkey server v=8.1.10 sha=00000000:1 malloc=jemalloc-5.3.0 bits=64 build=2cb63ac0e4567989
--- строка старта API: действующие лимиты и TTL ---
api-1 | INFO: Waiting for application startup.
api-1 | 2026-10-23 20:10:21,987 INFO messenger started: instance=b9f88891f2b8 session_store=postgres session_ttl=3600 cache_ttl=30 pool=1..10 max_inflight=64 max_body=65536
api-1 | INFO: Application startup complete.
api-1 | INFO: Uvicorn running on http://0.0.0.0:8080 (Press CTRL+C to quit)
api-1 | INFO: 172.18.0.1:57028 - "GET /health/ready HTTP/1.1" 200 OK
--- сверка .env с .env.example ---
ready: .env and secrets/ created locally; they stay out of Git
+227
View File
@@ -0,0 +1,227 @@
=== Стенд и версии ===
api mtusi-messenger:lab2 Up About a minute (healthy)
postgres postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2 Up About a minute (healthy)
valkey valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507 Up Less than a second (health: starting)
Darwin arm64
Docker version 29.7.2, build a7dcaa6
=== 1. Засев истории: цель 120000 сообщений, чаты неравномерные ===
seed_duration | seeded_rows | target_total | messages_total
-----------------+-------------+--------------+----------------
00:00:00.637022 | 66707 | 120000 | 120000
(1 row)
=== 2. Сравнение индексов и цены записи (каждый вариант в откатываемой транзакции) ===
messages_total
----------------
120000
(1 row)
############ Вариант A: messages_history_idx (chat_id, created_at, id) ############
index_size
------------
11 MB
(1 row)
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..52.46 rows=50 width=89) (actual time=0.015..0.024 rows=50 loops=1)
Buffers: shared hit=53
-> Index Scan using messages_history_idx on messages (cost=0.42..7478.52 rows=7184 width=89) (actual time=0.014..0.021 rows=50 loops=1)
Index Cond: ((chat_id = '69ee7d45-68b4-4606-befe-efaeecdedd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-23 20:11:34.584521+00'::timestamp with time zone, 'aa6010bb-02c6-4d17-986b-0f5103547576'::uuid)))
Buffers: shared hit=53
Planning:
Buffers: shared hit=19
Planning Time: 0.097 ms
Execution Time: 0.047 ms
(9 rows)
pages_measured
----------------
5000
(1 row)
hundred_pages_duration
------------------------
00:00:00.001077
(1 row)
insert_10k_duration
---------------------
00:00:00.085221
(1 row)
############ Вариант B: только (chat_id) ############
index_size
------------
856 kB
(1 row)
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=3274.42..3274.55 rows=50 width=90) (actual time=2.027..2.031 rows=50 loops=1)
Buffers: shared hit=475 read=35
I/O Timings: shared read=0.088
-> Sort (cost=3274.42..3292.14 rows=7088 width=90) (actual time=2.026..2.028 rows=50 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 33kB
Buffers: shared hit=475 read=35
I/O Timings: shared read=0.088
-> Bitmap Heap Scan on messages (cost=428.23..3038.96 rows=7088 width=90) (actual time=1.631..1.839 rows=3829 loops=1)
Recheck Cond: (chat_id = '69ee7d45-68b4-4606-befe-efaeecdedd32'::uuid)
Filter: (ROW(created_at, id) > ROW('2026-10-23 20:11:34.584521+00'::timestamp with time zone, 'aa6010bb-02c6-4d17-986b-0f5103547576'::uuid))
Rows Removed by Filter: 34464
Heap Blocks: exact=475
Buffers: shared hit=475 read=35
I/O Timings: shared read=0.088
-> Bitmap Index Scan on messages_chat_only_idx (cost=0.00..426.46 rows=38156 width=0) (actual time=0.397..0.397 rows=38293 loops=1)
Index Cond: (chat_id = '69ee7d45-68b4-4606-befe-efaeecdedd32'::uuid)
Buffers: shared read=35
I/O Timings: shared read=0.088
Planning:
Buffers: shared hit=27 read=1
I/O Timings: shared read=0.009
Planning Time: 0.123 ms
Execution Time: 2.056 ms
(24 rows)
pages_measured
----------------
5000
(1 row)
hundred_pages_duration
------------------------
00:00:02.52905
(1 row)
insert_10k_duration
---------------------
00:00:00.080589
(1 row)
############ Вариант C: (chat_id, created_at, id) INCLUDE (sender_id, text) ############
index_size
------------
14 MB
(1 row)
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..45.99 rows=50 width=89) (actual time=0.014..0.018 rows=50 loops=1)
Buffers: shared hit=1 read=3
I/O Timings: shared read=0.005
-> Index Only Scan using messages_history_covering_idx on messages (cost=0.42..6560.61 rows=7197 width=89) (actual time=0.013..0.015 rows=50 loops=1)
Index Cond: ((chat_id = '69ee7d45-68b4-4606-befe-efaeecdedd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-23 20:11:34.584521+00'::timestamp with time zone, 'aa6010bb-02c6-4d17-986b-0f5103547576'::uuid)))
Heap Fetches: 0
Buffers: shared hit=1 read=3
I/O Timings: shared read=0.005
Planning:
Buffers: shared hit=28 read=1
I/O Timings: shared read=0.003
Planning Time: 0.118 ms
Execution Time: 0.027 ms
(13 rows)
pages_measured
----------------
5000
(1 row)
hundred_pages_duration
------------------------
00:00:00.000734
(1 row)
insert_10k_duration
---------------------
00:00:00.08596
(1 row)
############ Схема после эксперимента (ROLLBACK вернул индексы) ############
indexname
----------------------
messages_history_idx
messages_pkey
(2 rows)
Самый большой чат: 69ee7d45-68b4-4606-befe-efaeecdedd32
=== 3. Состояние источника до бэкапа ===
relation | rows
--------------+--------
chat_members | 1036
chats | 68
messages | 120000
sessions | 45
users | 78
(5 rows)
big_chat_rows | big_chat_md5
---------------+----------------------------------
38293 | f18725746ed1acbdda044e804cdc4c7c
(1 row)
id | created_at | text
--------------------------------------+-------------------------------+----------
39cb2935-f53c-4e54-a75d-8b197126a6b4 | 2026-10-23 20:11:07.699544+00 | load-3-0
62d3d8a1-fdaa-4a6c-812f-79ef268ada42 | 2026-10-23 20:11:07.700168+00 | load-1-0
4fa775f1-6033-4d84-9e6c-0f39844e6201 | 2026-10-23 20:11:07.700828+00 | load-0-0
(3 rows)
marker_rows
-------------
0
(1 row)
=== 4. Бэкап pg_dump -Fc ===
backup_seconds=0.743
dump_size=5.7M
=== 5. Запись после бэкапа: граница потери данных ===
в источнике маркеров: 1
=== 6. Новое хранилище: отдельный контейнер и отдельный том ===
/var/run/postgresql:5432 - accepting connections
=== 7. Восстановление в новое хранилище ===
restore_seconds=0.354
=== 8. Сверка восстановленной копии ===
relation | rows
--------------+--------
chat_members | 1036
chats | 68
messages | 120000
sessions | 45
users | 78
(5 rows)
big_chat_rows | big_chat_md5
---------------+----------------------------------
38293 | f18725746ed1acbdda044e804cdc4c7c
(1 row)
id | created_at | text
--------------------------------------+-------------------------------+----------
39cb2935-f53c-4e54-a75d-8b197126a6b4 | 2026-10-23 20:11:07.699544+00 | load-3-0
62d3d8a1-fdaa-4a6c-812f-79ef268ada42 | 2026-10-23 20:11:07.700168+00 | load-1-0
4fa775f1-6033-4d84-9e6c-0f39844e6201 | 2026-10-23 20:11:07.700828+00 | load-0-0
(3 rows)
marker_rows
-------------
0
(1 row)
=== 9. Итог ===
backup_seconds=0.743 restore_seconds=0.354
messages_source_without_marker=120000 messages_restored=120000
big_chat_md5_source=f18725746ed1acbdda044e804cdc4c7c
big_chat_md5_restored=f18725746ed1acbdda044e804cdc4c7c
RESULT: восстановленная копия совпадает с источником на момент бэкапа
маркеров после бэкапа в восстановленной копии: 0 (ожидается 0: всё, что подтверждено после снимка, в дампе отсутствует)
+46
View File
@@ -0,0 +1,46 @@
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL UNIQUE
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name bytea NOT NULL
CONSTRAINT users_display_name_size CHECK (octet_length(display_name) BETWEEN 1 AND 400),
password_hash text NOT NULL,
created_at timestamptz NOT NULL
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title bytea NOT NULL
CONSTRAINT chats_title_size CHECK (octet_length(title) BETWEEN 1 AND 400),
created_at timestamptz NOT NULL
);
CREATE INDEX chats_created_idx ON chats (created_at, id);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT,
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 REFERENCES chats (id) ON DELETE CASCADE,
sender_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT,
text bytea NOT NULL
CONSTRAINT messages_text_size CHECK (octet_length(text) BETWEEN 1 AND 16000),
created_at timestamptz NOT NULL
);
CREATE INDEX messages_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) ON DELETE CASCADE,
created_at timestamptz NOT NULL,
expires_at timestamptz NOT NULL
);
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
+22
View File
@@ -0,0 +1,22 @@
annotated-types==0.8.0
anyio==4.15.1
argon2-cffi==25.1.0
argon2-cffi-bindings==26.1.0
cffi==2.1.1
click==8.5.0
fastapi==0.115.6
h11==0.16.0
httptools==0.9.0
idna==3.20
psycopg==3.3.6
psycopg-binary==3.3.6
psycopg-pool==3.3.3
pycparser==3.11
pydantic==2.14.1
pydantic-core==2.50.1
starlette==0.41.3
typing-extensions==4.16.0
typing-inspection==0.4.4
uvicorn==0.34.0
uvloop==0.23.0
valkey==6.2.0
+40
View File
@@ -0,0 +1,40 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
if [ -f .env ]; then
added=$(python3 - <<'PYEOF'
def pairs(path):
result = []
for line in open(path, encoding="utf-8"):
stripped = line.strip()
if stripped and not stripped.startswith("#") and "=" in stripped:
result.append((stripped.split("=", 1)[0], line.rstrip("\n")))
return result
present = {name for name, _ in pairs(".env")}
missing = [line for name, line in pairs(".env.example") if name not in present]
if missing:
with open(".env", "a", encoding="utf-8") as handle:
handle.write("\n# Добавлено bootstrap из .env.example\n")
for line in missing:
handle.write(line + "\n")
print(" ".join(line.split("=", 1)[0] for line in missing))
PYEOF
)
if [ -n "$added" ]; then
echo "в .env добавлены отсутствующие переменные: $added"
fi
else
cp .env.example .env
fi
mkdir -p secrets
if [ ! -f secrets/postgres_password ]; then
python3 -c "import secrets; print(secrets.token_urlsafe(24))" > secrets/postgres_password
fi
password=$(cat secrets/postgres_password)
printf 'postgresql://messenger:%s@postgres:5432/messenger\n' "$password" > secrets/database_url
printf 'valkey://valkey:6379/0\n' > secrets/cache_url
chmod 700 secrets
chmod 600 secrets/postgres_password secrets/database_url secrets/cache_url
echo "ready: .env and secrets/ created locally; they stay out of Git"
+60
View File
@@ -0,0 +1,60 @@
#!/usr/bin/env python3
"""Versioned SQL migrations: applied once, checksum-verified, safe to re-run."""
import hashlib
import os
import pathlib
import sys
import psycopg
ROOT = pathlib.Path(__file__).resolve().parents[1]
MIGRATIONS = ROOT / "migrations"
LOCK_ID = 2026_0002
def database_url() -> str:
path = os.environ.get("DATABASE_URL_FILE")
if path:
return pathlib.Path(path).read_text(encoding="utf-8").strip()
url = os.environ.get("DATABASE_URL", "").strip()
if not url:
sys.exit("DATABASE_URL or DATABASE_URL_FILE is required")
return url
def main() -> None:
files = sorted(MIGRATIONS.glob("*.sql"))
if not files:
sys.exit("no migration files found in %s" % MIGRATIONS)
with psycopg.connect(database_url(), autocommit=True, connect_timeout=10) as conn:
conn.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
" version text PRIMARY KEY,"
" checksum text NOT NULL,"
" applied_at timestamptz NOT NULL DEFAULT now())"
)
conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,))
rows = conn.execute("SELECT version, checksum FROM schema_migrations").fetchall()
applied = {row[0]: row[1] for row in rows}
for path in files:
version = path.stem
body = path.read_text(encoding="utf-8")
checksum = hashlib.sha256(body.encode("utf-8")).hexdigest()
if version in applied:
if applied[version] != checksum:
sys.exit("migration %s changed after it was applied" % version)
print("skip %s" % version)
continue
with conn.transaction():
conn.execute(body)
conn.execute(
"INSERT INTO schema_migrations (version, checksum) VALUES (%s, %s)",
(version, checksum),
)
print("apply %s" % version)
conn.execute("SELECT pg_advisory_unlock(%s)", (LOCK_ID,))
print("migrations complete: %d file(s)" % len(files))
if __name__ == "__main__":
main()
+5
View File
@@ -0,0 +1,5 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart postgres valkey api
+111
View File
@@ -0,0 +1,111 @@
"""Shared HTTP helpers for the student checks; stdlib only, Python 3.9+."""
import argparse
import base64
import json
import os
import sys
import urllib.error
import urllib.request
import uuid
DEFAULT_BASE = os.environ.get("BASE_URL", "http://localhost:8080")
class Failed(AssertionError):
pass
def expect(condition, message):
if not condition:
raise Failed(message)
def call(base, method, path, body=None, token=None, headers=None, timeout=10, raw=None, content_type=None):
sent = {"Accept": "application/json"}
data = raw
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
sent["Content-Type"] = "application/json"
if content_type is not None:
sent["Content-Type"] = content_type
if token:
sent["Authorization"] = "Bearer " + token
sent.update(headers or {})
request = urllib.request.Request(base + path, data=data, headers=sent, method=method)
try:
response = urllib.request.urlopen(request, timeout=timeout)
except urllib.error.HTTPError as error:
response = error
except (urllib.error.URLError, TimeoutError, OSError) as exc:
raise Failed("%s %s: нет соединения (%s)" % (method, path, type(exc).__name__)) from None
with response:
raw = response.read()
payload = None
if raw:
try:
payload = json.loads(raw)
except ValueError:
payload = None
return {"status": response.code, "headers": response.headers, "json": payload}
def credentials(label="check"):
return {
"username": "u_%s_%s" % (label, uuid.uuid4().hex[:10]),
"display_name": "Проверка " + label,
"password": "T3st-" + uuid.uuid4().hex,
}
def basic(username, password):
return "Basic " + base64.b64encode(("%s:%s" % (username, password)).encode("utf-8")).decode()
def register(base, label="check"):
body = credentials(label)
result = call(base, "POST", "/api/v1/users", body=body)
expect(result["status"] == 201, "регистрация вернула %s" % result["status"])
return {"registration": body, "user": result["json"], "id": result["json"]["id"]}
def login(base, actor):
result = call(
base,
"POST",
"/api/v1/auth/sessions",
headers={"Authorization": basic(actor["registration"]["username"], actor["registration"]["password"])},
)
expect(result["status"] == 201, "вход вернул %s" % result["status"])
actor["token"] = result["json"]["token"]
actor["session"] = result["json"]
return actor
def member(base, label="check"):
return login(base, register(base, label))
def chat_with(base, owner, *others):
members = [owner["id"]] + [other["id"] for other in others]
result = call(base, "POST", "/api/v1/chats", body={"title": "Проверка " + uuid.uuid4().hex[:8], "member_ids": members}, token=owner["token"])
expect(result["status"] == 201, "создание чата вернуло %s" % result["status"])
return result["json"]
def arguments(description):
parser = argparse.ArgumentParser(description=description)
parser.add_argument("--base-url", default=DEFAULT_BASE)
return parser.parse_args()
def run(tests, base):
failures = []
for test in tests:
try:
test(base)
print("PASS %s" % test.__name__)
except AssertionError as exc:
failures.append(test.__name__)
print("FAIL %s: %s" % (test.__name__, exc))
print("%d/%d checks passed" % (len(tests) - len(failures), len(tests)))
sys.exit(1 if failures else 0)
+39
View File
@@ -0,0 +1,39 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
COMPOSE="docker compose --env-file .env"
wait_ready() {
i=0
while [ "$i" -lt 60 ]; do
if curl -fsS http://localhost:8080/health/ready >/dev/null 2>&1; then return 0; fi
i=$((i + 1))
sleep 1
done
echo "API не стал ready" >&2
return 1
}
restore() {
$COMPOSE start valkey postgres >/dev/null 2>&1 || true
}
trap restore EXIT
echo "=== 1. Останавливаю кэш сессий (valkey) ==="
$COMPOSE stop valkey
$COMPOSE ps --format '{{.Service}} {{.Status}}'
python3 student-tests/test_without_cache.py --base-url http://localhost:8080
$COMPOSE start valkey
wait_ready
echo
echo "=== 2. Останавливаю PostgreSQL ==="
$COMPOSE stop postgres
$COMPOSE ps --format '{{.Service}} {{.Status}}'
python3 student-tests/test_without_db.py --base-url http://localhost:8080
$COMPOSE start postgres
wait_ready
echo
echo "=== 3. Состояние восстановлено ==="
$COMPOSE ps --format '{{.Service}} {{.Status}}'
+130
View File
@@ -0,0 +1,130 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
OUT=${OUT:-evidence}
TOTAL=${TOTAL:-120000}
COMPOSE="docker compose --env-file .env"
mkdir -p "$OUT" "$OUT/track2"
step() {
printf '\n######## %s ########\n' "$1"
}
wait_ready() {
i=0
while [ "$i" -lt 90 ]; do
if curl -fsS http://localhost:8080/health/ready >/dev/null 2>&1; then return 0; fi
i=$((i + 1))
sleep 1
done
echo "API не стал ready" >&2
return 1
}
step "0. Чистый стенд: удаляю том базы и поднимаю заново"
$COMPOSE down -v
$COMPOSE up -d --build
wait_ready
{
uname -sm
docker --version
$COMPOSE version
$COMPOSE ps --format '{{.Service}} {{.Image}} {{.Status}}'
$COMPOSE exec -T postgres psql -U messenger -d messenger -t -A -c 'select version()'
$COMPOSE exec -T valkey valkey-server --version
echo '--- строка старта API: действующие лимиты и TTL ---'
$COMPOSE logs api --tail=5
echo '--- сверка .env с .env.example ---'
sh scripts/bootstrap.sh
} > "$OUT/stand.txt" 2>&1
cat "$OUT/stand.txt"
step "1. Миграции с нуля и повторный запуск"
{
echo '--- первый запуск (из логов сервиса migrate) ---'
$COMPOSE logs migrate --tail=10
echo '--- повторный запуск ---'
$COMPOSE run --rm migrate
echo '--- схема ---'
$COMPOSE exec -T postgres psql -U messenger -d messenger -X -c '\d+ messages'
$COMPOSE exec -T postgres psql -U messenger -d messenger -X -c 'table schema_migrations'
} > "$OUT/migrations.txt" 2>&1
tail -5 "$OUT/migrations.txt"
step "2. Публичный smoke"
make test > "$OUT/smoke.txt" 2>&1
tail -1 "$OUT/smoke.txt"
step "3. Свои проверки уровня 4"
{
python3 student-tests/test_auth_sessions.py
echo
python3 student-tests/test_storage_rules.py
} > "$OUT/level4-tests.txt" 2>&1
grep 'checks passed' "$OUT/level4-tests.txt"
step "4. Истечение сессии при коротком TTL"
sh student-tests/expiry.sh > "$OUT/expiry.txt" 2>&1
grep 'checks passed' "$OUT/expiry.txt"
step "5. Отзыв сессии против кэша и зависшая БД"
python3 student-tests/test_outages.py > "$OUT/outages.txt" 2>&1
grep 'checks passed' "$OUT/outages.txt"
step "6. Отказ Valkey, затем отказ PostgreSQL"
sh student-tests/dependency.sh > "$OUT/dependency.txt" 2>&1
grep 'checks passed' "$OUT/dependency.txt"
step "7. Рестарт API и всех хранилищ"
{
echo '--- состояние контейнеров до рестарта ---'
$COMPOSE ps --format '{{.Service}} {{.Status}}'
} > "$OUT/persistence.txt" 2>&1
make test-persistence ACTION_SCRIPT=scripts/restart.sh >> "$OUT/persistence.txt" 2>&1
{
echo '--- состояние контейнеров после рестарта ---'
$COMPOSE ps --format '{{.Service}} {{.Status}}'
echo '--- логи postgres о перезапуске ---'
$COMPOSE logs postgres --tail=6
} >> "$OUT/persistence.txt" 2>&1
grep 'PASS\|FAIL' "$OUT/persistence.txt"
step "8. Нагрузка с кэшем сессий и без него"
python3 tests/load.py --duration 30 --concurrency 4 --output "$OUT/load-cache.json" > "$OUT/load.txt" 2>&1
$COMPOSE stop valkey
python3 tests/load.py --duration 30 --concurrency 4 --output "$OUT/load-nocache.json" >> "$OUT/load.txt" 2>&1
$COMPOSE start valkey
wait_ready
python3 - "$OUT" <<'PYEOF'
import json
import sys
out = sys.argv[1]
for name in ("load-cache", "load-nocache"):
with open(out + "/" + name + ".json") as handle:
data = json.load(handle)
print(name, data["successful_requests"], "ok,", data["failed_requests"], "fail,",
data["successful_rps"], "rps,", data["successful_latency_ms"])
PYEOF
step "9. План запроса истории"
make explain > "$OUT/explain-10k.txt" 2>&1
grep -E 'messages_total|Execution Time' "$OUT/explain-10k.txt" | head -8
step "10. Трек 5: индексы и восстановление"
TOTAL="$TOTAL" sh student-tests/track2.sh > "$OUT/track2/run.txt" 2>&1
grep -E 'backup_seconds|restore_seconds|RESULT|маркеров' "$OUT/track2/run.txt"
step "11. Гигиена репозитория"
{
git status --porcelain
echo '--- правила игнорирования ---'
git check-ignore -v .env secrets/database_url secrets/postgres_password backups || true
} > "$OUT/git-hygiene.txt" 2>&1
cat "$OUT/git-hygiene.txt"
step "Готово"
echo "Файлы доказательств: $OUT"
ls -1 "$OUT" "$OUT/track2"
+35
View File
@@ -0,0 +1,35 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
NAME=mtusi-lab2-api-shortttl
PORT=${PORT:-8081}
NETWORK=$(docker compose --env-file .env ps --format '{{.Name}}' api | head -1 | xargs -I{} docker inspect {} --format '{{range $k,$v := .NetworkSettings.Networks}}{{$k}}{{end}}')
cleanup() {
docker rm -f "$NAME" >/dev/null 2>&1 || true
}
trap cleanup EXIT
cleanup
echo "Поднимаю отдельный API с SESSION_TTL_SECONDS=2 на порту $PORT (сеть $NETWORK)"
docker run -d --name "$NAME" --network "$NETWORK" \
-p 127.0.0.1:"$PORT":8080 \
-v "$PWD/secrets/database_url:/run/secrets/database_url:ro" \
-v "$PWD/secrets/cache_url:/run/secrets/cache_url:ro" \
-e DATABASE_URL_FILE=/run/secrets/database_url \
-e CACHE_URL_FILE=/run/secrets/cache_url \
-e SESSION_TTL_SECONDS=2 \
-e SESSION_CACHE_TTL_SECONDS=2 \
-e SESSION_SWEEP_SECONDS=5 \
mtusi-messenger:lab2 >/dev/null
i=0
while [ "$i" -lt 60 ]; do
if curl -fsS "http://localhost:$PORT/health/ready" >/dev/null 2>&1; then break; fi
i=$((i + 1))
sleep 1
done
curl -fsS "http://localhost:$PORT/health/ready" >/dev/null
python3 student-tests/test_expiry.py --base-url "http://localhost:$PORT"
+15
View File
@@ -0,0 +1,15 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
TOTAL=${TOTAL:-10000}
PSQL="docker compose --env-file .env exec -T postgres psql -U messenger -d messenger -X -q"
echo "=== Стенд ==="
docker compose --env-file .env ps --format '{{.Service}} {{.Image}} {{.Status}}'
echo
echo "=== Засев $TOTAL сообщений с неравномерными чатами ==="
$PSQL -v total="$TOTAL" -f - < student-tests/seed.sql
echo
echo "=== План запроса истории ==="
$PSQL -f - < student-tests/explain.sql
+51
View File
@@ -0,0 +1,51 @@
\set ON_ERROR_STOP on
SELECT version() AS postgres_version;
SELECT count(*) AS messages_total,
count(DISTINCT chat_id) AS chats_with_messages,
pg_size_pretty(pg_table_size('messages')) AS table_size,
pg_size_pretty(pg_indexes_size('messages')) AS indexes_size
FROM messages;
\echo '--- распределение истории по чатам: 5 самых больших и 5 самых маленьких ---'
SELECT chat_id, count(*) AS rows FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 5;
SELECT chat_id, count(*) AS rows FROM messages GROUP BY chat_id ORDER BY count(*) ASC LIMIT 5;
SELECT chat_id AS big_chat, count(*) AS big_rows
FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1 \gset
SELECT created_at AS cur_ts, id AS cur_id
FROM messages
WHERE chat_id = :'big_chat'
ORDER BY created_at, id
OFFSET (:'big_rows'::bigint * 9 / 10) LIMIT 1 \gset
\echo '--- A. keyset, первая страница самого большого чата ---'
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = :'big_chat'
ORDER BY created_at, id
LIMIT 50;
\echo '--- B. keyset, страница на глубине 90% истории (так работает cursor API) ---'
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = :'big_chat'
AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid)
ORDER BY created_at, id
LIMIT 50;
\echo '--- C. OFFSET на той же глубине (так API не делает: цена растёт со страницей) ---'
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = :'big_chat'
ORDER BY created_at, id
OFFSET (:'big_rows'::bigint * 9 / 10) LIMIT 50;
\echo '--- индексы таблицы messages ---'
SELECT indexrelname AS index, pg_size_pretty(pg_relation_size(indexrelid)) AS size, idx_scan AS scans
FROM pg_stat_user_indexes WHERE relname = 'messages' ORDER BY indexrelname;
+37
View File
@@ -0,0 +1,37 @@
\set ON_ERROR_STOP on
INSERT INTO users (id, username, display_name, password_hash, created_at)
SELECT gen_random_uuid(), 'load_' || g, convert_to('Нагрузка ' || g, 'UTF8'), 'seed-row-cannot-log-in', now()
FROM generate_series(1, 20) AS g
ON CONFLICT (username) DO NOTHING;
INSERT INTO chats (id, title, created_at)
SELECT gen_random_uuid(), convert_to('load chat ' || g, 'UTF8'), now()
FROM generate_series(1, 50) AS g
WHERE NOT EXISTS (SELECT 1 FROM chats WHERE title = convert_to('load chat ' || g, 'UTF8'));
INSERT INTO chat_members (chat_id, user_id)
SELECT c.id, u.id
FROM chats c CROSS JOIN users u
WHERE position(convert_to('load chat ', 'UTF8') in c.title) = 1 AND u.username LIKE 'load\_%'
ON CONFLICT DO NOTHING;
SELECT greatest(0, :total - (SELECT count(*) FROM messages)) AS to_seed \gset
SELECT clock_timestamp() AS seed_started \gset
WITH c AS (SELECT array_agg(id ORDER BY title) AS ids FROM chats WHERE position(convert_to('load chat ', 'UTF8') in title) = 1),
u AS (SELECT array_agg(id ORDER BY username) AS ids FROM users WHERE username LIKE 'load\_%')
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(),
c.ids[1 + floor(array_length(c.ids, 1) * power(random(), 3))::int],
u.ids[1 + floor(array_length(u.ids, 1) * random())::int],
convert_to('load message ' || g || ' ' || md5(g::text), 'UTF8'),
now() - make_interval(secs => (:to_seed - g) / 100.0)
FROM generate_series(1, :to_seed) AS g, c, u;
SELECT clock_timestamp() - :'seed_started'::timestamptz AS seed_duration,
:to_seed AS seeded_rows,
:total AS target_total,
(SELECT count(*) FROM messages) AS messages_total;
ANALYZE users, chats, chat_members, messages;
+114
View File
@@ -0,0 +1,114 @@
#!/usr/bin/env python3
"""Level 4: session semantics — wrong password, challenges, logout, token quality."""
import json
import uuid
from common import arguments, basic, call, credentials, expect, login, member, register, run
def wrong_password_gives_same_401(base):
actor = register(base, "pw")
name = actor["registration"]["username"]
wrong = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": basic(name, "wrong-password-123")})
unknown = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": basic("u_absent_" + uuid.uuid4().hex[:8], "wrong-password-123")})
expect(wrong["status"] == unknown["status"] == 401, "ожидался 401 в обоих случаях")
expect(wrong["json"]["error"]["code"] == unknown["json"]["error"]["code"] == "unauthorized", "код ошибки отличается")
expect(wrong["headers"].get("WWW-Authenticate", "").startswith("Basic"), "нет Basic challenge")
expect(wrong["json"]["error"]["request_id"] == wrong["headers"].get("X-Request-Id"), "request_id не совпадает с заголовком")
def basic_is_rejected_on_business_endpoints(base):
actor = register(base, "basic")
name = actor["registration"]["username"]
password = actor["registration"]["password"]
result = call(base, "GET", "/api/v1/users/me", headers={"Authorization": basic(name, password)})
expect(result["status"] == 401, "Basic на /users/me вернул %s" % result["status"])
expect(result["headers"].get("WWW-Authenticate", "").startswith("Bearer"), "нет Bearer challenge")
def x_user_id_does_not_authenticate(base):
alice = member(base, "alice")
bob = register(base, "bob")
anonymous = call(base, "GET", "/api/v1/users/me", headers={"X-User-Id": alice["id"]})
expect(anonymous["status"] == 401, "X-User-Id без Bearer дал %s" % anonymous["status"])
overridden = call(base, "GET", "/api/v1/users/me", token=alice["token"], headers={"X-User-Id": bob["id"]})
expect(overridden["status"] == 200 and overridden["json"]["id"] == alice["id"], "X-User-Id подменил владельца сессии")
def logout_revokes_only_its_own_token(base):
actor = member(base, "logout")
second = login(base, dict(actor))
first_token = actor["token"]
revoked = call(base, "DELETE", "/api/v1/auth/sessions/current", token=first_token)
expect(revoked["status"] == 204, "logout вернул %s" % revoked["status"])
expect(call(base, "GET", "/api/v1/users/me", token=first_token)["status"] == 401, "отозванный токен всё ещё работает")
expect(call(base, "DELETE", "/api/v1/auth/sessions/current", token=first_token)["status"] == 401, "повторный logout не 401")
expect(call(base, "GET", "/api/v1/users/me", token=second["token"])["status"] == 200, "logout убил вторую сессию")
def token_is_opaque_and_unique(base):
actor = member(base, "token")
name = actor["registration"]["username"]
expect(len(actor["token"]) >= 32, "токен короче 32 символов")
expect(name not in actor["token"] and actor["id"] not in actor["token"], "токен раскрывает имя или id пользователя")
again = login(base, dict(actor))
expect(again["token"] != actor["token"], "повторный вход выдал тот же токен")
expect(actor["session"]["token_type"] == "Bearer", "token_type не Bearer")
def short_password_is_rejected(base):
body = credentials("short")
body["password"] = "short"
expect(call(base, "POST", "/api/v1/users", body=body)["status"] == 400, "короткий пароль принят")
body = credentials("long")
body["password"] = "x" * 129
expect(call(base, "POST", "/api/v1/users", body=body)["status"] == 400, "пароль длиннее 128 принят")
def password_is_never_returned(base):
actor = member(base, "leak")
expect("password" not in actor["user"] and "password_hash" not in actor["user"], "User содержит пароль")
me = call(base, "GET", "/api/v1/users/me", token=actor["token"])["json"]
expect(set(me) == {"id", "username", "display_name", "created_at"}, "в /users/me лишние поля: %s" % sorted(me))
expect("password" not in str(actor["session"]["user"]), "сессия раскрывает пароль")
def login_rejects_a_request_body(base):
actor = register(base, "body")
header = basic(actor["registration"]["username"], actor["registration"]["password"])
with_body = call(base, "POST", "/api/v1/auth/sessions", body={"username": actor["registration"]["username"]}, headers={"Authorization": header})
expect(with_body["status"] == 400, "вход с JSON-телом дал %s" % with_body["status"])
raw_body = call(base, "POST", "/api/v1/auth/sessions", raw=b"anything", headers={"Authorization": header}, content_type="text/plain")
expect(raw_body["status"] == 400, "вход с произвольным телом дал %s" % raw_body["status"])
clean = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": header})
expect(clean["status"] == 201, "вход без тела дал %s" % clean["status"])
def broken_utf8_credentials_are_rejected(base):
actor = register(base, "utf8")
name = actor["registration"]["username"]
import base64 as b64
header = "Basic " + b64.b64encode(name.encode() + b":" + actor["registration"]["password"].encode() + b"\xff").decode()
result = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": header})
expect(result["status"] == 401, "повреждённый UTF-8 в пароле дал %s" % result["status"])
body = credentials("utf8reg")
bad_body = json.dumps(body, ensure_ascii=False).encode("utf-8").replace(b'"password"', b'"passw\xffrd"')
broken = call(base, "POST", "/api/v1/users", raw=bad_body, content_type="application/json")
expect(broken["status"] == 400, "повреждённый UTF-8 в теле дал %s" % broken["status"])
TESTS = [
wrong_password_gives_same_401,
basic_is_rejected_on_business_endpoints,
x_user_id_does_not_authenticate,
logout_revokes_only_its_own_token,
token_is_opaque_and_unique,
short_password_is_rejected,
password_is_never_returned,
login_rejects_a_request_body,
broken_utf8_credentials_are_rejected,
]
if __name__ == "__main__":
run(TESTS, arguments(__doc__).base_url)
+44
View File
@@ -0,0 +1,44 @@
#!/usr/bin/env python3
"""Level 4: session expiry on a short SESSION_TTL_SECONDS instance."""
import time
from common import arguments, call, expect, member, run
TTL = 2
def session_expires_after_ttl(base):
actor = member(base, "ttl")
alive = call(base, "GET", "/api/v1/users/me", token=actor["token"])
expect(alive["status"] == 200, "свежая сессия дала %s" % alive["status"])
time.sleep(TTL + 2)
expired = call(base, "GET", "/api/v1/users/me", token=actor["token"])
expect(expired["status"] == 401, "истёкшая сессия дала %s" % expired["status"])
expect(expired["headers"].get("WWW-Authenticate", "").startswith("Bearer"), "нет Bearer challenge")
expect(expired["json"]["error"]["code"] == "unauthorized", "код ошибки %s" % expired["json"]["error"]["code"])
def expired_session_cannot_write_or_logout(base):
alice = member(base, "ttlwrite")
bob = member(base, "ttlwrite2")
chat = call(base, "POST", "/api/v1/chats", body={"title": "Срок жизни", "member_ids": [alice["id"], bob["id"]]}, token=alice["token"])
expect(chat["status"] == 201, "создание чата дало %s" % chat["status"])
time.sleep(TTL + 2)
write = call(base, "POST", "/api/v1/chats/%s/messages" % chat["json"]["id"], body={"text": "после истечения"}, token=alice["token"])
expect(write["status"] == 401, "запись истёкшим токеном дала %s" % write["status"])
expect(call(base, "DELETE", "/api/v1/auth/sessions/current", token=alice["token"])["status"] == 401, "logout истёкшим токеном не 401")
def expires_at_matches_configured_ttl(base):
import datetime as dt
actor = member(base, "ttlvalue")
expires_at = dt.datetime.fromisoformat(actor["session"]["expires_at"][:-1] + "+00:00")
remaining = (expires_at - dt.datetime.now(dt.timezone.utc)).total_seconds()
expect(0 < remaining <= TTL + 1, "expires_at обещает %.1f c при TTL=%d" % (remaining, TTL))
TESTS = [session_expires_after_ttl, expired_session_cannot_write_or_logout, expires_at_matches_configured_ttl]
if __name__ == "__main__":
run(TESTS, arguments(__doc__).base_url)
+213
View File
@@ -0,0 +1,213 @@
#!/usr/bin/env python3
"""Level 4/5: revocation must outlive the cache and outages must never grant trust."""
import hashlib
import pathlib
import subprocess
import threading
import time
from common import arguments, call, chat_with, expect, member, run
ROOT = pathlib.Path(__file__).resolve().parents[1]
COMPOSE = ["docker", "compose", "--env-file", ".env"]
def compose(*args):
subprocess.run(COMPOSE + list(args), cwd=str(ROOT), check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
def valkey(*args):
done = subprocess.run(COMPOSE + ["exec", "-T", "valkey", "valkey-cli", *args],
cwd=str(ROOT), capture_output=True, text=True, check=True)
return done.stdout.strip()
def session_key(token):
return "session:" + hashlib.sha256(token.encode("utf-8")).hexdigest()
def session_rows(token):
digest = hashlib.sha256(token.encode("utf-8")).hexdigest()
done = subprocess.run(
COMPOSE + ["exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-t", "-A",
"-c", "select count(*) from sessions where token_hash = '\\x%s'::bytea" % digest],
cwd=str(ROOT), capture_output=True, text=True, check=True)
return int(done.stdout.strip())
def wait_ready(base, seconds=90):
deadline = time.monotonic() + seconds
while time.monotonic() < deadline:
try:
if call(base, "GET", "/health/ready")["status"] == 200:
return
except AssertionError:
pass
time.sleep(0.5)
raise AssertionError("API не стал ready за %d с" % seconds)
def revoked_session_stays_revoked_after_cache_restart(base):
actor = member(base, "revoke")
expect(call(base, "GET", "/api/v1/users/me", token=actor["token"])["status"] == 200, "свежая сессия не работает")
expect(call(base, "DELETE", "/api/v1/auth/sessions/current", token=actor["token"])["status"] == 204, "logout не вернул 204")
compose("restart", "valkey")
wait_ready(base)
after = call(base, "GET", "/api/v1/users/me", token=actor["token"])
expect(after["status"] == 401, "отозванная сессия вернула доступ после рестарта кэша: %s" % after["status"])
def logout_is_not_confirmed_while_cache_is_down(base):
actor = member(base, "logoutdown")
expect(call(base, "GET", "/api/v1/users/me", token=actor["token"])["status"] == 200, "свежая сессия не работает")
compose("stop", "valkey")
try:
refused = call(base, "DELETE", "/api/v1/auth/sessions/current", token=actor["token"])
expect(refused["status"] == 503, "logout без кэша дал %s вместо 503" % refused["status"])
still = call(base, "GET", "/api/v1/users/me", token=actor["token"])
expect(still["status"] == 200, "сессия не отозвана, но доступ уже потерян: %s" % still["status"])
finally:
compose("start", "valkey")
wait_ready(base)
expect(call(base, "DELETE", "/api/v1/auth/sessions/current", token=actor["token"])["status"] == 204, "повторный logout не прошёл")
expect(call(base, "GET", "/api/v1/users/me", token=actor["token"])["status"] == 401, "после подтверждённого logout токен жив")
def cached_sessions_do_not_cross_users(base):
alice = member(base, "cross")
bob = member(base, "cross2")
for _ in range(3):
first = call(base, "GET", "/api/v1/users/me", token=alice["token"])["json"]
second = call(base, "GET", "/api/v1/users/me", token=bob["token"])["json"]
expect(first == alice["user"] and second == bob["user"], "кэш отдал не того владельца сессии: %r / %r" % (first, second))
chat = chat_with(base, alice, bob)
sent = call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": "от боба"}, token=bob["token"])
expect(sent["json"]["sender_id"] == bob["id"], "sender_id взят не из сессии")
def hung_database_fails_fast(base):
actor = member(base, "hang")
compose("pause", "postgres")
try:
started = time.monotonic()
result = call(base, "GET", "/api/v1/chats", token=actor["token"], timeout=60)
elapsed = time.monotonic() - started
expect(result["status"] == 503, "зависшая БД дала %s вместо 503" % result["status"])
expect(elapsed < 10, "ответ пришёл за %.1f с при заявленном клиентском лимите 6 с" % elapsed)
ready = call(base, "GET", "/health/ready", timeout=60)
expect(ready["status"] == 503, "/health/ready при зависшей БД дал %s" % ready["status"])
expect(call(base, "GET", "/health/live", timeout=60)["status"] == 200, "/health/live упал вместе с БД")
finally:
compose("unpause", "postgres")
wait_ready(base)
expect(call(base, "GET", "/api/v1/chats", token=actor["token"])["status"] == 200, "после возврата БД доступ не восстановился")
def cache_is_repopulated_after_a_miss(base):
actor = member(base, "miss")
key = session_key(actor["token"])
cached = call(base, "GET", "/api/v1/users/me", token=actor["token"])
expect(cached["status"] == 200, "свежая сессия дала %s" % cached["status"])
expect(valkey("exists", key) == "1", "после входа сессии нет в кэше")
expect(valkey("del", key) == "1", "ключ сессии не удалился")
served = call(base, "GET", "/api/v1/users/me", token=actor["token"])
expect(served["status"] == 200, "после промаха кэша ответ %s" % served["status"])
expect(served["json"] == cached["json"], "тело из PostgreSQL отличается от кэшированного: %r против %r" % (served["json"], cached["json"]))
expect(valkey("exists", key) == "1", "кэш не наполнился после промаха")
ttl = int(valkey("ttl", key))
expect(ttl > 0, "у восстановленного ключа нет срока жизни: ttl=%d" % ttl)
again = call(base, "GET", "/api/v1/users/me", token=actor["token"])
expect(again["json"] == cached["json"], "ответ из восстановленного кэша отличается: %r" % again["json"])
def cache_survives_its_own_restart(base):
actor = member(base, "warm")
expected = call(base, "GET", "/api/v1/users/me", token=actor["token"])["json"]
compose("restart", "valkey")
wait_ready(base)
key = session_key(actor["token"])
expect(valkey("exists", key) == "0", "кэш переживает рестарт, хотя persistence выключен")
after = call(base, "GET", "/api/v1/users/me", token=actor["token"])
expect(after["status"] == 200 and after["json"] == expected, "после рестарта кэша ответ изменился: %r" % after["json"])
expect(valkey("exists", key) == "1", "после рестарта кэш больше не наполняется")
def revoked_session_cannot_be_resurrected_by_a_race(base):
actor = member(base, "race")
token = actor["token"]
key = session_key(token)
digest = hashlib.sha256(token.encode("utf-8")).hexdigest()
expect(call(base, "GET", "/api/v1/users/me", token=token)["status"] == 200, "свежая сессия не работает")
expect(valkey("exists", key) == "1", "после входа сессии нет в кэше")
holder = subprocess.Popen(
COMPOSE + ["exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-X", "-q"],
cwd=str(ROOT), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True,
)
holder.stdin.write("BEGIN;\nSELECT 1 FROM sessions WHERE token_hash = '\\x%s'::bytea FOR UPDATE;\n" % digest)
holder.stdin.flush()
time.sleep(0.5)
outcome = {}
def logout():
outcome["status"] = call(base, "DELETE", "/api/v1/auth/sessions/current", token=token, timeout=30)["status"]
worker = threading.Thread(target=logout)
worker.start()
try:
deadline = time.monotonic() + 5
while time.monotonic() < deadline and valkey("get", key).startswith("{"):
time.sleep(0.05)
during = call(base, "GET", "/api/v1/users/me", token=token)
finally:
holder.stdin.write("COMMIT;\n\\q\n")
holder.stdin.flush()
holder.wait(timeout=15)
worker.join(timeout=30)
expect(outcome.get("status") == 204, "logout вернул %s вместо 204" % outcome.get("status"))
after = call(base, "GET", "/api/v1/users/me", token=token)
expect(after["status"] == 401,
"после подтверждённого logout токен ожил: /users/me дал %s, ttl ключа %s (запрос во время гонки дал %s)"
% (after["status"], valkey("ttl", key), during["status"]))
wrote = call(base, "GET", "/api/v1/chats", token=token)
expect(wrote["status"] == 401, "отозванный токен всё ещё читает список чатов: %s" % wrote["status"])
def failed_logout_leaves_cache_and_database_consistent(base):
actor = member(base, "rollback")
token = actor["token"]
key = session_key(token)
expect(call(base, "GET", "/api/v1/users/me", token=token)["status"] == 200, "свежая сессия не работает")
compose("pause", "postgres")
try:
refused = call(base, "DELETE", "/api/v1/auth/sessions/current", token=token, timeout=60)
expect(refused["status"] == 503, "logout при недоступной базе дал %s вместо 503" % refused["status"])
finally:
compose("unpause", "postgres")
wait_ready(base)
expect(valkey("get", key) != "revoked", "неподтверждённый logout оставил надгробие в кэше")
rows = session_rows(token)
answer = call(base, "GET", "/api/v1/users/me", token=token)["status"]
if rows == 1:
expect(answer == 200, "строка сессии в базе есть, но API отвечает %s" % answer)
expect(call(base, "DELETE", "/api/v1/auth/sessions/current", token=token)["status"] == 204, "повторный logout не прошёл")
expect(call(base, "GET", "/api/v1/users/me", token=token)["status"] == 401, "после подтверждённого logout токен жив")
else:
expect(answer == 401, "строки сессии в базе нет, но API отвечает %s" % answer)
TESTS = [
revoked_session_stays_revoked_after_cache_restart,
logout_is_not_confirmed_while_cache_is_down,
cached_sessions_do_not_cross_users,
cache_is_repopulated_after_a_miss,
cache_survives_its_own_restart,
revoked_session_cannot_be_resurrected_by_a_race,
failed_logout_leaves_cache_and_database_consistent,
hung_database_fails_fast,
]
if __name__ == "__main__":
run(TESTS, arguments(__doc__).base_url)
+242
View File
@@ -0,0 +1,242 @@
#!/usr/bin/env python3
"""Level 4: PostgreSQL rules — username race, transaction rollback, keyset paging, injection."""
import threading
import uuid
from urllib.parse import quote
from common import arguments, call, chat_with, credentials, expect, member, run
RACE_CLIENTS = 12
def duplicate_username_race_creates_one_user(base):
body = credentials("race")
results = []
lock = threading.Lock()
ready = threading.Barrier(RACE_CLIENTS)
def attempt():
ready.wait()
result = call(base, "POST", "/api/v1/users", body=body)
with lock:
results.append(result["status"])
threads = [threading.Thread(target=attempt) for _ in range(RACE_CLIENTS)]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
created = results.count(201)
conflicts = results.count(409)
expect(created == 1, "создано %d пользователей с одним username (ожидался 1): %s" % (created, results))
expect(created + conflicts == RACE_CLIENTS, "неожиданные ответы в гонке: %s" % results)
def unknown_member_rolls_chat_back(base):
alice = member(base, "rollback")
title = "Откат " + uuid.uuid4().hex[:8]
body = {"title": title, "member_ids": [alice["id"], str(uuid.uuid4())]}
result = call(base, "POST", "/api/v1/chats", body=body, token=alice["token"])
expect(result["status"] == 400, "неизвестный участник дал %s" % result["status"])
listed = call(base, "GET", "/api/v1/chats?limit=100", token=alice["token"])["json"]
expect(all(chat["title"] != title for chat in listed["items"]), "чат остался в базе после отката")
def keyset_pagination_is_complete(base):
alice = member(base, "pages")
bob = member(base, "pages2")
chat = chat_with(base, alice, bob)
total = 25
for index in range(total):
result = call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": "сообщение %d" % index}, token=alice["token"])
expect(result["status"] == 201, "отправка %d вернула %s" % (index, result["status"]))
seen = []
cursor = None
for _ in range(total):
path = "/api/v1/chats/%s/messages?limit=7" % chat["id"]
if cursor:
path += "&cursor=" + quote(cursor, safe="")
page = call(base, "GET", path, token=bob["token"])["json"]
seen.extend(page["items"])
cursor = page["next_cursor"]
if cursor is None:
break
expect(cursor is None, "обход истории не завершился")
ids = [item["id"] for item in seen]
expect(len(ids) == total, "прочитано %d сообщений из %d" % (len(ids), total))
expect(len(set(ids)) == total, "в обходе есть повторы")
keys = [(item["created_at"], uuid.UUID(item["id"]).int) for item in seen]
expect(keys == sorted(keys), "порядок (created_at, id) нарушен")
def cursor_is_bound_to_its_chat(base):
alice = member(base, "cursor")
bob = member(base, "cursor2")
first = chat_with(base, alice, bob)
second = chat_with(base, alice, bob)
for chat in (first, second):
for index in range(3):
call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": "текст %d" % index}, token=alice["token"])
page = call(base, "GET", "/api/v1/chats/%s/messages?limit=1" % first["id"], token=alice["token"])["json"]
expect(page["next_cursor"], "нет курсора для проверки")
foreign = call(base, "GET", "/api/v1/chats/%s/messages?limit=1&cursor=%s" % (second["id"], quote(page["next_cursor"], safe="")), token=alice["token"])
expect(foreign["status"] == 400, "курсор другого чата принят: %s" % foreign["status"])
tampered = page["next_cursor"][:-2] + ("aa" if not page["next_cursor"].endswith("aa") else "bb")
altered = call(base, "GET", "/api/v1/chats/%s/messages?cursor=%s" % (first["id"], quote(tampered, safe="")), token=alice["token"])
expect(altered["status"] == 400, "изменённый курсор принят: %s" % altered["status"])
def limit_bounds_are_enforced(base):
alice = member(base, "limit")
bob = member(base, "limit2")
chat = chat_with(base, alice, bob)
for value in ("0", "101", "abc", "-1", "1.5", ""):
result = call(base, "GET", "/api/v1/chats/%s/messages?limit=%s" % (chat["id"], quote(value, safe="")), token=alice["token"])
expect(result["status"] == 400, "limit=%r дал %s" % (value, result["status"]))
valid = call(base, "GET", "/api/v1/chats/%s/messages?limit=100" % chat["id"], token=alice["token"])
expect(valid["status"] == 200, "limit=100 дал %s" % valid["status"])
def sql_injection_is_not_executed(base):
probes = ["ad'; DROP TABLE users; --", "' OR '1'='1", "admin\"--", "ad\\'; SELECT 1"]
for probe in probes:
body = credentials("inj")
body["username"] = probe
result = call(base, "POST", "/api/v1/users", body=body)
expect(result["status"] == 400, "username %r дал %s" % (probe, result["status"]))
alice = member(base, "after")
bob = member(base, "after2")
chat = chat_with(base, alice, bob)
text = "текст с кавычкой ' и ; DROP TABLE messages; --"
created = call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": text}, token=alice["token"])
expect(created["status"] == 201 and created["json"]["text"] == text, "текст с кавычками испорчен или отклонён")
history = call(base, "GET", "/api/v1/chats/%s/messages" % chat["id"], token=bob["token"])["json"]
expect(any(item["text"] == text for item in history["items"]), "сообщение не читается после вставки")
def malformed_requests_are_rejected(base):
alice = member(base, "shape")
bob = member(base, "shape2")
chat = chat_with(base, alice, bob)
path = "/api/v1/chats/%s/messages" % chat["id"]
expect(call(base, "POST", path, body={"text": "ок", "sender_id": alice["id"]}, token=alice["token"])["status"] == 400, "лишнее поле принято")
expect(call(base, "POST", path, body={}, token=alice["token"])["status"] == 400, "пустой объект принят")
expect(call(base, "POST", path, body={"text": " "}, token=alice["token"])["status"] == 400, "пробельный текст принят")
expect(call(base, "POST", path, body={"text": "x" * 4001}, token=alice["token"])["status"] == 400, "текст длиннее 4000 принят")
expect(call(base, "GET", "/api/v1/chats/not-a-uuid", token=alice["token"])["status"] == 400, "неверный UUID дал не 400")
expect(call(base, "GET", "/api/v1/chats/%s" % uuid.uuid4(), token=alice["token"])["status"] == 404, "чужой чат дал не 404")
def nul_and_unicode_text_round_trips(base):
alice = member(base, "unicode")
bob = member(base, "unicode2")
chat = chat_with(base, alice, bob)
path = "/api/v1/chats/%s/messages" % chat["id"]
samples = [
"a\u0000b",
"\u0000",
"emoji \U0001f44b и ZWJ \U0001f469\u200d\U0001f4bb",
"комбинация e\u0301 и RTL \u05d0\u05d1",
"край \u0007\u001b\u007f",
]
created = []
for sample in samples:
result = call(base, "POST", path, body={"text": sample}, token=alice["token"])
expect(result["status"] == 201, "текст %r дал %s" % (sample, result["status"]))
expect(result["json"]["text"] == sample, "текст изменён при записи: %r -> %r" % (sample, result["json"]["text"]))
created.append(result["json"])
history = call(base, "GET", path + "?limit=100", token=bob["token"])["json"]["items"]
by_id = {item["id"]: item["text"] for item in history}
for item in created:
expect(by_id.get(item["id"]) == item["text"], "текст изменён при чтении: %r" % item["text"])
def text_length_limit_counts_code_points(base):
alice = member(base, "length")
bob = member(base, "length2")
chat = chat_with(base, alice, bob)
path = "/api/v1/chats/%s/messages" % chat["id"]
exact = "\U0001f600" * 4000
result = call(base, "POST", path, body={"text": exact}, token=alice["token"])
expect(result["status"] == 201, "4000 code points дали %s" % result["status"])
expect(result["json"]["text"] == exact, "текст на границе изменён")
over = call(base, "POST", path, body={"text": "\U0001f600" * 4001}, token=alice["token"])
expect(over["status"] == 400, "4001 code point дал %s" % over["status"])
def unicode_blanks_are_rejected(base):
alice = member(base, "blank")
bob = member(base, "blank2")
chat = chat_with(base, alice, bob)
path = "/api/v1/chats/%s/messages" % chat["id"]
blanks = [" ", "\t\n", "\u00a0", "\u2007", "\u3000", "\u200b", "\u200b \u200b", "\ufeff"]
for blank in blanks:
result = call(base, "POST", path, body={"text": blank}, token=alice["token"])
expect(result["status"] == 400, "пробельный текст %r дал %s" % (blank, result["status"]))
for field in ("display_name",):
body = credentials("blank")
body[field] = "\u200b"
expect(call(base, "POST", "/api/v1/users", body=body)["status"] == 400, "пустой %s принят" % field)
titles = call(base, "POST", "/api/v1/chats", body={"title": "\u00a0", "member_ids": [alice["id"]]}, token=alice["token"])
expect(titles["status"] == 400, "пробельный title принят: %s" % titles["status"])
def broken_json_does_not_break_the_api(base):
alice = member(base, "json")
bob = member(base, "json2")
chat = chat_with(base, alice, bob)
path = "/api/v1/chats/%s/messages" % chat["id"]
payloads = [
b'{"text": 1e999}',
b'{"text": NaN}',
b'{"text": Infinity}',
b'{"text": 1e+}',
b'{"text": ' + b"9" * 5000 + b"}",
b'{"text": ' + b"[" * 2000 + b"]" * 2000 + b"}",
b"[" * 2000,
b'{"text": {"text": "nested object"}}',
b'{"text": "\xff\xfe"}',
b"",
b"{",
]
for payload in payloads:
result = call(base, "POST", path, raw=payload, token=alice["token"], content_type="application/json")
expect(result["status"] == 400, "тело %r дало %s" % (payload[:24], result["status"]))
alive = call(base, "POST", path, body={"text": "после битого JSON"}, token=alice["token"])
expect(alive["status"] == 201, "API не отвечает после битых тел: %s" % alive["status"])
def content_type_is_required(base):
alice = member(base, "ctype")
bob = member(base, "ctype2")
chat = chat_with(base, alice, bob)
path = "/api/v1/chats/%s/messages" % chat["id"]
for content_type in ("text/plain", "application/x-www-form-urlencoded", "", "application/jsonx"):
result = call(base, "POST", path, raw=b'{"text":"x"}', token=alice["token"], content_type=content_type)
expect(result["status"] == 415, "Content-Type %r дал %s" % (content_type, result["status"]))
body = credentials("ctype")
import json as jsonlib
plain = call(base, "POST", "/api/v1/users", raw=jsonlib.dumps(body).encode(), content_type="text/plain")
expect(plain["status"] == 415, "регистрация с text/plain дала %s" % plain["status"])
charset = call(base, "POST", path, raw=b'{"text":"charset"}', token=alice["token"], content_type="application/json; charset=utf-8")
expect(charset["status"] == 201, "application/json с charset дал %s" % charset["status"])
TESTS = [
duplicate_username_race_creates_one_user,
unknown_member_rolls_chat_back,
keyset_pagination_is_complete,
cursor_is_bound_to_its_chat,
limit_bounds_are_enforced,
sql_injection_is_not_executed,
malformed_requests_are_rejected,
nul_and_unicode_text_round_trips,
text_length_limit_counts_code_points,
unicode_blanks_are_rejected,
broken_json_does_not_break_the_api,
content_type_is_required,
]
if __name__ == "__main__":
run(TESTS, arguments(__doc__).base_url)
+32
View File
@@ -0,0 +1,32 @@
#!/usr/bin/env python3
"""Level 4: the API keeps working from PostgreSQL while the session cache is down."""
from common import arguments, call, chat_with, expect, member, run
def login_and_read_work_without_cache(base):
alice = member(base, "nocache")
bob = member(base, "nocache2")
me = call(base, "GET", "/api/v1/users/me", token=alice["token"])
expect(me["status"] == 200 and me["json"]["id"] == alice["id"], "/users/me без кэша дал %s" % me["status"])
chat = chat_with(base, alice, bob)
sent = call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": "кэш выключен"}, token=alice["token"])
expect(sent["status"] == 201, "запись без кэша дала %s" % sent["status"])
history = call(base, "GET", "/api/v1/chats/%s/messages" % chat["id"], token=bob["token"])
expect(history["status"] == 200, "чтение без кэша дало %s" % history["status"])
expect(any(item["id"] == sent["json"]["id"] for item in history["json"]["items"]), "сообщение не видно без кэша")
def unknown_token_is_still_rejected(base):
expect(call(base, "GET", "/api/v1/users/me", token="definitely-not-a-valid-session-token")["status"] == 401, "неизвестный токен принят")
expect(call(base, "GET", "/api/v1/users/me")["status"] == 401, "анонимный запрос принят")
def readiness_ignores_the_cache(base):
ready = call(base, "GET", "/health/ready")
expect(ready["status"] == 200, "/health/ready без кэша дал %s" % ready["status"])
TESTS = [login_and_read_work_without_cache, unknown_token_is_still_rejected, readiness_ignores_the_cache]
if __name__ == "__main__":
run(TESTS, arguments(__doc__).base_url)
+41
View File
@@ -0,0 +1,41 @@
#!/usr/bin/env python3
"""Level 4: with PostgreSQL stopped the API degrades to a bounded error, never to trust."""
import uuid
from common import arguments, call, expect, run
def readiness_reports_the_outage(base):
ready = call(base, "GET", "/health/ready")
expect(ready["status"] == 503, "/health/ready без БД дал %s" % ready["status"])
expect(ready["json"]["error"]["code"] == "unavailable", "код ошибки %s" % ready["json"]["error"]["code"])
live = call(base, "GET", "/health/live")
expect(live["status"] == 200, "/health/live без БД дал %s" % live["status"])
def writes_fail_with_503(base):
body = {"username": "u_nodb_" + uuid.uuid4().hex[:8], "display_name": "Без БД", "password": "T3st-" + uuid.uuid4().hex}
created = call(base, "POST", "/api/v1/users", body=body)
expect(created["status"] == 503, "регистрация без БД дала %s" % created["status"])
def unknown_token_never_becomes_trusted(base):
for token in ("definitely-not-a-valid-session-token", uuid.uuid4().hex):
result = call(base, "GET", "/api/v1/users/me", token=token)
expect(result["status"] in (401, 503), "неизвестный токен без БД дал %s" % result["status"])
anonymous = call(base, "GET", "/api/v1/chats", token=None)
expect(anonymous["status"] == 401, "анонимный запрос без БД дал %s" % anonymous["status"])
def login_fails_closed(base):
import base64
header = "Basic " + base64.b64encode(b"u_any_user:any-password-123").decode()
result = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": header})
expect(result["status"] in (401, 503), "вход без БД дал %s" % result["status"])
TESTS = [readiness_reports_the_outage, writes_fail_with_503, unknown_token_never_becomes_trusted, login_fails_closed]
if __name__ == "__main__":
run(TESTS, arguments(__doc__).base_url)
+113
View File
@@ -0,0 +1,113 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
TOTAL=${TOTAL:-120000}
IMAGE=postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2
RNAME=mtusi-lab2-restore
RVOL=mtusi-lab2-restore-data
PSQL="docker compose --env-file .env exec -T postgres psql -U messenger -d messenger -X -q"
RPSQL="docker exec -i $RNAME psql -U messenger -d messenger_restored -X -q"
STAMP=$(date +%Y%m%d-%H%M%S)
DUMP="backups/messenger-$STAMP.dump"
now_ms() {
python3 -c 'import time; print(int(time.time() * 1000))'
}
elapsed() {
python3 -c "print('%.3f' % ((int('$2') - int('$1')) / 1000.0))"
}
cleanup() {
if [ "${KEEP:-0}" != "1" ]; then
docker rm -f "$RNAME" >/dev/null 2>&1 || true
docker volume rm "$RVOL" >/dev/null 2>&1 || true
fi
}
trap cleanup EXIT
mkdir -p backups
echo "=== Стенд и версии ==="
docker compose --env-file .env ps --format '{{.Service}} {{.Image}} {{.Status}}'
uname -sm
docker --version
echo
echo "=== 1. Засев истории: цель $TOTAL сообщений, чаты неравномерные ==="
$PSQL -v total="$TOTAL" -f - < student-tests/seed.sql
echo
echo "=== 2. Сравнение индексов и цены записи (каждый вариант в откатываемой транзакции) ==="
$PSQL -f - < student-tests/track2_indexes.sql
BIG_CHAT=$($PSQL -t -A -c "SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1")
echo
echo "Самый большой чат: $BIG_CHAT"
echo
echo "=== 3. Состояние источника до бэкапа ==="
$PSQL -v big_chat="$BIG_CHAT" -f - < student-tests/track2_verify.sql
echo
echo "=== 4. Бэкап pg_dump -Fc ==="
BACKUP_START=$(now_ms)
docker compose --env-file .env exec -T postgres pg_dump -U messenger -d messenger -Fc > "$DUMP"
BACKUP_END=$(now_ms)
echo "backup_seconds=$(elapsed "$BACKUP_START" "$BACKUP_END")"
echo "dump_size=$(du -h "$DUMP" | cut -f1)"
echo
echo "=== 5. Запись после бэкапа: граница потери данных ==="
$PSQL -c "INSERT INTO messages (id, chat_id, sender_id, text, created_at) SELECT gen_random_uuid(), '$BIG_CHAT', sender_id, convert_to('marker after backup $STAMP', 'UTF8'), clock_timestamp() FROM messages WHERE chat_id = '$BIG_CHAT' LIMIT 1"
$PSQL -t -A -c "SELECT 'в источнике маркеров: ' || count(*) FROM messages WHERE position(convert_to('marker after backup', 'UTF8') in text) = 1"
echo
echo "=== 6. Новое хранилище: отдельный контейнер и отдельный том ==="
docker volume create "$RVOL" >/dev/null
docker run -d --name "$RNAME" \
-e POSTGRES_USER=messenger \
-e POSTGRES_DB=messenger_restored \
-e POSTGRES_PASSWORD_FILE=/run/secrets/postgres_password \
-v "$PWD/secrets/postgres_password:/run/secrets/postgres_password:ro" \
-v "$RVOL:/var/lib/postgresql/data" \
"$IMAGE" >/dev/null
i=0
while [ "$i" -lt 60 ]; do
if docker exec "$RNAME" pg_isready -U messenger -d messenger_restored >/dev/null 2>&1; then break; fi
i=$((i + 1))
sleep 1
done
docker exec "$RNAME" pg_isready -U messenger -d messenger_restored
echo
echo "=== 7. Восстановление в новое хранилище ==="
docker cp "$DUMP" "$RNAME:/tmp/restore.dump" >/dev/null
RESTORE_START=$(now_ms)
docker exec "$RNAME" pg_restore -U messenger -d messenger_restored --no-owner --exit-on-error /tmp/restore.dump
RESTORE_END=$(now_ms)
echo "restore_seconds=$(elapsed "$RESTORE_START" "$RESTORE_END")"
echo
echo "=== 8. Сверка восстановленной копии ==="
$RPSQL -v big_chat="$BIG_CHAT" -f - < student-tests/track2_verify.sql
echo
echo "=== 9. Итог ==="
SRC_MD5=$($PSQL -t -A -c "SELECT md5(string_agg(id::text || '|' || created_at::text || '|' || encode(text, 'hex'), E'\n' ORDER BY created_at, id)) FROM messages WHERE chat_id = '$BIG_CHAT' AND position(convert_to('marker after backup', 'UTF8') in text) <> 1")
DST_MD5=$($RPSQL -t -A -c "SELECT md5(string_agg(id::text || '|' || created_at::text || '|' || encode(text, 'hex'), E'\n' ORDER BY created_at, id)) FROM messages WHERE chat_id = '$BIG_CHAT'")
SRC_ROWS=$($PSQL -t -A -c "SELECT count(*) FROM messages WHERE position(convert_to('marker after backup', 'UTF8') in text) <> 1")
DST_ROWS=$($RPSQL -t -A -c "SELECT count(*) FROM messages")
echo "backup_seconds=$(elapsed "$BACKUP_START" "$BACKUP_END") restore_seconds=$(elapsed "$RESTORE_START" "$RESTORE_END")"
echo "messages_source_without_marker=$SRC_ROWS messages_restored=$DST_ROWS"
echo "big_chat_md5_source=$SRC_MD5"
echo "big_chat_md5_restored=$DST_MD5"
if [ "$SRC_MD5" = "$DST_MD5" ] && [ "$SRC_ROWS" = "$DST_ROWS" ]; then
echo "RESULT: восстановленная копия совпадает с источником на момент бэкапа"
else
echo "RESULT: расхождение, смотри таблицы выше"
exit 1
fi
MARKERS=$($RPSQL -t -A -c "SELECT count(*) FROM messages WHERE position(convert_to('marker after backup', 'UTF8') in text) = 1")
echo "маркеров после бэкапа в восстановленной копии: $MARKERS (ожидается 0: всё, что подтверждено после снимка, в дампе отсутствует)"
+104
View File
@@ -0,0 +1,104 @@
\set ON_ERROR_STOP on
SELECT count(*) AS messages_total FROM messages;
SELECT chat_id AS big_chat, count(*) AS big_rows
FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1 \gset
SELECT created_at AS cur_ts, id AS cur_id
FROM messages WHERE chat_id = :'big_chat'
ORDER BY created_at, id OFFSET (:'big_rows'::bigint * 9 / 10) LIMIT 1 \gset
\echo '############ Вариант A: messages_history_idx (chat_id, created_at, id) ############'
BEGIN;
ANALYZE messages;
SELECT pg_size_pretty(pg_relation_size('messages_history_idx')) AS index_size;
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid)
ORDER BY created_at, id LIMIT 50;
SELECT clock_timestamp() AS q0 \gset
SELECT count(*) AS pages_measured FROM generate_series(1, 100) AS g,
LATERAL (
SELECT id FROM messages
WHERE chat_id = :'big_chat'
AND (created_at, id) > (:'cur_ts'::timestamptz + make_interval(secs => g * 0.001), :'cur_id'::uuid)
ORDER BY created_at, id LIMIT 50
) AS page;
SELECT clock_timestamp() - :'q0'::timestamptz AS hundred_pages_duration;
SELECT clock_timestamp() AS t0 \gset
WITH c AS (SELECT array_agg(id ORDER BY title) AS ids FROM chats WHERE position(convert_to('load chat ', 'UTF8') in title) = 1),
u AS (SELECT array_agg(id ORDER BY username) AS ids FROM users WHERE username LIKE 'load\_%')
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(),
c.ids[1 + floor(array_length(c.ids, 1) * power(random(), 3))::int],
u.ids[1 + floor(array_length(u.ids, 1) * random())::int],
convert_to('write cost A ' || g, 'UTF8'), now()
FROM generate_series(1, 10000) AS g, c, u;
SELECT clock_timestamp() - :'t0'::timestamptz AS insert_10k_duration;
ROLLBACK;
\echo '############ Вариант B: только (chat_id) ############'
BEGIN;
DROP INDEX messages_history_idx;
CREATE INDEX messages_chat_only_idx ON messages (chat_id);
ANALYZE messages;
SELECT pg_size_pretty(pg_relation_size('messages_chat_only_idx')) AS index_size;
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid)
ORDER BY created_at, id LIMIT 50;
SELECT clock_timestamp() AS q0 \gset
SELECT count(*) AS pages_measured FROM generate_series(1, 100) AS g,
LATERAL (
SELECT id FROM messages
WHERE chat_id = :'big_chat'
AND (created_at, id) > (:'cur_ts'::timestamptz + make_interval(secs => g * 0.001), :'cur_id'::uuid)
ORDER BY created_at, id LIMIT 50
) AS page;
SELECT clock_timestamp() - :'q0'::timestamptz AS hundred_pages_duration;
SELECT clock_timestamp() AS t0 \gset
WITH c AS (SELECT array_agg(id ORDER BY title) AS ids FROM chats WHERE position(convert_to('load chat ', 'UTF8') in title) = 1),
u AS (SELECT array_agg(id ORDER BY username) AS ids FROM users WHERE username LIKE 'load\_%')
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(),
c.ids[1 + floor(array_length(c.ids, 1) * power(random(), 3))::int],
u.ids[1 + floor(array_length(u.ids, 1) * random())::int],
convert_to('write cost B ' || g, 'UTF8'), now()
FROM generate_series(1, 10000) AS g, c, u;
SELECT clock_timestamp() - :'t0'::timestamptz AS insert_10k_duration;
ROLLBACK;
\echo '############ Вариант C: (chat_id, created_at, id) INCLUDE (sender_id, text) ############'
BEGIN;
DROP INDEX messages_history_idx;
CREATE INDEX messages_history_covering_idx ON messages (chat_id, created_at, id) INCLUDE (sender_id, text);
ANALYZE messages;
SELECT pg_size_pretty(pg_relation_size('messages_history_covering_idx')) AS index_size;
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid)
ORDER BY created_at, id LIMIT 50;
SELECT clock_timestamp() AS q0 \gset
SELECT count(*) AS pages_measured FROM generate_series(1, 100) AS g,
LATERAL (
SELECT id FROM messages
WHERE chat_id = :'big_chat'
AND (created_at, id) > (:'cur_ts'::timestamptz + make_interval(secs => g * 0.001), :'cur_id'::uuid)
ORDER BY created_at, id LIMIT 50
) AS page;
SELECT clock_timestamp() - :'q0'::timestamptz AS hundred_pages_duration;
SELECT clock_timestamp() AS t0 \gset
WITH c AS (SELECT array_agg(id ORDER BY title) AS ids FROM chats WHERE position(convert_to('load chat ', 'UTF8') in title) = 1),
u AS (SELECT array_agg(id ORDER BY username) AS ids FROM users WHERE username LIKE 'load\_%')
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(),
c.ids[1 + floor(array_length(c.ids, 1) * power(random(), 3))::int],
u.ids[1 + floor(array_length(u.ids, 1) * random())::int],
convert_to('write cost C ' || g, 'UTF8'), now()
FROM generate_series(1, 10000) AS g, c, u;
SELECT clock_timestamp() - :'t0'::timestamptz AS insert_10k_duration;
ROLLBACK;
\echo '############ Схема после эксперимента (ROLLBACK вернул индексы) ############'
SELECT indexname FROM pg_indexes WHERE tablename = 'messages' ORDER BY indexname;
+17
View File
@@ -0,0 +1,17 @@
\set ON_ERROR_STOP on
SELECT 'users' AS relation, count(*) AS rows FROM users
UNION ALL SELECT 'chats', count(*) FROM chats
UNION ALL SELECT 'chat_members', count(*) FROM chat_members
UNION ALL SELECT 'messages', count(*) FROM messages
UNION ALL SELECT 'sessions', count(*) FROM sessions
ORDER BY relation;
SELECT count(*) AS big_chat_rows,
md5(string_agg(id::text || '|' || created_at::text || '|' || encode(text, 'hex'), E'\n' ORDER BY created_at, id)) AS big_chat_md5
FROM messages WHERE chat_id = :'big_chat';
SELECT id, created_at, left(encode(text, 'escape'), 40) AS text FROM messages
WHERE chat_id = :'big_chat' ORDER BY created_at, id LIMIT 3;
SELECT count(*) AS marker_rows FROM messages WHERE position(convert_to('marker after backup', 'UTF8') in text) = 1;