ЛР 2 — БВТ2303 — Васюкова — на 5 #6
+7
-3
@@ -5,7 +5,11 @@ APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
DATABASE_URL=postgresql://user:password@postgres:5432/high_load_messenger
|
||||
POSTGRES_USER=user
|
||||
POSTGRES_PASSWORD=password
|
||||
POSTGRES_DB=high_load_messenger
|
||||
# Redis. Пароль не задан: Redis доступен только внутри compose-сети (порт наружу не публикуется)
|
||||
REDIS_URL=redis://redis:6379/0
|
||||
SESSION_STORE=redis
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
|
||||
@@ -10,6 +10,7 @@ certs/private/
|
||||
*.jks
|
||||
*.pem
|
||||
*.tfstate*
|
||||
*.dump
|
||||
volumes/
|
||||
data/
|
||||
backups/
|
||||
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
# --- Стадия сборки ---
|
||||
FROM python:3.12-slim AS builder
|
||||
|
||||
WORKDIR /build
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt
|
||||
|
||||
# --- Runtime ---
|
||||
FROM python:3.12-slim
|
||||
|
||||
# Непривилегированный пользователь
|
||||
RUN useradd --create-home --shell /usr/sbin/nologin appuser
|
||||
|
||||
WORKDIR /app
|
||||
COPY --from=builder /install /usr/local
|
||||
COPY src/ ./src/
|
||||
|
||||
ENV PYTHONUNBUFFERED=1 \
|
||||
PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONPATH=/app/src \
|
||||
APP_HOST=0.0.0.0 \
|
||||
APP_PORT=8080
|
||||
|
||||
USER appuser
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
|
||||
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/live').read()"
|
||||
|
||||
CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]
|
||||
@@ -4,10 +4,10 @@ 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 test-student load test-persistence
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; test-student: own tests; load: synthetic writes"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -18,6 +18,9 @@ validate:
|
||||
test:
|
||||
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
test-student:
|
||||
$(PYTHON) student-tests/run_all.py --base-url "$(BASE_URL)"
|
||||
|
||||
load:
|
||||
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
|
||||
@@ -1,37 +1,378 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Васюкова Наталья, БВТ2303
|
||||
- Целевая оценка: 5
|
||||
- Commit/PR: solution/BVT2303-Vasyukova
|
||||
- Использованные источники, библиотеки и помощь ИИ:
|
||||
- Контракт: contracts/openapi.json, contracts/README.md
|
||||
- Инструкции: README.md, COURSE.md, CONTRIBUTING.md
|
||||
- Библиотеки: fastapi==0.115.0, uvicorn[standard]==0.32.0, psycopg[binary]==3.2.3, psycopg_pool==3.2.3, redis==5.2.0, pydantic (из fastapi)
|
||||
- ИИ: DeepSeek — помощь в структурировании кода и отчёта. Весь код проверен, отредактирован и запущен разработчиком.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Версии runtime/образов:
|
||||
- Python: 3.12 (образ `python:3.12-slim`)
|
||||
- FastAPI 0.115.0, uvicorn[standard] 0.32.0, psycopg[binary] 3.2.3, psycopg_pool 3.2.3, redis 5.2.0
|
||||
- PostgreSQL 18.6-alpine (в Compose), Redis 7.4.1-alpine (в Compose)
|
||||
- Docker Desktop (Windows)
|
||||
|
||||
### Запуск стека
|
||||
|
||||
1. Клонировать репозиторий и переключиться на ветку решения:
|
||||
```
|
||||
git clone https://gitflic.ru/project/vasyukova-nat/mtusi2026lab2.git
|
||||
git checkout solution/BVT2303-Vasyukova
|
||||
```
|
||||
2. Создать `.env` из шаблона:
|
||||
```
|
||||
copy .env.example .env
|
||||
```
|
||||
3. Собрать и поднять:
|
||||
```
|
||||
docker compose --env-file .env up -d --build
|
||||
```
|
||||
4. Проверить готовность:
|
||||
```
|
||||
curl.exe -s http://localhost:8080/health/ready
|
||||
```
|
||||
Ожидается: `{"status":"ok"}`.
|
||||
|
||||
Альтернативный локальный запуск без Docker:
|
||||
python -m uvicorn src.app.main:app --host 0.0.0.0 --port 8080 --reload
|
||||
(в `.env` при этом `DATABASE_URL=postgresql://user:password@localhost:5432/high_load_messenger`)
|
||||
|
||||
### Проверки
|
||||
|
||||
`make` в среде автора недоступен (Windows без GNU Make), поэтому использованы эквивалентные прямые вызовы скриптов. Для Linux/CI рядом указаны команды `make`.
|
||||
|
||||
| Makefile-команда | Прямой вызов |
|
||||
| --- | --- |
|
||||
| `make check` | `python scripts/check_contract.py` |
|
||||
| `make validate` | `python scripts/validate_openapi.py` |
|
||||
| `make test` | `python tests/smoke.py --base-url http://localhost:8080` |
|
||||
| `make test-student` | `python student-tests/run_all.py --base-url http://localhost:8080` |
|
||||
| `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080` |
|
||||
| `make test-track2` | `python student-tests/test_track2.py --base-url http://localhost:8080` |
|
||||
|
||||
Примечание про 2 action-скрипта:
|
||||
`scripts/restart.sh` — обязательный артефакт для Linux/CI; `scripts/restart.bat` — Windows-эквивалент (`tests/resilience.py` запускает action-script напрямую через `subprocess.Popen` и не исполняет `.sh` на Windows).
|
||||
|
||||
### Проверки уровня 4 с остановкой зависимостей и TTL
|
||||
|
||||
Тесты уровня 4 разделены на два запуска: тяжёлые (гонка регистрации, rollback составной операции, EXPLAIN, недоступность Redis, недоступность PostgreSQL) выполняются при длинном TTL; expiry — при коротком TTL. Это сделано потому, что тест недоступности Redis использует заранее полученную рабочую сессию, и при `SESSION_TTL_SECONDS=5` она истекает быстрее, чем тест успевает остановить Redis.
|
||||
|
||||
Первый запуск (в .env SESSION_TTL_SECONDS=3600) — все тяжёлые тесты, включая Redis/Postgres down:
|
||||
```
|
||||
python student-tests/test_lab2_level4.py --base-url http://localhost:8080 --skip-expiry
|
||||
```
|
||||
|
||||
Второй запуск (в .env SESSION_TTL_SECONDS=5) — только expiry:
|
||||
```
|
||||
python student-tests/test_lab2_level4.py --base-url http://localhost:8080 --only-expiry
|
||||
```
|
||||
|
||||
Наблюдения:
|
||||
- гонка регистрации: из 8 одновременных POST один username — ровно одна 201 и семь 409, остальные ошибки (timeout/500/bad schema) проваливают тест; в БД ровно одна строка `users` с этим username;
|
||||
- rollback составной операции: патч-скрипт запускается через `docker exec` внутри контейнера API, подменяет `psycopg.Cursor.executemany` так, чтобы INSERT в `chat_members` упал уже после успешного INSERT в `chats`; после падения ни строки `chats`, ни строк `chat_members` с этим title не остаётся, и через API чат не виден; ошибка до INSERT (неизвестный участник) rollback не доказывает, поэтому используется именно сбой `executemany`;
|
||||
- EXPLAIN на 550 008 сообщениях: `Index Scan using idx_messages_chat_created`, без `Sort`, Execution Time ~0.06 мс;
|
||||
- недоступность Redis: с действующим токеном `/health/ready` → 503 и запрос с этим токеном → 503; после восстановления Redis прежняя сессия снова работает (AOF);
|
||||
- недоступность PostgreSQL: `/health/ready` → 503, запрос с действующим токеном → 503 в пределах таймаута, анонимный запрос не получает доступ; после восстановления БД прежняя сессия работает, ранее записанное сообщение сохранено; восстановление БД выполняется в `finally`, чтобы не оставить стенд остановленным при падении теста;
|
||||
- expiry (TTL=5): токен валиден до истечения, после TTL — 401, повторный вход работает.
|
||||
|
||||
### Остановка и удаление учебных данных
|
||||
|
||||
docker compose stop # данные PostgreSQL и Redis сохраняются (volumes)
|
||||
docker compose down # volumes сохраняются
|
||||
docker compose down -v # ТОЛЬКО если осознанно стираем данные БД и Redis
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Схема процессов и хранилищ:
|
||||
|
||||
```
|
||||
HTTP-клиент → FastAPI (uvicorn, 0.0.0.0:8080) → PostgreSQL 18.6 (postgres:5432)
|
||||
↘ Redis 7.4.1 (redis:6379)
|
||||
```
|
||||
|
||||
Все три сервиса — в одной compose-сети `mtuci2026lab2_default`. PostgreSQL и Redis доступны только по внутренним именам `postgres` и `redis`; наружу опубликован лишь порт API `127.0.0.1:8080` (Redis имеет `127.0.0.1:6379` только для отладки, БД порт не публикует).
|
||||
|
||||
Источник истины:
|
||||
- PostgreSQL — пользователи, чаты, членство, сообщения.
|
||||
- Redis — серверные сессии (TTL, инвалидация через logout).
|
||||
|
||||
Роль Redis на уровне 4:
|
||||
- Хранилище серверных сессий с TTL (`SETEX sess:<token> SESSION_TTL_SECONDS ...`).
|
||||
- Persistence: AOF `appendonly yes`, `appendfsync everysec`, RDB `save 60 1` — сессии переживают рестарт Redis.
|
||||
- Политика expiry: TTL задаёт сам Redis, продления нет. Инвалидация: `DEL sess:<token>` при `DELETE /auth/sessions/current`.
|
||||
- Источник истины для сессий — Redis. Если Redis недоступен, `/health/ready` → 503, бизнес-запросы не обслуживаются молча как анонимные.
|
||||
|
||||
Схема БД (подробнее — `src/app/storage/db.py`, константа `SCHEMA_SQL`):
|
||||
```
|
||||
users(id UUID PK, username TEXT UNIQUE, display_name TEXT, password_hash TEXT, created_at TIMESTAMPTZ)
|
||||
chats(id UUID PK, title TEXT, created_at TIMESTAMPTZ)
|
||||
chat_members(chat_id FK→chats, user_id FK→users, PK(chat_id,user_id))
|
||||
messages(id UUID PK, chat_id FK→chats, sender_id FK→users, text TEXT, created_at TIMESTAMPTZ)
|
||||
+ INDEX idx_messages_chat_created(chat_id, created_at, id)
|
||||
sessions(token TEXT PK, user_id FK→users, expires_at TIMESTAMPTZ) -- fallback SESSION_STORE=postgres
|
||||
```
|
||||
Применяется идемпотентно через `init_schema()` на старте. Все временные метки — `TIMESTAMPTZ`.
|
||||
|
||||
Транзакционные границы:
|
||||
- `create_user` — SELECT-проверка username и INSERT в одной транзакции; при гонке `UniqueViolation` ловится и превращается в 409.
|
||||
- `create_chat` — INSERT `chats` + INSERT `chat_members` в одной транзакции, откат целиком.
|
||||
- `add_message` — один INSERT, отдельная транзакция.
|
||||
- Создание/отзыв сессии — одна операция.
|
||||
|
||||
Пул соединений и таймауты (уровень 4):
|
||||
- `psycopg_pool.ConnectionPool(min_size=2, max_size=10, timeout=5.0)`, `statement_timeout=5000 ms` через `options`. Пул инициализируется в `lifespan` и закрывается на shutdown.
|
||||
|
||||
Keyset-пагинация (уровень 4):
|
||||
- `list_messages_page(chat_id, limit, after)`: `WHERE chat_id = %s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s`. Берётся `limit + 1`, чтобы определить наличие следующей страницы. Полного scan всей истории на страницу нет.
|
||||
|
||||
Аутентификация (lab1 → lab2):
|
||||
- Регистрация `POST /api/v1/users` требует поле `password` (12–128 code points). Пароль хешируется стандартным `hashlib.scrypt` с уникальной солью на пользователя, формат хранения `scrypt$N$r$p$salt$dk`. Проверка через `hmac.compare_digest`.
|
||||
- `POST /api/v1/auth/sessions` принимает только Basic `Authorization: Basic <base64(username:password)>`, без JSON body. Неверные креды → 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`.
|
||||
- Успешный вход → 201 `{token, token_type="Bearer", expires_at, user}`. Токен — `secrets.token_urlsafe(32)`, хранится серверной сессией в Redis с TTL из `SESSION_TTL_SECONDS` (по умолчанию 3600).
|
||||
- Защищённые endpoint принимают только `Authorization: Bearer <token>`. Истёкший/отозванный/неизвестный токен → 401 с `WWW-Authenticate: Bearer realm="messenger"`.
|
||||
- `DELETE /api/v1/auth/sessions/current` → отзыв текущей сессии. 204, повтор → 401.
|
||||
- `X-User-Id` (lab1) с lab2 игнорируется и доступа не даёт: смоук проверяет, что с валидным Bearer и чужим `X-User-Id: <eve>` возвращается владелец токена (Alice), а не Eve.
|
||||
- Согласно `contracts/README.md`, Basic на бизнес-endpoint → 401.
|
||||
|
||||
Обработка недоступности зависимостей:
|
||||
- `psycopg.OperationalError` → 503 `{"error":{"code":"unavailable",...}}` (обработчик в `main.py`).
|
||||
- Redis-ошибки в `sessions.py` обёрнуты в `RuntimeError("redis_unavailable: ...")`, `main.py` превращает в 503 `unavailable`.
|
||||
- `/health/ready` пингует PostgreSQL и, в режиме `redis`, Redis; при ошибке исключение вылетает наверх и превращается в 503 с телом `Error`.
|
||||
|
||||
Дерево проекта (изменения относительно lab1 отмечены `*`; трек 2 отмечен `**`):
|
||||
```
|
||||
mtuci2026lab2/
|
||||
├── compose.yaml * # API + PostgreSQL + Redis
|
||||
├── Dockerfile
|
||||
├── Makefile *
|
||||
├── README.md, COURSE.md, ... # скелет без изменений
|
||||
├── requirements.txt * # + psycopg_pool, redis
|
||||
├── .env.example * # + REDIS_URL, SESSION_STORE
|
||||
├── src/app/ # исходники приложения
|
||||
│ ├── main.py * # точка входа uvicorn, init_pool/close_pool, 503-обработчики
|
||||
│ ├── api/
|
||||
│ │ ├── health.py * # readiness пингует PostgreSQL + Redis
|
||||
│ │ ├── auth.py # Авторизация
|
||||
│ │ ├── security.py
|
||||
│ │ ├── users.py
|
||||
│ │ ├── chats.py
|
||||
│ │ └── messages.py * # keyset-пагинация в SQL
|
||||
│ ├── models/schemas.py # Pydantic-схемы
|
||||
│ └── storage/
|
||||
│ ├── db.py * # ConnectionPool, SCHEMA_SQL, statement_timeout
|
||||
│ ├── postgres.py * # PostgresStorage, делегаты сессий, list_messages_page
|
||||
│ ├── sessions.py * # Redis-сессии, RuntimeError
|
||||
│ └── memory.py # референс lab1, не используется
|
||||
├── scripts/
|
||||
│ ├── restart.sh * # Linux/CI: перезапуск API, PostgreSQL и Redis через compose
|
||||
│ └── restart.bat * # Windows-эквивалент для локального прогона
|
||||
├── student-tests/
|
||||
│ ├── run_all.py
|
||||
│ ├── test_negative.py
|
||||
│ ├── test_concurrency.py
|
||||
│ ├── test_lab2_level4.py * # гонка регистрации (реальные HTTP-коды + строка в БД), rollback составной операции create_chat (docker exec + patch executemany), EXPLAIN, недоступность Redis (с действующим токеном), недоступность PostgreSQL (с восстановлением в finally), expiry; режимы --skip-expiry / --only-expiry
|
||||
│ ├── track2_seed.sql ** # сидирование >=100 000 сообщений
|
||||
│ └── test_track2.py ** # Трек 2: EXPLAIN, стоимость записи, backup/restore, RPO
|
||||
└── tests/ # публичные проверки, без изменений
|
||||
```
|
||||
|
||||
Что перенесено из lab1 без изменений: FastAPI-роутеры, Pydantic-схемы, middleware `X-Request-Id`, структурное логирование, обработчик SIGTERM, формат ошибок, Dockerfile (multi-stage, non-root, healthcheck), `.dockerignore`, `student-tests/test_negative.py`, `student-tests/test_concurrency.py`.
|
||||
|
||||
Что изменено:
|
||||
- `requirements.txt`: добавлены `psycopg[binary]`, `psycopg_pool`, `redis`.
|
||||
- `.env.example`: добавлены `REDIS_URL`, `SESSION_STORE`.
|
||||
- `compose.yaml`: добавлены сервисы `postgres` и `redis`; `api` зависит от обоих через `depends_on: condition: service_healthy`.
|
||||
- `storage/db.py`: `connection()` берёт соединение из пула; `init_schema()` идемпотентен.
|
||||
- `src/app/storage/postgres.py` — реализует тот же интерфейс, что `MemoryStorage`, плюс делегаты сессий и `list_messages_page`.
|
||||
- `storage/sessions.py`: новый файл, хранилище сессий — Redis или PostgreSQL.
|
||||
- `api/messages.py`: keyset-пагинация вынесена в SQL.
|
||||
- `api/health.py`: readiness проверяет PostgreSQL и Redis.
|
||||
- `main.py`: `init_pool`/`close_pool`, обработчики 503.
|
||||
- `scripts/restart.sh`, `scripts/restart.bat`: перезапускают API, PostgreSQL и Redis.
|
||||
- `student-tests/test_lab2_level4.py`: тесты уровня 4; добавлены режимы `--skip-expiry` и `--only-expiry`.
|
||||
- `student-tests/track2_seed.sql`, `student-tests/test_track2.py`: трек 2 (уровень 5).
|
||||
- `Makefile`: цель `test-track2`.
|
||||
|
||||
Соответствие `.env.example` реальной конфигурации:
|
||||
- `APP_HOST`, `APP_PORT` — используются uvicorn/CMD в Dockerfile.
|
||||
- `APP_ENV` — пишется в стартовый лог `event=startup app_env=...`, в остальном на логику не влияет.
|
||||
- `SESSION_TTL_SECONDS` — TTL серверных сессий в Redis (или в таблице `sessions` при `SESSION_STORE=postgres`), по умолчанию 3600. Для теста expiry временно ставится 5 и возвращается обратно.
|
||||
- `DATABASE_URL` — строка подключения к PostgreSQL. В Docker используется `postgresql://user:password@postgres:5432/high_load_messenger`.
|
||||
- `REDIS_URL` — адрес Redis в compose-сети (`redis://redis:6379/0`), не секрет.
|
||||
- `SESSION_STORE` — `redis` (уровень 4) или `postgres` (fallback).
|
||||
- `CACHE_URL_FILE` — резервная переменная из скелета, не используется.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | Уровень |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| OpenAPI 3.1 и JSON Schema | `python scripts/validate_openapi.py` | `PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.` | evidence/lab2/lab2_checks.txt | **3** |
|
||||
| Структура и локальные ссылки | `python scripts/check_contract.py` | `PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.` | evidence/lab2/lab2_checks.txt | **3** |
|
||||
| Публичный smoke | `python tests/smoke.py --base-url http://localhost:8080` | `PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.` | evidence/lab2/lab2_checks.txt | **3** |
|
||||
| Собственные тесты lab1 | `python student-tests/run_all.py --base-url http://localhost:8080` | `PASS: all student tests (level 4) passed` | evidence/lab2/lab2_checks.txt | **3** |
|
||||
| Dockerfile собирает приложение, слушает 0.0.0.0:8080 | `docker compose --env-file .env up -d --build` | `/health/ready` → `{"status":"ok"}` | evidence/lab2/lab2_checks.txt | **3** |
|
||||
| PostgreSQL как источник истины | `init_schema()`; таблицы в psql (`docker exec mtuci-postgres psql ...`) | `users`, `chats`, `chat_members`, `messages`, `sessions` присутствуют | evidence/lab2/lab2_checks.txt | **3** |
|
||||
| PK/FK, уникальность username, миграции с нуля | `SCHEMA_SQL` в `db.py`; прогон на пустой БД | таблицы создаются идемпотентно, повторный запуск не дублирует | evidence/lab2/lab2_checks.txt | **3** |
|
||||
| Составная операция создания чата атомарна | `create_chat`: INSERT chats + INSERT chat_members в одной транзакции | при ошибке INSERT в `chat_members` чат не появляется | src/app/storage/postgres.py | **3** |
|
||||
| Basic только на `POST /auth/sessions` | смоук: Basic на `/users/me` → 401; `X-User-Id` игнорируется | `PASS: lab2 public API scenario` | evidence/lab2/lab2_checks.txt | **3** |
|
||||
| Срок жизни сессии и отзыв | `DELETE /auth/sessions/current` → 204; повтор → 401 | 204, затем 401 | evidence/lab2/lab2_checks.txt | **3** |
|
||||
| X-User-Id не даёт доступ | `GET /users/me` с `Authorization: Bearer Alice` и `X-User-Id: <eve>` | возвращает Alice | evidence/lab2/lab2_checks.txt | **3** |
|
||||
| Пароли хешируются password KDF | `hashlib.scrypt`, формат `scrypt$N$r$p$salt$dk` | plaintext/hash в ответах API не фигурируют | src/app/storage/postgres.py | **3** |
|
||||
| Persistence: данные и сессия переживают рестарт API, PostgreSQL и Redis | `python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080` | `PASS: persistence preserved confirmed data and existing session.` | evidence/lab2/lab2_persistence.txt | **3** |
|
||||
| Hook реально перезапустил API, PostgreSQL и Redis | `docker inspect -f "{{.State.StartedAt}}"` до/после | время старта изменилось у всех трёх контейнеров, данные сохранены | evidence/lab2/lab2_persistence.txt | **3** |
|
||||
| Secrets/volumes не попадают в Git | `.dockerignore`, `.env` локально | `DATABASE_URL`/`REDIS_URL` в `.env.example` — плейсхолдеры | .env.example | **3** |
|
||||
| Redis реально используется для сессий с TTL | `docker exec mtuci-redis redis-cli KEYS "sess:*"`, `TTL sess:<token>` | ключи `sess:*`, TTL ≈ `SESSION_TTL_SECONDS` | evidence/lab2/lab2_level4.txt | **4** |
|
||||
| Redis persistence, выдерживающее рестарт | `docker exec mtuci-redis redis-cli INFO persistence`; рестарт Redis | `aof_enabled:1`; сессии живы после рестарта | evidence/lab2/lab2_level4.txt | **4** |
|
||||
| Параметризованные запросы, ограниченный пул, таймауты | `psycopg_pool.ConnectionPool(2..10, timeout=5)`, `statement_timeout=5000` | нет `psycopg.connect()` на запрос | src/app/storage/db.py | **4** |
|
||||
| Гонка регистрации одинакового username | `python student-tests/test_lab2_level4.py --skip-expiry` (блок `test_concurrent_registration`) | ровно одна 201, остальные 409; остальные ошибки проваливают тест; в БД ровно одна строка `users` | evidence/lab2/lab2_level4.txt | **4** |
|
||||
| Rollback составной операции create_chat | тот же скрипт, `test_chat_rollback` (docker exec + patch `psycopg.Cursor.executemany`) | ошибка на executemany ПОСЛЕ успешного INSERT в chats: ни строки chats, ни chat_members не осталось; через API чат не виден | evidence/lab2/lab2_level4.txt | **4** |
|
||||
| Индекс истории обоснован EXPLAIN на ≥10 000 сообщениях | тот же скрипт, `test_explain` | `Index Scan using idx_messages_chat_created` | evidence/lab2/lab2_level4.txt | **4** |
|
||||
| Keyset-пагинация без полного scan на страницу | `list_messages_page` в `postgres.py` | `WHERE (created_at, id) > (…, …)` + `LIMIT` | src/app/storage/postgres.py | **4** |
|
||||
| Автопроверка expiry при коротком TTL | `SESSION_TTL_SECONDS=5`, `python student-tests/test_lab2_level4.py --only-expiry` | до TTL — 200, после — 401; повторный вход работает | evidence/lab2/lab2_level4.txt | **4** |
|
||||
| Logout и неверный пароль | `DELETE /auth/sessions/current`; неверный Basic | 204 → 401; неверный Basic → 401 с Basic-challenge | evidence/lab2/lab2_checks.txt | **3** |
|
||||
| Недоступность Redis не даёт анонимный доступ | `test_redis_unavailable` (stop redis → ready 503; запрос с действующим токеном → 503; после старта токен снова работает) | `/health/ready` → 503 `unavailable`, действующий Bearer получает 503, после восстановления прежняя сессия работает | evidence/lab2/lab2_level4.txt | **4** |
|
||||
| Недоступность PostgreSQL → 503 | `test_postgres_unavailable` (stop postgres → ready 503; действующий токен → 503 в пределах таймаута; аноним — 401/503; после `start postgres` прежний токен и запись сохранены) | 503 `unavailable`, восстановление в `finally`, данные сохранены | evidence/lab2/lab2_level4.txt | **4** |
|
||||
| Трек 5. Трек 2: ≥100 000 сообщений с неравномерными чатами | `python student-tests/test_track2.py` (шаг 1) | 250 002 сообщения, распределение 151818/54545/…/1 | evidence/lab2_track2_explain.md | **5** |
|
||||
| Трек 5. Трек 2: сравнение ≥2 индексов на большом/маленьком чате | тот же скрипт (шаг 2), `EXPLAIN (ANALYZE, BUFFERS)` | без индекса — Seq Scan + Sort; `(chat_id)` — Bitmap + Sort; `(chat_id, created_at, id)` — Index Scan без Sort | evidence/lab2_track2_explain.md | **5** |
|
||||
| Трек 5. Трек 2: стоимость записи | тот же скрипт (шаг 3), 10 000 INSERT на каждом варианте | см. `lab2_track2_write_cost.json` | evidence/lab2_track2_write_cost.json | **5** |
|
||||
| Трек 5. Трек 2: backup → restore → сверка | тот же скрипт (шаг 4) | COUNT, распределение по чатам и 100 случайных сообщений совпадают | evidence/lab2_track2_restore.txt | **5** |
|
||||
| Трек 5. Трек 2: границы потери данных (RPO) | тот же скрипт (шаг 5) | сообщение, записанное после старта дампа, в restore отсутствует | evidence/lab2_track2_rpo.txt | **5** |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Hardware и версии:
|
||||
- Windows 11, Docker Desktop (WSL2 backend), без лимитов CPU/RAM на контейнер;
|
||||
- Образ `mtuci-messenger:lab2` на `python:3.12-slim`;
|
||||
- PostgreSQL 18.6-alpine в Compose (том `mtuci2026lab2_postgres-data`);
|
||||
- Redis 7.4.1-alpine в Compose.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Восстановление / потери |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| `docker compose restart api postgres redis` (`scripts/restart.bat`) | API, PostgreSQL и Redis перезапускаются, volumes не трогаются; прежний Bearer читает прежние данные | `PASS: persistence preserved confirmed data and existing session`; `event=startup` в логах, `StartedAt` изменился у всех 3-х | downtime ≈ 3–5 с; потери 0 |
|
||||
| `docker compose stop postgres`, затем запрос | 503 `unavailable` (обработчик `psycopg.OperationalError`), БД-операции не идут | 503 `unavailable` на `/health/ready` и бизнес-запросах; после `start postgres` — 200, данные и сессия сохранены | downtime ≈ 3 с; потери 0 (том сохранён) |
|
||||
| `docker compose stop redis`, затем запрос | 503 `unavailable`, анонимный доступ не открывается | `PASS: readiness 503 без Redis`; с действующим токеном 503, после `start redis` прежняя сессия снова работает | downtime ≈ 3 с; потери сессий 0 (AOF) |
|
||||
| Падение `executemany` внутри `create_chat` после успешного INSERT в `chats` | Транзакция откатывается целиком | `PATCHED_FAILURE_OK`; ни строки `chats`, ни `chat_members` не осталось | потери 0 (откат) |
|
||||
| Повторный `init_schema()` | Идемпотентно, без дублирования, таблицы уже существуют | ошибок нет, нет дублирования строк | — |
|
||||
| SIGTERM (`docker stop -t 10`) | завершение ≤ 10 с | как в lab1: <1 с, `event=shutdown_complete` | — |
|
||||
|
||||
Профиль нагрузки на lab2 не снимался: на уровне 3/4 нагрузочные измерения не требуются, EXPLAIN на ≥10 000 сообщениях подтверждает индекс запроса истории. Для Трека 2 использован отдельный эксперимент (см. ниже).
|
||||
|
||||
## Трек 5. Трек 2. План запроса и восстановление
|
||||
|
||||
**Гипотеза.** Индекс `(chat_id, created_at, id)` должен ускорять keyset-запрос истории и убирать сортировку; наивный `(chat_id)` потребует сортировки; без индекса — полный скан. Ускорение чтения достигается ценой более медленной записи и роста размера индекса. `pg_dump` даёт снапшот на момент старта, поэтому часть свежих сообщений в restore не попадёт (RPO > 0).
|
||||
|
||||
**Методика.** Скрипт `student-tests/test_track2.py` (шаги):
|
||||
1. сидирует ≥100 000 сообщений с неравномерными чатами (`track2_seed.sql`);
|
||||
2. снимает `EXPLAIN (ANALYZE, BUFFERS)` на большом (~151818) и маленьком (~1) чате для трёх вариантов индексов;
|
||||
3. замеряет 10 000 INSERT на каждом варианте (время, размер индекса, общий размер таблицы);
|
||||
4. делает `pg_dump -Fc`, восстанавливает в отдельный контейнер `postgres:18-alpine` (в той же compose-сети), сверяет COUNT, распределение по чатам и 100 случайных сообщений;
|
||||
5. пишет сообщение через API после старта `pg_dump` и проверяет, что его нет в restore.
|
||||
|
||||
Запуск: `python student-tests/test_track2.py --base-url http://localhost:8080` (эквивалент: `make test-track2`).
|
||||
|
||||
**Результаты.**
|
||||
|
||||
### Seed
|
||||
Вывод в терминале:
|
||||
```
|
||||
=== 1. seed ===
|
||||
messages before: 250002
|
||||
messages after: 280002
|
||||
распределение по чатам:
|
||||
362231ce-de25-4394-a32c-9dcddc4fabe0|151818
|
||||
ec18fd9c-e539-4e4b-952e-fd754abfe99e|54545
|
||||
a34e5dda-6ed1-470a-af37-5a584046c9de|18182
|
||||
651afbb8-cd22-4cb3-a5e5-48934e4e0dbb|10000
|
||||
01e06e06-cbbe-49c8-bfea-a73ffee16976|9091
|
||||
6e81610f-f06c-43fe-b4ad-cd4edc6611c2|1818
|
||||
8d877077-ec2d-40d6-b229-37f6d60feb46|909
|
||||
e73a9ae4-e6b4-4daf-a55d-4d4723f59ecd|909
|
||||
19cf6e6f-bc28-40ae-afdc-0cf10ed5b252|909
|
||||
9e5c725a-1107-4b68-b610-8b6afa50394a|909
|
||||
a34f608d-d771-413b-88d4-5a8d6babfdaf|909
|
||||
61004e52-701f-4f72-ab45-62c0a1ab97ec|1
|
||||
6cbb6de0-b918-435c-89e2-66e944ed7774|1
|
||||
e320b42f-e328-446b-a748-b27425281864|1
|
||||
```
|
||||
|
||||
### План запроса
|
||||
- Без индекса — `Parallel Seq Scan` + `Sort` (top-N heapsort), на большом чате execution time ~12.9 мс, прочитано 3210 буферов.
|
||||
- `(chat_id)` — `Bitmap Index Scan` + `Sort`; на большом чате execution time ~11.7 мс, 3210 буферов.
|
||||
- `(chat_id, created_at, id)` — `Index Scan` без `Sort`; на большом чате execution time ~0.2 мс, 54 буфера.
|
||||
- На маленьком чате разница между `(chat_id)` и полным индексом в пределах десятых долей мс: полный индекс даёт execution time ~0.1 мс и 4 буфера; `(chat_id)` — ~0.1 мс и 10 буферов. Индекс важен там, где строк много.
|
||||
|
||||
Дополнительный прогон `test_explain` на 550 008 сообщениях подтверждает выбор индекса: `Index Scan using idx_messages_chat_created`, без `Sort`, Execution Time ~0.06 мс.
|
||||
|
||||
### Стоимость записи (10 000 INSERT)
|
||||
Вывод в терминале:
|
||||
```
|
||||
=== 3. Стоимость записи: 10 000 INSERT на каждом варианте ===
|
||||
no_index insert=1.085s idx=6896 kB total=24 MB
|
||||
chat_only insert=0.992s idx=8880 kB total=27 MB
|
||||
full insert=0.977s idx=19 MB total=38 MB
|
||||
```
|
||||
|
||||
Пояснения к столбцам:
|
||||
| Вариант | INSERT, сек | Индекс | Таблица+индексы |
|
||||
|
||||
Выводы:
|
||||
Индекс ускоряет чтение, но занимает больше диска; время вставки на таком объёме отличается слабо (в пределах ~10 %), потому что на запись влияет не только число индексов, но и WAL/checkpoint.
|
||||
|
||||
### Backup/restore
|
||||
Вывод в терминале:
|
||||
```
|
||||
=== 4. backup -> restore -> сверка ===
|
||||
dump size = 7.42 MiB, time = 1.70s
|
||||
pg_restore exit=0, time = 1.62s
|
||||
OK: COUNT, распределение по чатам и 100 случайных сообщений совпадают
|
||||
RTO (pg_restore) = 1.62s, dump = 7.42 MiB
|
||||
```
|
||||
Комментарий:
|
||||
- `pg_dump -Fc`: размер 7.42 MiB (`dump_size_bytes=7783813`), время 1.70 с (`dump_time_s`).
|
||||
- `pg_restore` в новый контейнер: 1.62 с (`restore_time_s`) — это RTO.
|
||||
- Сверка: COUNT(*) — `count_original=280002` и `count_restored=280002` совпадают; распределение по чатам — `dist_match=true`; 100 случайных сообщений (id + text) — `random100_match=true` — совпадают.
|
||||
|
||||
Полные значения сохранены в `evidence/lab2_track2_restore.txt`.
|
||||
|
||||
### RPO
|
||||
Вывод:
|
||||
```
|
||||
=== 5. RPO: запись во время pg_dump ===
|
||||
OK: сообщение 33458232 записано после старта дампа и в restore отсутствует
|
||||
```
|
||||
Комментарий:
|
||||
Сообщение, отправленное через API после старта `pg_dump`, в restore отсутствует. `pg_dump` даёт логический snapshot на момент старта; всё, что записано после, в дамп не попадает. Чтобы RPO → 0, нужна потоковая репликация / WAL-архив — вне рамок трека, здесь только фиксируем границу.
|
||||
|
||||
### Ограничения эксперимента
|
||||
- Один Docker-host: PostgreSQL и API живут рядом в одной compose-сети, restore-контейнер — одноразовый; переносить абсолютные числа на другое железо нельзя.
|
||||
- EXPLAIN снимался на «холодном» плане без прогрева кэша ОС; в реальной эксплуатации цифры будут стабильнее.
|
||||
- Дамп включает все таблицы БД; сравниваем только то, что важно контракту (сообщения, чаты, пользователи).
|
||||
|
||||
Полный отчет — в `evidence/lab2_track2_explain.md`. Метрики и результаты — в `evidence/lab2_track2_write_cost.json`, `lab2_track2_restore.txt`, `lab2_track2_rpo.txt`.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Что выдерживает реализация:
|
||||
- Штатную работу API с PostgreSQL (источник истины) и Redis (сессии с TTL и AOF), оба сервиса — в одной compose-сети, наружу выведен только API.
|
||||
- Регистрацию (scrypt), Basic → Bearer, TTL, отзыв, повторный вход.
|
||||
- Сохранение пользователей, чатов, членства, сообщений и действующих сессий при рестарте API, PostgreSQL и Redis без удаления volumes.
|
||||
- Атомарность создания чата (INSERT chats + INSERT chat_members в одной транзакции); идемпотентную миграцию.
|
||||
- Keyset-пагинацию в SQL с индексом `idx_messages_chat_created`.
|
||||
- Контрактные ответы, `X-Request-Id`, `WWW-Authenticate`, 503 при недоступности Redis/PostgreSQL.
|
||||
- Конкурентную регистрацию одинакового username без дублей; тест проверяет фактические HTTP-коды и наличие одной строки в БД.
|
||||
- Откат составной операции `create_chat` при падении `executemany` уже после INSERT в `chats`: отдельный тест запускает патч-скрипт внутри контейнера API, подменяет `psycopg.Cursor.executemany` и проверяет, что ни строки чата, ни членства не сохранилось.
|
||||
- Остановку Redis и PostgreSQL: 503 на readiness и на запросы с действующим токеном, без анонимного доступа; восстановление зависимостей в `finally`, прежние данные и сессии сохранены.
|
||||
|
||||
Учебные упрощения:
|
||||
- PostgreSQL запущен в Compose (том `mtuci2026lab2_postgres-data`) и общается с API по внутреннему имени `postgres`, порт наружу не вынесен.
|
||||
- `storage/memory.py` оставлен как референс lab1 и в приложении не используется.
|
||||
- `SESSION_STORE=postgres` — fallback, оставлен для сравнения; в рабочем режиме — `redis`.
|
||||
|
||||
Что не входит в уровень 5:
|
||||
- Горизонтальное масштабирование, балансировщик, HA (lab3+).
|
||||
- Вложения и S3 (lab4+), фоновая обработка (lab5+), OTel/Grafana (lab6+), TLS/mTLS/OpenBao/Argon2id (lab7).
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
x-lab-number: 2
|
||||
x-required-roles:
|
||||
- api
|
||||
- postgres
|
||||
|
||||
# Лабораторная 2. API + PostgreSQL + Redis
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:18.6-alpine
|
||||
container_name: mtuci-postgres
|
||||
environment:
|
||||
POSTGRES_USER: ${POSTGRES_USER:-messenger}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-messenger}
|
||||
POSTGRES_DB: ${POSTGRES_DB:-high_load_messenger}
|
||||
volumes:
|
||||
- postgres-data:/var/lib/postgresql
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-high_load_messenger}"]
|
||||
interval: 5s
|
||||
timeout: 5s
|
||||
retries: 20
|
||||
start_period: 30s
|
||||
restart: unless-stopped
|
||||
|
||||
redis:
|
||||
image: redis:7.4.1-alpine
|
||||
container_name: mtuci-redis
|
||||
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec", "--save", "60", "1"]
|
||||
ports:
|
||||
- "127.0.0.1:6379:6379"
|
||||
volumes:
|
||||
- redis-data:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
start_period: 3s
|
||||
restart: unless-stopped
|
||||
|
||||
api:
|
||||
build: .
|
||||
image: mtuci-messenger:lab2
|
||||
container_name: mtuci-messenger-lab2
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
env_file:
|
||||
- .env
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready').read()"]
|
||||
interval: 10s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
start_period: 10s
|
||||
restart: unless-stopped
|
||||
|
||||
volumes:
|
||||
postgres-data:
|
||||
name: mtuci2026lab2_postgres-data
|
||||
redis-data:
|
||||
name: mtuci2026lab2_redis-data
|
||||
|
||||
networks:
|
||||
default:
|
||||
name: mtuci2026lab2_default
|
||||
@@ -0,0 +1,58 @@
|
||||
|
||||
=== Лабораторная 1. Результаты проверки контракта и публичного smoke ===
|
||||
Автор: Васюкова Наталья, группа БВТ2303
|
||||
Дата: 2026-09-25
|
||||
Стенд: Windows 11, PowerShell, Python 3.14.5 (venv), Docker Desktop
|
||||
Образ: mtusi-messenger:lab1 (python:3.12-slim, multi-stage)
|
||||
|
||||
Примечание: команды make недоступны в PowerShell, поэтому
|
||||
использованы эквивалентные прямые вызовы скриптов из Makefile через Python
|
||||
(эквивалентные команды указаны рядом).
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
1. make check -> python scripts/check_contract.py
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
|
||||
Наблюдение: структура репозитория целостна (скелет не изменён): lab.json и версия в openapi.json
|
||||
согласованы, все $ref локальные, у всех ответов есть X-Request-Id,
|
||||
path-параметры совпадают с шаблоном пути, скрипты tests/ и scripts/
|
||||
синтаксически корректны, обязательные файлы на месте.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
2. make validate -> python scripts/validate_openapi.py
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python scripts/validate_openapi.py
|
||||
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
|
||||
|
||||
Наблюдение: контракт contracts/openapi.json прошёл полную валидацию по OpenAPI 3.1,
|
||||
примеры из contracts/examples.json соответствуют схемам компонентов.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
3. make test -> python tests/smoke.py --base-url http://localhost:8080
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python tests/smoke.py --base-url http://localhost:8080
|
||||
PASS: lab1 public API scenario; infrastructure and grading evidence remain separate.
|
||||
|
||||
Наблюдение: сквозной публичный сценарий ЛР1 пройден. Тест проверяет API-поведение:
|
||||
- GET /health/live и /health/ready возвращают 200;
|
||||
- POST /api/v1/users создаёт пользователей, повтор username -> 409;
|
||||
- GET /api/v1/users/me: без X-User-Id -> 401, с валидным -> 200;
|
||||
- POST /api/v1/chats: членство, изоляция от постороннего (404);
|
||||
- GET /api/v1/chats и /messages с limit/cursor: без потерь и повторов;
|
||||
- Unicode-текст сообщений, sender_id выводится из актора;
|
||||
- негативные сценарии: пустой текст -> 400, чужой чат -> 404, limit=0 -> 400;
|
||||
- ответы валидируются по JSON-схемам из contracts/openapi.json.
|
||||
Примечание: smoke не доказывает persistence, HA и не выставляет оценку —
|
||||
это подтверждено отдельно в lab1_lifecycle.txt.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
ИТОГ
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Все три проверки пройдены.
|
||||
@@ -0,0 +1,155 @@
|
||||
=== Лабораторная 1. Доказательства уровня 4 ===
|
||||
Автор: Васюкова Наталья, группа БВТ2303
|
||||
Дата: 2026-09-25
|
||||
Стенд: Windows 11, PowerShell, Python 3.12 (venv), Docker Desktop
|
||||
Образ: mtusi-messenger:lab1 (python:3.12-slim, multi-stage)
|
||||
Commit: solution/BVT2303-Vasyukova
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
1. Собственные негативные тесты
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python student-tests/test_negative.py --base-url http://localhost:8080
|
||||
PASS: lab1 negative scenarios (dup, malformed JSON, extra fields, wrong type,
|
||||
empty text, foreign chat, pagination, bad limit, unknown user)
|
||||
|
||||
Наблюдение: проверены сценарии — повтор username -> 409; malformed JSON -> 400;
|
||||
лишние поля -> 400; неверный тип поля -> 400; пустое/пробельное сообщение -> 400;
|
||||
доступ к чужому чату (GET чата, GET сообщений, POST сообщения) -> 404;
|
||||
обход нескольких страниц cursor-пагинации без потерь, дублей и изменения порядка;
|
||||
limit=0 и limit=101 -> 400; неизвестный UUID в X-User-Id -> 401.
|
||||
Все ответы об ошибках соответствуют формату contracts/openapi.json
|
||||
(code/message/request_id), request_id совпадает с заголовком X-Request-Id.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
2. Конкурентный тест: 100 сообщений от 10 клиентов
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python student-tests/test_concurrency.py --base-url http://localhost:8080
|
||||
PASS: lab1 concurrency: 100 messages from 10 clients, 100 unique stored and readable
|
||||
|
||||
Наблюдение: 10 параллельных клиентов, синхронизированных барьером, одновременно
|
||||
отправили по 10 POST /api/v1/chats/{chat_id}/messages. Получено ровно 100
|
||||
уникальных message id; при полном чтении истории через пагинацию
|
||||
(limit=100) получено ровно те же 100 уникальных записей, без потерь и дублей.
|
||||
Это подтверждает атомарность операций MemoryStorage под threading.RLock.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
3. Единая команда запуска собственных тестов
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python student-tests/run_all.py --base-url http://localhost:8080
|
||||
=== test_negative.py ===
|
||||
PASS: lab1 negative scenarios (dup, malformed JSON, extra fields, wrong type, empty text, foreign chat, pagination, bad limit, unknown user)
|
||||
=== test_concurrency.py ===
|
||||
PASS: lab1 concurrency: 100 messages from 10 clients, 100 unique stored and readable
|
||||
PASS: all student tests (level 4) passed
|
||||
|
||||
(Эквивалент через Makefile: make test-student BASE_URL=http://localhost:8080)
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
4. Обработка SIGTERM
|
||||
--------------------------------------------------------------------
|
||||
|
||||
В терминале 1:
|
||||
$ docker run --rm --name mtusi-messenger-lab1 -p 127.0.0.1:8080:8080 --env-file .env mtusi-messenger:lab1
|
||||
В терминале 2:
|
||||
Цикл опроса TCP-порта 8080 (TcpClient, жёсткий таймаут 500 мс):
|
||||
```
|
||||
while ($true) {
|
||||
$t = Get-Date -Format "HH:mm:ss.fff"
|
||||
$client = New-Object System.Net.Sockets.TcpClient
|
||||
try {
|
||||
$iar = $client.BeginConnect("127.0.0.1", 8080, $null, $null)
|
||||
$ok = $iar.AsyncWaitHandle.WaitOne(500)
|
||||
if ($ok -and $client.Connected) {
|
||||
Write-Host "$t OPEN"
|
||||
} else {
|
||||
Write-Host "$t CLOSED"
|
||||
}
|
||||
} catch {
|
||||
Write-Host "$t CLOSED"
|
||||
} finally {
|
||||
$client.Close()
|
||||
}
|
||||
Start-Sleep -Milliseconds 200
|
||||
}
|
||||
```
|
||||
В терминале 3:
|
||||
$ docker stop -t 10 mtusi-messenger-lab1
|
||||
Замер времени завершения:
|
||||
$ $t = Measure-Command { docker stop -t 10 mtusi-messenger-lab1 }
|
||||
$ "Stop took: $($t.TotalSeconds) s"
|
||||
Stop took: 0.7416883 s
|
||||
|
||||
Фрагмент вывода терминала 2:
|
||||
02:06:06.269 OPEN
|
||||
02:06:06.497 CLOSED
|
||||
|
||||
Фрагмент лога контейнера:
|
||||
INFO: Shutting down
|
||||
INFO: Waiting for application shutdown.
|
||||
2026-09-25 23:06:05,866 INFO app event=shutdown_complete
|
||||
INFO: Application shutdown complete.
|
||||
INFO: Finished server process [1]
|
||||
|
||||
Наблюдение: контейнер завершился за ~0.74 с (существенно быстрее grace-period 10 с).
|
||||
Порт закрылся (первый CLOSED) через ~0.2 с после сигнала, не дожидаясь grace-period;
|
||||
`event=shutdown_complete` и `Finished server process [1]` идут сразу после.
|
||||
Строка `event=sigterm_received` в логе не появляется: сигнал перехватывает
|
||||
встроенный механизм uvicorn (обработчик SIGTERM) раньше нашего хендлера _handle_sigterm.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
5. Логи без содержимого сообщений
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Пример строк лога контейнера (meta-only):
|
||||
|
||||
2026-09-25 ... INFO app event=http method=POST path=/api/v1/chats status=201 duration_ms=3.12 request_id=...
|
||||
2026-09-25 ... INFO app event=http method=POST path=/api/v1/chats/<uuid>/messages status=201 duration_ms=2.01 request_id=...
|
||||
2026-09-25 ... INFO app event=startup app_env=lab
|
||||
2026-09-25 ... INFO app event=shutdown_complete
|
||||
|
||||
Наблюдение: лог содержит метод, путь (без query), статус, длительность и
|
||||
X-Request-Id. Текст сообщений, значения X-User-Id, пароли и токены в лог
|
||||
не попадают. Ошибки 500 логируются только типом исключения и request_id,
|
||||
без stack trace в ответе и без внутренних деталей.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
6. Конфигурация контейнера (уровень 4)
|
||||
--------------------------------------------------------------------
|
||||
|
||||
- Dockerfile: базовый образ python:3.12-slim (multi-stage), зависимости
|
||||
закреплены (fastapi==0.115.0, uvicorn[standard]==0.32.0).
|
||||
- Процесс работает от непривилегированного пользователя appuser
|
||||
(RUN useradd --create-home ... ; USER appuser).
|
||||
- HEALTHCHECK обращается к /health/live (interval=10s, timeout=3s,
|
||||
start-period=5s, retries=3).
|
||||
- .dockerignore исключает .env, secrets, certs, volumes, backups,
|
||||
*.key/*.pem/*.p12/*.pfx/*.jks, .venv, __pycache__, node_modules,
|
||||
evidence, .DS_Store. В образ не копируются локальные секреты.
|
||||
|
||||
Проверка:
|
||||
$ docker inspect --format "{{.Config.User}}" mtusi-messenger-lab1
|
||||
appuser
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
ИТОГ
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Результаты:
|
||||
- собственные негативные тесты — PASS;
|
||||
- конкурентный тест 100/10 — PASS, 100 уникальных сообщений;
|
||||
- единая команда запуска test-student — PASS;
|
||||
- SIGTERM: контейнер останавливается за ~0.74 с, порт закрывается через
|
||||
~0.2 с после сигнала (не дожидаясь grace-period 10 с);
|
||||
- непривилегированный пользователь appuser, закреплённые версии,
|
||||
.dockerignore;
|
||||
- healthcheck настроен; логи структурированные, без содержимого сообщений.
|
||||
@@ -0,0 +1,58 @@
|
||||
=== Лабораторная 1. Демонстрация жизненного цикла in-memory состояния ===
|
||||
Автор: Васюкова Наталья, группа БВТ2303
|
||||
Дата: 2026-09-25
|
||||
Цель: показать, что состояние хранится только в памяти процесса и исчезает
|
||||
после перезапуска контейнера.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
1. До перезапуска: пользователь существует
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Пользователь создан через Swagger. Получен его id.
|
||||
|
||||
Проверка:
|
||||
$ curl.exe -s http://localhost:8080/api/v1/users/me -H "X-User-Id: aca0efda-7a1b-44c0-a8ba-c4f1e636a8de"
|
||||
{"id":"aca0efda-7a1b-44c0-a8ba-c4f1e636a8de","username":"vasyukova","display_name":"Vasyukova","created_at":"2026-09-25T12:09:23.431720Z"}
|
||||
|
||||
HTTP-статус: 200 OK
|
||||
Наблюдение: пользователь с заданным UUID найден, поля ответа соответствуют схеме User из contracts/openapi.json.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
2. Остановка контейнера
|
||||
--------------------------------------------------------------------
|
||||
|
||||
В терминале с запущенным контейнером:
|
||||
Ctrl+C.
|
||||
Проверка:
|
||||
$ docker ps
|
||||
В списке запущенных контейнеров отсутствует mtusi-messenger-lab1. Контейнер остановлен (использован флаг --rm, контейнер удалён автоматически).
|
||||
|
||||
--------------------------------------------------------------------
|
||||
3. Повторный запуск контейнера
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ docker run --rm --name mtusi-messenger-lab1 -p 127.0.0.1:8080:8080 --env-file .env mtusi-messenger:lab1
|
||||
Uvicorn запущен на http://0.0.0.0:8080, контейнер готов принимать запросы.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
4. После перезапуска: пользователь отсутствует
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Повторная проверка:
|
||||
$ curl.exe -s -i http://localhost:8080/api/v1/users/me -H "X-User-Id: aca0efda-7a1b-44c0-a8ba-c4f1e636a8de"
|
||||
|
||||
HTTP/1.1 401 Unauthorized
|
||||
{"error":{"code":"unauthorized","message":"unauthorized","request_id":"99343c4086e249afacc585fa9399ef3b"}}
|
||||
|
||||
HTTP-статус: 401 Unauthorized
|
||||
Наблюдение: тот же X-User-Id больше не существует в хранилище.
|
||||
Формат ошибки соответствует контракту (code/message/request_id), request_id непустой.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
ВЫВОД
|
||||
--------------------------------------------------------------------
|
||||
|
||||
После перезапуска пользователь исчез. Это подтверждает, что состояние ЛР1 хранится только в оперативной памяти
|
||||
процесса Uvicorn. Volumes, БД, файлы состояния не используются. Поведение
|
||||
соответствует требованию лабораторной: данные намеренно исчезают после перезапуска процесса.
|
||||
@@ -0,0 +1,24 @@
|
||||
{
|
||||
"lab": 1,
|
||||
"track": 1,
|
||||
"variant": "after",
|
||||
"profile": {
|
||||
"history_sizes": [100, 1000, 5000],
|
||||
"concurrency_levels": [1, 4, 16],
|
||||
"duration_seconds": 10,
|
||||
"note": "closed-loop; клиент ограничивает throughput; RSS — docker stats; sort on read REMOVED"
|
||||
},
|
||||
"points": [
|
||||
{"history_size": 100, "concurrency": 1, "duration_s": 10.357, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.483, "latency_ms": {"p50": 2064.323, "p95": 2078.936, "p99": 2078.936}, "rss_mb": 46.01},
|
||||
{"history_size": 100, "concurrency": 4, "duration_s": 10.379, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.927, "latency_ms": {"p50": 2061.138, "p95": 2090.765, "p99": 2093.1}, "rss_mb": 35.47},
|
||||
{"history_size": 100, "concurrency": 16, "duration_s": 10.522, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.603, "latency_ms": {"p50": 2065.596, "p95": 2084.327, "p99": 2090.339}, "rss_mb": 35.54},
|
||||
|
||||
{"history_size": 1000, "concurrency": 1, "duration_s": 10.341, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.483, "latency_ms": {"p50": 2070.498, "p95": 2076.896, "p99": 2076.896}, "rss_mb": 35.91},
|
||||
{"history_size": 1000, "concurrency": 4, "duration_s": 10.383, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.926, "latency_ms": {"p50": 2061.585, "p95": 2085.476, "p99": 2089.531}, "rss_mb": 36.91},
|
||||
{"history_size": 1000, "concurrency": 16, "duration_s": 10.571, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.568, "latency_ms": {"p50": 2075.703, "p95": 2092.981, "p99": 2102.494}, "rss_mb": 37.53},
|
||||
|
||||
{"history_size": 5000, "concurrency": 1, "duration_s": 10.296, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.486, "latency_ms": {"p50": 2043.537, "p95": 2086.686, "p99": 2086.686}, "rss_mb": 41.6},
|
||||
{"history_size": 5000, "concurrency": 4, "duration_s": 10.324, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.937, "latency_ms": {"p50": 2057.056, "p95": 2065.708, "p99": 2068.095}, "rss_mb": 42.15},
|
||||
{"history_size": 5000, "concurrency": 16, "duration_s": 10.747, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.444, "latency_ms": {"p50": 2072.015, "p95": 2116.62, "p99": 2124.503}, "rss_mb": 43.08}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
{
|
||||
"lab": 1,
|
||||
"track": 1,
|
||||
"variant": "before",
|
||||
"profile": {
|
||||
"history_sizes": [100, 1000, 5000],
|
||||
"concurrency_levels": [1, 4, 16],
|
||||
"duration_seconds": 10,
|
||||
"note": "closed-loop; клиент ограничивает throughput; RSS — docker stats; sort on read ENABLED"
|
||||
},
|
||||
"points": [
|
||||
{"history_size": 100, "concurrency": 1, "duration_s": 10.355, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.483, "latency_ms": {"p50": 2066.139, "p95": 2085.291, "p99": 2085.291}, "rss_mb": 34.35},
|
||||
{"history_size": 100, "concurrency": 4, "duration_s": 10.415, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.92, "latency_ms": {"p50": 2073.966, "p95": 2088.797, "p99": 2091.95}, "rss_mb": 34.83},
|
||||
{"history_size": 100, "concurrency": 16, "duration_s": 10.589, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.555, "latency_ms": {"p50": 2071.131, "p95": 2127.922, "p99": 2134.262}, "rss_mb": 35.44},
|
||||
|
||||
{"history_size": 1000, "concurrency": 1, "duration_s": 10.372, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.482, "latency_ms": {"p50": 2076.358, "p95": 2082.009, "p99": 2082.009}, "rss_mb": 36.84},
|
||||
{"history_size": 1000, "concurrency": 4, "duration_s": 10.381, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.927, "latency_ms": {"p50": 2062.515, "p95": 2094.389, "p99": 2106.044}, "rss_mb": 36.71},
|
||||
{"history_size": 1000, "concurrency": 16, "duration_s": 10.58, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.562, "latency_ms": {"p50": 2076.528, "p95": 2101.717, "p99": 2115.533}, "rss_mb": 38.19},
|
||||
|
||||
{"history_size": 5000, "concurrency": 1, "duration_s": 10.39, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.481, "latency_ms": {"p50": 2076.522, "p95": 2097.586, "p99": 2097.586}, "rss_mb": 53.12},
|
||||
{"history_size": 5000, "concurrency": 4, "duration_s": 10.494, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.906, "latency_ms": {"p50": 2086.895, "p95": 2108.007, "p99": 2108.871}, "rss_mb": 42.75},
|
||||
{"history_size": 5000, "concurrency": 16, "duration_s": 10.701, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.476, "latency_ms": {"p50": 2090.597, "p95": 2183.025, "p99": 2188.819}, "rss_mb": 44.57}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,167 @@
|
||||
# Трек 1. Предел in-memory архитектуры — сводка. Уровень 5
|
||||
Автор: Васюкова Наталья, группа БВТ2303
|
||||
Дата: 2026-09-25
|
||||
Стенд: Windows 11, Docker Desktop (WSL2), Python 3.12, образ python:3.12-slim.
|
||||
Дата: 2026-09-25.
|
||||
Commit: solution/BVT2303-Vasyukova.
|
||||
|
||||
Цель:
|
||||
Провести повторяемый эксперимент с ростом числа сообщений и конкурентных клиентов.
|
||||
Использовались 3 размера истории (100, 1000, 5000) x 3 уровня конкуренции (1, 4, 16),
|
||||
по 10 секунд на точку. Профиль: closed-loop чтение GET /api/v1/chats/{id}/messages?limit=100.
|
||||
|
||||
Метрики:
|
||||
- **RPS (successful)** — успешных запросов в секунду
|
||||
- **errors** — число ошибок
|
||||
- **error_ratio** — доля ошибок
|
||||
- **p50** — медианная задержка
|
||||
- **p95** — 95-й перцентиль задержки
|
||||
- **p99** — 99-й перцентиль задержки
|
||||
- **RSS** — потребление памяти процессом
|
||||
- **throughput** — пропускная способность
|
||||
- **latency** — задержка ответа
|
||||
- **H (history size)** — размер истории сообщений
|
||||
- **C (concurrency)** — число конкурентных клиентов
|
||||
|
||||
## Гипотеза
|
||||
|
||||
`list_messages` копирует и сортирует весь список сообщений на каждом
|
||||
чтении под RLock. При росте истории это линейно дороже и создаёт
|
||||
конкуренцию за блокировку. Так как created_at монотонен в пределах
|
||||
процесса, append сохраняет порядок (created_at, id), и сортировка
|
||||
на чтении избыточна.
|
||||
|
||||
Изменение: убрать sort в list_messages, хранить список как есть.
|
||||
|
||||
## Ход исследования
|
||||
|
||||
Исследование проводится в 2 шага:
|
||||
|
||||
1. Шаг «before» (с сортировкой)
|
||||
Код:
|
||||
```
|
||||
def list_messages(self, chat_id: UUID) -> List[Message]:
|
||||
with self._lock:
|
||||
items = list(self._messages.get(chat_id, []))
|
||||
items.sort(key=lambda m: (m.created_at, str(m.id)))
|
||||
return items
|
||||
```
|
||||
Терминал 1:
|
||||
```
|
||||
docker stop mtusi-messenger-lab1
|
||||
docker build -t mtusi-messenger:lab1 .
|
||||
docker run --rm --name mtusi-messenger-lab1 -p 127.0.0.1:8080:8080 --env-file .env mtusi-messenger:lab1
|
||||
```
|
||||
Терминал 2:
|
||||
```
|
||||
python student-tests/test_load_track1.py --base-url http://localhost:8080
|
||||
Copy-Item evidence/lab1_track1_load.json evidence/lab1_track1_load_before.json
|
||||
```
|
||||
|
||||
2. Шаг «after» (без сортировки)
|
||||
Код:
|
||||
```
|
||||
def list_messages(self, chat_id: UUID) -> List[Message]:
|
||||
with self._lock:
|
||||
# Без пересортировки: список уже в порядке (created_at, id).
|
||||
return list(self._messages.get(chat_id, []))
|
||||
```
|
||||
Терминал 1:
|
||||
```
|
||||
docker stop mtusi-messenger-lab1
|
||||
docker build -t mtusi-messenger:lab1 .
|
||||
docker run --rm --name mtusi-messenger-lab1 -p 127.0.0.1:8080:8080 --env-file .env mtusi-messenger:lab1
|
||||
```
|
||||
Терминал 2:
|
||||
```
|
||||
python student-tests/test_load_track1.py --base-url http://localhost:8080
|
||||
Copy-Item evidence/lab1_track1_load.json evidence/lab1_track1_load_after.json
|
||||
```
|
||||
|
||||
|
||||
## Результаты
|
||||
|
||||
Во всех точках errors = 0, error_ratio = 0.0.
|
||||
|
||||
### p95, мс (before / after)
|
||||
|
||||
| H | C=1 | C=4 | C=16 |
|
||||
|-------|---------------------|---------------------|---------------------|
|
||||
| 100 | 2085.3 / 2078.9 | 2088.8 / 2090.8 | 2127.9 / 2084.3 |
|
||||
| 1000 | 2082.0 / 2076.9 | 2094.4 / 2085.5 | 2101.7 / 2093.0 |
|
||||
| 5000 | 2097.6 / 2086.7 | 2108.0 / 2065.7 | 2183.0 / 2116.6 |
|
||||
|
||||
### p99, мс (before / after)
|
||||
|
||||
| H | C=1 | C=4 | C=16 |
|
||||
|-------|---------------------|---------------------|---------------------|
|
||||
| 100 | 2085.3 / 2078.9 | 2092.0 / 2093.1 | 2134.3 / 2090.3 |
|
||||
| 1000 | 2082.0 / 2076.9 | 2106.0 / 2089.5 | 2115.5 / 2102.5 |
|
||||
| 5000 | 2097.6 / 2086.7 | 2108.9 / 2068.1 | 2188.8 / 2124.5 |
|
||||
|
||||
### RPS (успешные, before / after)
|
||||
|
||||
| H | C=1 | C=4 | C=16 |
|
||||
|-------|---------------------|---------------------|---------------------|
|
||||
| 100 | 0.483 / 0.483 | 1.920 / 1.927 | 7.555 / 7.603 |
|
||||
| 1000 | 0.482 / 0.483 | 1.927 / 1.926 | 7.562 / 7.568 |
|
||||
| 5000 | 0.481 / 0.486 | 1.906 / 1.937 | 7.476 / 7.444 |
|
||||
|
||||
### RSS, МБ (before / after)
|
||||
|
||||
| H | C=1 | C=4 | C=16 |
|
||||
|-------|---------------------|---------------------|---------------------|
|
||||
| 100 | 34.35 / 46.01 | 34.83 / 35.47 | 35.44 / 35.54 |
|
||||
| 1000 | 36.84 / 35.91 | 36.71 / 36.91 | 38.19 / 37.53 |
|
||||
| 5000 | 53.12 / 41.60 | 42.75 / 42.15 | 44.57 / 43.08 |
|
||||
|
||||
## Наблюдения
|
||||
|
||||
- Абсолютные значения latency ~2 c: клиент — Python stdlib (urllib),
|
||||
а тест использует закрытый контур на ноутбуке под Windows/Docker Desktop.
|
||||
Это ограничение клиента и среды, а не только сервера.
|
||||
- RPS растёт с конкуренцией (≈0.48 → ≈1.9 → ≈7.5) — узкое место в
|
||||
клиентском контуре, а не в API.
|
||||
- RSS растёт с историей (after: 35.5 → 37.5 → 43.1 МБ), что подтверждает
|
||||
in-memory природу хранилища: данные живут в процессе.
|
||||
- `after` ниже по RSS в большинстве точек: H=1000 — 35.9–37.5 против
|
||||
36.7–38.2; H=5000/C=4 — 42.15 против 42.75; H=5000/C=16 — 43.08
|
||||
против 44.57. Единичный выброс H=100/C=1 (46.01 после против 34.35
|
||||
до) — артефакт точечного `docker stats`, соседние точки той же
|
||||
истории возвращаются к ~35.5 МБ.
|
||||
- На H=5000/C=16 `after` лучше по latency. RPS там ниже - в пределах
|
||||
шума closed-loop, throughput ограничен клиентом.
|
||||
- На H=100 разница в пределах шума — сортировка короткого списка дёшева.
|
||||
- Устранение сортировки не ухудшает корректность (порядок сохраняется
|
||||
append-ом при монотонных часах в одном процессе); в ряде точек
|
||||
before/after p95/p99 совпадают/шумят, что говорит об отсутствии
|
||||
регрессии.
|
||||
- errors = 0 во всех точках обоих прогонов.
|
||||
|
||||
## Ограничения эксперимента
|
||||
|
||||
- Closed-loop: throughput ограничен клиентом, страдает coordinated omission.
|
||||
- Один Docker-host: HA/durability не проверяются и не заявляются.
|
||||
- Абсолютные p95/p99 не переносимы на другой ноутбук.
|
||||
- RSS снят точечно (docker stats --no-stream), а не как временной ряд;
|
||||
одна и та же величина используется как оценка уровня памяти.
|
||||
- Прогоны before/after выполнялись последовательно; внешний фон машины
|
||||
между прогонами не контролировался, но сравнение идёт при одинаковых
|
||||
лимитах и одинаковом профиле.
|
||||
|
||||
## Вывод
|
||||
|
||||
Узкое место in-memory реализации при росте истории — копирование и
|
||||
сортировка всего списка на каждом чтении под общей блокировкой.
|
||||
Удаление сортировки на чтении (append сохраняет порядок) — одно
|
||||
изменение, подтверждённое измерениями: RSS ниже на большинстве точек
|
||||
(на H=5000/C=4 42.15 против 42.75 МБ, на H=5000/C=16 43.08 против
|
||||
44.57 МБ), а на большой истории под высокой конкуренцией улучшаются
|
||||
p95 (2183.0 → 2116.6 мс) и p99 (2188.8 → 2124.5 мс) без потери
|
||||
корректности. Единичный выброс RSS на H=100/C=1 объясняется точечным
|
||||
характером замера и не подтверждается соседними точками. Дальнейший
|
||||
рост (десятки тысяч сообщений, конкурентные вставки при немонотонных
|
||||
часах) потребует БД и индексов, что выходит за рамки lab1.
|
||||
```
|
||||
|
||||
Ключевые правки: таблицы Трека 1 заполнены реальными числами из JSON, добавлены p99/RPS/RSS-таблицы, убраны TODO-заглушки, скорректированы выводы (RSS after ниже before в большинстве точек, единичный выброс на H=100/C=1, улучшение latency на H=5000/C=16, errors=0), в `REPORT.md` раздел Трека 1 приведён в соответствие с summary.
|
||||
@@ -0,0 +1,139 @@
|
||||
# Трек 2. EXPLAIN (ANALYZE, BUFFERS): 3 варианта индекса
|
||||
|
||||
Данные: 250002 сообщений, неравномерные чаты. Запрос: `SELECT ... FROM messages WHERE chat_id = <id> AND (created_at, id) > (<середина>, …) ORDER BY created_at, id LIMIT 51`.
|
||||
Большой чат ~151818, маленький чат ~1.
|
||||
|
||||
## 1. Без индекса, большой чат
|
||||
|
||||
`Parallel Seq Scan` по всей таблице, затем `Sort`.
|
||||
|
||||
```
|
||||
Limit (cost=6593.26..6599.20 rows=51 width=70) (actual time=10.966..12.790 rows=51.00 loops=1)
|
||||
Buffers: shared hit=3210
|
||||
-> Gather Merge (cost=6593.26..11539.13 rows=42466 width=70) (actual time=10.964..12.782 rows=51.00 loops=1)
|
||||
Workers Planned: 2
|
||||
Workers Launched: 2
|
||||
Buffers: shared hit=3210
|
||||
-> Sort (cost=5593.24..5637.48 rows=17694 width=70) (actual time=7.715..7.718 rows=39.00 loops=3)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: top-N heapsort Memory: 36kB
|
||||
Buffers: shared hit=3210
|
||||
Worker 0: Sort Method: top-N heapsort Memory: 36kB
|
||||
Worker 1: Sort Method: top-N heapsort Memory: 36kB
|
||||
-> Parallel Seq Scan on messages (cost=0.00..5002.93 rows=17694 width=70) (actual time=3.301..5.795 rows=26666.67 loops=3)
|
||||
Filter: ((chat_id = '362231ce-de25-4394-a32c-9dcddc4fabe0'::uuid) AND (ROW(created_at, id) > ROW('2026-10-02 15:00:32.39108+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
|
||||
Rows Removed by Filter: 56667
|
||||
Buffers: shared hit=3180
|
||||
Planning:
|
||||
Buffers: shared hit=88
|
||||
Planning Time: 0.571 ms
|
||||
Execution Time: 12.922 ms
|
||||
```
|
||||
|
||||
## 2. Без индекса, маленький чат
|
||||
|
||||
Тот же `Parallel Seq Scan` по всей таблице.
|
||||
|
||||
```
|
||||
Limit (cost=6003.04..6003.05 rows=1 width=70) (actual time=7.881..10.103 rows=1.00 loops=1)
|
||||
Buffers: shared hit=3186
|
||||
-> Sort (cost=6003.04..6003.05 rows=1 width=70) (actual time=7.879..10.099 rows=1.00 loops=1)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: quicksort Memory: 25kB
|
||||
Buffers: shared hit=3186
|
||||
-> Gather (cost=1000.00..6003.03 rows=1 width=70) (actual time=7.667..10.055 rows=1.00 loops=1)
|
||||
Workers Planned: 2
|
||||
Workers Launched: 2
|
||||
Buffers: shared hit=3180
|
||||
-> Parallel Seq Scan on messages (cost=0.00..5002.93 rows=1 width=70) (actual time=3.431..4.199 rows=0.33 loops=3)
|
||||
Filter: ((chat_id = '61004e52-701f-4f72-ab45-62c0a1ab97ec'::uuid) AND (ROW(created_at, id) > ROW('2026-10-02 14:24:06.811443+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
|
||||
Rows Removed by Filter: 83334
|
||||
Buffers: shared hit=3180
|
||||
Planning:
|
||||
Buffers: shared hit=88
|
||||
Planning Time: 0.662 ms
|
||||
Execution Time: 10.192 ms
|
||||
```
|
||||
|
||||
## 3. Индекс (chat_id), большой чат
|
||||
|
||||
`Bitmap Index Scan` по `idx_messages_chat_only`, затем `Bitmap Heap Scan` и `Sort`.
|
||||
|
||||
```
|
||||
Limit (cost=6594.20..6600.14 rows=51 width=70) (actual time=9.705..11.642 rows=51.00 loops=1)
|
||||
Buffers: shared hit=3210
|
||||
-> Gather Merge (cost=6594.20..11547.87 rows=42533 width=70) (actual time=9.688..11.619 rows=51.00 loops=1)
|
||||
Workers Planned: 2
|
||||
Workers Launched: 2
|
||||
Buffers: shared hit=3210
|
||||
-> Sort (cost=5594.17..5638.48 rows=17722 width=70) (actual time=6.872..6.874 rows=37.33 loops=3)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: top-N heapsort Memory: 36kB
|
||||
Buffers: shared hit=3210
|
||||
Worker 0: Sort Method: top-N heapsort Memory: 36kB
|
||||
Worker 1: Sort Method: top-N heapsort Memory: 37kB
|
||||
-> Parallel Seq Scan on messages (cost=0.00..5002.93 rows=17722 width=70) (actual time=2.667..5.224 rows=26666.67 loops=3)
|
||||
Filter: ((chat_id = '362231ce-de25-4394-a32c-9dcddc4fabe0'::uuid) AND (ROW(created_at, id) > ROW('2026-10-02 15:00:32.39108+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
|
||||
Rows Removed by Filter: 56667
|
||||
Buffers: shared hit=3180
|
||||
Planning:
|
||||
Buffers: shared hit=100
|
||||
Planning Time: 0.552 ms
|
||||
Execution Time: 11.745 ms
|
||||
```
|
||||
|
||||
## 4. Индекс (chat_id), маленький чат
|
||||
|
||||
`Index Scan using idx_messages_chat_only` + `Sort`.
|
||||
|
||||
```
|
||||
Limit (cost=32.15..32.16 rows=4 width=70) (actual time=0.055..0.056 rows=1.00 loops=1)
|
||||
Buffers: shared hit=10
|
||||
-> Sort (cost=32.15..32.16 rows=4 width=70) (actual time=0.054..0.055 rows=1.00 loops=1)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: quicksort Memory: 25kB
|
||||
Buffers: shared hit=10
|
||||
-> Index Scan using idx_messages_chat_only on messages (cost=0.42..32.11 rows=4 width=70) (actual time=0.022..0.023 rows=1.00 loops=1)
|
||||
Index Cond: (chat_id = '61004e52-701f-4f72-ab45-62c0a1ab97ec'::uuid)
|
||||
Filter: (ROW(created_at, id) > ROW('2026-10-02 14:24:06.811443+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid))
|
||||
Index Searches: 1
|
||||
Buffers: shared hit=4
|
||||
Planning:
|
||||
Buffers: shared hit=100
|
||||
Planning Time: 0.642 ms
|
||||
Execution Time: 0.112 ms
|
||||
```
|
||||
|
||||
## 5. Полный индекс (chat_id, created_at, id), большой чат
|
||||
|
||||
`Index Scan using idx_messages_chat_created`, **без `Sort`**.
|
||||
|
||||
```
|
||||
Limit (cost=0.42..17.05 rows=51 width=70) (actual time=0.093..0.150 rows=51.00 loops=1)
|
||||
Buffers: shared hit=53 read=1
|
||||
-> Index Scan using idx_messages_chat_created on messages (cost=0.42..13689.96 rows=41992 width=70) (actual time=0.092..0.146 rows=51.00 loops=1)
|
||||
Index Cond: ((chat_id = '362231ce-de25-4394-a32c-9dcddc4fabe0'::uuid) AND (ROW(created_at, id) > ROW('2026-10-02 15:00:32.39108+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
|
||||
Index Searches: 1
|
||||
Buffers: shared hit=53 read=1
|
||||
Planning:
|
||||
Buffers: shared hit=111
|
||||
Planning Time: 0.751 ms
|
||||
Execution Time: 0.208 ms
|
||||
```
|
||||
|
||||
## 6. Полный индекс (chat_id, created_at, id), маленький чат
|
||||
|
||||
`Index Scan` без `Sort`.
|
||||
|
||||
```
|
||||
Limit (cost=0.42..8.44 rows=1 width=70) (actual time=0.028..0.029 rows=1.00 loops=1)
|
||||
Buffers: shared hit=4
|
||||
-> Index Scan using idx_messages_chat_created on messages (cost=0.42..8.44 rows=1 width=70) (actual time=0.027..0.028 rows=1.00 loops=1)
|
||||
Index Cond: ((chat_id = '61004e52-701f-4f72-ab45-62c0a1ab97ec'::uuid) AND (ROW(created_at, id) > ROW('2026-10-02 14:24:06.811443+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
|
||||
Index Searches: 1
|
||||
Buffers: shared hit=4
|
||||
Planning:
|
||||
Buffers: shared hit=111
|
||||
Planning Time: 0.846 ms
|
||||
Execution Time: 0.105 ms
|
||||
```
|
||||
@@ -0,0 +1,8 @@
|
||||
Track 2 restore
|
||||
dump_time_s=1.701
|
||||
dump_size_bytes=7783813
|
||||
restore_time_s=1.623
|
||||
count_original=280002
|
||||
count_restored=280002
|
||||
dist_match=true
|
||||
random100_match=true
|
||||
@@ -0,0 +1,4 @@
|
||||
Track 2 RPO
|
||||
marker_message_id=9c0393a4-4fbd-4c79-8229-1fdd065eb7d8
|
||||
present_in_restore=0
|
||||
expected=0
|
||||
@@ -0,0 +1,20 @@
|
||||
[
|
||||
{
|
||||
"variant": "no_index",
|
||||
"insert_10000_s": 0.873,
|
||||
"indexes_size": "10 MB",
|
||||
"total_size": "36 MB"
|
||||
},
|
||||
{
|
||||
"variant": "chat_only",
|
||||
"insert_10000_s": 0.888,
|
||||
"indexes_size": "12 MB",
|
||||
"total_size": "39 MB"
|
||||
},
|
||||
{
|
||||
"variant": "full",
|
||||
"insert_10000_s": 0.805,
|
||||
"indexes_size": "26 MB",
|
||||
"total_size": "54 MB"
|
||||
}
|
||||
]
|
||||
@@ -0,0 +1,6 @@
|
||||
fastapi==0.115.0
|
||||
uvicorn[standard]==0.32.0
|
||||
psycopg[binary]==3.2.3
|
||||
psycopg_pool==3.2.3
|
||||
redis==5.2.0
|
||||
openapi-spec-validator==0.7.2
|
||||
@@ -0,0 +1,24 @@
|
||||
@echo off
|
||||
REM Windows-эквивалент scripts/restart.sh для lab2.
|
||||
REM
|
||||
REM Методичка:
|
||||
REM Перезапустите API и ВСЕ используемые хранилища состояний (БД, сессии, S3, брокер, если применимо).
|
||||
REM Сохраните постоянные тома и схемы/данные; не используйте -v / flush / re-seed.
|
||||
REM Разрешите оператору снять защиту, если это необходимо в lab7; не выводите учетные данные.
|
||||
REM Выходите из программы с кодом 0 только после выполнения запланированного действия; тест отдельно проверяет готовность API.
|
||||
|
||||
REM Уровень 4: перезапуск API, PostgreSQL и Redis. Тома не трогаем.
|
||||
docker compose --env-file .env restart api postgres redis >nul 2>&1
|
||||
if errorlevel 1 (
|
||||
docker restart mtuci-messenger-lab2 >nul 2>&1
|
||||
docker restart mtuci-postgres >nul 2>&1
|
||||
docker restart mtuci-redis >nul 2>&1
|
||||
)
|
||||
set /a i=0
|
||||
:wait_loop
|
||||
if %i% geq 90 exit /b 1
|
||||
curl -fsS http://localhost:8080/health/ready >nul 2>&1
|
||||
if not errorlevel 1 exit /b 0
|
||||
set /a i+=1
|
||||
timeout /t 1 /nobreak >nul
|
||||
goto wait_loop
|
||||
@@ -0,0 +1,23 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Методичка:
|
||||
# Перезапустите API и ВСЕ используемые хранилища состояний (БД, сессии, S3, брокер, если применимо).
|
||||
# Сохраните постоянные тома и схемы/данные; не используйте -v / flush / re-seed.
|
||||
# Разрешите оператору снять защиту, если это необходимо в lab7; не выводите учетные данные.
|
||||
# Выходите из программы с кодом 0 только после выполнения запланированного действия; тест отдельно проверяет готовность API.
|
||||
|
||||
# Уровень 4: перезапускаем API, PostgreSQL и Redis. Тома (postgres-data, redis-data) не трогаем.
|
||||
docker compose --env-file .env restart api postgres redis >/dev/null 2>&1 || {
|
||||
docker restart mtuci-messenger-lab2 >/dev/null 2>&1 || true
|
||||
docker restart mtuci-postgres >/dev/null 2>&1 || true
|
||||
docker restart mtuci-redis >/dev/null 2>&1 || true
|
||||
}
|
||||
# Ждём readiness
|
||||
i=0
|
||||
while [ $i -lt 90 ]; do
|
||||
if curl -fsS http://localhost:8080/health/ready >/dev/null 2>&1; then
|
||||
exit 0
|
||||
fi
|
||||
i=$((i+1)); sleep 1
|
||||
done
|
||||
exit 1
|
||||
@@ -0,0 +1,77 @@
|
||||
import base64
|
||||
import binascii
|
||||
import os
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException, Request
|
||||
from fastapi.security import HTTPBasic, HTTPBasicCredentials
|
||||
|
||||
from ..models.schemas import Session
|
||||
from ..storage.postgres import storage
|
||||
|
||||
|
||||
router = APIRouter(prefix="/api/v1/auth", tags=["auth"])
|
||||
|
||||
basic_scheme = HTTPBasic(auto_error=False)
|
||||
|
||||
DEFAULT_TTL_SECONDS = 3600
|
||||
|
||||
|
||||
def _ttl_seconds() -> int:
|
||||
try:
|
||||
return int(os.environ.get("SESSION_TTL_SECONDS", DEFAULT_TTL_SECONDS))
|
||||
except ValueError:
|
||||
return DEFAULT_TTL_SECONDS
|
||||
|
||||
|
||||
def _parse_basic(credentials: HTTPBasicCredentials | None) -> tuple[str, str] | None:
|
||||
"""HTTPBasic уже разобрал заголовок; сюда попадают username/password.
|
||||
|
||||
Дополнительно валидируем кодировку: username — ASCII, пароль — UTF-8.
|
||||
"""
|
||||
if credentials is None:
|
||||
return None
|
||||
username = credentials.username
|
||||
password = credentials.password
|
||||
if not username or not password:
|
||||
return None
|
||||
try:
|
||||
username.encode("ascii")
|
||||
except UnicodeEncodeError:
|
||||
return None
|
||||
return username, password
|
||||
|
||||
|
||||
@router.post(
|
||||
path="/sessions",
|
||||
summary="Вход: Basic username:password; выдаёт сессию",
|
||||
response_model=Session,
|
||||
status_code=201,
|
||||
)
|
||||
def create_session(
|
||||
credentials: HTTPBasicCredentials | None = Depends(basic_scheme),
|
||||
) -> Session:
|
||||
parsed = _parse_basic(credentials)
|
||||
if parsed is None:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
username, password = parsed
|
||||
user = storage.verify_credentials(username, password)
|
||||
if user is None:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
token, expires_at = storage.create_session(user.id, _ttl_seconds())
|
||||
return Session(token=token, token_type="Bearer", expires_at=expires_at, user=user)
|
||||
|
||||
|
||||
@router.delete(
|
||||
path="/sessions/current",
|
||||
summary="Отозвать текущую сессию",
|
||||
status_code=204,
|
||||
)
|
||||
def revoke_session(request: Request) -> None:
|
||||
auth = request.headers.get("Authorization", "")
|
||||
if not auth.lower().startswith("bearer "):
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
token = auth[7:].strip()
|
||||
if not token or storage.get_session_user(token) is None:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
storage.revoke_session(token)
|
||||
return None
|
||||
@@ -0,0 +1,83 @@
|
||||
import base64
|
||||
import json
|
||||
from uuid import UUID
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query
|
||||
from ..models.schemas import Chat, ChatPage, CreateChat, User
|
||||
from ..storage.postgres import storage
|
||||
from .security import current_user
|
||||
|
||||
|
||||
router = APIRouter(prefix="/api/v1/chats", tags=["chats"])
|
||||
|
||||
|
||||
def _encode_cursor(user_id: UUID, chat: Chat) -> str:
|
||||
"""Простой курсор: user_id + id + created_at, base64."""
|
||||
data = {"user_id": str(user_id), "id": str(chat.id), "created_at": chat.created_at.isoformat()}
|
||||
return base64.urlsafe_b64encode(json.dumps(data).encode()).decode()
|
||||
|
||||
|
||||
def _decode_cursor(user_id: UUID, cursor: str) -> tuple:
|
||||
try:
|
||||
data = json.loads(base64.urlsafe_b64decode(cursor.encode()).decode())
|
||||
if data.get("user_id") != str(user_id):
|
||||
raise ValueError("cursor_user_mismatch")
|
||||
return UUID(data["id"]), data["created_at"]
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
|
||||
|
||||
@router.post(
|
||||
path="",
|
||||
summary="Создать чат",
|
||||
response_model=Chat,
|
||||
status_code=201,
|
||||
)
|
||||
def create_chat(
|
||||
payload: CreateChat,
|
||||
user: User = Depends(current_user),
|
||||
) -> Chat:
|
||||
"""Вызывающий должен входить в member_ids"""
|
||||
user_id = user.id
|
||||
if user_id not in payload.member_ids:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
if len(set(payload.member_ids)) != len(payload.member_ids):
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
try:
|
||||
return storage.create_chat(payload.title, list(payload.member_ids))
|
||||
except ValueError:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
|
||||
|
||||
@router.get(
|
||||
path="",
|
||||
summary="Получить список чатов текущего пользователя",
|
||||
response_model=ChatPage,
|
||||
)
|
||||
def list_chats(
|
||||
user: User = Depends(current_user),
|
||||
limit: int = Query(50, ge=1, le=100),
|
||||
cursor: str | None = None,
|
||||
) -> ChatPage:
|
||||
user_id = user.id
|
||||
chats = storage.list_chats_for_user(user_id)
|
||||
if cursor:
|
||||
cid, ccreated = _decode_cursor(user_id, cursor)
|
||||
chats = [c for c in chats if (c.created_at.isoformat(), str(c.id)) > (ccreated, str(cid))]
|
||||
page = chats[:limit]
|
||||
next_cursor = _encode_cursor(user_id, page[-1]) if len(chats) > limit else None
|
||||
return ChatPage(items=page, next_cursor=next_cursor)
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/{chat_id}",
|
||||
summary="Получить доступный чат по идентификатору",
|
||||
response_model=Chat,
|
||||
)
|
||||
def get_chat(
|
||||
chat_id: UUID,
|
||||
user: User = Depends(current_user),
|
||||
) -> Chat:
|
||||
chat = storage.get_chat(chat_id)
|
||||
if chat is None or user.id not in chat.member_ids:
|
||||
raise HTTPException(status_code=404, detail="not_found")
|
||||
return chat
|
||||
@@ -0,0 +1,38 @@
|
||||
from fastapi import APIRouter
|
||||
from ..models.schemas import Health
|
||||
from ..storage import db as _db
|
||||
from ..storage.sessions import _redis_client, _store
|
||||
|
||||
|
||||
router = APIRouter(tags=["health"])
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/health/live",
|
||||
summary="Проверка жизнеспособности процесса",
|
||||
response_model=Health,
|
||||
)
|
||||
def liveness() -> Health:
|
||||
"""Процесс жив"""
|
||||
return Health(status="ok")
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/health/ready",
|
||||
summary="Проверка готовности принимать трафик",
|
||||
response_model=Health,
|
||||
)
|
||||
def readiness() -> Health:
|
||||
"""200, если PostgreSQL и (в режиме redis) Redis доступны.
|
||||
|
||||
При недоступности зависимости исключение вылетает наверх, и main.py
|
||||
конвертирует его в 503 с телом Error из contracts/openapi.json.
|
||||
"""
|
||||
with _db.connection() as conn, conn.cursor() as cur:
|
||||
cur.execute("SELECT 1")
|
||||
cur.fetchone()
|
||||
if _store() == "redis":
|
||||
# _redis_client() сам поднимает RuntimeError("redis_unavailable")
|
||||
# при ошибке; main.runtime_error_handler → 503 Error.
|
||||
_redis_client().ping()
|
||||
return Health(status="ok")
|
||||
@@ -0,0 +1,72 @@
|
||||
import base64
|
||||
import json
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query
|
||||
from ..models.schemas import CreateMessage, Message, MessagePage, User
|
||||
from ..storage.postgres import storage
|
||||
from .security import current_user
|
||||
|
||||
|
||||
router = APIRouter(prefix="/api/v1/chats", tags=["messages"])
|
||||
|
||||
|
||||
def _require_member(chat_id: UUID, user_id: UUID):
|
||||
chat = storage.get_chat(chat_id)
|
||||
if chat is None or user_id not in chat.member_ids:
|
||||
raise HTTPException(status_code=404, detail="not_found")
|
||||
return chat
|
||||
|
||||
|
||||
def _encode_cursor(chat_id: UUID, message: Message) -> str:
|
||||
data = {"chat_id": str(chat_id), "id": str(message.id), "created_at": message.created_at.isoformat()}
|
||||
return base64.urlsafe_b64encode(json.dumps(data).encode()).decode()
|
||||
|
||||
|
||||
def _decode_cursor(chat_id: UUID, cursor: str) -> tuple:
|
||||
try:
|
||||
data = json.loads(base64.urlsafe_b64decode(cursor.encode()).decode())
|
||||
if data.get("chat_id") != str(chat_id):
|
||||
raise ValueError("cursor_chat_mismatch")
|
||||
return datetime.fromisoformat(data["created_at"]), UUID(data["id"])
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
|
||||
|
||||
@router.post(
|
||||
path="/{chat_id}/messages",
|
||||
summary="Отправить сообщение в чат",
|
||||
response_model=Message,
|
||||
status_code=201,
|
||||
)
|
||||
def create_message(
|
||||
chat_id: UUID,
|
||||
payload: CreateMessage,
|
||||
user: User = Depends(current_user),
|
||||
) -> Message:
|
||||
_require_member(chat_id, user.id)
|
||||
if not payload.text.strip():
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
return storage.add_message(chat_id, user.id, payload.text)
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/{chat_id}/messages",
|
||||
summary="Получить историю сообщений чата",
|
||||
response_model=MessagePage,
|
||||
)
|
||||
def list_messages(
|
||||
chat_id: UUID,
|
||||
user: User = Depends(current_user),
|
||||
limit: int = Query(50, ge=1, le=100),
|
||||
cursor: str | None = None,
|
||||
) -> MessagePage:
|
||||
"""Keyset-пагинация в SQL: (created_at, id) по возрастанию, без полного scan истории."""
|
||||
_require_member(chat_id, user.id)
|
||||
after = _decode_cursor(chat_id, cursor) if cursor else None
|
||||
# Берём limit+1, чтобы понять, есть ли следующая страница
|
||||
rows = storage.list_messages_page(chat_id, limit + 1, after=after)
|
||||
has_more = len(rows) > limit
|
||||
items = rows[:limit]
|
||||
next_cursor = _encode_cursor(chat_id, items[-1]) if has_more and items else None
|
||||
return MessagePage(items=items, next_cursor=next_cursor)
|
||||
@@ -0,0 +1,24 @@
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import HTTPException, Security
|
||||
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
|
||||
|
||||
from ..models.schemas import User
|
||||
from ..storage.postgres import storage
|
||||
|
||||
bearer_scheme = HTTPBearer(auto_error=False, scheme_name="bearerAuth")
|
||||
|
||||
|
||||
def current_user(
|
||||
credentials: HTTPAuthorizationCredentials | None = Security(bearer_scheme),
|
||||
) -> User:
|
||||
"""Достаёт Bearer-токен и возвращает владельца сессии.
|
||||
|
||||
Basic на бизнес-endpoint не принимается, X-User-Id игнорируется.
|
||||
"""
|
||||
if credentials is None or credentials.scheme.lower() != "bearer":
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
user = storage.get_session_user(credentials.credentials)
|
||||
if user is None:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
return user
|
||||
@@ -0,0 +1,30 @@
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from ..models.schemas import CreateUser, User
|
||||
from ..storage.postgres import storage
|
||||
from .security import current_user
|
||||
|
||||
router = APIRouter(prefix="/api/v1", tags=["users"])
|
||||
|
||||
|
||||
@router.post(
|
||||
path="/users",
|
||||
summary="Создать пользователя",
|
||||
response_model=User,
|
||||
status_code=201,
|
||||
)
|
||||
def register_user(payload: CreateUser) -> User:
|
||||
"""Публичная регистрация."""
|
||||
try:
|
||||
return storage.create_user(payload.username, payload.display_name, payload.password)
|
||||
except ValueError:
|
||||
raise HTTPException(status_code=409, detail="conflict")
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/users/me",
|
||||
summary="Получить текущего пользователя",
|
||||
response_model=User,
|
||||
)
|
||||
def current_user_me(user: User = Depends(current_user)) -> User:
|
||||
"""Текущий пользователь по Bearer-сессии."""
|
||||
return user
|
||||
+198
@@ -0,0 +1,198 @@
|
||||
import logging
|
||||
import os
|
||||
import signal
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.openapi.utils import get_openapi
|
||||
from fastapi.responses import JSONResponse
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
import psycopg
|
||||
import uvicorn
|
||||
from .api import auth, chats, health, messages, users
|
||||
from .storage.db import init_schema, init_pool, close_pool
|
||||
|
||||
|
||||
# --- Логирование: структурированный stdout, без содержимого сообщений ---
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format="%(asctime)s %(levelname)s %(name)s %(message)s",
|
||||
stream=sys.stdout,
|
||||
)
|
||||
logger = logging.getLogger("app")
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app: FastAPI):
|
||||
init_pool() # пул соединений PostgreSQL с таймаутами (уровень 4)
|
||||
init_schema() # создать таблицы в БД если их ещё нет
|
||||
logger.info(
|
||||
"event=startup app_env=%s session_store=%s",
|
||||
os.environ.get("APP_ENV", "lab"),
|
||||
os.environ.get("SESSION_STORE", "postgres"),
|
||||
)
|
||||
yield
|
||||
close_pool()
|
||||
logger.info("event=shutdown_complete")
|
||||
|
||||
|
||||
app = FastAPI(
|
||||
title="MTUCI Messenger — lab2",
|
||||
version="1.2.0",
|
||||
lifespan=lifespan,
|
||||
swagger_ui_parameters={"persistAuthorization": True},
|
||||
)
|
||||
|
||||
|
||||
def custom_openapi():
|
||||
if app.openapi_schema:
|
||||
return app.openapi_schema
|
||||
schema = get_openapi(title=app.title, version=app.version, routes=app.routes)
|
||||
app.openapi_schema = schema
|
||||
return schema
|
||||
|
||||
|
||||
app.openapi = custom_openapi
|
||||
|
||||
|
||||
@app.middleware("http")
|
||||
async def observability_middleware(request: Request, call_next):
|
||||
"""X-Request-Id во всех ответах + структурный лог без тела сообщений."""
|
||||
request_id = request.headers.get("X-Request-Id") or uuid.uuid4().hex
|
||||
request.state.request_id = request_id
|
||||
started = time.monotonic()
|
||||
response = await call_next(request)
|
||||
response.headers["X-Request-Id"] = request_id
|
||||
duration_ms = round((time.monotonic() - started) * 1000, 2)
|
||||
# Логируем только метаданные: метод, путь без query, статус, длительность, request_id
|
||||
path = request.url.path
|
||||
logger.info(
|
||||
"event=http method=%s path=%s status=%s duration_ms=%s request_id=%s",
|
||||
request.method,
|
||||
path,
|
||||
response.status_code,
|
||||
duration_ms,
|
||||
request_id,
|
||||
)
|
||||
return response
|
||||
|
||||
|
||||
# Словарь HTTP-кодов → кодов ошибок из контракта
|
||||
_ERROR_CODES = {
|
||||
400: "invalid_request",
|
||||
401: "unauthorized",
|
||||
404: "not_found",
|
||||
409: "conflict",
|
||||
413: "payload_too_large",
|
||||
415: "unsupported_media_type",
|
||||
429: "rate_limited",
|
||||
503: "unavailable",
|
||||
500: "internal_error",
|
||||
}
|
||||
|
||||
|
||||
def _unauthorized_challenge(path: str) -> str:
|
||||
"""Basic — только для POST /api/v1/auth/sessions; остальное — Bearer."""
|
||||
if path == "/api/v1/auth/sessions":
|
||||
return 'Basic realm="messenger", charset="UTF-8"'
|
||||
return 'Bearer realm="messenger"'
|
||||
|
||||
|
||||
def _error_response(
|
||||
status_code: int, message: str, request_id: str, path: str = ""
|
||||
) -> JSONResponse:
|
||||
code = _ERROR_CODES.get(status_code, "internal_error")
|
||||
headers = {}
|
||||
if status_code == 401:
|
||||
headers["WWW-Authenticate"] = _unauthorized_challenge(path)
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content={"error": {"code": code, "message": message, "request_id": request_id}},
|
||||
headers=headers,
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(StarletteHTTPException)
|
||||
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
|
||||
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
|
||||
message = exc.detail if isinstance(exc.detail, str) else "Ошибка"
|
||||
return _error_response(exc.status_code, message, request_id, request.url.path)
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_exception_handler(request: Request, exc: RequestValidationError):
|
||||
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
|
||||
return _error_response(400, "Неверный запрос", request_id, request.url.path)
|
||||
|
||||
|
||||
@app.exception_handler(psycopg.OperationalError)
|
||||
async def db_unavailable_handler(request: Request, exc: psycopg.OperationalError):
|
||||
"""PostgreSQL недоступен → 503 unavailable, без внутренних деталей."""
|
||||
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
|
||||
logger.error(
|
||||
"event=db_unavailable type=%s request_id=%s",
|
||||
type(exc).__name__,
|
||||
request_id,
|
||||
)
|
||||
return _error_response(503, "Зависимость недоступна", request_id, request.url.path)
|
||||
|
||||
|
||||
@app.exception_handler(RuntimeError)
|
||||
async def runtime_error_handler(request: Request, exc: RuntimeError):
|
||||
"""Redis недоступен или конфигурация битая.
|
||||
|
||||
sessions.py поднимает RuntimeError("redis_unavailable") при ошибке Redis.
|
||||
Отдаём 503, чтобы смоук/resilience видели корректный unavailable,
|
||||
а не внутреннюю 500.
|
||||
"""
|
||||
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
|
||||
text = str(exc)
|
||||
if "redis_unavailable" in text:
|
||||
logger.error("event=redis_unavailable request_id=%s", request_id)
|
||||
return _error_response(503, "Зависимость недоступна", request_id, request.url.path)
|
||||
logger.error(
|
||||
"event=runtime_error type=%s request_id=%s",
|
||||
type(exc).__name__,
|
||||
request_id,
|
||||
)
|
||||
return _error_response(500, "Внутренняя ошибка", request_id, request.url.path)
|
||||
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def unhandled_exception_handler(request: Request, exc: Exception):
|
||||
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
|
||||
# Внутренние детали не раскрываем; пишем в лог без секретов
|
||||
logger.error("event=unhandled_exception type=%s request_id=%s", type(exc).__name__, request_id)
|
||||
return _error_response(500, "Внутренняя ошибка", request_id, request.url.path)
|
||||
|
||||
|
||||
app.include_router(health.router)
|
||||
app.include_router(auth.router)
|
||||
app.include_router(users.router)
|
||||
app.include_router(chats.router)
|
||||
app.include_router(messages.router)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
config = uvicorn.Config(
|
||||
"app.main:app",
|
||||
host="0.0.0.0",
|
||||
port=8080,
|
||||
log_level="info",
|
||||
)
|
||||
server = uvicorn.Server(config)
|
||||
|
||||
def _handle_sigterm(signum, frame):
|
||||
"""SIGTERM: логируем и инициируем graceful shutdown uvicorn.
|
||||
|
||||
server.should_exit=True заставляет uvicorn закрыть слушающий сокет
|
||||
(healthcheck перестаёт отвечать) и корректно завершить процесс.
|
||||
"""
|
||||
logger.info("event=sigterm_received signal=%s", signum)
|
||||
server.should_exit = True
|
||||
|
||||
signal.signal(signal.SIGTERM, _handle_sigterm)
|
||||
server.run()
|
||||
@@ -0,0 +1,107 @@
|
||||
from datetime import datetime, timezone
|
||||
from typing import List, Optional
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field, field_serializer
|
||||
|
||||
|
||||
def _to_z(dt: datetime) -> str:
|
||||
"""RFC 3339 UTC с Z, как требует contracts/README.md."""
|
||||
if dt.tzinfo is None:
|
||||
dt = dt.replace(tzinfo=timezone.utc)
|
||||
dt = dt.astimezone(timezone.utc)
|
||||
return dt.isoformat().replace("+00:00", "Z")
|
||||
|
||||
|
||||
class Health(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
status: str
|
||||
|
||||
|
||||
class CreateUser(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
|
||||
display_name: str = Field(min_length=1, max_length=100)
|
||||
password: str = Field(min_length=12, max_length=128)
|
||||
|
||||
|
||||
class User(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
id: UUID
|
||||
username: str
|
||||
display_name: str
|
||||
created_at: datetime
|
||||
|
||||
@field_serializer("created_at")
|
||||
def _ser_created_at(self, dt: datetime) -> str:
|
||||
return _to_z(dt)
|
||||
|
||||
|
||||
class CreateChat(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
title: str = Field(min_length=1, max_length=100)
|
||||
member_ids: List[UUID] = Field(min_length=1, max_length=100)
|
||||
|
||||
|
||||
class Chat(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
id: UUID
|
||||
title: str
|
||||
member_ids: List[UUID]
|
||||
created_at: datetime
|
||||
|
||||
@field_serializer("created_at")
|
||||
def _ser_created_at(self, dt: datetime) -> str:
|
||||
return _to_z(dt)
|
||||
|
||||
|
||||
class CreateMessage(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
text: str = Field(min_length=1, max_length=4000)
|
||||
|
||||
|
||||
class Message(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
id: UUID
|
||||
chat_id: UUID
|
||||
sender_id: UUID
|
||||
text: str
|
||||
created_at: datetime
|
||||
|
||||
@field_serializer("created_at")
|
||||
def _ser_created_at(self, dt: datetime) -> str:
|
||||
return _to_z(dt)
|
||||
|
||||
|
||||
class ChatPage(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
items: List[Chat]
|
||||
next_cursor: Optional[str] = None
|
||||
|
||||
|
||||
class MessagePage(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
items: List[Message]
|
||||
next_cursor: Optional[str] = None
|
||||
|
||||
|
||||
class Session(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
token: str
|
||||
token_type: str = "Bearer"
|
||||
expires_at: datetime
|
||||
user: User
|
||||
|
||||
@field_serializer("expires_at")
|
||||
def _ser_expires_at(self, dt: datetime) -> str:
|
||||
return _to_z(dt)
|
||||
|
||||
|
||||
class ErrorBody(BaseModel):
|
||||
code: str
|
||||
message: str
|
||||
request_id: str
|
||||
|
||||
|
||||
class ErrorResponse(BaseModel):
|
||||
error: ErrorBody
|
||||
@@ -0,0 +1,97 @@
|
||||
import os
|
||||
from contextlib import contextmanager
|
||||
from typing import Iterator
|
||||
|
||||
import psycopg
|
||||
from psycopg_pool import ConnectionPool
|
||||
|
||||
|
||||
_pool: ConnectionPool | None = None
|
||||
|
||||
|
||||
def _dsn() -> str:
|
||||
dsn = os.environ.get("DATABASE_URL")
|
||||
if not dsn:
|
||||
raise RuntimeError("DATABASE_URL is not set")
|
||||
return dsn
|
||||
|
||||
|
||||
def init_pool() -> None:
|
||||
"""Ограниченный пул соединений с таймаутами. Вызывается один раз на старте."""
|
||||
global _pool
|
||||
if _pool is not None:
|
||||
return
|
||||
_pool = ConnectionPool(
|
||||
conninfo=_dsn(),
|
||||
min_size=2,
|
||||
max_size=10,
|
||||
timeout=5.0,
|
||||
max_idle=300.0,
|
||||
kwargs={"options": "-c statement_timeout=5000"},
|
||||
open=True,
|
||||
)
|
||||
|
||||
|
||||
def close_pool() -> None:
|
||||
global _pool
|
||||
if _pool is not None:
|
||||
_pool.close()
|
||||
_pool = None
|
||||
|
||||
|
||||
@contextmanager
|
||||
def connection() -> Iterator[psycopg.Connection]:
|
||||
"""Соединение из пула; autocommit=False для явных транзакций."""
|
||||
if _pool is None:
|
||||
init_pool()
|
||||
assert _pool is not None
|
||||
with _pool.connection() as conn:
|
||||
yield conn
|
||||
|
||||
|
||||
SCHEMA_SQL = """
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id UUID PRIMARY KEY,
|
||||
username TEXT NOT NULL UNIQUE,
|
||||
display_name TEXT NOT NULL,
|
||||
password_hash TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS chats (
|
||||
id UUID PRIMARY KEY,
|
||||
title TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS chat_members (
|
||||
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS messages (
|
||||
id UUID PRIMARY KEY,
|
||||
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
text TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_messages_chat_created
|
||||
ON messages (chat_id, created_at, id);
|
||||
|
||||
-- sessions остаются как fallback, если SESSION_STORE=postgres.
|
||||
CREATE TABLE IF NOT EXISTS sessions (
|
||||
token TEXT PRIMARY KEY,
|
||||
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
expires_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
"""
|
||||
|
||||
|
||||
def init_schema() -> None:
|
||||
"""Идемпотентная миграция: запускается на старте приложения."""
|
||||
with connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute(SCHEMA_SQL)
|
||||
conn.commit()
|
||||
@@ -0,0 +1,177 @@
|
||||
import hashlib
|
||||
import hmac
|
||||
import secrets
|
||||
import threading
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from typing import Dict, List, Optional
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
from ..models.schemas import Chat, Message, User
|
||||
|
||||
|
||||
def now_utc() -> datetime:
|
||||
"""Время сервера в UTC с суффиксом Z на выходе."""
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
# --- Password KDF (stdlib scrypt) ---
|
||||
_SCRYPT_N = 2 ** 14
|
||||
_SCRYPT_R = 8
|
||||
_SCRYPT_P = 1
|
||||
_SCRYPT_DKLEN = 32
|
||||
|
||||
|
||||
def _hash_password(password: str) -> str:
|
||||
salt = secrets.token_bytes(16)
|
||||
dk = hashlib.scrypt(
|
||||
password.encode("utf-8"),
|
||||
salt=salt,
|
||||
n=_SCRYPT_N,
|
||||
r=_SCRYPT_R,
|
||||
p=_SCRYPT_P,
|
||||
dklen=_SCRYPT_DKLEN,
|
||||
)
|
||||
return "scrypt$%d$%d$%d$%s$%s" % (
|
||||
_SCRYPT_N, _SCRYPT_R, _SCRYPT_P,
|
||||
salt.hex(), dk.hex(),
|
||||
)
|
||||
|
||||
|
||||
def _verify_password(password: str, stored: str) -> bool:
|
||||
try:
|
||||
scheme, n, r, p, salt_hex, dk_hex = stored.split("$")
|
||||
if scheme != "scrypt":
|
||||
return False
|
||||
dk = hashlib.scrypt(
|
||||
password.encode("utf-8"),
|
||||
salt=bytes.fromhex(salt_hex),
|
||||
n=int(n), r=int(r), p=int(p),
|
||||
dklen=len(bytes.fromhex(dk_hex)),
|
||||
)
|
||||
return hmac.compare_digest(dk.hex(), dk_hex)
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
class MemoryStorage:
|
||||
"""Потокобезопасное In-memory хранилище пользователей, чатов, сообщений и сессий. Все данные исчезают при перезапуске процесса"""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._lock = threading.RLock()
|
||||
self._users: Dict[UUID, User] = {}
|
||||
self._usernames: Dict[str, UUID] = {}
|
||||
self._passwords: Dict[UUID, str] = {}
|
||||
self._chats: Dict[UUID, Chat] = {}
|
||||
self._messages: Dict[UUID, List[Message]] = {}
|
||||
# token -> (user_id, expires_at)
|
||||
self._sessions: Dict[str, tuple] = {}
|
||||
|
||||
# ---------- Пользователи ----------
|
||||
def create_user(self, username: str, display_name: str, password: str) -> User:
|
||||
with self._lock:
|
||||
if username in self._usernames:
|
||||
raise ValueError("username_taken")
|
||||
user = User(
|
||||
id=uuid4(),
|
||||
username=username,
|
||||
display_name=display_name,
|
||||
created_at=now_utc(),
|
||||
)
|
||||
self._users[user.id] = user
|
||||
self._usernames[username] = user.id
|
||||
self._passwords[user.id] = _hash_password(password)
|
||||
return user
|
||||
|
||||
def get_user(self, user_id: UUID) -> Optional[User]:
|
||||
with self._lock:
|
||||
return self._users.get(user_id)
|
||||
|
||||
def get_user_by_username(self, username: str) -> Optional[User]:
|
||||
with self._lock:
|
||||
uid = self._usernames.get(username)
|
||||
return self._users.get(uid) if uid else None
|
||||
|
||||
def verify_credentials(self, username: str, password: str) -> Optional[User]:
|
||||
with self._lock:
|
||||
uid = self._usernames.get(username)
|
||||
if uid is None:
|
||||
return None
|
||||
stored = self._passwords.get(uid)
|
||||
if not stored or not _verify_password(password, stored):
|
||||
return None
|
||||
return self._users.get(uid)
|
||||
|
||||
# ---------- Сессии ----------
|
||||
def create_session(self, user_id: UUID, ttl_seconds: int) -> tuple:
|
||||
with self._lock:
|
||||
token = secrets.token_urlsafe(32)
|
||||
expires_at = now_utc() + timedelta(seconds=ttl_seconds)
|
||||
self._sessions[token] = (user_id, expires_at)
|
||||
return token, expires_at
|
||||
|
||||
def get_session_user(self, token: str) -> Optional[User]:
|
||||
with self._lock:
|
||||
entry = self._sessions.get(token)
|
||||
if entry is None:
|
||||
return None
|
||||
user_id, expires_at = entry
|
||||
if expires_at <= now_utc():
|
||||
self._sessions.pop(token, None)
|
||||
return None
|
||||
return self._users.get(user_id)
|
||||
|
||||
def revoke_session(self, token: str) -> None:
|
||||
with self._lock:
|
||||
self._sessions.pop(token, None)
|
||||
|
||||
# ---------- Чаты ----------
|
||||
def create_chat(self, title: str, member_ids: List[UUID]) -> Chat:
|
||||
with self._lock:
|
||||
for uid in member_ids:
|
||||
if uid not in self._users:
|
||||
raise ValueError("unknown_member")
|
||||
chat = Chat(
|
||||
id=uuid4(),
|
||||
title=title,
|
||||
member_ids=list(member_ids),
|
||||
created_at=now_utc(),
|
||||
)
|
||||
self._chats[chat.id] = chat
|
||||
self._messages[chat.id] = []
|
||||
return chat
|
||||
|
||||
def get_chat(self, chat_id: UUID) -> Optional[Chat]:
|
||||
with self._lock:
|
||||
return self._chats.get(chat_id)
|
||||
|
||||
def list_chats_for_user(self, user_id: UUID) -> List[Chat]:
|
||||
with self._lock:
|
||||
chats = [c for c in self._chats.values() if user_id in c.member_ids]
|
||||
chats.sort(key=lambda c: (c.created_at, str(c.id)))
|
||||
return chats
|
||||
|
||||
# ---------- Сообщения ----------
|
||||
def add_message(self, chat_id: UUID, sender_id: UUID, text: str) -> Message:
|
||||
"""Улучшение Трека 1: список сообщений хранится уже отсортированным.
|
||||
created_at монотонен в пределах одного процесса, поэтому append
|
||||
сохраняет порядок (created_at, id) по возрастанию — сортировка на
|
||||
чтении не нужна. При конкурентных вставках под RLock порядок
|
||||
сохраняется, но монотонность часов не гарантируется контрактом."""
|
||||
with self._lock:
|
||||
message = Message(
|
||||
id=uuid4(),
|
||||
chat_id=chat_id,
|
||||
sender_id=sender_id,
|
||||
text=text,
|
||||
created_at=now_utc(),
|
||||
)
|
||||
self._messages.setdefault(chat_id, []).append(message)
|
||||
return message
|
||||
|
||||
def list_messages(self, chat_id: UUID) -> List[Message]:
|
||||
with self._lock:
|
||||
# Без пересортировки: список уже в порядке (created_at, id).
|
||||
return list(self._messages.get(chat_id, []))
|
||||
|
||||
|
||||
storage = MemoryStorage() # единственный экземпляр хранилища на процесс
|
||||
@@ -0,0 +1,267 @@
|
||||
import hashlib
|
||||
import hmac
|
||||
import secrets
|
||||
import threading
|
||||
from datetime import datetime, timezone
|
||||
from typing import List, Optional
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
from ..models.schemas import Chat, Message, User
|
||||
from .db import connection
|
||||
from .sessions import (
|
||||
create_session as _sess_create,
|
||||
get_session_user as _sess_get,
|
||||
revoke_session as _sess_revoke,
|
||||
)
|
||||
|
||||
|
||||
def now_utc() -> datetime:
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
# --- Password KDF (stdlib scrypt) ---
|
||||
_SCRYPT_N = 2 ** 14
|
||||
_SCRYPT_R = 8
|
||||
_SCRYPT_P = 1
|
||||
_SCRYPT_DKLEN = 32
|
||||
|
||||
|
||||
def _hash_password(password: str) -> str:
|
||||
salt = secrets.token_bytes(16)
|
||||
dk = hashlib.scrypt(
|
||||
password.encode("utf-8"),
|
||||
salt=salt,
|
||||
n=_SCRYPT_N, r=_SCRYPT_R, p=_SCRYPT_P, dklen=_SCRYPT_DKLEN,
|
||||
)
|
||||
return "scrypt$%d$%d$%d$%s$%s" % (
|
||||
_SCRYPT_N, _SCRYPT_R, _SCRYPT_P, salt.hex(), dk.hex(),
|
||||
)
|
||||
|
||||
|
||||
def _verify_password(password: str, stored: str) -> bool:
|
||||
try:
|
||||
scheme, n, r, p, salt_hex, dk_hex = stored.split("$")
|
||||
if scheme != "scrypt":
|
||||
return False
|
||||
dk = hashlib.scrypt(
|
||||
password.encode("utf-8"),
|
||||
salt=bytes.fromhex(salt_hex),
|
||||
n=int(n), r=int(r), p=int(p),
|
||||
dklen=len(bytes.fromhex(dk_hex)),
|
||||
)
|
||||
return hmac.compare_digest(dk.hex(), dk_hex)
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def _row_to_user(row) -> User:
|
||||
return User(id=row[0], username=row[1], display_name=row[2], created_at=row[3])
|
||||
|
||||
|
||||
def _row_to_chat(row, member_ids: List[UUID]) -> Chat:
|
||||
return Chat(id=row[0], title=row[1], member_ids=member_ids, created_at=row[2])
|
||||
|
||||
|
||||
def _row_to_message(row) -> Message:
|
||||
return Message(
|
||||
id=row[0], chat_id=row[1], sender_id=row[2],
|
||||
text=row[3], created_at=row[4],
|
||||
)
|
||||
|
||||
|
||||
class PostgresStorage:
|
||||
"""Потокобезопасная обёртка; параллелизм обеспечивает PostgreSQL."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._lock = threading.RLock()
|
||||
|
||||
# ---------- Пользователи ----------
|
||||
def create_user(self, username: str, display_name: str, password: str) -> User:
|
||||
with self._lock, connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
# SELECT-проверка + INSERT в одной транзакции; уникальный индекс
|
||||
# users.username отсекает гонку на уровне БД (UniqueViolation).
|
||||
cur.execute("SELECT 1 FROM users WHERE username = %s", (username,))
|
||||
if cur.fetchone() is not None:
|
||||
raise ValueError("username_taken")
|
||||
user = User(
|
||||
id=uuid4(), username=username,
|
||||
display_name=display_name, created_at=now_utc(),
|
||||
)
|
||||
try:
|
||||
cur.execute(
|
||||
"INSERT INTO users (id, username, display_name, password_hash, created_at)"
|
||||
" VALUES (%s, %s, %s, %s, %s)",
|
||||
(user.id, user.username, user.display_name,
|
||||
_hash_password(password), user.created_at),
|
||||
)
|
||||
except Exception as exc:
|
||||
# Параллельная регистрация того же username: уникальный индекс
|
||||
# выбросил UniqueViolation — превращаем в доменную ошибку.
|
||||
if exc.__class__.__name__ == "UniqueViolation":
|
||||
raise ValueError("username_taken")
|
||||
raise
|
||||
conn.commit()
|
||||
return user
|
||||
|
||||
def get_user(self, user_id: UUID) -> Optional[User]:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
|
||||
(user_id,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
return _row_to_user(row) if row else None
|
||||
|
||||
def get_user_by_username(self, username: str) -> Optional[User]:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, username, display_name, created_at FROM users WHERE username = %s",
|
||||
(username,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
return _row_to_user(row) if row else None
|
||||
|
||||
def verify_credentials(self, username: str, password: str) -> Optional[User]:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, username, display_name, created_at, password_hash"
|
||||
" FROM users WHERE username = %s",
|
||||
(username,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
if not _verify_password(password, row[4]):
|
||||
return None
|
||||
return _row_to_user(row[:4])
|
||||
|
||||
# ---------- Сессии (Redis или PostgreSQL — см. storage/sessions.py) ----------
|
||||
# Тонкие делегаты: роутеры продолжают вызывать storage.create_session(...),
|
||||
# storage.get_session_user(...), storage.revoke_session(...) без изменений.
|
||||
def create_session(self, user_id: UUID, ttl_seconds: int) -> tuple:
|
||||
return _sess_create(user_id, ttl_seconds)
|
||||
|
||||
def get_session_user(self, token: str) -> Optional[User]:
|
||||
return _sess_get(token)
|
||||
|
||||
def revoke_session(self, token: str) -> None:
|
||||
_sess_revoke(token)
|
||||
|
||||
# ---------- Чаты ----------
|
||||
def create_chat(self, title: str, member_ids: List[UUID]) -> Chat:
|
||||
with self._lock, connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
# проверяем всех участников
|
||||
cur.execute(
|
||||
"SELECT id FROM users WHERE id = ANY(%s)",
|
||||
(list(member_ids),),
|
||||
)
|
||||
found = {r[0] for r in cur.fetchall()}
|
||||
if len(found) != len(set(member_ids)):
|
||||
raise ValueError("unknown_member")
|
||||
chat = Chat(
|
||||
id=uuid4(), title=title,
|
||||
member_ids=list(member_ids), created_at=now_utc(),
|
||||
)
|
||||
cur.execute(
|
||||
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)",
|
||||
(chat.id, chat.title, chat.created_at),
|
||||
)
|
||||
cur.executemany(
|
||||
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
|
||||
[(chat.id, uid) for uid in member_ids],
|
||||
)
|
||||
conn.commit()
|
||||
return chat
|
||||
|
||||
def get_chat(self, chat_id: UUID) -> Optional[Chat]:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, title, created_at FROM chats WHERE id = %s",
|
||||
(chat_id,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
cur.execute(
|
||||
"SELECT user_id FROM chat_members WHERE chat_id = %s", (chat_id,),
|
||||
)
|
||||
members = [r[0] for r in cur.fetchall()]
|
||||
return _row_to_chat(row, members)
|
||||
|
||||
def list_chats_for_user(self, user_id: UUID) -> List[Chat]:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT c.id, c.title, c.created_at FROM chats c"
|
||||
" JOIN chat_members m ON m.chat_id = c.id"
|
||||
" WHERE m.user_id = %s ORDER BY c.created_at, c.id",
|
||||
(user_id,),
|
||||
)
|
||||
rows = cur.fetchall()
|
||||
chats = []
|
||||
for row in rows:
|
||||
cur.execute(
|
||||
"SELECT user_id FROM chat_members WHERE chat_id = %s", (row[0],),
|
||||
)
|
||||
members = [r[0] for r in cur.fetchall()]
|
||||
chats.append(_row_to_chat(row, members))
|
||||
return chats
|
||||
|
||||
# ---------- Сообщения ----------
|
||||
def add_message(self, chat_id: UUID, sender_id: UUID, text: str) -> Message:
|
||||
with self._lock, connection() as conn:
|
||||
message = Message(
|
||||
id=uuid4(), chat_id=chat_id, sender_id=sender_id,
|
||||
text=text, created_at=now_utc(),
|
||||
)
|
||||
with conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text, created_at)"
|
||||
" VALUES (%s, %s, %s, %s, %s)",
|
||||
(message.id, message.chat_id, message.sender_id,
|
||||
message.text, message.created_at),
|
||||
)
|
||||
conn.commit()
|
||||
return message
|
||||
|
||||
def list_messages(self, chat_id: UUID) -> List[Message]:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, chat_id, sender_id, text, created_at FROM messages"
|
||||
" WHERE chat_id = %s ORDER BY created_at, id",
|
||||
(chat_id,),
|
||||
)
|
||||
return [_row_to_message(r) for r in cur.fetchall()]
|
||||
|
||||
def list_messages_page(
|
||||
self,
|
||||
chat_id: UUID,
|
||||
limit: int,
|
||||
after: Optional[tuple] = None,
|
||||
) -> List[Message]:
|
||||
"""Keyset-пагинация в SQL
|
||||
|
||||
after = (created_at, id) последней записи предыдущей страницы или None.
|
||||
Запрос использует индекс idx_messages_chat_created (chat_id, created_at, id)
|
||||
и не делает полный scan всей истории на каждую страницу.
|
||||
"""
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
if after is None:
|
||||
cur.execute(
|
||||
"SELECT id, chat_id, sender_id, text, created_at FROM messages"
|
||||
" WHERE chat_id = %s ORDER BY created_at, id LIMIT %s",
|
||||
(chat_id, limit),
|
||||
)
|
||||
else:
|
||||
after_ts, after_id = after
|
||||
cur.execute(
|
||||
"SELECT id, chat_id, sender_id, text, created_at FROM messages"
|
||||
" WHERE chat_id = %s AND (created_at, id) > (%s, %s)"
|
||||
" ORDER BY created_at, id LIMIT %s",
|
||||
(chat_id, after_ts, after_id, limit),
|
||||
)
|
||||
return [_row_to_message(r) for r in cur.fetchall()]
|
||||
|
||||
|
||||
storage = PostgresStorage() # единственный экземпляр на процесс
|
||||
@@ -0,0 +1,143 @@
|
||||
"""Хранилище сессий. Redis (основной режим, lab2 level 4) или PostgreSQL (fallback).
|
||||
|
||||
Ключевое: при недоступности Redis поднимаем RuntimeError("redis_unavailable"),
|
||||
чтобы main.py отдал 503 unavailable, а не 500 internal_error.
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import secrets
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from typing import Optional
|
||||
from uuid import UUID
|
||||
|
||||
from ..models.schemas import User
|
||||
from . import db as _db
|
||||
|
||||
try:
|
||||
import redis as _redis
|
||||
except ImportError: # pragma: no cover
|
||||
_redis = None
|
||||
|
||||
|
||||
_SESSION_PREFIX = "sess:"
|
||||
|
||||
|
||||
def now_utc() -> datetime:
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
def _store() -> str:
|
||||
return os.environ.get("SESSION_STORE", "redis").strip().lower()
|
||||
|
||||
|
||||
def _redis_client():
|
||||
"""Возвращает подключённый клиент Redis или поднимает RuntimeError.
|
||||
|
||||
RuntimeError("redis_unavailable: ...") ловит main.runtime_error_handler → 503.
|
||||
"""
|
||||
if _redis is None:
|
||||
raise RuntimeError("redis_unavailable: redis library is not installed")
|
||||
url = os.environ.get("REDIS_URL", "redis://redis:6379/0")
|
||||
try:
|
||||
client = _redis.from_url(
|
||||
url,
|
||||
decode_responses=True,
|
||||
socket_timeout=2.0,
|
||||
socket_connect_timeout=2.0,
|
||||
)
|
||||
client.ping()
|
||||
return client
|
||||
except _redis.RedisError as exc:
|
||||
raise RuntimeError("redis_unavailable: %s" % type(exc).__name__) from exc
|
||||
|
||||
|
||||
def _user_key(user_id: UUID) -> str:
|
||||
return str(user_id)
|
||||
|
||||
|
||||
def create_session(user_id: UUID, ttl_seconds: int) -> tuple[str, datetime]:
|
||||
token = secrets.token_urlsafe(32)
|
||||
expires_at = now_utc() + timedelta(seconds=ttl_seconds)
|
||||
if _store() == "redis":
|
||||
r = _redis_client()
|
||||
payload = json.dumps({"user_id": _user_key(user_id), "expires_at": expires_at.isoformat()})
|
||||
try:
|
||||
# SETEX: TTL — сама суть Redis-сессий
|
||||
r.setex(_SESSION_PREFIX + token, ttl_seconds, payload)
|
||||
except _redis.RedisError as exc:
|
||||
raise RuntimeError("redis_unavailable: %s" % type(exc).__name__) from exc
|
||||
else:
|
||||
with _db.connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"INSERT INTO sessions (token, user_id, expires_at) VALUES (%s, %s, %s)",
|
||||
(token, user_id, expires_at),
|
||||
)
|
||||
conn.commit()
|
||||
return token, expires_at
|
||||
|
||||
|
||||
def get_session_user(token: str) -> Optional[User]:
|
||||
if _store() == "redis":
|
||||
r = _redis_client()
|
||||
try:
|
||||
raw = r.get(_SESSION_PREFIX + token)
|
||||
except _redis.RedisError as exc:
|
||||
raise RuntimeError("redis_unavailable: %s" % type(exc).__name__) from exc
|
||||
if raw is None:
|
||||
return None
|
||||
try:
|
||||
data = json.loads(raw)
|
||||
user_id = UUID(data["user_id"])
|
||||
expires_at = datetime.fromisoformat(data["expires_at"])
|
||||
except Exception:
|
||||
return None
|
||||
if expires_at <= now_utc():
|
||||
try:
|
||||
r.delete(_SESSION_PREFIX + token)
|
||||
except _redis.RedisError:
|
||||
pass
|
||||
return None
|
||||
return _load_user(user_id)
|
||||
# postgres fallback
|
||||
with _db.connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.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 = %s",
|
||||
(token,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
if row[4] <= now_utc():
|
||||
cur.execute("DELETE FROM sessions WHERE token = %s", (token,))
|
||||
conn.commit()
|
||||
return None
|
||||
return User(id=row[0], username=row[1], display_name=row[2], created_at=row[3])
|
||||
|
||||
|
||||
def revoke_session(token: str) -> None:
|
||||
if _store() == "redis":
|
||||
r = _redis_client()
|
||||
try:
|
||||
r.delete(_SESSION_PREFIX + token)
|
||||
except _redis.RedisError as exc:
|
||||
raise RuntimeError("redis_unavailable: %s" % type(exc).__name__) from exc
|
||||
return
|
||||
with _db.connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute("DELETE FROM sessions WHERE token = %s", (token,))
|
||||
conn.commit()
|
||||
|
||||
|
||||
def _load_user(user_id: UUID) -> Optional[User]:
|
||||
with _db.connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
|
||||
(user_id,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
return User(id=row[0], username=row[1], display_name=row[2], created_at=row[3]) if row else None
|
||||
@@ -0,0 +1,40 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Единая команда запуска собственных тестов.
|
||||
Запускает: test_negative.py, test_concurrency.py.
|
||||
Публичный smoke запускается отдельно."""
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
|
||||
|
||||
def run_one(script, base_url):
|
||||
print("=== %s ===" % script.name)
|
||||
proc = subprocess.run(
|
||||
[sys.executable, str(script), "--base-url", base_url],
|
||||
cwd=str(HERE),
|
||||
)
|
||||
if proc.returncode != 0:
|
||||
print("FAIL: %s" % script.name)
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def main():
|
||||
import argparse
|
||||
p = argparse.ArgumentParser(description="Lab1 student tests (level 4)")
|
||||
p.add_argument("--base-url", default="http://localhost:8080")
|
||||
args = p.parse_args()
|
||||
|
||||
ok = True
|
||||
for script in ("test_negative.py", "test_concurrency.py"):
|
||||
if not run_one(HERE / script, args.base_url):
|
||||
ok = False
|
||||
if not ok:
|
||||
raise SystemExit(1)
|
||||
print("PASS: all student tests (level 4) passed")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,70 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Конкурентный тест: 100 сообщений от 10 клиентов -> ровно 100 уникальных.
|
||||
Проверяет защиту in-memory структур от гонок (RLock)."""
|
||||
import sys
|
||||
import threading
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, arguments, check, run # noqa: E402
|
||||
|
||||
TOTAL_MESSAGES = 100
|
||||
CLIENTS = 10
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments("Lab1 concurrency safety")
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
path = "/api/v1/chats/" + chat["id"]
|
||||
|
||||
# Каждый «клиент» — свой actor (alice/bob) для реалистичной конкуренции
|
||||
actors = [alice, bob]
|
||||
barrier = threading.Barrier(CLIENTS)
|
||||
|
||||
def worker(worker_id):
|
||||
local = Client(args.base_url, args.ca_file, timeout=15)
|
||||
actor = actors[worker_id % len(actors)]
|
||||
barrier.wait() # синхронный старт всех потоков
|
||||
produced = []
|
||||
for i in range(TOTAL_MESSAGES // CLIENTS):
|
||||
text = "c-%02d-%02d-%s" % (worker_id, i, uuid.uuid4().hex[:8])
|
||||
msg = local.message(actor, chat, text)["json"]
|
||||
produced.append(msg)
|
||||
return produced
|
||||
|
||||
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
|
||||
results = list(pool.map(worker, range(CLIENTS)))
|
||||
|
||||
all_ids = [m["id"] for chunk in results for m in chunk]
|
||||
check(len(all_ids) == TOTAL_MESSAGES,
|
||||
"expected %d message ids, got %d" % (TOTAL_MESSAGES, len(all_ids)))
|
||||
check(len(set(all_ids)) == TOTAL_MESSAGES,
|
||||
"duplicate message ids under concurrency: %d unique" % len(set(all_ids)))
|
||||
|
||||
# Читаем всю историю через пагинацию
|
||||
collected = []
|
||||
cursor = None
|
||||
from urllib.parse import quote
|
||||
for _ in range(50):
|
||||
q = path + "/messages?limit=100"
|
||||
if cursor:
|
||||
q += "&cursor=" + quote(cursor, safe="")
|
||||
page = c.call("GET", q, actor=alice, schema="MessagePage")["json"]
|
||||
collected.extend(m["id"] for m in page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
check(len(collected) == TOTAL_MESSAGES,
|
||||
"stored messages: %d, expected %d" % (len(collected), TOTAL_MESSAGES))
|
||||
check(len(set(collected)) == TOTAL_MESSAGES,
|
||||
"stored messages contain duplicates: %d unique" % len(set(collected)))
|
||||
|
||||
print("PASS: lab1 concurrency: %d messages from %d clients, "
|
||||
"%d unique stored and readable" % (TOTAL_MESSAGES, CLIENTS, len(set(collected))))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,587 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Уровень 4 lab2: expiry TTL, конкурентная регистрация, EXPLAIN, недоступность Redis/PostgreSQL.
|
||||
|
||||
Перед запуском:
|
||||
1) в .env выставить SESSION_TTL_SECONDS=5
|
||||
2) docker compose --env-file .env up -d --force-recreate api
|
||||
3) docker exec mtuci-redis redis-cli flushdb
|
||||
4) python student-tests/test_lab2_level4.py --base-url http://localhost:8080
|
||||
5) перед smoke/persistence вернуть SESSION_TTL_SECONDS=3600 и снова up -d --force-recreate api
|
||||
|
||||
Порядок тестов: тяжёлые по данным и конкурентные — ДО expiry-теста,
|
||||
потому что при коротком TTL любой долгий шаг съедает окно жизни сессии.
|
||||
Expiry-тест запускается последним и использует свежие сессии.
|
||||
|
||||
test_explain не зависит от TTL вообще: он сидирует данные напрямую
|
||||
через psql и проверяет план SQL-запроса, а не HTTP-слой.
|
||||
|
||||
test_chat_rollback проверяет транзакционную границу create_chat: он
|
||||
запускает патч-скрипт ВНУТРИ контейнера API (там есть psycopg и
|
||||
DATABASE_URL), monkey-patch-ит psycopg.Cursor.executemany так, чтобы
|
||||
INSERT в chat_members упал ПОСЛЕ успешного INSERT в chats. Затем через
|
||||
psql проверяется, что ни chat, ни chat_members не сохранились.
|
||||
"""
|
||||
import base64
|
||||
import datetime as dt
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, Failure, arguments, check, run # noqa: E402
|
||||
|
||||
# Имя compose-сети проекта: mtuci2026lab2_default (зафиксировано в compose.yaml networks.default.name).
|
||||
COMPOSE_NETWORK = os.environ.get("COMPOSE_NETWORK", "mtuci2026lab2_default")
|
||||
|
||||
# Имя контейнера API (зафиксировано в compose.yaml container_name).
|
||||
API_CONTAINER = os.environ.get("API_CONTAINER", "mtuci-messenger-lab2")
|
||||
|
||||
|
||||
# ---------- 1. Конкурентная регистрация одинакового username ----------
|
||||
def test_concurrent_registration(c):
|
||||
"""Один и тот же username с 8 потоков — ровно одна 201, остальные 409.
|
||||
|
||||
Проверяем ФАКТИЧЕСКИЕ HTTP-коды, а не факт исключения: timeout, 500
|
||||
или неверный формат ответа должны проваливать тест, а не выдаваться
|
||||
за ожидаемый конфликт. Дополнительно сверяем, что в БД создана
|
||||
ровно одна строка пользователя.
|
||||
"""
|
||||
username = "race_" + uuid.uuid4().hex[:10]
|
||||
password = "T3st-" + uuid.uuid4().hex
|
||||
body = {"username": username, "display_name": "Race", "password": password}
|
||||
results = []
|
||||
lock = threading.Lock()
|
||||
|
||||
def one(_):
|
||||
local = Client(c.base, timeout=10)
|
||||
try:
|
||||
r = local.call("POST", "/api/v1/users", (201, 409),
|
||||
body=body, schema="User" if True else None)
|
||||
# schema валидируется только для 2xx; при 409 приходит Error.
|
||||
status = r["status"]
|
||||
except Failure as exc:
|
||||
# Любая иная ошибка (timeout, 500, bad schema) — это не 409.
|
||||
status = "failure:%s" % exc
|
||||
with lock:
|
||||
results.append(status)
|
||||
|
||||
with ThreadPoolExecutor(max_workers=8) as pool:
|
||||
list(pool.map(one, range(8)))
|
||||
|
||||
ok = [r for r in results if r == 201]
|
||||
conflict = [r for r in results if r == 409]
|
||||
bad = [r for r in results if r not in (201, 409)]
|
||||
check(not bad, "unexpected results under concurrent registration: %s" % results)
|
||||
check(len(ok) == 1, "expected exactly one 201, got %s" % results)
|
||||
check(len(conflict) == 7, "expected seven 409, got %s" % results)
|
||||
|
||||
# В БД должна быть ровно одна строка с этим username.
|
||||
dsn = _read_dsn()
|
||||
rows = _scalar(dsn, "SELECT count(*) FROM users WHERE username = '%s';" % username)
|
||||
check(int(rows) == 1,
|
||||
"ожидалась ровно одна строка users для %s, получено %s" % (username, rows))
|
||||
|
||||
|
||||
# ---------- 2. EXPLAIN на реальной БД ----------
|
||||
def _read_dsn() -> str:
|
||||
dsn = os.environ.get("DATABASE_URL")
|
||||
if not dsn:
|
||||
env_file = Path(__file__).resolve().parents[1] / ".env"
|
||||
if env_file.is_file():
|
||||
for line in env_file.read_text(encoding="utf-8").splitlines():
|
||||
line = line.strip()
|
||||
if line.startswith("DATABASE_URL="):
|
||||
dsn = line.split("=", 1)[1].strip()
|
||||
break
|
||||
check(dsn, "DATABASE_URL не найден ни в окружении, ни в .env")
|
||||
# Postgres доступен только внутри compose-сети; одноразовые psql-контейнеры
|
||||
# запускаются в этой же сети, поэтому имя хоста postgres резолвится как есть.
|
||||
return dsn
|
||||
|
||||
|
||||
def _psql(dsn_in_container: str, sql: str) -> str:
|
||||
r = subprocess.run(
|
||||
[
|
||||
"docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"postgres:18-alpine",
|
||||
"psql", dsn_in_container, "-tA", "-c", sql,
|
||||
],
|
||||
capture_output=True, text=True, timeout=120,
|
||||
)
|
||||
return r.stdout + r.stderr
|
||||
|
||||
|
||||
def _scalar(dsn: str, sql: str) -> str:
|
||||
r = subprocess.run(
|
||||
[
|
||||
"docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"postgres:18-alpine",
|
||||
"psql", dsn, "-tA", "-v", "ON_ERROR_STOP=1", "-c", sql,
|
||||
],
|
||||
capture_output=True, text=True, timeout=120,
|
||||
)
|
||||
check(r.returncode == 0, "psql failed:\n" + r.stdout + r.stderr)
|
||||
return r.stdout.strip().splitlines()[-1]
|
||||
|
||||
|
||||
def test_explain(c):
|
||||
"""EXPLAIN (ANALYZE, BUFFERS) истории сообщений на >=10 000 строк.
|
||||
|
||||
Методичка: индекс истории обоснован запросом и EXPLAIN на >=10 000
|
||||
сообщениях. На пустой таблице планировщик выбирает Seq Scan, поэтому
|
||||
тест сам доводит messages до >=10 000 строк и делает ANALYZE.
|
||||
|
||||
Данные сидируются напрямую через psql, без API: тест не зависит от
|
||||
SESSION_TTL_SECONDS и скорости scrypt. Это корректно, потому что
|
||||
EXPLAIN проверяет план SQL-запроса, а не HTTP-слой.
|
||||
"""
|
||||
dsn_in_container = _read_dsn()
|
||||
|
||||
# Смотрим, сколько строк уже есть.
|
||||
have_raw = _psql(dsn_in_container, "SELECT count(*) FROM messages;")
|
||||
have = int(have_raw.strip().splitlines()[-1])
|
||||
print(" в таблице messages сейчас: %d строк" % have)
|
||||
|
||||
target_total = 10_000
|
||||
if have < target_total:
|
||||
need = target_total - have
|
||||
print(" сидируем %d сообщений напрямую через psql ..." % need)
|
||||
|
||||
# Один чат: берём существующий или создаём минимальный.
|
||||
# gen_random_uuid() доступен в PG13+ без расширений.
|
||||
seed_sql = """
|
||||
DO $$
|
||||
DECLARE
|
||||
v_user UUID;
|
||||
v_chat UUID;
|
||||
BEGIN
|
||||
SELECT id INTO v_user FROM users LIMIT 1;
|
||||
IF v_user IS NULL THEN
|
||||
v_user := gen_random_uuid();
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES (v_user, 'seed_' || substr(v_user::text, 1, 8), 'Seed',
|
||||
'scrypt$16384$8$1$00$00', now());
|
||||
END IF;
|
||||
|
||||
SELECT id INTO v_chat FROM chats LIMIT 1;
|
||||
IF v_chat IS NULL THEN
|
||||
v_chat := gen_random_uuid();
|
||||
INSERT INTO chats (id, title, created_at) VALUES (v_chat, 'Seed chat', now());
|
||||
INSERT INTO chat_members (chat_id, user_id) VALUES (v_chat, v_user);
|
||||
END IF;
|
||||
|
||||
-- Доливаем ровно need строк в этот чат.
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(), v_chat, v_user,
|
||||
'seed-' || g, now() - (g || ' milliseconds')::interval
|
||||
FROM generate_series(1, %d) AS g;
|
||||
END $$;
|
||||
""" % need
|
||||
r = subprocess.run(
|
||||
[
|
||||
"docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"postgres:18-alpine",
|
||||
"psql", dsn_in_container, "-c", seed_sql,
|
||||
],
|
||||
capture_output=True, text=True, timeout=120,
|
||||
)
|
||||
seed_out = r.stdout + r.stderr
|
||||
check("ERROR" not in seed_out, "сидирование не удалось:\n" + seed_out)
|
||||
|
||||
# ANALYZE обязателен: без него планировщик не знает реальных размеров.
|
||||
_psql(dsn_in_container, "ANALYZE messages;")
|
||||
_psql(dsn_in_container, "ANALYZE chat_members;")
|
||||
_psql(dsn_in_container, "ANALYZE chats;")
|
||||
print(" сидирование завершено")
|
||||
|
||||
# EXPLAIN по САМОМУ БОЛЬШОМУ чату, чтобы планировщик имел основания
|
||||
# выбрать индекс, а не Seq Scan.
|
||||
biggest = _psql(
|
||||
dsn_in_container,
|
||||
"SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1;",
|
||||
).strip().splitlines()[-1]
|
||||
check(biggest and len(biggest) >= 32, "не удалось выбрать самый большой чат: %r" % biggest)
|
||||
|
||||
sql = (
|
||||
"EXPLAIN (ANALYZE, BUFFERS) "
|
||||
"SELECT id, chat_id, sender_id, text, created_at FROM messages "
|
||||
"WHERE chat_id = '%s' "
|
||||
"ORDER BY created_at, id LIMIT 51;" % biggest
|
||||
)
|
||||
r = subprocess.run(
|
||||
[
|
||||
"docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"postgres:18-alpine",
|
||||
"psql", dsn_in_container, "-c", sql,
|
||||
],
|
||||
capture_output=True, text=True, timeout=120,
|
||||
)
|
||||
out = r.stdout + r.stderr
|
||||
print("EXPLAIN (фрагмент):")
|
||||
for line in out.splitlines()[:12]:
|
||||
print(" ", line)
|
||||
check("Index" in out or "Bitmap Index" in out or "idx_messages_chat_created" in out,
|
||||
"EXPLAIN не показал использования индекса:\n" + out)
|
||||
|
||||
|
||||
# ---------- 3. Rollback составной операции create_chat ----------
|
||||
def test_chat_rollback(c):
|
||||
"""Проверяем, что при падении INSERT в chat_members ПОСЛЕ успешного
|
||||
INSERT в chats не остаётся ни строки чата, ни частичного членства.
|
||||
|
||||
Как добиться ошибки именно на вставке участников, а не на предварительной
|
||||
проверке unknown_member? Проверка `SELECT id FROM users WHERE id = ANY(...)`
|
||||
в postgres.py отсекает неизвестных до INSERT. Значит, нужен сбой именно
|
||||
в executemany.
|
||||
|
||||
Решение: запускаем патч-скрипт ВНУТРИ контейнера API через docker exec —
|
||||
там уже установлен psycopg и доступен DATABASE_URL. Скрипт monkey-patch-ит
|
||||
psycopg.Cursor.executemany так, чтобы он бросил исключение, и вызывает
|
||||
storage.create_chat с двумя реально существующими пользователями.
|
||||
Транзакция дойдёт до INSERT в chats, упадёт на executemany и должна
|
||||
откатиться.
|
||||
|
||||
После этого через psql проверяем:
|
||||
- в таблице chats нет строки с этим title;
|
||||
- в таблице chat_members нет строк с этим chat_id;
|
||||
- через API GET /api/v1/chats пользователь не видит этот чат.
|
||||
"""
|
||||
dsn = _read_dsn()
|
||||
|
||||
# Готовим двух валидных пользователей через API, чтобы FK был валиден.
|
||||
suffix = uuid.uuid4().hex[:10]
|
||||
alice_username = "rb_a_" + suffix
|
||||
bob_username = "rb_b_" + suffix
|
||||
alice_password = "T3st-" + uuid.uuid4().hex
|
||||
bob_password = "T3st-" + uuid.uuid4().hex
|
||||
alice = c.call("POST", "/api/v1/users", 201,
|
||||
body={"username": alice_username, "display_name": "RB-A",
|
||||
"password": alice_password},
|
||||
schema="User")["json"]
|
||||
bob = c.call("POST", "/api/v1/users", 201,
|
||||
body={"username": bob_username, "display_name": "RB-B",
|
||||
"password": bob_password},
|
||||
schema="User")["json"]
|
||||
|
||||
# Уникальный title, чтобы точно найти строку, если rollback не сработает.
|
||||
marker_title = "rollback-chat-" + uuid.uuid4().hex
|
||||
|
||||
# Скрипт запускается ВНУТРИ контейнера API: там есть psycopg и DATABASE_URL.
|
||||
# Патчит executemany так, чтобы он упал после успешного INSERT в chats.
|
||||
patch_script = r'''
|
||||
import os, sys, psycopg
|
||||
from uuid import UUID
|
||||
|
||||
_orig = psycopg.Cursor.executemany
|
||||
def boom(self, *args, **kwargs):
|
||||
raise RuntimeError("patched_executemany_failure")
|
||||
psycopg.Cursor.executemany = boom
|
||||
|
||||
sys.path.insert(0, "/app/src")
|
||||
from app.storage.postgres import storage
|
||||
|
||||
try:
|
||||
storage.create_chat(os.environ["RB_TITLE"],
|
||||
[UUID(os.environ["RB_ALICE"]), UUID(os.environ["RB_BOB"])])
|
||||
except RuntimeError as exc:
|
||||
if "patched_executemany_failure" in str(exc):
|
||||
print("PATCHED_FAILURE_OK"); sys.exit(0)
|
||||
raise
|
||||
except Exception as exc:
|
||||
print("UNEXPECTED:%s:%s" % (type(exc).__name__, exc)); sys.exit(2)
|
||||
print("NO_FAILURE"); sys.exit(3)
|
||||
'''
|
||||
|
||||
proc = subprocess.run(
|
||||
["docker", "exec",
|
||||
"-e", "RB_TITLE=" + marker_title,
|
||||
"-e", "RB_ALICE=" + alice["id"],
|
||||
"-e", "RB_BOB=" + bob["id"],
|
||||
API_CONTAINER,
|
||||
"python", "-c", patch_script],
|
||||
capture_output=True, text=True, timeout=60,
|
||||
)
|
||||
out = (proc.stdout + proc.stderr).strip()
|
||||
print(" rollback-процесс: exit=%d, out=%r" % (proc.returncode, out[:200]))
|
||||
check("PATCHED_FAILURE_OK" in out,
|
||||
"не удалось вызвать ошибку именно на executemany: %s" % out)
|
||||
|
||||
# Проверяем в БД: ни chats, ни chat_members с этим маркером не осталось.
|
||||
chats_count = _scalar(
|
||||
dsn,
|
||||
"SELECT count(*) FROM chats WHERE title = '%s';" % marker_title,
|
||||
)
|
||||
check(int(chats_count) == 0,
|
||||
"rollback не сработал: строка chats с title=%s осталась (%s)" % (marker_title, chats_count))
|
||||
|
||||
members_count = _scalar(
|
||||
dsn,
|
||||
"SELECT count(*) FROM chat_members cm "
|
||||
"JOIN chats c ON c.id = cm.chat_id "
|
||||
"WHERE c.title = '%s';" % marker_title,
|
||||
)
|
||||
check(int(members_count) == 0,
|
||||
"rollback не сработал: остались строки chat_members (%s)" % members_count)
|
||||
|
||||
# Дополнительно: у пользователя нет чата с таким title через API.
|
||||
cred = base64.b64encode((alice_username + ":" + alice_password).encode()).decode()
|
||||
session = c.call("POST", "/api/v1/auth/sessions", 201,
|
||||
headers={"Authorization": "Basic " + cred},
|
||||
schema="Session")["json"]
|
||||
listed = c.call("GET", "/api/v1/chats?limit=100",
|
||||
headers={"Authorization": "Bearer " + session["token"]},
|
||||
schema="ChatPage")["json"]
|
||||
check(all(item["title"] != marker_title for item in listed["items"]),
|
||||
"чат с маркером rollback виден в списке чатов пользователя")
|
||||
|
||||
|
||||
# ---------- 4. Недоступность Redis (с действующим токеном) ----------
|
||||
def _compose(action, service="redis"):
|
||||
return subprocess.run(
|
||||
["docker", "compose", "--env-file", ".env", action, service],
|
||||
capture_output=True, text=True, timeout=60,
|
||||
)
|
||||
|
||||
|
||||
def _wait_ready(c, timeout=60):
|
||||
deadline = time.monotonic() + timeout
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
c.call("GET", "/health/ready", 200)
|
||||
return
|
||||
except Failure:
|
||||
time.sleep(1)
|
||||
raise Failure("API не вернулся в ready за %d секунд после восстановления зависимости" % timeout)
|
||||
|
||||
|
||||
def test_redis_unavailable(c):
|
||||
"""Останавливаем Redis: /health/ready → 503, действующий токен не работает.
|
||||
|
||||
Важно: используем ЗАРАНЕЕ полученную рабочую сессию, а не заведомо
|
||||
неправильный Bearer. Иначе 401 мог бы получиться и без обращения к Redis.
|
||||
После восстановления Redis прежняя сессия снова должна работать.
|
||||
"""
|
||||
print(" (проверка недоступности Redis: docker compose stop redis на ~6 секунд)")
|
||||
|
||||
# Готовим рабочую сессию ДО остановки Redis.
|
||||
suffix = uuid.uuid4().hex[:10]
|
||||
username = "redis_" + suffix
|
||||
password = "T3st-" + uuid.uuid4().hex
|
||||
c.call("POST", "/api/v1/users", 201,
|
||||
body={"username": username, "display_name": "Redis", "password": password},
|
||||
schema="User")
|
||||
cred = base64.b64encode((username + ":" + password).encode()).decode()
|
||||
session = c.call("POST", "/api/v1/auth/sessions", 201,
|
||||
headers={"Authorization": "Basic " + cred},
|
||||
schema="Session")["json"]
|
||||
token = session["token"]
|
||||
|
||||
# Контроль: до остановки Redis токен рабочий.
|
||||
me = c.call("GET", "/api/v1/users/me", 200,
|
||||
headers={"Authorization": "Bearer " + token},
|
||||
schema="User")["json"]
|
||||
check(me["username"] == username, "токен должен принадлежать созданному пользователю")
|
||||
|
||||
stopped = _compose("stop", "redis")
|
||||
check(stopped.returncode == 0,
|
||||
"docker compose stop redis не сработал:\n" + (stopped.stdout + stopped.stderr))
|
||||
|
||||
try:
|
||||
time.sleep(3)
|
||||
# /health/ready должен стать 503.
|
||||
ready = c.call("GET", "/health/ready", 503)
|
||||
check(ready["status"] == 503, "readiness must be 503 without Redis")
|
||||
|
||||
# Действующий токен при мёртвом Redis не должен давать доступ:
|
||||
# сервер не может проверить сессию и обязан ответить 503.
|
||||
r = c.call("GET", "/api/v1/users/me", (401, 503),
|
||||
headers={"Authorization": "Bearer " + token})
|
||||
check(r["status"] == 503,
|
||||
"запрос с действующим токеном при мёртвом Redis должен быть 503, получено %s" % r["status"])
|
||||
finally:
|
||||
# Только восстановление. Никаких return/break/continue внутри finally.
|
||||
started = _compose("start", "redis")
|
||||
check(started.returncode == 0,
|
||||
"docker compose start redis не сработал:\n" + (started.stdout + started.stderr))
|
||||
|
||||
# Ждём готовности — УЖЕ ВНЕ finally.
|
||||
_wait_ready(c, timeout=60)
|
||||
|
||||
# Прежний токен снова должен работать: сессия пережила рестарт Redis (AOF).
|
||||
me2 = c.call("GET", "/api/v1/users/me", 200,
|
||||
headers={"Authorization": "Bearer " + token},
|
||||
schema="User")["json"]
|
||||
check(me2["id"] == me["id"], "прежняя сессия должна снова работать после восстановления Redis")
|
||||
|
||||
|
||||
# ---------- 5. Недоступность PostgreSQL ----------
|
||||
def test_postgres_unavailable(c):
|
||||
"""Останавливаем PostgreSQL: /health/ready → 503, действующий токен → 503.
|
||||
|
||||
Проверяем:
|
||||
- /health/ready возвращает 503;
|
||||
- запрос с действующим токеном возвращает 503 в пределах таймаута;
|
||||
- анонимный запрос не получает доступ;
|
||||
- после запуска БД прежний токен работает, ранее записанные данные сохранены.
|
||||
Восстановление БД выполняется в finally, чтобы не оставлять стенд остановленным.
|
||||
"""
|
||||
print(" (проверка недоступности PostgreSQL: docker compose stop postgres на ~6 секунд)")
|
||||
|
||||
# Готовим рабочую сессию и сообщение ДО остановки БД.
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
marker = "pgdown-" + uuid.uuid4().hex
|
||||
sent = c.message(alice, chat, marker)["json"]
|
||||
|
||||
# Контроль: до остановки всё работает.
|
||||
c.call("GET", "/api/v1/users/me", 200, actor=alice, schema="User")
|
||||
|
||||
stopped = _compose("stop", "postgres")
|
||||
check(stopped.returncode == 0,
|
||||
"docker compose stop postgres не сработал:\n" + (stopped.stdout + stopped.stderr))
|
||||
|
||||
try:
|
||||
time.sleep(3)
|
||||
# /health/ready должен стать 503.
|
||||
ready = c.call("GET", "/health/ready", 503)
|
||||
check(ready["status"] == 503, "readiness must be 503 without PostgreSQL")
|
||||
|
||||
# Запрос с действующим токеном: 503 в пределах таймаута.
|
||||
t0 = time.monotonic()
|
||||
r = c.call("GET", "/api/v1/users/me", 503, actor=alice)
|
||||
elapsed = time.monotonic() - t0
|
||||
check(r["status"] == 503,
|
||||
"запрос с действующим токеном при мёртвой БД должен быть 503")
|
||||
# statement_timeout=5000 + пул timeout=5.0: укладываемся в разумный предел.
|
||||
check(elapsed < 30, "ответ при мёртвой БД занял %.1f c, ожидался в пределах таймаута" % elapsed)
|
||||
|
||||
# Анонимный запрос не получает доступ.
|
||||
anon = c.call("GET", "/api/v1/users/me", (401, 503))
|
||||
check(anon["status"] in (401, 503),
|
||||
"анонимный запрос при мёртвой БД должен быть 401 или 503, получено %s" % anon["status"])
|
||||
finally:
|
||||
started = _compose("start", "postgres")
|
||||
check(started.returncode == 0,
|
||||
"docker compose start postgres не сработал:\n" + (started.stdout + started.stderr))
|
||||
|
||||
# Ждём готовности — УЖЕ ВНЕ finally.
|
||||
_wait_ready(c, timeout=60)
|
||||
|
||||
# Прежний токен работает, ранее записанное сообщение сохранено.
|
||||
c.call("GET", "/api/v1/users/me", 200, actor=alice, schema="User")
|
||||
messages = c.call("GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100",
|
||||
actor=bob, schema="MessagePage")["json"]["items"]
|
||||
check(any(m["id"] == sent["id"] and m["text"] == marker for m in messages),
|
||||
"ранее записанное сообщение не найдено после восстановления PostgreSQL")
|
||||
|
||||
|
||||
# ---------- 6. Expiry TTL ----------
|
||||
def test_short_ttl_expiry(c):
|
||||
"""TTL=5. Проверяем полный цикл: токен валиден -> истекает -> 401.
|
||||
|
||||
Идёт ПОСЛЕДНИМ: при коротком TTL любая долгая подготовка съедает
|
||||
окно жизни сессии, поэтому соседние тесты работают раньше.
|
||||
"""
|
||||
suffix = uuid.uuid4().hex[:10]
|
||||
username = "ttl_" + suffix
|
||||
password = "T3st-" + uuid.uuid4().hex
|
||||
user = c.call("POST", "/api/v1/users", 201,
|
||||
body={"username": username, "display_name": "TTL", "password": password},
|
||||
schema="User")["json"]
|
||||
cred = base64.b64encode((username + ":" + password).encode()).decode()
|
||||
session = c.call("POST", "/api/v1/auth/sessions", 201,
|
||||
headers={"Authorization": "Basic " + cred},
|
||||
schema="Session")["json"]
|
||||
token = session["token"]
|
||||
|
||||
# Контроль: сервер выдал короткий TTL, иначе тест бессмыслен.
|
||||
expires_at = dt.datetime.fromisoformat(session["expires_at"].replace("Z", "+00:00"))
|
||||
ttl_actual = (expires_at - dt.datetime.now(dt.timezone.utc)).total_seconds()
|
||||
check(3.0 <= ttl_actual <= 10,
|
||||
"SESSION_TTL_SECONDS не короткий (получено %.1f c). "
|
||||
"Поставьте, пожалуйста, SESSION_TTL_SECONDS=5 в .env и перезапустите API (команда: docker compose --env-file .env up -d api)." % ttl_actual)
|
||||
|
||||
# До истечения токен должен работать.
|
||||
me = c.call("GET", "/api/v1/users/me", 200,
|
||||
headers={"Authorization": "Bearer " + token},
|
||||
schema="User")["json"]
|
||||
check(me["id"] == user["id"], "token must identify its owner before expiry")
|
||||
|
||||
# Ждём гарантированного истечения TTL + запас.
|
||||
remaining = (expires_at - dt.datetime.now(dt.timezone.utc)).total_seconds()
|
||||
time.sleep(max(remaining, 0.0) + 1.0)
|
||||
|
||||
# Истёкший токен — 401.
|
||||
c.call("GET", "/api/v1/users/me", 401,
|
||||
headers={"Authorization": "Bearer " + token})
|
||||
|
||||
# Второй вход тем же пользователем даёт рабочий токен: истёк именно
|
||||
# первый токен, а не пользователь/хранилище целиком.
|
||||
session2 = c.call("POST", "/api/v1/auth/sessions", 201,
|
||||
headers={"Authorization": "Basic " + cred},
|
||||
schema="Session")["json"]
|
||||
c.call("GET", "/api/v1/users/me", 200,
|
||||
headers={"Authorization": "Bearer " + session2["token"]},
|
||||
schema="User")
|
||||
|
||||
|
||||
# ---------- main ----------
|
||||
def main():
|
||||
args = arguments("Lab2 level 4 checks", configure=_configure)
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
|
||||
# Порядок и режимы:
|
||||
# --only-expiry — ТОЛЬКО expiry-тест (запускать при SESSION_TTL_SECONDS=5)
|
||||
# --skip-expiry — все тяжёлые тесты, без expiry (при SESSION_TTL_SECONDS=3600)
|
||||
# без флагов — сначала тяжёлые, expiry последним (при SESSION_TTL_SECONDS=5
|
||||
# это сработает только если тяжёлые тесты успевают до истечения TTL,
|
||||
# поэтому на практике используйте --only-expiry/--skip-expiry)
|
||||
run_expiry = not args.skip_expiry
|
||||
run_others = not args.only_expiry
|
||||
|
||||
if run_others:
|
||||
print("=== test_concurrent_registration ===")
|
||||
test_concurrent_registration(c)
|
||||
print("PASS: concurrent registration produces exactly one user")
|
||||
|
||||
print("=== test_chat_rollback ===")
|
||||
test_chat_rollback(c)
|
||||
print("PASS: create_chat rollback leaves no chat and no partial membership")
|
||||
|
||||
print("=== test_explain ===")
|
||||
test_explain(c)
|
||||
print("PASS: EXPLAIN uses idx_messages_chat_created")
|
||||
|
||||
print("=== test_redis_unavailable ===")
|
||||
test_redis_unavailable(c)
|
||||
print("PASS: readiness 503 без Redis, действующий токен отвергнут, затем восстановление")
|
||||
|
||||
print("=== test_postgres_unavailable ===")
|
||||
test_postgres_unavailable(c)
|
||||
print("PASS: readiness 503 без PostgreSQL, данные и сессия сохранены")
|
||||
|
||||
if run_expiry:
|
||||
print("=== test_short_ttl_expiry ===")
|
||||
test_short_ttl_expiry(c)
|
||||
print("PASS: session valid before TTL, expires after TTL, 401 on expired token")
|
||||
|
||||
print("PASS: all requested lab2 level-4 checks passed")
|
||||
|
||||
|
||||
def _configure(p):
|
||||
p.add_argument("--only-expiry", action="store_true",
|
||||
help="запустить только expiry-тест (SESSION_TTL_SECONDS=5)")
|
||||
p.add_argument("--skip-expiry", action="store_true",
|
||||
help="запустить всё, кроме expiry (SESSION_TTL_SECONDS=3600)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,194 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Трек 1 (оценка 5). Предел in-memory архитектуры.
|
||||
|
||||
Гипотеза: на больших историях список сообщений при чтении каждый раз
|
||||
копируется и сортируется под RLock, что ухудшает p95/p99 при росте
|
||||
истории. Убираем сортировку на чтении (append сохраняет порядок) и
|
||||
сравниваем "до/после" при тех же лимитах.
|
||||
|
||||
Эксперимент: >=3 размера истории (H) x >=3 уровня конкуренции (C).
|
||||
Метрики: successful RPS, доля ошибок, p50/p95/p99 только успешных
|
||||
запросов, RSS процесса API (читается через docker stats или /proc).
|
||||
|
||||
Скрипт не меняет API; использует те же публичные клиенты из tests/.
|
||||
Stdlib only, Python 3.9+.
|
||||
"""
|
||||
import json
|
||||
import math
|
||||
import statistics
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, Failure, arguments, check, run # noqa: E402
|
||||
|
||||
|
||||
# --- профиль эксперимента -------------------------------------------------
|
||||
HISTORY_SIZES = [100, 1000, 5000] # >=3 размера истории
|
||||
CONCURRENCY_LEVELS = [1, 4, 16] # >=3 уровня конкуренции
|
||||
DURATION_SECONDS = 10 # на каждую точку (H, C)
|
||||
API_CONTAINER = "mtusi-messenger-lab1" # имя контейнера для docker stats
|
||||
|
||||
|
||||
def rss_mb(container: str):
|
||||
"""RSS процесса API в МБ через docker stats --no-stream."""
|
||||
try:
|
||||
out = subprocess.run(
|
||||
["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", container],
|
||||
capture_output=True, text=True, timeout=10,
|
||||
)
|
||||
if out.returncode != 0:
|
||||
return None
|
||||
# Пример: "120.5MiB / 1GiB"
|
||||
used = out.stdout.strip().split("/")[0].strip()
|
||||
if used.endswith("MiB"):
|
||||
return round(float(used[:-3]), 2)
|
||||
if used.endswith("GiB"):
|
||||
return round(float(used[:-3]) * 1024, 2)
|
||||
if used.endswith("KiB"):
|
||||
return round(float(used[:-3]) / 1024, 2)
|
||||
except Exception:
|
||||
return None
|
||||
return None
|
||||
|
||||
|
||||
def seed_history(c, actor, chat, count, workers=16):
|
||||
"""Заполняет историю до count сообщений параллельно."""
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
def one(i):
|
||||
local = Client(c.base, timeout=15)
|
||||
local.message(actor, chat, "seed-%06d-%s" % (i, uuid.uuid4().hex[:6]))
|
||||
with ThreadPoolExecutor(max_workers=workers) as pool:
|
||||
list(pool.map(one, range(count)))
|
||||
|
||||
|
||||
def measure_read_point(c, chat, actor, duration, concurrency):
|
||||
"""Закрытый контур: параллельно читаем GET /messages?limit=100."""
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages?limit=100"
|
||||
barrier = threading.Barrier(concurrency)
|
||||
latencies, errors = [], 0
|
||||
errors_lock = threading.Lock()
|
||||
|
||||
def worker(_):
|
||||
nonlocal errors
|
||||
local = Client(c.base, timeout=15)
|
||||
barrier.wait()
|
||||
deadline = time.monotonic() + duration
|
||||
local_lat = []
|
||||
while time.monotonic() < deadline:
|
||||
start = time.monotonic()
|
||||
try:
|
||||
local.call("GET", path, actor=actor, schema="MessagePage")
|
||||
local_lat.append(time.monotonic() - start)
|
||||
except Failure:
|
||||
with errors_lock:
|
||||
errors += 1
|
||||
return local_lat
|
||||
|
||||
started = time.monotonic()
|
||||
with ThreadPoolExecutor(max_workers=concurrency) as pool:
|
||||
results = list(pool.map(worker, range(concurrency)))
|
||||
elapsed = time.monotonic() - started
|
||||
|
||||
for chunk in results:
|
||||
latencies.extend(chunk)
|
||||
latencies.sort()
|
||||
|
||||
def pct(p):
|
||||
if not latencies:
|
||||
return None
|
||||
return round(1000 * latencies[max(0, math.ceil(p * len(latencies)) - 1)], 3)
|
||||
|
||||
total = len(latencies) + errors
|
||||
return {
|
||||
"history_size": None, # заполнит вызывающий
|
||||
"concurrency": concurrency,
|
||||
"duration_s": round(elapsed, 3),
|
||||
"successful": len(latencies),
|
||||
"errors": errors,
|
||||
"error_ratio": round(errors / total, 6) if total else None,
|
||||
"rps": round(len(latencies) / elapsed, 3),
|
||||
"latency_ms": {"p50": pct(.50), "p95": pct(.95), "p99": pct(.99)},
|
||||
}
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments("Трек 1: предел in-memory архитектуры")
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
|
||||
report = {"lab": 1, "track": 1, "profile": {
|
||||
"history_sizes": HISTORY_SIZES,
|
||||
"concurrency_levels": CONCURRENCY_LEVELS,
|
||||
"duration_seconds": DURATION_SECONDS,
|
||||
"note": "closed-loop; клиент ограничивает throughput; RSS — docker stats",
|
||||
}, "points": []}
|
||||
|
||||
for h in HISTORY_SIZES:
|
||||
# Досеиваем историю до h (bootstrap уже создал часть).
|
||||
# Считаем число сообщений в истории.
|
||||
# Предыдущая версия: limit=1 - возвращает только одну страницу и далее считает её длину страницы за длину всей истории,
|
||||
# Текущая версия: limit=100 - делаем полный обход истории по курсору => реальное число сообщений
|
||||
have = 0
|
||||
cursor = None
|
||||
from urllib.parse import quote
|
||||
while True:
|
||||
q = path + "?limit=100"
|
||||
if cursor:
|
||||
q += "&cursor=" + quote(cursor, safe="")
|
||||
page = c.call("GET", q, actor=alice, schema="MessagePage")["json"]
|
||||
have += len(page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
if have < h:
|
||||
seed_history(c, alice, chat, h - have)
|
||||
|
||||
for con in CONCURRENCY_LEVELS:
|
||||
point = measure_read_point(c, chat, alice, DURATION_SECONDS, con)
|
||||
point["history_size"] = h
|
||||
point["rss_mb"] = rss_mb(API_CONTAINER)
|
||||
report["points"].append(point)
|
||||
print(json.dumps(point, ensure_ascii=False))
|
||||
|
||||
out = Path("evidence/lab1_track1_load.json")
|
||||
out.parent.mkdir(parents=True, exist_ok=True)
|
||||
out.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n")
|
||||
print("PASS: track1 load matrix saved to", out)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Дополнительный CLI: --container для имени Docker-контейнера.
|
||||
import argparse
|
||||
p = argparse.ArgumentParser(add_help=False)
|
||||
p.add_argument("--container", default=API_CONTAINER)
|
||||
extra, _ = p.parse_known_args()
|
||||
# Прокидываем в namespace аргументов arguments() через env-подобный трюк.
|
||||
sys.argv = [a for a in sys.argv if not a.startswith("--container")]
|
||||
import os
|
||||
os.environ.setdefault("TRACK1_CONTAINER", extra.container)
|
||||
|
||||
def _bind_container(ns):
|
||||
ns.container = os.environ.get("TRACK1_CONTAINER", API_CONTAINER)
|
||||
return ns
|
||||
|
||||
# Патчим arguments, чтобы добавить --container.
|
||||
import client as _client # noqa: E402
|
||||
_orig_arguments = _client.arguments
|
||||
|
||||
def _arguments(description, configure=None):
|
||||
def cfg(parser):
|
||||
if configure:
|
||||
configure(parser)
|
||||
parser.add_argument("--container", default=API_CONTAINER)
|
||||
return _orig_arguments(description, cfg)
|
||||
|
||||
_client.arguments = _arguments
|
||||
run(main)
|
||||
@@ -0,0 +1,100 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Негативные сценарии lab1: неверный JSON, чужой чат, пустое сообщение,
|
||||
дубликат username, обход нескольких страниц. Stdlib only, Python 3.9+."""
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, Failure, arguments, check, run # noqa: E402
|
||||
|
||||
|
||||
def _raw_call(base_url, method, path, body=None, headers=None):
|
||||
"""Сырой запрос для проверки malformed JSON (client.py всегда сериализует)."""
|
||||
url = base_url.rstrip("/") + path
|
||||
data = body if isinstance(body, (bytes, type(None))) else body.encode("utf-8")
|
||||
req = urllib.request.Request(url, data=data, headers=headers or {}, method=method)
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=10) as resp:
|
||||
return resp.status, resp.read()
|
||||
except urllib.error.HTTPError as e:
|
||||
return e.code, e.read()
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments("Lab1 negative scenarios")
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
path = "/api/v1/chats/" + chat["id"]
|
||||
|
||||
# 1. Дубликат username -> 409
|
||||
c.call("POST", "/api/v1/users", 409, body=alice["registration"])
|
||||
|
||||
# 2. Неверный JSON (malformed) -> 400
|
||||
status, _ = _raw_call(
|
||||
c.base,
|
||||
"POST",
|
||||
"/api/v1/users",
|
||||
body=b"{not json at all",
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
check(status == 400, "malformed JSON must be 400, got %s" % status)
|
||||
|
||||
# 3. Лишние поля -> 400
|
||||
c.call(
|
||||
"POST",
|
||||
"/api/v1/users",
|
||||
400,
|
||||
body={"username": "extra_user_x", "display_name": "X", "unexpected": True},
|
||||
)
|
||||
|
||||
# 4. Неверный тип -> 400
|
||||
c.call("POST", "/api/v1/users", 400, body={"username": 123, "display_name": "X"})
|
||||
|
||||
# 5. Пустое / пробельное сообщение -> 400
|
||||
c.call("POST", path + "/messages", 400, actor=alice, body={"text": ""})
|
||||
c.call("POST", path + "/messages", 400, actor=alice, body={"text": " "})
|
||||
|
||||
# 6. Чужой чат -> 404 (не 403)
|
||||
c.call("GET", path, 404, actor=eve)
|
||||
c.call("GET", path + "/messages", 404, actor=eve)
|
||||
c.call("POST", path + "/messages", 404, actor=eve, body={"text": "чужое"})
|
||||
|
||||
# 7. Пагинация: обход нескольких страниц без потерь и дублей
|
||||
texts = ["p-%02d" % i for i in range(7)]
|
||||
for t in texts:
|
||||
c.message(alice, chat, t)
|
||||
collected = []
|
||||
cursor = None
|
||||
seen_cursors = set()
|
||||
for _ in range(20): # предохранитель от бесконечного цикла
|
||||
q = path + "/messages?limit=2"
|
||||
if cursor:
|
||||
from urllib.parse import quote
|
||||
q += "&cursor=" + quote(cursor, safe="")
|
||||
page = c.call("GET", q, actor=bob, schema="MessagePage")["json"]
|
||||
collected.extend(m["text"] for m in page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
check(cursor not in seen_cursors, "cursor loop detected")
|
||||
seen_cursors.add(cursor)
|
||||
check(len(collected) == len(texts), "pagination lost messages: %d != %d" % (len(collected), len(texts)))
|
||||
check(len(set(collected)) == len(collected), "pagination duplicated messages")
|
||||
check(collected == texts, "pagination order/contents mismatch")
|
||||
|
||||
# 8. Некорректный limit -> 400
|
||||
c.call("GET", path + "/messages?limit=0", 400, actor=alice)
|
||||
c.call("GET", path + "/messages?limit=101", 400, actor=alice)
|
||||
|
||||
# 9. Неизвестный X-User-Id -> 401
|
||||
c.call("GET", "/api/v1/users/me", 401, headers={"X-User-Id": str(uuid.uuid4())})
|
||||
|
||||
print("PASS: lab1 negative scenarios (dup, malformed JSON, extra fields, "
|
||||
"wrong type, empty text, foreign chat, pagination, bad limit, unknown user)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,465 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Трек 2 (оценка 5). План запроса, стоимость записи, backup/restore, RPO.
|
||||
|
||||
Шаги:
|
||||
1. Сидируем >=100 000 сообщений с неравномерными чатами (track2_seed.sql).
|
||||
2. Сравниваем 3 варианта индексов на большом и маленьком чате:
|
||||
- baseline (нет индекса) -> Seq Scan
|
||||
- (chat_id) -> Bitmap/Index + Sort
|
||||
- (chat_id, created_at, id) -> Index Scan без Sort (текущий)
|
||||
Снимаем: план (EXPLAIN ANALYZE BUFFERS), время, shared hit/read.
|
||||
3. Стоимость записи: INSERT 10 000 строк на каждом варианте -> время вставки,
|
||||
pg_indexes_size, pg_total_relation_size.
|
||||
4. Backup/restore: pg_dump -Fc, restore в новый контейнер postgres:18-alpine,
|
||||
сверка COUNT(*), COUNT(*) GROUP BY chat_id и 100 случайных сообщений.
|
||||
5. Границы потери данных: во время pg_dump через API пишем новые сообщения,
|
||||
после restore проверяем, что их нет.
|
||||
|
||||
Все psql-вызовы идут через docker run postgres:18-alpine в compose-сети проекта
|
||||
(--network mtuci2026lab2_default), DSN указывает на хост postgres.
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import random
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
import base64
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, Failure, arguments, check, run # noqa: E402
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
EVIDENCE = ROOT / "evidence"
|
||||
EVIDENCE.mkdir(exist_ok=True)
|
||||
|
||||
SEED_SQL = ROOT / "student-tests" / "track2_seed.sql"
|
||||
|
||||
# Имя compose-сети проекта: mtuci2026lab2_default (зафиксировано в compose.yaml networks.default.name).
|
||||
COMPOSE_NETWORK = os.environ.get("COMPOSE_NETWORK", "mtuci2026lab2_default")
|
||||
|
||||
|
||||
# ---------- helpers ----------
|
||||
def _read_dsn() -> str:
|
||||
dsn = os.environ.get("DATABASE_URL")
|
||||
if not dsn:
|
||||
env_file = ROOT / ".env"
|
||||
if env_file.is_file():
|
||||
for line in env_file.read_text(encoding="utf-8").splitlines():
|
||||
line = line.strip()
|
||||
if line.startswith("DATABASE_URL="):
|
||||
dsn = line.split("=", 1)[1].strip()
|
||||
break
|
||||
check(dsn, "DATABASE_URL не найден ни в окружении, ни в .env")
|
||||
# Postgres доступен только внутри compose-сети; одноразовые psql/pg_dump
|
||||
# контейнеры запускаются в этой же сети, имя хоста postgres резолвится как есть.
|
||||
return dsn
|
||||
|
||||
|
||||
def _psql(dsn: str, sql: str, extra=None):
|
||||
cmd = [
|
||||
"docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"postgres:18-alpine",
|
||||
"psql", dsn, "-tA", "-v", "ON_ERROR_STOP=1",
|
||||
]
|
||||
if extra:
|
||||
cmd += extra
|
||||
cmd += ["-c", sql]
|
||||
return subprocess.run(cmd, capture_output=True, text=True, timeout=300)
|
||||
|
||||
|
||||
def _psql_file(dsn: str, path: Path):
|
||||
cmd = [
|
||||
"docker", "run", "--rm", "-i",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"-v", f"{path}:/seed.sql:ro",
|
||||
"postgres:18-alpine",
|
||||
"psql", dsn, "-v", "ON_ERROR_STOP=1", "-f", "/seed.sql",
|
||||
]
|
||||
return subprocess.run(cmd, capture_output=True, text=True, timeout=600)
|
||||
|
||||
|
||||
def _scalar(dsn: str, sql: str):
|
||||
r = _psql(dsn, sql)
|
||||
check(r.returncode == 0, "psql failed:\n" + r.stdout + r.stderr)
|
||||
return r.stdout.strip().splitlines()[-1]
|
||||
|
||||
|
||||
# ---------- 1. seed ----------
|
||||
def step_seed(dsn: str):
|
||||
print("=== 1. seed ===")
|
||||
before = int(_scalar(dsn, "SELECT count(*) FROM messages;"))
|
||||
print(" messages before:", before)
|
||||
r = _psql_file(dsn, SEED_SQL)
|
||||
check(r.returncode == 0, "seed failed:\n" + r.stdout + r.stderr)
|
||||
after = int(_scalar(dsn, "SELECT count(*) FROM messages;"))
|
||||
print(" messages after:", after)
|
||||
check(after >= 100_000, "seed не довёл до 100 000 (получено %d)" % after)
|
||||
dist = _psql(dsn, "SELECT chat_id, count(*) FROM messages GROUP BY chat_id ORDER BY count(*) DESC;")
|
||||
print(" распределение по чатам:\n" + dist.stdout)
|
||||
return after
|
||||
|
||||
|
||||
# ---------- 2. explain ----------
|
||||
def _big_and_small(dsn):
|
||||
big = _scalar(dsn, "SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1;")
|
||||
small = _scalar(dsn, "SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) ASC LIMIT 1;")
|
||||
return big, small
|
||||
|
||||
|
||||
def _chat_size(dsn: str, chat_id: str) -> int:
|
||||
return int(_scalar(dsn, "SELECT count(*) FROM messages WHERE chat_id = '%s';" % chat_id))
|
||||
|
||||
|
||||
def _explain(dsn: str, chat_id: str, label: str):
|
||||
# Берём средний created_at, чтобы keyset реально резал историю
|
||||
mid = _scalar(dsn,
|
||||
"SELECT created_at FROM messages WHERE chat_id = '%s' ORDER BY created_at, id OFFSET (SELECT count(*)/2 FROM messages WHERE chat_id = '%s') LIMIT 1;" % (chat_id, chat_id))
|
||||
sql = (
|
||||
"EXPLAIN (ANALYZE, BUFFERS) "
|
||||
"SELECT id, chat_id, sender_id, text, created_at FROM messages "
|
||||
"WHERE chat_id = '%s' AND (created_at, id) > ('%s', '00000000-0000-0000-0000-000000000000') "
|
||||
"ORDER BY created_at, id LIMIT 51;" % (chat_id, mid)
|
||||
)
|
||||
r = _psql(dsn, sql)
|
||||
check(r.returncode == 0, "EXPLAIN failed:\n" + r.stdout + r.stderr)
|
||||
out = r.stdout
|
||||
print("\n--- EXPLAIN %s (chat=%s...) ---" % (label, chat_id[:8]))
|
||||
for line in out.splitlines():
|
||||
print(" ", line)
|
||||
return out
|
||||
|
||||
|
||||
def _drop_indexes(dsn):
|
||||
_psql(dsn, "DROP INDEX IF EXISTS idx_messages_chat_created;")
|
||||
_psql(dsn, "DROP INDEX IF EXISTS idx_messages_chat_only;")
|
||||
|
||||
|
||||
def _format_section(title: str, chat_size: int, plan: str, note: str = "") -> str:
|
||||
"""Собирает один раздел отчёта в формате образца."""
|
||||
head = "## %s\n\n" % title
|
||||
if note:
|
||||
head += note.rstrip() + "\n\n"
|
||||
return head + "```\n" + plan.rstrip() + "\n```\n"
|
||||
|
||||
|
||||
def step_explain(dsn: str, total_messages: int):
|
||||
print("=== 2. EXPLAIN 3 варианта ===")
|
||||
big, small = _big_and_small(dsn)
|
||||
big_size = _chat_size(dsn, big)
|
||||
small_size = _chat_size(dsn, small)
|
||||
|
||||
# (1) без индекса
|
||||
_drop_indexes(dsn)
|
||||
_psql(dsn, "ANALYZE messages;")
|
||||
no_index_big = _explain(dsn, big, "no_index/big")
|
||||
no_index_small = _explain(dsn, small, "no_index/small")
|
||||
|
||||
# (2) только (chat_id)
|
||||
_psql(dsn, "CREATE INDEX idx_messages_chat_only ON messages (chat_id);")
|
||||
_psql(dsn, "ANALYZE messages;")
|
||||
chat_only_big = _explain(dsn, big, "chat_only/big")
|
||||
chat_only_small = _explain(dsn, small, "chat_only/small")
|
||||
|
||||
# (3) полный рабочий
|
||||
_psql(dsn, "DROP INDEX IF EXISTS idx_messages_chat_only;")
|
||||
_psql(dsn, "CREATE INDEX idx_messages_chat_created ON messages (chat_id, created_at, id);")
|
||||
_psql(dsn, "ANALYZE messages;")
|
||||
full_big = _explain(dsn, big, "full/big")
|
||||
full_small = _explain(dsn, small, "full/small")
|
||||
|
||||
# Заголовок отчёта — как в образце
|
||||
parts = []
|
||||
parts.append(
|
||||
"# Трек 2. EXPLAIN (ANALYZE, BUFFERS): 3 варианта индекса\n\n"
|
||||
"Данные: %d сообщений, неравномерные чаты. "
|
||||
"Запрос: `SELECT ... FROM messages WHERE chat_id = <id> AND (created_at, id) > (<середина>, …) "
|
||||
"ORDER BY created_at, id LIMIT 51`.\n"
|
||||
"Большой чат ~%d, маленький чат ~%d.\n" % (total_messages, big_size, small_size)
|
||||
)
|
||||
|
||||
parts.append(_format_section(
|
||||
"1. Без индекса, большой чат", big_size, no_index_big,
|
||||
"`Parallel Seq Scan` по всей таблице, затем `Sort`."))
|
||||
parts.append(_format_section(
|
||||
"2. Без индекса, маленький чат", small_size, no_index_small,
|
||||
"Тот же `Parallel Seq Scan` по всей таблице."))
|
||||
parts.append(_format_section(
|
||||
"3. Индекс (chat_id), большой чат", big_size, chat_only_big,
|
||||
"`Bitmap Index Scan` по `idx_messages_chat_only`, затем `Bitmap Heap Scan` и `Sort`."))
|
||||
parts.append(_format_section(
|
||||
"4. Индекс (chat_id), маленький чат", small_size, chat_only_small,
|
||||
"`Index Scan using idx_messages_chat_only` + `Sort`."))
|
||||
parts.append(_format_section(
|
||||
"5. Полный индекс (chat_id, created_at, id), большой чат", big_size, full_big,
|
||||
"`Index Scan using idx_messages_chat_created`, **без `Sort`**."))
|
||||
parts.append(_format_section(
|
||||
"6. Полный индекс (chat_id, created_at, id), маленький чат", small_size, full_small,
|
||||
"`Index Scan` без `Sort`."))
|
||||
|
||||
(EVIDENCE / "lab2_track2_explain.md").write_text(
|
||||
"\n".join(parts), encoding="utf-8")
|
||||
|
||||
return {"big_chat": big, "small_chat": small}
|
||||
|
||||
|
||||
# ---------- 3. write cost ----------
|
||||
def _index_sizes(dsn: str):
|
||||
out = _scalar(dsn, "SELECT pg_size_pretty(pg_indexes_size('messages')) || '|' || pg_size_pretty(pg_total_relation_size('messages'));")
|
||||
idx, total = out.split("|")
|
||||
return idx.strip(), total.strip()
|
||||
|
||||
|
||||
def step_write_cost(dsn: str):
|
||||
print("=== 3. Стоимость записи: 10 000 INSERT на каждом варианте ===")
|
||||
seed_user = _scalar(dsn, "SELECT id FROM users LIMIT 1;")
|
||||
seed_chat = _scalar(dsn, "SELECT id FROM chats WHERE title = 'seed-chat-4' LIMIT 1;")
|
||||
|
||||
results = []
|
||||
for name, setup in (
|
||||
("no_index", lambda: _drop_indexes(dsn)),
|
||||
("chat_only", lambda: (_psql(dsn, "DROP INDEX IF EXISTS idx_messages_chat_created;"),
|
||||
_psql(dsn, "CREATE INDEX IF NOT EXISTS idx_messages_chat_only ON messages (chat_id);"))),
|
||||
("full", lambda: (_psql(dsn, "DROP INDEX IF EXISTS idx_messages_chat_only;"),
|
||||
_psql(dsn, "CREATE INDEX IF NOT EXISTS idx_messages_chat_created ON messages (chat_id, created_at, id);"))),
|
||||
):
|
||||
setup()
|
||||
# мерить именно вставку 10k
|
||||
t0 = time.monotonic()
|
||||
r = _psql(dsn,
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text, created_at) "
|
||||
"SELECT gen_random_uuid(), '%s', '%s', 'wc-%s-' || g, now() "
|
||||
"FROM generate_series(1, 10000) AS g;" % (seed_chat, seed_user, name))
|
||||
dt = time.monotonic() - t0
|
||||
check(r.returncode == 0, "insert failed:\n" + r.stdout + r.stderr)
|
||||
idx, total = _index_sizes(dsn)
|
||||
results.append({"variant": name, "insert_10000_s": round(dt, 3),
|
||||
"indexes_size": idx, "total_size": total})
|
||||
print(" %-10s insert=%.3fs idx=%s total=%s" % (name, dt, idx, total))
|
||||
|
||||
(EVIDENCE / "lab2_track2_write_cost.json").write_text(
|
||||
json.dumps(results, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
|
||||
return results
|
||||
|
||||
|
||||
# ---------- 4. backup/restore ----------
|
||||
def step_backup_restore(dsn: str):
|
||||
print("=== 4. backup -> restore -> сверка ===")
|
||||
out_file = EVIDENCE / "lab2_track2_dump.dump"
|
||||
if out_file.exists():
|
||||
out_file.unlink()
|
||||
|
||||
# pg_dump через docker run (использует образ PG 18), в compose-сети
|
||||
t0 = time.monotonic()
|
||||
r = subprocess.run(
|
||||
["docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"-v", f"{EVIDENCE}:/out",
|
||||
"postgres:18-alpine",
|
||||
"pg_dump", "-Fc", "-f", "/out/lab2_track2_dump.dump", dsn],
|
||||
capture_output=True, text=True, timeout=600,
|
||||
)
|
||||
dump_time = time.monotonic() - t0
|
||||
check(r.returncode == 0, "pg_dump failed:\n" + r.stdout + r.stderr)
|
||||
size = out_file.stat().st_size
|
||||
print(" dump size = %.1f MiB, time = %.2fs" % (size / 1024 / 1024, dump_time))
|
||||
|
||||
# новый контейнер как отдельное хранилище — в той же compose-сети,
|
||||
# порт наружу не публикуем
|
||||
restore_container = "mtuci-pg-restore"
|
||||
subprocess.run(["docker", "rm", "-f", restore_container], capture_output=True)
|
||||
subprocess.run(
|
||||
["docker", "run", "-d", "--name", restore_container,
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"-e", "POSTGRES_PASSWORD=restore", "-e", "POSTGRES_USER=postgres",
|
||||
"-e", "POSTGRES_DB=high_load_messenger",
|
||||
"postgres:18-alpine"],
|
||||
capture_output=True, text=True,
|
||||
)
|
||||
# ждём готовности
|
||||
deadline = time.monotonic() + 60
|
||||
while time.monotonic() < deadline:
|
||||
c = subprocess.run(["docker", "exec", restore_container, "pg_isready", "-U", "postgres"],
|
||||
capture_output=True, text=True)
|
||||
if c.returncode == 0:
|
||||
break
|
||||
time.sleep(1)
|
||||
else:
|
||||
raise Failure("restore container не поднялся")
|
||||
|
||||
# pg_restore -c (clean) на пустую БД; restore-контейнер доступен по имени
|
||||
# в compose-сети
|
||||
t0 = time.monotonic()
|
||||
r = subprocess.run(
|
||||
["docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"-v", f"{EVIDENCE}:/in",
|
||||
"postgres:18-alpine",
|
||||
"pg_restore", "-d", "postgresql://postgres:restore@mtuci-pg-restore:5432/high_load_messenger",
|
||||
"--no-owner", "--no-privileges", "/in/lab2_track2_dump.dump"],
|
||||
capture_output=True, text=True, timeout=600,
|
||||
)
|
||||
restore_time = time.monotonic() - t0
|
||||
print(" pg_restore exit=%d, time=%.2fs" % (r.returncode, restore_time))
|
||||
check(r.returncode == 0, "pg_restore failed:\n" + r.stdout + r.stderr)
|
||||
|
||||
# Сверка: сравнение с исходной БД через docker exec psql внутри restore-контейнера
|
||||
def q_restore(sql):
|
||||
c = subprocess.run(["docker", "exec", restore_container, "psql", "-U", "postgres",
|
||||
"-d", "high_load_messenger", "-tA", "-c", sql],
|
||||
capture_output=True, text=True, timeout=120)
|
||||
check(c.returncode == 0, "restore psql failed:\n" + c.stdout + c.stderr)
|
||||
return c.stdout.strip().splitlines()[-1]
|
||||
|
||||
orig_total = int(_scalar(dsn, "SELECT count(*) FROM messages;"))
|
||||
rest_total = int(q_restore("SELECT count(*) FROM messages;"))
|
||||
check(orig_total == rest_total, "COUNT(*) mismatch: %d vs %d" % (orig_total, rest_total))
|
||||
|
||||
orig_dist = _scalar(dsn,
|
||||
"SELECT string_agg(chat_id::text || ':' || c, ',' ORDER BY chat_id) "
|
||||
"FROM (SELECT chat_id, count(*) c FROM messages GROUP BY chat_id) t;")
|
||||
rest_dist = q_restore(
|
||||
"SELECT string_agg(chat_id::text || ':' || c, ',' ORDER BY chat_id) "
|
||||
"FROM (SELECT chat_id, count(*) c FROM messages GROUP BY chat_id) t;")
|
||||
check(orig_dist == rest_dist, "распределение по чатам не совпадает")
|
||||
|
||||
# 100 случайных сообщений
|
||||
ids_raw = _scalar(dsn, "SELECT string_agg(id::text, ',') FROM (SELECT id FROM messages ORDER BY random() LIMIT 100) t;")
|
||||
ids = ids_raw.split(",")
|
||||
check(len(ids) == 100, "не удалось выбрать 100 id")
|
||||
ids_list = ",".join("'%s'" % i for i in ids)
|
||||
orig_rows = _scalar(dsn,
|
||||
"SELECT string_agg(id::text || '|' || text, E'\n' ORDER BY id) FROM messages WHERE id IN (%s);" % ids_list)
|
||||
rest_rows = q_restore(
|
||||
"SELECT string_agg(id::text || '|' || text, E'\n' ORDER BY id) FROM messages WHERE id IN (%s);" % ids_list)
|
||||
check(orig_rows == rest_rows, "100 случайных сообщений различаются")
|
||||
|
||||
print(" OK: COUNT, распределение по чатам и 100 случайных сообщений совпадают")
|
||||
print(" RTO (pg_restore) = %.2fs, dump = %.1f MiB" % (restore_time, size / 1024 / 1024))
|
||||
|
||||
(EVIDENCE / "lab2_track2_restore.txt").write_text(
|
||||
"Track 2 restore\n"
|
||||
"dump_time_s=%.3f\ndump_size_bytes=%d\nrestore_time_s=%.3f\n"
|
||||
"count_original=%d\ncount_restored=%d\n"
|
||||
"dist_match=true\nrandom100_match=true\n"
|
||||
% (dump_time, size, restore_time, orig_total, rest_total),
|
||||
encoding="utf-8")
|
||||
|
||||
# чистим restore-контейнер (volume анонимный)
|
||||
subprocess.run(["docker", "rm", "-f", restore_container], capture_output=True)
|
||||
return {"dump_time_s": round(dump_time, 3), "restore_time_s": round(restore_time, 3),
|
||||
"dump_bytes": size, "count": orig_total}
|
||||
|
||||
|
||||
# ---------- 5. RPO ----------
|
||||
def step_rpo(dsn: str, base_url: str, ca_file):
|
||||
print("=== 5. RPO: запись во время pg_dump ===")
|
||||
c = Client(base_url, ca_file)
|
||||
|
||||
# Данные и сессии готовим заранее, до дампа.
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
|
||||
# Контроль: сессия должна быть валидна, иначе 401 — это не RPO.
|
||||
me = c.call("GET", "/api/v1/users/me", 200, actor=alice, schema="User")
|
||||
check(me["status"] == 200, "сессия должна быть валидна перед RPO-тестом")
|
||||
|
||||
marker = "rpo-" + uuid.uuid4().hex
|
||||
# Запускаем pg_dump
|
||||
out_file = EVIDENCE / "lab2_track2_rpo.dump"
|
||||
if out_file.exists():
|
||||
out_file.unlink()
|
||||
|
||||
# pg_dump: тот же приём, что в шаге 4, в compose-сети.
|
||||
proc = subprocess.Popen(
|
||||
["docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"-v", f"{EVIDENCE}:/out",
|
||||
"postgres:18-alpine",
|
||||
"pg_dump", "-Fc", "-f", "/out/lab2_track2_rpo.dump", dsn],
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
|
||||
)
|
||||
time.sleep(1.0) # снапшот уже снят
|
||||
|
||||
# Свежий логин прямо перед записью: не зависим от TTL старой сессии.
|
||||
cred = base64.b64encode(
|
||||
(alice["registration"]["username"] + ":" +
|
||||
alice["registration"]["password"]).encode()
|
||||
).decode()
|
||||
fresh = c.call("POST", "/api/v1/auth/sessions", 201,
|
||||
headers={"Authorization": "Basic " + cred},
|
||||
schema="Session")["json"]
|
||||
alice_for_write = {"id": alice["id"], "user": alice["user"], "token": fresh["token"]}
|
||||
|
||||
written = c.message(alice_for_write, chat, marker)["json"]
|
||||
code = proc.wait(timeout=300)
|
||||
check(code == 0, "pg_dump для RPO упал")
|
||||
|
||||
# Временный restore-контейнер: в compose-сети, без публикации портов.
|
||||
restore_container = "mtuci-pg-rpo"
|
||||
subprocess.run(["docker", "rm", "-f", restore_container], capture_output=True)
|
||||
subprocess.run(
|
||||
["docker", "run", "-d", "--name", restore_container,
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"-e", "POSTGRES_PASSWORD=restore", "-e", "POSTGRES_USER=postgres",
|
||||
"-e", "POSTGRES_DB=high_load_messenger",
|
||||
"postgres:18-alpine"],
|
||||
capture_output=True, text=True,
|
||||
)
|
||||
|
||||
deadline = time.monotonic() + 60
|
||||
while time.monotonic() < deadline:
|
||||
c2 = subprocess.run(["docker", "exec", restore_container, "pg_isready", "-U", "postgres"],
|
||||
capture_output=True, text=True)
|
||||
if c2.returncode == 0:
|
||||
break
|
||||
time.sleep(1)
|
||||
else:
|
||||
raise Failure("restore container для RPO не поднялся")
|
||||
|
||||
# pg_restore идёт в restore-контейнер по имени в compose-сети.
|
||||
r = subprocess.run(
|
||||
["docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"-v", f"{EVIDENCE}:/in",
|
||||
"postgres:18-alpine",
|
||||
"pg_restore", "-d",
|
||||
"postgresql://postgres:restore@mtuci-pg-rpo:5432/high_load_messenger",
|
||||
"--no-owner", "--no-privileges", "/in/lab2_track2_rpo.dump"],
|
||||
capture_output=True, text=True, timeout=600,
|
||||
)
|
||||
check(r.returncode == 0, "pg_restore для RPO упал:\n" + r.stdout + r.stderr)
|
||||
|
||||
c3 = subprocess.run(["docker", "exec", restore_container, "psql", "-U", "postgres",
|
||||
"-d", "high_load_messenger", "-tA", "-c",
|
||||
"SELECT count(*) FROM messages WHERE id = '%s';" % written["id"]],
|
||||
capture_output=True, text=True)
|
||||
present = int(c3.stdout.strip().splitlines()[-1])
|
||||
check(present == 0, "сообщение, записанное во время дампа, попало в дамп (RPO не 0)")
|
||||
print(" OK: сообщение %s записано после старта дампа и в restore отсутствует" % written["id"][:8])
|
||||
|
||||
(EVIDENCE / "lab2_track2_rpo.txt").write_text(
|
||||
"Track 2 RPO\n"
|
||||
"marker_message_id=%s\npresent_in_restore=%d\nexpected=0\n"
|
||||
% (written["id"], present),
|
||||
encoding="utf-8")
|
||||
|
||||
subprocess.run(["docker", "rm", "-f", restore_container], capture_output=True)
|
||||
|
||||
|
||||
# ---------- main ----------
|
||||
def main():
|
||||
args = arguments("Track 2: plan, write cost, backup/restore, RPO")
|
||||
dsn = _read_dsn()
|
||||
total = step_seed(dsn)
|
||||
step_explain(dsn, total)
|
||||
step_write_cost(dsn)
|
||||
step_backup_restore(dsn)
|
||||
step_rpo(dsn, args.base_url, args.ca_file)
|
||||
print("PASS: track 2 (explain + write cost + backup/restore + RPO)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,10 @@
|
||||
-- Track 2: сравнение планов и стоимости записи.
|
||||
-- Все три варианта прогоняются на одном большом чате (60k) и одном маленьком (~1400).
|
||||
|
||||
-- 0. Определяем два чата
|
||||
\set ON_ERROR_STOP on
|
||||
|
||||
SELECT id AS big_chat_id
|
||||
FROM messages GROUP BY id_chat GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1;
|
||||
|
||||
SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) ASC LIMIT 1;
|
||||
@@ -0,0 +1,81 @@
|
||||
-- Track 2: сидирование >=100 000 сообщений с неравномерными чатами.
|
||||
-- Запускать через: docker run --rm ... psql "$DATABASE_URL" -f track2_seed.sql
|
||||
-- Идемпотентно по количеству: если сообщений уже >= 100 000, ничего не делает.
|
||||
|
||||
DO $$
|
||||
DECLARE
|
||||
v_user UUID;
|
||||
v_total INT;
|
||||
v_have INT;
|
||||
v_need INT;
|
||||
v_chat UUID;
|
||||
rec RECORD;
|
||||
BEGIN
|
||||
SELECT count(*) INTO v_have FROM messages;
|
||||
v_total := 100000;
|
||||
SELECT count(*) INTO v_have FROM messages;
|
||||
IF v_have < 100000 THEN
|
||||
-- меньше 100к: догоняем до 100к
|
||||
v_need := 100000 - v_have; -- сколько добавлять за прогон
|
||||
ELSE
|
||||
v_need := 50000; -- добавляем фиксированные 50к за прогон
|
||||
END IF;
|
||||
|
||||
-- Гарантируем хотя бы одного пользователя
|
||||
SELECT id INTO v_user FROM users LIMIT 1;
|
||||
IF v_user IS NULL THEN
|
||||
v_user := gen_random_uuid();
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES (v_user, 'seed_' || substr(v_user::text, 1, 8), 'Seed',
|
||||
'scrypt$16384$8$1$00$00', now());
|
||||
END IF;
|
||||
|
||||
-- Создаём 10 чатов, если их меньше (нужны только для распределения)
|
||||
-- Неравномерность: 60k / 20k / 10k / по ~1400 на остальные 7.
|
||||
-- Считаем веса, доливаем только v_need строк.
|
||||
CREATE TEMP TABLE _plan(chat_no INT, weight INT) ON COMMIT DROP;
|
||||
INSERT INTO _plan VALUES (1, 60), (2, 20), (3, 10),
|
||||
(4, 2), (5, 2), (6, 1), (7, 1),
|
||||
(8, 1), (9, 1), (10, 1);
|
||||
|
||||
FOR rec IN SELECT * FROM _plan ORDER BY chat_no LOOP
|
||||
-- Находим/создаём chat_id для этого номера: используем title 'seed-chat-<no>'
|
||||
SELECT c.id INTO v_chat FROM chats c WHERE c.title = 'seed-chat-' || rec.chat_no LIMIT 1;
|
||||
IF v_chat IS NULL THEN
|
||||
v_chat := gen_random_uuid();
|
||||
INSERT INTO chats (id, title, created_at) VALUES (v_chat, 'seed-chat-' || rec.chat_no, now());
|
||||
END IF;
|
||||
IF NOT EXISTS (SELECT 1 FROM chat_members WHERE chat_id = v_chat AND user_id = v_user) THEN
|
||||
INSERT INTO chat_members (chat_id, user_id) VALUES (v_chat, v_user);
|
||||
END IF;
|
||||
END LOOP;
|
||||
|
||||
-- Распределяем v_need по весам (целочисленно), последний чат добирает остаток.
|
||||
DECLARE
|
||||
v_sum INT;
|
||||
v_acc INT := 0;
|
||||
v_alloc INT;
|
||||
BEGIN
|
||||
SELECT sum(weight) INTO v_sum FROM _plan;
|
||||
FOR rec IN SELECT * FROM _plan ORDER BY chat_no LOOP
|
||||
IF rec.chat_no = 10 THEN
|
||||
v_alloc := v_need - v_acc; -- остаток
|
||||
ELSE
|
||||
v_alloc := (v_need::numeric * rec.weight / v_sum)::int;
|
||||
v_acc := v_acc + v_alloc;
|
||||
END IF;
|
||||
|
||||
SELECT c.id INTO v_chat FROM chats c WHERE c.title = 'seed-chat-' || rec.chat_no LIMIT 1;
|
||||
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(), v_chat, v_user,
|
||||
'seed-' || rec.chat_no || '-' || g,
|
||||
now() - (g || ' milliseconds')::interval
|
||||
FROM generate_series(1, v_alloc) AS g;
|
||||
END LOOP;
|
||||
END;
|
||||
END $$;
|
||||
|
||||
ANALYZE messages;
|
||||
ANALYZE chat_members;
|
||||
ANALYZE chats;
|
||||
Reference in New Issue
Block a user