forked from mtusi2026/mtusi2026lab2
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
ffb98242ff |
+13
-3
@@ -1,11 +1,21 @@
|
||||
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
|
||||
# These are logical interface suggestions; map actual framework names in REPORT.md.
|
||||
# scripts/init-secrets.sh делает это автоматически и создаёт secrets/.
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
# Строка подключения читается из файла (Docker secret), значение в окружение не попадает.
|
||||
# Файл создаёт scripts/init-secrets.sh: secrets/database_url -> /run/secrets/database_url.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
# Ограниченный пул соединений и таймаут SQL.
|
||||
DB_POOL_SIZE=10
|
||||
DB_STATEMENT_TIMEOUT_MS=5000
|
||||
# Источник истины для сессий — PostgreSQL; Valkey — кэш проверенных сессий (SESSION_CACHE=off отключает).
|
||||
SESSION_STORE=postgres
|
||||
SESSION_CACHE=valkey
|
||||
# URL Valkey читается из файла (Docker secret secrets/cache_url, создаёт scripts/init-secrets.sh).
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
# Срок жизни записи кэша (не больше остатка сессии), таймаут операций и пауза обхода после отказа.
|
||||
SESSION_CACHE_TTL_SECONDS=30
|
||||
CACHE_TIMEOUT_MS=250
|
||||
CACHE_RETRY_SECONDS=5
|
||||
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
# Lab2: мессенджер на Python 3.12 + PostgreSQL (драйвер psycopg 3).
|
||||
FROM python:3.12.7-slim
|
||||
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONUNBUFFERED=1 \
|
||||
APP_HOST=0.0.0.0 \
|
||||
APP_PORT=8080
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
# Сначала зависимости с закреплёнными версиями — слой кэшируется, пока не изменится requirements.txt.
|
||||
COPY requirements.txt /app/
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
COPY src/ /app/src/
|
||||
COPY migrations/ /app/migrations/
|
||||
|
||||
# Запуск без root; сервер — основной процесс контейнера (PID 1), корректно обрабатывает SIGTERM.
|
||||
RUN useradd --no-create-home --uid 10001 app
|
||||
USER app
|
||||
|
||||
EXPOSE 8080
|
||||
HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=5 \
|
||||
CMD ["python", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).status == 200 else 1)"]
|
||||
CMD ["python", "/app/src/server.py"]
|
||||
@@ -4,7 +4,7 @@ CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence
|
||||
.PHONY: help check validate test load test-persistence secrets up down student-test student-bench
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@@ -24,3 +24,20 @@ 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)
|
||||
|
||||
# --- Цели студента (lab2) ---
|
||||
secrets:
|
||||
sh scripts/init-secrets.sh
|
||||
|
||||
up: secrets
|
||||
docker compose --env-file .env up -d --build --wait
|
||||
|
||||
down:
|
||||
docker compose --env-file .env down
|
||||
|
||||
student-test:
|
||||
$(PYTHON) student-tests/test_lab2.py --base-url "$(BASE_URL)" $(STUDENT_ARGS)
|
||||
|
||||
student-bench:
|
||||
$(PYTHON) student-tests/history_bench.py --base-url "$(BASE_URL)"
|
||||
$(PYTHON) student-tests/cache_bench.py --base-url "$(BASE_URL)" --label valkey
|
||||
|
||||
@@ -1,37 +1,253 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Автор, группа: Лазарев Юрий Сергеевич, БПИ2303
|
||||
- Целевая оценка; выбранный трек 5, если нужен: **4**, трек 5 не заявлен
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Использованные источники, библиотеки и помощь ИИ: Python 3.12 (стандартная библиотека: `http.server`, `hashlib.scrypt`, `secrets`, `hmac`), `psycopg[binary]==3.2.3`, `psycopg-pool==3.2.4`, `redis==5.2.1` (клиент протокола RESP, работает с Valkey); образы `python:3.12.7-slim`, `postgres:16.4-alpine`, `valkey/valkey:8.0.2-alpine`. Документация PostgreSQL (transactions, EXPLAIN, constraints), Valkey (persistence, eviction), RFC 7617. Код перенесён из моей lab1 и доработан с помощью ИИ-ассистента (Claude), проверен и запущен автором.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Требования: Docker Engine 28 с Compose v2 (проверено: Docker Desktop 28.0.4, Compose v2.34.0, macOS), Python 3.9+ на хосте только для тестов, `make`. Порты `127.0.0.1:8080` и `127.0.0.1:8081` (тест TTL) должны быть свободны.
|
||||
|
||||
```sh
|
||||
# 1. Локальные синтетические секреты и .env (значения не печатаются; повторный запуск ничего не перезаписывает)
|
||||
sh scripts/init-secrets.sh # или: make secrets
|
||||
# secrets/postgres_password, secrets/database_url, secrets/valkey.conf, secrets/cache_url (каталог в .gitignore)
|
||||
|
||||
# 2. Проверка конфигурации, сборка и запуск API + PostgreSQL + Valkey; --wait ждёт healthy
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build --wait # или: make up
|
||||
|
||||
# 3. Готовность
|
||||
curl -si http://localhost:8080/health/ready # 200 {"status": "ok"}
|
||||
|
||||
# 4. Публичные проверки
|
||||
make check
|
||||
make test
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
|
||||
# 5. Собственные проверки: границы, гонка, откат, TTL, отказ БД, кэш и отказ Valkey, рестарт
|
||||
docker compose --env-file .env --profile ttl up -d --wait api-short-ttl # API с SESSION_TTL_SECONDS=2 на :8081
|
||||
python3 student-tests/test_lab2.py --expiry-url http://localhost:8081 --db-outage --cache --persistence
|
||||
docker compose --env-file .env --profile ttl stop api-short-ttl
|
||||
|
||||
# 6. План запроса истории на 110 000 сообщений + обход истории через API (добавляет синтетические данные)
|
||||
python3 student-tests/history_bench.py --big 100000 --small-chats 20 --small-size 500
|
||||
|
||||
# 7. Польза кэша: транзакции PostgreSQL и задержка на 1000 проверок токена
|
||||
python3 student-tests/cache_bench.py --label valkey
|
||||
SESSION_CACHE=off docker compose --env-file .env up -d --wait api
|
||||
python3 student-tests/cache_bench.py --label off
|
||||
docker compose --env-file .env up -d --wait api # вернуть кэш
|
||||
```
|
||||
|
||||
**Миграции** применяются автоматически при старте API (каталог `migrations/`, таблица `schema_migrations`, advisory lock). Отдельный запуск без старта сервера:
|
||||
|
||||
```sh
|
||||
docker compose --env-file .env run --rm api python /app/src/server.py --migrate-only
|
||||
```
|
||||
|
||||
**Безопасная остановка** (данные и том сохраняются): `docker compose --env-file .env --profile ttl down` (или `make down`).
|
||||
|
||||
**Намеренное удаление учебных данных** (необратимо, удаляет том `mtusi-lab2_pgdata`): `docker compose --env-file .env --profile ttl down -v`. Если удалить `secrets/`, но оставить том, пароль в томе разойдётся с новым секретом — тогда нужно удалить и том.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```
|
||||
клиент (curl / tests)
|
||||
│ HTTP 127.0.0.1:8080, Basic только на POST /auth/sessions, далее Bearer
|
||||
▼
|
||||
api (mtusi-messenger:lab2, Python 3.12, uid 10001, PID 1)
|
||||
│ 1) проверка токена: Valkey (кэш) ──промах/отказ──► 2) PostgreSQL
|
||||
├──────────────► valkey (valkey:8.0.2-alpine) — кэш сессий, без persistence, пул ≤10, таймаут 250 мс
|
||||
▼
|
||||
postgres (postgres:16.4-alpine) — источник истины, пул ≤10, ожидание ≤5 с, statement_timeout 5 с
|
||||
└── volume pgdata → /var/lib/postgresql/data
|
||||
```
|
||||
|
||||
| Роль | Service | Образ/версия | Health/readiness | Volume | Сеть/порт | Credentials |
|
||||
| --- | --- | --- | --- | --- | --- | --- |
|
||||
| api | `api` | сборка из `Dockerfile`, база `python:3.12.7-slim` | `HEALTHCHECK` → `/health/ready` | нет (stateless) | `127.0.0.1:8080→8080` | secrets `database_url`, `cache_url` → `DATABASE_URL_FILE`, `CACHE_URL_FILE` |
|
||||
| postgres | `postgres` | `postgres:16.4-alpine` | `pg_isready` | `pgdata` (именованный) | внутренняя сеть, 5432 | secret `postgres_password` → `POSTGRES_PASSWORD_FILE` |
|
||||
| redis_or_valkey | `valkey` | `valkey/valkey:8.0.2-alpine` | `valkey-cli ping` (с паролем) | нет: persistence выключено намеренно | внутренняя сеть, 6379 | secret `valkey.conf` (`requirepass`); без пароля — `NOAUTH` |
|
||||
| api (TTL-тест) | `api-short-ttl`, профиль `ttl` | тот же образ | — | нет | `127.0.0.1:8081→8080` | те же секреты |
|
||||
|
||||
### Схема и транзакции (уровень 3)
|
||||
|
||||
**Источник истины — PostgreSQL**: пользователи, чаты, участники, сообщения и сессии. В памяти API состояния нет.
|
||||
|
||||
Схема (`migrations/001_init.sql`):
|
||||
|
||||
- `users`: PK, `UNIQUE (username)`, CHECK формата username и длины display_name; `password_hash` — scrypt.
|
||||
- `chats`: PK, CHECK длины title.
|
||||
- `chat_members`: PK `(chat_id, user_id)`, FK на `chats` и `users`, `position` — порядок `member_ids`; индекс `(user_id, chat_id)` для списка чатов пользователя.
|
||||
- `messages`: PK, FK на чат и отправителя, CHECK 1–4000; индекс `(chat_id, created_at, id)` — обоснование ниже.
|
||||
- `sessions`: PK `token_hash` (SHA-256 токена), FK на `users`, `expires_at`, `revoked_at`; индекс `expires_at`.
|
||||
|
||||
Транзакционные границы:
|
||||
|
||||
- **Создание чата**: проверка участников, `INSERT chats` и все `INSERT chat_members` — одна транзакция. Ошибка, включая нарушение FK, откатывает её целиком.
|
||||
- **Сообщение**: в одной транзакции `SELECT ... FOR UPDATE` строки чата с проверкой членства и `INSERT`. Вставки в один чат сериализуются, `created_at = clock_timestamp()` растёт в порядке фиксации, и keyset-курсор не пропускает конкурентные вставки. Ограничение: порядок зависит от часов сервера БД.
|
||||
- **Регистрация**: гонку одинакового username решает `UNIQUE` в БД (`UniqueViolation` → 409), без «SELECT, потом INSERT».
|
||||
- **Миграции**: каждый файл и его запись в `schema_migrations` — одна транзакция; процессы сериализуются `pg_advisory_lock`.
|
||||
|
||||
### Аутентификация и сессии
|
||||
|
||||
- Пароль 12–128 code points хешируется `hashlib.scrypt` (N=2^15, r=8, p=1, соль 16 байт). Проверка — `hmac.compare_digest`; для неизвестного username считается фиктивный хеш (одинаковое время ответа). bcrypt не выбран из-за усечения до 72 байт.
|
||||
- `POST /api/v1/auth/sessions` принимает только Basic. Любая ошибка — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`.
|
||||
- Токен — `secrets.token_urlsafe(32)` (256 бит). В PostgreSQL и Valkey хранится только SHA-256 токена.
|
||||
- `expires_at = now() + SESSION_TTL_SECONDS` вычисляет БД; logout ставит `revoked_at`. Рестарт TTL не продлевает.
|
||||
- Остальные endpoint требуют Bearer; Basic и `X-User-Id` дают 401, `X-User-Id` рядом с Bearer игнорируется. Чужой и несуществующий чат одинаково дают 404.
|
||||
|
||||
### Valkey: роль, источник истины, expiry и инвалидация (уровень 4)
|
||||
|
||||
**Роль** — кэш проверенных сессий (`src/session_cache.py`). Проверка Bearer-токена выполняется на каждом защищённом запросе, поэтому без кэша каждый запрос — это минимум одна транзакция PostgreSQL. **Источник истины остаётся PostgreSQL**, в Valkey лежат только производные копии:
|
||||
|
||||
- ключ `sess:<sha256(token) hex>` — сам токен в Valkey не попадает;
|
||||
- значение `{"user": {...}, "exp": <unix-время истечения сессии>}` либо `"revoked"`.
|
||||
|
||||
**Путь проверки токена** (`current_user` в `src/server.py`):
|
||||
|
||||
1. `GET sess:<h>` в Valkey:
|
||||
- копия → пользователь, PostgreSQL не трогаем;
|
||||
- `"revoked"` → 401;
|
||||
- промах или ошибка → шаг 2.
|
||||
2. `SELECT` из `sessions` (действующая, не отозвана, не истекла). Затем `SET sess:<h> ... PX=<ttl> NX`.
|
||||
|
||||
**Политика expiry**:
|
||||
|
||||
- Положительная запись живёт `min(SESSION_CACHE_TTL_SECONDS=30, остаток сессии)` (PX в мс), поэтому кэш не переживает сессию. При чтении `exp` дополнительно сверяется с часами.
|
||||
- Tombstone `"revoked"` живёт 31 с — дольше любой положительной записи.
|
||||
- `maxmemory 64mb`, `allkeys-lru`: вытеснение любой записи безопасно. Вытесненная копия означает промах и чтение из БД. Вытесненный tombstone тоже даёт промах, а БД отвечает «отозвана».
|
||||
|
||||
**Инвалидация (logout)**:
|
||||
|
||||
1. `UPDATE sessions SET revoked_at` — COMMIT в PostgreSQL.
|
||||
2. `SET sess:<h> "revoked"` поверх возможной копии (не `DEL`).
|
||||
|
||||
Кэш после промаха заполняется только через `SET NX`. Поэтому конкурентный запрос, прочитавший БД до отзыва, не может перезаписать tombstone. Кроме того, кэш не заполняется, если между чтением БД и записью прошло больше 1 с.
|
||||
|
||||
**Persistence Valkey выключено намеренно** (`save ""`, `appendonly no`). Valkey — не единственное хранилище сессий, а кэш над PostgreSQL. После рестарта или `FLUSHALL` кэш пуст: сессии читаются из БД и снова кэшируются, действующие токены работают, отозванные остаются отозванными. Это проверено публичным persistence-тестом (restart hook перезапускает и Valkey) и тестом `FLUSHALL`.
|
||||
|
||||
**Отказ Valkey**:
|
||||
|
||||
- Любая ошибка или таймаут (250 мс на соединение и операцию) → запрос обслуживается из PostgreSQL. Следующие 5 с кэш не опрашивается (circuit breaker), чтобы не платить таймаутом на каждом запросе.
|
||||
- `/health/ready` остаётся 200: Valkey не критичен для обязательного пути.
|
||||
- Если не удалось записать tombstone (Valkey завис или недоступен во время logout), процесс 31 с не доверяет положительным записям кэша. Устаревшая копия могла остаться в Valkey, но за это время она гарантированно истечёт.
|
||||
- Анонимный или неизвестный токен при отказе Valkey не проходит: решение всегда принимает PostgreSQL.
|
||||
|
||||
**Ограничение**: окно недоверия хранится в памяти процесса. В lab2 API один, и защита полная. В lab3 при нескольких репликах о неудавшейся инвалидации узнает только одна реплика. Тогда нужен общий сигнал (например, эпоха кэша в PostgreSQL) или отказ от logout при недоступном Valkey.
|
||||
|
||||
### Пулы, таймауты, параметризация (уровень 4)
|
||||
|
||||
- Все SQL-запросы параметризованы (`%s` в psycopg, значения отдельно от текста запроса). Ключи Valkey строятся из hex-хеша.
|
||||
- PostgreSQL: `ConnectionPool(min_size=1, max_size=DB_POOL_SIZE=10, timeout=5)`, `connect_timeout=5`, `statement_timeout=DB_STATEMENT_TIMEOUT_MS=5000`. Перед выдачей соединение проверяется (`check_connection`), поэтому после рестарта БД нет ложных 503.
|
||||
- Valkey: `BlockingConnectionPool(max_connections=10, timeout=0.25)`, `socket_timeout` и `socket_connect_timeout` 250 мс.
|
||||
- Нет БД → `503 unavailable` за ≤5 с (ожидание пула и connect_timeout), а не зависание или 500.
|
||||
|
||||
### Что перенесено из lab1 и что изменено
|
||||
|
||||
Из lab1 перенесён каркас HTTP-сервера на `http.server`: маршрутизация, единый формат ошибок, `X-Request-Id`, валидация полей и длин в code points, 415 для не-JSON, keyset-курсор с привязкой к ресурсу, логирование без тел запросов, SIGTERM, non-root образ.
|
||||
|
||||
Изменено (переход 1 → 2): `password` при регистрации; Basic → Bearer-сессия вместо `X-User-Id`; logout; in-memory хранилище заменено PostgreSQL (`src/store.py`); добавлены кэш сессий в Valkey (`src/session_cache.py`), миграции, Compose, Docker secrets, restart hook и собственные тесты.
|
||||
|
||||
### Соответствие `.env.example` реальной конфигурации
|
||||
|
||||
| Переменная | Где используется | Значение |
|
||||
| --- | --- | --- |
|
||||
| `APP_HOST`, `APP_PORT`, `APP_ENV` | `src/server.py` | `0.0.0.0`, `8080`, `lab` |
|
||||
| `SESSION_TTL_SECONDS` | `create_session` | 3600 (в `api-short-ttl` — 2) |
|
||||
| `DATABASE_URL_FILE` | `database_conninfo` | `/run/secrets/database_url` |
|
||||
| `DB_POOL_SIZE`, `DB_STATEMENT_TIMEOUT_MS` | `src/store.py` | 10, 5000 |
|
||||
| `SESSION_STORE` | информационно: где хранятся сессии | `postgres` (источник истины) |
|
||||
| `SESSION_CACHE` | `cache_url()` | `valkey`; `off` отключает кэш (для сравнения) |
|
||||
| `CACHE_URL_FILE` | `cache_url()` | `/run/secrets/cache_url` |
|
||||
| `SESSION_CACHE_TTL_SECONDS`, `CACHE_TIMEOUT_MS`, `CACHE_RETRY_SECONDS` | `src/session_cache.py` | 30, 250, 5 |
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
### Уровень 3
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
| Структура skeleton | `make check` | `PASS: offline skeleton structure...` | [evidence/smoke.txt](evidence/smoke.txt) |
|
||||
| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | [evidence/smoke.txt](evidence/smoke.txt) |
|
||||
| Данные и действующие сессии переживают рестарт API и всех хранилищ без удаления томов | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS`; `StartedAt` у api, postgres и valkey изменился; в логах PostgreSQL `shut down` → `ready to accept`, у Valkey `SIGTERM` → `Ready`; том тот же | [evidence/persistence.txt](evidence/persistence.txt) |
|
||||
| После рестарта отозванный токен остаётся отозванным, история та же | `test_lab2.py --persistence` | 5 × OK | [evidence/student-tests.txt](evidence/student-tests.txt) |
|
||||
| PK/FK, UNIQUE username, 4 таблицы | `\d` таблиц | ключи, `users_username_key`, CHECK, индексы | [evidence/database.txt](evidence/database.txt) |
|
||||
| Миграции с нуля и повторно без дублей | первый старт на пустом томе; `--migrate-only` × 2 | `migration applied: 001_init.sql`; счётчики до и после равны | [evidence/database.txt](evidence/database.txt) |
|
||||
| Создание чата атомарно | чат с неизвестным 3-м участником | 400, списки чатов не изменились, следующее создание — 201 | [evidence/student-tests.txt](evidence/student-tests.txt) |
|
||||
| Basic только на входе, Bearer на остальных, `X-User-Id` не даёт доступ | тесты auth + smoke | Basic на `/users/me` → 401; только `X-User-Id` → 401; владелец не меняется | [evidence/student-tests.txt](evidence/student-tests.txt) |
|
||||
| Срок жизни и отзыв | TTL = 2; logout | через 3 с 401; logout 204 → 401 → повторный 401 | [evidence/student-tests.txt](evidence/student-tests.txt) |
|
||||
| Password KDF | `users.password_hash` | все хеши `scrypt N=2^15 r=8 p=1`; в `sessions` только 32-байтовые SHA-256 | [evidence/database.txt](evidence/database.txt) |
|
||||
| Secrets/volumes не в Git | `git status --ignored`, `git check-ignore` | `.env` и все файлы `secrets/` игнорируются | [evidence/stack.txt](evidence/stack.txt) |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
### Уровень 4
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Valkey реально используется (кэш сессий с TTL) | `test_lab2.py --cache` | после входа в Valkey копия сессии; 50 запросов → 50 попаданий, 0 промахов | [evidence/student-tests.txt](evidence/student-tests.txt) |
|
||||
| Кэш осмысленный (снимает нагрузку с источника истины) | `cache_bench.py`, 1000 проверок токена × 3 повтора | транзакций PostgreSQL: **3–13** с кэшем против **1693–1789** без; p50 0,80–0,86 мс против 1,08–1,16 мс | [evidence/cache-bench.txt](evidence/cache-bench.txt) |
|
||||
| Описаны источник истины, expiry, инвалидация | раздел «Valkey» выше | logout → tombstone, отозванный токен сразу 401 | [evidence/student-tests.txt](evidence/student-tests.txt) |
|
||||
| Рестарт/flush Valkey не теряет сессии (persistence не нужно: Valkey — кэш) | `FLUSHALL`; restart hook | действующий токен работает из БД, отозванный 401, кэш заново заполняется | [evidence/student-tests.txt](evidence/student-tests.txt), [evidence/persistence.txt](evidence/persistence.txt) |
|
||||
| Параметризованные запросы, ограниченный пул, таймауты | код `src/store.py`, `src/session_cache.py` | пулы ≤10, таймауты 5 с / 250 мс, `statement_timeout` | раздел «Пулы» выше |
|
||||
| Гонка регистрации одинакового username | 20 параллельных `POST /users` | ровно один 201, 19 × 409 | [evidence/student-tests.txt](evidence/student-tests.txt) |
|
||||
| Rollback составной операции | чат с неизвестным участником | ни чата, ни участников; следующее создание — 201 | [evidence/student-tests.txt](evidence/student-tests.txt) |
|
||||
| Индекс истории обоснован `EXPLAIN (ANALYZE, BUFFERS)` на ≥10 000 сообщений | `history_bench.py`: 110 205 сообщений, один чат на 100 000 и 20 по 500 | см. таблицу ниже: keyset-страница на глубине 90 000 — Index Scan, 51 строка, 7 буферов, 0,058 мс | [evidence/explain.txt](evidence/explain.txt) |
|
||||
| Пагинация не сканирует всю историю на каждой странице | обход 100 000 сообщений через API, limit=100 | 1000 страниц без потерь и повторов; медиана первых 20 страниц 3,14 мс, последних 20 — 2,83 мс | [evidence/explain.txt](evidence/explain.txt) |
|
||||
| Автопроверка expiry при коротком TTL | `--expiry-url` (TTL = 2) | 200 → через 3 с 401 с `WWW-Authenticate: Bearer` | [evidence/student-tests.txt](evidence/student-tests.txt) |
|
||||
| Автопроверка logout и неверного пароля | `test_lab2.py` | logout 204/401/401; неверный пароль 401 Basic | [evidence/student-tests.txt](evidence/student-tests.txt) |
|
||||
| Автопроверка недоступности БД | `--db-outage` | ready 503, live 200, `/chats` 503 за <10 с, вход 503, неизвестный токен не проходит; после старта прежний токен работает | [evidence/student-tests.txt](evidence/student-tests.txt) |
|
||||
| Автопроверка недоступности Valkey | `--cache` (stop valkey) | ready 200; токен работает через БД за <2 с; без токена и с чужим 401; вход 201, logout 204 → 401; после старта токен, отозванный во время отказа, остаётся 401 | [evidence/student-tests.txt](evidence/student-tests.txt) |
|
||||
| Зависание Valkey во время logout не «воскрешает» токен | `--cache` (pause valkey) | logout 204; в Valkey осталась устаревшая копия, но через 6 с (breaker закрыт) токен всё равно 401; в журнале `positive entries distrusted for 31s` | [evidence/student-tests.txt](evidence/student-tests.txt) |
|
||||
|
||||
### EXPLAIN (ANALYZE, BUFFERS) — сводка
|
||||
|
||||
Запрос — ровно тот, что выполняет приложение:
|
||||
|
||||
```sql
|
||||
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 51
|
||||
```
|
||||
|
||||
Данные: 110 205 строк, таблица 22 MB, индекс 11 MB; большой чат — 100 000 сообщений.
|
||||
|
||||
| Вариант | План | Прочитано строк | Буферов | Время выполнения |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| Первая страница, индекс | Index Scan `messages_chat_order_idx` | 51 | 5 | 0,064 мс |
|
||||
| **Keyset после 90 000-го, индекс** (как в приложении) | Index Scan, условие `ROW(created_at, id) > ROW(...)` в Index Cond | 51 | 7 | 0,058 мс |
|
||||
| OFFSET 90000, индекс (так приложение не делает) | Index Scan, затем отбрасывание | 90 051 | 4 726 | 12,6 мс |
|
||||
| Первая страница без индекса | Parallel Seq Scan + Sort top-N | вся таблица | 2 836 | 12,3 мс |
|
||||
| Keyset без индекса | Seq Scan, `Rows Removed by Filter: 100205` | вся таблица | 2 792 | 7,7 мс |
|
||||
|
||||
Вывод: составной индекс `(chat_id, created_at, id)` совпадает с фильтром и сортировкой. Страница любой глубины — это спуск по B-дереву и чтение `limit + 1` записей, без сортировки. Стоимость не зависит ни от глубины, ни от размера чата. `OFFSET` растёт линейно с глубиной, а без индекса каждая страница читает всю таблицу.
|
||||
|
||||
Стоимость индекса: 11 MB на 110 тыс. строк и дополнительная запись в B-дерево при каждой вставке. Заливка 110 тыс. строк с индексом заняла 1,8 с; отдельно стоимость записи на «4» не измерялась.
|
||||
|
||||
Ограничения замера: все страницы в shared buffers (`shared hit`), холодный кэш и диск не измерялись; один прогон на ноутбуке без лимитов CPU/RAM.
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Стенд: MacBook (macOS), Docker Desktop 28.0.4, лимиты CPU/RAM на контейнеры не заданы, настройки PostgreSQL и Valkey по умолчанию, кроме указанных выше. Замеры latency последовательные (один клиент), это не нагрузочный тест.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| `scripts/restart.sh`: штатный рестарт API, PostgreSQL и Valkey | данные и сессии сохранены, прежний токен работает | public persistence PASS; те же пользователь, чат и история; отозванный токен 401 | ~3–4 с до `ready`; потерь нет; кэш пуст и заполняется заново |
|
||||
| `docker compose stop postgres` | ready 503, бизнес-запросы 503 за ограниченное время | ready 503, live 200, `/chats` 503, вход 503; `/users/me` — 200 из кэша сессий, пока жива копия (≤30 с), иначе 503 (отзыв без БД невозможен: logout тоже 503) | после `start` — несколько секунд; потерь нет |
|
||||
| `docker compose stop valkey` | API продолжает работать через PostgreSQL | все операции работают, ready 200, ответ <2 с (одна попытка 250 мс, далее breaker 5 с) | после `start` через 5 с кэш снова используется |
|
||||
| `FLUSHALL` в Valkey | кэш пуст, корректность сохранена | действующий токен работает, отозванный 401 | мгновенно |
|
||||
| `docker compose pause valkey` во время logout | отзыв фиксируется в БД, устаревшая копия не принимается | logout 204; устаревшая копия в Valkey не принята (31 с недоверия) | — |
|
||||
| Сессия с `SESSION_TTL_SECONDS=2` | через 2 с — 401 | 401 на обоих экземплярах API (запись кэша живёт не дольше сессии) | — |
|
||||
|
||||
Гарантии durability: подтверждённое сообщение — это успешный COMMIT. При `fsync=on` и `synchronous_commit=on` (по умолчанию) WAL сброшен на диск до ответа, поэтому рестарт и падение процесса БД не теряют подтверждённых записей. Потерю тома или Docker-host это не покрывает.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- Выдерживается: рестарт или пересоздание контейнеров API, PostgreSQL и Valkey при сохранённом томе; временная недоступность PostgreSQL (503 и восстановление без перезапуска API); полная недоступность, зависание или очистка Valkey.
|
||||
- Не выдерживается: потеря тома или Docker-host (бэкапов нет); единственные экземпляры PostgreSQL, Valkey и API.
|
||||
- Окно недоверия кэшу после неудачной инвалидации локально для процесса; для нескольких реплик в lab3 нужен общий механизм (см. раздел «Valkey»).
|
||||
- Во время отказа PostgreSQL `/users/me` может быть отдан из кэша до 30 с — это осознанный выбор: копия соответствует действующей сессии, а отозвать её без БД нельзя.
|
||||
- HTTP без TLS допустим только на `127.0.0.1` с синтетическими данными.
|
||||
- Истёкшие и отозванные сессии не удаляются из таблицы автоматически (индекс `sessions_expires_idx` подготовлен для периодической очистки).
|
||||
- `history_bench.py` при каждом запуске добавляет ~110 тыс. синтетических сообщений в учебную БД.
|
||||
|
||||
+105
@@ -0,0 +1,105 @@
|
||||
# Lab2: API + PostgreSQL (источник истины) + Valkey (кэш сессий). Секреты — файлы в ./secrets (не коммитятся), создаются scripts/init-secrets.sh.
|
||||
name: mtusi-lab2
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.4-alpine
|
||||
environment:
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
|
||||
secrets:
|
||||
- postgres_password
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data # данные переживают перезапуск/пересоздание контейнера
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 30
|
||||
stop_grace_period: 30s # даём PostgreSQL штатно завершиться (checkpoint)
|
||||
restart: unless-stopped
|
||||
|
||||
# Кэш проверенных сессий. Источник истины — PostgreSQL, поэтому persistence намеренно
|
||||
# выключено: после рестарта/flush кэш пуст, сессии читаются из БД и снова кэшируются.
|
||||
valkey:
|
||||
image: valkey/valkey:8.0.2-alpine
|
||||
command:
|
||||
- valkey-server
|
||||
- /run/secrets/valkey.conf # requirepass из секрета
|
||||
- --save
|
||||
- "" # без RDB-снимков
|
||||
- --appendonly
|
||||
- "no" # без AOF
|
||||
- --maxmemory
|
||||
- 64mb
|
||||
- --maxmemory-policy
|
||||
- allkeys-lru # при нехватке памяти вытесняются старые записи
|
||||
secrets:
|
||||
- valkey.conf
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "valkey-cli --no-auth-warning -a \"$$(sed -n 's/^requirepass //p' /run/secrets/valkey.conf)\" ping | grep -q PONG"]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 30
|
||||
restart: unless-stopped
|
||||
|
||||
api:
|
||||
build: .
|
||||
image: mtusi-messenger:lab2
|
||||
environment:
|
||||
APP_HOST: ${APP_HOST:-0.0.0.0}
|
||||
APP_PORT: ${APP_PORT:-8080}
|
||||
APP_ENV: ${APP_ENV:-lab}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
SESSION_STORE: ${SESSION_STORE:-postgres}
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
DB_POOL_SIZE: ${DB_POOL_SIZE:-10}
|
||||
DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000}
|
||||
SESSION_CACHE: ${SESSION_CACHE:-valkey}
|
||||
CACHE_URL_FILE: /run/secrets/cache_url
|
||||
SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-30}
|
||||
CACHE_TIMEOUT_MS: ${CACHE_TIMEOUT_MS:-250}
|
||||
CACHE_RETRY_SECONDS: ${CACHE_RETRY_SECONDS:-5}
|
||||
secrets:
|
||||
- database_url
|
||||
- cache_url
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080" # только localhost: Basic по HTTP — учебный стенд
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
valkey:
|
||||
condition: service_started # Valkey не критичен: API стартует и без него
|
||||
restart: unless-stopped
|
||||
|
||||
# Отдельный экземпляр API с коротким TTL — только для проверки истечения сессии.
|
||||
# Запуск: docker compose --profile ttl up -d api-short-ttl (порт 8081, та же БД).
|
||||
api-short-ttl:
|
||||
profiles: ["ttl"]
|
||||
image: mtusi-messenger:lab2
|
||||
environment:
|
||||
SESSION_TTL_SECONDS: 2
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
CACHE_URL_FILE: /run/secrets/cache_url
|
||||
secrets:
|
||||
- database_url
|
||||
- cache_url
|
||||
ports:
|
||||
- "127.0.0.1:8081:8080"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
|
||||
secrets:
|
||||
postgres_password:
|
||||
file: ./secrets/postgres_password
|
||||
database_url:
|
||||
file: ./secrets/database_url
|
||||
valkey.conf:
|
||||
file: ./secrets/valkey.conf
|
||||
cache_url:
|
||||
file: ./secrets/cache_url
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
@@ -0,0 +1,11 @@
|
||||
# 2026-10-15T23:09:37Z 1000 последовательных GET /users/me одним токеном, 3 повтора на режим
|
||||
{"label": "valkey #1", "requests": 1000, "postgres_xact_commit_delta": 13, "p50_ms": 0.8, "p95_ms": 1.72}
|
||||
{"label": "valkey #2", "requests": 1000, "postgres_xact_commit_delta": 13, "p50_ms": 0.85, "p95_ms": 2.05}
|
||||
{"label": "valkey #3", "requests": 1000, "postgres_xact_commit_delta": 3, "p50_ms": 0.86, "p95_ms": 1.83}
|
||||
$ SESSION_CACHE=off docker compose up -d --wait api
|
||||
INFO listening on 0.0.0.0:8080 env=lab session_ttl=3600s session_cache=off
|
||||
{"label": "off #1", "requests": 1000, "postgres_xact_commit_delta": 1789, "p50_ms": 1.16, "p95_ms": 2.28}
|
||||
{"label": "off #2", "requests": 1000, "postgres_xact_commit_delta": 1693, "p50_ms": 1.09, "p95_ms": 1.98}
|
||||
{"label": "off #3", "requests": 1000, "postgres_xact_commit_delta": 1699, "p50_ms": 1.08, "p95_ms": 2.02}
|
||||
$ docker compose up -d --wait api (возврат SESSION_CACHE=valkey)
|
||||
INFO listening on 0.0.0.0:8080 env=lab session_ttl=3600s session_cache=valkey
|
||||
@@ -0,0 +1,108 @@
|
||||
# 2026-10-12T14:22:38Z
|
||||
--- 1. Миграции с нуля (пустой том, первый старт API):
|
||||
api-1 | 2026-10-12 14:21:13,412 INFO migration applied: 001_init.sql
|
||||
api-1 | 2026-10-12 14:21:13,412 INFO schema version: 001_init.sql
|
||||
|
||||
--- 2. Повторный запуск миграций не дублирует данные
|
||||
до:
|
||||
users | chats | messages | migrations
|
||||
-------+-------+----------+------------
|
||||
11 | 5 | 103 | 1
|
||||
(1 row)
|
||||
|
||||
$ docker compose run --rm api python /app/src/server.py --migrate-only (запуск 1)
|
||||
2026-10-12 14:22:39,348 INFO schema version: 001_init.sql
|
||||
2026-10-12 14:22:39,348 INFO migrations are up to date, exiting (--migrate-only)
|
||||
$ docker compose run --rm api python /app/src/server.py --migrate-only (запуск 2)
|
||||
2026-10-12 14:22:40,518 INFO schema version: 001_init.sql
|
||||
2026-10-12 14:22:40,518 INFO migrations are up to date, exiting (--migrate-only)
|
||||
после:
|
||||
users | chats | messages | migrations
|
||||
-------+-------+----------+------------
|
||||
11 | 5 | 103 | 1
|
||||
(1 row)
|
||||
|
||||
version | applied_at
|
||||
--------------+-------------------------------
|
||||
001_init.sql | 2026-10-12 14:21:13.401972+00
|
||||
(1 row)
|
||||
|
||||
--- 3. Схема: ключи, ограничения, индексы
|
||||
Table "public.users"
|
||||
Column | Type | Collation | Nullable | Default
|
||||
---------------+--------------------------+-----------+----------+---------
|
||||
id | uuid | | not null |
|
||||
username | text | | not null |
|
||||
display_name | text | | not null |
|
||||
password_hash | text | | not null |
|
||||
created_at | timestamp with time zone | | not null |
|
||||
Indexes:
|
||||
"users_pkey" PRIMARY KEY, btree (id)
|
||||
"users_username_key" UNIQUE CONSTRAINT, btree (username)
|
||||
Check constraints:
|
||||
"users_display_name_len" CHECK (char_length(display_name) >= 1 AND char_length(display_name) <= 100)
|
||||
"users_username_format" CHECK (username ~ '^[a-z0-9_]{3,32}$'::text)
|
||||
Referenced by:
|
||||
TABLE "chat_members" CONSTRAINT "chat_members_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id)
|
||||
TABLE "messages" CONSTRAINT "messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id)
|
||||
TABLE "sessions" CONSTRAINT "sessions_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id)
|
||||
|
||||
Table "public.chat_members"
|
||||
Column | Type | Collation | Nullable | Default
|
||||
----------+---------+-----------+----------+---------
|
||||
chat_id | uuid | | not null |
|
||||
user_id | uuid | | not null |
|
||||
position | integer | | not null |
|
||||
Indexes:
|
||||
"chat_members_pkey" PRIMARY KEY, btree (chat_id, user_id)
|
||||
"chat_members_user_idx" btree (user_id, chat_id)
|
||||
Check constraints:
|
||||
"chat_members_position_check" CHECK ("position" >= 0)
|
||||
Foreign-key constraints:
|
||||
"chat_members_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
|
||||
"chat_members_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id)
|
||||
|
||||
Table "public.messages"
|
||||
Column | Type | Collation | Nullable | Default
|
||||
------------+--------------------------+-----------+----------+---------
|
||||
id | uuid | | not null |
|
||||
chat_id | uuid | | not null |
|
||||
sender_id | uuid | | not null |
|
||||
text | text | | not null |
|
||||
created_at | timestamp with time zone | | not null |
|
||||
Indexes:
|
||||
"messages_pkey" PRIMARY KEY, btree (id)
|
||||
"messages_chat_order_idx" btree (chat_id, created_at, id)
|
||||
Check constraints:
|
||||
"messages_text_check" CHECK (char_length(text) >= 1 AND char_length(text) <= 4000)
|
||||
Foreign-key constraints:
|
||||
"messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
|
||||
"messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id)
|
||||
|
||||
Table "public.sessions"
|
||||
Column | Type | Collation | Nullable | Default
|
||||
------------+--------------------------+-----------+----------+---------
|
||||
token_hash | bytea | | not null |
|
||||
user_id | uuid | | not null |
|
||||
created_at | timestamp with time zone | | not null |
|
||||
expires_at | timestamp with time zone | | not null |
|
||||
revoked_at | timestamp with time zone | | |
|
||||
Indexes:
|
||||
"sessions_pkey" PRIMARY KEY, btree (token_hash)
|
||||
"sessions_expires_idx" btree (expires_at)
|
||||
Check constraints:
|
||||
"sessions_check" CHECK (expires_at > created_at)
|
||||
Foreign-key constraints:
|
||||
"sessions_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id)
|
||||
|
||||
--- 4. Пароли: только scrypt-хеш (показаны параметры), токены: только SHA-256 (32 байта)
|
||||
kdf_params | count
|
||||
-----------------------+-------
|
||||
scrypt N=2^15 r=8 p=1 | 11
|
||||
(1 row)
|
||||
|
||||
hash_bytes | sessions | revoked
|
||||
------------+----------+---------
|
||||
32 | 14 | 2
|
||||
(1 row)
|
||||
|
||||
@@ -0,0 +1,126 @@
|
||||
# 2026-10-15T23:09:01Z MacBook, Docker Desktop 28.0.4, без CPU/RAM-лимитов, postgres:16.4-alpine (настройки по умолчанию)
|
||||
$ python3 student-tests/history_bench.py --big 100000 --small-chats 20 --small-size 500
|
||||
|
||||
====================================================================================================
|
||||
1. Заливка данных
|
||||
====================================================================================================
|
||||
залито за 1.8 с
|
||||
messages_total | chats_with_messages | in_big_chat | table_size | index_size
|
||||
----------------+---------------------+-------------+------------+------------
|
||||
110205 | 26 | 100000 | 22 MB | 11 MB
|
||||
(1 row)
|
||||
|
||||
====================================================================================================
|
||||
2a. С индексом: первая страница (как в приложении, limit=50 → LIMIT 51)
|
||||
====================================================================================================
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11' ORDER BY created_at, id LIMIT 51
|
||||
QUERY PLAN
|
||||
-------------------------------------------------------------------------------------------------------
|
||||
Limit (actual time=0.026..0.038 rows=51 loops=1)
|
||||
Buffers: shared hit=5
|
||||
-> Index Scan using messages_chat_order_idx on messages (actual time=0.025..0.035 rows=51 loops=1)
|
||||
Index Cond: (chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid)
|
||||
Buffers: shared hit=5
|
||||
Planning:
|
||||
Buffers: shared hit=137
|
||||
Planning Time: 0.396 ms
|
||||
Execution Time: 0.064 ms
|
||||
(9 rows)
|
||||
|
||||
====================================================================================================
|
||||
2b. С индексом: страница после 90000-го сообщения, keyset-курсор (как в приложении)
|
||||
====================================================================================================
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11' AND (created_at, id) > ('2026-01-01 00:01:30+00', '29f2fea4-8210-4561-9e6a-e0c3a1b513c0'::uuid) ORDER BY created_at, id LIMIT 51
|
||||
QUERY PLAN
|
||||
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (actual time=0.018..0.029 rows=51 loops=1)
|
||||
Buffers: shared hit=7
|
||||
-> Index Scan using messages_chat_order_idx on messages (actual time=0.017..0.026 rows=51 loops=1)
|
||||
Index Cond: ((chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:01:30+00'::timestamp with time zone, '29f2fea4-8210-4561-9e6a-e0c3a1b513c0'::uuid)))
|
||||
Buffers: shared hit=7
|
||||
Planning:
|
||||
Buffers: shared hit=136
|
||||
Planning Time: 0.352 ms
|
||||
Execution Time: 0.058 ms
|
||||
(9 rows)
|
||||
|
||||
====================================================================================================
|
||||
2c. Для сравнения: та же глубина через OFFSET 90000 (так приложение НЕ делает)
|
||||
====================================================================================================
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11' ORDER BY created_at, id OFFSET 90000 LIMIT 51
|
||||
QUERY PLAN
|
||||
-----------------------------------------------------------------------------------------------------------
|
||||
Limit (actual time=12.582..12.591 rows=51 loops=1)
|
||||
Buffers: shared hit=4726
|
||||
-> Index Scan using messages_chat_order_idx on messages (actual time=0.019..10.068 rows=90051 loops=1)
|
||||
Index Cond: (chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid)
|
||||
Buffers: shared hit=4726
|
||||
Planning:
|
||||
Buffers: shared hit=137
|
||||
Planning Time: 0.377 ms
|
||||
Execution Time: 12.607 ms
|
||||
(9 rows)
|
||||
|
||||
====================================================================================================
|
||||
2d. БЕЗ индекса messages_chat_order_idx (DROP INDEX внутри BEGIN … ROLLBACK, данные не меняются)
|
||||
====================================================================================================
|
||||
--- первая страница без индекса
|
||||
QUERY PLAN
|
||||
-----------------------------------------------------------------------------------------------
|
||||
Limit (actual time=10.974..12.247 rows=51 loops=1)
|
||||
Buffers: shared hit=2836
|
||||
-> Gather Merge (actual time=10.973..12.241 rows=51 loops=1)
|
||||
Workers Planned: 1
|
||||
Workers Launched: 1
|
||||
Buffers: shared hit=2836
|
||||
-> Sort (actual time=9.575..9.579 rows=51 loops=2)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: top-N heapsort Memory: 39kB
|
||||
Buffers: shared hit=2836
|
||||
Worker 0: Sort Method: top-N heapsort Memory: 40kB
|
||||
-> Parallel Seq Scan on messages (actual time=0.019..6.242 rows=50000 loops=2)
|
||||
Filter: (chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid)
|
||||
Rows Removed by Filter: 5102
|
||||
Buffers: shared hit=2792
|
||||
Planning:
|
||||
Buffers: shared hit=104
|
||||
Planning Time: 0.367 ms
|
||||
Execution Time: 12.294 ms
|
||||
(19 rows)
|
||||
|
||||
--- keyset-страница без индекса
|
||||
QUERY PLAN
|
||||
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (actual time=7.631..7.636 rows=51 loops=1)
|
||||
Buffers: shared hit=2792
|
||||
-> Sort (actual time=7.630..7.632 rows=51 loops=1)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: top-N heapsort Memory: 45kB
|
||||
Buffers: shared hit=2792
|
||||
-> Seq Scan on messages (actual time=4.642..7.102 rows=10000 loops=1)
|
||||
Filter: ((chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:01:30+00'::timestamp with time zone, '29f2fea4-8210-4561-9e6a-e0c3a1b513c0'::uuid)))
|
||||
Rows Removed by Filter: 100205
|
||||
Buffers: shared hit=2792
|
||||
Planning Time: 0.060 ms
|
||||
Execution Time: 7.668 ms
|
||||
(12 rows)
|
||||
indexname
|
||||
-------------------------
|
||||
messages_chat_order_idx
|
||||
messages_pkey
|
||||
(2 rows)
|
||||
|
||||
====================================================================================================
|
||||
3. Полный обход истории большого чата через API (limit=100)
|
||||
====================================================================================================
|
||||
{
|
||||
"pages": 1000,
|
||||
"messages_read": 100000,
|
||||
"expected": 100000,
|
||||
"first_20_pages_median_ms": 3.14,
|
||||
"last_20_pages_median_ms": 2.83,
|
||||
"all_pages_p50_ms": 2.8,
|
||||
"all_pages_p95_ms": 4.33,
|
||||
"all_pages_max_ms": 10.96
|
||||
}
|
||||
PASS: все 100000 сообщений прочитаны без потерь и повторов
|
||||
@@ -0,0 +1,22 @@
|
||||
# 2026-10-15T23:10:29Z
|
||||
--- до: контейнеры
|
||||
/mtusi-lab2-api-1 started=2026-10-15T23:10:13.308098346Z
|
||||
/mtusi-lab2-postgres-1 started=2026-10-15T23:08:12.796745137Z
|
||||
/mtusi-lab2-valkey-1 started=2026-10-15T23:08:12.79643622Z
|
||||
$ make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
--- после: контейнеры (StartedAt изменился у всех трёх => перезапущены API, PostgreSQL и Valkey)
|
||||
/mtusi-lab2-api-1 started=2026-10-15T23:10:33.226933382Z
|
||||
/mtusi-lab2-postgres-1 started=2026-10-15T23:10:31.075516256Z
|
||||
/mtusi-lab2-valkey-1 started=2026-10-15T23:10:31.076417256Z
|
||||
--- том pgdata сохранён:
|
||||
mtusi-lab2_pgdata created=2026-10-12T14:21:10Z
|
||||
--- логи PostgreSQL о перезапуске:
|
||||
postgres-1 | 2026-10-15 23:10:30.838 UTC [1] LOG: database system is shut down
|
||||
postgres-1 | 2026-10-15 23:10:31.171 UTC [29] LOG: database system was shut down at 2026-10-15 23:10:30 UTC
|
||||
postgres-1 | 2026-10-15 23:10:31.174 UTC [1] LOG: database system is ready to accept connections
|
||||
--- логи Valkey о перезапуске:
|
||||
valkey-1 | 1:signal-handler (1792105830) Received SIGTERM scheduling shutdown...
|
||||
valkey-1 | 1:M 15 Oct 2026 23:10:31.135 * Ready to accept connections tcp
|
||||
@@ -0,0 +1,8 @@
|
||||
# 2026-10-15T23:10:28Z
|
||||
$ make check
|
||||
python3 scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
|
||||
$ make test
|
||||
python3 tests/smoke.py --base-url "http://localhost:8080"
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -0,0 +1,55 @@
|
||||
# 2026-10-15T23:11:46Z
|
||||
Docker Engine 28.0.4
|
||||
Docker Compose version v2.34.0-desktop.1
|
||||
|
||||
$ docker compose ps
|
||||
SERVICE IMAGE STATUS PORTS
|
||||
api mtusi-messenger:lab2 Up 11 seconds (healthy) 127.0.0.1:8080->8080/tcp
|
||||
postgres postgres:16.4-alpine Up 13 seconds (healthy) 5432/tcp
|
||||
valkey valkey/valkey:8.0.2-alpine Up 13 seconds (healthy) 6379/tcp
|
||||
|
||||
$ docker volume ls (именованные тома стенда)
|
||||
mtusi-lab2_pgdata
|
||||
|
||||
$ Valkey: persistence выключено намеренно (кэш, источник истины — PostgreSQL)
|
||||
save
|
||||
appendonly no
|
||||
maxmemory-policy allkeys-lru
|
||||
$ Valkey без пароля не отвечает:
|
||||
NOAUTH Authentication required.
|
||||
|
||||
|
||||
$ процесс API — PID 1, не root
|
||||
uid=10001(app) gid=10001(app) groups=10001(app)
|
||||
python /app/src/server.py
|
||||
|
||||
$ git status --short --ignored
|
||||
M .env.example
|
||||
M Makefile
|
||||
M REPORT.md
|
||||
?? Dockerfile
|
||||
?? compose.yaml
|
||||
?? evidence/cache-bench.txt
|
||||
?? evidence/database.txt
|
||||
?? evidence/explain.txt
|
||||
?? evidence/persistence.txt
|
||||
?? evidence/smoke.txt
|
||||
?? evidence/stack.txt
|
||||
?? evidence/student-tests.txt
|
||||
?? migrations/
|
||||
?? requirements.txt
|
||||
?? scripts/init-secrets.sh
|
||||
?? scripts/restart.sh
|
||||
?? src/
|
||||
?? student-tests/
|
||||
!! .env
|
||||
!! secrets/
|
||||
!! src/__pycache__/
|
||||
!! student-tests/__pycache__/
|
||||
|
||||
$ git check-ignore secrets/* .env
|
||||
secrets/cache_url
|
||||
secrets/database_url
|
||||
secrets/postgres_password
|
||||
secrets/valkey.conf
|
||||
.env
|
||||
@@ -0,0 +1,108 @@
|
||||
# 2026-10-15T23:10:42Z
|
||||
$ python3 student-tests/test_lab2.py --expiry-url http://localhost:8081 --db-outage --cache --persistence
|
||||
OK регистрация без password -> 400 (ожидалось 400)
|
||||
OK password 11 символов -> 400 (ожидалось 400)
|
||||
OK password 129 символов -> 400 (ожидалось 400)
|
||||
OK password не строка -> 400 (ожидалось 400)
|
||||
OK дубликат username -> 409 (ожидалось 409)
|
||||
OK User не содержит пароль/хеш -> ['created_at', 'display_name', 'id', 'us… (ожидалось ['created_at', 'display_name', 'id', 'us…)
|
||||
OK malformed JSON -> 400 (ожидалось 400)
|
||||
OK неверный пароль -> 401 (ожидалось 401)
|
||||
OK challenge Basic -> True (ожидалось True)
|
||||
OK неизвестный пользователь -> 401 (ожидалось 401)
|
||||
OK вход без Authorization -> 401 (ожидалось 401)
|
||||
OK вход с Bearer вместо Basic -> 401 (ожидалось 401)
|
||||
OK мусор вместо base64 -> 401 (ожидалось 401)
|
||||
OK пароль с двоеточием и Unicode -> 50babb13-8c3d-4066-9146-f2961f042e25 (ожидалось 50babb13-8c3d-4066-9146-f2961f042e25)
|
||||
OK два входа дают разные токены -> True (ожидалось True)
|
||||
OK без токена -> 401 (ожидалось 401)
|
||||
OK challenge Bearer -> True (ожидалось True)
|
||||
OK случайный токен -> 401 (ожидалось 401)
|
||||
OK Basic на бизнес-endpoint -> 401 (ожидалось 401)
|
||||
OK только X-User-Id -> 401 (ожидалось 401)
|
||||
OK X-User-Id не меняет владельца -> 50babb13-8c3d-4066-9146-f2961f042e25 (ожидалось 50babb13-8c3d-4066-9146-f2961f042e25)
|
||||
OK logout -> 204 (ожидалось 204)
|
||||
OK отозванный токен -> 401 (ожидалось 401)
|
||||
OK повторный logout -> 401 (ожидалось 401)
|
||||
OK другая сессия того же пользователя жива -> 200 (ожидалось 200)
|
||||
OK чат: создатель не участник -> 400 (ожидалось 400)
|
||||
OK чат: неизвестный участник -> 400 (ожидалось 400)
|
||||
OK чат: дубликат участника -> 400 (ожидалось 400)
|
||||
OK порядок member_ids сохранён -> ['50babb13-8c3d-4066-9146-f2961f042e25',… (ожидалось ['50babb13-8c3d-4066-9146-f2961f042e25',…)
|
||||
OK чужой чат (Ева) -> 404 (ожидалось 404)
|
||||
OK запись в чужой чат (Ева) -> 404 (ожидалось 404)
|
||||
OK пустое сообщение -> 400 (ожидалось 400)
|
||||
OK sender_id в теле -> 400 (ожидалось 400)
|
||||
OK 4001 символ -> 400 (ожидалось 400)
|
||||
OK 100 параллельных POST: ошибок -> 0 (ожидалось 0)
|
||||
OK 100 параллельных POST: уникальных -> 100 (ожидалось 100)
|
||||
OK история отсортирована (created_at, id) -> True (ожидалось True)
|
||||
OK cursor от другого чата -> 400 (ожидалось 400)
|
||||
OK мусорный cursor -> 400 (ожидалось 400)
|
||||
OK limit=0 -> 400 (ожидалось 400)
|
||||
OK неверный UUID в пути -> 400 (ожидалось 400)
|
||||
OK гонка 20 регистраций: ровно один 201 -> 1 (ожидалось 1)
|
||||
OK гонка 20 регистраций: остальные 409 -> 19 (ожидалось 19)
|
||||
OK чат с неизвестным 3-м участником -> 400 (ожидалось 400)
|
||||
OK после ошибки чат не появился у создателя -> [] (ожидалось [])
|
||||
OK после ошибки чат не появился у участника b -> ['f719daa9-38c4-45b4-9e11-72582a3ab25d'] (ожидалось ['f719daa9-38c4-45b4-9e11-72582a3ab25d'])
|
||||
OK следующее создание чата работает -> (201, ['50f22c4f-7abb-4395-9921-1bb23c95… (ожидалось (201, ['50f22c4f-7abb-4395-9921-1bb23c95…)
|
||||
OK TTL=2: вход -> 201 (ожидалось 201)
|
||||
OK TTL=2: сразу после входа токен работает -> 200 (ожидалось 200)
|
||||
OK TTL=2: через 3 с токен истёк -> 401 (ожидалось 401)
|
||||
OK challenge Bearer -> True (ожидалось True)
|
||||
OK TTL=2: истёкший токен не работает и на основном API -> 401 (ожидалось 401)
|
||||
--- остановка PostgreSQL: docker compose stop postgres
|
||||
OK БД нет: /health/ready -> (503, 'unavailable') (ожидалось (503, 'unavailable'))
|
||||
OK БД нет: /health/live -> 200 (ожидалось 200)
|
||||
OK БД нет: список чатов с токеном -> 503, не 200 -> (503, 'unavailable') (ожидалось (503, 'unavailable'))
|
||||
OK БД нет: ответ ограничен по времени (<10 с) -> True (ожидалось True)
|
||||
OK БД нет: /users/me -> 200 из кэша или 503 -> True (ожидалось True)
|
||||
OK БД нет: неизвестный токен не проходит -> True (ожидалось True)
|
||||
OK БД нет: анонимный запрос не проходит -> True (ожидалось True)
|
||||
OK БД нет: вход -> 503 -> 503 (ожидалось 503)
|
||||
OK БД вернулась: прежний токен работает -> {'id': '50babb13-8c3d-4066-9146-f2961f04… (ожидалось {'id': '50babb13-8c3d-4066-9146-f2961f04…)
|
||||
OK кэш: после входа в Valkey лежит копия сессии -> True (ожидалось True)
|
||||
OK кэш: в Valkey нет самого токена/пароля -> True (ожидалось True)
|
||||
OK кэш: 50 запросов -> 50 попаданий в Valkey -> (50, 0) (ожидалось (50, 0))
|
||||
OK кэш: logout -> 204 (ожидалось 204)
|
||||
OK кэш: в Valkey tombstone вместо копии -> revoked (ожидалось revoked)
|
||||
OK кэш: отозванный токен сразу 401 -> 401 (ожидалось 401)
|
||||
OK FLUSHALL: действующий токен работает (из БД) -> {'id': '547cea17-7447-4159-8601-17f1e477… (ожидалось {'id': '547cea17-7447-4159-8601-17f1e477…)
|
||||
OK FLUSHALL: отозванный токен по-прежнему 401 -> 401 (ожидалось 401)
|
||||
OK FLUSHALL: кэш снова заполнен после промаха -> True (ожидалось True)
|
||||
--- остановка Valkey: docker compose stop valkey
|
||||
OK Valkey нет: /health/ready 200 (не критичен) -> 200 (ожидалось 200)
|
||||
OK Valkey нет: токен работает через БД -> {'id': '547cea17-7447-4159-8601-17f1e477… (ожидалось {'id': '547cea17-7447-4159-8601-17f1e477…)
|
||||
OK Valkey нет: ответ быстрый (<2 с) -> True (ожидалось True)
|
||||
OK Valkey нет: список чатов -> 200 (ожидалось 200)
|
||||
OK Valkey нет: без токена 401 -> 401 (ожидалось 401)
|
||||
OK Valkey нет: чужой токен 401 -> 401 (ожидалось 401)
|
||||
OK Valkey нет: отозванный токен 401 -> 401 (ожидалось 401)
|
||||
OK Valkey нет: вход 201 -> True (ожидалось True)
|
||||
OK Valkey нет: logout 204 -> 204 (ожидалось 204)
|
||||
OK Valkey нет: после logout 401 -> 401 (ожидалось 401)
|
||||
OK Valkey вернулся: токен работает -> {'id': '547cea17-7447-4159-8601-17f1e477… (ожидалось {'id': '547cea17-7447-4159-8601-17f1e477…)
|
||||
OK Valkey вернулся: кэш снова заполняется -> True (ожидалось True)
|
||||
OK Valkey вернулся: токен, отозванный при отказе, 401 -> 401 (ожидалось 401)
|
||||
--- зависание Valkey во время logout: docker compose pause valkey
|
||||
OK Valkey завис: logout всё равно 204 (отзыв в БД) -> 204 (ожидалось 204)
|
||||
OK Valkey ожил: в нём осталась устаревшая копия -> True (ожидалось True)
|
||||
OK Valkey ожил: устаревшая копия не принята, 401 -> 401 (ожидалось 401)
|
||||
OK Valkey ожил: действующий токен работает -> {'id': '547cea17-7447-4159-8601-17f1e477… (ожидалось {'id': '547cea17-7447-4159-8601-17f1e477…)
|
||||
--- перезапуск API и PostgreSQL: scripts/restart.sh
|
||||
OK после рестарта: прежний токен работает -> {'id': '50babb13-8c3d-4066-9146-f2961f04… (ожидалось {'id': '50babb13-8c3d-4066-9146-f2961f04…)
|
||||
OK после рестарта: чат на месте -> {'id': 'f719daa9-38c4-45b4-9e11-72582a3a… (ожидалось {'id': 'f719daa9-38c4-45b4-9e11-72582a3a…)
|
||||
OK после рестарта: история та же -> [{'id': 'c0e23a76-540f-46db-81a4-dbee552… (ожидалось [{'id': 'c0e23a76-540f-46db-81a4-dbee552…)
|
||||
OK после рестарта: отозванный токен всё ещё отозван -> 401 (ожидалось 401)
|
||||
OK после рестарта: вход по паролю работает -> 201 (ожидалось 201)
|
||||
ИТОГО: ВСЕ ПРОВЕРКИ ПРОШЛИ
|
||||
|
||||
--- журнал API во время отказов Valkey (без токенов и тел запросов):
|
||||
2026-10-15 23:10:56,857 WARNING database unavailable request_id=4ab5c512a16341c4bf7cc58c88e683e3
|
||||
2026-10-15 23:11:01,873 WARNING database unavailable request_id=5c558c1c14714272a4563a46f3c2a88b
|
||||
2026-10-15 23:11:06,888 WARNING database unavailable request_id=a20e46964d9046cb9aacf37b77904c45
|
||||
2026-10-15 23:11:18,939 WARNING cache unavailable op=get; bypassing cache for 5s
|
||||
2026-10-15 23:11:19,032 WARNING cache unavailable op=revoke; bypassing cache for 5s; positive entries distrusted for 31s
|
||||
2026-10-15 23:11:25,882 WARNING cache unavailable op=get; bypassing cache for 5s
|
||||
2026-10-15 23:11:26,156 WARNING cache unavailable op=revoke; bypassing cache for 5s; positive entries distrusted for 31s
|
||||
@@ -0,0 +1,51 @@
|
||||
-- Lab2, миграция 001: начальная схема. Источник истины — PostgreSQL.
|
||||
-- Применяется приложением один раз (таблица schema_migrations, advisory lock),
|
||||
-- в одной транзакции вместе с отметкой о версии.
|
||||
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL,
|
||||
display_name text NOT NULL,
|
||||
password_hash text NOT NULL, -- scrypt$logN$r$p$salt$hash, не plaintext
|
||||
created_at timestamptz NOT NULL,
|
||||
CONSTRAINT users_username_key UNIQUE (username), -- гонка регистраций решается здесь
|
||||
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
|
||||
created_at timestamptz NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
user_id uuid NOT NULL REFERENCES users(id),
|
||||
position integer NOT NULL CHECK (position >= 0), -- порядок участников как в запросе
|
||||
PRIMARY KEY (chat_id, user_id) -- участник не дублируется
|
||||
);
|
||||
-- Список чатов пользователя: поиск членства по user_id.
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
sender_id uuid NOT NULL REFERENCES users(id),
|
||||
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
|
||||
created_at timestamptz NOT NULL
|
||||
);
|
||||
-- Keyset-пагинация истории: WHERE chat_id = ? AND (created_at, id) > (?, ?)
|
||||
-- ORDER BY created_at, id LIMIT n — читает только нужную страницу индекса.
|
||||
CREATE INDEX messages_chat_order_idx ON messages (chat_id, created_at, id);
|
||||
|
||||
CREATE TABLE sessions (
|
||||
token_hash bytea PRIMARY KEY, -- SHA-256 от токена; сам токен не хранится
|
||||
user_id uuid NOT NULL REFERENCES users(id),
|
||||
created_at timestamptz NOT NULL,
|
||||
expires_at timestamptz NOT NULL,
|
||||
revoked_at timestamptz,
|
||||
CHECK (expires_at > created_at)
|
||||
);
|
||||
-- Для обслуживания: удаление истёкших сессий (DELETE ... WHERE expires_at < now()).
|
||||
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
|
||||
@@ -0,0 +1,4 @@
|
||||
# Закреплённые версии: драйвер и пул PostgreSQL, клиент Redis-протокола для Valkey.
|
||||
psycopg[binary]==3.2.3
|
||||
psycopg-pool==3.2.4
|
||||
redis==5.2.1
|
||||
Executable
+27
@@ -0,0 +1,27 @@
|
||||
#!/bin/sh
|
||||
# Создаёт локальные синтетические секреты для учебного стенда (каталог secrets/ в .gitignore).
|
||||
# Повторный запуск не перезаписывает существующие файлы: пароль БД в volume уже задан.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
mkdir -p secrets
|
||||
chmod 700 secrets
|
||||
if [ ! -f secrets/postgres_password ]; then
|
||||
python3 -c 'import secrets; print(secrets.token_urlsafe(24), end="")' > secrets/postgres_password
|
||||
echo "created secrets/postgres_password"
|
||||
fi
|
||||
if [ ! -f secrets/database_url ]; then
|
||||
printf 'postgresql://messenger:%s@postgres:5432/messenger' "$(cat secrets/postgres_password)" > secrets/database_url
|
||||
echo "created secrets/database_url"
|
||||
fi
|
||||
if [ ! -f secrets/valkey.conf ]; then
|
||||
# Пароль Valkey передаётся через конфиг-файл (Docker secret), а не аргументом командной строки.
|
||||
VALKEY_PASSWORD=$(python3 -c 'import secrets; print(secrets.token_urlsafe(24), end="")')
|
||||
printf 'requirepass %s\n' "$VALKEY_PASSWORD" > secrets/valkey.conf
|
||||
printf 'redis://:%s@valkey:6379/0' "$VALKEY_PASSWORD" > secrets/cache_url
|
||||
echo "created secrets/valkey.conf and secrets/cache_url"
|
||||
fi
|
||||
# Файлы монтируются в контейнеры как Docker secrets; процессы там работают не от uid хоста,
|
||||
# поэтому файлы читаемы, а доступ ограничивает каталог secrets/ (700).
|
||||
chmod 644 secrets/postgres_password secrets/database_url secrets/valkey.conf secrets/cache_url
|
||||
[ -f .env ] || { cp .env.example .env; echo "created .env from .env.example"; }
|
||||
echo "secrets ready (values are not printed)"
|
||||
Executable
+11
@@ -0,0 +1,11 @@
|
||||
#!/bin/sh
|
||||
# Перезапуск API и всех используемых хранилищ (PostgreSQL, Valkey) с сохранением volume pgdata.
|
||||
# Не выполняет down -v, не пересоздаёт БД и не меняет данные.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
# Сначала останавливаем API, затем хранилища (PostgreSQL — штатный shutdown с checkpoint);
|
||||
# поднимаем в обратном порядке. Valkey без persistence стартует с пустым кэшем.
|
||||
docker compose --env-file .env stop api
|
||||
docker compose --env-file .env stop postgres valkey
|
||||
docker compose --env-file .env start postgres valkey
|
||||
docker compose --env-file .env start api
|
||||
@@ -0,0 +1,53 @@
|
||||
"""Пароли (scrypt из стандартной библиотеки) и сессионные токены."""
|
||||
import base64
|
||||
import hashlib
|
||||
import hmac
|
||||
import os
|
||||
import secrets
|
||||
|
||||
# Параметры scrypt: N=2^15, r=8, p=1 (~32 МБ памяти и ~0.1 с на проверку).
|
||||
SCRYPT_LOG_N = 15
|
||||
SCRYPT_R = 8
|
||||
SCRYPT_P = 1
|
||||
_MAXMEM = 128 * 1024 * 1024
|
||||
|
||||
|
||||
def _scrypt(password, salt, log_n, r, p):
|
||||
return hashlib.scrypt(password.encode("utf-8"), salt=salt, n=2 ** log_n, r=r, p=p,
|
||||
maxmem=_MAXMEM, dklen=32)
|
||||
|
||||
|
||||
def hash_password(password):
|
||||
"""Возвращает строку scrypt$logN$r$p$salt$hash; plaintext нигде не хранится."""
|
||||
salt = os.urandom(16)
|
||||
digest = _scrypt(password, salt, SCRYPT_LOG_N, SCRYPT_R, SCRYPT_P)
|
||||
return "scrypt$%d$%d$%d$%s$%s" % (
|
||||
SCRYPT_LOG_N, SCRYPT_R, SCRYPT_P,
|
||||
base64.b64encode(salt).decode(), base64.b64encode(digest).decode())
|
||||
|
||||
|
||||
def verify_password(password, stored):
|
||||
try:
|
||||
scheme, log_n, r, p, salt, digest = stored.split("$")
|
||||
if scheme != "scrypt":
|
||||
return False
|
||||
expected = base64.b64decode(digest)
|
||||
actual = _scrypt(password, base64.b64decode(salt), int(log_n), int(r), int(p))
|
||||
except (ValueError, TypeError):
|
||||
return False
|
||||
return hmac.compare_digest(actual, expected) # сравнение за постоянное время
|
||||
|
||||
|
||||
# Хеш несуществующего пользователя: неверный логин тратит столько же времени,
|
||||
# сколько неверный пароль, и не выдаёт, существует ли username.
|
||||
DUMMY_HASH = hash_password(secrets.token_urlsafe(16))
|
||||
|
||||
|
||||
def new_token():
|
||||
"""Непрозрачный случайный токен: 32 байта = 256 бит энтропии."""
|
||||
return secrets.token_urlsafe(32)
|
||||
|
||||
|
||||
def token_hash(token):
|
||||
"""В БД лежит только SHA-256 токена: утечка таблицы не даёт готовых сессий."""
|
||||
return hashlib.sha256(token.encode("utf-8")).digest()
|
||||
+503
@@ -0,0 +1,503 @@
|
||||
#!/usr/bin/env python3
|
||||
"""MTUSI Messenger, lab2: REST API с PostgreSQL и сессиями.
|
||||
|
||||
Отличия от lab1:
|
||||
* данные лежат в PostgreSQL и переживают перезапуск API и БД;
|
||||
* регистрация требует password (хранится только scrypt-хеш);
|
||||
* POST /api/v1/auth/sessions (Basic) выдаёт Bearer-токен;
|
||||
* все защищённые endpoint принимают только Authorization: Bearer;
|
||||
* X-User-Id игнорируется.
|
||||
|
||||
Общий каркас (маршрутизация, формат ошибок, X-Request-Id, валидация, keyset-курсор)
|
||||
перенесён из lab1 (app/server.py); хранилище в памяти заменено на store.py.
|
||||
"""
|
||||
import base64
|
||||
import binascii
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import signal
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from pathlib import Path
|
||||
from urllib.parse import parse_qs, urlsplit
|
||||
|
||||
import psycopg
|
||||
from psycopg.conninfo import make_conninfo
|
||||
from psycopg_pool import PoolTimeout
|
||||
|
||||
import security
|
||||
from session_cache import REVOKED, SessionCache
|
||||
from store import Conflict, Store, UnknownMember, format_ts
|
||||
|
||||
HOST = os.environ.get("APP_HOST", "0.0.0.0")
|
||||
PORT = int(os.environ.get("APP_PORT", "8080"))
|
||||
APP_ENV = os.environ.get("APP_ENV", "lab")
|
||||
SESSION_TTL_SECONDS = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
|
||||
MIGRATIONS_DIR = os.environ.get("MIGRATIONS_DIR", str(Path(__file__).resolve().parents[1] / "migrations"))
|
||||
MAX_BODY_BYTES = 1024 * 1024
|
||||
|
||||
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
|
||||
DEFAULT_LIMIT = 50
|
||||
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
|
||||
BEARER_CHALLENGE = 'Bearer realm="messenger"'
|
||||
|
||||
logging.basicConfig(stream=sys.stdout, level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
|
||||
log = logging.getLogger("messenger")
|
||||
|
||||
|
||||
def database_conninfo():
|
||||
"""Строка подключения к PostgreSQL.
|
||||
|
||||
Порядок: DATABASE_URL_FILE (Docker secret, рекомендуемый путь) → DATABASE_URL →
|
||||
набор POSTGRES_*. Значение секрета нигде не логируется.
|
||||
"""
|
||||
path = os.environ.get("DATABASE_URL_FILE")
|
||||
if path:
|
||||
url = Path(path).read_text(encoding="utf-8").strip()
|
||||
else:
|
||||
url = os.environ.get("DATABASE_URL", "")
|
||||
if url:
|
||||
# connect_timeout ограничивает ожидание недоступной БД при открытии соединения.
|
||||
return make_conninfo(url, connect_timeout=5)
|
||||
return make_conninfo(
|
||||
host=os.environ.get("POSTGRES_HOST", "localhost"),
|
||||
port=os.environ.get("POSTGRES_PORT", "5432"),
|
||||
dbname=os.environ.get("POSTGRES_DB", "messenger"),
|
||||
user=os.environ.get("POSTGRES_USER", "messenger"),
|
||||
password=os.environ.get("POSTGRES_PASSWORD", ""),
|
||||
connect_timeout=5,
|
||||
)
|
||||
|
||||
|
||||
STORE = Store(database_conninfo(),
|
||||
pool_size=int(os.environ.get("DB_POOL_SIZE", "10")),
|
||||
statement_timeout_ms=int(os.environ.get("DB_STATEMENT_TIMEOUT_MS", "5000")))
|
||||
|
||||
|
||||
def cache_url():
|
||||
"""URL Valkey из CACHE_URL_FILE (Docker secret). SESSION_CACHE=off отключает кэш."""
|
||||
if os.environ.get("SESSION_CACHE", "valkey").lower() == "off":
|
||||
return ""
|
||||
path = os.environ.get("CACHE_URL_FILE")
|
||||
if path:
|
||||
return Path(path).read_text(encoding="utf-8").strip()
|
||||
return os.environ.get("CACHE_URL", "")
|
||||
|
||||
|
||||
SESSION_CACHE = SessionCache(
|
||||
cache_url(),
|
||||
ttl_seconds=int(os.environ.get("SESSION_CACHE_TTL_SECONDS", "30")),
|
||||
timeout_ms=int(os.environ.get("CACHE_TIMEOUT_MS", "250")),
|
||||
retry_seconds=float(os.environ.get("CACHE_RETRY_SECONDS", "5")))
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Ошибки API
|
||||
# --------------------------------------------------------------------------
|
||||
class ApiError(Exception):
|
||||
def __init__(self, status, code, message, headers=None):
|
||||
super().__init__(message)
|
||||
self.status = status
|
||||
self.code = code
|
||||
self.message = message
|
||||
self.headers = headers or {}
|
||||
|
||||
|
||||
def bad_request(message="Неверный запрос"):
|
||||
return ApiError(400, "invalid_request", message)
|
||||
|
||||
|
||||
def unauthorized(challenge=BEARER_CHALLENGE):
|
||||
# Одинаковый ответ для любых причин: не раскрываем, что именно не так.
|
||||
return ApiError(401, "unauthorized", "Требуется действительная аутентификация",
|
||||
{"WWW-Authenticate": challenge})
|
||||
|
||||
|
||||
def not_found():
|
||||
return ApiError(404, "not_found", "Объект не найден")
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Валидация
|
||||
# --------------------------------------------------------------------------
|
||||
def parse_uuid(value):
|
||||
try:
|
||||
return str(uuid.UUID(value))
|
||||
except (ValueError, TypeError, AttributeError):
|
||||
return None
|
||||
|
||||
|
||||
def require_object(body, allowed, required):
|
||||
if not isinstance(body, dict):
|
||||
raise bad_request("Тело запроса должно быть JSON-объектом")
|
||||
if set(body) - set(allowed):
|
||||
raise bad_request("Лишние поля в запросе")
|
||||
if any(k not in body for k in required):
|
||||
raise bad_request("Не хватает обязательных полей")
|
||||
|
||||
|
||||
def require_text(value, field, max_len, min_len=1):
|
||||
if not isinstance(value, str):
|
||||
raise bad_request("Поле %s должно быть строкой" % field)
|
||||
if not value.strip():
|
||||
raise bad_request("Поле %s не должно быть пустым" % field)
|
||||
if "\x00" in value:
|
||||
raise bad_request("Поле %s содержит недопустимый символ" % field)
|
||||
if not min_len <= len(value) <= max_len: # len() считает Unicode code points
|
||||
raise bad_request("Поле %s имеет недопустимую длину" % field)
|
||||
return value
|
||||
|
||||
|
||||
def encode_cursor(kind, scope, key):
|
||||
raw = json.dumps({"k": kind, "s": scope, "t": key[0], "i": key[1]}, separators=(",", ":"))
|
||||
return base64.urlsafe_b64encode(raw.encode()).decode().rstrip("=")
|
||||
|
||||
|
||||
def decode_cursor(cursor, kind, scope):
|
||||
try:
|
||||
padded = cursor + "=" * (-len(cursor) % 4)
|
||||
data = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")))
|
||||
if data["k"] != kind or data["s"] != scope:
|
||||
raise ValueError
|
||||
t, i = data["t"], parse_uuid(data["i"])
|
||||
if not isinstance(t, int) or isinstance(t, bool) or i is None or abs(t) > 10 ** 17:
|
||||
raise ValueError
|
||||
return (t, i)
|
||||
except (ValueError, KeyError, TypeError, UnicodeError, binascii.Error):
|
||||
raise bad_request("Неверный cursor")
|
||||
|
||||
|
||||
def page_params(query):
|
||||
def single(name):
|
||||
values = query.get(name)
|
||||
if values is None:
|
||||
return None
|
||||
if len(values) != 1:
|
||||
raise bad_request("Параметр %s указан несколько раз" % name)
|
||||
return values[0]
|
||||
|
||||
limit_raw = single("limit")
|
||||
if limit_raw is None:
|
||||
limit = DEFAULT_LIMIT
|
||||
else:
|
||||
if not re.fullmatch(r"[0-9]{1,3}", limit_raw) or not 1 <= int(limit_raw) <= 100:
|
||||
raise bad_request("limit должен быть целым от 1 до 100")
|
||||
limit = int(limit_raw)
|
||||
cursor = single("cursor")
|
||||
if cursor == "":
|
||||
raise bad_request("Неверный cursor")
|
||||
return limit, cursor
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Обработчики
|
||||
# --------------------------------------------------------------------------
|
||||
def h_live(req):
|
||||
return 200, {"status": "ok"}
|
||||
|
||||
|
||||
def h_ready(req):
|
||||
# Критичная зависимость одна — PostgreSQL. Без неё обслуживать запросы нельзя.
|
||||
# Valkey не критичен: при его отказе сессии проверяются напрямую в PostgreSQL.
|
||||
try:
|
||||
STORE.ping()
|
||||
except Exception:
|
||||
raise ApiError(503, "unavailable", "Сервис временно недоступен")
|
||||
return 200, {"status": "ok"}
|
||||
|
||||
|
||||
def h_create_user(req):
|
||||
body = req.json_body()
|
||||
fields = ("username", "display_name", "password")
|
||||
require_object(body, fields, fields)
|
||||
username = body["username"]
|
||||
if not isinstance(username, str) or not USERNAME_RE.fullmatch(username):
|
||||
raise bad_request("username должен соответствовать [a-z0-9_]{3,32}")
|
||||
display_name = require_text(body["display_name"], "display_name", 100)
|
||||
password = require_text(body["password"], "password", 128, min_len=12)
|
||||
try:
|
||||
return 201, STORE.create_user(username, display_name, security.hash_password(password))
|
||||
except Conflict:
|
||||
raise ApiError(409, "conflict", "Имя пользователя уже занято")
|
||||
|
||||
|
||||
def h_create_session(req):
|
||||
"""Вход: только Authorization: Basic, без JSON body."""
|
||||
header = req.headers.get("Authorization", "")
|
||||
scheme, _, encoded = header.partition(" ")
|
||||
failure = unauthorized(BASIC_CHALLENGE)
|
||||
if scheme.lower() != "basic":
|
||||
raise failure
|
||||
try:
|
||||
decoded = base64.b64decode(encoded.strip(), validate=True).decode("utf-8")
|
||||
except (binascii.Error, ValueError, UnicodeError):
|
||||
raise failure
|
||||
username, sep, password = decoded.partition(":") # двоеточие в пароле допустимо
|
||||
if not sep:
|
||||
raise failure
|
||||
user, stored_hash = (None, None)
|
||||
if USERNAME_RE.fullmatch(username):
|
||||
user, stored_hash = STORE.get_credentials(username)
|
||||
# Проверяем scrypt всегда (для неизвестного логина — с фиктивным хешем):
|
||||
# время ответа не выдаёт, существует ли пользователь.
|
||||
ok = security.verify_password(password, stored_hash or security.DUMMY_HASH)
|
||||
if user is None or not ok:
|
||||
raise failure
|
||||
token = security.new_token()
|
||||
th = security.token_hash(token)
|
||||
started = time.monotonic()
|
||||
expires_at = STORE.create_session(user["id"], th, SESSION_TTL_SECONDS) # источник истины
|
||||
SESSION_CACHE.put(th, user, expires_at.timestamp(), started) # прогрев кэша
|
||||
return 201, {"token": token, "token_type": "Bearer", "expires_at": format_ts(expires_at), "user": user}
|
||||
|
||||
|
||||
def h_delete_session(req):
|
||||
req.current_user()
|
||||
STORE.revoke_session(req.token_hash) # 1) COMMIT отзыва в PostgreSQL
|
||||
SESSION_CACHE.revoke(req.token_hash) # 2) tombstone в Valkey поверх возможной копии
|
||||
return 204, None
|
||||
|
||||
|
||||
def h_me(req):
|
||||
return 200, req.current_user()
|
||||
|
||||
|
||||
def h_create_chat(req):
|
||||
user = req.current_user()
|
||||
body = req.json_body()
|
||||
require_object(body, ("title", "member_ids"), ("title", "member_ids"))
|
||||
title = require_text(body["title"], "title", 100)
|
||||
members = body["member_ids"]
|
||||
if not isinstance(members, list) or not 1 <= len(members) <= 100:
|
||||
raise bad_request("member_ids должен быть списком из 1–100 UUID")
|
||||
normalized = []
|
||||
for m in members:
|
||||
mid = parse_uuid(m) if isinstance(m, str) else None
|
||||
if mid is None:
|
||||
raise bad_request("member_ids должен содержать UUID-строки")
|
||||
normalized.append(mid)
|
||||
if len(set(normalized)) != len(normalized):
|
||||
raise bad_request("Дубликаты в member_ids")
|
||||
if user["id"] not in normalized:
|
||||
raise bad_request("Создатель должен входить в member_ids")
|
||||
try:
|
||||
return 201, STORE.create_chat(title, normalized)
|
||||
except UnknownMember:
|
||||
raise bad_request("Неизвестный участник чата")
|
||||
|
||||
|
||||
def h_list_chats(req):
|
||||
user = req.current_user()
|
||||
limit, cursor = page_params(req.query)
|
||||
after = decode_cursor(cursor, "chats", user["id"]) if cursor else None
|
||||
items, last = STORE.list_chats(user["id"], after, limit)
|
||||
return 200, {"items": items, "next_cursor": encode_cursor("chats", user["id"], last) if last else None}
|
||||
|
||||
|
||||
def _chat_or_404(user, chat_id):
|
||||
chat = STORE.get_chat_for(user["id"], chat_id)
|
||||
if chat is None:
|
||||
raise not_found()
|
||||
return chat
|
||||
|
||||
|
||||
def h_get_chat(req, chat_id):
|
||||
user = req.current_user()
|
||||
return 200, _chat_or_404(user, req.path_uuid(chat_id))
|
||||
|
||||
|
||||
def h_create_message(req, chat_id):
|
||||
user = req.current_user()
|
||||
cid = req.path_uuid(chat_id)
|
||||
_chat_or_404(user, cid) # сначала доступ: посторонний получает 404
|
||||
body = req.json_body()
|
||||
require_object(body, ("text",), ("text",))
|
||||
text = require_text(body["text"], "text", 4000)
|
||||
message = STORE.add_message(user["id"], cid, text)
|
||||
if message is None:
|
||||
raise not_found()
|
||||
return 201, message
|
||||
|
||||
|
||||
def h_list_messages(req, chat_id):
|
||||
user = req.current_user()
|
||||
cid = req.path_uuid(chat_id)
|
||||
_chat_or_404(user, cid)
|
||||
limit, cursor = page_params(req.query)
|
||||
after = decode_cursor(cursor, "messages", cid) if cursor else None
|
||||
items, last = STORE.list_messages(cid, after, limit)
|
||||
return 200, {"items": items, "next_cursor": encode_cursor("messages", cid, last) if last else None}
|
||||
|
||||
|
||||
ROUTES = [
|
||||
("GET", re.compile(r"^/health/live$"), h_live),
|
||||
("GET", re.compile(r"^/health/ready$"), h_ready),
|
||||
("POST", re.compile(r"^/api/v1/users$"), h_create_user),
|
||||
("GET", re.compile(r"^/api/v1/users/me$"), h_me),
|
||||
("POST", re.compile(r"^/api/v1/auth/sessions$"), h_create_session),
|
||||
("DELETE", re.compile(r"^/api/v1/auth/sessions/current$"), h_delete_session),
|
||||
("POST", re.compile(r"^/api/v1/chats$"), h_create_chat),
|
||||
("GET", re.compile(r"^/api/v1/chats$"), h_list_chats),
|
||||
("GET", re.compile(r"^/api/v1/chats/([^/]+)$"), h_get_chat),
|
||||
("POST", re.compile(r"^/api/v1/chats/([^/]+)/messages$"), h_create_message),
|
||||
("GET", re.compile(r"^/api/v1/chats/([^/]+)/messages$"), h_list_messages),
|
||||
]
|
||||
|
||||
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
protocol_version = "HTTP/1.1"
|
||||
server_version = "mtusi-messenger/2.0"
|
||||
sys_version = ""
|
||||
|
||||
def json_body(self):
|
||||
ctype = (self.headers.get("Content-Type") or "").split(";")[0].strip().lower()
|
||||
if ctype != "application/json":
|
||||
raise ApiError(415, "unsupported_media_type", "Ожидается Content-Type: application/json")
|
||||
try:
|
||||
return json.loads(self._body.decode("utf-8"))
|
||||
except (UnicodeDecodeError, ValueError):
|
||||
raise bad_request("Некорректный JSON")
|
||||
|
||||
def current_user(self):
|
||||
"""Только Bearer-токен действующей сессии. Basic и X-User-Id доступа не дают."""
|
||||
scheme, _, token = self.headers.get("Authorization", "").partition(" ")
|
||||
token = token.strip()
|
||||
if scheme.lower() != "bearer" or not token:
|
||||
raise unauthorized()
|
||||
self.token_hash = security.token_hash(token)
|
||||
cached = SESSION_CACHE.get(self.token_hash) # 1) Valkey: hit / tombstone / промах
|
||||
if cached is REVOKED:
|
||||
raise unauthorized()
|
||||
if cached is not None:
|
||||
return cached
|
||||
started = time.monotonic()
|
||||
found = STORE.get_session_user(self.token_hash) # 2) промах → PostgreSQL
|
||||
if found is None:
|
||||
raise unauthorized()
|
||||
user, expires_at = found
|
||||
SESSION_CACHE.put(self.token_hash, user, expires_at.timestamp(), started)
|
||||
return user
|
||||
|
||||
def path_uuid(self, value):
|
||||
parsed = parse_uuid(value)
|
||||
if parsed is None:
|
||||
raise bad_request("Неверный UUID в пути")
|
||||
return parsed
|
||||
|
||||
def _read_body(self):
|
||||
length = self.headers.get("Content-Length")
|
||||
if length is None:
|
||||
return b""
|
||||
try:
|
||||
n = int(length)
|
||||
except ValueError:
|
||||
raise bad_request("Неверный Content-Length")
|
||||
if n < 0:
|
||||
raise bad_request("Неверный Content-Length")
|
||||
if n > MAX_BODY_BYTES:
|
||||
self.close_connection = True
|
||||
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое")
|
||||
return self.rfile.read(n)
|
||||
|
||||
def _dispatch(self, method):
|
||||
self.request_id = uuid.uuid4().hex
|
||||
started = time.monotonic()
|
||||
parts = urlsplit(self.path)
|
||||
path = parts.path
|
||||
headers = {}
|
||||
try:
|
||||
self._body = self._read_body()
|
||||
self.query = parse_qs(parts.query, keep_blank_values=True)
|
||||
for m, pattern, func in ROUTES:
|
||||
match = pattern.match(path)
|
||||
if match and m == method:
|
||||
status, payload = func(self, *match.groups())
|
||||
break
|
||||
else:
|
||||
raise not_found()
|
||||
except ApiError as err:
|
||||
status, payload, headers = err.status, self._error(err.code, err.message), err.headers
|
||||
except (psycopg.OperationalError, PoolTimeout):
|
||||
# БД недоступна: честный 503, а не «успех» или 500.
|
||||
log.warning("database unavailable request_id=%s", self.request_id)
|
||||
status, payload = 503, self._error("unavailable", "Сервис временно недоступен")
|
||||
except Exception:
|
||||
log.exception("unhandled error request_id=%s", self.request_id)
|
||||
status, payload = 500, self._error("internal_error", "Внутренняя ошибка сервера")
|
||||
self._send(status, payload, headers)
|
||||
# В лог не попадают тела запросов, пароли, токены и тексты сообщений.
|
||||
log.info("%s %s -> %d %.1fms request_id=%s", method, path, status,
|
||||
(time.monotonic() - started) * 1000, self.request_id)
|
||||
|
||||
def _error(self, code, message):
|
||||
return {"error": {"code": code, "message": message, "request_id": self.request_id}}
|
||||
|
||||
def _send(self, status, payload, headers):
|
||||
self.send_response(status)
|
||||
self.send_header("X-Request-Id", self.request_id)
|
||||
for name, value in headers.items():
|
||||
self.send_header(name, value)
|
||||
if payload is None: # 204: без тела
|
||||
self.end_headers()
|
||||
return
|
||||
data = json.dumps(payload, ensure_ascii=False).encode("utf-8")
|
||||
self.send_header("Content-Type", "application/json; charset=utf-8")
|
||||
self.send_header("Content-Length", str(len(data)))
|
||||
self.end_headers()
|
||||
self.wfile.write(data)
|
||||
|
||||
def do_GET(self):
|
||||
self._dispatch("GET")
|
||||
|
||||
def do_POST(self):
|
||||
self._dispatch("POST")
|
||||
|
||||
def do_PUT(self):
|
||||
self._dispatch("PUT")
|
||||
|
||||
def do_PATCH(self):
|
||||
self._dispatch("PATCH")
|
||||
|
||||
def do_DELETE(self):
|
||||
self._dispatch("DELETE")
|
||||
|
||||
def log_message(self, fmt, *args):
|
||||
pass
|
||||
|
||||
|
||||
class Server(ThreadingHTTPServer):
|
||||
request_queue_size = 1024
|
||||
daemon_threads = True
|
||||
|
||||
|
||||
def main():
|
||||
STORE.open()
|
||||
STORE.migrate(MIGRATIONS_DIR)
|
||||
if "--migrate-only" in sys.argv[1:]:
|
||||
# Отдельный запуск миграций: docker compose run --rm api python /app/src/server.py --migrate-only
|
||||
log.info("migrations are up to date, exiting (--migrate-only)")
|
||||
STORE.close()
|
||||
return
|
||||
server = Server((HOST, PORT), Handler)
|
||||
|
||||
def stop(signum, frame):
|
||||
log.info("signal %d received, shutting down", signum)
|
||||
threading.Thread(target=server.shutdown, daemon=True).start()
|
||||
|
||||
signal.signal(signal.SIGTERM, stop)
|
||||
signal.signal(signal.SIGINT, stop)
|
||||
log.info("listening on %s:%d env=%s session_ttl=%ds session_cache=%s", HOST, PORT, APP_ENV,
|
||||
SESSION_TTL_SECONDS, "valkey" if SESSION_CACHE.enabled else "off")
|
||||
server.serve_forever()
|
||||
server.server_close()
|
||||
STORE.close()
|
||||
log.info("stopped")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,121 @@
|
||||
"""Кэш сессий в Valkey (уровень 4).
|
||||
|
||||
Роль: ускорить проверку Bearer-токена, которая выполняется на КАЖДОМ защищённом запросе.
|
||||
Источник истины — таблица sessions в PostgreSQL; Valkey хранит только производные копии.
|
||||
|
||||
Ключ: sess:<sha256(token) hex> (сам токен в Valkey не попадает)
|
||||
Значение: {"user": {...}, "exp": <unix-время истечения сессии>} либо "revoked"
|
||||
|
||||
Политика expiry:
|
||||
* положительная запись живёт min(SESSION_CACHE_TTL_SECONDS, остаток сессии) — PX в мс,
|
||||
поэтому кэш не переживает саму сессию; при чтении "exp" дополнительно сверяется с часами;
|
||||
* запись "revoked" (tombstone) живёт SESSION_CACHE_TTL_SECONDS + 1 с — дольше любой
|
||||
положительной записи, созданной до отзыва.
|
||||
|
||||
Инвалидация (logout): сначала UPDATE sessions SET revoked_at в PostgreSQL (COMMIT), затем
|
||||
SET sess:<h> "revoked" поверх положительной записи. Заполнение кэша после промаха делается
|
||||
SET NX, поэтому конкурентный запрос, прочитавший БД до отзыва, не может перезаписать tombstone.
|
||||
|
||||
Отказ Valkey: любая ошибка/таймаут (по умолчанию 250 мс) → запрос обслуживается из PostgreSQL,
|
||||
кэш обходится CACHE_RETRY_SECONDS секунд (простой circuit breaker). Если не удалось записать
|
||||
tombstone, процесс SESSION_CACHE_TTL_SECONDS+1 секунд не доверяет положительным записям кэша:
|
||||
устаревшая запись могла остаться в Valkey, но за это время она гарантированно истечёт.
|
||||
"""
|
||||
import json
|
||||
import logging
|
||||
import threading
|
||||
import time
|
||||
|
||||
import redis
|
||||
|
||||
log = logging.getLogger("messenger.cache")
|
||||
|
||||
PREFIX = "sess:"
|
||||
REVOKED = object() # результат get(): сессия отозвана (tombstone)
|
||||
MISS = None # результат get(): нет данных/кэш недоступен → идти в PostgreSQL
|
||||
_TOMBSTONE = b"revoked"
|
||||
|
||||
|
||||
class SessionCache:
|
||||
def __init__(self, url, ttl_seconds=30, timeout_ms=250, retry_seconds=5.0, pool_size=10):
|
||||
self.enabled = bool(url)
|
||||
self.ttl = ttl_seconds
|
||||
self.retry_seconds = retry_seconds
|
||||
self._lock = threading.Lock()
|
||||
self._skip_until = 0.0 # circuit breaker: до этого момента кэш не опрашиваем
|
||||
self._distrust_until = 0.0 # до этого момента положительные записи игнорируем
|
||||
self.client = None
|
||||
if self.enabled:
|
||||
timeout = timeout_ms / 1000.0
|
||||
# Ограниченный пул: не более pool_size соединений, ожидание свободного — timeout.
|
||||
pool = redis.BlockingConnectionPool.from_url(
|
||||
url, max_connections=pool_size, timeout=timeout,
|
||||
socket_timeout=timeout, socket_connect_timeout=timeout)
|
||||
self.client = redis.Redis(connection_pool=pool)
|
||||
|
||||
# --- служебное ---
|
||||
def _available(self):
|
||||
return self.enabled and time.monotonic() >= self._skip_until
|
||||
|
||||
def _failed(self, op, invalidation=False):
|
||||
now = time.monotonic()
|
||||
with self._lock:
|
||||
self._skip_until = now + self.retry_seconds
|
||||
if invalidation:
|
||||
self._distrust_until = max(self._distrust_until, now + self.ttl + 1)
|
||||
log.warning("cache unavailable op=%s; bypassing cache for %.0fs%s", op, self.retry_seconds,
|
||||
"; positive entries distrusted for %ds" % (self.ttl + 1) if invalidation else "")
|
||||
|
||||
@staticmethod
|
||||
def _key(token_hash):
|
||||
return PREFIX + token_hash.hex()
|
||||
|
||||
# --- API ---
|
||||
def get(self, token_hash):
|
||||
"""Пользователь из кэша, REVOKED или MISS."""
|
||||
if not self._available():
|
||||
return MISS
|
||||
try:
|
||||
raw = self.client.get(self._key(token_hash))
|
||||
except redis.RedisError:
|
||||
self._failed("get")
|
||||
return MISS
|
||||
if raw is None:
|
||||
return MISS
|
||||
if raw == _TOMBSTONE:
|
||||
return REVOKED
|
||||
if time.monotonic() < self._distrust_until:
|
||||
return MISS
|
||||
try:
|
||||
data = json.loads(raw)
|
||||
if data["exp"] <= time.time():
|
||||
return MISS
|
||||
return data["user"]
|
||||
except (ValueError, KeyError, TypeError):
|
||||
return MISS
|
||||
|
||||
def put(self, token_hash, user, expires_epoch, read_started):
|
||||
"""Заполнить кэш после чтения действующей сессии из PostgreSQL."""
|
||||
if not self._available():
|
||||
return
|
||||
# Если между чтением БД и записью в кэш прошло подозрительно много времени,
|
||||
# данные могли устареть (например, logout + истечение tombstone) — не кэшируем.
|
||||
if time.monotonic() - read_started > 1.0:
|
||||
return
|
||||
ttl_ms = int(min(self.ttl, expires_epoch - time.time()) * 1000)
|
||||
if ttl_ms <= 0:
|
||||
return
|
||||
value = json.dumps({"user": user, "exp": expires_epoch}, separators=(",", ":"))
|
||||
try:
|
||||
self.client.set(self._key(token_hash), value, px=ttl_ms, nx=True)
|
||||
except redis.RedisError:
|
||||
self._failed("set")
|
||||
|
||||
def revoke(self, token_hash):
|
||||
"""Tombstone после COMMIT отзыва в PostgreSQL. Пробуем даже при открытом breaker."""
|
||||
if not self.enabled:
|
||||
return
|
||||
try:
|
||||
self.client.set(self._key(token_hash), _TOMBSTONE, ex=self.ttl + 1)
|
||||
except redis.RedisError:
|
||||
self._failed("revoke", invalidation=True)
|
||||
+271
@@ -0,0 +1,271 @@
|
||||
"""Работа с PostgreSQL: пользователи, чаты, сообщения, сессии.
|
||||
|
||||
Источник истины — база данных. В памяти процесса состояния нет, поэтому
|
||||
перезапуск API (и самой БД с сохранённым volume) не теряет данные.
|
||||
"""
|
||||
import datetime as dt
|
||||
import logging
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
import psycopg
|
||||
from psycopg.rows import dict_row
|
||||
from psycopg_pool import ConnectionPool
|
||||
|
||||
log = logging.getLogger("messenger.store")
|
||||
|
||||
EPOCH = dt.datetime(1970, 1, 1, tzinfo=dt.timezone.utc)
|
||||
MIGRATIONS_LOCK_ID = 727001 # произвольный номер advisory-блокировки для миграций
|
||||
|
||||
|
||||
class Conflict(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class UnknownMember(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def format_ts(value):
|
||||
"""datetime -> RFC 3339 UTC с микросекундами и суффиксом Z."""
|
||||
return value.astimezone(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
|
||||
|
||||
|
||||
def to_micros(value):
|
||||
delta = value - EPOCH
|
||||
return (delta.days * 86400 + delta.seconds) * 1_000_000 + delta.microseconds
|
||||
|
||||
|
||||
def from_micros(micros):
|
||||
return EPOCH + dt.timedelta(microseconds=micros)
|
||||
|
||||
|
||||
def _user(row):
|
||||
# Пароль/hash и сессионные данные никогда не входят в User.
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"username": row["username"],
|
||||
"display_name": row["display_name"],
|
||||
"created_at": format_ts(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
def _chat(row):
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"title": row["title"],
|
||||
"member_ids": [str(m) for m in row["member_ids"]],
|
||||
"created_at": format_ts(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
def _message(row):
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"chat_id": str(row["chat_id"]),
|
||||
"sender_id": str(row["sender_id"]),
|
||||
"text": row["text"],
|
||||
"created_at": format_ts(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
CHAT_COLUMNS = """c.id, c.title, c.created_at,
|
||||
(SELECT array_agg(m.user_id ORDER BY m.position) FROM chat_members m WHERE m.chat_id = c.id) AS member_ids"""
|
||||
|
||||
|
||||
class Store:
|
||||
def __init__(self, conninfo, pool_size=10, statement_timeout_ms=5000):
|
||||
# Ограниченный пул: не более pool_size соединений; ожидание свободного — до 5 с,
|
||||
# затем PoolTimeout → 503. statement_timeout обрывает зависший SQL.
|
||||
# check: перед выдачей соединение проверяется. После перезапуска PostgreSQL
|
||||
# «мёртвые» соединения отбрасываются, и запрос не получает ложный 503.
|
||||
self.pool = ConnectionPool(
|
||||
conninfo, min_size=1, max_size=pool_size, timeout=5,
|
||||
kwargs={"row_factory": dict_row,
|
||||
"options": "-c statement_timeout=%d" % statement_timeout_ms},
|
||||
open=False,
|
||||
check=ConnectionPool.check_connection)
|
||||
|
||||
# --- запуск ---
|
||||
def open(self, wait_seconds=60):
|
||||
"""Ждём готовности БД (она может стартовать дольше API) и открываем пул."""
|
||||
self.pool.open()
|
||||
deadline = time.monotonic() + wait_seconds
|
||||
while True:
|
||||
try:
|
||||
with self.pool.connection() as conn:
|
||||
conn.execute("SELECT 1")
|
||||
return
|
||||
except Exception as exc:
|
||||
if time.monotonic() > deadline:
|
||||
raise
|
||||
log.info("database is not ready yet (%s), retrying", type(exc).__name__)
|
||||
time.sleep(1)
|
||||
|
||||
def close(self):
|
||||
self.pool.close()
|
||||
|
||||
def migrate(self, directory):
|
||||
"""Применяет *.sql по порядку имён; каждая миграция — одна транзакция, один раз."""
|
||||
files = sorted(Path(directory).glob("*.sql"))
|
||||
with self.pool.connection() as conn:
|
||||
# Advisory-блокировка (сессионная): несколько процессов не применят миграции одновременно.
|
||||
conn.autocommit = True
|
||||
conn.execute("SELECT pg_advisory_lock(%s)", (MIGRATIONS_LOCK_ID,))
|
||||
try:
|
||||
conn.execute("""CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())""")
|
||||
done = {r["version"] for r in conn.execute("SELECT version FROM schema_migrations")}
|
||||
for path in files:
|
||||
if path.name in done:
|
||||
continue
|
||||
# Каждая миграция и её отметка — одна транзакция: либо целиком, либо никак.
|
||||
with conn.transaction():
|
||||
conn.execute(path.read_text(encoding="utf-8"))
|
||||
conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.name,))
|
||||
log.info("migration applied: %s", path.name)
|
||||
log.info("schema version: %s", files[-1].name if files else "none")
|
||||
finally:
|
||||
conn.execute("SELECT pg_advisory_unlock(%s)", (MIGRATIONS_LOCK_ID,))
|
||||
conn.autocommit = False
|
||||
|
||||
def ping(self):
|
||||
with self.pool.connection() as conn:
|
||||
conn.execute("SELECT 1")
|
||||
|
||||
# --- пользователи ---
|
||||
def create_user(self, username, display_name, password_hash):
|
||||
try:
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"""INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES (%s, %s, %s, %s, clock_timestamp())
|
||||
RETURNING id, username, display_name, created_at""",
|
||||
(uuid.uuid4(), username, display_name, password_hash)).fetchone()
|
||||
except psycopg.errors.UniqueViolation:
|
||||
# Уникальность гарантирует сама БД — гонка двух регистраций безопасна.
|
||||
raise Conflict()
|
||||
return _user(row)
|
||||
|
||||
def get_credentials(self, username):
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
|
||||
(username,)).fetchone()
|
||||
if row is None:
|
||||
return None, None
|
||||
return _user(row), row["password_hash"]
|
||||
|
||||
# --- сессии ---
|
||||
def create_session(self, user_id, token_hash, ttl_seconds):
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"""INSERT INTO sessions (token_hash, user_id, created_at, expires_at)
|
||||
VALUES (%s, %s, now(), now() + make_interval(secs => %s))
|
||||
RETURNING expires_at""",
|
||||
(token_hash, user_id, ttl_seconds)).fetchone()
|
||||
return row["expires_at"]
|
||||
|
||||
def get_session_user(self, token_hash):
|
||||
"""(пользователь, expires_at) действующей сессии или None (неизвестна/истекла/отозвана)."""
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"""SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at
|
||||
FROM sessions s JOIN users u ON u.id = s.user_id
|
||||
WHERE s.token_hash = %s AND s.revoked_at IS NULL AND s.expires_at > now()""",
|
||||
(token_hash,)).fetchone()
|
||||
return (_user(row), row["expires_at"]) if row else None
|
||||
|
||||
def revoke_session(self, token_hash):
|
||||
with self.pool.connection() as conn:
|
||||
conn.execute(
|
||||
"UPDATE sessions SET revoked_at = now() WHERE token_hash = %s AND revoked_at IS NULL",
|
||||
(token_hash,))
|
||||
|
||||
# --- чаты ---
|
||||
def create_chat(self, title, member_ids):
|
||||
"""Чат и его участники создаются в одной транзакции (атомарно)."""
|
||||
chat_id = uuid.uuid4()
|
||||
# Блок `with pool.connection()` = одна транзакция: COMMIT при выходе без исключения,
|
||||
# ROLLBACK при любом исключении. Чат без участников (или наоборот) не появится.
|
||||
try:
|
||||
with self.pool.connection() as conn:
|
||||
found = conn.execute(
|
||||
"SELECT count(*) AS n FROM users WHERE id = ANY(%s::uuid[])", (member_ids,)).fetchone()["n"]
|
||||
if found != len(member_ids):
|
||||
raise UnknownMember()
|
||||
conn.execute(
|
||||
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, clock_timestamp())",
|
||||
(chat_id, title))
|
||||
with conn.cursor() as cur:
|
||||
cur.executemany(
|
||||
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
|
||||
[(chat_id, m, i) for i, m in enumerate(member_ids)])
|
||||
row = conn.execute("SELECT " + CHAT_COLUMNS + " FROM chats c WHERE c.id = %s", (chat_id,)).fetchone()
|
||||
except psycopg.errors.ForeignKeyViolation:
|
||||
# Внешний ключ — последняя линия защиты: транзакция откатывается целиком.
|
||||
raise UnknownMember()
|
||||
return _chat(row)
|
||||
|
||||
def get_chat_for(self, user_id, chat_id):
|
||||
"""Чат, если пользователь — участник; иначе None (чужой и несуществующий неразличимы)."""
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"SELECT " + CHAT_COLUMNS + """ FROM chats c
|
||||
WHERE c.id = %s AND EXISTS (
|
||||
SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = %s)""",
|
||||
(chat_id, user_id)).fetchone()
|
||||
return _chat(row) if row else None
|
||||
|
||||
def list_chats(self, user_id, after, limit):
|
||||
params = [user_id]
|
||||
where = ""
|
||||
if after:
|
||||
where = "AND (c.created_at, c.id) > (%s, %s::uuid)"
|
||||
params += [from_micros(after[0]), after[1]]
|
||||
params.append(limit + 1) # +1 запись: узнаём, есть ли следующая страница
|
||||
with self.pool.connection() as conn:
|
||||
rows = conn.execute(
|
||||
"SELECT " + CHAT_COLUMNS + """ FROM chats c
|
||||
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s
|
||||
WHERE true """ + where + " ORDER BY c.created_at, c.id LIMIT %s", params).fetchall()
|
||||
return self._page(rows, limit, _chat)
|
||||
|
||||
# --- сообщения ---
|
||||
def add_message(self, user_id, chat_id, text):
|
||||
with self.pool.connection() as conn:
|
||||
# FOR UPDATE по строке чата: вставки в один чат идут по очереди, поэтому
|
||||
# created_at растёт в порядке фиксации и keyset-курсор не пропускает записи.
|
||||
allowed = conn.execute(
|
||||
"""SELECT 1 FROM chats c WHERE c.id = %s AND EXISTS (
|
||||
SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = %s)
|
||||
FOR UPDATE OF c""", (chat_id, user_id)).fetchone()
|
||||
if allowed is None:
|
||||
return None
|
||||
row = conn.execute(
|
||||
"""INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
VALUES (%s, %s, %s, %s, clock_timestamp())
|
||||
RETURNING id, chat_id, sender_id, text, created_at""",
|
||||
(uuid.uuid4(), chat_id, user_id, text)).fetchone()
|
||||
return _message(row)
|
||||
|
||||
def list_messages(self, chat_id, after, limit):
|
||||
params = [chat_id]
|
||||
where = ""
|
||||
if after:
|
||||
where = "AND (created_at, id) > (%s, %s::uuid)"
|
||||
params += [from_micros(after[0]), after[1]]
|
||||
params.append(limit + 1)
|
||||
with self.pool.connection() as conn:
|
||||
rows = conn.execute(
|
||||
"SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s "
|
||||
+ where + " ORDER BY created_at, id LIMIT %s", params).fetchall()
|
||||
return self._page(rows, limit, _message)
|
||||
|
||||
@staticmethod
|
||||
def _page(rows, limit, convert):
|
||||
has_more = len(rows) > limit
|
||||
rows = rows[:limit]
|
||||
last = (to_micros(rows[-1]["created_at"]), str(rows[-1]["id"])) if rows and has_more else None
|
||||
return [convert(r) for r in rows], last
|
||||
@@ -0,0 +1,72 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Польза кэша сессий: нагрузка на PostgreSQL и задержка проверки токена.
|
||||
|
||||
python3 student-tests/cache_bench.py --label valkey [--requests 1000]
|
||||
|
||||
Делает N последовательных GET /api/v1/users/me одним токеном и считает:
|
||||
* прирост xact_commit в pg_stat_database (сколько транзакций выполнила БД);
|
||||
* p50/p95 задержки.
|
||||
Сравнение: запустить при SESSION_CACHE=valkey и при SESSION_CACHE=off (см. REPORT.md).
|
||||
Фоновый шум: healthcheck API (~1 SELECT 1 раз в 5 с).
|
||||
"""
|
||||
import argparse
|
||||
import base64
|
||||
import json
|
||||
import statistics
|
||||
import subprocess
|
||||
import time
|
||||
import urllib.request
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
p = argparse.ArgumentParser()
|
||||
p.add_argument("--base-url", default="http://localhost:8080")
|
||||
p.add_argument("--label", required=True)
|
||||
p.add_argument("--requests", type=int, default=1000)
|
||||
args = p.parse_args()
|
||||
BASE = args.base_url.rstrip("/")
|
||||
|
||||
|
||||
def api(method, path, body=None, headers=None):
|
||||
h = dict(headers or {})
|
||||
data = json.dumps(body).encode() if body is not None else None
|
||||
if data:
|
||||
h["Content-Type"] = "application/json"
|
||||
with urllib.request.urlopen(urllib.request.Request(BASE + path, data=data, headers=h, method=method),
|
||||
timeout=30) as r:
|
||||
return json.loads(r.read() or b"null")
|
||||
|
||||
|
||||
def commits():
|
||||
time.sleep(1.5) # статистика PostgreSQL публикуется с задержкой до ~1 с
|
||||
out = subprocess.run(
|
||||
["docker", "compose", "--env-file", str(ROOT / ".env"), "exec", "-T", "postgres", "psql",
|
||||
"-U", "messenger", "-d", "messenger", "-X", "-A", "-t", "-c",
|
||||
"SELECT xact_commit FROM pg_stat_database WHERE datname = 'messenger'"],
|
||||
cwd=ROOT, check=True, capture_output=True, text=True)
|
||||
return int(out.stdout.strip())
|
||||
|
||||
|
||||
name, pw = "cb_" + uuid.uuid4().hex[:10], "T3st-" + uuid.uuid4().hex
|
||||
api("POST", "/api/v1/users", {"username": name, "display_name": "Cache bench", "password": pw})
|
||||
token = api("POST", "/api/v1/auth/sessions",
|
||||
headers={"Authorization": "Basic " + base64.b64encode((name + ":" + pw).encode()).decode()})["token"]
|
||||
auth = {"Authorization": "Bearer " + token}
|
||||
for _ in range(20): # прогрев соединений
|
||||
api("GET", "/api/v1/users/me", headers=auth)
|
||||
|
||||
before = commits()
|
||||
lat = []
|
||||
for _ in range(args.requests):
|
||||
t0 = time.perf_counter()
|
||||
api("GET", "/api/v1/users/me", headers=auth)
|
||||
lat.append((time.perf_counter() - t0) * 1000)
|
||||
after = commits()
|
||||
lat.sort()
|
||||
print(json.dumps({
|
||||
"label": args.label, "requests": args.requests,
|
||||
"postgres_xact_commit_delta": after - before,
|
||||
"p50_ms": round(statistics.median(lat), 2),
|
||||
"p95_ms": round(lat[int(len(lat) * 0.95) - 1], 2),
|
||||
}, ensure_ascii=False))
|
||||
@@ -0,0 +1,156 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Обоснование индекса истории: EXPLAIN (ANALYZE, BUFFERS) на большом объёме + замер пагинации через API.
|
||||
|
||||
python3 student-tests/history_bench.py [--big 100000] [--small-chats 20] [--small-size 500]
|
||||
|
||||
1. Через API создаёт двух синтетических пользователей, большой чат и N маленьких чатов.
|
||||
2. Через psql (docker compose exec postgres) заливает сообщения: generate_series, одна транзакция.
|
||||
Неравномерно: один чат на --big сообщений, остальные по --small-size.
|
||||
3. Печатает EXPLAIN (ANALYZE, BUFFERS) ровно того SQL, который выполняет приложение:
|
||||
первая страница, «глубокая» страница по keyset-курсору, та же глубина через OFFSET;
|
||||
затем те же запросы БЕЗ индекса messages_chat_order_idx (DROP INDEX внутри BEGIN … ROLLBACK).
|
||||
4. Проходит всю историю большого чата через API (limit=100) и сравнивает задержку первых и
|
||||
последних страниц: при keyset-пагинации она не растёт с номером страницы.
|
||||
|
||||
Каждый запуск добавляет синтетические данные в учебную БД (API курса не удаляет сообщения).
|
||||
"""
|
||||
import argparse
|
||||
import base64
|
||||
import json
|
||||
import statistics
|
||||
import subprocess
|
||||
import time
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--base-url", default="http://localhost:8080")
|
||||
parser.add_argument("--big", type=int, default=100_000)
|
||||
parser.add_argument("--small-chats", type=int, default=20)
|
||||
parser.add_argument("--small-size", type=int, default=500)
|
||||
args = parser.parse_args()
|
||||
BASE = args.base_url.rstrip("/")
|
||||
|
||||
|
||||
def api(method, path, body=None, headers=None):
|
||||
h = dict(headers or {})
|
||||
data = None
|
||||
if body is not None:
|
||||
data = json.dumps(body).encode()
|
||||
h["Content-Type"] = "application/json"
|
||||
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
|
||||
with urllib.request.urlopen(req, timeout=30) as r:
|
||||
raw = r.read()
|
||||
return json.loads(raw) if raw else None
|
||||
|
||||
|
||||
def psql(sql, tuples_only=False):
|
||||
cmd = ["docker", "compose", "--env-file", str(ROOT / ".env"), "exec", "-T", "postgres",
|
||||
"psql", "-U", "messenger", "-d", "messenger", "-X", "-q", "-v", "ON_ERROR_STOP=1"]
|
||||
if tuples_only:
|
||||
cmd += ["-A", "-t"]
|
||||
out = subprocess.run(cmd, input=sql, cwd=ROOT, check=True, capture_output=True, text=True)
|
||||
return out.stdout.strip()
|
||||
|
||||
|
||||
def user(label):
|
||||
name = "bench_%s_%s" % (label, uuid.uuid4().hex[:8])
|
||||
pw = "T3st-" + uuid.uuid4().hex
|
||||
u = api("POST", "/api/v1/users", {"username": name, "display_name": "Bench " + label, "password": pw})
|
||||
cred = base64.b64encode((name + ":" + pw).encode()).decode()
|
||||
s = api("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred})
|
||||
return u, {"Authorization": "Bearer " + s["token"]}
|
||||
|
||||
|
||||
def section(title):
|
||||
print("\n" + "=" * 100 + "\n" + title + "\n" + "=" * 100)
|
||||
|
||||
|
||||
# ---------- 1. данные ----------
|
||||
a, ha = user("a")
|
||||
b, _ = user("b")
|
||||
big = api("POST", "/api/v1/chats", {"title": "Большой чат", "member_ids": [a["id"], b["id"]]}, ha)
|
||||
small = [api("POST", "/api/v1/chats", {"title": "Малый %d" % i, "member_ids": [a["id"], b["id"]]}, ha)
|
||||
for i in range(args.small_chats)]
|
||||
|
||||
section("1. Заливка данных")
|
||||
started = time.monotonic()
|
||||
values = ",".join("('%s'::uuid)" % c["id"] for c in small) # UUID получены от нашего API
|
||||
psql("""
|
||||
BEGIN;
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(), '{big}'::uuid,
|
||||
CASE WHEN n % 2 = 0 THEN '{a}'::uuid ELSE '{b}'::uuid END,
|
||||
'synthetic message #' || n || ' ' || repeat('x', (n * 7919) % 200),
|
||||
timestamptz '2026-01-01 00:00:00+00' + n * interval '1 millisecond'
|
||||
FROM generate_series(1, {big_n}) AS n;
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(), c.id, '{a}'::uuid, 'small chat message #' || n,
|
||||
timestamptz '2026-01-01 00:00:00+00' + n * interval '1 millisecond'
|
||||
FROM (VALUES {values}) AS c(id), generate_series(1, {small_n}) AS n;
|
||||
COMMIT;
|
||||
ANALYZE messages;
|
||||
""".format(big=big["id"], a=a["id"], b=b["id"], big_n=args.big, small_n=args.small_size, values=values))
|
||||
print("залито за %.1f с" % (time.monotonic() - started))
|
||||
print(psql("""SELECT count(*) AS messages_total,
|
||||
count(DISTINCT chat_id) AS chats_with_messages,
|
||||
(SELECT count(*) FROM messages WHERE chat_id = '{big}') AS in_big_chat,
|
||||
pg_size_pretty(pg_relation_size('messages')) AS table_size,
|
||||
pg_size_pretty(pg_relation_size('messages_chat_order_idx')) AS index_size
|
||||
FROM messages""".format(big=big["id"])))
|
||||
|
||||
# ---------- 2. EXPLAIN ----------
|
||||
deep_offset = int(args.big * 0.9)
|
||||
cur_ts, cur_id = psql("""SELECT created_at, id FROM messages WHERE chat_id = '{big}'
|
||||
ORDER BY created_at, id OFFSET {off} LIMIT 1""".format(
|
||||
big=big["id"], off=deep_offset - 1), tuples_only=True).split("|")
|
||||
|
||||
COLS = "SELECT id, chat_id, sender_id, text, created_at FROM messages"
|
||||
Q_FIRST = COLS + " WHERE chat_id = '{c}' ORDER BY created_at, id LIMIT 51".format(c=big["id"])
|
||||
Q_KEYSET = (COLS + " WHERE chat_id = '{c}' AND (created_at, id) > ('{t}', '{i}'::uuid)"
|
||||
" ORDER BY created_at, id LIMIT 51").format(c=big["id"], t=cur_ts, i=cur_id)
|
||||
Q_OFFSET = (COLS + " WHERE chat_id = '{c}' ORDER BY created_at, id OFFSET {o} LIMIT 51").format(
|
||||
c=big["id"], o=deep_offset)
|
||||
EXPLAIN = "EXPLAIN (ANALYZE, BUFFERS, COSTS OFF) "
|
||||
|
||||
for title, q in [
|
||||
("2a. С индексом: первая страница (как в приложении, limit=50 → LIMIT 51)", Q_FIRST),
|
||||
("2b. С индексом: страница после %d-го сообщения, keyset-курсор (как в приложении)" % deep_offset, Q_KEYSET),
|
||||
("2c. Для сравнения: та же глубина через OFFSET %d (так приложение НЕ делает)" % deep_offset, Q_OFFSET)]:
|
||||
section(title)
|
||||
print(q)
|
||||
print(psql(EXPLAIN + q))
|
||||
|
||||
section("2d. БЕЗ индекса messages_chat_order_idx (DROP INDEX внутри BEGIN … ROLLBACK, данные не меняются)")
|
||||
print(psql("BEGIN;\nDROP INDEX messages_chat_order_idx;\n"
|
||||
"\\echo '--- первая страница без индекса'\n" + EXPLAIN + Q_FIRST + ";\n"
|
||||
"\\echo '--- keyset-страница без индекса'\n" + EXPLAIN + Q_KEYSET + ";\nROLLBACK;"))
|
||||
print(psql("SELECT indexname FROM pg_indexes WHERE tablename = 'messages' ORDER BY 1"))
|
||||
|
||||
# ---------- 3. пагинация через API ----------
|
||||
section("3. Полный обход истории большого чата через API (limit=100)")
|
||||
path = "/api/v1/chats/%s/messages?limit=100" % big["id"]
|
||||
latencies, total, cursor = [], 0, None
|
||||
while True:
|
||||
url = path + ("&cursor=" + urllib.parse.quote(cursor, safe="") if cursor else "")
|
||||
t0 = time.perf_counter()
|
||||
page = api("GET", url, headers=ha)
|
||||
latencies.append((time.perf_counter() - t0) * 1000)
|
||||
total += len(page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if not cursor:
|
||||
break
|
||||
first, last = latencies[1:21], latencies[-20:] # первая страница — прогрев
|
||||
print(json.dumps({
|
||||
"pages": len(latencies), "messages_read": total, "expected": args.big,
|
||||
"first_20_pages_median_ms": round(statistics.median(first), 2),
|
||||
"last_20_pages_median_ms": round(statistics.median(last), 2),
|
||||
"all_pages_p50_ms": round(statistics.median(latencies), 2),
|
||||
"all_pages_p95_ms": round(sorted(latencies)[int(len(latencies) * 0.95) - 1], 2),
|
||||
"all_pages_max_ms": round(max(latencies), 2),
|
||||
}, ensure_ascii=False, indent=1))
|
||||
assert total == args.big, "пагинация потеряла или задублировала сообщения"
|
||||
print("PASS: все %d сообщений прочитаны без потерь и повторов" % total)
|
||||
@@ -0,0 +1,364 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Собственные проверки lab2 (только stdlib): аутентификация, границы, транзакции, сохранность.
|
||||
|
||||
python3 student-tests/test_lab2.py # граничные проверки, гонка, атомарность
|
||||
python3 student-tests/test_lab2.py --expiry-url http://localhost:8081 # + истечение (SESSION_TTL_SECONDS=2)
|
||||
python3 student-tests/test_lab2.py --db-outage # + остановка PostgreSQL -> 503, восстановление
|
||||
python3 student-tests/test_lab2.py --persistence # + перезапуск API и БД через scripts/restart.sh
|
||||
|
||||
Токены и пароли не печатаются. Флаги --db-outage/--persistence управляют docker compose.
|
||||
"""
|
||||
import argparse
|
||||
import base64
|
||||
import json
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--base-url", default="http://localhost:8080")
|
||||
parser.add_argument("--persistence", action="store_true")
|
||||
parser.add_argument("--expiry-url", default=None, help="экземпляр API с SESSION_TTL_SECONDS=2")
|
||||
parser.add_argument("--db-outage", action="store_true")
|
||||
parser.add_argument("--cache", action="store_true",
|
||||
help="проверки Valkey: отказ, FLUSHALL, зависание при logout (docker compose)")
|
||||
args = parser.parse_args()
|
||||
BASE = args.base_url.rstrip("/")
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
fails = 0
|
||||
|
||||
|
||||
def call(method, path, body=None, token=None, headers=None, raw=None, base=None):
|
||||
h = dict(headers or {})
|
||||
if token:
|
||||
h["Authorization"] = "Bearer " + token
|
||||
data = raw if raw is not None else (json.dumps(body, ensure_ascii=False).encode() if body is not None else None)
|
||||
if data is not None:
|
||||
h.setdefault("Content-Type", "application/json")
|
||||
req = urllib.request.Request((base or BASE) + path, data=data, headers=h, method=method)
|
||||
try:
|
||||
resp = urllib.request.urlopen(req, timeout=30)
|
||||
except urllib.error.HTTPError as err:
|
||||
resp = err
|
||||
with resp:
|
||||
text = resp.read()
|
||||
assert resp.headers.get("X-Request-Id"), "нет X-Request-Id"
|
||||
return resp.code, (json.loads(text) if text else None), resp.headers
|
||||
|
||||
|
||||
def expect(name, got, want):
|
||||
global fails
|
||||
ok = got == want
|
||||
fails += not ok
|
||||
short = lambda v: (str(v)[:40] + "…") if len(str(v)) > 40 else str(v)
|
||||
print("%-4s %-46s -> %s (ожидалось %s)" % ("OK" if ok else "FAIL", name, short(got), short(want)))
|
||||
|
||||
|
||||
def basic(username, password):
|
||||
return {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode()).decode()}
|
||||
|
||||
|
||||
def register(prefix, password):
|
||||
username = prefix + uuid.uuid4().hex[:8]
|
||||
code, user, _ = call("POST", "/api/v1/users", {"username": username, "display_name": "Тест", "password": password})
|
||||
assert code == 201, code
|
||||
return user
|
||||
|
||||
|
||||
def login(username, password):
|
||||
code, session, _ = call("POST", "/api/v1/auth/sessions", headers=basic(username, password))
|
||||
assert code == 201, code
|
||||
return session["token"]
|
||||
|
||||
|
||||
PW_A, PW_B = "Пароль:с:двоеточием-Ω1", "T3st-" + uuid.uuid4().hex
|
||||
a, b, e = register("a_", PW_A), register("b_", PW_B), register("e_", PW_B)
|
||||
ta, tb, te = login(a["username"], PW_A), login(b["username"], PW_B), login(e["username"], PW_B)
|
||||
|
||||
# --- регистрация ---
|
||||
users = "/api/v1/users"
|
||||
expect("регистрация без password", call("POST", users, {"username": "zz_" + uuid.uuid4().hex[:6], "display_name": "x"})[0], 400)
|
||||
expect("password 11 символов", call("POST", users, {"username": "zz_" + uuid.uuid4().hex[:6], "display_name": "x", "password": "a" * 11})[0], 400)
|
||||
expect("password 129 символов", call("POST", users, {"username": "zz_" + uuid.uuid4().hex[:6], "display_name": "x", "password": "a" * 129})[0], 400)
|
||||
expect("password не строка", call("POST", users, {"username": "zz_" + uuid.uuid4().hex[:6], "display_name": "x", "password": 123456789012})[0], 400)
|
||||
expect("дубликат username", call("POST", users, {"username": a["username"], "display_name": "x", "password": PW_B})[0], 409)
|
||||
expect("User не содержит пароль/хеш", sorted(a), ["created_at", "display_name", "id", "username"])
|
||||
expect("malformed JSON", call("POST", users, raw=b"{bad")[0], 400)
|
||||
|
||||
# --- вход ---
|
||||
sess = "/api/v1/auth/sessions"
|
||||
code, _, hdr = call("POST", sess, headers=basic(a["username"], "wrong-password-123"))
|
||||
expect("неверный пароль", code, 401)
|
||||
expect(" challenge Basic", hdr.get("WWW-Authenticate", "").startswith("Basic"), True)
|
||||
expect("неизвестный пользователь", call("POST", sess, headers=basic("no_such_user_x", PW_B))[0], 401)
|
||||
expect("вход без Authorization", call("POST", sess)[0], 401)
|
||||
expect("вход с Bearer вместо Basic", call("POST", sess, token=ta)[0], 401)
|
||||
expect("мусор вместо base64", call("POST", sess, headers={"Authorization": "Basic !!!"})[0], 401)
|
||||
expect("пароль с двоеточием и Unicode", call("GET", "/api/v1/users/me", token=ta)[1]["id"], a["id"])
|
||||
t1, t2 = login(b["username"], PW_B), login(b["username"], PW_B)
|
||||
expect("два входа дают разные токены", t1 != t2 and len(t1) >= 43, True)
|
||||
|
||||
# --- Bearer ---
|
||||
me = "/api/v1/users/me"
|
||||
code, _, hdr = call("GET", me)
|
||||
expect("без токена", code, 401)
|
||||
expect(" challenge Bearer", hdr.get("WWW-Authenticate", "").startswith("Bearer"), True)
|
||||
expect("случайный токен", call("GET", me, token="x" * 43)[0], 401)
|
||||
expect("Basic на бизнес-endpoint", call("GET", me, headers=basic(a["username"], PW_A))[0], 401)
|
||||
expect("только X-User-Id", call("GET", me, headers={"X-User-Id": a["id"]})[0], 401)
|
||||
expect("X-User-Id не меняет владельца", call("GET", me, token=ta, headers={"X-User-Id": e["id"]})[1]["id"], a["id"])
|
||||
|
||||
# --- logout ---
|
||||
expect("logout", call("DELETE", sess + "/current", token=t1)[0], 204)
|
||||
expect("отозванный токен", call("GET", me, token=t1)[0], 401)
|
||||
expect("повторный logout", call("DELETE", sess + "/current", token=t1)[0], 401)
|
||||
expect("другая сессия того же пользователя жива", call("GET", me, token=t2)[0], 200)
|
||||
|
||||
# --- чаты и сообщения ---
|
||||
chats = "/api/v1/chats"
|
||||
expect("чат: создатель не участник", call("POST", chats, {"title": "t", "member_ids": [b["id"]]}, ta)[0], 400)
|
||||
expect("чат: неизвестный участник", call("POST", chats, {"title": "t", "member_ids": [a["id"], str(uuid.uuid4())]}, ta)[0], 400)
|
||||
expect("чат: дубликат участника", call("POST", chats, {"title": "t", "member_ids": [a["id"], a["id"]]}, ta)[0], 400)
|
||||
chat = call("POST", chats, {"title": "Проверка", "member_ids": [a["id"], b["id"]]}, ta)[1]
|
||||
chat2 = call("POST", chats, {"title": "t2", "member_ids": [a["id"]]}, ta)[1]
|
||||
expect("порядок member_ids сохранён", chat["member_ids"], [a["id"], b["id"]])
|
||||
msgs = "/api/v1/chats/%s/messages" % chat["id"]
|
||||
expect("чужой чат (Ева)", call("GET", chats + "/" + chat["id"], token=te)[0], 404)
|
||||
expect("запись в чужой чат (Ева)", call("POST", msgs, {"text": "x"}, te)[0], 404)
|
||||
expect("пустое сообщение", call("POST", msgs, {"text": " "}, ta)[0], 400)
|
||||
expect("sender_id в теле", call("POST", msgs, {"text": "x", "sender_id": b["id"]}, ta)[0], 400)
|
||||
expect("4001 символ", call("POST", msgs, {"text": "я" * 4001}, ta)[0], 400)
|
||||
|
||||
errors = []
|
||||
|
||||
|
||||
def send(i):
|
||||
try:
|
||||
code, _, _ = call("POST", msgs, {"text": "m%d 👋" % i}, ta if i % 2 else tb)
|
||||
if code != 201:
|
||||
errors.append(code)
|
||||
except Exception as exc:
|
||||
errors.append(type(exc).__name__)
|
||||
|
||||
|
||||
threads = [threading.Thread(target=send, args=(i,)) for i in range(100)]
|
||||
[t.start() for t in threads]
|
||||
[t.join() for t in threads]
|
||||
|
||||
|
||||
def read_all(token, limit=7):
|
||||
seen, cursor = [], None
|
||||
while True:
|
||||
_, page, _ = call("GET", msgs + "?limit=%d" % limit + ("&cursor=" + cursor if cursor else ""), token=token)
|
||||
seen += page["items"]
|
||||
cursor = page["next_cursor"]
|
||||
if not cursor:
|
||||
return seen
|
||||
|
||||
|
||||
history = read_all(tb)
|
||||
expect("100 параллельных POST: ошибок", len(errors), 0)
|
||||
expect("100 параллельных POST: уникальных", len({m["id"] for m in history}), 100)
|
||||
expect("история отсортирована (created_at, id)",
|
||||
history == sorted(history, key=lambda m: (m["created_at"], uuid.UUID(m["id"]).int)), True)
|
||||
first = call("GET", msgs + "?limit=1", token=ta)[1]
|
||||
expect("cursor от другого чата", call("GET", "/api/v1/chats/%s/messages?cursor=%s" % (chat2["id"], first["next_cursor"]), token=ta)[0], 400)
|
||||
expect("мусорный cursor", call("GET", msgs + "?cursor=abc", token=ta)[0], 400)
|
||||
expect("limit=0", call("GET", msgs + "?limit=0", token=ta)[0], 400)
|
||||
expect("неверный UUID в пути", call("GET", chats + "/xyz", token=ta)[0], 400)
|
||||
|
||||
# --- гонка регистрации одного username ---
|
||||
race_name = "race_" + uuid.uuid4().hex[:10]
|
||||
race_codes = []
|
||||
|
||||
|
||||
def register_same():
|
||||
try:
|
||||
race_codes.append(call("POST", "/api/v1/users",
|
||||
{"username": race_name, "display_name": "Гонка", "password": PW_B})[0])
|
||||
except Exception as exc:
|
||||
race_codes.append(type(exc).__name__)
|
||||
|
||||
|
||||
threads = [threading.Thread(target=register_same) for _ in range(20)]
|
||||
[t.start() for t in threads]
|
||||
[t.join() for t in threads]
|
||||
expect("гонка 20 регистраций: ровно один 201", sorted(race_codes).count(201), 1)
|
||||
expect("гонка 20 регистраций: остальные 409", sorted(race_codes).count(409), 19)
|
||||
|
||||
# --- атомарность создания чата: ошибка не оставляет «полу-чата» ---
|
||||
def chat_ids(token):
|
||||
_, page, _ = call("GET", chats + "?limit=100", token=token)
|
||||
return [c["id"] for c in page["items"]]
|
||||
|
||||
|
||||
fresh_pw = "T3st-" + uuid.uuid4().hex
|
||||
fresh = register("f_", fresh_pw)
|
||||
tf = login(fresh["username"], fresh_pw)
|
||||
before = chat_ids(tf)
|
||||
before_b = chat_ids(tb)
|
||||
code = call("POST", chats, {"title": "откат", "member_ids": [fresh["id"], b["id"], str(uuid.uuid4())]}, tf)[0]
|
||||
expect("чат с неизвестным 3-м участником", code, 400)
|
||||
expect("после ошибки чат не появился у создателя", chat_ids(tf), before)
|
||||
expect("после ошибки чат не появился у участника b", chat_ids(tb), before_b)
|
||||
code, ok_chat, _ = call("POST", chats, {"title": "после отката", "member_ids": [fresh["id"]]}, tf)
|
||||
expect("следующее создание чата работает", (code, chat_ids(tf)), (201, before + [ok_chat["id"]]))
|
||||
|
||||
# --- истечение сессии (отдельный экземпляр API с SESSION_TTL_SECONDS=2) ---
|
||||
if args.expiry_url:
|
||||
eb = args.expiry_url.rstrip("/")
|
||||
code, s, _ = call("POST", sess, headers=basic(a["username"], PW_A), base=eb)
|
||||
expect("TTL=2: вход", code, 201)
|
||||
expect("TTL=2: сразу после входа токен работает", call("GET", me, token=s["token"], base=eb)[0], 200)
|
||||
time.sleep(3)
|
||||
code, _, hdr = call("GET", me, token=s["token"], base=eb)
|
||||
expect("TTL=2: через 3 с токен истёк", code, 401)
|
||||
expect(" challenge Bearer", hdr.get("WWW-Authenticate", "").startswith("Bearer"), True)
|
||||
expect("TTL=2: истёкший токен не работает и на основном API", call("GET", me, token=s["token"])[0], 401)
|
||||
|
||||
# --- недоступность PostgreSQL ---
|
||||
if args.db_outage:
|
||||
print("--- остановка PostgreSQL: docker compose stop postgres")
|
||||
compose = ["docker", "compose", "--env-file", str(ROOT / ".env")]
|
||||
subprocess.run(compose + ["stop", "postgres"], cwd=ROOT, check=True,
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
try:
|
||||
code, body, _ = call("GET", "/health/ready")
|
||||
expect("БД нет: /health/ready", (code, body["error"]["code"]), (503, "unavailable"))
|
||||
expect("БД нет: /health/live", call("GET", "/health/live")[0], 200)
|
||||
started = time.monotonic()
|
||||
code, body, _ = call("GET", chats, token=ta)
|
||||
expect("БД нет: список чатов с токеном -> 503, не 200", (code, body["error"]["code"]), (503, "unavailable"))
|
||||
expect("БД нет: ответ ограничен по времени (<10 с)", time.monotonic() - started < 10, True)
|
||||
# /users/me может быть отдан из кэша сессий (копия действующей сессии, отзыв без БД невозможен)
|
||||
expect("БД нет: /users/me -> 200 из кэша или 503", call("GET", me, token=ta)[0] in (200, 503), True)
|
||||
expect("БД нет: неизвестный токен не проходит", call("GET", me, token="y" * 43)[0] in (401, 503), True)
|
||||
expect("БД нет: анонимный запрос не проходит", call("GET", me)[0] in (401, 503), True)
|
||||
expect("БД нет: вход -> 503", call("POST", sess, headers=basic(a["username"], PW_A))[0], 503)
|
||||
finally:
|
||||
subprocess.run(compose + ["start", "postgres"], cwd=ROOT, check=True,
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
deadline = time.monotonic() + 60
|
||||
while call("GET", "/health/ready")[0] != 200:
|
||||
assert time.monotonic() < deadline, "БД не восстановилась"
|
||||
time.sleep(1)
|
||||
expect("БД вернулась: прежний токен работает", call("GET", me, token=ta)[1], a)
|
||||
|
||||
|
||||
# --- Valkey: роль кэша, отказ, flush, зависание при logout ---
|
||||
if args.cache:
|
||||
compose = ["docker", "compose", "--env-file", str(ROOT / ".env")]
|
||||
|
||||
def dc(*cmd):
|
||||
subprocess.run(compose + list(cmd), cwd=ROOT, check=True,
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
|
||||
def vcli(*cmd):
|
||||
"""valkey-cli внутри контейнера; пароль читается там же из секрета и не печатается."""
|
||||
out = subprocess.run(compose + ["exec", "-T", "valkey", "sh", "-c",
|
||||
'valkey-cli --no-auth-warning -a "$(sed -n "s/^requirepass //p" '
|
||||
'/run/secrets/valkey.conf)" "$@"', "_"] + list(cmd),
|
||||
cwd=ROOT, check=True, capture_output=True, text=True)
|
||||
return out.stdout.strip()
|
||||
|
||||
def stats():
|
||||
info = dict(l.split(":", 1) for l in vcli("INFO", "stats").splitlines() if ":" in l)
|
||||
return int(info["keyspace_hits"]), int(info["keyspace_misses"])
|
||||
|
||||
import hashlib
|
||||
|
||||
def cache_value(token):
|
||||
return vcli("GET", "sess:" + hashlib.sha256(token.encode()).hexdigest())
|
||||
|
||||
pw = "T3st-" + uuid.uuid4().hex
|
||||
cu = register("c_", pw)
|
||||
tc = login(cu["username"], pw)
|
||||
expect("кэш: после входа в Valkey лежит копия сессии", cu["id"] in cache_value(tc), True)
|
||||
expect("кэш: в Valkey нет самого токена/пароля", tc not in vcli("--scan", "--pattern", "*") and True, True)
|
||||
h0, m0 = stats()
|
||||
for _ in range(50):
|
||||
call("GET", me, token=tc)
|
||||
h1, m1 = stats()
|
||||
expect("кэш: 50 запросов -> 50 попаданий в Valkey", (h1 - h0, m1 - m0), (50, 0))
|
||||
|
||||
# logout мгновенно виден через кэш
|
||||
t2 = login(cu["username"], pw)
|
||||
call("GET", me, token=t2)
|
||||
expect("кэш: logout", call("DELETE", sess + "/current", token=t2)[0], 204)
|
||||
expect("кэш: в Valkey tombstone вместо копии", cache_value(t2), "revoked")
|
||||
expect("кэш: отозванный токен сразу 401", call("GET", me, token=t2)[0], 401)
|
||||
|
||||
# FLUSHALL: кэш пуст, сессии читаются из PostgreSQL
|
||||
vcli("FLUSHALL")
|
||||
expect("FLUSHALL: действующий токен работает (из БД)", call("GET", me, token=tc)[1], cu)
|
||||
expect("FLUSHALL: отозванный токен по-прежнему 401", call("GET", me, token=t2)[0], 401)
|
||||
expect("FLUSHALL: кэш снова заполнен после промаха", cu["id"] in cache_value(tc), True)
|
||||
|
||||
# Valkey остановлен: API работает через PostgreSQL
|
||||
print("--- остановка Valkey: docker compose stop valkey")
|
||||
dc("stop", "valkey")
|
||||
try:
|
||||
expect("Valkey нет: /health/ready 200 (не критичен)", call("GET", "/health/ready")[0], 200)
|
||||
started = time.monotonic()
|
||||
expect("Valkey нет: токен работает через БД", call("GET", me, token=tc)[1], cu)
|
||||
expect("Valkey нет: ответ быстрый (<2 с)", time.monotonic() - started < 2, True)
|
||||
expect("Valkey нет: список чатов", call("GET", chats, token=tc)[0], 200)
|
||||
expect("Valkey нет: без токена 401", call("GET", me)[0], 401)
|
||||
expect("Valkey нет: чужой токен 401", call("GET", me, token="z" * 43)[0], 401)
|
||||
expect("Valkey нет: отозванный токен 401", call("GET", me, token=t2)[0], 401)
|
||||
t3 = login(cu["username"], pw)
|
||||
expect("Valkey нет: вход 201", bool(t3), True)
|
||||
expect("Valkey нет: logout 204", call("DELETE", sess + "/current", token=t3)[0], 204)
|
||||
expect("Valkey нет: после logout 401", call("GET", me, token=t3)[0], 401)
|
||||
finally:
|
||||
dc("start", "valkey")
|
||||
deadline = time.monotonic() + 30
|
||||
while "PONG" not in vcli("PING"):
|
||||
assert time.monotonic() < deadline, "Valkey не поднялся"
|
||||
time.sleep(0.5)
|
||||
time.sleep(6) # дольше CACHE_RETRY_SECONDS: приложение снова опрашивает кэш
|
||||
expect("Valkey вернулся: токен работает", call("GET", me, token=tc)[1], cu)
|
||||
expect("Valkey вернулся: кэш снова заполняется", cu["id"] in cache_value(tc), True)
|
||||
expect("Valkey вернулся: токен, отозванный при отказе, 401", call("GET", me, token=t3)[0], 401)
|
||||
|
||||
# Самый опасный случай: Valkey «завис» (pause) во время logout -> tombstone не записан,
|
||||
# в Valkey осталась положительная копия сессии. Она не должна «воскресить» токен.
|
||||
t4 = login(cu["username"], pw)
|
||||
call("GET", me, token=t4)
|
||||
print("--- зависание Valkey во время logout: docker compose pause valkey")
|
||||
dc("pause", "valkey")
|
||||
try:
|
||||
expect("Valkey завис: logout всё равно 204 (отзыв в БД)", call("DELETE", sess + "/current", token=t4)[0], 204)
|
||||
finally:
|
||||
dc("unpause", "valkey")
|
||||
expect("Valkey ожил: в нём осталась устаревшая копия", cu["id"] in cache_value(t4), True)
|
||||
time.sleep(6) # breaker закрыт, кэш снова опрашивается
|
||||
expect("Valkey ожил: устаревшая копия не принята, 401", call("GET", me, token=t4)[0], 401)
|
||||
expect("Valkey ожил: действующий токен работает", call("GET", me, token=tc)[1], cu)
|
||||
|
||||
|
||||
if args.persistence:
|
||||
print("--- перезапуск API и PostgreSQL: scripts/restart.sh")
|
||||
subprocess.run([str(ROOT / "scripts" / "restart.sh")], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
deadline = time.monotonic() + 90
|
||||
while True:
|
||||
try:
|
||||
if call("GET", "/health/ready")[0] == 200:
|
||||
break
|
||||
except Exception:
|
||||
pass
|
||||
assert time.monotonic() < deadline, "сервер не поднялся"
|
||||
time.sleep(1)
|
||||
expect("после рестарта: прежний токен работает", call("GET", me, token=ta)[1], a)
|
||||
expect("после рестарта: чат на месте", call("GET", chats + "/" + chat["id"], token=tb)[1], chat)
|
||||
expect("после рестарта: история та же", read_all(tb), history)
|
||||
expect("после рестарта: отозванный токен всё ещё отозван", call("GET", me, token=t1)[0], 401)
|
||||
expect("после рестарта: вход по паролю работает", call("POST", sess, headers=basic(a["username"], PW_A))[0], 201)
|
||||
|
||||
print("ИТОГО:", "ВСЕ ПРОВЕРКИ ПРОШЛИ" if not fails else "%d ПРОВАЛОВ" % fails)
|
||||
sys.exit(1 if fails else 0)
|
||||
Reference in New Issue
Block a user