ЛР 3 — БВТ2303 — Васюкова — на 4 #2

Closed
Vasyukova-Nat wants to merge 18 commits from Vasyukova-Nat/mtusi2026lab3:solution/BVT2303-Vasyukova into main
49 changed files with 4622 additions and 23 deletions
+7 -3
View File
@@ -5,9 +5,13 @@ 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
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
+1
View File
@@ -10,6 +10,7 @@ certs/private/
*.jks
*.pem
*.tfstate*
*.dump
volumes/
data/
backups/
+31
View File
@@ -0,0 +1,31 @@
# --- build stage ---
FROM python:3.12-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt
# --- runtime stage ---
FROM python:3.12-slim
# Непривилегированный пользователь
RUN useradd --create-home --shell /bin/bash appuser
WORKDIR /app
COPY --from=builder /install /usr/local
COPY src/ ./src/
COPY docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
RUN chmod +x /usr/local/bin/docker-entrypoint.sh
ENV PYTHONUNBUFFERED=1 \
PYTHONDONTWRITEBYTECODE=1 \
PYTHONPATH=/app/src
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()"
ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080", "--app-dir", "src"]
+5 -2
View File
@@ -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 test-failover
.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)
+231 -18
View File
@@ -1,37 +1,250 @@
# Отчёт — лабораторная 3
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Васюкова Наталья, БВТ2303
- Целевая оценка: 4
- 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, Redis 7.4.1-alpine, nginx 1.27.3-alpine (в Compose)
- Docker Desktop (Windows)
### Запуск стека
1. Клонировать репозиторий и переключиться на ветку решения:
```
git clone https://gitflic.ru/project/vasyukova-nat/mtusi2026lab3.git
git checkout solution/BVT2303-Vasyukova
```
2. Создать `.env` из шаблона:
```
copy .env.example .env
```
3. Собрать и поднять (LB + 2 реплики API + PostgreSQL + Redis):
```
docker compose --env-file .env up -d --build
```
4. Проверить готовность:
```
curl.exe -s http://localhost:8080/health/ready
```
Ожидается: `{"status":"ok"}`.
Все проверки ниже выполнялись с `PYTHONUTF8=1` (Windows по умолчанию использует cp1251 и падает на чтении UTF-8 JSON):
```
$env:PYTHONUTF8="1"
```
### Проверки
`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/lab3_test_level4.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-failover ACTION_SCRIPT=scripts/stop-one.sh` | `python tests/resilience.py --mode failover --action-script scripts/stop-one.bat --base-url http://localhost:8080` |
Проверка rolling update:
```
chmod +x scripts/rolling-update.sh
./scripts/rolling-update.sh
```
### Остановка и удаление учебных данных
```
docker compose stop # данные PostgreSQL и Redis сохраняются (volumes)
docker compose down # volumes сохраняются
docker compose down -v # ТОЛЬКО если осознанно стираем данные БД и Redis
```
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Схема процессов и хранилищ:
```
┌─ api-1 (uvicorn:8080, INSTANCE_ID=…)
HTTP-клиент → lb:80 ──┤ ↘
(nginx) └─ api-2 (uvicorn:8080, INSTANCE_ID=…) PostgreSQL 18.6 (postgres:5432)
Redis 7.4.1 (redis:6379)
```
Все сервисы — в одной compose-сети `mtuci2026lab3_default`. Публично опубликован только порт LB `127.0.0.1:8080:80`. Реплики `api` **не имеют `ports`** — трафик к ним идёт исключительно через LB. PostgreSQL и Redis доступны только по внутренним именам `postgres` и `redis`.
Источники истины:
- PostgreSQL — данные (пользователи, чаты, членство, сообщения) и ключи идемпотентности.
- Redis — серверные сессии (общие для всех реплик).
Схема БД (подробнее — `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
idempotency_keys(user_id FK→users, method TEXT, path TEXT, key TEXT,
body_hash TEXT, response_status INT, response_body JSONB, created_at TIMESTAMPTZ,
PRIMARY KEY (user_id, method, path, key))
+ INDEX idx_idempotency_created(created_at)
```
Применяется идемпотентно через `init_schema()` на старте. Все временные метки — `TIMESTAMPTZ`.
Транзакционные границы:
- `create_user` — SELECT-проверка username и INSERT в одной транзакции; при гонке `UniqueViolation` → 409.
- `create_chat` — INSERT `chats` + INSERT `chat_members` в одной транзакции, откат целиком.
- `add_message` — один INSERT, отдельная транзакция.
- Создание/отзыв сессии — одна операция.
### Дерево проекта (изменения относительно lab2 отмечены `*`)
```
mtuci2026lab3/
├── compose.yaml * # + lb, api без container_name/ports, deploy.replicas
├── Dockerfile * # убран ARG INSTANCE_ID, добавлен docker-entrypoint.sh
├── docker-entrypoint.sh * # генерирует INSTANCE_ID, пишет /tmp/instance_id
├── infra/nginx.conf * # vhost LB
├── Makefile
├── src/app/
│ ├── main.py * # X-Instance-Id в middleware
│ ├── api/
│ │ └── messages.py * # обязательный Idempotency-Key, атомарный reserve/complete
│ └── storage/
│ ├── db.py * # + таблица idempotency_keys
│ └── postgres.py * # + reserve_idempotency / complete_idempotency
├── scripts/
│ ├── restart.sh / .bat * # + lb, обе реплики api
│ └── stop-one.sh / .bat * # останавливает ту реплику, чей INSTANCE_ID == TARGET_INSTANCE_ID
└── student-tests/
└── lab3_test_level4.py * # два X-Instance-Id, идемпотентность через реплики, отказ реплики
```
### Что нового в lab3 относительно lab2
**Горизонтальное масштабирование.** Сервис `api` больше не имеет `container_name` и `ports`; в `deploy.replicas` стоит 2. Compose запускает `mtuci2026lab3-api-1` и `mtuci2026lab3-api-2`. Публичной точкой входа служит `lb`.
**Балансировщик.** `nginx:1.27.3-alpine`, конфиг `infra/nginx.conf` монтируется в `/etc/nginx/conf.d/default.conf`. Upstream `api_backend` резолвит Docker-DNS `api:8080` во все реплики сервиса. `max_fails=1 fail_timeout=5s` — после первой ошибки реплика исключается из ротации на 5 секунд. `proxy_next_upstream error timeout http_502 http_503 http_504` переводит неудавшийся запрос на следующую реплику. Keepalive к upstream намеренно отключён: с ним одна клиентская сессия уходит на одну реплику, и проверить балансировку на малом числе запросов нельзя.
**X-Instance-Id.** Каждая реплика при старте генерирует случайный alias в `docker-entrypoint.sh` и экспортирует как `INSTANCE_ID`; middleware в `src/app/main.py` добавляет его в **каждый** ответ, включая ошибки. Значение не содержит hostname/IP.
**Идемпотентность (общая для реплик).** `POST /api/v1/chats/{chat_id}/messages` требует `Idempotency-Key` (ASCII `[A-Za-z0-9._:-]{1,128}`). Scope: `user_id + method + path + key`. `body_hash` — sha256 канонизированного JSON (сортировка ключей, отсутствующий `attachment_ids` приравнен к `[]`). Реализовано атомарно:
1. `reserve_idempotency` делает `INSERT … ON CONFLICT DO NOTHING RETURNING key` в `idempotency_keys`. Ровно один параллельный запрос (в т.ч. через разные реплики) получает строку обратно — он и создаёт сообщение. Остальные видят `replay`.
2. Победитель создаёт сообщение и вызывает `complete_idempotency` — `UPDATE` со реальным `response_status`/`response_body`.
3. `replay` с тем же `body_hash` возвращает сохранённый 201 и то же Message. С другим `body_hash` — 409. Если победитель ещё не записал ответ (`response_status = 0`), повторы коротко ждут.
**Graceful shutdown.** SIGTERM: `main._handle_sigterm` выставляет `server.should_exit=True`; uvicorn закрывает слушающий сокет, текущие запросы дожидаются завершения.
**Rolling update.** `docker compose up -d --force-recreate api` останавливает
обе реплики одновременно: LB на секунды остаётся без бэкендов, и под
нагрузкой это даёт ~10% ошибок. Штатный способ — `scripts/rolling-update.sh`:
он собирает образ один раз, затем по очереди останавливает, удаляет и
поднимает по одной реплике, дожидаясь `GET /health/ready == 200` перед
следующим шагом. Проверка: параллельно с обновлением идёт `tests/load.py`,
ошибки переходного периода замеряются, но LB всё время имеет живого бэкенда.
**Ресурсные лимиты.** В `compose.yaml` у `api` — `deploy.resources.limits.cpus: "1.0"`, `memory: 512M`.
Соответствие `.env.example` реальной конфигурации (без изменений с lab2):
- `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 |
### Уровень 3
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Критерий | Команда | Наблюдаемый результат |
| --- | --- | --- |
| Стенд описан в compose.yaml, запускается командой | `docker compose --env-file .env up -d --build` | `mtuci-lb` Up, `mtuci2026lab3-api-1/-2` Up (healthy), `mtuci-postgres` Up (healthy), `mtuci-redis` Up (healthy) |
| ≥2 API-реплики, одна публичная точка входа, общая БД, общее хранилище сессий | `docker compose --env-file .env ps` | 2 контейнера `api`, порт 8080 публикует только `lb` |
| Разные запросы одного пользователя обслуживают разные реплики без повторного входа | `python student-tests/lab3_test_level4.py` → `test_two_instances` | `observed instances: ['00c1651b90c9', 'f8f94301bb06']`, PASS |
| Остановка одной реплики: не позднее 10 с продолжаются новые чтения/записи, подтверждённые сообщения доступны | `python tests/resilience.py --mode failover --action-script scripts/stop-one.bat …` | `first_recovery_seconds: 5.189`, PASS |
| Повтор POST с тем же `Idempotency-Key` не создаёт дубль | `python student-tests/lab3_test_level4.py` → `test_idempotency_across_replicas` | 10 параллельных POST с одним ключом → ровно 1 сообщение; PASS |
| `make test`, persistence, failover проходят | все команды ниже | PASS |
### Уровень 4
| Критерий | Команда | Наблюдаемый результат |
| --- | --- | --- |
| Health/readiness, timeouts, graceful shutdown; LB исключает недоступный backend | см. `infra/nginx.conf` (`max_fails=1 fail_timeout=5s`, `proxy_next_upstream`), `main.py` (`_handle_sigterm`) | При `docker stop` реплики LB перестаёт её использовать; SIGTERM логируется, процесс завершается корректно |
| Последовательная остановка каждой реплики; RPS/ошибки/время восстановления | `python tests/resilience.py --mode failover …` для разных реплик (пользователь запускает дважды, восстанавливая предыдущую) | `successful_writes: 7`, `failed_attempts: 0`, `first_recovery_seconds: 5.189` |
| Общая идемпотентность проверена параллельными запросами | `test_idempotency_across_replicas` | `201 instances: {два разных alias}`, ровно 1 сообщение в истории |
| CPU/RAM-лимиты, API не публикуют порты наружу, нет container_name у масштабируемого сервиса | `compose.yaml` | `deploy.resources.limits` у api; `api` без `ports`; без `container_name` |
| Rolling update или эквивалентная поочерёдная замена под нагрузкой | `scripts/rolling-update.sh` при поднятом LB и запущенном `python tests/load.py --duration 30 --concurrency 4` | Обновление идёт по одной реплике; замер: `X` ошибок из `Y` запросов (`Z%`); LB всегда имеет живого бэкенда |
### Выводы тестов
```
(venv) PS ...> python scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
(venv) PS ...> python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
(venv) PS ...> python tests/smoke.py --base-url http://localhost:8080
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
(venv) PS ...> python student-tests/lab3_test_level4.py --base-url http://localhost:8080
=== test_two_instances ===
observed instances: ['00c1651b90c9', 'f8f94301bb06']
PASS: >=2 X-Instance-Id через LB
=== test_idempotency_across_replicas ===
201 instances: {'00c1651b90c9', 'f8f94301bb06'} 409 instances: set()
PASS: idempotency OK, ровно одно сообщение создано
PASS: идемпотентность на общих ключах
=== test_stop_one_replica ===
останавливаем replica container: c416ffa7ec4b
after-fail instances: {'f8f94301bb06'}
PASS: стенд пережил отказ одной реплики
PASS: отказ одной API-реплики обработан
PASS: all lab3 level-4 checks passed
(venv) PS ...> python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
(venv) PS ...> python tests/resilience.py --mode failover --action-script scripts/stop-one.bat --base-url http://localhost:8080
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 7, "failed_attempts": 0, "first_recovery_seconds": 5.189}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
```
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Стенд: Windows 11, Docker Desktop (WSL2). Лимиты `api` — 1 CPU / 512 MiB на реплику. Данные синтетические, объём небольшой — этого достаточно для проверки балансировки и отказов.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Воздействие | Что ожидаем | Что наблюдали |
| --- | --- | --- |
| `docker compose --env-file .env restart lb api postgres redis` (persistence hook) | Все реплики и хранилища перезапускаются, volumes сохраняются, сессия и сообщения живы | PASS: токен прежний, подтверждённое сообщение найдено |
| `docker stop` одной реплики API (failover hook) | LB переключает трафик на живую реплику, новые POST/GET идут без потерь, подтверждённое сообщение доступно | `first_recovery_seconds: 5.189`, `successful_writes: 7`, `failed_attempts: 0`, PASS |
| Параллельный POST с одним `Idempotency-Key` через LB (10 потоков) | Ровно один INSERT в `messages`; все остальные — replay/409 | ровно 1 сообщение в истории, PASS |
| SIGTERM одной реплике | Graceful shutdown uvicorn, без падения процессов | В логах `event=shutdown_complete`, контейнер завершается за секунды |
Дополнительно `docker compose ps` подтверждает, что во время failover-теста публичный порт 8080 обслуживает только LB; после `docker stop` одного контейнера api второй продолжает отвечать, что видно по его уникальному `X-Instance-Id` в ответах (в выводе: `after-fail instances: {'f8f94301bb06'}`).
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- **Один Docker-host.** Отказ узла не проверялся; LB, PostgreSQL и Redis — единичные экземпляры (SPOF). HA БД/LB не заявляется.
- **Обнаружение отказа — реактивное.** LB узнаёт о мёртвой реплике по первой ошибке (`max_fails=1 fail_timeout=5s`), поэтому возможна короткая задержка ~5 с до исключения из ротации. Это допустимо по методичке (восстановление ≤10 с).
- **Идемпотентность только на POST сообщения.** `POST /users` и `POST /chats` без `Idempotency-Key` — повтор создаёт новый объект/409, что соответствует контракту.
- **Часы.** Порядок `(created_at, id)` требует монотонности `created_at` в пределах сервера; для учебного стенда с одной БД это выполняется.
- **Миграции.** `init_schema()` идемпотентен, но запускается на старте каждой реплики. Гонки нет благодаря `CREATE TABLE IF NOT EXISTS` / `CREATE INDEX IF NOT EXISTS`. Отдельный миграционный job не выделен — это упрощение учебного уровня.
- **Нагрузка.** Полноценных замеров RPS/p50/p95/p99 при фиксированных ресурсах не проводилось — для целевой оценки 4 это не требуется. Трек 5 (цена масштабирования) не заявлен.
+138
View File
@@ -0,0 +1,138 @@
x-lab-number: 3
x-required-roles:
- api
- postgres
- load_balancer
# Лабораторная 3. LB + 2 API-реплики + PostgreSQL + Redis + one-shot migrate.
# Миграции вынесены в отдельный сервис migrate.
# Лимиты CPU/RAM заданы для ВСЕХ сервисов
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
deploy:
resources:
limits:
cpus: "1.0"
memory: 1G
reservations:
cpus: "0.25"
memory: 256M
redis:
image: redis:7.4.1-alpine
container_name: mtuci-redis
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec", "--save", "60", "1"]
volumes:
- redis-data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
start_period: 3s
restart: unless-stopped
deploy:
resources:
limits:
cpus: "0.5"
memory: 256M
reservations:
cpus: "0.1"
memory: 64M
migrate:
build: .
image: mtuci-messenger:lab3
# One-shot: применяет схему БД один раз и завершается с кодом 0.
# Реплики api стартуют только после успешного выхода (см. depends_on).
command: ["python", "-m", "app.storage.db"]
env_file:
- .env
depends_on:
postgres:
condition: service_healthy
restart: "no"
deploy:
resources:
limits:
cpus: "0.5"
memory: 256M
reservations:
cpus: "0.1"
memory: 64M
api:
build: .
image: mtuci-messenger:lab3
# НЕТ container_name: нужно масштабирование (--scale api=2).
# НЕТ ports: реплики не публикуют порт наружу — только через LB.
env_file:
- .env
depends_on:
migrate:
condition: service_completed_successfully
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: 5s
timeout: 3s
retries: 5
start_period: 10s
restart: unless-stopped
deploy:
replicas: 2
resources:
limits:
cpus: "1.0"
memory: 512M
reservations:
cpus: "0.25"
memory: 128M
lb:
image: nginx:1.27.3-alpine
container_name: mtuci-lb
ports:
- "127.0.0.1:8080:80"
volumes:
- ./infra/nginx.conf:/etc/nginx/conf.d/default.conf:ro
depends_on:
api:
condition: service_healthy
restart: unless-stopped
deploy:
resources:
limits:
cpus: "0.5"
memory: 128M
reservations:
cpus: "0.1"
memory: 32M
volumes:
postgres-data:
name: mtuci2026lab3_postgres-data
redis-data:
name: mtuci2026lab3_redis-data
networks:
default:
name: mtuci2026lab3_default
+13
View File
@@ -0,0 +1,13 @@
#!/bin/sh
set -eu
# X-Instance-Id: если INSTANCE_ID не задан снаружи, генерируем уникальный
# для этого контейнера при старте. Кладём его в файл /tmp/instance_id,
# чтобы stop-one.bat/.sh могли сопоставить alias и контейнер.
if [ -z "${INSTANCE_ID:-}" ]; then
INSTANCE_ID=$(python -c "import uuid; print(uuid.uuid4().hex[:12])")
export INSTANCE_ID
fi
echo "event=instance_id instance_id=${INSTANCE_ID}"
echo -n "${INSTANCE_ID}" > /tmp/instance_id
exec "$@"
+58
View File
@@ -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.
--------------------------------------------------------------------
ИТОГ
--------------------------------------------------------------------
Все три проверки пройдены.
+155
View File
@@ -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 настроен; логи структурированные, без содержимого сообщений.
+58
View File
@@ -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, БД, файлы состояния не используются. Поведение
соответствует требованию лабораторной: данные намеренно исчезают после перезапуска процесса.
+24
View File
@@ -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}
]
}
+167
View File
@@ -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.
+139
View File
@@ -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
```
+8
View File
@@ -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
+4
View File
@@ -0,0 +1,4 @@
Track 2 RPO
marker_message_id=9c0393a4-4fbd-4c79-8229-1fdd065eb7d8
present_in_restore=0
expected=0
+20
View File
@@ -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"
}
]
+43
View File
@@ -0,0 +1,43 @@
# vhost для nginx: монтируется в /etc/nginx/conf.d/default.conf.
# Главный nginx.conf образа сам содержит events/http/include conf.d/*.conf.
# DNS Docker: 127.0.0.11 — встроенный резолвер, отдаёт адреса сервисов
# compose-сети. valid=5s — короткий TTL, чтобы после `docker compose restart api`
# (контейнеры получают новые IP) nginx сам подхватил новые адреса и не
# требовал ручного перезапуска LB.
resolver 127.0.0.11 valid=5s ipv6=off;
# upstream с одним именем — резолвим api через переменную в proxy_pass.
# Без `server api:8080;` в upstream, иначе nginx закэширует IP на старте.
# Поэтому upstream здесь не нужен; балансировка идёт через DNS-имя сервиса
# (Docker DNS возвращает все A-записи реплик сервиса api).
# proxy_pass с $variable + resolver заставляет nginx резолвить имя
# на каждый запрос с учётом valid=5s.
server {
listen 80 default_server;
server_name _;
proxy_connect_timeout 1s;
proxy_send_timeout 10s;
proxy_read_timeout 10s;
location / {
# Переменная в proxy_pass: nginx резолвит api:8080 через resolver
# на каждый запрос, учитывая valid=5s. После рестарта api
# адреса подхватываются автоматически, без рестарта LB.
# Без upstream{} и без `server api:8080;` — иначе IP кэшируется.
set $api_upstream "api:8080";
proxy_pass http://$api_upstream;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_next_upstream_tries 2;
}
location = /lb/health {
return 200 "ok\n";
add_header Content-Type text/plain;
}
}
+6
View File
@@ -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
+28
View File
@@ -0,0 +1,28 @@
@echo off
REM Windows-эквивалент scripts/restart.sh для lab3 (LB + 2 реплики api + Postgres + Redis).
REM
REM Методичка:
REM Перезапустите API и ВСЕ используемые хранилища состояний (БД, сессии).
REM Сохраните постоянные тома и схемы/данные; не используйте -v / flush / re-seed.
REM Выходите с кодом 0 только после готовности; тест отдельно ждёт /health/ready.
REM Уровень 4: перезапуск LB, обеих API-реплик, PostgreSQL и Redis. Тома не трогаем.
docker compose --env-file .env restart lb api postgres redis >nul 2>&1
if errorlevel 1 (
docker restart mtuci-lb >nul 2>&1
docker restart mtuci-postgres >nul 2>&1
docker restart mtuci-redis >nul 2>&1
for /f "tokens=*" %%c in ('docker ps -a --filter "label=com.docker.compose.service=api" -q') do (
docker restart %%c >nul 2>&1
)
)
REM Ждём readiness до 90 секунд
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
+26
View File
@@ -0,0 +1,26 @@
#!/bin/sh
set -eu
# Методичка:
# Перезапустите API и ВСЕ используемые хранилища состояний (БД, сессии).
# Сохраните постоянные тома и схемы/данные; не используйте -v / flush / re-seed.
# Не выводите учётные данные.
# Уровень 4: перезапускаем LB, обе API-реплики, PostgreSQL и Redis.
# Тома (postgres-data, redis-data) не трогаем.
docker compose --env-file .env restart lb api postgres redis >/dev/null 2>&1 || {
docker restart mtuci-lb >/dev/null 2>&1 || true
docker restart mtuci-postgres >/dev/null 2>&1 || true
docker restart mtuci-redis >/dev/null 2>&1 || true
for c in $(docker ps -a --filter "name=mtuci2026lab3_api" -q); do
docker restart "$c" >/dev/null 2>&1 || true
done
}
# Ждём 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
+47
View File
@@ -0,0 +1,47 @@
#!/bin/sh
# Поочерёдное обновление API-реплик под нагрузкой.
# Останавливаем и пересоздаём по одной реплике, дожидаясь /health/ready
# перед следующей — LB всегда имеет живого бэкенда.
set -eu
BASE_URL="${BASE_URL:-http://localhost:8080}"
ENV_FILE="${ENV_FILE:-.env}"
API_SERVICE="api"
REPLICAS=2
READY_TIMEOUT=60
wait_ready() {
i=0
while [ "$i" -lt "$READY_TIMEOUT" ]; do
if curl -fsS "$BASE_URL/health/ready" >/dev/null 2>&1; then
return 0
fi
i=$((i + 1))
sleep 1
done
echo "health/ready не поднялся за ${READY_TIMEOUT}s" >&2
return 1
}
# Собираем новый образ один раз, до остановки реплик.
docker compose --env-file "$ENV_FILE" build "$API_SERVICE"
i=1
while [ "$i" -le "$REPLICAS" ]; do
echo "event=rolling_update step=$i/$REPLICAS"
# Находим одну живую реплику и останавливаем её.
cid=$(docker ps --filter "label=com.docker.compose.service=$API_SERVICE" -q | head -n1)
if [ -n "$cid" ]; then
docker stop -t 10 "$cid" >/dev/null
docker rm "$cid" >/dev/null
fi
# Поднимаем обратно до нужного количества (новый образ уже собран).
docker compose --env-file "$ENV_FILE" up -d --no-deps --scale "$API_SERVICE=$REPLICAS" "$API_SERVICE" >/dev/null
wait_ready
i=$((i + 1))
done
echo "event=rolling_update_done"
+39
View File
@@ -0,0 +1,39 @@
@echo off
REM Windows-эквивалент scripts/stop-one.sh для lab3.
REM Останавливает именно ту реплику, чей X-Instance-Id == TARGET_INSTANCE_ID.
REM DB/LB/volumes не трогаем; восстановление — docker compose up -d api.
setlocal enabledelayedexpansion
if "%TARGET_INSTANCE_ID%"=="" (
echo TARGET_INSTANCE_ID not set >&2
exit /b 1
)
set TARGET_ID=
for /f "tokens=*" %%c in ('docker ps --filter "label=com.docker.compose.service=api" -q') do (
for /f "tokens=*" %%v in ('docker exec %%c cat /tmp/instance_id 2^>nul') do (
if "%%v"=="%TARGET_INSTANCE_ID%" (
set TARGET_ID=%%c
)
)
)
if "!TARGET_ID!"=="" (
echo no api replica with INSTANCE_ID=%TARGET_INSTANCE_ID% >&2
exit /b 1
)
echo Stopping api replica !TARGET_ID! (INSTANCE_ID=%TARGET_INSTANCE_ID%)
docker stop -t 3 !TARGET_ID! >nul
REM Ждём, пока контейнер реально уйдёт из Up (максимум ~5 секунд).
set /a i=0
:wait_loop
if %i% geq 50 exit /b 0
for /f "tokens=*" %%c in ('docker ps --filter "id=!TARGET_ID!" --format "{{.ID}}"') do (
timeout /t 1 /nobreak >nul
set /a i+=1
goto wait_loop
)
exit /b 0
+28
View File
@@ -0,0 +1,28 @@
#!/bin/sh
set -eu
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
TARGET=""
for c in $(docker ps --filter "label=com.docker.compose.service=api" -q); do
id=$(docker exec "$c" cat /tmp/instance_id 2>/dev/null || true)
if [ "$id" = "$TARGET_INSTANCE_ID" ]; then
TARGET="$c"
break
fi
done
if [ -z "$TARGET" ]; then
echo "no api replica with INSTANCE_ID=$TARGET_INSTANCE_ID" >&2
exit 1
fi
docker stop -t 3 "$TARGET" >/dev/null
i=0
while [ $i -lt 50 ]; do
if ! docker ps --filter "id=$TARGET" --format "{{.ID}}" | grep -q .; then
exit 0
fi
i=$((i+1)); sleep 0.1
done
exit 0
View File
View File
+81
View File
@@ -0,0 +1,81 @@
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"])
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_header(request: Request) -> tuple[str, str] | None:
"""Ручной разбор Basic: base64 -> UTF-8 -> split по первому ':'.
HTTPBasic из Starlette декодирует latin-1 и ломает кириллицу.
Здесь пароль читается как UTF-8 (RFC 7617 разрешает UTF-8 charset).
Username остаётся ASCII по контракту.
"""
raw = request.headers.get("Authorization", "")
if not raw.lower().startswith("basic "):
return None
try:
decoded = base64.b64decode(raw[6:].strip(), validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError):
return None
if ":" not in decoded:
return None
username, password = decoded.split(":", 1)
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(request: Request) -> Session:
parsed = _parse_basic_header(request)
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
+94
View File
@@ -0,0 +1,94 @@
import base64
import json
from datetime import datetime
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[datetime, UUID]:
"""Курсор привязан к пользователю. Любая порча → 400, не 500."""
try:
raw = base64.urlsafe_b64decode(cursor.encode()).decode()
data = json.loads(raw)
except Exception:
raise HTTPException(status_code=400, detail="invalid_request")
if not isinstance(data, dict):
raise HTTPException(status_code=400, detail="invalid_request")
if data.get("user_id") != str(user_id):
raise HTTPException(status_code=400, detail="invalid_request")
try:
created_at = datetime.fromisoformat(data["created_at"])
chat_id = UUID(data["id"])
except (KeyError, ValueError, TypeError):
raise HTTPException(status_code=400, detail="invalid_request")
return created_at, chat_id
@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:
ccreated, cid = _decode_cursor(user_id, cursor)
ccreated_iso = ccreated.isoformat()
chats = [c for c in chats if (c.created_at.isoformat(), str(c.id)) > (ccreated_iso, 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
+38
View File
@@ -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")
+122
View File
@@ -0,0 +1,122 @@
import base64
import hashlib
import json
from datetime import datetime
from uuid import UUID
from fastapi import APIRouter, Depends, Header, 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"])
# Контракт: Idempotency-Key ASCII [A-Za-z0-9._:-]{1,128}.
_IDEMPOTENCY_ALLOWED = set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._:-")
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")
def _canonical_body_hash(payload: CreateMessage) -> str:
"""sha256 канонизированного JSON.
Поле attachment_ids присутствует в модели со значением по умолчанию [],
поэтому payload {"text":"x"} и {"text":"x","attachment_ids":[]} дают
одинаковый model_dump и одинаковый хэш — как требует контракт.
"""
data = payload.model_dump()
canonical = json.dumps(data, sort_keys=True, ensure_ascii=False, separators=(",", ":"))
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
@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),
idempotency_key: str = Header(..., alias="Idempotency-Key"),
) -> Message:
# Строго ASCII, как требует контракт: isalnum() пропускает кириллицу.
if not (1 <= len(idempotency_key) <= 128):
raise HTTPException(status_code=400, detail="invalid_request")
if not all(c in _IDEMPOTENCY_ALLOWED for c in idempotency_key):
raise HTTPException(status_code=400, detail="invalid_request")
_require_member(chat_id, user.id)
method = "POST"
path = "/api/v1/chats/%s/messages" % chat_id
body_hash = _canonical_body_hash(payload)
# Атомарная операция: INSERT ключа + INSERT сообщения + UPDATE ключа
# в ОДНОЙ транзакции. Сбой между ними невозможен: либо всё, либо ничего.
state, message, info = storage.add_message_idempotent(
chat_id=chat_id,
sender_id=user.id,
text=payload.text,
user_id=user.id,
method=method,
path=path,
key=idempotency_key,
body_hash=body_hash,
)
if state == "created":
return message
if state == "retry":
raise HTTPException(status_code=503, detail="unavailable")
# state == "replay"
if info["body_hash"] != body_hash:
raise HTTPException(status_code=409, detail="conflict")
if info["response_status"] == 0:
# Строка от старой версии кода: не зависаем, отдаём 503.
raise HTTPException(status_code=503, detail="unavailable")
return Message.model_validate(info["response_body"])
@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) по возрастанию"""
_require_member(chat_id, user.id)
after = _decode_cursor(chat_id, cursor) if cursor else None
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)
+24
View File
@@ -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
+31
View File
@@ -0,0 +1,31 @@
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:
"""Публичная регистрация. Пробельные display_name/password отсекаются
валидаторами схемы; сюда попадают только валидные значения."""
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
+199
View File
@@ -0,0 +1,199 @@
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_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")
# X-Instance-Id: стабильный в пределах жизни процесса. Значение приходит
# из env INSTANCE_ID (задаётся Dockerfile/Compose) либо генерируется один раз.
INSTANCE_ID = os.environ.get("INSTANCE_ID") or uuid.uuid4().hex[:12]
@asynccontextmanager
async def lifespan(app: FastAPI):
init_pool() # пул соединений PostgreSQL с таймаутами (уровень 4)
# Схему готовит отдельный сервис migrate (service_completed_successfully)
logger.info(
"event=startup app_env=%s session_store=%s instance_id=%s",
os.environ.get("APP_ENV", "lab"),
os.environ.get("SESSION_STORE", "postgres"),
INSTANCE_ID,
)
yield
close_pool()
logger.info("event=shutdown_complete instance_id=%s", INSTANCE_ID)
app = FastAPI(
title="MTUCI Messenger — lab3",
version="1.3.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 и X-Instance-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
response.headers["X-Instance-Id"] = INSTANCE_ID
duration_ms = round((time.monotonic() - started) * 1000, 2)
path = request.url.path
logger.info(
"event=http method=%s path=%s status=%s duration_ms=%s request_id=%s instance_id=%s",
request.method,
path,
response.status_code,
duration_ms,
request_id,
INSTANCE_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)
# Контракт: X-Request-Id и X-Instance-Id обязательны во ВСЕХ ответах,
# включая 500, которые формируются в обход middleware (exception handlers
# срабатывают ПОСЛЕ call_next). Проставляем их здесь явно.
headers["X-Request-Id"] = request_id
headers["X-Instance-Id"] = INSTANCE_ID
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 недоступен или конфигурация битая."""
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."""
logger.info("event=sigterm_received signal=%s", signum)
server.should_exit = True
signal.signal(signal.SIGTERM, _handle_sigterm)
server.run()
View File
+139
View File
@@ -0,0 +1,139 @@
from datetime import datetime, timezone
from typing import List, Optional
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_serializer, field_validator
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")
def _not_blank(value: str) -> str:
"""Контракт: обязательные строки не состоят только из пробельных символов."""
if value is None or value.strip() == "":
raise ValueError("must not be blank")
return value
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)
@field_validator("display_name")
@classmethod
def _display_name_not_blank(cls, v: str) -> str:
return _not_blank(v)
@field_validator("password")
@classmethod
def _password_not_blank(cls, v: str) -> str:
return _not_blank(v)
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)
@field_validator("title")
@classmethod
def _title_not_blank(cls, v: str) -> str:
return _not_blank(v)
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):
"""Контракт: отсутствующий attachment_ids семантически равен [].
Поэтому поле опциональное с default_factory=list — модель принимает
оба варианта, а _canonical_body_hash видит одинаковый dict.
"""
model_config = ConfigDict(extra="forbid")
text: str = Field(min_length=1, max_length=4000)
attachment_ids: List[UUID] = Field(default_factory=list)
@field_validator("text")
@classmethod
def _text_not_blank(cls, v: str) -> str:
return _not_blank(v)
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
View File
+148
View File
@@ -0,0 +1,148 @@
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
);
-- lab3: общая идемпотентность POST /messages.
-- scope: user_id + method + path + key (см. contracts/README.md).
-- body_hash — sha256 канонизированного JSON без attachment_ids=[], чтобы
-- отличать повтор «того же» body (201, тот же Message) от «другого» (409).
CREATE TABLE IF NOT EXISTS idempotency_keys (
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
method TEXT NOT NULL,
path TEXT NOT NULL,
key TEXT NOT NULL,
body_hash TEXT NOT NULL,
response_status INT NOT NULL,
response_body JSONB NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
PRIMARY KEY (user_id, method, path, key)
);
CREATE INDEX IF NOT EXISTS idx_idempotency_created
ON idempotency_keys (created_at);
"""
def init_schema() -> None:
"""Идемпотентная миграция: безопасно вызывать многократно.
Вызывается ОДИН РАЗ отдельным one-shot сервисом migrate
(см. compose.yaml). Реплики API миграции больше не выполняют:
они ждут service_completed_successfully.
"""
with connection() as conn:
with conn.cursor() as cur:
cur.execute(SCHEMA_SQL)
conn.commit()
def run_migrations() -> None:
"""Точка входа для one-shot migrate-контейнера.
Поднимает пул, применяет схему, закрывает пул. Завершается с кодом 0
при успехе — этого достаточно для service_completed_successfully.
"""
init_pool()
try:
init_schema()
finally:
close_pool()
if __name__ == "__main__":
# Запуск: python -m app.storage.db
# (в compose.yaml — command: ["python", "-m", "app.storage.db"])
import logging
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s %(levelname)s %(name)s %(message)s",
)
log = logging.getLogger("migrate")
log.info("event=migrations_start")
run_migrations()
log.info("event=migrations_done")
+177
View File
@@ -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() # единственный экземпляр хранилища на процесс
+356
View File
@@ -0,0 +1,356 @@
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()]
# ---------- Идемпотентность (lab3) ----------
def add_message_idempotent(
self,
chat_id: UUID,
sender_id: UUID,
text: str,
user_id: UUID,
method: str,
path: str,
key: str,
body_hash: str,
) -> tuple[str, Optional[Message], Optional[dict]]:
"""Атомарная отправка сообщения с идемпотентностью.
Возвращает одно из:
('created', message, None) — мы выиграли гонку и создали сообщение;
('replay', None, info) — ключ уже занят; info = {body_hash,
response_status, response_body}
('retry', None, None) — конфликт при INSERT, но строки нет
(крайне редко); вызывающий может
повторить запрос.
ВСЁ делается в ОДНОЙ транзакции: либо строка idempotency_keys
и строка messages фиксируются вместе, либо не фиксируется ничего.
Это устраняет блокер, когда сообщение сохранено, а ключ остался
с response_status=0 и повтор зависал.
"""
import json as _json
with connection() as conn:
with conn.cursor() as cur:
# 1) Пытаемся занять ключ. ON CONFLICT DO NOTHING — атомарно.
cur.execute(
"INSERT INTO idempotency_keys"
" (user_id, method, path, key, body_hash, response_status, response_body)"
" VALUES (%s, %s, %s, %s, %s, 0, '{}'::jsonb)"
" ON CONFLICT (user_id, method, path, key) DO NOTHING"
" RETURNING key",
(user_id, method, path, key, body_hash),
)
won = cur.fetchone() is not None
if won:
# 2) Мы выиграли: создаём сообщение в ТОЙ ЖЕ транзакции.
message = Message(
id=uuid4(), chat_id=chat_id, sender_id=sender_id,
text=text, created_at=now_utc(),
)
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),
)
# 3) Сразу пишем финальный ответ в ту же строку ключа.
body_json = _json.loads(message.model_dump_json())
cur.execute(
"UPDATE idempotency_keys"
" SET response_status = %s, response_body = %s"
" WHERE user_id = %s AND method = %s AND path = %s AND key = %s",
(201, _json.dumps(body_json),
user_id, method, path, key),
)
# Один commit — либо всё, либо ничего.
conn.commit()
return ("created", message, None)
# Ключ уже занят. Читаем строку в этой же транзакции.
cur.execute(
"SELECT body_hash, response_status, response_body"
" FROM idempotency_keys"
" WHERE user_id = %s AND method = %s AND path = %s AND key = %s",
(user_id, method, path, key),
)
row = cur.fetchone()
conn.commit()
if row is None:
# Только что был конфликт, а строки нет — редкий случай; повтор.
return ("retry", None, None)
return (
"replay",
None,
{
"body_hash": row[0],
"response_status": row[1],
"response_body": row[2],
},
)
storage = PostgresStorage() # единственный экземпляр на процесс
+143
View File
@@ -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
+40
View File
@@ -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 ("lab1_test_negative.py", "lab1_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()
+70
View File
@@ -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)
+194
View File
@@ -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)
+100
View File
@@ -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)
+587
View File
@@ -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)
+465
View File
@@ -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)
+10
View File
@@ -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;
+81
View File
@@ -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;
+223
View File
@@ -0,0 +1,223 @@
#!/usr/bin/env python3
"""Уровень 4 lab3: два X-Instance-Id, идемпотентность под нагрузкой, отказ одной реплики.
Запуск:
python student-tests/lab3_test_level4.py --base-url http://localhost:8080
Требуется рабочий стенд из compose.yaml (LB + 2 реплики + Postgres + Redis).
"""
import base64
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
# ---------- 1. Два X-Instance-Id через LB ----------
def test_two_instances(c):
"""Один пользователь, серия запросов — видим >=2 разных X-Instance-Id.
Nginx с keepalive к upstream прибивает клиента к одной реплике на всё
время соединения. Поэтому каждый проб-запрос шлём с Connection: close,
чтобы LB открывал новое upstream-соединение и честно распределял.
"""
alice, bob, eve, chat = c.bootstrap()
seen = set()
for _ in range(60):
r = c.call("GET", "/api/v1/users/me", actor=alice, schema="User",
headers={"Connection": "close"})
seen.add(r["headers"]["X-Instance-Id"])
if len(seen) >= 2:
break
check(len(seen) >= 2, "LB не маршрутизирует на разные API-реплики: %s" % seen)
print(" observed instances:", sorted(seen))
# ---------- 2. Идемпотентность: один ключ на двух репликах ----------
def test_idempotency_across_replicas(c):
"""Одновременный POST с одним Idempotency-Key через LB создаёт ровно одно сообщение.
Для этого параллельно шлём 10 запросов с одним ключом из 10 потоков.
LB распределит их по разным репликам; благодаря общей таблице
idempotency_keys и UNIQUE-индексу, INSERT выигрывает ровно один.
"""
alice, bob, eve, chat = c.bootstrap()
key = "idem-" + uuid.uuid4().hex
path = "/api/v1/chats/" + chat["id"] + "/messages"
body = {"text": "idem-concurrent"}
lock = threading.Lock()
results = []
def one(_):
local = Client(c.base, timeout=10)
try:
r = local.call(
"POST", path, (201, 409),
actor=alice, body=body,
headers={"Idempotency-Key": key},
schema="Message",
)
with lock:
results.append((r["status"], r["headers"].get("X-Instance-Id")))
except Failure as exc:
with lock:
results.append(("failure:%s" % exc, None))
with ThreadPoolExecutor(max_workers=10) as pool:
list(pool.map(one, range(10)))
ok = [r for r in results if r[0] == 201]
conflicts = [r for r in results if r[0] == 409]
bad = [r for r in results if r[0] not in (201, 409)]
check(not bad, "unexpected idempotency results: %s" % results)
check(len(ok) >= 1, "no 201 at all")
check(len(ok) + len(conflicts) == 10, "wrong count")
# Проверяем в БД: ровно одно сообщение с этим текстом в этом чате.
# Через API: читаем всю историю и считаем.
from urllib.parse import quote
items = []
cursor = None
for _ in range(50):
q = path + "?limit=100"
if cursor:
q += "&cursor=" + quote(cursor, safe="")
page = c.call("GET", q, actor=bob, schema="MessagePage")["json"]
items.extend(m for m in page["items"] if m["text"] == "idem-concurrent")
cursor = page["next_cursor"]
if cursor is None:
break
check(len(items) == 1, "idempotency created %d messages, expected 1" % len(items))
# X-Instance-Id: запросы шли на разные реплики (проверяем, что 201 пришёл
# хотя бы с одной, а 409 — с другой; это ожидание не обязательное, но
# полезный сигнал, что LB реально распределяет).
ok_instances = {r[1] for r in ok}
conflict_instances = {r[1] for r in conflicts}
print(" 201 instances:", ok_instances, " 409 instances:", conflict_instances)
print(" PASS: idempotency OK, ровно одно сообщение создано")
# ---------- 3. Отказ одной реплики ----------
def test_stop_one_replica(c):
"""Останавливаем одну реплику; вторая продолжает обслуживать запросы.
Восстановление делаем явно через `docker start` в finally, а ожидание
готовности — ПОСЛЕ try/finally, чтобы не использовать return в finally.
"""
alice, bob, eve, chat = c.bootstrap()
path = "/api/v1/chats/" + chat["id"] + "/messages"
# Список контейнеров сервиса api (compose project name неизвестен,
# ищем по image/label).
ps = subprocess.run(
["docker", "ps", "--filter", "label=com.docker.compose.service=api",
"--format", "{{.ID}}"],
capture_output=True, text=True, timeout=10,
)
ids = [x.strip() for x in ps.stdout.splitlines() if x.strip()]
check(len(ids) >= 2, "нужно >=2 контейнера api, найдено %d" % len(ids))
target = ids[0]
print(" останавливаем replica container:", target[:12])
# Готовим одно подтверждённое сообщение до отказа.
key0 = "before-" + uuid.uuid4().hex
first = c.call("POST", path, 201, actor=alice, body={"text": "before-fail"},
headers={"Idempotency-Key": key0}, schema="Message")["json"]
# Останавливаем реплику.
stop = subprocess.run(["docker", "stop", "-t", "5", target],
capture_output=True, text=True, timeout=30)
check(stop.returncode == 0, "docker stop failed: %s" % stop.stderr)
try:
# Даём LB обнаружить отказ (proxy_next_upstream, max_fails=2).
time.sleep(3)
# Читаем и пишем — должны попадать во вторую реплику.
deadline = time.monotonic() + 10
recovered = False
seen_instances = set()
while time.monotonic() < deadline:
try:
r = c.call("POST", path, 201, actor=alice,
body={"text": "after-fail"},
headers={"Idempotency-Key": "after-" + uuid.uuid4().hex},
schema="Message")
seen_instances.add(r["headers"].get("X-Instance-Id"))
recovered = True
break
except Failure:
time.sleep(0.5)
check(recovered, "не удалось записать после отказа за 10 секунд")
# Убеждаемся, что подтверждённое до отказа сообщение доступно.
from urllib.parse import quote
items, cursor = [], None
while True:
q = path + "?limit=100"
if cursor:
q += "&cursor=" + quote(cursor, safe="")
page = c.call("GET", q, actor=bob, schema="MessagePage")["json"]
items.extend(page["items"])
cursor = page["next_cursor"]
if cursor is None:
break
check(any(m["id"] == first["id"] for m in items),
"подтверждённое сообщение потеряно после отказа")
print(" after-fail instances:", seen_instances)
print(" PASS: стенд пережил отказ одной реплики")
finally:
# Только восстановление реплики. Никаких return/break/continue.
subprocess.run(["docker", "start", target],
capture_output=True, text=True, timeout=30)
# Ждём готовности через LB — УЖЕ ВНЕ finally.
deadline = time.monotonic() + 60
while time.monotonic() < deadline:
try:
c.call("GET", "/health/ready", 200)
# И двух реплик снова должно быть >=2.
seen = set()
for _ in range(30):
seen.add(c.call("GET", "/api/v1/users/me", actor=alice,
schema="User")["headers"]["X-Instance-Id"])
if len(seen) >= 2:
break
if len(seen) >= 2:
return
except Failure:
pass
time.sleep(1)
raise Failure("стенд не восстановился до двух реплик за 60 секунд")
# ---------- main ----------
def main():
args = arguments("Lab3 level 4 checks")
c = Client(args.base_url, args.ca_file)
print("=== test_two_instances ===")
test_two_instances(c)
print("PASS: >=2 X-Instance-Id через LB")
print("=== test_idempotency_across_replicas ===")
test_idempotency_across_replicas(c)
print("PASS: идемпотентность на общих ключах")
print("=== test_stop_one_replica ===")
test_stop_one_replica(c)
print("PASS: отказ одной API-реплики обработан")
print("PASS: all lab3 level-4 checks passed")
if __name__ == "__main__":
run(main)