ЛР2: PostgreSQL, сессии Bearer, кэш Valkey, Compose, исследование индексов и backup

This commit is contained in:
kolya5544
2026-10-03 05:10:45 +03:00
parent 65003b6119
commit 078c9f5f78
29 changed files with 2282 additions and 20 deletions
+6
View File
@@ -18,3 +18,9 @@ __pycache__
node_modules
evidence
.DS_Store
research
student-tests
scripts
docs
requirements-research.txt
*.md
+8 -5
View File
@@ -1,11 +1,14 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
# Секреты (пароль БД, DATABASE_URL) создаёт scripts/init-secrets.sh в каталоге secrets/ — не в .env.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
# Срок жизни сессии; для проверки expiry запускайте с SESSION_TTL_SECONDS=2 (см. student-tests/test_expiry.sh)
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
# TTL записи в кэше Valkey (не больше остатка жизни сессии)
SESSION_CACHE_TTL_SECONDS=60
# Источник сессий: PostgreSQL (истина) + Valkey (кэш). Адрес кэша задан в compose.yaml (VALKEY_URL).
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
DB_POOL_MAX=10
# Файлы секретов внутри контейнера (создаются scripts/init-secrets.sh)
DATABASE_URL_FILE=/run/secrets/database_url
+29
View File
@@ -0,0 +1,29 @@
# syntax=docker/dockerfile:1
# Базовый образ закреплён тегом и digest (python 3.12.12, Debian bookworm).
ARG PYTHON_IMAGE=python:3.12.12-slim-bookworm@sha256:593bd06efe90efa80dc4eee3948be7c0fde4134606dd40d8dd8dbcade98e669c
# --- сборка зависимостей в отдельном слое (в runtime не попадают pip и кэш) ---
FROM ${PYTHON_IMAGE} AS builder
ENV PIP_DISABLE_PIP_VERSION_CHECK=1 PIP_NO_CACHE_DIR=1
WORKDIR /build
COPY requirements.txt .
RUN python -m venv /opt/venv && /opt/venv/bin/pip install -r requirements.txt
# --- runtime ---
FROM ${PYTHON_IMAGE}
ENV PATH=/opt/venv/bin:$PATH \
PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=/srv/src \
APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab LIMIT_CONCURRENCY=1000 MIGRATIONS_DIR=/srv/migrations
RUN groupadd --system --gid 10001 app && useradd --system --uid 10001 --gid app --no-create-home app
COPY --from=builder /opt/venv /opt/venv
WORKDIR /srv
COPY src/ /srv/src/
COPY migrations/ /srv/migrations/
USER 10001:10001
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD ["python", "-c", "import urllib.request,os,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:%s/health/ready' % os.environ.get('APP_PORT','8080'), timeout=2).status == 200 else 1)"]
# exec-форма + одиночный процесс: сервер = PID 1, SIGTERM доходит до uvicorn.
# Состояние хранится в PostgreSQL/Valkey, поэтому процесс stateless; один worker на контейнер, масштабирование — репликами.
# graceful shutdown 8 c < 10 c (лимит задания); keep-alive закрывается при остановке.
CMD ["sh", "-c", "exec python -m uvicorn --app-dir src app.main:app --host \"$APP_HOST\" --port \"$APP_PORT\" --workers 1 --no-access-log --timeout-graceful-shutdown 8 --timeout-keep-alive 5 --limit-concurrency \"$LIMIT_CONCURRENCY\""]
+20
View File
@@ -24,3 +24,23 @@ load:
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
# --- собственные цели студента ---
.PHONY: secrets up down student-test test-expiry test-dependencies
secrets:
sh scripts/init-secrets.sh
up: secrets
docker compose --env-file .env up -d --build
down:
docker compose --env-file .env down
student-test:
$(PYTHON) -m unittest discover -s student-tests -p "test_api.py" -v
test-expiry:
$(PYTHON) student-tests/test_expiry.py
test-dependencies:
$(PYTHON) student-tests/test_dependencies.py
+91 -15
View File
@@ -1,37 +1,113 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: [ФИО], [группа]
- Целевая оценка; выбранный трек 5, если нужен: **5**, трек 2 «План запроса и восстановление»
- Commit/PR: локальный коммит ветки `solution/lab2`; PR — после публикации
- Использованные источники, библиотеки и помощь ИИ: Python 3.12, uvicorn, asyncpg (PostgreSQL), redis-py (клиент Valkey), argon2-cffi (Argon2id); документация PostgreSQL (EXPLAIN, pg_dump), Valkey. Код lab1 перенесён (HTTP-слой, валидация, формат ошибок, лимиты). Использование ИИ: [заполняется автором]
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Prerequisites: Docker Compose v2, Python ≥ 3.9 (публичные тесты), bash (Git Bash на Windows) для `init-secrets.sh`.
Версии: `python:3.12.12-slim-bookworm@sha256:593bd06e…`, `postgres:17.11-alpine@sha256:b0f9560a…`, `valkey/valkey:8.1.10-alpine@sha256:081c2f5c…`, зависимости — `requirements.txt` (все версии закреплены).
```sh
sh scripts/init-secrets.sh # создаёт secrets/postgres_password и secrets/database_url (в Git не попадают)
cp .env.example .env # необязательные настройки (TTL сессии и т. д.)
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
# дождаться готовности (migrate выполняется один раз и завершается, api стартует после него):
curl http://127.0.0.1:8080/health/ready # {"status":"ok"}
python3 tests/smoke.py --base-url http://127.0.0.1:8080 # make test
python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080
```
На Windows (CreateProcess не запускает `.sh`) используйте `scripts/restart.cmd` — тот же `docker compose restart`.
Остановка с сохранением данных: `docker compose --env-file .env stop`. **Намеренное удаление учебных данных**: `docker compose --env-file .env down -v` (удаляет volumes `pgdata` и `valkeydata`).
Миграции: сервис `migrate` (тот же образ, `python -m app.migrate`) выполняется до старта `api`, повторный запуск безопасен (таблица `schema_migrations`, контрольные суммы, advisory lock). Ручной запуск: `docker compose --env-file .env run --rm migrate`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
Клиент ─HTTP─▶ API (uvicorn, 1 процесс) ──asyncpg (пул ≤10)──▶ PostgreSQL 17 [volume pgdata] ← источник истины
└─redis-py (timeout 0.2 c)──▶ Valkey 8 [volume valkeydata] ← кэш сессий
```
| Роль | Сервис compose | Версия/digest | Health/readiness | Volume | Сеть/порт | Credentials |
| --- | --- | --- | --- | --- | --- | --- |
| api | `api` | собирается из `Dockerfile` | `/health/ready` (HEALTHCHECK), PostgreSQL критичен, Valkey — нет | — | `127.0.0.1:8080` | `DATABASE_URL_FILE` → docker secret |
| postgres | `postgres` | 17.11-alpine@sha256:b0f9560a… | `pg_isready` | `pgdata` | только сеть `backend` | `POSTGRES_PASSWORD_FILE` → secret |
| valkey | `valkey` | 8.1.10-alpine@sha256:081c2f5c… | `valkey-cli ping` | `valkeydata` | только сеть `backend` | без пароля, не опубликован |
| миграции | `migrate` (one-shot) | образ api | завершается кодом 0 | — | `backend` | secret `database_url` |
- **Источник истины** — PostgreSQL: пользователи, чаты, участники, сообщения и сессии. Схема — `migrations/0001_init.sql`: PK/FK, `UNIQUE(username)`, `CHECK`-ограничения, индексы `messages(chat_id, created_at, id)`, `chat_members(user_id, chat_created_at, chat_id)`. Создание чата — одна транзакция (чат + участники); неизвестный участник нарушает FK и откатывает всё.
- **Пароли**: Argon2id (m=19 МиБ, t=2, p=1) в отдельном пуле потоков, не блокируя event loop; для неизвестного username проверяется фиктивный хеш (одинаковые ответ и время).
- **Сессии**: токен — 256 бит (`secrets.token_urlsafe(32)`), в БД и в кэше хранится только SHA-256. TTL — `SESSION_TTL_SECONDS` (по умолчанию 3600), срок считается по часам БД (`now() + интервал`), использование токена срок не продлевает. Logout — `revoked_at` в БД + удаление ключа в Valkey.
- **Роль Valkey** — read-through кэш сессий: ключ `s:<sha256>` → `user_id|expires_ms`, TTL = min(остаток жизни, `SESSION_CACHE_TTL_SECONDS`=60 с). Экономит один SELECT на каждый защищённый запрос. Политика expiry: TTL ключа + проверка `expires_ms`; инвалидация: logout/DEL. При недоступном Valkey кэш обходится (чтение из БД), circuit breaker на 5 с исключает ожидание таймаута; анонимный запрос никогда не считается доверенным. Окно устаревания: если Valkey был недоступен именно во время logout, ключ может прожить ≤ 60 с (после возврата сервиса). Valkey запущен с AOF (`everysec`) и `maxmemory 64mb`, чтобы тёплый кэш переживал рестарт, но корректность от этого не зависит — после потери кэша всё читается из PostgreSQL.
- **Пул соединений и таймауты**: `asyncpg` pool `max_size=10`, ожидание соединения 2 с, `command_timeout=5 с`, `connect timeout=2 с`; все запросы параметризованы (`$1…`), конкатенации SQL нет. Сбои зависимости → `503 unavailable` + `Retry-After`; для чтений один повтор при разорванном соединении пула (после рестарта БД).
- **Readiness**: `/health/ready` = SELECT 1 к PostgreSQL (таймаут 1 с). Недоступность Valkey не останавливает API.
- **История и конкурентные вставки**: `created_at` = `clock_timestamp()` БД (микросекунды), порядок `(created_at, id)`. Две транзакции в одном чате могут зафиксироваться не в порядке `created_at`; читатель, уже прошедший позицию, может не увидеть позднее зафиксированное сообщение с меньшей меткой (snapshot между HTTP-запросами не гарантируется контрактом). Допущение документировано.
- **Лимиты lab1 сохранены**: тело ≤ 64 КиБ (413), `MAX_INFLIGHT` → 429, потолок соединений → 503 JSON.
- Соответствие переменных из `.env.example`: `APP_*`, `SESSION_TTL_SECONDS`, `DATABASE_URL_FILE`, `SESSION_CACHE_TTL_SECONDS`, `DB_POOL_MAX` используются как есть; `VALKEY_URL` задаётся в `compose.yaml`.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke | `python3 tests/smoke.py …` | PASS | `evidence/checks.txt` |
| Persistence: API и ВСЕ хранилища перезапущены, volumes сохранены, прежний токен работает | `tests/resilience.py --mode persistence --action-script scripts/restart.sh` | PASS; `StartedAt` postgres/valkey/api изменился, volumes на месте | `evidence/persistence_containers.txt` |
| Миграции с нуля и повторно без дублирования | `docker compose up` (первый запуск) и `docker compose run --rm migrate` | первый запуск: `migration_applied`, повтор: `applied=0` | `evidence/migrations.txt` |
| Basic только на `POST /auth/sessions`, Bearer на остальных, `X-User-Id` игнорируется, expiry, logout | `student-tests/test_api.py` | 12 тестов OK | `evidence/checks.txt` |
| Пароли хешируются KDF | `test_password_is_not_exposed_or_stored_plain` | в БД `$argon2id$…`, пароль не найден | `evidence/checks.txt` |
| Роль Valkey, TTL, инвалидация, обход при отказе | описание выше + `test_dependencies.py::test_valkey_down_is_bypassed` | API работает без Valkey, logout виден без кэша | `evidence/checks.txt` |
| Параметризованные запросы, пул, таймауты; гонка username; rollback | `test_concurrent_registration_of_same_username`, `test_chat_creation_is_atomic` | из 12 параллельных регистраций — 1×201 и 11×409; после неудачного создания чата числа строк в `chats`/`chat_members` не изменились | `evidence/checks.txt` |
| Индекс истории и EXPLAIN (ANALYZE, BUFFERS) на ≥10 000 сообщений | `research/track2_plans_backup.py` (105 000 сообщений) | keyset-запрос: Index Scan, 6 буферов, 0.07 мс против Seq Scan + Sort, 2 632 буфера, 10 мс без индекса | `evidence/track2_explain_plans.txt` |
| Expiry при коротком TTL | `student-tests/test_expiry.py` (SESSION_TTL_SECONDS=2) | через 3.5 с токен → 401 (кэш и БД), TTL не продлевается использованием | `evidence/checks.txt` |
| Недоступность БД/кэша | `student-tests/test_dependencies.py` | PostgreSQL остановлен → 503 JSON + `Retry-After`, `/health/ready` 503, без токена 401; после старта БД API восстановился сам и сессия действует | `evidence/checks.txt` |
| Нагрузочный профиль | `tests/load.py --duration 20 --concurrency 8` | 0 ошибок, ≈960 успешных RPS (урезан клиентом на urllib), p95 ≈ 16 мс | `evidence/load.json` |
| Трек 2 | `research/track2_plans_backup.py` | см. ниже | `evidence/track2_results.json`, `track2_explain_plans.txt` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Эксперименты и отказы (трек 2)
## Эксперименты и отказы
**Гипотеза.** Составной индекс `(chat_id, created_at, id)` превращает страницу истории в чтение ~50 строк по индексу независимо от размера чата и позиции в нём, а цена — рост индекса и небольшое замедление записи. Логический backup `pg_dump -Fc` позволяет восстановить полное состояние в новом хранилище, граница потери данных — момент backup.
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
**Методика** (`research/track2_plans_backup.py`; PostgreSQL 17.11 в Docker, 1 CPU, `shared_buffers=128MB`; отдельная БД `research`, данные синтетические). Набор: **105 000 сообщений** в 1 106 чатах неравномерного размера (1 × 60 000, 5 × 5 000, 100 × 100, 1 000 × 10), 200 пользователей. 4 варианта индексов × 4 запроса; `EXPLAIN (ANALYZE, BUFFERS)`, медиана 9 прогонов (прогретый кэш). Стоимость записи: bulk `INSERT … SELECT` всех строк в пустую копию и 5 000 одиночных `INSERT` с тем же набором индексов.
| Вариант индексов | keyset, середина большого чата (50 строк) | первая страница, большой чат | OFFSET 30 000 | первая страница, малый чат (10 сообщений) | bulk-вставка 105 000 | размер индексов |
| --- | --- | --- | --- | --- | --- | --- |
| V0: только PK | 10.20 мс (Seq Scan + Sort, 2 632 буфера) | 9.15 мс | 23.9 мс | 5.79 мс | 0.42 с | 4.3 МБ |
| V1: `(chat_id)` | 8.19 мс (Sort) | 8.78 мс | 22.7 мс | 0.063 мс | 0.49 с | 5.2 МБ |
| **V2: `(chat_id, created_at, id)` — выбран** | **0.076 мс (Index Scan, 6 буферов)** | **0.043 мс** | 3.49 мс | 0.070 мс | 0.53 с | 12 МБ |
| V3: V2 + `INCLUDE (sender_id)` | 0.068 мс | 0.042 мс | 3.59 мс | 0.075 мс | 0.50 с | 15 МБ |
Выводы: keyset-запрос на V2 в ≈130 раз быстрее V0 и V1 и читает 6 страниц вместо 2 632; глубокий OFFSET остаётся ≈50× медленнее keyset (нужно пройти 30 000 записей индекса) — поэтому API использует cursor. Стоимость индекса V2: +25 % времени bulk-вставки относительно V0 и +8 МБ на 105 000 строк; одиночные вставки различаются на уровне шума (30–38 мс на 5 000 строк — различие в пределах погрешности одного прогона). `INCLUDE` почти не даёт выигрыша (index-only scan невозможен, т. к. запрос читает `text`) и увеличивает индекс — отвергнут. Для малого чата индекс по `chat_id` достаточен.
**Backup → восстановление в новое хранилище → сверка.** `pg_dump -Fc` БД `research` → отдельный контейнер `postgres:17.11-alpine` с **новым volume** → `pg_restore`:
| Показатель | Результат |
| --- | --- |
| Размер дампа | 7 765 134 байт (7.4 МБ, 105 000 сообщений) |
| Время backup / restore (RTO для этого объёма) | 1.15 с / 0.85 с |
| Строки (users/chats/members) | 200 / 1 106 / 1 106 — совпадают |
| Контрольная сумма всех сообщений (`md5` по `id, chat_id, sender_id, text, created_at`) | совпадает: `105000 105f3be9…` |
| Выборочная страница истории (100 сообщений с позиции 30 000) | md5 совпадает |
| Индексы | восстановлены (`ix_hist`, `messages_pkey`) |
| 25 сообщений, записанных **после** backup | в восстановленной копии отсутствуют |
**Границы.** RPO логического backup — интервал между дампами: всё записанное после него теряется (подтверждено 25 строками). Для меньшего RPO нужен непрерывный архив WAL / PITR — не реализован. RTO на 7 МБ ≈ 1 с — на промышленных объёмах растёт линейно с размером данных и перестройкой индексов; восстановление также требует остановки записи в старое хранилище. Измерения проведены на одном ноутбуке без конкурирующей нагрузки; абсолютные миллисекунды не переносимы, соотношения (Seq Scan/Sort против Index Scan) — переносимы.
### Отказы (уровень 4)
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Рестарт API, PostgreSQL и Valkey с volumes | прежний токен работает, данные на месте | `tests/resilience.py` PASS | готовность < 90 с; потери нет |
| Остановка Valkey | кэш обходится, API работает | 5 запросов с токеном — 200, быстрее 3 с; login/logout работают | мгновенно; потери нет |
| Остановка PostgreSQL | 503 вместо 500/анонимного доступа | все защищённые запросы и login → 503 + `Retry-After`; `ready`=503; без токена 401 | после запуска БД API восстанавливается сам; потери нет |
| TTL=2 с | токен отвергается после срока | 401 + `WWW-Authenticate: Bearer` | — |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Выдерживается: рестарт всех компонентов с сохранёнными volumes, отказ Valkey, кратковременная потеря PostgreSQL. Не выдерживается: потеря volume `pgdata` (нужен backup), отказ хоста Docker; PostgreSQL одиночный (SPOF), репликации нет.
- Один API-процесс; нет балансировщика и идемпотентности отправки (lab3).
- Окно инвалидации кэша (≤ 60 с) при недоступном Valkey в момент logout; создание сессии не ограничено rate limit (429 в контракте допустим, но не реализован).
- Подтверждено экспериментами: выбор индекса, корректность backup/restore на 105 000 сообщений, поведение при отказах. Гипотеза без доказательства: поведение индексов на данных, значительно превышающих память.
+95
View File
@@ -0,0 +1,95 @@
# Стенд lab2: API + PostgreSQL + Valkey (кэш сессий). Запуск и проверка — см. REPORT.md.
# Секреты: scripts/init-secrets.sh создаёт secrets/* (в Git не попадают).
name: mtusi-lab2
x-limits: &limits
restart: unless-stopped
logging:
driver: json-file
options: {max-size: "10m", max-file: "3"}
services:
postgres:
<<: *limits
image: postgres:17.11-alpine@sha256:b0f9560a2de083e2cc7382e75f808c7381a32852a7ec49117deedb300e552b24
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets: [postgres_password]
volumes:
- pgdata:/var/lib/postgresql/data
# Durability по умолчанию: fsync=on, synchronous_commit=on -> COMMIT означает запись WAL на диск.
command: ["postgres", "-c", "max_connections=100", "-c", "shared_buffers=128MB",
"-c", "log_min_duration_statement=500"]
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 12
mem_limit: 512m
cpus: 1.0
networks: [backend]
valkey:
<<: *limits
image: valkey/valkey:8.1.10-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507
# Кэш сессий (источник истины — PostgreSQL). AOF включён, чтобы тёплый кэш пережил рестарт; maxmemory ограничивает RAM.
command: ["valkey-server", "--appendonly", "yes", "--appendfsync", "everysec",
"--maxmemory", "64mb", "--maxmemory-policy", "volatile-ttl", "--save", ""]
volumes:
- valkeydata:/data
healthcheck:
test: ["CMD", "valkey-cli", "ping"]
interval: 5s
timeout: 3s
retries: 12
mem_limit: 128m
cpus: 0.5
networks: [backend]
migrate:
build: .
image: mtusi-messenger:lab2
command: ["python", "-m", "app.migrate"]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
secrets: [database_url]
depends_on:
postgres: {condition: service_healthy}
restart: "no"
networks: [backend]
api:
<<: *limits
build: .
image: mtusi-messenger:lab2
environment:
APP_ENV: ${APP_ENV:-lab}
DATABASE_URL_FILE: /run/secrets/database_url
VALKEY_URL: redis://valkey:6379/0
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-60}
DB_POOL_MAX: ${DB_POOL_MAX:-10}
secrets: [database_url]
depends_on:
migrate: {condition: service_completed_successfully}
valkey: {condition: service_healthy}
ports:
- "127.0.0.1:8080:8080"
mem_limit: 256m
cpus: 1.0
networks: [backend]
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
volumes:
pgdata:
valkeydata:
networks:
backend:
Binary file not shown.
+16
View File
@@ -0,0 +1,16 @@
$ python3 tests/smoke.py
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
$ python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh (Windows: restart.cmd; контейнеры до/после — persistence_containers.txt)
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
$ python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
$ python -m unittest discover -s student-tests -p test_api.py
Ran 12 tests in 2.802s
OK
$ python student-tests/test_expiry.py (SESSION_TTL_SECONDS=2)
Ran 2 tests in 10.310s
OK
$ python student-tests/test_dependencies.py (остановка Valkey / PostgreSQL)
Ran 2 tests in 14.884s
OK
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 20.0,
"elapsed_seconds": 20.187,
"concurrency": 8,
"successful_requests": 19411,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 961.559,
"successful_latency_ms": {
"p50": 15.0,
"p95": 16.0,
"p99": 16.0
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+7
View File
@@ -0,0 +1,7 @@
# 1. миграции на пустую БД
{"ts": "2026-10-02T22:28:31Z", "level": "info", "msg": "migration_applied", "version": "0001_init.sql"}
{"ts": "2026-10-02T22:28:31Z", "level": "info", "msg": "migrations_done", "applied": 1, "total": 1}
# 2. повторный запуск (идемпотентность)
{"ts": "2026-10-02T22:28:32Z", "level": "info", "msg": "migrations_done", "applied": 0, "total": 1}
# 3. запуск на рабочей БД (уже применено)
{"ts": "2026-10-02T22:28:34Z", "level": "info", "msg": "migrations_done", "applied": 0, "total": 1}
+18
View File
@@ -0,0 +1,18 @@
# До перезапуска
/mtusi-lab2-postgres-1 StartedAt=2026-10-02T22:27:01.751292444Z restarts=0 health=healthy
/mtusi-lab2-valkey-1 StartedAt=2026-10-02T22:27:04.038032167Z restarts=0 health=healthy
/mtusi-lab2-api-1 StartedAt=2026-10-02T22:26:48.094412012Z restarts=0 health=healthy
# docker volume ls (должны сохраниться)
mtusi-lab2_pgdata
mtusi-lab2_valkeydata
$ python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh (на Windows: scripts/restart.cmd, тот же compose restart)
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
# После перезапуска (StartedAt всех трёх сервисов изменился, volumes на месте)
/mtusi-lab2-postgres-1 StartedAt=2026-10-02T22:27:28.059336695Z restarts=0 health=starting
/mtusi-lab2-valkey-1 StartedAt=2026-10-02T22:27:28.233209818Z restarts=0 health=starting
/mtusi-lab2-api-1 StartedAt=2026-10-02T22:27:28.462473382Z restarts=0 health=starting
mtusi-lab2_pgdata
mtusi-lab2_valkeydata
+307
View File
@@ -0,0 +1,307 @@
===== V0_pk_only / keyset_big_chat_middle (медиана 10.195 мс из 9) =====
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=5036.29..5036.42 rows=51 width=171) (actual time=10.450..10.456 rows=51 loops=1)
Buffers: shared hit=2632
-> Sort (cost=5036.29..5079.22 rows=17169 width=171) (actual time=10.448..10.451 rows=51 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 40kB
Buffers: shared hit=2632
-> Seq Scan on messages (cost=0.00..4463.50 rows=17169 width=171) (actual time=0.080..8.640 rows=29999 loops=1)
Filter: ((chat_id = 'ae663d40-43bf-4930-94b0-07eef693fca2'::uuid) AND (ROW(created_at, id) > ROW('2026-10-02 06:45:15.998444+00'::timestamp with time zone, '7df96ec6-9cae-4a9d-9696-c854f9218ab5'::uuid)))
Rows Removed by Filter: 75001
Buffers: shared hit=2626
Planning:
Buffers: shared hit=113
Planning Time: 0.456 ms
Execution Time: 10.519 ms
(14 rows)
===== V0_pk_only / first_page_big_chat (медиана 9.149 мс из 9) =====
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=5585.66..5591.53 rows=51 width=171) (actual time=7.011..8.604 rows=51 loops=1)
Buffers: shared hit=2670
-> Gather Merge (cost=5585.66..9679.32 rows=35597 width=171) (actual time=7.009..8.600 rows=51 loops=1)
Workers Planned: 1
Workers Launched: 1
Buffers: shared hit=2670
-> Sort (cost=4585.65..4674.64 rows=35597 width=171) (actual time=5.790..5.792 rows=51 loops=2)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 40kB
Buffers: shared hit=2670
Worker 0: Sort Method: top-N heapsort Memory: 39kB
-> Parallel Seq Scan on messages (cost=0.00..3398.06 rows=35597 width=171) (actual time=0.007..3.950 rows=30000 loops=2)
Filter: (chat_id = 'ae663d40-43bf-4930-94b0-07eef693fca2'::uuid)
Rows Removed by Filter: 22500
Buffers: shared hit=2626
Planning:
Buffers: shared hit=114
Planning Time: 0.435 ms
Execution Time: 8.655 ms
(19 rows)
===== V0_pk_only / offset_big_chat_30000 (медиана 23.898 мс из 9) =====
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=13584.11..13589.97 rows=51 width=171) (actual time=20.720..23.072 rows=51 loops=1)
Buffers: shared hit=2670, temp read=1088 written=1370
-> Gather Merge (cost=10134.11..14227.76 rows=35597 width=171) (actual time=15.085..22.454 rows=30051 loops=1)
Workers Planned: 1
Workers Launched: 1
Buffers: shared hit=2670, temp read=1088 written=1370
-> Sort (cost=9134.10..9223.09 rows=35597 width=171) (actual time=13.549..14.977 rows=15192 loops=2)
Sort Key: created_at, id
Sort Method: external merge Disk: 5800kB
Buffers: shared hit=2670, temp read=1088 written=1370
Worker 0: Sort Method: external merge Disk: 5128kB
-> Parallel Seq Scan on messages (cost=0.00..3398.06 rows=35597 width=171) (actual time=0.006..4.295 rows=30000 loops=2)
Filter: (chat_id = 'ae663d40-43bf-4930-94b0-07eef693fca2'::uuid)
Rows Removed by Filter: 22500
Buffers: shared hit=2626
Planning:
Buffers: shared hit=114
Planning Time: 0.422 ms
Execution Time: 23.755 ms
(19 rows)
===== V0_pk_only / first_page_small_chat (медиана 5.785 мс из 9) =====
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------
Limit (cost=3938.69..3938.72 rows=11 width=171) (actual time=5.746..5.749 rows=10 loops=1)
Buffers: shared hit=2632
-> Sort (cost=3938.69..3938.72 rows=11 width=171) (actual time=5.745..5.746 rows=10 loops=1)
Sort Key: created_at, id
Sort Method: quicksort Memory: 27kB
Buffers: shared hit=2632
-> Seq Scan on messages (cost=0.00..3938.50 rows=11 width=171) (actual time=5.401..5.713 rows=10 loops=1)
Filter: (chat_id = 'b8b701bf-339f-44c0-9468-9e10800583fe'::uuid)
Rows Removed by Filter: 104990
Buffers: shared hit=2626
Planning:
Buffers: shared hit=114
Planning Time: 0.440 ms
Execution Time: 5.777 ms
(14 rows)
===== V1_chat_id / keyset_big_chat_middle (медиана 8.189 мс из 9) =====
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=4916.20..4916.32 rows=51 width=171) (actual time=8.528..8.535 rows=51 loops=1)
Buffers: shared hit=1567
-> Sort (cost=4916.20..4958.68 rows=16994 width=171) (actual time=8.526..8.530 rows=51 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 40kB
Buffers: shared hit=1567
-> Bitmap Heap Scan on messages (cost=674.15..4349.24 rows=16994 width=171) (actual time=1.094..6.629 rows=29999 loops=1)
Recheck Cond: (chat_id = 'ae663d40-43bf-4930-94b0-07eef693fca2'::uuid)
Filter: (ROW(created_at, id) > ROW('2026-10-02 06:45:15.998444+00'::timestamp with time zone, '7df96ec6-9cae-4a9d-9696-c854f9218ab5'::uuid))
Rows Removed by Filter: 30001
Heap Blocks: exact=1508
Buffers: shared hit=1561
-> Bitmap Index Scan on ix_chat (cost=0.00..669.90 rows=59948 width=0) (actual time=0.923..0.923 rows=60000 loops=1)
Index Cond: (chat_id = 'ae663d40-43bf-4930-94b0-07eef693fca2'::uuid)
Buffers: shared hit=53
Planning:
Buffers: shared hit=125
Planning Time: 0.555 ms
Execution Time: 8.615 ms
(19 rows)
===== V1_chat_id / first_page_big_chat (медиана 8.781 мс из 9) =====
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=5574.55..5580.42 rows=51 width=171) (actual time=7.829..10.288 rows=51 loops=1)
Buffers: shared hit=2670
-> Gather Merge (cost=5574.55..9629.91 rows=35264 width=171) (actual time=7.827..10.282 rows=51 loops=1)
Workers Planned: 1
Workers Launched: 1
Buffers: shared hit=2670
-> Sort (cost=4574.54..4662.70 rows=35264 width=171) (actual time=6.300..6.303 rows=51 loops=2)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 40kB
Buffers: shared hit=2670
Worker 0: Sort Method: top-N heapsort Memory: 39kB
-> Parallel Seq Scan on messages (cost=0.00..3398.06 rows=35264 width=171) (actual time=0.007..4.247 rows=30000 loops=2)
Filter: (chat_id = 'ae663d40-43bf-4930-94b0-07eef693fca2'::uuid)
Rows Removed by Filter: 22500
Buffers: shared hit=2626
Planning:
Buffers: shared hit=126
Planning Time: 0.622 ms
Execution Time: 10.363 ms
(19 rows)
===== V1_chat_id / offset_big_chat_30000 (медиана 22.723 мс из 9) =====
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=13525.04..13530.91 rows=51 width=171) (actual time=19.289..21.512 rows=51 loops=1)
Buffers: shared hit=2670, temp read=1089 written=1371
-> Gather Merge (cost=10075.04..14130.40 rows=35264 width=171) (actual time=13.620..20.895 rows=30051 loops=1)
Workers Planned: 1
Workers Launched: 1
Buffers: shared hit=2670, temp read=1089 written=1371
-> Sort (cost=9075.03..9163.19 rows=35264 width=171) (actual time=11.849..13.263 rows=15164 loops=2)
Sort Key: created_at, id
Sort Method: external merge Disk: 5976kB
Buffers: shared hit=2670, temp read=1089 written=1371
Worker 0: Sort Method: external merge Disk: 4960kB
-> Parallel Seq Scan on messages (cost=0.00..3398.06 rows=35264 width=171) (actual time=0.006..3.514 rows=30000 loops=2)
Filter: (chat_id = 'ae663d40-43bf-4930-94b0-07eef693fca2'::uuid)
Rows Removed by Filter: 22500
Buffers: shared hit=2626
Planning:
Buffers: shared hit=126
Planning Time: 0.514 ms
Execution Time: 22.164 ms
(19 rows)
===== V1_chat_id / first_page_small_chat (медиана 0.063 мс из 9) =====
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------
Limit (cost=46.57..46.60 rows=11 width=171) (actual time=0.039..0.040 rows=10 loops=1)
Buffers: shared hit=9
-> Sort (cost=46.57..46.60 rows=11 width=171) (actual time=0.038..0.039 rows=10 loops=1)
Sort Key: created_at, id
Sort Method: quicksort Memory: 27kB
Buffers: shared hit=9
-> Bitmap Heap Scan on messages (cost=4.38..46.38 rows=11 width=171) (actual time=0.012..0.012 rows=10 loops=1)
Recheck Cond: (chat_id = 'b8b701bf-339f-44c0-9468-9e10800583fe'::uuid)
Heap Blocks: exact=1
Buffers: shared hit=3
-> Bitmap Index Scan on ix_chat (cost=0.00..4.38 rows=11 width=0) (actual time=0.007..0.007 rows=10 loops=1)
Index Cond: (chat_id = 'b8b701bf-339f-44c0-9468-9e10800583fe'::uuid)
Buffers: shared hit=2
Planning:
Buffers: shared hit=126
Planning Time: 0.475 ms
Execution Time: 0.063 ms
(17 rows)
===== V2_chat_created_id / keyset_big_chat_middle (медиана 0.076 мс из 9) =====
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..34.02 rows=51 width=171) (actual time=0.022..0.033 rows=51 loops=1)
Buffers: shared hit=6
-> Index Scan using ix_hist on messages (cost=0.42..11340.82 rows=17213 width=171) (actual time=0.021..0.030 rows=51 loops=1)
Index Cond: ((chat_id = 'ae663d40-43bf-4930-94b0-07eef693fca2'::uuid) AND (ROW(created_at, id) > ROW('2026-10-02 06:45:15.998444+00'::timestamp with time zone, '7df96ec6-9cae-4a9d-9696-c854f9218ab5'::uuid)))
Buffers: shared hit=6
Planning:
Buffers: shared hit=136
Planning Time: 0.608 ms
Execution Time: 0.067 ms
(9 rows)
===== V2_chat_created_id / first_page_big_chat (медиана 0.043 мс из 9) =====
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..11.65 rows=51 width=171) (actual time=0.013..0.021 rows=51 loops=1)
Buffers: shared hit=5
-> Index Scan using ix_hist on messages (cost=0.42..13298.21 rows=60389 width=171) (actual time=0.012..0.018 rows=51 loops=1)
Index Cond: (chat_id = 'ae663d40-43bf-4930-94b0-07eef693fca2'::uuid)
Buffers: shared hit=5
Planning:
Buffers: shared hit=137
Planning Time: 0.516 ms
Execution Time: 0.038 ms
(9 rows)
===== V2_chat_created_id / offset_big_chat_30000 (медиана 3.492 мс из 9) =====
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=6606.48..6617.71 rows=51 width=171) (actual time=3.347..3.355 rows=51 loops=1)
Buffers: shared hit=1234
-> Index Scan using ix_hist on messages (cost=0.42..13298.21 rows=60389 width=171) (actual time=0.016..2.753 rows=30051 loops=1)
Index Cond: (chat_id = 'ae663d40-43bf-4930-94b0-07eef693fca2'::uuid)
Buffers: shared hit=1234
Planning:
Buffers: shared hit=137
Planning Time: 0.556 ms
Execution Time: 3.378 ms
(9 rows)
===== V2_chat_created_id / first_page_small_chat (медиана 0.07 мс из 9) =====
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------
Limit (cost=46.69..46.72 rows=11 width=171) (actual time=0.057..0.058 rows=10 loops=1)
Buffers: shared hit=10
-> Sort (cost=46.69..46.72 rows=11 width=171) (actual time=0.055..0.056 rows=10 loops=1)
Sort Key: created_at, id
Sort Method: quicksort Memory: 27kB
Buffers: shared hit=10
-> Bitmap Heap Scan on messages (cost=4.50..46.50 rows=11 width=171) (actual time=0.023..0.023 rows=10 loops=1)
Recheck Cond: (chat_id = 'b8b701bf-339f-44c0-9468-9e10800583fe'::uuid)
Heap Blocks: exact=1
Buffers: shared hit=4
-> Bitmap Index Scan on ix_hist (cost=0.00..4.50 rows=11 width=0) (actual time=0.013..0.013 rows=10 loops=1)
Index Cond: (chat_id = 'b8b701bf-339f-44c0-9468-9e10800583fe'::uuid)
Buffers: shared hit=3
Planning:
Buffers: shared hit=137
Planning Time: 0.785 ms
Execution Time: 0.090 ms
(17 rows)
===== V3_chat_created_id_include / keyset_big_chat_middle (медиана 0.068 мс из 9) =====
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..34.11 rows=51 width=171) (actual time=0.026..0.033 rows=51 loops=1)
Buffers: shared hit=5
-> Index Scan using ix_hist_inc on messages (cost=0.42..11506.55 rows=17419 width=171) (actual time=0.025..0.029 rows=51 loops=1)
Index Cond: ((chat_id = 'ae663d40-43bf-4930-94b0-07eef693fca2'::uuid) AND (ROW(created_at, id) > ROW('2026-10-02 06:45:15.998444+00'::timestamp with time zone, '7df96ec6-9cae-4a9d-9696-c854f9218ab5'::uuid)))
Buffers: shared hit=5
Planning:
Buffers: shared hit=139
Planning Time: 0.586 ms
Execution Time: 0.095 ms
(9 rows)
===== V3_chat_created_id_include / first_page_big_chat (медиана 0.042 мс из 9) =====
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..12.14 rows=51 width=171) (actual time=0.013..0.024 rows=51 loops=1)
Buffers: shared hit=6
-> Index Scan using ix_hist_inc on messages (cost=0.42..13823.52 rows=60154 width=171) (actual time=0.013..0.021 rows=51 loops=1)
Index Cond: (chat_id = 'ae663d40-43bf-4930-94b0-07eef693fca2'::uuid)
Buffers: shared hit=6
Planning:
Buffers: shared hit=140
Planning Time: 0.581 ms
Execution Time: 0.052 ms
(9 rows)
===== V3_chat_created_id_include / offset_big_chat_30000 (медиана 3.587 мс из 9) =====
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=6894.28..6906.00 rows=51 width=171) (actual time=3.503..3.509 rows=51 loops=1)
Buffers: shared hit=1300
-> Index Scan using ix_hist_inc on messages (cost=0.42..13823.52 rows=60154 width=171) (actual time=0.011..2.892 rows=30051 loops=1)
Index Cond: (chat_id = 'ae663d40-43bf-4930-94b0-07eef693fca2'::uuid)
Buffers: shared hit=1300
Planning:
Buffers: shared hit=140
Planning Time: 0.513 ms
Execution Time: 3.529 ms
(9 rows)
===== V3_chat_created_id_include / first_page_small_chat (медиана 0.075 мс из 9) =====
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------
Limit (cost=42.93..42.96 rows=10 width=171) (actual time=0.064..0.066 rows=10 loops=1)
Buffers: shared hit=10
-> Sort (cost=42.93..42.96 rows=10 width=171) (actual time=0.063..0.064 rows=10 loops=1)
Sort Key: created_at, id
Sort Method: quicksort Memory: 27kB
Buffers: shared hit=10
-> Bitmap Heap Scan on messages (cost=4.50..42.77 rows=10 width=171) (actual time=0.023..0.024 rows=10 loops=1)
Recheck Cond: (chat_id = 'b8b701bf-339f-44c0-9468-9e10800583fe'::uuid)
Heap Blocks: exact=1
Buffers: shared hit=4
-> Bitmap Index Scan on ix_hist_inc (cost=0.00..4.49 rows=10 width=0) (actual time=0.014..0.014 rows=10 loops=1)
Index Cond: (chat_id = 'b8b701bf-339f-44c0-9468-9e10800583fe'::uuid)
Buffers: shared hit=3
Planning:
Buffers: shared hit=140
Planning Time: 0.564 ms
Execution Time: 0.112 ms
(17 rows)
+136
View File
@@ -0,0 +1,136 @@
{
"date": "2026-10-03 01:25:18",
"messages": 105000,
"postgres": "17.11",
"chat_sizes": "1x60000, 5x5000, 100x100, 1000x10",
"variants": {
"V0_pk_only": {
"queries": {
"keyset_big_chat_middle": {
"median_ms": 10.195,
"min_ms": 9.989,
"top_node": "Sort"
},
"first_page_big_chat": {
"median_ms": 9.149,
"min_ms": 8.655,
"top_node": "Gather Merge"
},
"offset_big_chat_30000": {
"median_ms": 23.898,
"min_ms": 22.635,
"top_node": "Gather Merge"
},
"first_page_small_chat": {
"median_ms": 5.785,
"min_ms": 5.575,
"top_node": "Sort"
}
},
"bulk_insert_all_rows_seconds": 0.42,
"single_insert_5000_seconds": 0.030014,
"table_and_index_size": "21 MB / indexes 4336 kB"
},
"V1_chat_id": {
"queries": {
"keyset_big_chat_middle": {
"median_ms": 8.189,
"min_ms": 8.031,
"top_node": "Sort"
},
"first_page_big_chat": {
"median_ms": 8.781,
"min_ms": 8.102,
"top_node": "Gather Merge"
},
"offset_big_chat_30000": {
"median_ms": 22.723,
"min_ms": 22.164,
"top_node": "Gather Merge"
},
"first_page_small_chat": {
"median_ms": 0.063,
"min_ms": 0.062,
"top_node": "Sort"
}
},
"bulk_insert_all_rows_seconds": 0.49,
"single_insert_5000_seconds": 0.034086,
"table_and_index_size": "21 MB / indexes 5168 kB"
},
"V2_chat_created_id": {
"queries": {
"keyset_big_chat_middle": {
"median_ms": 0.076,
"min_ms": 0.061,
"top_node": "Index Scan"
},
"first_page_big_chat": {
"median_ms": 0.043,
"min_ms": 0.036,
"top_node": "Index Scan"
},
"offset_big_chat_30000": {
"median_ms": 3.492,
"min_ms": 3.378,
"top_node": "Index Scan"
},
"first_page_small_chat": {
"median_ms": 0.07,
"min_ms": 0.068,
"top_node": "Sort"
}
},
"bulk_insert_all_rows_seconds": 0.53,
"single_insert_5000_seconds": 0.037934,
"table_and_index_size": "21 MB / indexes 12 MB"
},
"V3_chat_created_id_include": {
"queries": {
"keyset_big_chat_middle": {
"median_ms": 0.068,
"min_ms": 0.059,
"top_node": "Index Scan"
},
"first_page_big_chat": {
"median_ms": 0.042,
"min_ms": 0.039,
"top_node": "Index Scan"
},
"offset_big_chat_30000": {
"median_ms": 3.587,
"min_ms": 3.453,
"top_node": "Index Scan"
},
"first_page_small_chat": {
"median_ms": 0.075,
"min_ms": 0.068,
"top_node": "Sort"
}
},
"bulk_insert_all_rows_seconds": 0.5,
"single_insert_5000_seconds": 0.0378,
"table_and_index_size": "21 MB / indexes 15 MB"
}
},
"backup_restore": {
"backup_seconds": 1.15,
"dump_bytes": 7765134,
"restore_seconds": 0.85,
"source_before_backup": {
"messages_checksum": "105000 105f3be9c5800d9063d35984fce8cdc5",
"rows": "users=200 chats=1106 members=1106"
},
"source_after_extra_writes": "105025 6b8ca4bbec223dfe62280f33554e2247",
"restored": {
"messages_checksum": "105000 105f3be9c5800d9063d35984fce8cdc5",
"rows": "users=200 chats=1106 members=1106"
},
"restore_matches_backup_state": true,
"page_checksum_source": "45def68fe4148adfc2d9066720956ab4",
"page_checksum_restored": "45def68fe4148adfc2d9066720956ab4",
"sample_page_matches": true,
"extra_rows_written_after_backup_absent_in_restore": true,
"restored_indexes": "ix_hist,messages_pkey"
}
}
+52
View File
@@ -0,0 +1,52 @@
-- 0001: пользователи, чаты, участники, сообщения, сессии.
-- Источник истины для всех данных — PostgreSQL. Каждая миграция выполняется в транзакции.
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL,
display_name text NOT NULL,
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
);
-- Уникальность username: гонка двух регистраций решается ограничением БД, а не проверкой в приложении.
CREATE UNIQUE INDEX users_username_key ON users (username);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100)
);
-- chat_created_at денормализован ради keyset-пагинации списка чатов пользователя без join+sort.
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users (id),
chat_created_at timestamptz NOT NULL,
ord smallint NOT NULL,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_chats ON chat_members (user_id, chat_created_at, 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),
text text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT messages_text_len CHECK (char_length(text) <= 4000)
);
-- История чата: WHERE chat_id = ? AND (created_at, id) > (?, ?) ORDER BY created_at, id LIMIT n
-- обслуживается этим индексом без сортировки и без сканирования всей истории.
CREATE INDEX messages_chat_history ON messages (chat_id, created_at, id);
-- Серверные сессии. В БД хранится только SHA-256 токена: утечка БД не раскрывает рабочие токены.
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL DEFAULT now(),
expires_at timestamptz NOT NULL,
revoked_at timestamptz
);
CREATE INDEX sessions_expires_at ON sessions (expires_at);
+12
View File
@@ -0,0 +1,12 @@
argon2-cffi==23.1.0
argon2-cffi-bindings==26.1.0
asyncpg==0.30.0
cffi==2.1.1
click==8.5.0
h11==0.16.0
httptools==0.8.0
pycparser==3.0
redis==5.2.1
typing_extensions==4.16.0
uvicorn==0.34.0
uvloop==0.21.0; sys_platform != "win32"
+217
View File
@@ -0,0 +1,217 @@
#!/usr/bin/env python3
"""Трек 2 (план запроса и восстановление), lab2.
Что делает (стенд `docker compose up -d` должен работать; рабочие данные не затрагиваются —
используется отдельная БД `research` внутри того же PostgreSQL):
1. Создаёт БД research со схемой из migrations/ и ≥100 000 сообщений с неравномерными размерами чатов
(1 чат 60 000, 5 по 5 000, 100 по 100, 1 000 по 10).
2. Сравнивает 4 варианта индексов и 3 запроса истории: EXPLAIN (ANALYZE, BUFFERS), медиана 9 прогонов.
3. Измеряет стоимость записи для каждого варианта индексов (bulk INSERT и 5 000 одиночных INSERT) и размер индексов.
4. Backup (pg_dump -Fc) -> восстановление в НОВОЕ хранилище (отдельный контейнер postgres с новым volume)
-> сверка количества строк, контрольной суммы всех сообщений и выбранных страниц истории.
5. Показывает границу потери данных: строки, записанные после backup, в восстановленной копии отсутствуют.
Результаты: evidence/track2_*.{json,txt}.
"""
import json
import os
import re
import statistics
import subprocess
import sys
import time
ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
OUT = os.path.join(ROOT, "evidence")
TARGET = "mtusi-lab2-restore-target"
TARGET_VOLUME = "mtusi-lab2-restore-target-data"
def sh(args, stdin=None, check=True):
r = subprocess.run(args, cwd=ROOT, input=stdin, capture_output=True, text=True, encoding="utf-8")
if check and r.returncode != 0:
raise RuntimeError("команда %s завершилась с %d: %s" % (args[:4], r.returncode, r.stderr[-800:]))
return r.stdout
def psql(sql, db="research", container=None, tuples=True):
base = (["docker", "exec", "-i", container] if container else
["docker", "compose", "--env-file", ".env", "exec", "-T", "postgres"])
args = base + ["psql", "-X", "-U", "messenger", "-d", db, "-v", "ON_ERROR_STOP=1"] + (["-At"] if tuples else [])
return sh(args, stdin=sql).strip()
def timed_exec(sql):
t = time.perf_counter()
psql(sql)
return time.perf_counter() - t
def setup():
psql("DROP DATABASE IF EXISTS research", db="postgres")
psql("CREATE DATABASE research", db="postgres")
with open(os.path.join(ROOT, "migrations", "0001_init.sql"), encoding="utf-8") as fh:
psql(fh.read())
psql("""
INSERT INTO users (id, username, display_name, password_hash)
SELECT gen_random_uuid(), 'r_' || g, 'user ' || g, 'x' FROM generate_series(1, 200) g;
CREATE TABLE sizes AS
SELECT gen_random_uuid() AS id, n, sz, now() - interval '1 day' + n * interval '1 millisecond' AS created_at,
(SELECT id FROM users ORDER BY random() LIMIT 1) AS u1
FROM (SELECT 1 AS n, 60000 AS sz
UNION ALL SELECT g, 5000 FROM generate_series(2, 6) g
UNION ALL SELECT g, 100 FROM generate_series(7, 106) g
UNION ALL SELECT g, 10 FROM generate_series(107, 1106) g) s;
INSERT INTO chats (id, title, created_at) SELECT id, 'chat ' || n, created_at FROM sizes;
INSERT INTO chat_members (chat_id, user_id, chat_created_at, ord) SELECT id, u1, created_at, 1 FROM sizes;
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), s.id, s.u1, 'message ' || i || ' ' || repeat('x', (random() * 200)::int),
s.created_at + i * interval '1 second' + (random() * 999)::int * interval '1 microsecond'
FROM sizes s, generate_series(1, s.sz) i;
ANALYZE;""")
total = psql("SELECT count(*) FROM messages")
big = psql("SELECT id FROM sizes WHERE n = 1")
small = psql("SELECT id FROM sizes WHERE n = 500")
return int(total), big, small
VARIANTS = {
"V0_pk_only": [],
"V1_chat_id": ["CREATE INDEX ix_chat ON messages (chat_id)"],
"V2_chat_created_id": ["CREATE INDEX ix_hist ON messages (chat_id, created_at, id)"],
"V3_chat_created_id_include": ["CREATE INDEX ix_hist_inc ON messages (chat_id, created_at, id) INCLUDE (sender_id)"],
}
def apply_variant(name):
rows = psql("SELECT indexname FROM pg_indexes WHERE tablename = 'messages' AND indexname <> 'messages_pkey'").split()
drops = "".join("DROP INDEX IF EXISTS %s;" % r for r in rows)
psql(drops + ";".join(VARIANTS[name]) + (";" if VARIANTS[name] else "") + "ANALYZE messages;")
def explain(sql, runs=9):
times, text = [], ""
for i in range(runs):
out = psql("EXPLAIN (ANALYZE, BUFFERS) " + sql, tuples=False)
m = re.search(r"Execution Time: ([0-9.]+) ms", out)
times.append(float(m.group(1)))
text = out
node = re.search(r"->\s+([A-Za-z ]+?)(?: using| on| \()", text) or re.search(r"^\s*([A-Za-z ]+?)(?: using| on| \()", text, re.M)
return {"median_ms": round(statistics.median(times), 3), "min_ms": min(times), "plan": text, "top_node": node.group(1).strip() if node else "?"}
def queries(big, small):
mid = psql("SELECT created_at || '|' || id FROM messages WHERE chat_id = '%s' ORDER BY created_at, id OFFSET 30000 LIMIT 1" % big)
ts, mid_id = mid.split("|")
return {
"keyset_big_chat_middle": "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '%s' AND (created_at, id) > ('%s', '%s') ORDER BY created_at, id LIMIT 51" % (big, ts, mid_id),
"first_page_big_chat": "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '%s' ORDER BY created_at, id LIMIT 51" % big,
"offset_big_chat_30000": "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '%s' ORDER BY created_at, id OFFSET 30000 LIMIT 51" % big,
"first_page_small_chat": "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '%s' ORDER BY created_at, id LIMIT 51" % small,
}
def write_cost(name):
"""bulk INSERT всех строк в пустую копию с тем же набором индексов + 5 000 одиночных INSERT."""
psql("DROP TABLE IF EXISTS m_copy; CREATE TABLE m_copy (LIKE messages INCLUDING DEFAULTS INCLUDING CONSTRAINTS);"
"ALTER TABLE m_copy ADD PRIMARY KEY (id);" + ";".join(s.replace("messages", "m_copy").replace("ix_", "cx_") for s in VARIANTS[name]) + ";")
bulk = timed_exec("INSERT INTO m_copy SELECT * FROM messages;")
return bulk
def single_insert_seconds(name):
out = subprocess.run(["docker", "compose", "--env-file", ".env", "exec", "-T", "postgres", "psql", "-X", "-U", "messenger", "-d", "research"],
cwd=ROOT, input="""DO $$ DECLARE t0 timestamptz; c uuid; u uuid; BEGIN
SELECT id, u1 INTO c, u FROM sizes WHERE n = 2; t0 := clock_timestamp();
FOR i IN 1..5000 LOOP INSERT INTO m_copy (id, chat_id, sender_id, text) VALUES (gen_random_uuid(), c, u, 'w' || i); END LOOP;
RAISE NOTICE 'ELAPSED %', extract(epoch FROM clock_timestamp() - t0); END $$;""", capture_output=True, text=True, encoding="utf-8")
m = re.search(r"ELAPSED ([0-9.]+)", out.stderr + out.stdout)
return float(m.group(1)) if m else None
def sizes():
return psql("SELECT pg_size_pretty(pg_relation_size('m_copy')) || ' / indexes ' || pg_size_pretty(pg_indexes_size('m_copy'))")
CHECKSUM_SQL = ("SELECT count(*) || ' ' || md5(string_agg(id::text || chat_id::text || sender_id::text || text || created_at::text, ',' ORDER BY id)) FROM messages")
ROWS_SQL = "SELECT 'users=' || (SELECT count(*) FROM users) || ' chats=' || (SELECT count(*) FROM chats) || ' members=' || (SELECT count(*) FROM chat_members)"
def checksum(db="research", container=None):
return psql(CHECKSUM_SQL, db=db, container=container)
def backup_restore(big):
apply_variant("V2_chat_created_id")
before = {"messages_checksum": checksum(), "rows": psql(ROWS_SQL)}
t = time.perf_counter()
sh(["docker", "compose", "--env-file", ".env", "exec", "-T", "postgres", "sh", "-c", "pg_dump -U messenger -Fc -d research -f /tmp/research.dump"])
backup_s = time.perf_counter() - t
size = int(sh(["docker", "compose", "--env-file", ".env", "exec", "-T", "postgres", "sh", "-c", "stat -c %s /tmp/research.dump"]).strip())
# данные, записанные ПОСЛЕ backup (граница потери: RPO = интервал между backup)
psql("INSERT INTO messages (id, chat_id, sender_id, text) SELECT gen_random_uuid(), id, u1, 'after-backup ' || g FROM sizes, generate_series(1, 25) g WHERE n = 3;")
after_write = checksum()
# новое хранилище
sh(["docker", "rm", "-f", TARGET], check=False)
sh(["docker", "volume", "rm", "-f", TARGET_VOLUME], check=False)
pg_image = "postgres:17.11-alpine@sha256:b0f9560a2de083e2cc7382e75f808c7381a32852a7ec49117deedb300e552b24"
sh(["docker", "run", "-d", "--name", TARGET, "-e", "POSTGRES_USER=messenger", "-e", "POSTGRES_PASSWORD=restore-target-local",
"-e", "POSTGRES_DB=restored", "-v", TARGET_VOLUME + ":/var/lib/postgresql/data", pg_image])
for _ in range(60):
if subprocess.run(["docker", "exec", TARGET, "pg_isready", "-U", "messenger", "-d", "restored"], capture_output=True).returncode == 0:
time.sleep(1)
break
time.sleep(1)
sh(["docker", "compose", "--env-file", ".env", "cp", "postgres:/tmp/research.dump", os.path.join(OUT, ".research.dump")])
sh(["docker", "cp", os.path.join(OUT, ".research.dump"), TARGET + ":/tmp/research.dump"])
t = time.perf_counter()
sh(["docker", "exec", TARGET, "pg_restore", "-U", "messenger", "-d", "restored", "--no-owner", "--exit-on-error", "/tmp/research.dump"])
restore_s = time.perf_counter() - t
os.remove(os.path.join(OUT, ".research.dump"))
restored = {"messages_checksum": checksum("restored", TARGET), "rows": psql(ROWS_SQL, db="restored", container=TARGET)}
page_src = psql("SELECT md5(string_agg(id::text, ',' ORDER BY created_at, id)) FROM (SELECT id, created_at FROM messages WHERE chat_id = '%s' ORDER BY created_at, id OFFSET 30000 LIMIT 100) p" % big)
page_dst = psql("SELECT md5(string_agg(id::text, ',' ORDER BY created_at, id)) FROM (SELECT id, created_at FROM messages WHERE chat_id = '%s' ORDER BY created_at, id OFFSET 30000 LIMIT 100) p" % big, db="restored", container=TARGET)
indexes = psql("SELECT string_agg(indexname, ',' ORDER BY indexname) FROM pg_indexes WHERE tablename = 'messages'", db="restored", container=TARGET)
sh(["docker", "rm", "-f", TARGET], check=False)
sh(["docker", "volume", "rm", "-f", TARGET_VOLUME], check=False)
return {"backup_seconds": round(backup_s, 2), "dump_bytes": size, "restore_seconds": round(restore_s, 2),
"source_before_backup": before, "source_after_extra_writes": after_write, "restored": restored,
"restore_matches_backup_state": before["messages_checksum"] == restored["messages_checksum"] and before["rows"] == restored["rows"],
"page_checksum_source": page_src, "page_checksum_restored": page_dst, "sample_page_matches": page_src == page_dst,
"extra_rows_written_after_backup_absent_in_restore": after_write != restored["messages_checksum"],
"restored_indexes": indexes}
def main():
os.makedirs(OUT, exist_ok=True)
total, big, small = setup()
print("сообщений:", total)
qs = queries(big, small)
report = {"date": time.strftime("%Y-%m-%d %H:%M:%S"), "messages": total, "postgres": psql("SHOW server_version", db="postgres"),
"chat_sizes": "1x60000, 5x5000, 100x100, 1000x10", "variants": {}}
plans = []
for name in VARIANTS:
apply_variant(name)
entry = {"queries": {}}
for qname, sql in qs.items():
r = explain(sql)
entry["queries"][qname] = {"median_ms": r["median_ms"], "min_ms": r["min_ms"], "top_node": r["top_node"]}
plans.append("===== %s / %s (медиана %s мс из 9) =====\n%s\n" % (name, qname, r["median_ms"], r["plan"]))
report["variants"][name] = entry
# стоимость записи
for name in VARIANTS:
bulk = write_cost(name)
entry = report["variants"][name]
entry["bulk_insert_all_rows_seconds"] = round(bulk, 2)
entry["single_insert_5000_seconds"] = single_insert_seconds(name)
entry["table_and_index_size"] = sizes()
print(name, entry["bulk_insert_all_rows_seconds"], entry["single_insert_5000_seconds"], entry["table_and_index_size"])
report["backup_restore"] = backup_restore(big)
with open(os.path.join(OUT, "track2_results.json"), "w", encoding="utf-8") as fh:
json.dump(report, fh, ensure_ascii=False, indent=2)
with open(os.path.join(OUT, "track2_explain_plans.txt"), "w", encoding="utf-8") as fh:
fh.write("\n".join(plans))
print(json.dumps(report, ensure_ascii=False, indent=2)[:6000])
if __name__ == "__main__":
main()
+14
View File
@@ -0,0 +1,14 @@
#!/usr/bin/env bash
# Создаёт локальные секреты стенда (secrets/ в .gitignore). Идемпотентно: существующие файлы не перезаписываются.
set -eu
cd "$(dirname "$0")/.."
mkdir -p secrets
if [ ! -s secrets/postgres_password ]; then
head -c 24 /dev/urandom | base64 | tr -d '=+/\n' > secrets/postgres_password
echo "создан secrets/postgres_password"
fi
if [ ! -s secrets/database_url ]; then
printf 'postgresql://messenger:%s@postgres:5432/messenger' "$(cat secrets/postgres_password)" > secrets/database_url
echo "создан secrets/database_url"
fi
chmod 644 secrets/* 2>/dev/null || true # читает непривилегированный пользователь контейнера (uid 10001)
+5
View File
@@ -0,0 +1,5 @@
@echo off
rem Windows analogue of restart.sh: restart PostgreSQL, Valkey and API; volumes are kept.
cd /d "%~dp0.."
docker compose --env-file .env restart postgres valkey api >NUL 2>&1
exit /b %errorlevel%
+5
View File
@@ -0,0 +1,5 @@
#!/bin/sh
# Перезапуск API и ВСЕХ хранилищ (PostgreSQL, Valkey) с сохранением volumes. Данные не удаляются и не пересоздаются.
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart postgres valkey api >/dev/null 2>&1
+53
View File
@@ -0,0 +1,53 @@
"""Конфигурация из переменных окружения (см. .env.example)."""
import os
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=""):
"""Значение из переменной NAME либо из файла NAME_FILE (Docker secrets); файл читается один раз."""
if os.environ.get(name):
return os.environ[name]
path = os.environ.get(name + "_FILE")
if path and os.path.exists(path):
with open(path, encoding="utf-8") as fh:
return fh.read().strip()
return default
APP_HOST = os.environ.get("APP_HOST", "0.0.0.0")
APP_PORT = _int("APP_PORT", 8080)
APP_ENV = os.environ.get("APP_ENV", "lab")
DATABASE_URL = _secret("DATABASE_URL")
DB_POOL_MIN = _int("DB_POOL_MIN", 2)
DB_POOL_MAX = _int("DB_POOL_MAX", 10)
DB_ACQUIRE_TIMEOUT = _float("DB_ACQUIRE_TIMEOUT", 2.0) # ожидание свободного соединения пула
DB_COMMAND_TIMEOUT = _float("DB_COMMAND_TIMEOUT", 5.0) # таймаут одного запроса
DB_CONNECT_TIMEOUT = _float("DB_CONNECT_TIMEOUT", 2.0)
VALKEY_URL = os.environ.get("VALKEY_URL", "") # пусто = кэш сессий выключен
VALKEY_TIMEOUT = _float("VALKEY_TIMEOUT", 0.2)
VALKEY_BREAKER_SECONDS = _float("VALKEY_BREAKER_SECONDS", 5.0)
SESSION_TTL_SECONDS = _int("SESSION_TTL_SECONDS", 3600)
SESSION_CACHE_TTL_SECONDS = _int("SESSION_CACHE_TTL_SECONDS", 60)
ARGON2_TIME_COST = _int("ARGON2_TIME_COST", 2)
ARGON2_MEMORY_KIB = _int("ARGON2_MEMORY_KIB", 19456) # 19 MiB, рекомендация OWASP
ARGON2_PARALLELISM = _int("ARGON2_PARALLELISM", 1)
HASH_CONCURRENCY = _int("HASH_CONCURRENCY", 4)
MAX_BODY_BYTES = _int("MAX_BODY_BYTES", 65536)
MAX_INFLIGHT = _int("MAX_INFLIGHT", 64)
LIMIT_CONCURRENCY = _int("LIMIT_CONCURRENCY", 1000)
RETRY_AFTER_SECONDS = _int("RETRY_AFTER_SECONDS", 1)
MIGRATIONS_DIR = os.environ.get("MIGRATIONS_DIR", os.path.join(os.path.dirname(__file__), "..", "..", "migrations"))
+71
View File
@@ -0,0 +1,71 @@
"""PostgreSQL: ограниченный пул asyncpg, таймауты, перевод сбоев зависимости в 503."""
import asyncio
from contextlib import asynccontextmanager
import asyncpg
from . import config
from .web import log, unavailable
DEPENDENCY_ERRORS = (asyncpg.PostgresConnectionError, asyncpg.InterfaceError, asyncpg.exceptions.OperatorInterventionError,
asyncpg.exceptions.InsufficientResourcesError, asyncio.TimeoutError, OSError)
_RETRYABLE = (asyncpg.ConnectionDoesNotExistError, asyncpg.InterfaceError, ConnectionResetError)
class Database:
def __init__(self):
self.pool = None
async def start(self):
if not config.DATABASE_URL:
log("error", "database_url_missing")
return
# min_size=0: приложение стартует и без БД (readiness покажет 503), пул подключается лениво.
self.pool = await asyncpg.create_pool(
dsn=config.DATABASE_URL, min_size=0, max_size=config.DB_POOL_MAX,
command_timeout=config.DB_COMMAND_TIMEOUT, timeout=config.DB_CONNECT_TIMEOUT,
max_inactive_connection_lifetime=60,
server_settings={"application_name": "messenger-api", "timezone": "UTC"})
async def stop(self):
if self.pool:
try:
await asyncio.wait_for(self.pool.close(), 3)
except Exception:
self.pool.terminate()
@asynccontextmanager
async def conn(self):
if self.pool is None:
raise unavailable("База данных не настроена")
try:
async with self.pool.acquire(timeout=config.DB_ACQUIRE_TIMEOUT) as connection:
yield connection
except DEPENDENCY_ERRORS as exc:
log("warning", "db_unavailable", error_type=type(exc).__name__)
raise unavailable() from exc
async def _run(self, method, sql, args, retry):
for attempt in (0, 1):
try:
async with self.conn() as c:
return await getattr(c, method)(sql, *args)
except Exception as exc:
if attempt == 0 and retry and isinstance(exc.__cause__, _RETRYABLE):
continue # разорванное соединение пула (рестарт БД): один повтор только для чтения
raise
async def fetch(self, sql, *args):
return await self._run("fetch", sql, args, True)
async def fetchrow(self, sql, *args):
return await self._run("fetchrow", sql, args, True)
async def fetchval(self, sql, *args):
return await self._run("fetchval", sql, args, True)
async def execute(self, sql, *args):
return await self._run("execute", sql, args, False)
async def ping(self):
return await asyncio.wait_for(self.fetchval("SELECT 1"), 1.0)
+335
View File
@@ -0,0 +1,335 @@
"""ASGI-приложение мессенджера (lab2): REST API, PostgreSQL, сессии Bearer, кэш Valkey."""
import asyncio
import base64
import binascii
import os
import re
import time
import uuid
import asyncpg
from . import config, passwords
from .db import DEPENDENCY_ERRORS, Database
from .sessions import SessionCache, Sessions
from .web import (ApiError, Request, bad, dt_to_us, encode_cursor, format_dt, log, new_request_id, page_params,
parse_json_object, parse_uuid, respond, unavailable, us_to_dt, valid_text, USERNAME_RE)
ROUTES = [
("health_live", re.compile(r"/health/live"), {"GET"}),
("health_ready", re.compile(r"/health/ready"), {"GET"}),
("users", re.compile(r"/api/v1/users"), {"POST"}),
("users_me", re.compile(r"/api/v1/users/me"), {"GET"}),
("create_session", re.compile(r"/api/v1/auth/sessions"), {"POST"}),
("session_current", re.compile(r"/api/v1/auth/sessions/current"), {"DELETE"}),
("chats", re.compile(r"/api/v1/chats"), {"GET", "POST"}),
("chat", re.compile(r"/api/v1/chats/(?P<chat_id>[^/]+)"), {"GET"}),
("messages", re.compile(r"/api/v1/chats/(?P<chat_id>[^/]+)/messages"), {"GET", "POST"}),
]
ROUTE_LABELS = {
"health_live": "/health/live", "health_ready": "/health/ready", "users": "/api/v1/users",
"users_me": "/api/v1/users/me", "create_session": "/api/v1/auth/sessions",
"session_current": "/api/v1/auth/sessions/current", "chats": "/api/v1/chats",
"chat": "/api/v1/chats/{chat_id}", "messages": "/api/v1/chats/{chat_id}/messages",
}
TOKEN_RE = re.compile(r"[A-Za-z0-9_-]{32,128}")
BEARER = 'Bearer realm="messenger"'
BASIC = 'Basic realm="messenger", charset="UTF-8"'
INSTANCE_ID = os.environ.get("INSTANCE_ID") or uuid.uuid4().hex[:12]
CHAT_SELECT = ("SELECT c.id, c.title, c.created_at, "
"(SELECT array_agg(m2.user_id ORDER BY m2.ord) FROM chat_members m2 WHERE m2.chat_id = c.id) AS member_ids ")
def user_json(row):
return {"id": str(row["id"]), "username": row["username"], "display_name": row["display_name"],
"created_at": format_dt(row["created_at"])}
def chat_json(row):
return {"id": str(row["id"]), "title": row["title"], "member_ids": [str(x) for x in row["member_ids"]],
"created_at": format_dt(row["created_at"])}
def message_json(row):
return {"id": str(row["id"]), "chat_id": str(row["chat_id"]), "sender_id": str(row["sender_id"]),
"text": row["text"], "created_at": format_dt(row["created_at"])}
def unauthorized(challenge=BEARER, message="Требуется действительная сессия"):
return ApiError(401, "unauthorized", message, {"www-authenticate": challenge})
class Messenger:
def __init__(self):
self.db = Database()
self.cache = SessionCache()
self.sessions = Sessions(self.db, self.cache)
self.inflight = 0
self.draining = False
# --- аутентификация ------------------------------------------------------
@staticmethod
def bearer_token(req):
header = req.headers.get("authorization", "")
scheme, _, token = header.partition(" ")
if scheme.lower() != "bearer" or not TOKEN_RE.fullmatch(token.strip()):
raise unauthorized()
return token.strip()
async def authenticate(self, req):
token = self.bearer_token(req)
user_id = await self.sessions.resolve(token)
if user_id is None:
raise unauthorized()
req.user_id, req.token = user_id, token
return user_id
# --- обработчики -----------------------------------------------------------
async def health_live(self, req, params):
return 200, {"status": "ok"}
async def health_ready(self, req, params):
# Критичная зависимость — PostgreSQL. Valkey — необязательный кэш: его отказ не останавливает API.
if self.draining:
raise unavailable("Сервис останавливается")
try:
await self.db.ping()
except ApiError:
raise
except Exception:
raise unavailable() from None
return 200, {"status": "ok"}
async def users(self, req, params):
req.require_json_media_type()
data = parse_json_object(await req.body(), {"username", "display_name", "password"},
{"username", "display_name", "password"})
username = data["username"]
if not isinstance(username, str) or not USERNAME_RE.fullmatch(username):
raise bad("username должен соответствовать [a-z0-9_]{3,32}")
display_name = valid_text(data["display_name"], "display_name", 100)
password = valid_text(data["password"], "password", 128, allow_empty=True)
if len(password) < 12:
raise bad("password должен содержать от 12 до 128 символов")
pw_hash = await passwords.hash_password(password)
row = await self.db.fetchrow(
"INSERT INTO users (id, username, display_name, password_hash) VALUES ($1, $2, $3, $4) "
"ON CONFLICT (username) DO NOTHING RETURNING id, username, display_name, created_at",
uuid.uuid4(), username, display_name, pw_hash)
if row is None:
raise ApiError(409, "conflict", "username уже занят")
return 201, user_json(row)
async def users_me(self, req, params):
user_id = await self.authenticate(req)
row = await self.db.fetchrow("SELECT id, username, display_name, created_at FROM users WHERE id = $1", user_id)
if row is None:
raise unauthorized()
return 200, user_json(row)
async def create_session(self, req, params):
header = req.headers.get("authorization", "")
scheme, _, value = header.partition(" ")
if scheme.lower() != "basic" or not value.strip():
raise unauthorized(BASIC, "Неверные учётные данные")
try:
decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8")
username, sep, password = decoded.partition(":")
if not sep:
raise ValueError
except (binascii.Error, ValueError, UnicodeDecodeError):
raise unauthorized(BASIC, "Неверные учётные данные") from None
row = None
if USERNAME_RE.fullmatch(username):
row = await self.db.fetchrow("SELECT id, username, display_name, created_at, password_hash FROM users "
"WHERE username = $1", username)
ok = await passwords.verify_password(row["password_hash"] if row else None, password)
if not ok:
raise unauthorized(BASIC, "Неверные учётные данные")
token, expires_at = await self.sessions.create(row["id"])
return 201, {"token": token, "token_type": "Bearer", "expires_at": format_dt(expires_at), "user": user_json(row)}
async def session_current(self, req, params):
await self.authenticate(req)
await self.sessions.revoke(req.token)
return 204, None
async def chats(self, req, params):
user_id = await self.authenticate(req)
if req.method == "GET":
limit, after = page_params(req.query, "c", user_id)
if after is None:
rows = await self.db.fetch(
CHAT_SELECT + "FROM chat_members m JOIN chats c ON c.id = m.chat_id WHERE m.user_id = $1 "
"ORDER BY m.chat_created_at, m.chat_id LIMIT $2", user_id, limit + 1)
else:
rows = await self.db.fetch(
CHAT_SELECT + "FROM chat_members m JOIN chats c ON c.id = m.chat_id WHERE m.user_id = $1 "
"AND (m.chat_created_at, m.chat_id) > ($2, $3) ORDER BY m.chat_created_at, m.chat_id LIMIT $4",
user_id, us_to_dt(after[0]), uuid.UUID(after[1]), limit + 1)
more = len(rows) > limit
rows = rows[:limit]
cursor = encode_cursor("c", user_id, (dt_to_us(rows[-1]["created_at"]), str(rows[-1]["id"]))) if more else None
return 200, {"items": [chat_json(r) for r in rows], "next_cursor": cursor}
req.require_json_media_type()
data = parse_json_object(await req.body(), {"title", "member_ids"}, {"title", "member_ids"})
title = valid_text(data["title"], "title", 100)
members = data["member_ids"]
if not isinstance(members, list) or not 1 <= len(members) <= 100:
raise bad("member_ids должен содержать от 1 до 100 элементов")
ids = [parse_uuid(m, "member_id") for m in members]
if len(set(ids)) != len(ids):
raise bad("member_ids содержит дубликаты")
if user_id not in ids:
raise bad("Создатель должен быть в member_ids")
chat_id = uuid.uuid4()
uuids = [uuid.UUID(i) for i in ids]
try:
async with self.db.conn() as c:
async with c.transaction(): # чат и участники создаются атомарно
# Существование участников проверяет внешний ключ chat_members.user_id: при неизвестном
# участнике вставка падает и откатывается вся транзакция, включая уже созданный чат.
created = await c.fetchval("INSERT INTO chats (id, title) VALUES ($1, $2) RETURNING created_at",
chat_id, title)
await c.execute(
"INSERT INTO chat_members (chat_id, user_id, chat_created_at, ord) "
"SELECT $1, u, $2, o FROM unnest($3::uuid[]) WITH ORDINALITY AS t(u, o)",
chat_id, created, uuids)
except asyncpg.ForeignKeyViolationError:
raise bad("Неизвестный участник") from None
return 201, {"id": str(chat_id), "title": title, "member_ids": ids, "created_at": format_dt(created)}
async def _require_member(self, user_id, params):
chat_id = parse_uuid(params["chat_id"], "chat_id")
ok = await self.db.fetchval("SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2", chat_id, user_id)
if not ok:
raise ApiError(404, "not_found", "Чат не найден")
return chat_id
async def chat(self, req, params):
user_id = await self.authenticate(req)
chat_id = parse_uuid(params["chat_id"], "chat_id")
row = await self.db.fetchrow(
CHAT_SELECT + "FROM chats c JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $2 WHERE c.id = $1",
chat_id, user_id)
if row is None:
raise ApiError(404, "not_found", "Чат не найден")
return 200, chat_json(row)
async def messages(self, req, params):
user_id = await self.authenticate(req)
chat_id = await self._require_member(user_id, params)
if req.method == "GET":
limit, after = page_params(req.query, "m", chat_id)
if after is None:
rows = await self.db.fetch(
"SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1 "
"ORDER BY created_at, id LIMIT $2", chat_id, limit + 1)
else:
rows = await self.db.fetch(
"SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1 "
"AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT $4",
chat_id, us_to_dt(after[0]), uuid.UUID(after[1]), limit + 1)
more = len(rows) > limit
rows = rows[:limit]
cursor = encode_cursor("m", chat_id, (dt_to_us(rows[-1]["created_at"]), str(rows[-1]["id"]))) if more else None
return 200, {"items": [message_json(r) for r in rows], "next_cursor": cursor}
req.require_json_media_type()
data = parse_json_object(await req.body(), {"text"}, {"text"})
text = valid_text(data["text"], "text", 4000)
row = await self.db.fetchrow(
"INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1, $2, $3, $4) "
"RETURNING id, chat_id, sender_id, text, created_at", uuid.uuid4(), chat_id, user_id, text)
return 201, message_json(row)
# --- ASGI ----------------------------------------------------------------------
async def __call__(self, scope, receive, send):
if scope["type"] == "lifespan":
return await self.lifespan(receive, send)
if scope["type"] != "http":
return
started = time.perf_counter()
request_id = new_request_id()
route_name, status, headers = "unknown", 500, {}
try:
req = Request(scope, receive, request_id)
handler, params, route_name = self.route(req.method, req.path)
if not route_name.startswith("health") and self.inflight >= config.MAX_INFLIGHT:
raise ApiError(429, "rate_limited", "Слишком много одновременных запросов",
{"retry-after": str(config.RETRY_AFTER_SECONDS)})
self.inflight += 1
try:
await asyncio.sleep(0)
status, body = await handler(req, params)
finally:
self.inflight -= 1
except ApiError as exc:
status, headers = exc.status, exc.headers
body = {"error": {"code": exc.code, "message": exc.message, "request_id": request_id}}
except DEPENDENCY_ERRORS as exc:
log("warning", "dependency_error", request_id=request_id, error_type=type(exc).__name__)
status, headers = 503, {"retry-after": str(config.RETRY_AFTER_SECONDS)}
body = {"error": {"code": "unavailable", "message": "Зависимость временно недоступна", "request_id": request_id}}
except Exception as exc:
log("error", "unhandled_exception", request_id=request_id, error_type=type(exc).__name__)
status = 500
body = {"error": {"code": "internal_error", "message": "Внутренняя ошибка", "request_id": request_id}}
await respond(send, status, body, request_id, headers, INSTANCE_ID)
if os.environ.get("ACCESS_LOG", "1") != "0":
log("info", "request", request_id=request_id, method=scope.get("method"),
route=ROUTE_LABELS.get(route_name, "unmatched"), status=status,
duration_ms=round((time.perf_counter() - started) * 1000, 3))
def route(self, method, path):
for name, pattern, methods in ROUTES:
m = pattern.fullmatch(path)
if m:
if method not in methods:
raise ApiError(405, "invalid_request", "Метод не поддерживается", {"allow": ", ".join(sorted(methods))})
return getattr(self, name), m.groupdict(), name
raise ApiError(404, "not_found", "Ресурс не найден")
async def lifespan(self, receive, send):
while True:
event = await receive()
if event["type"] == "lifespan.startup":
await self.db.start()
await self.cache.start()
log("info", "startup", env=config.APP_ENV, instance=INSTANCE_ID, cache=bool(config.VALKEY_URL),
session_ttl=config.SESSION_TTL_SECONDS, pool_max=config.DB_POOL_MAX)
await send({"type": "lifespan.startup.complete"})
elif event["type"] == "lifespan.shutdown":
self.draining = True
await self.cache.stop()
await self.db.stop()
log("info", "shutdown")
await send({"type": "lifespan.shutdown.complete"})
return
async def overloaded_app(scope, receive, send):
"""Ответ uvicorn при превышении --limit-concurrency в контрактном формате."""
if scope["type"] != "http":
return
request_id = new_request_id()
body = {"error": {"code": "unavailable", "message": "Сервер перегружен: слишком много соединений",
"request_id": request_id}}
await respond(send, 503, body, request_id, {"retry-after": str(config.RETRY_AFTER_SECONDS), "connection": "close"}, INSTANCE_ID)
def _install_overload_response():
for name in ("uvicorn.protocols.http.httptools_impl", "uvicorn.protocols.http.h11_impl"):
try:
module = __import__(name, fromlist=["service_unavailable"])
except ImportError:
continue
module.service_unavailable = overloaded_app
def create_app():
_install_overload_response()
return Messenger()
app = create_app()
+64
View File
@@ -0,0 +1,64 @@
"""Применение версионируемых SQL-миграций: python -m app.migrate
Свойства:
* повторный запуск ничего не делает (таблица schema_migrations);
* одновременный запуск нескольких экземпляров безопасен (advisory lock);
* каждая миграция — одна транзакция вместе с записью о применении;
* ждёт готовности PostgreSQL до MIGRATE_WAIT_SECONDS.
"""
import asyncio
import hashlib
import os
import sys
import time
import asyncpg
from . import config
from .web import log
LOCK_ID = 7352001
async def connect(deadline):
while True:
try:
return await asyncpg.connect(config.DATABASE_URL, timeout=3)
except (OSError, asyncpg.PostgresError, asyncio.TimeoutError) as exc:
if time.monotonic() > deadline:
raise
log("info", "waiting_for_database", error_type=type(exc).__name__)
await asyncio.sleep(1)
async def main():
wait = float(os.environ.get("MIGRATE_WAIT_SECONDS", "60"))
conn = await connect(time.monotonic() + wait)
try:
await conn.execute("SELECT pg_advisory_lock($1)", LOCK_ID)
await conn.execute("CREATE TABLE IF NOT EXISTS schema_migrations ("
"version text PRIMARY KEY, checksum text NOT NULL, applied_at timestamptz NOT NULL DEFAULT now())")
applied = {r["version"]: r["checksum"] for r in await conn.fetch("SELECT version, checksum FROM schema_migrations")}
directory = os.path.abspath(config.MIGRATIONS_DIR)
files = sorted(f for f in os.listdir(directory) if f.endswith(".sql"))
count = 0
for name in files:
sql = open(os.path.join(directory, name), encoding="utf-8").read()
checksum = hashlib.sha256(sql.encode("utf-8")).hexdigest()
if name in applied:
if applied[name] != checksum:
log("error", "migration_modified", version=name)
sys.exit(2)
continue
async with conn.transaction():
await conn.execute(sql)
await conn.execute("INSERT INTO schema_migrations (version, checksum) VALUES ($1, $2)", name, checksum)
count += 1
log("info", "migration_applied", version=name)
log("info", "migrations_done", applied=count, total=len(files))
finally:
await conn.close()
if __name__ == "__main__":
asyncio.run(main())
+31
View File
@@ -0,0 +1,31 @@
"""Хеширование паролей: Argon2id (библиотека argon2-cffi), вычисления вне event loop."""
import asyncio
from concurrent.futures import ThreadPoolExecutor
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError, VerifyMismatchError
from . import config
_hasher = PasswordHasher(time_cost=config.ARGON2_TIME_COST, memory_cost=config.ARGON2_MEMORY_KIB,
parallelism=config.ARGON2_PARALLELISM)
_pool = ThreadPoolExecutor(max_workers=config.HASH_CONCURRENCY, thread_name_prefix="argon2")
# Для неизвестного username проверяем фиктивный хеш: время ответа не выдаёт существование пользователя.
_DUMMY = _hasher.hash("dummy-password-for-timing-equalisation")
async def hash_password(password):
return await asyncio.get_running_loop().run_in_executor(_pool, _hasher.hash, password)
def _verify(stored, password):
try:
return _hasher.verify(stored, password)
except (VerifyMismatchError, VerificationError, InvalidHashError):
return False
async def verify_password(stored, password):
"""stored=None -> проверка фиктивного хеша, результат всегда False."""
ok = await asyncio.get_running_loop().run_in_executor(_pool, _verify, stored or _DUMMY, password)
return ok and stored is not None
+131
View File
@@ -0,0 +1,131 @@
"""Сессии: PostgreSQL — источник истины; Valkey — кэш с TTL (read-through).
Политики:
* токен — 256 бит из secrets; в БД и Valkey хранится только SHA-256 токена;
* expiry: expires_at в БД (по часам БД). В кэше TTL = min(остаток жизни, SESSION_CACHE_TTL_SECONDS);
* инвалидация: logout помечает revoked_at в БД и удаляет ключ в Valkey;
* Valkey недоступен -> кэш обходится (чтение из БД), анонимный запрос никогда не считается доверенным;
circuit breaker не даёт каждому запросу ждать таймаут;
* окно устаревания: если Valkey был недоступен во время logout, ключ может прожить до SESSION_CACHE_TTL_SECONDS.
"""
import hashlib
import secrets
import time
from . import config
from .web import log
try:
import redis.asyncio as aioredis
except ImportError: # кэш опционален
aioredis = None
def token_hash(token):
return hashlib.sha256(token.encode("ascii")).digest()
class SessionCache:
def __init__(self):
self.client = None
self.down_until = 0.0
self.stats = {"hit": 0, "miss": 0, "error": 0}
async def start(self):
if config.VALKEY_URL and aioredis:
self.client = aioredis.Redis.from_url(config.VALKEY_URL, socket_timeout=config.VALKEY_TIMEOUT,
socket_connect_timeout=config.VALKEY_TIMEOUT)
async def stop(self):
if self.client:
await self.client.aclose()
def _usable(self):
return self.client is not None and time.monotonic() >= self.down_until
def _fail(self, exc):
self.stats["error"] += 1
if time.monotonic() >= self.down_until:
log("warning", "session_cache_unavailable", error_type=type(exc).__name__)
self.down_until = time.monotonic() + config.VALKEY_BREAKER_SECONDS
async def get(self, key):
if not self._usable():
return None
try:
value = await self.client.get(b"s:" + key)
except Exception as exc:
self._fail(exc)
return None
self.stats["hit" if value is not None else "miss"] += 1
return value
async def put(self, key, value, ttl):
if not self._usable() or ttl <= 0:
return
try:
await self.client.set(b"s:" + key, value, ex=max(1, int(ttl)))
except Exception as exc:
self._fail(exc)
async def delete(self, key):
if not self._usable():
return
try:
await self.client.delete(b"s:" + key)
except Exception as exc:
self._fail(exc)
async def ping(self):
if self.client is None:
return None
try:
return bool(await self.client.ping())
except Exception:
return False
class Sessions:
def __init__(self, db, cache):
self.db, self.cache = db, cache
@staticmethod
def _cache_value(user_id, expires_at):
return ("%s|%d" % (user_id, int(expires_at.timestamp() * 1000))).encode()
async def create(self, user_id):
token = secrets.token_urlsafe(32) # 256 бит энтропии
digest = token_hash(token)
row = await self.db.fetchrow(
"INSERT INTO sessions (token_hash, user_id, expires_at) "
"VALUES ($1, $2, now() + make_interval(secs => $3)) RETURNING expires_at",
digest, user_id, float(config.SESSION_TTL_SECONDS))
remaining = row["expires_at"].timestamp() - time.time()
await self.cache.put(digest, self._cache_value(user_id, row["expires_at"]),
min(remaining, config.SESSION_CACHE_TTL_SECONDS))
return token, row["expires_at"]
async def resolve(self, token):
"""token -> user_id (str) либо None, если сессии нет/истекла/отозвана."""
digest = token_hash(token)
cached = await self.cache.get(digest)
if cached is not None:
user_id, _, expires_ms = cached.decode().partition("|")
if int(expires_ms) > time.time() * 1000:
return user_id
await self.cache.delete(digest)
row = await self.db.fetchrow(
"SELECT user_id, expires_at FROM sessions "
"WHERE token_hash = $1 AND revoked_at IS NULL AND expires_at > now()", digest)
if row is None:
return None
user_id = str(row["user_id"])
remaining = row["expires_at"].timestamp() - time.time()
await self.cache.put(digest, self._cache_value(user_id, row["expires_at"]),
min(remaining, config.SESSION_CACHE_TTL_SECONDS))
return user_id
async def revoke(self, token):
digest = token_hash(token)
await self.db.execute("UPDATE sessions SET revoked_at = now() WHERE token_hash = $1 AND revoked_at IS NULL", digest)
await self.cache.delete(digest)
+187
View File
@@ -0,0 +1,187 @@
"""Общий HTTP-слой: ошибки, запрос, валидация, курсоры, ответы, журнал."""
import base64
import json
import re
import sys
import time
import uuid
from datetime import datetime, timedelta, timezone
from urllib.parse import parse_qsl
from . import config
UUID_RE = re.compile(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}")
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}")
LIMIT_RE = re.compile(r"[0-9]{1,9}")
EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)
class ApiError(Exception):
def __init__(self, status, code, message, headers=None):
super().__init__(message)
self.status, self.code, self.message, self.headers = status, code, message, headers or {}
def bad(message):
return ApiError(400, "invalid_request", message)
def unavailable(message="Зависимость временно недоступна"):
return ApiError(503, "unavailable", message, {"retry-after": str(config.RETRY_AFTER_SECONDS)})
def log(level, msg, **fields):
record = {"ts": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), "level": level, "msg": msg}
record.update(fields)
sys.stdout.write(json.dumps(record, ensure_ascii=False) + "\n")
sys.stdout.flush()
# --- время -------------------------------------------------------------------
def format_dt(value):
value = value.astimezone(timezone.utc)
return value.strftime("%Y-%m-%dT%H:%M:%S.") + "%06dZ" % value.microsecond
def dt_to_us(value):
return (value - EPOCH) // timedelta(microseconds=1)
def us_to_dt(us):
return EPOCH + timedelta(microseconds=us)
# --- валидация ---------------------------------------------------------------
def parse_uuid(value, what="id"):
if not isinstance(value, str) or not UUID_RE.fullmatch(value):
raise bad("Некорректный %s" % what)
return value.lower()
def valid_text(value, field, maximum, allow_empty=False):
if not isinstance(value, str):
raise bad("Поле %s должно быть строкой" % field)
try:
value.encode("utf-8")
except UnicodeEncodeError:
raise bad("Поле %s содержит некорректные символы" % field) from None
if "\x00" in value:
raise bad("Поле %s содержит NUL" % field)
if len(value) > maximum:
raise bad("Поле %s слишком длинное" % field)
if not allow_empty and not value.strip():
raise bad("Поле %s не может быть пустым" % field)
return value
def _reject_constant(name):
raise ValueError(name)
def parse_json_object(raw, required, allowed):
try:
data = json.loads(raw.decode("utf-8"), parse_constant=_reject_constant)
except (UnicodeDecodeError, ValueError, RecursionError):
raise bad("Тело запроса — некорректный JSON") from None
if not isinstance(data, dict):
raise bad("Ожидается JSON-объект")
if set(data) - allowed:
raise bad("Лишние поля в запросе")
if any(key not in data for key in required):
raise bad("Не хватает обязательных полей")
return data
def encode_cursor(kind, resource, key):
payload = json.dumps({"k": kind, "r": resource, "t": key[0], "i": key[1]}, separators=(",", ":"))
return base64.urlsafe_b64encode(payload.encode()).decode().rstrip("=")
def decode_cursor(text, kind, resource):
try:
data = json.loads(base64.urlsafe_b64decode(text + "=" * (-len(text) % 4)).decode())
if (not isinstance(data, dict) or data.get("k") != kind or data.get("r") != resource
or not isinstance(data.get("t"), int) or isinstance(data.get("t"), bool)
or not isinstance(data.get("i"), str) or not UUID_RE.fullmatch(data["i"])
or not -62135596800000000 < data["t"] < 253402300799000000):
raise ValueError
return data["t"], data["i"]
except (ValueError, UnicodeError):
raise bad("Некорректный cursor") from None
def page_params(query, kind, resource):
limit, cursor = 50, None
if "limit" in query:
if len(query["limit"]) != 1 or not LIMIT_RE.fullmatch(query["limit"][0]):
raise bad("limit должен быть целым числом 1–100")
limit = int(query["limit"][0])
if not 1 <= limit <= 100:
raise bad("limit должен быть целым числом 1–100")
if "cursor" in query:
if len(query["cursor"]) != 1 or not query["cursor"][0]:
raise bad("Некорректный cursor")
cursor = decode_cursor(query["cursor"][0], kind, resource)
return limit, cursor
def parse_query(raw):
result = {}
if raw:
for key, value in parse_qsl(raw.decode("latin-1"), keep_blank_values=True):
result.setdefault(key, []).append(value)
return result
class Request:
def __init__(self, scope, receive, request_id):
self.method = scope["method"]
self.path = scope["path"]
self.query = parse_query(scope.get("query_string", b""))
self.headers = {k.decode("latin-1").lower(): v.decode("latin-1") for k, v in scope["headers"]}
self.receive = receive
self.request_id = request_id
self.user_id = None
async def body(self):
declared = self.headers.get("content-length")
if declared is not None:
if not declared.isdigit():
raise bad("Некорректный Content-Length")
if int(declared) > config.MAX_BODY_BYTES:
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое", {"connection": "close"})
chunks, size = [], 0
while True:
event = await self.receive()
if event["type"] == "http.disconnect":
raise bad("Соединение закрыто клиентом")
chunk = event.get("body", b"")
size += len(chunk)
if size > config.MAX_BODY_BYTES:
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое", {"connection": "close"})
chunks.append(chunk)
if not event.get("more_body"):
return b"".join(chunks)
def require_json_media_type(self):
media = self.headers.get("content-type", "").split(";")[0].strip().lower()
if media != "application/json":
raise ApiError(415, "unsupported_media_type", "Ожидается Content-Type: application/json")
async def respond(send, status, body, request_id, extra=None, instance_id=None):
payload = b"" if status == 204 else json.dumps(body, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
headers = [(b"x-request-id", request_id.encode())]
if status != 204:
headers += [(b"content-type", b"application/json"), (b"content-length", str(len(payload)).encode())]
else:
headers.append((b"content-length", b"0"))
if instance_id:
headers.append((b"x-instance-id", instance_id.encode()))
headers += [(k.encode(), v.encode()) for k, v in (extra or {}).items()]
await send({"type": "http.response.start", "status": status, "headers": headers})
await send({"type": "http.response.body", "body": payload})
def new_request_id():
return uuid.uuid4().hex
+206
View File
@@ -0,0 +1,206 @@
"""Собственные тесты lab2 против запущенного стенда (docker compose up -d).
python -m unittest discover -s student-tests -v # BASE_URL по умолчанию http://127.0.0.1:8080
Тесты используют только синтетические данные и ничего не удаляют. Проверки expiry и недоступности
зависимостей лежат отдельно (test_expiry.py, test_dependencies.py): они управляют контейнерами.
"""
import base64
import json
import os
import subprocess
import unittest
import urllib.error
import urllib.request
import uuid
from concurrent.futures import ThreadPoolExecutor
from urllib.parse import quote
BASE = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/")
ROOT = os.path.join(os.path.dirname(__file__), "..")
def call(method, path, body=None, token=None, headers=None, raw=None):
h = dict(headers or {})
data = raw
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
h.setdefault("Content-Type", "application/json")
if token:
h["Authorization"] = "Bearer " + token
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
try:
with urllib.request.urlopen(req, timeout=10) as resp:
status, hdrs, payload = resp.status, resp.headers, resp.read()
except urllib.error.HTTPError as err:
status, hdrs, payload = err.code, err.headers, err.read()
return status, hdrs, (json.loads(payload) if payload else None)
def basic(username, password):
return {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode("utf-8")).decode()}
def register(prefix="u"):
name = "%s_%s" % (prefix, uuid.uuid4().hex[:12])
password = "Pa55:word-" + uuid.uuid4().hex # двоеточие в пароле допустимо
status, _, user = call("POST", "/api/v1/users", {"username": name, "display_name": "Имя " + name, "password": password})
assert status == 201, user
status, _, session = call("POST", "/api/v1/auth/sessions", headers=basic(name, password))
assert status == 201, session
return {"user": user, "password": password, "token": session["token"], "session": session}
def psql(sql):
out = subprocess.run(["docker", "compose", "--env-file", ".env", "exec", "-T", "postgres", "psql", "-U", "messenger",
"-d", "messenger", "-Atc", sql], cwd=ROOT, capture_output=True, text=True, check=True)
return out.stdout.strip()
class AuthTest(unittest.TestCase):
def assertError(self, result, status, code):
self.assertEqual(result[0], status, result[2])
self.assertEqual(result[2]["error"]["code"], code)
self.assertEqual(result[2]["error"]["request_id"], result[1]["X-Request-Id"])
def test_register_validation(self):
base = {"username": "val_" + uuid.uuid4().hex[:8], "display_name": "x", "password": "p" * 12}
for patch in ({"password": "short"}, {"password": "p" * 129}, {"password": 12345678901234}, {"extra": 1},
{"username": "BAD"}, {"display_name": " "}):
body = dict(base, **patch)
self.assertError(call("POST", "/api/v1/users", body), 400, "invalid_request")
missing = {k: v for k, v in base.items() if k != "password"}
self.assertError(call("POST", "/api/v1/users", missing), 400, "invalid_request")
self.assertEqual(call("POST", "/api/v1/users", dict(base, password="я" * 12))[0], 201) # 12 code points
def test_password_is_not_exposed_or_stored_plain(self):
actor = register()
self.assertEqual(set(actor["user"]), {"id", "username", "display_name", "created_at"})
stored = psql("SELECT password_hash FROM users WHERE username = '%s'" % actor["user"]["username"])
self.assertTrue(stored.startswith("$argon2id$"), stored[:12])
self.assertNotIn(actor["password"], stored)
def test_wrong_password_and_unknown_user_are_indistinguishable(self):
actor = register()
wrong = call("POST", "/api/v1/auth/sessions", headers=basic(actor["user"]["username"], "wrong-password-123"))
unknown = call("POST", "/api/v1/auth/sessions", headers=basic("nobody_" + uuid.uuid4().hex[:8], "wrong-password-123"))
for r in (wrong, unknown):
self.assertError(r, 401, "unauthorized")
self.assertEqual(r[1]["WWW-Authenticate"], 'Basic realm="messenger", charset="UTF-8"')
self.assertEqual(wrong[2]["error"]["message"], unknown[2]["error"]["message"])
for bad in ({}, {"Authorization": "Basic !!!"}, {"Authorization": "Basic " + base64.b64encode(b"nocolon").decode()},
{"Authorization": "Bearer abc"}):
self.assertEqual(call("POST", "/api/v1/auth/sessions", headers=bad)[0], 401)
def test_bearer_rules(self):
actor = register()
self.assertEqual(call("GET", "/api/v1/users/me", token=actor["token"])[2], actor["user"])
for headers in ({}, basic(actor["user"]["username"], actor["password"]), {"X-User-Id": actor["user"]["id"]},
{"Authorization": "Bearer " + "A" * 43}, {"Authorization": "Bearer short"}):
r = call("GET", "/api/v1/users/me", headers=headers)
self.assertError(r, 401, "unauthorized")
self.assertEqual(r[1]["WWW-Authenticate"], 'Bearer realm="messenger"')
other = register()
me = call("GET", "/api/v1/users/me", token=actor["token"], headers={"X-User-Id": other["user"]["id"]})[2]
self.assertEqual(me["id"], actor["user"]["id"]) # X-User-Id игнорируется
def test_session_shape_entropy_and_logout(self):
actor = register()
s = actor["session"]
self.assertEqual(s["token_type"], "Bearer")
self.assertGreaterEqual(len(s["token"]), 43) # 32 байта в base64url = 256 бит
self.assertNotIn(actor["user"]["id"], s["token"])
self.assertNotEqual(register()["token"], s["token"])
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", token=s["token"])[0], 204)
self.assertError(call("GET", "/api/v1/users/me", token=s["token"]), 401, "unauthorized")
self.assertError(call("DELETE", "/api/v1/auth/sessions/current", token=s["token"]), 401, "unauthorized")
def test_logout_revokes_in_database_and_cache(self):
actor = register()
call("GET", "/api/v1/users/me", token=actor["token"]) # прогреваем кэш
call("DELETE", "/api/v1/auth/sessions/current", token=actor["token"])
revoked = psql("SELECT count(*) FROM sessions s JOIN users u ON u.id = s.user_id "
"WHERE u.username = '%s' AND s.revoked_at IS NOT NULL" % actor["user"]["username"])
self.assertEqual(revoked, "1")
def test_token_only_stored_as_hash(self):
actor = register()
count = psql("SELECT count(*) FROM sessions WHERE token_hash = '\\x00'::bytea OR encode(token_hash,'escape') = '%s'" % actor["token"])
self.assertEqual(count, "0")
def test_concurrent_registration_of_same_username(self):
name = "race_" + uuid.uuid4().hex[:10]
body = {"username": name, "display_name": "x", "password": "racing-password-1"}
with ThreadPoolExecutor(12) as pool:
codes = sorted(pool.map(lambda _: call("POST", "/api/v1/users", body)[0], range(12)))
self.assertEqual(codes, [201] + [409] * 11)
self.assertEqual(psql("SELECT count(*) FROM users WHERE username = '%s'" % name), "1")
class DataTest(unittest.TestCase):
def test_chat_creation_is_atomic(self):
a = register()
before = psql("SELECT (SELECT count(*) FROM chats) || '/' || (SELECT count(*) FROM chat_members)")
ghost = str(uuid.uuid4())
r = call("POST", "/api/v1/chats", {"title": "откат", "member_ids": [a["user"]["id"], ghost]}, token=a["token"])
self.assertEqual(r[0], 400)
after = psql("SELECT (SELECT count(*) FROM chats) || '/' || (SELECT count(*) FROM chat_members)")
self.assertEqual(before, after, "после неудачного создания не должно остаться чата или участников")
ok = call("POST", "/api/v1/chats", {"title": "ок", "member_ids": [a["user"]["id"]]}, token=a["token"])
self.assertEqual(ok[0], 201)
def test_foreign_chat_empty_message_bad_json(self):
a, b, eve = register(), register(), register()
chat = call("POST", "/api/v1/chats", {"title": "ЛС", "member_ids": [a["user"]["id"], b["user"]["id"]]}, a["token"])[2]
path = "/api/v1/chats/%s/messages" % chat["id"]
self.assertEqual(call("POST", path, {"text": "чужое"}, eve["token"])[0], 404)
self.assertEqual(call("GET", path, token=eve["token"])[0], 404)
self.assertEqual(call("POST", path, {"text": " "}, a["token"])[0], 400)
self.assertEqual(call("POST", path, raw=b"{oops", token=a["token"], headers={"Content-Type": "application/json"})[0], 400)
self.assertEqual(call("POST", path, {"text": "x", "sender_id": b["user"]["id"]}, a["token"])[0], 400)
sent = call("POST", path, {"text": "Привет 👋"}, a["token"])[2]
self.assertEqual(sent["sender_id"], a["user"]["id"])
def test_multi_page_history_and_cursor_binding(self):
a, b = register(), register()
chat = call("POST", "/api/v1/chats", {"title": "стр", "member_ids": [a["user"]["id"], b["user"]["id"]]}, a["token"])[2]
other = call("POST", "/api/v1/chats", {"title": "др", "member_ids": [a["user"]["id"]]}, a["token"])[2]
path = "/api/v1/chats/%s/messages" % chat["id"]
sent = [call("POST", path, {"text": "m%d" % i}, (a if i % 2 else b)["token"])[2] for i in range(23)]
walked, cursor, pages = [], None, 0
while True:
q = "?limit=%d" % (5 if pages % 2 == 0 else 8) + ("&cursor=" + quote(cursor, safe="") if cursor else "")
page = call("GET", path + q, token=b["token"])[2]
walked += page["items"]
pages += 1
cursor = page["next_cursor"]
if not cursor:
break
self.assertEqual(walked, sent)
self.assertGreaterEqual(pages, 3)
first = call("GET", path + "?limit=1", token=a["token"])[2]["next_cursor"]
r = call("GET", "/api/v1/chats/%s/messages?cursor=%s" % (other["id"], quote(first, safe="")), token=a["token"])
self.assertEqual(r[0], 400)
def test_parallel_writes_from_many_clients(self):
users = [register() for _ in range(5)]
chat = call("POST", "/api/v1/chats", {"title": "гонки", "member_ids": [u["user"]["id"] for u in users]}, users[0]["token"])[2]
path = "/api/v1/chats/%s/messages" % chat["id"]
def client(u):
return [call("POST", path, {"text": "%s-%d" % (u["user"]["username"], i)}, u["token"])[0] for i in range(20)]
with ThreadPoolExecutor(5) as pool:
codes = [c for part in pool.map(client, users) for c in part]
self.assertEqual(codes, [201] * 100)
total, cursor = [], None
while True:
page = call("GET", path + "?limit=100" + ("&cursor=" + quote(cursor, safe="") if cursor else ""), token=users[0]["token"])[2]
total += page["items"]
cursor = page["next_cursor"]
if not cursor:
break
self.assertEqual(len({m["id"] for m in total}), 100)
if __name__ == "__main__":
unittest.main()
+80
View File
@@ -0,0 +1,80 @@
"""Поведение при недоступности зависимостей: Valkey (кэш) и PostgreSQL (источник истины).
python student-tests/test_dependencies.py
Контейнеры останавливаются и запускаются обратно (volumes сохраняются). Ожидания:
* Valkey остановлен -> кэш обходится, API работает (чтение сессии из PostgreSQL), logout работает;
* PostgreSQL остановлен -> 503 в контрактном формате с Retry-After (не 500, не «анонимный» доступ),
/health/ready = 503, запрос без токена по-прежнему 401; после запуска БД API восстанавливается сам.
"""
import os
import subprocess
import sys
import time
import unittest
sys.path.insert(0, os.path.dirname(__file__))
from test_api import ROOT, basic, call, register # noqa: E402
def compose(*args):
return subprocess.run(["docker", "compose", "--env-file", ".env", *args], cwd=ROOT, check=True, capture_output=True, text=True)
def wait(predicate, seconds=60):
deadline = time.time() + seconds
while time.time() < deadline:
try:
if predicate():
return
except Exception:
pass
time.sleep(0.5)
raise RuntimeError("условие не выполнено за %d с" % seconds)
class DependencyTest(unittest.TestCase):
def tearDown(self):
compose("start", "postgres", "valkey")
wait(lambda: call("GET", "/health/ready")[0] == 200)
def test_valkey_down_is_bypassed(self):
actor = register("dep")
self.assertEqual(call("GET", "/api/v1/users/me", token=actor["token"])[0], 200)
compose("stop", "valkey")
started = time.time()
for _ in range(5):
self.assertEqual(call("GET", "/api/v1/users/me", token=actor["token"])[0], 200)
self.assertLess(time.time() - started, 3, "circuit breaker не должен давать каждому запросу ждать таймаут")
# вход и выход работают без кэша
s = call("POST", "/api/v1/auth/sessions", headers=basic(actor["user"]["username"], actor["password"]))
self.assertEqual(s[0], 201)
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", token=s[2]["token"])[0], 204)
self.assertEqual(call("GET", "/api/v1/users/me", token=s[2]["token"])[0], 401) # отзыв виден без кэша
self.assertEqual(call("GET", "/health/ready")[0], 200) # кэш не критичен для readiness
def test_postgres_down_gives_bounded_503_never_anonymous_access(self):
actor = register("dep")
self.assertEqual(call("GET", "/api/v1/users/me", token=actor["token"])[0], 200) # токен в кэше
compose("stop", "postgres")
time.sleep(1)
for method, path, body, token in (("GET", "/api/v1/users/me", None, actor["token"]),
("GET", "/api/v1/chats", None, actor["token"]),
("POST", "/api/v1/chats", {"title": "x", "member_ids": [actor["user"]["id"]]}, actor["token"]),
("GET", "/api/v1/users/me", None, "Z" * 43)): # неизвестный токен: кэш пуст -> БД -> 503
r = call(method, path, body, token)
self.assertEqual(r[0], 503, (path, r))
self.assertEqual(r[2]["error"]["code"], "unavailable")
self.assertGreaterEqual(int(r[1]["Retry-After"]), 1)
self.assertEqual(r[2]["error"]["request_id"], r[1]["X-Request-Id"])
r = call("POST", "/api/v1/auth/sessions", headers=basic(actor["user"]["username"], actor["password"]))
self.assertEqual(r[0], 503)
self.assertEqual(call("GET", "/health/ready")[0], 503)
self.assertEqual(call("GET", "/health/live")[0], 200)
self.assertEqual(call("GET", "/api/v1/users/me")[0], 401) # без токена — по-прежнему 401
compose("start", "postgres")
wait(lambda: call("GET", "/health/ready")[0] == 200)
self.assertEqual(call("GET", "/api/v1/users/me", token=actor["token"])[0], 200) # сессия пережила простой БД
if __name__ == "__main__":
unittest.main()
+69
View File
@@ -0,0 +1,69 @@
"""Проверка срока жизни сессии при коротком SESSION_TTL_SECONDS (по умолчанию 2).
python student-tests/test_expiry.py
Скрипт пересоздаёт только контейнер api с SESSION_TTL_SECONDS=2, проверяет expiry и возвращает настройки
по умолчанию. Данные и volumes не затрагиваются.
"""
import os
import subprocess
import sys
import time
import unittest
sys.path.insert(0, os.path.dirname(__file__))
from test_api import ROOT, call, register # noqa: E402
TTL = 2
def compose(*args, env=None):
return subprocess.run(["docker", "compose", "--env-file", ".env", *args], cwd=ROOT, check=True,
capture_output=True, text=True, env=dict(os.environ, **(env or {})))
def wait_ready(seconds=60):
deadline = time.time() + seconds
while time.time() < deadline:
try:
if call("GET", "/health/ready")[0] == 200:
return
except Exception:
pass
time.sleep(0.5)
raise RuntimeError("api не стал ready")
class ExpiryTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
compose("up", "-d", "--no-deps", "--force-recreate", "api", env={"SESSION_TTL_SECONDS": str(TTL)})
wait_ready()
@classmethod
def tearDownClass(cls):
compose("up", "-d", "--no-deps", "--force-recreate", "api")
wait_ready()
def test_session_expires_after_ttl(self):
actor = register("exp")
session = actor["session"]
self.assertEqual(call("GET", "/api/v1/users/me", token=actor["token"])[0], 200) # валидна, кэш прогрет
time.sleep(TTL + 1.5)
r = call("GET", "/api/v1/users/me", token=actor["token"])
self.assertEqual(r[0], 401, "после TTL токен должен быть отвергнут (и кэшем, и БД)")
self.assertEqual(r[1]["WWW-Authenticate"], 'Bearer realm="messenger"')
self.assertEqual(r[2]["error"]["code"], "unauthorized")
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", token=actor["token"])[0], 401)
self.assertIn("expires_at", session)
def test_expiry_is_not_extended_by_use(self):
actor = register("exp")
for _ in range(3):
call("GET", "/api/v1/users/me", token=actor["token"])
time.sleep(0.5)
time.sleep(1.5)
self.assertEqual(call("GET", "/api/v1/users/me", token=actor["token"])[0], 401)
if __name__ == "__main__":
unittest.main()