Author SHA1 Message Date
RainakandClaude Opus 5.5 7844e7d4b8 Перенос исправления PR #99 (lab3): строки с U+0000 вместо 500
Expand-миграция 0005 (*_raw bytea для text, display_name, title), app/pgtext.py,
тест test_nul_in_text_roundtrip в регрессии lab3, раздел в REPORT.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 12:33:43 +03:00
RainakandClaude Opus 5.5 25d59bbcb2 REPORT: ссылка на PR
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 19:00:07 +03:00
RainakandClaude Opus 5.5 2dca5c114b ЛР4 БВТ2304 Запорожец на 3
Вложения: приватный S3-bucket (RustFS 1.0.4) + метаданные в PostgreSQL, upload PNG/JPEG
с лимитами до декодирования, авторизованный download, attachment_ids в сообщениях,
идемпотентный bootstrap bucket, failover/persistence/S3-down тесты и REPORT.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 18:49:12 +03:00
46 changed files with 3763 additions and 16 deletions
+27 -1
View File
@@ -7,7 +7,9 @@ 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
# postgres - sessions only in PostgreSQL
# postgres+valkey - PostgreSQL is the source of truth, Valkey is a shared read-through session cache with TTL
SESSION_STORE=postgres+valkey
CACHE_URL_FILE=/run/secrets/cache_url
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
@@ -18,3 +20,27 @@ S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
# --- solution-specific (lab3) ---
# Max lifetime of a cached session copy (also the cache-distrust window after a Valkey error)
SESSION_CACHE_TTL_SECONDS=60
# On SIGTERM a replica keeps serving but reports not-ready this long, so the LB drains it
SHUTDOWN_DRAIN_MS=3000
# Bounded pool and timeouts, per replica
DB_POOL_MAX=10
DB_STATEMENT_TIMEOUT_MS=5000
DB_ACQUIRE_TIMEOUT_MS=2000
CACHE_TIMEOUT_MS=300
# Parallel Argon2id computations per replica (each uses 64 MiB)
PASSWORD_HASH_WORKERS=2
# --- solution-specific (lab4) ---
# Deadline of one S3 operation (connect 2 s, no retries); after it the API answers 503
S3_TIMEOUT_MS=5000
# Parallel image validations per replica (CPU/RAM bound)
IMAGE_CHECK_WORKERS=2
# Per-replica limits
API_CPUS=1.0
API_MEMORY=384M
PG_CPUS=2.0
# Host ports bound to 127.0.0.1: LB entrypoint and LB stats page
LB_PUBLISHED_PORT=8080
LB_STATS_PORT=8404
+6
View File
@@ -0,0 +1,6 @@
# Shell-скрипты выполняются в Linux-контейнерах: всегда LF, даже при checkout на Windows.
*.sh text eol=lf
*.sql text eol=lf
*.conf text eol=lf
Dockerfile text eol=lf
*.Dockerfile text eol=lf
+30
View File
@@ -0,0 +1,30 @@
# API мессенджера lab4 (stateless-реплика). Образ собирается из исходников этого репозитория.
FROM python:3.12.12-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1 \
PIP_DISABLE_PIP_VERSION_CHECK=1
WORKDIR /srv
# Сначала зависимости (кэшируемый слой), потом код.
COPY requirements.txt .
RUN pip install --no-deps -r requirements.txt
COPY app ./app
COPY migrations ./migrations
RUN useradd --system --uid 10001 --no-create-home appuser
USER appuser
EXPOSE 8080
HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=3 \
CMD ["python", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).status == 200 else 1)"]
# Метка сборки (последний слой, кэш не ломает): rolling update показывает, что реплики заменены новым образом.
ARG BUILD_ID=dev
LABEL org.opencontainers.image.revision=$BUILD_ID
# exec-форма: python — PID 1 и сам получает SIGTERM от docker stop (drain -> graceful shutdown).
CMD ["python", "-m", "app"]
+140 -15
View File
@@ -1,37 +1,162 @@
# Отчёт — лабораторная 4
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Запорожец Михаил, БВТ2304
- Целевая оценка: **3** (трек 5 не заявлен)
- Commit/PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab4/pulls/115 (ветка `solution/bvt2304-zaporozhets`, коммит 2dca5c1)
- Использованные источники, библиотеки и помощь ИИ: документация AWS S3 (object uploads, bucket policy), RustFS (docs.rustfs.com, переменные `RUSTFS_*`), спецификация PNG (IHDR, IDAT, Adam7), Pillow (lazy open, `verify`, `draft`, `MAX_IMAGE_PIXELS`), Docker Compose (secrets, healthcheck, `service_completed_successfully`). Библиотеки: FastAPI 0.115, uvicorn 0.34, asyncpg 0.30, argon2-cffi 23.1, redis-py 5.2, **minio-py 7.2.18** (S3-клиент), **Pillow 11.3.0**. Код, конфигурации и тесты написаны с помощью ИИ-ассистента (Claude); решения разобраны и проверены автором.
## Исправления по замечаниям преподавателя
| Замечание | Причина | Исправление | Проверка |
| --- | --- | --- | --- |
| PR lab3 #99, `app/main.py:380`: `{"text":"abc\u0000def"}` с действующей сессией и новым ключом возвращает 500 вместо 201 | Тип `text` в PostgreSQL не может хранить байт 0x00, INSERT падал с ошибкой кодировки. Та же ошибка была у `display_name` и `title` чата | Миграция `migrations/0005_nul_safe_text.sql` (только expand) добавляет nullable `display_name_raw`, `title_raw`, `text_raw bytea`. Если строка содержит U+0000, в `*_raw` пишутся её точные UTF-8 байты, а в основной столбец — та же строка с U+FFFD вместо U+0000: длина не меняется, CHECK и предыдущая версия при rolling update продолжают работать. При чтении API отдаёт точную строку из `*_raw` (`app/pgtext.py`). Fingerprint идемпотентности считается по исходной строке | `test_nul_in_text_roundtrip`: 201, точный текст в ответе, в истории и в идемпотентном повторе; другой текст с тем же ключом → 409; `display_name` и `title` с NUL сохраняются точно (`evidence/student-tests.txt`) |
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
**Нужно:** Docker Engine/Desktop с Compose v2.20+ (проверено: Docker 29.8.2, Compose 5.6.0, Windows 11 + Docker Desktop, WSL2) и POSIX-shell (Linux/macOS или Git Bash). Python и make на хосте **не нужны**: проверки запускаются в сервисе `tester`.
| Роль | Сервис | Образ | Health/readiness | Volume | Сеть / порт | Credentials |
| --- | --- | --- | --- | --- | --- | --- |
| Балансировщик | `lb` | `haproxy:3.2.8-alpine` | wget `/stats`; сам проверяет API по `/health/ready` | — | edge; **единственная** публикация `127.0.0.1:8080` (+ `127.0.0.1:8404` статистика) | не нужны |
| API × N | `api` (`deploy.replicas: ${API_REPLICAS:-2}`) | сборка `Dockerfile` (python:3.12.12-slim-bookworm) | HEALTHCHECK `/health/ready` | **нет**; root fs read-only, `/tmp` tmpfs | edge + data; порты не публикуются | secrets `database_url`, `cache_url`, `s3_access_key_id`, `s3_secret_access_key` |
| Миграции | `migrate` (one-shot) | тот же образ | exit 0 | — | data | secret `database_url` |
| **S3** | `s3` | `rustfs/rustfs:1.0.4@sha256:ed9210d6…dcc2` | curl `/health` | **`s3data`** | data (internal); порты **не публикуются**, веб-консоль выключена | `RUSTFS_ACCESS_KEY_FILE`, `RUSTFS_SECRET_KEY_FILE` |
| Bootstrap bucket | `s3-init` (one-shot) | образ API, `python -m app.s3_bootstrap` | exit 0 | — | data | S3 secrets |
| PostgreSQL | `postgres` | `postgres:17.7-bookworm` | `pg_isready` | `pgdata` | data (internal) | `POSTGRES_PASSWORD_FILE` |
| Кэш сессий | `valkey` | `valkey/valkey:8.1.4` | `valkey-cli ping` | нет (кэш) | data (internal) | `requirepass` в secret `valkey_conf` |
| API с TTL=2 с | `api-ttl` (profile `test`) | образ API | как у api | — | edge + data | как у api |
| Тестовый стенд | `tester` (profile `tools`) | python:3.12.12-alpine3.22 + make + curl + docker-cli | — | bind `.` | edge | docker.sock |
```sh
git clone <repo> && cd <repo>
sh scripts/init-secrets.sh # ./secrets/* (пароль БД, Valkey, ключи S3) и .env из .env.example; значения не печатает
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait
# postgres, s3, valkey -> migrate (схема) -> s3-init (bucket) -> api x2 (healthy) -> lb
# Публичные проверки (Linux-контейнер tester; на Linux-хосте можно просто `make ...`)
docker compose --env-file .env --profile tools run --rm tester make check
docker compose --env-file .env --profile tools run --rm tester make test
docker compose --env-file .env --profile tools run --rm tester make test-failover ACTION_SCRIPT=scripts/stop-one.sh
docker compose --env-file .env --profile tools run --rm tester sh scripts/restore.sh # вернуть реплику
docker compose --env-file .env --profile tools run --rm tester make test-persistence ACTION_SCRIPT=scripts/restart.sh
sh scripts/test-lab4.sh # собственные тесты lab4 + регрессия lab3 и lab2
sh scripts/collect-evidence.sh # все доказательства evidence/*.txt одной командой
```
- **Bootstrap БД:** `python -m app.migrate` (сервис `migrate`) применяет `migrations/NNNN_*.sql` по порядку под `pg_advisory_lock`. Новая миграция lab4 — `0004_attachments.sql`, она только добавляет объекты (expand).
- **Bootstrap S3:** `python -m app.s3_bootstrap` (сервис `s3-init`). Создаёт bucket `messenger-attachments`, если его нет. Если у bucket есть политика анонимного доступа, удаляет её. Затем кладёт служебный объект и делает **анонимный GET в обход API**: ожидается 403, иначе bootstrap падает и API не стартует. Повторный запуск безопасен: печатает `exists` и данные не трогает (`evidence/stand.txt`).
- **Действий оператора**, кроме `init-secrets.sh`, не требуется. Если на 8080 работает стенд lab3, его нужно остановить (`docker compose -p mtusi-lab3 stop`) или задать `LB_PUBLISHED_PORT` в `.env`.
- **Безопасная остановка** (данные сохраняются): `docker compose --env-file .env stop` или `... down`.
- **Намеренное удаление учебных данных:** `docker compose --env-file .env down -v` (удаляет volumes `mtusi-lab4_pgdata` и `mtusi-lab4_s3data`); секреты — каталог `secrets/`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
клиент ──HTTP──> lb: HAProxy 3.2 (127.0.0.1:8080) сеть edge
│ roundrobin, без sticky, /health/ready раз в 1 с
┌───────┴────────┐
▼ ▼
api-1 ... api-N (FastAPI/uvicorn, stateless, read-only FS)
│ │ сеть data (internal)
┌──────┼────────────────┼──────────┐
▼ ▼ ▼ ▼
postgres (pgdata) s3: RustFS (s3data) valkey (кэш сессий)
users, chats, приватный bucket
messages, sessions, messenger-attachments/
attachments (мета), attachments/<uuid> ← байты оригиналов
message_attachments
```
**Что перенесено из lab3 без изменений:** HAProxy (DNS-обнаружение реплик, проверка готовности, повтор только безопасных запросов), drain по SIGTERM, `X-Instance-Id`, обязательный `Idempotency-Key`, Argon2id, Bearer-сессии в PostgreSQL с кэшем в Valkey, однократные миграции, hook-скрипты `stop-one.sh`/`restore.sh`. Тесты lab3 и lab2 оставлены как регрессия.
**Что добавлено в lab4:**
| Где | Что |
| --- | --- |
| `migrations/0004_attachments.sql` | Таблица `attachments`: id, chat_id, owner_id, filename, content_type, size_bytes, sha256, width, height, object_key, status, created_at, updated_at. Таблица `message_attachments` (message_id, attachment_id, chat_id, position). Ограничение `text` ослаблено до 0..4000: сообщение может состоять только из вложений. |
| `app/storage.py` | S3-клиент (minio-py → RustFS по S3 API): put/get/delete с дедлайном на операцию и компенсирующее удаление. |
| `app/images.py` | Ограниченное чтение тела и проверка PNG/JPEG по содержимому. |
| `app/s3_bootstrap.py` | Идемпотентное создание приватного bucket и проверка анонимного доступа. |
| `app/main.py` | `POST /chats/{id}/attachments`, `GET /attachments/{id}`, `GET /attachments/{id}/content`; `attachment_ids` в сообщениях. |
**Источник истины.** Метаданные вложения и связь с чатом и сообщением хранятся в PostgreSQL. Байты оригинала лежат только в S3: ни в БД, ни на диске API их нет. Вложение заранее привязано к **чату**: `attachments.chat_id` задаётся при загрузке, а к сообщению файл привязывается позже, через `attachment_ids`. Составные FK `(attachment_id, chat_id)` и `(message_id, chat_id)` не дают даже на уровне БД прикрепить файл другого чата.
**Object key** назначает сервер: `attachments/<случайный UUID>`. Имя файла клиента в ключе не участвует и хранится только для отображения. В ответах API ключа, адреса S3 и credentials нет.
**Порядок загрузки и когда честно вернуть 201:**
1. Аутентификация, затем проверка членства в чате. Посторонний получает 404 до чтения тела, то есть не может залить в чужой чат ни байта.
2. Проверка `filename` (400) и `Content-Type` (только `image/png` или `image/jpeg`, иначе 415).
3. Чтение тела с лимитом. Если `Content-Length` больше 10 MiB — сразу 413. Тело читается потоком с обрывом на 10 485 761-м байте, так что и chunked без длины ограничен.
4. Проверка содержимого: сигнатура должна совпасть с `Content-Type`, иначе 415. Размеры читаются из заголовка; если `ширина × высота` больше 40 млн, ответ 413 **до распаковки пикселей**. Только после этого идёт проверка целостности: у PNG — CRC чанков и потоковая распаковка IDAT со сверкой объёма с IHDR (пиксели не хранятся), у JPEG — декодирование в режиме draft 1/8. Повреждённый файл получает 415.
5. `PUT` в S3. Сбой даёт 503, метаданных при этом нет.
6. `INSERT` метаданных в PostgreSQL. Если он не прошёл (БД недоступна, клиент оборвал соединение), API удаляет только что записанный объект: это компенсация.
7. **201 `status=ready`** отдаётся только после `COMMIT`. К этому моменту и байты, и запись уже надёжно сохранены.
**Если S3 PUT прошёл, а COMMIT в PostgreSQL — нет**, срабатывает компенсация из шага 6: объект удаляется, клиент получает 503 и может повторить загрузку. Если упадёт и сама компенсация (S3 тоже недоступен) или процесс API убьют между шагами 5 и 6, в bucket останется неучтённый объект. На метаданные и доступ он не влияет, но место занимает. Автоматическая сверка и очистка таких объектов с grace period — это критерий уровня 4, здесь она **не реализована** (см. «Ограничения»). Обратная ситуация невозможна: запись в БД без объекта не появится, потому что INSERT выполняется только после успешного PUT.
**Скачивание** проходит через API: сначала аутентификация, потом проверка членства в чате вложения, затем чтение из S3. Байты отдаются с истинным `Content-Type` и **без redirect**. Посторонний получает 404 одинаково на метаданные и на content. Ответ несёт заголовки `Cache-Control: private, no-store`, `X-Content-Type-Options: nosniff` и `ETag` = sha256.
**Почему приватный bucket и случайный ключ не заменяют ACL приложения.** Ключ попадает в логи, URL и историю браузера, его можно переслать. Кроме того, «случайный» не значит «секретный навсегда»: участника могут исключить из чата, а ключ останется прежним. Приватный bucket защищает только от анонимного доступа к S3, а знает, кто участник чата, одно приложение. Поэтому проверка выполняется на каждый запрос к API.
**Почему файл в Docker volume одной реплики — не объектное хранилище.** Volume привязан к конкретному контейнеру и хосту. Файл, загруженный через `api-1`, не виден `api-2`: после остановки `api-1` download через другую реплику вернул бы 404 или 500. Именно это проверяет `test_failover_of_uploading_replica`. У API в этом решении корневая ФС read-only, а `/tmp` — tmpfs, так что локальной копии нет физически (`test_no_local_copy_on_api`).
**Готовность (`/health/ready`).** Критична только PostgreSQL, как и в lab3. Недоступность S3 **не** выводит реплики из балансировки: текст, история и метаданные вложений продолжают работать, а upload и download честно отвечают 503 за ограниченное время. Если бы S3 входил в readiness, его сбой выключил бы весь мессенджер, включая текстовые сообщения.
**Таймауты S3.** Подключение — 2 с, чтение — `S3_TIMEOUT_MS` (5 с), повторов на уровне HTTP-клиента нет. Дополнительно стоит общий дедлайн операции (`asyncio.wait_for`): DNS-резолв остановленного контейнера во внутренней сети Docker занимал около 8 с и не ограничивался таймаутами urllib3. Дедлайн (5 с) меньше `timeout server` HAProxy (15 с), поэтому клиент получает 503 от API, а не 504 от LB.
**Память.** Тело загрузки держится в памяти целиком (до 10 MiB). Проверку изображений одновременно выполняют не больше `IMAGE_CHECK_WORKERS=2` на реплику. PNG не декодируется в пиксели, JPEG декодируется в масштабе 1/8. Лимит контейнера API — 384 MiB. Эксперимент с ≥10 одновременными загрузками и замером пика RAM относится к уровню 4 и не проводился.
**S3-сервер: RustFS, а не MinIO.** Образы MinIO на момент выполнения удалены из публичных реестров (Docker Hub: «repository does not exist», quay.io: 401). RustFS 1.0.4 (релиз 25.10.2026) закреплён по тегу и digest и совместим по S3 API, поэтому клиент — стандартный minio-py. Веб-консоль RustFS по умолчанию выключена (`RUSTFS_CONSOLE_ENABLE` не задан), порты S3 на хост не публикуются, сеть `data` помечена internal.
**Соответствие `.env.example` реальной конфигурации:**
| Переменная | Где используется |
| --- | --- |
| `S3_ENDPOINT`, `S3_REGION`, `S3_BUCKET` | `app/config.py` → `app/storage.py`, `app/s3_bootstrap.py`; `RUSTFS_REGION` у сервиса `s3` |
| `S3_ACCESS_KEY_ID_FILE`, `S3_SECRET_ACCESS_KEY_FILE` | compose secrets `s3_access_key_id`, `s3_secret_access_key` (создаёт `init-secrets.sh`); те же файлы — root credentials RustFS |
| `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS` | `app/config.py`, значения можно только уменьшить относительно контракта |
| `S3_TIMEOUT_MS`, `IMAGE_CHECK_WORKERS` | добавлены решением: дедлайн S3-операции и число параллельных проверок изображений |
| остальные | без изменений с lab3 |
## Доказательства критериев
Все файлы получены одной командой `sh scripts/collect-evidence.sh` на запущенном стенде 12.11.2026.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke | `make check`, `make validate`, `make test` | `PASS: lab4 public API scenario` (upload 201 ready, `attachment_ids`, download вторым участником = оригинал, 404 постороннему) | `evidence/public-tests.txt` |
| Возможности lab3 сохранены | `make test-failover` ×2, регрессия `test_lab3.py`, `test_lab2_regression.py` | обе реплики остановлены по очереди, `failed_attempts: 0`; 8/8 и 10/10 | `evidence/failover-hook.txt`, `evidence/student-tests.txt` |
| S3 в общем стенде, приватный bucket | `compose ps`, логи `s3-init`, повторный запуск `s3-init` | `rustfs:1.0.4@sha256` healthy, volume `s3data`; анонимный GET → `HTTP 403`; повтор: `exists` | `evidence/stand.txt` |
| Метаданные в PostgreSQL, байты в S3, не в БД и не на API | `test_no_local_copy_on_api`, `test_bucket_private_outside_api` | rootfs API read-only, нет volume и записываемых bind, `/tmp` пуст; в `attachments` только метаданные и `object_key` | `evidence/student-tests.txt`, `migrations/0004_attachments.sql` |
| 201 ready, побайтный download, SHA-256 | `test_png_and_jpeg_roundtrip` | PNG и JPEG: `status=ready`, `variants=[]`; bytes и sha256 совпадают; `Content-Type` истинный | `evidence/student-tests.txt` |
| Message с `attachment_ids` читается участниками | `test_message_with_attachments` | `text=""` + 2 вложения, порядок сохранён, идемпотентный повтор равен оригиналу, история возвращает `attachment_ids` | там же |
| Посторонний не имеет доступа | smoke, `test_png_and_jpeg_roundtrip`, `test_foreign_attachment_rejected` | 404 на метаданные и content, 401 без токена; upload в чужой чат → 404; вложение другого чата в сообщении → 404, сообщение не создано | там же |
| Лимиты ≤10 MiB / ≤40 Мпикс до чтения/декодирования | `test_limits_and_mime` | 10 MiB + 1 → 413; PNG-заголовок 10000×5000 (~100 байт) → 413 без декодирования; 6000×6000 без пикселей → 415 | там же |
| MIME по содержимому | `test_limits_and_mime` | PNG как `image/jpeg` и JPEG как `image/png` → 415; GIF, обрезанные PNG/JPEG, пустое тело, `text/plain`, multipart → 415 | там же |
| Опасные filename | `test_dangerous_filenames` | `../etc/passwd`, `a/b.png`, `a\b.png`, NUL, `\t`, `\n`, DEL, пустое, `..`, 256 символов → 400; Unicode-имя и 255 символов принимаются | там же |
| Upload → стоп обслужившей реплики → download через другую | `test_failover_of_uploading_replica` | `uploaded via 406b73449330-…, downloaded via 9f9f380ebef7-…`, байты совпадают | там же |
| Restart с volumes сохраняет метаданные и оригинал | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS` (тест lab4 повторно читает метаданные и скачивает оригинал прежним токеном); `StartedAt` всех процессов (lb, api×2, postgres, **s3**, valkey) сменился | `evidence/persistence.txt` |
| Недоступность S3 | `test_s3_unavailable` | `docker stop s3`: upload и download → 503 (не 500, не 504), текст → 201, метаданные → 200, `/health/ready` → 200; после `docker start` тот же файл скачивается | `evidence/student-tests.txt` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Стенд: Windows 11, Docker Desktop (WSL2) — VM 8 CPU / 4 GiB. Лимиты: API 1 CPU / 384 MiB на реплику, RustFS 1 CPU / 512 MiB, PostgreSQL 2 CPU / 768 MiB. Fixture: `tests/fixtures/sample.png` (111 817 байт) и синтетический `student-tests/fixtures/sample.jpg` 160×100 (1 992 байта).
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `docker stop` реплики, загрузившей файл | download через другую реплику | тот же файл, другой `X-Instance-Id` | сразу (LB исключил реплику по drain); потерь нет |
| `make test-failover` для каждой реплики | 0 потерянных подтверждённых записей | 125 успешных записей, `failed_attempts: 0`, вложение скачано после отказа | первая запись после отказа через 4,2–4,7 с; потерь нет |
| `docker stop s3` | 503 на файлы, остальное работает | upload/download 503 за ≤5 с каждый; текст 201; ready 200 | после `docker start s3` файл снова скачивается (≤60 с ожидания в тесте); потерь нет |
| `scripts/restart.sh` (lb, api, postgres, s3, valkey) | данные, сессия и файл сохраняются | `PASS`, `StartedAt` всех 6 процессов новые | весь hook с повторным `migrate`/`s3-init` — около 45 с; потерь нет |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- **Нет сверки и очистки неучтённых объектов** (уровень 4). Компенсация на месте срабатывает при ошибке INSERT, но объект останется, если процесс API убьют между PUT и COMMIT, если не удастся сама компенсация или если PUT завершится в фоне уже после того, как дедлайн вернул клиенту 503. Следующий шаг — фоновый reconciler: обходит bucket, сравнивает ключи с `attachments.object_key` и удаляет объекты без метаданных старше grace period, например 24 часов.
- **API работает с root credentials RustFS.** Отдельный пользователь S3 с правами только на bucket (уровень 4) не настроен.
- **Тело загрузки целиком в памяти** (до 10 MiB на запрос); потоковой передачи в S3 и замера пика RAM при ≥10 параллельных загрузках нет (уровень 4).
- **RustFS в single-node режиме без избыточности** (`storage_class has no parity` в логе): отказ диска означает потерю файлов. Для учебного стенда это допустимо, в production нужен distributed-режим или реплицированное хранилище.
- **Неучтённые объекты от отменённых PUT** возможны из-за дедлайна: поток, который нельзя прервать, может дописать объект уже после ответа 503. Это ещё одна причина, по которой нужен reconciler.
- **Подтверждено:** все обязательные сценарии уровня 3 и регрессия lab3/lab2 (`evidence/`). Остальные пункты уровней 4 и 5 не заявлены.
View File
+48
View File
@@ -0,0 +1,48 @@
"""Запуск: python -m app (HTTP-процесс — PID 1 в контейнере).
SIGTERM (docker stop) обрабатывается в два этапа:
1. drain: SHUTDOWN_DRAIN_MS процесс продолжает обслуживать запросы, но /health/ready отвечает 503 —
балансировщик за это время исключает реплику по активной проверке и перестаёт слать новые запросы;
2. обычный graceful shutdown uvicorn: новые соединения не принимаются, начатые запросы
дообрабатываются до timeout_graceful_shutdown.
"""
import logging
import os
import threading
import uvicorn
from . import lifecycle
log = logging.getLogger('messenger')
class DrainingServer(uvicorn.Server):
drain_seconds = 0.0
def handle_exit(self, sig, frame):
if lifecycle.draining or self.drain_seconds <= 0:
# Повторный сигнал (или drain выключен) — сразу штатное завершение uvicorn.
return super().handle_exit(sig, frame)
lifecycle.start_draining()
log.info('signal %s: draining for %.1fs before shutdown, instance=%s',
sig, self.drain_seconds, lifecycle.INSTANCE_ID)
timer = threading.Timer(self.drain_seconds, super().handle_exit, (sig, frame))
timer.daemon = True
timer.start()
def main() -> None:
logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(name)s %(message)s')
config = uvicorn.Config('app.main:app', host=os.environ.get('APP_HOST', '0.0.0.0'),
port=int(os.environ.get('APP_PORT', '8080')), proxy_headers=False,
server_header=False, timeout_graceful_shutdown=10,
timeout_keep_alive=30) # дольше, чем держит idle-соединение HAProxy
server = DrainingServer(config)
server.drain_seconds = int(os.environ.get('SHUTDOWN_DRAIN_MS', '3000')) / 1000
log.info('starting instance %s', lifecycle.INSTANCE_ID)
server.run()
if __name__ == '__main__':
main()
+89
View File
@@ -0,0 +1,89 @@
"""Настройки из переменных окружения. Секреты читаются только из файлов (*_FILE)."""
import os
from dataclasses import dataclass
from pathlib import Path
def _int(name: str, default: int, low: int, high: int) -> int:
value = int(os.environ.get(name, default))
if not low <= value <= high:
raise ValueError(f'{name} must be in [{low}, {high}]')
return value
def _secret(name: str) -> str | None:
"""Значение из файла, путь к которому лежит в переменной NAME_FILE."""
path = os.environ.get(name + '_FILE')
if not path:
return None
return Path(path).read_text(encoding='utf-8').strip()
def _required_secret(name: str) -> str:
value = _secret(name)
if not value:
raise RuntimeError(f'{name}_FILE is not configured')
return value
@dataclass(frozen=True)
class Settings:
host: str
port: int
session_ttl: int
session_store: str
session_cache_ttl: int
database_url: str
cache_url: str | None
db_pool_max: int
db_statement_timeout_ms: int
db_acquire_timeout: float
cache_timeout: float
hash_workers: int
idempotency_ttl: int
drain_seconds: float
s3_endpoint: str
s3_region: str
s3_bucket: str
s3_access_key: str
s3_secret_key: str
s3_timeout: float
max_upload_bytes: int
max_image_pixels: int
image_workers: int
def load() -> Settings:
database_url = _secret('DATABASE_URL') or os.environ.get('DATABASE_URL')
if not database_url:
raise RuntimeError('DATABASE_URL_FILE is not configured')
store = os.environ.get('SESSION_STORE', 'postgres')
if store not in ('postgres', 'postgres+valkey'):
raise ValueError('SESSION_STORE must be postgres or postgres+valkey')
cache_url = _secret('CACHE_URL') if store == 'postgres+valkey' else None
return Settings(
host=os.environ.get('APP_HOST', '0.0.0.0'),
port=_int('APP_PORT', 8080, 1, 65535),
session_ttl=_int('SESSION_TTL_SECONDS', 3600, 1, 30 * 24 * 3600),
session_store=store,
session_cache_ttl=_int('SESSION_CACHE_TTL_SECONDS', 60, 1, 3600),
database_url=database_url,
cache_url=cache_url,
db_pool_max=_int('DB_POOL_MAX', 10, 1, 100),
db_statement_timeout_ms=_int('DB_STATEMENT_TIMEOUT_MS', 5000, 100, 600000),
db_acquire_timeout=_int('DB_ACQUIRE_TIMEOUT_MS', 2000, 100, 60000) / 1000,
cache_timeout=_int('CACHE_TIMEOUT_MS', 300, 10, 10000) / 1000,
hash_workers=_int('PASSWORD_HASH_WORKERS', 4, 1, 32),
idempotency_ttl=_int('IDEMPOTENCY_TTL_SECONDS', 86400, 86400, 30 * 24 * 3600), # контракт: не менее 24 ч
drain_seconds=_int('SHUTDOWN_DRAIN_MS', 3000, 0, 60000) / 1000,
s3_endpoint=os.environ.get('S3_ENDPOINT', 'http://s3:9000'),
s3_region=os.environ.get('S3_REGION', 'us-east-1'),
s3_bucket=os.environ.get('S3_BUCKET', 'messenger-attachments'),
s3_access_key=_required_secret('S3_ACCESS_KEY_ID'),
s3_secret_key=_required_secret('S3_SECRET_ACCESS_KEY'),
s3_timeout=_int('S3_TIMEOUT_MS', 5000, 100, 12000) / 1000, # < timeout server HAProxy (15 с)
# Контракт: не более 10 MiB и 40 млн пикселей; значения можно только уменьшить.
max_upload_bytes=_int('MAX_UPLOAD_BYTES', 10485760, 1, 10485760),
max_image_pixels=_int('MAX_IMAGE_PIXELS', 40_000_000, 1, 40_000_000),
image_workers=_int('IMAGE_CHECK_WORKERS', 2, 1, 16),
)
+65
View File
@@ -0,0 +1,65 @@
"""Ограниченный пул соединений asyncpg и перевод сбоев БД в 503."""
import asyncio
from contextlib import asynccontextmanager
import asyncpg
from .config import Settings
from .errors import unavailable
# Ошибки "БД недоступна/перегружена" -> 503, а не 500 и тем более не пропуск запроса.
DB_UNAVAILABLE = (
OSError,
asyncio.TimeoutError,
asyncpg.PostgresConnectionError,
asyncpg.InterfaceError,
asyncpg.CannotConnectNowError,
asyncpg.TooManyConnectionsError,
asyncpg.QueryCanceledError, # statement_timeout
asyncpg.AdminShutdownError,
)
class Database:
def __init__(self, settings: Settings):
self.settings = settings
self.pool: asyncpg.Pool | None = None
async def start(self) -> None:
s = self.settings
# min_size соединений создаётся лениво (connect при первом acquire), поэтому API стартует
# даже при недоступной БД и честно отвечает 503 в /health/ready.
self.pool = asyncpg.create_pool(
s.database_url,
min_size=0,
max_size=s.db_pool_max,
timeout=3, # таймаут установления соединения
command_timeout=s.db_statement_timeout_ms / 1000 + 1,
max_inactive_connection_lifetime=300,
server_settings={
'application_name': 'messenger-api',
'statement_timeout': str(s.db_statement_timeout_ms),
'idle_in_transaction_session_timeout': '10000',
'timezone': 'UTC',
},
)
await self.pool
async def close(self) -> None:
if self.pool is not None:
await self.pool.close()
@asynccontextmanager
async def connection(self):
try:
async with self.pool.acquire(timeout=self.settings.db_acquire_timeout) as conn:
yield conn
except DB_UNAVAILABLE:
raise unavailable() from None
async def ping(self) -> bool:
try:
async with self.pool.acquire(timeout=1) as conn:
return await conn.fetchval('SELECT 1', timeout=1) == 1
except DB_UNAVAILABLE:
return False
+48
View File
@@ -0,0 +1,48 @@
"""Единый формат ошибок {"error":{"code","message","request_id"}}."""
from contextvars import ContextVar
from fastapi.responses import JSONResponse
request_id_var: ContextVar[str] = ContextVar('request_id', default='-')
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
class ApiError(Exception):
def __init__(self, status: int, code: str, message: str, headers: dict | None = None):
super().__init__(message)
self.status = status
self.code = code
self.message = message
self.headers = headers or {}
def invalid(message: str = 'Некорректный запрос') -> ApiError:
return ApiError(400, 'invalid_request', message)
def not_found() -> ApiError:
# Одинаковый ответ для "нет такого" и "чужое": существование чужого чата не раскрывается.
return ApiError(404, 'not_found', 'Объект не найден')
def unauthorized_bearer() -> ApiError:
return ApiError(401, 'unauthorized', 'Требуется действительная сессия', {'WWW-Authenticate': BEARER_CHALLENGE})
def unauthorized_basic() -> ApiError:
return ApiError(401, 'unauthorized', 'Неверные учётные данные', {'WWW-Authenticate': BASIC_CHALLENGE})
def unavailable() -> ApiError:
return ApiError(503, 'unavailable', 'Сервис временно недоступен')
def error_response(status: int, code: str, message: str, headers: dict | None = None) -> JSONResponse:
rid = request_id_var.get()
return JSONResponse(
status_code=status,
content={'error': {'code': code, 'message': message, 'request_id': rid}},
headers=headers,
)
+156
View File
@@ -0,0 +1,156 @@
"""Приём изображения: ограниченное чтение тела и проверка PNG/JPEG по содержимому.
Порядок выбран так, чтобы ни один лимит не проверялся ПОСЛЕ дорогой операции:
1. Content-Length больше лимита -> 413 сразу, тело не читается;
2. чтение потоком с обрывом на MAX_UPLOAD_BYTES + 1 байте (chunked без длины тоже ограничен);
3. сигнатура (magic bytes) -> тип; несовпадение с Content-Type или чужой формат -> 415;
4. размеры из заголовка изображения (Pillow читает только header) -> > MAX_IMAGE_PIXELS -> 413
ДО распаковки пикселей (защита от decompression bomb);
5. только потом проверка целостности: PNG verify() (CRC чанков), JPEG — декодирование в draft-режиме 1/8.
"""
import asyncio
import io
import warnings
from fastapi import Request
from PIL import Image
from .errors import ApiError
# Лимит пикселей проверяем сами (п.4) с нужным кодом ответа; встроенный в Pillow оставляем как страховку.
Image.MAX_IMAGE_PIXELS = 40_000_000
Image.LOAD_TRUNCATED_IMAGES = False
SIGNATURES = {
'image/png': b'\x89PNG\r\n\x1a\n',
'image/jpeg': b'\xff\xd8\xff',
}
PIL_FORMATS = {'image/png': 'PNG', 'image/jpeg': 'JPEG'}
def too_large(message: str = 'Файл превышает лимит') -> ApiError:
return ApiError(413, 'payload_too_large', message)
def unsupported(message: str = 'Ожидается корректное изображение PNG или JPEG') -> ApiError:
return ApiError(415, 'unsupported_media_type', message)
def declared_type(request: Request) -> str:
media_type = request.headers.get('content-type', '').split(';')[0].strip().lower()
if media_type not in SIGNATURES:
raise unsupported('Content-Type должен быть image/png или image/jpeg')
return media_type
async def read_limited(request: Request, limit: int) -> bytes:
length = request.headers.get('content-length')
if length is not None and length.isdigit() and int(length) > limit:
raise too_large()
buf = bytearray()
async for chunk in request.stream():
buf += chunk
if len(buf) > limit:
raise too_large()
return bytes(buf)
class ImageChecker:
def __init__(self, max_pixels: int, workers: int):
self.max_pixels = max_pixels
# Не больше N одновременных проверок на реплику: декодирование занимает CPU и память.
self.slots = asyncio.Semaphore(workers)
async def inspect(self, data: bytes, declared: str) -> tuple[str, int, int]:
detected = next((t for t, sig in SIGNATURES.items() if data.startswith(sig)), None)
if detected is None or detected != declared:
raise unsupported()
async with self.slots:
return await asyncio.to_thread(self._inspect, data, detected)
def _inspect(self, data: bytes, content_type: str) -> tuple[str, int, int]:
with warnings.catch_warnings():
warnings.simplefilter('error', Image.DecompressionBombWarning)
try:
img = Image.open(io.BytesIO(data)) # ленивый: читает только заголовок
width, height = img.size
if img.format != PIL_FORMATS[content_type]:
raise unsupported()
except (Image.DecompressionBombError, Image.DecompressionBombWarning):
raise too_large('Изображение превышает лимит пикселей') from None
except ApiError:
raise
except Exception:
raise unsupported() from None
if width <= 0 or height <= 0:
raise unsupported()
if width * height > self.max_pixels:
raise too_large('Изображение превышает лимит пикселей')
try:
if content_type == 'image/png':
img.verify() # CRC и структура чанков без хранения пикселей
check_png_pixel_stream(data) # объём пиксельных данных совпадает с IHDR
else:
img.draft('RGB', (max(1, width // 8), max(1, height // 8)))
img.load() # обрезанный/битый JPEG -> исключение
except Exception:
raise unsupported() from None
finally:
img.close()
return content_type, width, height
# ---------- PNG: потоковая проверка пиксельных данных ----------
# verify() Pillow проверяет только CRC чанков. Файл с честным IHDR 6000x6000 и почти пустым IDAT он
# пропустит. Полное декодирование 40 Мпикс заняло бы 160 MiB на запрос, поэтому IDAT распаковывается
# потоково кусками по 64 KiB: считаются только байты, пиксели не хранятся. Распакованный объём должен
# точно совпасть с вычисленным по IHDR, иначе файл повреждён (или это zip-бомба сверх заявленного).
CHANNELS = {0: 1, 2: 3, 3: 1, 4: 2, 6: 4}
ADAM7 = ((0, 0, 8, 8), (4, 0, 8, 8), (0, 4, 4, 8), (2, 0, 4, 4), (0, 2, 2, 4), (1, 0, 2, 2), (0, 1, 1, 2))
def _row_bytes(width: int, bits_per_pixel: int) -> int:
return (width * bits_per_pixel + 7) // 8
def expected_png_raw_size(width: int, height: int, bit_depth: int, color_type: int, interlace: int) -> int:
bpp = CHANNELS[color_type] * bit_depth
if not interlace:
return height * (1 + _row_bytes(width, bpp))
total = 0
for xs, ys, dx, dy in ADAM7:
pw = (width - xs + dx - 1) // dx if width > xs else 0
ph = (height - ys + dy - 1) // dy if height > ys else 0
if pw and ph:
total += ph * (1 + _row_bytes(pw, bpp))
return total
def check_png_pixel_stream(data: bytes) -> None:
import struct
import zlib
pos, expected, produced = 8, None, 0
inflater = zlib.decompressobj()
while pos + 8 <= len(data):
length, kind = struct.unpack('>I4s', data[pos:pos + 8])
body = data[pos + 8:pos + 8 + length]
pos += 12 + length
if kind == b'IHDR':
width, height, bit_depth, color_type, _c, _f, interlace = struct.unpack('>IIBBBBB', body)
expected = expected_png_raw_size(width, height, bit_depth, color_type, interlace)
elif kind == b'IDAT':
if expected is None:
raise ValueError('IDAT before IHDR')
chunk = body
while chunk:
out = inflater.decompress(chunk, 64 * 1024)
produced += len(out)
if produced > expected:
raise ValueError('pixel data larger than IHDR')
chunk = inflater.unconsumed_tail
elif kind == b'IEND':
break
produced += len(inflater.flush())
if expected is None or produced != expected or not inflater.eof:
raise ValueError('pixel data does not match IHDR')
+16
View File
@@ -0,0 +1,16 @@
"""Состояние процесса реплики: идентификатор для X-Instance-Id и флаг drain при SIGTERM."""
import os
import secrets
import socket
# Стабилен в пределах жизни процесса, новый после перезапуска. Префикс — hostname контейнера
# (= короткий ID контейнера в Docker), по нему scripts/stop-one.sh находит именно эту реплику.
# В lab7 по контракту понадобится непрозрачный alias без hostname.
INSTANCE_ID = os.environ.get('INSTANCE_ID') or f'{socket.gethostname()}-{secrets.token_hex(3)}'
draining = False
def start_draining() -> None:
global draining
draining = True
+540
View File
@@ -0,0 +1,540 @@
"""HTTP API мессенджера lab4 по contracts/openapi.json (stateless-реплика за балансировщиком).
lab4: вложения. Метаданные — PostgreSQL, байты — приватный S3-bucket (MinIO). Локальных файлов у API нет.
"""
import asyncio
import base64
import binascii
import hashlib
import json
import logging
import re
import uuid
from contextlib import asynccontextmanager
from datetime import datetime, timezone
from urllib.parse import quote
from uuid import UUID
import asyncpg
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse, Response
from starlette.exceptions import HTTPException as StarletteHTTPException
from . import config, pgtext, images, lifecycle, validation as v
from .db import DB_UNAVAILABLE, Database
from .errors import (ApiError, error_response, invalid, not_found, request_id_var,
unauthorized_basic, unauthorized_bearer, unavailable)
from .security import PasswordService, new_token
from .sessions import SessionStore
from .storage import Storage
log = logging.getLogger('messenger')
settings = config.load()
db = Database(settings)
sessions = SessionStore(settings, db)
passwords = PasswordService(settings.hash_workers)
storage = Storage(settings)
image_checker = images.ImageChecker(settings.max_image_pixels, settings.image_workers)
async def purge_loop() -> None:
while True:
await asyncio.sleep(3600)
try:
removed = await sessions.purge_expired()
keys = await purge_idempotency_keys()
log.info('purged %d expired sessions, %d idempotency keys', removed, keys)
except Exception: # очистка — фоновая гигиена, её сбой не должен ронять процесс
log.warning('purge failed', exc_info=True)
async def purge_idempotency_keys() -> int:
# Удаление по одному ключу индекса created_at; параллельный запуск на нескольких репликах безопасен.
async with db.connection() as conn:
status = await conn.execute(
'DELETE FROM idempotency_keys WHERE created_at < clock_timestamp() - make_interval(secs => $1)',
settings.idempotency_ttl)
return int(status.split()[-1])
@asynccontextmanager
async def lifespan(_app: FastAPI):
await db.start()
task = asyncio.create_task(purge_loop())
yield
task.cancel()
await sessions.cache.close()
await db.close()
passwords.close()
app = FastAPI(lifespan=lifespan, openapi_url=None, docs_url=None, redoc_url=None)
# ---------- request id, ошибки ----------
REQUEST_ID_RE = re.compile(r'[A-Za-z0-9._:-]{1,128}')
@app.middleware('http')
async def request_id_middleware(request: Request, call_next):
incoming = request.headers.get('x-request-id', '')
rid = incoming if REQUEST_ID_RE.fullmatch(incoming) else uuid.uuid4().hex
request_id_var.set(rid)
try:
response = await call_next(request)
except Exception:
log.exception('unhandled error, request_id=%s', rid)
response = error_response(500, 'internal_error', 'Внутренняя ошибка сервера')
response.headers['X-Request-Id'] = rid
response.headers['X-Instance-Id'] = lifecycle.INSTANCE_ID
if lifecycle.draining:
# Во время drain закрываем keep-alive: следующий запрос LB откроет соединение уже к живой реплике.
response.headers['Connection'] = 'close'
return response
@app.exception_handler(ApiError)
async def api_error_handler(_request: Request, exc: ApiError):
return error_response(exc.status, exc.code, exc.message, exc.headers)
@app.exception_handler(StarletteHTTPException)
async def http_error_handler(_request: Request, exc: StarletteHTTPException):
if exc.status_code == 404:
return error_response(404, 'not_found', 'Объект не найден')
if exc.status_code == 405:
return error_response(405, 'invalid_request', 'Метод не поддерживается', dict(exc.headers or {}))
return error_response(exc.status_code, 'invalid_request', 'Некорректный запрос')
@app.exception_handler(RequestValidationError)
async def validation_error_handler(_request: Request, _exc: RequestValidationError):
return error_response(400, 'invalid_request', 'Некорректный запрос')
async def db_unavailable_handler(_request: Request, _exc: Exception):
# Страховка: сбой связи с БД вне db.connection() тоже даёт ограниченный 503, а не 500.
return error_response(503, 'unavailable', 'Сервис временно недоступен')
for _exc_type in DB_UNAVAILABLE:
app.add_exception_handler(_exc_type, db_unavailable_handler)
# ---------- представление ----------
def ts(value: datetime) -> str:
# RFC 3339 UTC с микросекундами: точность совпадает с timestamptz и с ключом пагинации.
return value.astimezone(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%fZ')
def user_json(row) -> dict:
return {'id': str(row['id']), 'username': row['username'],
'display_name': pgtext.join(row['display_name'], row['display_name_raw']), 'created_at': ts(row['created_at'])}
def chat_json(row) -> dict:
return {'id': str(row['id']), 'title': pgtext.join(row['title'], row['title_raw']),
'member_ids': [str(m) for m in row['member_ids']], 'created_at': ts(row['created_at'])}
def message_json(row) -> dict:
return {'id': str(row['id']), 'chat_id': str(row['chat_id']), 'sender_id': str(row['sender_id']),
'text': pgtext.join(row['text'], row['text_raw']), 'created_at': ts(row['created_at']),
'attachment_ids': [str(a) for a in row['attachment_ids']]}
def attachment_json(row) -> dict:
# object_key и внутренние адреса S3 в ответ не попадают.
return {'id': str(row['id']), 'chat_id': str(row['chat_id']), 'owner_id': str(row['owner_id']),
'filename': row['filename'], 'content_type': row['content_type'],
'size_bytes': row['size_bytes'], 'sha256': row['sha256'], 'status': row['status'],
'variants': [], 'error_code': None,
'created_at': ts(row['created_at']), 'updated_at': ts(row['updated_at'])}
USER_COLUMNS = 'id, username, display_name, display_name_raw, created_at'
CHAT_COLUMNS = ('c.id, c.title, c.title_raw, c.created_at, '
'ARRAY(SELECT cm.user_id FROM chat_members cm WHERE cm.chat_id = c.id ORDER BY cm.user_id) AS member_ids')
MESSAGE_ATTACHMENTS = ('ARRAY(SELECT ma.attachment_id FROM message_attachments ma '
'WHERE ma.message_id = {m}.id ORDER BY ma.position) AS attachment_ids')
MESSAGE_COLUMNS = 'id, chat_id, sender_id, text, text_raw, created_at, ' + MESSAGE_ATTACHMENTS.format(m='messages')
ATTACHMENT_COLUMNS = ('a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256, '
'a.status, a.object_key, a.created_at, a.updated_at')
# ---------- аутентификация ----------
TOKEN_RE = re.compile(r'[A-Za-z0-9_-]{32,128}')
def bearer_token(request: Request) -> str:
"""Только Authorization: Bearer. X-User-Id и Basic здесь игнорируются/отклоняются."""
scheme, _, token = request.headers.get('authorization', '').partition(' ')
token = token.strip()
if scheme.lower() != 'bearer' or not TOKEN_RE.fullmatch(token):
raise unauthorized_bearer()
return token
async def current_user(request: Request) -> UUID:
session = await sessions.resolve(bearer_token(request))
if session is None:
raise unauthorized_bearer()
return session.user_id
def basic_credentials(request: Request) -> tuple[str, str]:
scheme, _, encoded = request.headers.get('authorization', '').partition(' ')
if scheme.lower() != 'basic':
raise unauthorized_basic()
try:
decoded = base64.b64decode(encoded.strip(), validate=True)
username, sep, password = decoded.partition(b':') # двоеточие допустимо внутри пароля
if not sep:
raise ValueError
return username.decode('ascii'), password.decode('utf-8')
except (ValueError, binascii.Error, UnicodeDecodeError):
raise unauthorized_basic() from None
# ---------- health ----------
@app.get('/health/live')
async def live():
return {'status': 'ok'}
@app.get('/health/ready')
async def ready():
# Критична только PostgreSQL (источник истины). Valkey — кэш: без него API работает медленнее, но корректно.
# Во время drain (получен SIGTERM) реплика честно сообщает LB, что новых запросов ей давать не надо.
if lifecycle.draining or not await db.ping():
raise unavailable()
return {'status': 'ok'}
# ---------- пользователи и сессии ----------
@app.post('/api/v1/users', status_code=201)
async def create_user(request: Request):
data = await v.read_json(request)
v.fields(data, {'username', 'display_name', 'password'})
username = v.username(data)
display_name = v.text_field(data, 'display_name', 1, 100)
password = v.text_field(data, 'password', 12, 128)
password_hash = await passwords.hash(password)
try:
async with db.connection() as conn:
row = await conn.fetchrow(
'INSERT INTO users (username, display_name, display_name_raw, password_hash) '
f'VALUES ($1, $2, $3, $4) RETURNING {USER_COLUMNS}',
username, *pgtext.split(display_name), password_hash)
except asyncpg.UniqueViolationError:
# Гонка двух одинаковых регистраций решается UNIQUE-индексом: COMMIT пройдёт только у одной.
raise ApiError(409, 'conflict', 'username уже занят') from None
return JSONResponse(user_json(row), status_code=201)
@app.post('/api/v1/auth/sessions', status_code=201)
async def create_session(request: Request):
if await request.body():
raise invalid('Тело запроса не допускается; используйте Authorization: Basic')
username, password = basic_credentials(request)
row = None
if v.USERNAME_RE.fullmatch(username) and 12 <= len(password) <= 128:
async with db.connection() as conn:
row = await conn.fetchrow(
f'SELECT {USER_COLUMNS}, password_hash FROM users WHERE username = $1', username)
# verify выполняется всегда (и для несуществующего пользователя) — одинаковое время ответа.
if not await passwords.verify(row['password_hash'] if row else None, password):
raise unauthorized_basic()
token = new_token()
session = await sessions.create(row['id'], token)
return JSONResponse({'token': token, 'token_type': 'Bearer', 'expires_at': ts(session.expires_at),
'user': user_json(row)}, status_code=201, headers={'Cache-Control': 'no-store'})
@app.delete('/api/v1/auth/sessions/current', status_code=204)
async def delete_session(request: Request):
token = bearer_token(request)
if not await sessions.revoke(token):
raise unauthorized_bearer()
return Response(status_code=204)
@app.get('/api/v1/users/me')
async def me(request: Request):
user_id = await current_user(request)
async with db.connection() as conn:
row = await conn.fetchrow(f'SELECT {USER_COLUMNS} FROM users WHERE id = $1', user_id)
if row is None:
raise not_found()
return user_json(row)
# ---------- чаты ----------
@app.post('/api/v1/chats', status_code=201)
async def create_chat(request: Request):
user_id = await current_user(request)
data = await v.read_json(request)
v.fields(data, {'title', 'member_ids'})
title = v.text_field(data, 'title', 1, 100)
raw_members = data['member_ids']
if not isinstance(raw_members, list) or not 1 <= len(raw_members) <= 100:
raise invalid('member_ids должен быть массивом из 1..100 UUID')
members = [v.uuid_value(m, 'member_id') for m in raw_members]
if len(set(members)) != len(members):
raise invalid('member_ids содержит дубликаты')
if user_id not in members:
raise invalid('Создатель должен входить в member_ids')
async with db.connection() as conn:
# Одна транзакция: чат и все участники появляются вместе или не появляются вовсе.
async with conn.transaction():
chat = await conn.fetchrow(
'INSERT INTO chats (title, title_raw, created_by) VALUES ($1, $2, $3) RETURNING id, created_at',
*pgtext.split(title), user_id)
added = await conn.fetch(
'INSERT INTO chat_members (chat_id, user_id) '
'SELECT $1, u.id FROM users u WHERE u.id = ANY($2::uuid[]) RETURNING user_id',
chat['id'], members)
if len(added) != len(members):
# Исключение внутри conn.transaction() -> ROLLBACK, строка chats тоже откатывается.
raise invalid('member_ids содержит неизвестных пользователей')
return JSONResponse({'id': str(chat['id']), 'title': title,
'member_ids': sorted(str(m) for m in members),
'created_at': ts(chat['created_at'])}, status_code=201)
@app.get('/api/v1/chats')
async def list_chats(request: Request):
user_id = await current_user(request)
limit = v.limit_param(request)
after = v.decode_cursor(request, 'chats')
query = (f'SELECT {CHAT_COLUMNS} FROM chats c '
'JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $1 ')
params = [user_id, limit + 1]
if after:
query += 'WHERE (c.created_at, c.id) > ($3, $4) '
params += after
query += 'ORDER BY c.created_at, c.id LIMIT $2'
async with db.connection() as conn:
rows = await conn.fetch(query, *params)
return page(rows, limit, 'chats', chat_json)
def page(rows, limit: int, scope: str, render) -> dict:
# Читаем limit+1 строку: если лишняя есть — следующая страница существует.
items = rows[:limit]
cursor = (v.encode_cursor(scope, items[-1]['created_at'], items[-1]['id'])
if len(rows) > limit else None)
return {'items': [render(r) for r in items], 'next_cursor': cursor}
async def chat_for_member(conn, chat_id: UUID, user_id: UUID):
return await conn.fetchrow(
f'SELECT {CHAT_COLUMNS} FROM chats c '
'WHERE c.id = $1 AND EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = $2)',
chat_id, user_id)
@app.get('/api/v1/chats/{chat_id}')
async def get_chat(chat_id: str, request: Request):
user_id = await current_user(request)
cid = v.uuid_value(chat_id, 'chat_id')
async with db.connection() as conn:
row = await chat_for_member(conn, cid, user_id)
if row is None:
raise not_found()
return chat_json(row)
# ---------- сообщения ----------
IDEMPOTENCY_KEY_RE = re.compile(r'[A-Za-z0-9._:-]{1,128}')
def idempotency_key(request: Request) -> str:
key = request.headers.get('idempotency-key')
if key is None or not IDEMPOTENCY_KEY_RE.fullmatch(key):
raise invalid('Требуется заголовок Idempotency-Key: [A-Za-z0-9._:-]{1,128}')
return key
def request_fingerprint(text: str, attachments: list[UUID]) -> bytes:
# Хешируем разобранное тело, а не байты: порядок ключей и пробелы JSON не делают запрос "другим",
# отсутствующий attachment_ids равен []. Порядок вложений значим — он сохраняется в сообщении.
canonical = json.dumps({'text': text, 'attachment_ids': [str(a) for a in attachments]},
ensure_ascii=False, sort_keys=True, separators=(',', ':'))
return hashlib.sha256(canonical.encode('utf-8')).digest()
@app.post('/api/v1/chats/{chat_id}/messages', status_code=201)
async def create_message(chat_id: str, request: Request):
# Повтор заново проверяет сессию и членство: сохранённый ответ не выдаётся без текущего доступа.
user_id = await current_user(request)
cid = v.uuid_value(chat_id, 'chat_id')
key = idempotency_key(request)
data = await v.read_json(request)
# sender_id в запросе не принимается — отправитель берётся из сессии
v.fields(data, {'text'}, {'attachment_ids'})
text = v.text_field(data, 'text', 0, 4000, allow_blank=True)
attachments = v.attachment_ids(data)
if not attachments and not text.strip():
raise invalid('Нужен непустой текст или хотя бы одно вложение')
fingerprint = request_fingerprint(text, attachments)
async with db.connection() as conn:
async with conn.transaction():
member = await conn.fetchval(
'SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2', cid, user_id)
if member is None:
raise not_found()
# Ключ — "замок": параллельный INSERT того же PK с другой реплики ждёт COMMIT/ROLLBACK этой
# транзакции. Просроченный (старше TTL) ключ атомарно переиспользуется как новый.
message_id = await conn.fetchval(
'INSERT INTO idempotency_keys (user_id, chat_id, key, request_hash, message_id) '
'VALUES ($1, $2, $3, $4, gen_random_uuid()) '
'ON CONFLICT (user_id, chat_id, key) DO UPDATE '
'SET request_hash = EXCLUDED.request_hash, message_id = EXCLUDED.message_id, '
' created_at = clock_timestamp() '
'WHERE idempotency_keys.created_at < clock_timestamp() - make_interval(secs => $5) '
'RETURNING message_id',
user_id, cid, key, fingerprint, settings.idempotency_ttl)
if message_id is not None:
# Ключ и сообщение фиксируются одним COMMIT: при сбое не остаётся ни того, ни другого,
# поэтому транзиентная 5xx не становится "окончательным" результатом ключа.
if attachments:
# Все вложения — из ЭТОГО чата (иначе 404, как для чужого объекта). FOR SHARE
# фиксирует строки до COMMIT; составной FK (attachment_id, chat_id) страхует на уровне БД.
found = await conn.fetchval(
'SELECT count(*) FROM (SELECT 1 FROM attachments '
"WHERE chat_id = $1 AND id = ANY($2::uuid[]) AND status = 'ready' FOR SHARE) s",
cid, attachments)
if found != len(attachments):
raise not_found()
row = await conn.fetchrow(
'INSERT INTO messages (id, chat_id, sender_id, text, text_raw) VALUES ($1, $2, $3, $4, $5) '
'RETURNING id, chat_id, sender_id, text, text_raw, created_at',
message_id, cid, user_id, *pgtext.split(text))
if attachments:
await conn.execute(
'INSERT INTO message_attachments (message_id, attachment_id, chat_id, position) '
'SELECT $1, a.id, $2, a.ord - 1 FROM unnest($3::uuid[]) WITH ORDINALITY AS a(id, ord)',
message_id, cid, attachments)
row = {**dict(row), 'attachment_ids': attachments}
else:
row = await conn.fetchrow(
'SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.text_raw, m.created_at, '
+ MESSAGE_ATTACHMENTS.format(m='m') + ' '
'FROM idempotency_keys k JOIN messages m ON m.id = k.message_id '
'WHERE k.user_id = $1 AND k.chat_id = $2 AND k.key = $3', user_id, cid, key)
if row is None:
raise unavailable() # не должно случаться: ключ без сообщения не коммитится
if row['request_hash'] != fingerprint:
raise ApiError(409, 'conflict', 'Idempotency-Key уже использован с другим сообщением')
return JSONResponse(message_json(row), status_code=201)
@app.get('/api/v1/chats/{chat_id}/messages')
async def list_messages(chat_id: str, request: Request):
user_id = await current_user(request)
cid = v.uuid_value(chat_id, 'chat_id')
limit = v.limit_param(request)
after = v.decode_cursor(request, 'messages:' + str(cid))
async with db.connection() as conn:
member = await conn.fetchval(
'SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2', cid, user_id)
if member is None:
raise not_found()
if after:
# Keyset: продолжаем строго после последнего элемента прошлой страницы (без OFFSET).
rows = await conn.fetch(
f'SELECT {MESSAGE_COLUMNS} FROM messages WHERE chat_id = $1 AND (created_at, id) > ($3, $4) '
'ORDER BY created_at, id LIMIT $2', cid, limit + 1, *after)
else:
rows = await conn.fetch(
f'SELECT {MESSAGE_COLUMNS} FROM messages WHERE chat_id = $1 '
'ORDER BY created_at, id LIMIT $2', cid, limit + 1)
return page(rows, limit, 'messages:' + str(cid), message_json)
# ---------- вложения (lab4) ----------
async def attachment_for_member(conn, attachment_id: UUID, user_id: UUID):
# Доступ = членство в чате вложения. Чужое и несуществующее неразличимы (404).
return await conn.fetchrow(
f'SELECT {ATTACHMENT_COLUMNS} FROM attachments a '
'JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = $2 WHERE a.id = $1',
attachment_id, user_id)
@app.post('/api/v1/chats/{chat_id}/attachments', status_code=201)
async def upload_attachment(chat_id: str, request: Request):
user_id = await current_user(request)
cid = v.uuid_value(chat_id, 'chat_id')
async with db.connection() as conn:
member = await conn.fetchval(
'SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2', cid, user_id)
if member is None:
raise not_found() # посторонний не загружает ни байта в чужой чат
filename = v.filename_param(request)
declared = images.declared_type(request)
data = await images.read_limited(request, settings.max_upload_bytes)
content_type, width, height = await image_checker.inspect(data, declared)
sha256 = hashlib.sha256(data).hexdigest()
attachment_id = uuid.uuid4()
object_key = f'attachments/{attachment_id}' # назначает сервер; filename в ключе не участвует
# 1) байты в S3. Сбой -> 503, метаданных нет, клиент может повторить.
await storage.put(object_key, data, content_type)
# 2) метаданные в PostgreSQL. 201 отдаётся только после COMMIT: тогда и байты, и запись уже надёжны.
try:
async with db.connection() as conn:
row = await conn.fetchrow(
'INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes, sha256, '
'width, height, object_key) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) '
'RETURNING id, chat_id, owner_id, filename, content_type, size_bytes, sha256, status, '
'created_at, updated_at',
attachment_id, cid, user_id, filename, content_type, len(data), sha256, width, height, object_key)
except BaseException:
# PUT прошёл, COMMIT — нет: удаляем объект, чтобы не оставить неучтённый файл.
await storage.delete_quietly(object_key)
raise
return JSONResponse(attachment_json(row), status_code=201)
@app.get('/api/v1/attachments/{attachment_id}')
async def get_attachment(attachment_id: str, request: Request):
user_id = await current_user(request)
aid = v.uuid_value(attachment_id, 'attachment_id')
async with db.connection() as conn:
row = await attachment_for_member(conn, aid, user_id)
if row is None:
raise not_found()
return attachment_json(row)
KNOWN_VARIANTS = {'thumbnail', 'crop', 'optimized'}
@app.get('/api/v1/attachments/{attachment_id}/content')
async def download_attachment(attachment_id: str, request: Request):
user_id = await current_user(request)
aid = v.uuid_value(attachment_id, 'attachment_id')
variant = request.query_params.get('variant', 'original')
if variant != 'original' and variant not in KNOWN_VARIANTS:
raise invalid('Неизвестный variant')
async with db.connection() as conn:
row = await attachment_for_member(conn, aid, user_id)
if row is None or variant != 'original':
raise not_found() # в lab4 вариантов нет: отсутствующий вариант — 404
# Байты идут через API после проверки доступа, без redirect на S3.
data = await storage.get(row['object_key'])
return Response(data, media_type=row['content_type'], headers={
'Cache-Control': 'private, no-store',
'X-Content-Type-Options': 'nosniff',
'Content-Disposition': "inline; filename*=UTF-8''" + quote(row['filename'], safe=''),
'ETag': '"' + row['sha256'] + '"',
})
+60
View File
@@ -0,0 +1,60 @@
"""Версионированные миграции: migrations/NNNN_name.sql применяются по порядку, каждая в своей транзакции.
Повторный запуск безопасен: применённые версии записаны в schema_migrations и пропускаются,
изменённый задним числом файл (другая контрольная сумма) останавливает запуск.
Advisory lock не даёт двум параллельным запускам применить одну миграцию дважды.
"""
import asyncio
import hashlib
from pathlib import Path
import asyncpg
from . import config
MIGRATIONS = Path(__file__).resolve().parent.parent / 'migrations'
LOCK_ID = 2026_0002
async def connect(url: str, attempts: int = 30) -> asyncpg.Connection:
for attempt in range(attempts):
try:
return await asyncpg.connect(url, timeout=3)
except (OSError, asyncpg.CannotConnectNowError, asyncpg.PostgresConnectionError):
if attempt == attempts - 1:
raise
await asyncio.sleep(1)
async def migrate() -> None:
# Только DATABASE_URL: сервису migrate не нужны (и не выдаются) S3-credentials API.
database_url = config._secret('DATABASE_URL')
if not database_url:
raise SystemExit('DATABASE_URL_FILE is not configured')
conn = await connect(database_url)
try:
await conn.execute('SELECT pg_advisory_lock($1)', LOCK_ID)
await conn.execute(
'CREATE TABLE IF NOT EXISTS schema_migrations ('
' version text PRIMARY KEY, checksum text NOT NULL,'
' applied_at timestamptz NOT NULL DEFAULT clock_timestamp())')
applied = {r['version']: r['checksum'] for r in await conn.fetch('SELECT version, checksum FROM schema_migrations')}
for path in sorted(MIGRATIONS.glob('[0-9][0-9][0-9][0-9]_*.sql')):
version = path.stem
sql = path.read_text(encoding='utf-8')
checksum = hashlib.sha256(sql.encode()).hexdigest()
if version in applied:
if applied[version] != checksum:
raise SystemExit(f'migration {version} was modified after being applied')
print(f'skip {version}')
continue
async with conn.transaction():
await conn.execute(sql)
await conn.execute('INSERT INTO schema_migrations (version, checksum) VALUES ($1, $2)', version, checksum)
print(f'apply {version}')
finally:
await conn.close()
if __name__ == '__main__':
asyncio.run(migrate())
+22
View File
@@ -0,0 +1,22 @@
"""Точное хранение строк с U+0000 в PostgreSQL.
Тип text в PostgreSQL не может содержать байт 0x00, а JSON-контракт допускает "\\u0000" в тексте
сообщения, display_name и title. Раньше такой INSERT падал с 500 (замечание к lab3, PR #99).
Схема (только expand, совместима с предыдущей версией при rolling update):
- столбец text/display_name/title получает ту же строку, где U+0000 заменён на U+FFFD: длина в code points
не меняется, поэтому CHECK char_length и прежние реплики продолжают работать;
- столбец *_raw bytea получает точные UTF-8 байты исходной строки, но ТОЛЬКО если в ней был U+0000
(иначе NULL, лишнего места не занимает);
- при чтении API возвращает декодированный *_raw, если он есть, иначе обычный столбец.
"""
def split(value: str) -> tuple[str, bytes | None]:
if '\x00' in value:
return value.replace('\x00', '\ufffd'), value.encode('utf-8')
return value, None
def join(text: str, raw: bytes | None) -> str:
return bytes(raw).decode('utf-8') if raw is not None else text
+72
View File
@@ -0,0 +1,72 @@
"""Bootstrap S3: создаёт приватный bucket для вложений. Запуск: python -m app.s3_bootstrap (сервис s3-init).
Идемпотентно: повторный запуск не трогает существующий bucket и данные в нём.
"Приватный" = у bucket нет политики анонимного доступа. Если политика есть (например, кто-то включил
public read руками), она удаляется. В конце выполняется проверка снаружи API: анонимный GET объекта
должен получить отказ (403), иначе bootstrap завершается ошибкой и API не стартует.
"""
import io
import os
import sys
import time
import urllib.error
import urllib.request
from pathlib import Path
from urllib.parse import urlparse
from minio import Minio
from minio.error import S3Error
def secret(name: str) -> str:
return Path(os.environ[name + '_FILE']).read_text(encoding='utf-8').strip()
def main() -> None:
endpoint = os.environ.get('S3_ENDPOINT', 'http://s3:9000')
bucket = os.environ.get('S3_BUCKET', 'messenger-attachments')
region = os.environ.get('S3_REGION', 'us-east-1')
url = urlparse(endpoint)
client = Minio(url.netloc, access_key=secret('S3_ACCESS_KEY_ID'), secret_key=secret('S3_SECRET_ACCESS_KEY'),
secure=url.scheme == 'https', region=region)
for attempt in range(30):
try:
exists = client.bucket_exists(bucket)
break
except Exception as exc: # S3 ещё стартует
if attempt == 29:
raise SystemExit(f's3 not reachable: {type(exc).__name__}')
time.sleep(1)
if exists:
print(f'bucket {bucket}: exists')
else:
client.make_bucket(bucket, location=region)
print(f'bucket {bucket}: created')
try:
client.get_bucket_policy(bucket)
client.delete_bucket_policy(bucket)
print(f'bucket {bucket}: anonymous policy removed')
except S3Error as exc:
if exc.code not in ('NoSuchBucketPolicy', 'NoSuchPolicy'):
raise
print(f'bucket {bucket}: no bucket policy (private)')
# Проверка приватности без credentials: служебный объект, анонимный GET, ожидаем 403.
probe = '_bootstrap/private-check'
client.put_object(bucket, probe, io.BytesIO(b'private'), 7, content_type='text/plain')
try:
urllib.request.urlopen(f'{endpoint}/{bucket}/{probe}', timeout=5)
print('ERROR: anonymous GET returned object, bucket is public', file=sys.stderr)
sys.exit(1)
except urllib.error.HTTPError as exc:
print(f'anonymous GET {bucket}/{probe}: HTTP {exc.code} (denied)')
if exc.code not in (401, 403):
sys.exit(1)
finally:
client.remove_object(bucket, probe)
if __name__ == '__main__':
main()
+47
View File
@@ -0,0 +1,47 @@
"""Пароли (Argon2id) и непрозрачные токены сессий."""
import asyncio
import hashlib
import secrets
from concurrent.futures import ThreadPoolExecutor
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
# Параметры по умолчанию argon2-cffi = профиль RFC 9106 "low memory": Argon2id, m=64 MiB, t=3, p=4.
_hasher = PasswordHasher()
# Хеш для несуществующего пользователя: вход выполняет ту же работу и не выдаёт по времени,
# что такого username нет.
_DUMMY_HASH = _hasher.hash('dummy-password-for-timing')
class PasswordService:
"""KDF дорогой по CPU и памяти: считаем в отдельном ограниченном пуле потоков,
чтобы не блокировать event loop и не съесть всю память параллельными входами."""
def __init__(self, workers: int):
self._pool = ThreadPoolExecutor(max_workers=workers, thread_name_prefix='argon2')
async def hash(self, password: str) -> str:
return await asyncio.get_running_loop().run_in_executor(self._pool, _hasher.hash, password)
async def verify(self, password_hash: str | None, password: str) -> bool:
def check() -> bool:
try:
return _hasher.verify(password_hash or _DUMMY_HASH, password) and password_hash is not None
except (VerificationError, InvalidHashError):
return False
return await asyncio.get_running_loop().run_in_executor(self._pool, check)
def close(self) -> None:
self._pool.shutdown(wait=False)
def new_token() -> str:
# 32 случайных байта = 256 бит энтропии из CSPRNG ОС; base64url -> 43 символа.
return secrets.token_urlsafe(32)
def token_hash(token: str) -> bytes:
# Для токена с 256 битами энтропии быстрый SHA-256 достаточен: перебор невозможен.
# Для паролей (низкая энтропия) так нельзя — там нужен медленный KDF.
return hashlib.sha256(token.encode('ascii')).digest()
+187
View File
@@ -0,0 +1,187 @@
"""Сессии: PostgreSQL — источник истины, Valkey — read-through кэш с TTL.
Политика:
- создание: INSERT в PostgreSQL (COMMIT), затем SET в кэш с TTL = min(остаток жизни, SESSION_CACHE_TTL_SECONDS);
- проверка: кэш -> при промахе PostgreSQL -> заполнить кэш;
- logout: UPDATE revoked_at в PostgreSQL (COMMIT), затем DEL из кэша;
- любой сбой Valkey: работаем только с PostgreSQL и SESSION_CACHE_TTL_SECONDS не доверяем кэшу
(все записи, сделанные до сбоя, за это время гарантированно истекут — например, не удалённая
при logout копия отозванной сессии). Flush/рестарт Valkey = пустой кэш, сессии не теряются.
- lab3, несколько реплик: окно недоверия ОБЩЕЕ. Реплика, получившая ошибку Valkey, записывает его
в PostgreSQL (cache_state), а попадание в кэш принимается, только если общий признак проверен
не раньше SHARED_STATE_MAX_AGE назад. Иначе реплика, которая сама сбоя не видела, могла бы
отдать копию сессии, отозванной на другой реплике во время разрыва с Valkey.
"""
import asyncio
import json
import logging
import time
from dataclasses import dataclass
from datetime import datetime, timezone
from uuid import UUID
import redis.asyncio as redis
from redis.exceptions import RedisError
from .config import Settings
from .db import Database
from .security import token_hash
log = logging.getLogger('messenger.sessions')
@dataclass(frozen=True)
class Session:
user_id: UUID
expires_at: datetime
# Насколько устаревшим может быть знание реплики об общем окне недоверия (не чаще 2 запросов/с к БД).
SHARED_STATE_MAX_AGE = 0.5
class SessionCache:
def __init__(self, url: str | None, ttl: int, timeout: float, db: Database):
self.ttl = ttl
self.db = db
self.client = redis.Redis.from_url(
url, socket_timeout=timeout, socket_connect_timeout=timeout,
retry_on_timeout=False, health_check_interval=30,
) if url else None
self._distrust_until = 0.0 # локально (monotonic): своя ошибка действует сразу
self._shared_trusted = False # результат последней проверки общего признака
self._shared_checked = -1e9
self._lock = asyncio.Lock()
@staticmethod
def key(digest: bytes) -> str:
return 'session:' + digest.hex()
def usable(self) -> bool:
return self.client is not None and time.monotonic() >= self._distrust_until
async def trusted(self) -> bool:
"""Можно ли принять попадание в кэш: нет ни своего, ни общего (с других реплик) окна недоверия."""
if not self.usable():
return False
if time.monotonic() - self._shared_checked > SHARED_STATE_MAX_AGE:
async with self._lock:
if time.monotonic() - self._shared_checked > SHARED_STATE_MAX_AGE:
try:
async with self.db.pool.acquire(timeout=1) as conn:
self._shared_trusted = await conn.fetchval(
'SELECT distrust_until <= clock_timestamp() FROM cache_state WHERE id = 1',
timeout=1) is True
except Exception: # без БД сессию всё равно не проверить; кэшу не доверяем
self._shared_trusted = False
self._shared_checked = time.monotonic()
return self._shared_trusted
async def _failed(self, op: str) -> None:
# Не знаем, что успело/не успело записаться: перестаём читать кэш на один максимальный TTL —
# сами сразу и все остальные реплики через общий признак в PostgreSQL.
self._distrust_until = time.monotonic() + self.ttl
self._shared_checked = -1e9
log.warning('valkey %s failed; bypassing cache for %ss on all replicas', op, self.ttl)
try:
async with self.db.pool.acquire(timeout=1) as conn:
await conn.execute(
'UPDATE cache_state SET distrust_until = greatest(distrust_until, '
'clock_timestamp() + make_interval(secs => $1)) WHERE id = 1', self.ttl, timeout=1)
except Exception: # БД недоступна — и кэш, и сессии всё равно проверить нельзя
log.warning('could not publish cache distrust window', exc_info=True)
async def get(self, digest: bytes) -> Session | None:
if not await self.trusted():
return None
try:
raw = await self.client.get(self.key(digest))
except (RedisError, OSError):
await self._failed('get')
return None
if raw is None:
return None
data = json.loads(raw)
return Session(UUID(data['u']), datetime.fromtimestamp(data['e'], timezone.utc))
async def put(self, digest: bytes, session: Session) -> None:
if not self.usable():
return
remaining = int((session.expires_at - datetime.now(timezone.utc)).total_seconds())
ttl = min(self.ttl, remaining)
if ttl <= 0:
return
value = json.dumps({'u': str(session.user_id), 'e': session.expires_at.timestamp()})
try:
await self.client.set(self.key(digest), value, ex=ttl)
except (RedisError, OSError):
await self._failed('set')
async def delete(self, digest: bytes) -> None:
if self.client is None:
return
try:
await self.client.delete(self.key(digest))
except (RedisError, OSError):
await self._failed('delete')
async def close(self) -> None:
if self.client is not None:
await self.client.aclose()
class SessionStore:
def __init__(self, settings: Settings, db: Database):
self.ttl = settings.session_ttl
self.db = db
self.cache = SessionCache(settings.cache_url, settings.session_cache_ttl, settings.cache_timeout, db)
async def create(self, user_id: UUID, token: str) -> Session:
digest = token_hash(token)
async with self.db.connection() as conn:
# Время берём из БД, чтобы срок не зависел от часов конкретной реплики API.
expires_at = await conn.fetchval(
'INSERT INTO sessions (token_hash, user_id, expires_at) '
'VALUES ($1, $2, clock_timestamp() + make_interval(secs => $3)) RETURNING expires_at',
digest, user_id, self.ttl,
)
session = Session(user_id, expires_at)
await self.cache.put(digest, session)
return session
async def resolve(self, token: str) -> Session | None:
digest = token_hash(token)
now = datetime.now(timezone.utc)
cached = await self.cache.get(digest)
if cached is not None and cached.expires_at > now:
return cached
async with self.db.connection() as conn:
row = await conn.fetchrow(
'SELECT user_id, expires_at FROM sessions '
'WHERE token_hash = $1 AND revoked_at IS NULL AND expires_at > clock_timestamp()',
digest,
)
if row is None:
return None
session = Session(row['user_id'], row['expires_at'])
await self.cache.put(digest, session)
return session
async def revoke(self, token: str) -> bool:
digest = token_hash(token)
async with self.db.connection() as conn:
status = await conn.execute(
'UPDATE sessions SET revoked_at = clock_timestamp() '
'WHERE token_hash = $1 AND revoked_at IS NULL AND expires_at > clock_timestamp()',
digest,
)
# Инвалидация кэша строго после COMMIT в источнике истины.
await self.cache.delete(digest)
return status == 'UPDATE 1'
async def purge_expired(self) -> int:
async with self.db.connection() as conn:
status = await conn.execute(
"DELETE FROM sessions WHERE expires_at < clock_timestamp() - interval '1 day'")
return int(status.split()[-1])
+85
View File
@@ -0,0 +1,85 @@
"""Приватное S3-хранилище оригиналов вложений (MinIO, S3 API).
Клиент minio-py синхронный, поэтому вызовы уходят в пул потоков (asyncio.to_thread) и не блокируют
event loop. Таймауты и число повторов ограничены: недоступный S3 даёт 503 за секунды, а не зависание.
Ключи объектов назначает сервер; bucket приватный, байты отдаёт только API после проверки доступа.
"""
import asyncio
import io
import logging
from urllib.parse import urlparse
import urllib3
from minio import Minio
from minio.error import MinioException, S3Error
from .config import Settings
from .errors import ApiError, unavailable
log = logging.getLogger('messenger.storage')
class ObjectMissing(Exception):
"""Метаданные в БД есть, а объекта в bucket нет (рассогласование хранилищ)."""
class Storage:
def __init__(self, settings: Settings):
endpoint = urlparse(settings.s3_endpoint)
self.bucket = settings.s3_bucket
# Без повторов на уровне HTTP-клиента: повтор удваивал бы время отказа. Общий дедлайн операции —
# в _call: getaddrinfo (DNS остановленного контейнера ~8 с) таймаутами urllib3 не ограничен.
self.deadline = settings.s3_timeout
http = urllib3.PoolManager(
timeout=urllib3.Timeout(connect=2, read=settings.s3_timeout),
retries=urllib3.Retry(total=0, redirect=0),
maxsize=16,
)
self.client = Minio(endpoint.netloc, access_key=settings.s3_access_key,
secret_key=settings.s3_secret_key, secure=endpoint.scheme == 'https',
region=settings.s3_region, http_client=http)
async def _call(self, fn, *args, **kwargs):
try:
return await asyncio.wait_for(asyncio.to_thread(fn, *args, **kwargs), self.deadline)
except asyncio.TimeoutError:
# Поток дорабатывает в фоне (его нельзя прервать), но клиент получает 503 в пределах дедлайна.
log.warning('S3 deadline %.1fs exceeded on %s', self.deadline, fn.__name__)
raise unavailable() from None
except S3Error as exc:
if exc.code in ('NoSuchKey', 'NoSuchObject'):
raise ObjectMissing() from None
log.warning('S3 error %s on %s', exc.code, fn.__name__)
raise unavailable() from None
except (MinioException, urllib3.exceptions.HTTPError, OSError, ValueError):
# Нет связи, таймаут, 5xx после повтора — для клиента это временная недоступность.
log.warning('S3 unavailable on %s', fn.__name__, exc_info=True)
raise unavailable() from None
async def put(self, key: str, data: bytes, content_type: str) -> None:
await self._call(self.client.put_object, self.bucket, key, io.BytesIO(data), len(data),
content_type=content_type)
async def get(self, key: str) -> bytes:
def read() -> bytes:
response = self.client.get_object(self.bucket, key)
try:
return response.read()
finally:
response.close()
response.release_conn()
try:
return await self._call(read)
except ObjectMissing:
log.error('object %s is missing in bucket %s', key, self.bucket)
raise ApiError(500, 'internal_error', 'Внутренняя ошибка сервера') from None
async def delete(self, key: str) -> None:
await self._call(self.client.remove_object, self.bucket, key)
async def delete_quietly(self, key: str) -> None:
"""Компенсация после неудачной записи метаданных. Сбой здесь не меняет ответ клиенту."""
try:
await asyncio.shield(self.delete(key))
except Exception:
log.error('compensation failed: orphan object %s left in bucket', key)
+138
View File
@@ -0,0 +1,138 @@
"""Строгий разбор JSON и параметров: лишние поля, неверные типы, malformed JSON -> 400."""
import base64
import json
import re
from datetime import datetime
from uuid import UUID
from fastapi import Request
from .errors import ApiError, invalid
MAX_BODY_BYTES = 64 * 1024
USERNAME_RE = re.compile(r'[a-z0-9_]{3,32}')
async def read_json(request: Request) -> dict:
media_type = request.headers.get('content-type', '').split(';')[0].strip().lower()
if media_type != 'application/json':
raise ApiError(415, 'unsupported_media_type', 'Ожидается Content-Type: application/json')
body = await request.body()
if len(body) > MAX_BODY_BYTES:
raise ApiError(413, 'payload_too_large', 'Слишком большое тело запроса')
try:
data = json.loads(body.decode('utf-8'))
except (UnicodeDecodeError, ValueError):
raise invalid('Некорректный JSON') from None
if not isinstance(data, dict):
raise invalid('Ожидается JSON-объект')
return data
def fields(data: dict, required: set[str], optional: set[str] = frozenset()) -> None:
extra = set(data) - required - optional
if extra:
raise invalid('Неизвестные поля: ' + ', '.join(sorted(extra)))
missing = required - set(data)
if missing:
raise invalid('Отсутствуют поля: ' + ', '.join(sorted(missing)))
def text_field(data: dict, name: str, min_len: int, max_len: int, *, allow_blank: bool = False) -> str:
value = data[name]
if not isinstance(value, str):
raise invalid(f'Поле {name} должно быть строкой')
try:
value.encode('utf-8') # отсекает одиночные суррогаты из \uD800-экранирования
except UnicodeEncodeError:
raise invalid(f'Поле {name} содержит некорректный Unicode') from None
if not min_len <= len(value) <= max_len: # len(str) в Python = число code points
raise invalid(f'Длина поля {name} должна быть {min_len}..{max_len} символов')
if not allow_blank and not value.strip():
raise invalid(f'Поле {name} не может состоять из пробелов')
return value
def username(data: dict) -> str:
value = data['username']
if not isinstance(value, str) or not USERNAME_RE.fullmatch(value):
raise invalid('username должен соответствовать [a-z0-9_]{3,32}')
return value
def uuid_value(value, what: str = 'идентификатор') -> UUID:
if not isinstance(value, str):
raise invalid(f'Некорректный {what}')
try:
parsed = UUID(value)
except ValueError:
raise invalid(f'Некорректный {what}') from None
if str(parsed) != value.lower(): # только каноническая форма 8-4-4-4-12
raise invalid(f'Некорректный {what}')
return parsed
def limit_param(request: Request) -> int:
raw = request.query_params.get('limit')
if raw is None:
return 50
if not re.fullmatch(r'[0-9]{1,3}', raw) or not 1 <= int(raw) <= 100:
raise invalid('limit должен быть целым 1..100')
return int(raw)
# Курсор: base64url(JSON {"s": область, "t": created_at, "i": id}). Для клиента это непрозрачная строка.
# Подделка курсора ничего не даёт: доступ к чату проверяется отдельно, а область привязывает
# курсор к конкретному чату/списку — курсор другого чата отклоняется с 400.
def encode_cursor(scope: str, created_at: datetime, item_id: UUID) -> str:
raw = json.dumps({'s': scope, 't': created_at.isoformat(), 'i': str(item_id)}, separators=(',', ':'))
return base64.urlsafe_b64encode(raw.encode()).decode().rstrip('=')
def decode_cursor(request: Request, scope: str) -> tuple[datetime, UUID] | None:
raw = request.query_params.get('cursor')
if raw is None:
return None
try:
if len(raw) > 512:
raise ValueError
data = json.loads(base64.urlsafe_b64decode(raw + '=' * (-len(raw) % 4)))
if not isinstance(data, dict) or set(data) != {'s', 't', 'i'} or data['s'] != scope:
raise ValueError
created_at = datetime.fromisoformat(data['t'])
if created_at.tzinfo is None:
raise ValueError
return created_at, UUID(data['i'])
except (ValueError, TypeError, UnicodeDecodeError):
raise invalid('Некорректный cursor') from None
# Имя файла — только для отображения: в ключ S3 и пути оно не попадает. Разделители путей,
# NUL и управляющие символы (C0, DEL, C1) отклоняются, чтобы имя нельзя было выдать за путь.
FILENAME_FORBIDDEN_RE = re.compile(r'[/\\\x00-\x1f\x7f-\x9f]')
def filename_param(request: Request) -> str:
values = request.query_params.getlist('filename')
if len(values) != 1:
raise invalid('Требуется ровно один параметр filename')
value = values[0]
try:
value.encode('utf-8')
except UnicodeEncodeError:
raise invalid('filename содержит некорректный Unicode') from None
if not 1 <= len(value) <= 255 or not value.strip() or value in ('.', '..') \
or FILENAME_FORBIDDEN_RE.search(value):
raise invalid('Недопустимое имя файла')
return value
def attachment_ids(data: dict) -> list[UUID]:
raw = data.get('attachment_ids', [])
if not isinstance(raw, list) or len(raw) > 10:
raise invalid('attachment_ids должен быть массивом из 0..10 UUID')
ids = [uuid_value(x, 'attachment_id') for x in raw]
if len(set(ids)) != len(ids):
raise invalid('attachment_ids содержит дубликаты')
return ids
+253
View File
@@ -0,0 +1,253 @@
# Стенд lab4: lb (HAProxy) -> api x N -> postgres (метаданные) + s3 (RustFS, байты вложений) + valkey (кэш сессий).
# migrate и s3-init — одноразовый bootstrap схемы БД и приватного bucket.
# Подготовка: sh scripts/init-secrets.sh
# Запуск: docker compose --env-file .env up -d --build --wait
name: mtusi-lab4
x-api-env: &api-env
APP_HOST: ${APP_HOST:-0.0.0.0}
APP_PORT: "8080"
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_STORE: ${SESSION_STORE:-postgres+valkey}
SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-60}
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
SHUTDOWN_DRAIN_MS: ${SHUTDOWN_DRAIN_MS:-3000}
DATABASE_URL_FILE: ${DATABASE_URL_FILE:-/run/secrets/database_url}
CACHE_URL_FILE: ${CACHE_URL_FILE:-/run/secrets/cache_url}
DB_POOL_MAX: ${DB_POOL_MAX:-10}
DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000}
DB_ACQUIRE_TIMEOUT_MS: ${DB_ACQUIRE_TIMEOUT_MS:-2000}
CACHE_TIMEOUT_MS: ${CACHE_TIMEOUT_MS:-300}
PASSWORD_HASH_WORKERS: ${PASSWORD_HASH_WORKERS:-2}
S3_ENDPOINT: ${S3_ENDPOINT:-http://s3:9000}
S3_REGION: ${S3_REGION:-us-east-1}
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
S3_ACCESS_KEY_ID_FILE: ${S3_ACCESS_KEY_ID_FILE:-/run/secrets/s3_access_key_id}
S3_SECRET_ACCESS_KEY_FILE: ${S3_SECRET_ACCESS_KEY_FILE:-/run/secrets/s3_secret_access_key}
S3_TIMEOUT_MS: ${S3_TIMEOUT_MS:-5000}
MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760}
MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000}
IMAGE_CHECK_WORKERS: ${IMAGE_CHECK_WORKERS:-2}
x-api-depends: &api-depends
postgres:
condition: service_healthy
migrate:
condition: service_completed_successfully
s3-init:
# bucket создан и проверен на приватность до старта API
condition: service_completed_successfully
valkey:
# Valkey — кэш, не источник истины: API должен стартовать и без него.
condition: service_started
required: false
x-api-limits: &api-limits
limits:
cpus: "${API_CPUS:-1.0}"
memory: ${API_MEMORY:-384M} # 2 Argon2id x 64 MiB + 2 загрузки x (10 MiB тело + проверка) + интерпретатор
services:
lb:
image: haproxy:3.2.8-alpine
volumes:
- ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
ports:
# Единственная публичная точка входа API (только loopback хоста) + страница состояния LB.
- "127.0.0.1:${LB_PUBLISHED_PORT:-8080}:8080"
- "127.0.0.1:${LB_STATS_PORT:-8404}:8404"
networks: [edge]
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8404/stats"]
interval: 5s
timeout: 2s
retries: 5
depends_on:
api:
condition: service_healthy
deploy:
resources:
limits: {cpus: "1.0", memory: 128M}
restart: unless-stopped
api:
image: mtusi-lab4-api:local
build: .
# Нет container_name и ports: реплики взаимозаменяемы, доступны только через lb.
deploy:
replicas: ${API_REPLICAS:-2}
resources: *api-limits
environment: *api-env
secrets: [database_url, cache_url, s3_access_key_id, s3_secret_access_key]
networks: [edge, data]
# Корневая ФС только для чтения, tmpfs /tmp — у API нет места для локальной копии оригинала.
read_only: true
tmpfs: [/tmp]
stop_grace_period: 20s # drain 3 с + graceful shutdown uvicorn до 10 с, с запасом
depends_on: *api-depends
restart: unless-stopped
migrate:
# Один запуск на весь стенд (а не в каждой реплике): pg_advisory_lock + schema_migrations.
build: .
image: mtusi-lab4-api:local
command: ["python", "-m", "app.migrate"]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
SESSION_STORE: postgres
secrets: [database_url]
networks: [data]
depends_on:
postgres:
condition: service_healthy
deploy:
resources:
limits: {cpus: "0.5", memory: 128M}
restart: "no"
# S3-совместимое хранилище оригиналов. Порты не публикуются на хост: доступ только из сети data
# (API и s3-init). Веб-консоль RustFS выключена (по умолчанию, RUSTFS_CONSOLE_ENABLE не задан).
s3:
image: rustfs/rustfs:1.0.4@sha256:ed9210d6411d77ffceb70d94b964a3cb7d225983368bc25bebe01e995293dcc2
environment:
RUSTFS_ACCESS_KEY_FILE: /run/secrets/s3_access_key_id
RUSTFS_SECRET_KEY_FILE: /run/secrets/s3_secret_access_key
RUSTFS_REGION: ${S3_REGION:-us-east-1}
RUSTFS_VOLUMES: /data
RUSTFS_OBS_LOG_DIRECTORY: "" # логи в stdout контейнера
RUSTFS_OBS_LOGGER_LEVEL: warn
secrets: [s3_access_key_id, s3_secret_access_key]
volumes:
- s3data:/data
networks: [data]
healthcheck:
test: ["CMD", "curl", "-fs", "-o", "/dev/null", "http://127.0.0.1:9000/health"]
interval: 2s
timeout: 3s
retries: 30
start_period: 5s
stop_grace_period: 20s
deploy:
resources:
limits: {cpus: "1.0", memory: 512M}
restart: unless-stopped
s3-init:
# Идемпотентный bootstrap: bucket создаётся, если его нет; анонимная политика удаляется;
# анонимный GET проверяется на отказ. Повторный запуск данные не трогает.
image: mtusi-lab4-api:local
command: ["python", "-m", "app.s3_bootstrap"]
environment:
S3_ENDPOINT: ${S3_ENDPOINT:-http://s3:9000}
S3_REGION: ${S3_REGION:-us-east-1}
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret_access_key
secrets: [s3_access_key_id, s3_secret_access_key]
networks: [data]
depends_on:
s3:
condition: service_healthy
migrate:
condition: service_completed_successfully # образ api уже собран сервисом migrate
deploy:
resources:
limits: {cpus: "0.5", memory: 128M}
restart: "no"
postgres:
image: postgres:17.7-bookworm
environment:
POSTGRES_USER: app
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets: [postgres_password]
volumes:
- pgdata:/var/lib/postgresql/data
networks: [data]
healthcheck:
test: ["CMD", "pg_isready", "-U", "app", "-d", "messenger"]
interval: 2s
timeout: 3s
retries: 30
shm_size: 128m
stop_grace_period: 30s # даём PostgreSQL завершиться с checkpoint, без recovery при старте
deploy:
resources:
limits: {cpus: "${PG_CPUS:-2.0}", memory: 768M}
restart: unless-stopped
valkey:
image: valkey/valkey:8.1.4
command: ["valkey-server", "/run/secrets/valkey_conf"]
secrets: [valkey_conf]
networks: [data]
healthcheck:
test: ["CMD-SHELL", "valkey-cli --no-auth-warning -a \"$$(sed -n 's/^requirepass //p' /run/secrets/valkey_conf)\" ping | grep -q PONG"]
interval: 2s
timeout: 3s
retries: 30
deploy:
resources:
limits: {cpus: "0.5", memory: 96M}
restart: unless-stopped
# Отдельная реплика с коротким TTL только для автотеста истечения сессии (lab2, уровень 4).
# Порт не публикуется: tester обращается к ней по внутренней сети.
api-ttl:
profiles: [test]
image: mtusi-lab4-api:local
environment:
<<: *api-env
SESSION_TTL_SECONDS: "2"
secrets: [database_url, cache_url, s3_access_key_id, s3_secret_access_key]
networks: [edge, data]
read_only: true
tmpfs: [/tmp]
deploy:
resources: *api-limits
depends_on: *api-depends
# Linux-окружение для make/тестов/hook-скриптов (нужно на Windows без make и WSL).
tester:
profiles: [tools]
build:
context: .
dockerfile: tools/tester.Dockerfile
image: mtusi-lab4-tester:local
working_dir: /work
environment:
BASE_URL: http://lb:8080
TTL_BASE_URL: http://api-ttl:8080
LB_STATS_URL: http://lb:8404/stats
PYTHONUTF8: "1"
PYTHONDONTWRITEBYTECODE: "1"
networks: [edge]
volumes:
- .:/work
- /var/run/docker.sock:/var/run/docker.sock
networks:
# edge: lb <-> api (+ tester). data: api/migrate <-> хранилища; lb в неё не входит.
edge:
data:
internal: true
volumes:
pgdata:
s3data:
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
valkey_conf:
file: ./secrets/valkey.conf
s3_access_key_id:
file: ./secrets/s3_access_key_id
s3_secret_access_key:
file: ./secrets/s3_secret_access_key
+17
View File
@@ -0,0 +1,17 @@
# 2026-11-12T15:42:03Z, commit ec540a1
python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://lb:8080"
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 125, "failed_attempts": 0, "first_recovery_seconds": 4.666}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
mtusi-lab4-api-1 Up 2 minutes (healthy)
mtusi-lab4-api-2 Up 6 seconds (healthy)
python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://lb:8080"
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 125, "failed_attempts": 0, "first_recovery_seconds": 4.244}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
mtusi-lab4-api-1 Up 6 seconds (healthy)
mtusi-lab4-api-2 Up 35 seconds (healthy)
# evidence/stop-one.log (what the hook really stopped):
2026-11-12T15:42:09Z mode=stop instance=406b73449330-7c6529 container=mtusi-lab4-api-2 state=exited exit=0 finished=2026-11-12T15:42:12.725820822Z
2026-11-12T15:42:38Z mode=stop instance=9f9f380ebef7-2fe1ee container=mtusi-lab4-api-1 state=exited exit=0 finished=2026-11-12T15:42:41.725669058Z
+21
View File
@@ -0,0 +1,21 @@
# 2026-11-12T15:43:02Z, commit ec540a1
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://lb: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.
# hook scope (StartedAt before/after of every process):
before:
/mtusi-lab4-api-1 2026-11-12T15:43:25.945855638Z
/mtusi-lab4-api-2 2026-11-12T15:43:26.378025301Z
/mtusi-lab4-lb-1 2026-11-12T15:43:32.867507504Z
/mtusi-lab4-postgres-1 2026-11-12T15:43:15.880707203Z
/mtusi-lab4-s3-1 2026-11-12T15:43:15.991679035Z
/mtusi-lab4-valkey-1 2026-11-12T15:43:16.182909146Z
after:
/mtusi-lab4-api-1 2026-11-12T15:43:54.05450379Z
/mtusi-lab4-api-2 2026-11-12T15:43:54.412315531Z
/mtusi-lab4-lb-1 2026-11-12T15:44:00.933617411Z
/mtusi-lab4-postgres-1 2026-11-12T15:43:44.505071692Z
/mtusi-lab4-s3-1 2026-11-12T15:43:44.304941151Z
/mtusi-lab4-valkey-1 2026-11-12T15:43:44.162913947Z
ready
+7
View File
@@ -0,0 +1,7 @@
# 2026-11-12T15:41:38Z, commit ec540a1
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
python3 scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
python3 tests/smoke.py --base-url "http://lb:8080"
PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.
+28
View File
@@ -0,0 +1,28 @@
# 2026-11-12T15:41:26Z, commit ec540a1
NAME IMAGE STATUS PORTS
mtusi-lab4-api-1 mtusi-lab4-api:local Up About a minute (healthy) 8080/tcp
mtusi-lab4-api-2 mtusi-lab4-api:local Up 3 minutes (healthy) 8080/tcp
mtusi-lab4-api-ttl-1 mtusi-lab4-api:local Exited (137) 38 seconds ago
mtusi-lab4-lb-1 haproxy:3.2.8-alpine Up 8 minutes (healthy) 127.0.0.1:8080->8080/tcp, 127.0.0.1:8404->8404/tcp
mtusi-lab4-migrate-1 mtusi-lab4-api:local Exited (0) 2 minutes ago
mtusi-lab4-postgres-1 postgres:17.7-bookworm Up 44 seconds (healthy) 5432/tcp
mtusi-lab4-s3-1 rustfs/rustfs:1.0.4@sha256:ed9210d6411d77ffceb70d94b964a3cb7d225983368bc25bebe01e995293dcc2 Up 2 minutes (healthy) 9000-9001/tcp
mtusi-lab4-s3-init-1 mtusi-lab4-api:local Exited (0) 2 minutes ago
mtusi-lab4-valkey-1 valkey/valkey:8.1.4 Up 58 seconds (healthy) 6379/tcp
# s3-init (idempotent bucket bootstrap + anonymous access check):
bucket messenger-attachments: exists
bucket messenger-attachments: no bucket policy (private)
anonymous GET messenger-attachments/_bootstrap/private-check: HTTP 403 (denied)
bucket messenger-attachments: exists
bucket messenger-attachments: no bucket policy (private)
anonymous GET messenger-attachments/_bootstrap/private-check: HTTP 403 (denied)
# repeated bootstrap run (must not touch existing bucket):
bucket messenger-attachments: exists
bucket messenger-attachments: no bucket policy (private)
anonymous GET messenger-attachments/_bootstrap/private-check: HTTP 403 (denied)
# volumes:
mtusi-lab4_pgdata
mtusi-lab4_s3data
+33
View File
@@ -0,0 +1,33 @@
# 2026-11-12T15:44:05Z, commit ec540a1
PASS test_png_and_jpeg_roundtrip (2.4s)
PASS test_message_with_attachments (2.2s)
PASS test_foreign_attachment_rejected (2.4s)
PASS test_limits_and_mime (2.5s)
PASS test_dangerous_filenames (2.7s)
anonymous GET object/list -> 403
PASS test_bucket_private_outside_api (3.4s)
PASS test_no_local_copy_on_api (3.2s)
uploaded via 406b73449330-d4521b, downloaded via 9f9f380ebef7-65ee96
PASS test_failover_of_uploading_replica (8.4s)
PASS test_s3_unavailable (14.1s)
9/9 passed
PASS test_session_across_replicas (1.0s)
PASS test_same_key_concurrent_across_replicas (4.5s)
PASS test_same_key_concurrent_different_bodies (3.6s)
PASS test_key_scope_and_format (2.9s)
PASS test_replay_rechecks_session (2.3s)
PASS test_transient_failure_not_recorded (7.8s)
PASS test_sigterm_drain (11.4s)
PASS test_infrastructure_rules (1.0s)
8/8 passed
PASS test_wrong_password (1.4s)
PASS test_logout (1.1s)
PASS test_short_ttl (3.7s)
PASS test_username_race (5.4s)
PASS test_chat_rollback (1.5s)
PASS test_cursor_rules (2.2s)
PASS test_valkey_cache_role (2.1s)
PASS test_revoke_during_cache_partition (3.1s)
PASS test_valkey_down (6.1s)
PASS test_postgres_down (11.4s)
10/10 passed
+89
View File
@@ -0,0 +1,89 @@
# HAProxy — единственная публичная точка входа lab3.
# Реплики API обнаруживаются через DNS Docker (имя сервиса "api" -> все IP его контейнеров),
# поэтому масштабирование `--scale api=N` (N <= 8) не требует правки конфигурации.
# Sticky session нет намеренно: любая реплика обслуживает любой запрос, состояние — в PostgreSQL/Valkey.
global
log stdout format raw local0 info
maxconn 4096
hard-stop-after 30s
# Встроенный DNS Docker. Интервал повторного разрешения 1 с: остановленный контейнер исчезает
# из ответа DNS, и его слот server-template уходит в MAINT ("No IP for server") за 1–2 с.
resolvers docker
nameserver dns 127.0.0.11:53
accepted_payload_size 8192
resolve_retries 2
timeout resolve 1s
timeout retry 500ms
hold valid 1s
hold obsolete 1s
hold nx 1s
hold other 1s
hold refused 1s
hold timeout 1s
defaults
mode http
log global
option httplog
option dontlognull
timeout connect 1s # до живой реплики в той же сети — миллисекунды; 1 с = признак отказа
timeout client 30s
timeout server 15s # дольше statement_timeout БД (5 с) и Argon2id под нагрузкой
timeout http-request 10s
timeout http-keep-alive 10s # меньше keep-alive uvicorn (30 с): idle-соединение закрывает HAProxy первым
timeout queue 5s
timeout check 1s
# Повтор на ДРУГОЙ реплике (redispatch) при неудачном соединении; L7-повторы ограничены ниже.
retries 2
option redispatch 1
# Ответы, созданные самим LB, — в формате ошибок контракта (без X-Instance-Id: их создал не API).
http-error status 502 content-type application/json lf-string "{\"error\":{\"code\":\"unavailable\",\"message\":\"Bad gateway\",\"request_id\":\"%[req.hdr(x-request-id)]\"}}" hdr X-Request-Id "%[req.hdr(x-request-id)]"
http-error status 503 content-type application/json lf-string "{\"error\":{\"code\":\"unavailable\",\"message\":\"No API replica available\",\"request_id\":\"%[req.hdr(x-request-id)]\"}}" hdr X-Request-Id "%[req.hdr(x-request-id)]"
http-error status 504 content-type application/json lf-string "{\"error\":{\"code\":\"unavailable\",\"message\":\"Gateway timeout\",\"request_id\":\"%[req.hdr(x-request-id)]\"}}" hdr X-Request-Id "%[req.hdr(x-request-id)]"
frontend public
bind :8080
# Сквозной request id: API принимает корректный входящий X-Request-Id, LB подставляет свой, если его нет.
unique-id-format %[uuid()]
http-request set-header X-Request-Id %[unique-id] unless { req.hdr(x-request-id) -m reg ^[A-Za-z0-9._:-]{1,128}$ }
# Если /health/ready не проходит НИ У ОДНОЙ реплики (например, недоступна БД), не отвечаем
# безликим 503 от LB, а отдаём запрос живым процессам: они вернут честный 503 контракта,
# а /health/live продолжит работать.
use_backend api_live if { nbsrv(api) eq 0 }
default_backend api
backend api
balance roundrobin
option httpchk
http-check send meth GET uri /health/ready
http-check expect status 200
# Активная проверка раз в 1 с, вывод из ротации после 2 неудач подряд, возврат после 2 успехов.
# Пассивно: 2 ошибки соединения подряд на реальном трафике — сразу DOWN, не дожидаясь проверки.
default-server check inter 1s fastinter 500ms downinter 1s fall 2 rise 2 observe layer4 error-limit 2 on-error mark-down
# L7-повтор на другой реплике безопасен только для GET и POST сообщения (защищён Idempotency-Key).
# Для POST /users, /chats, /auth/sessions и DELETE остаются лишь повторы до отправки запроса (conn-failure).
retry-on conn-failure empty-response response-timeout
acl safe_method method GET HEAD
acl is_post method POST
acl messages_path path_reg ^/api/v1/chats/[^/]+/messages$
http-request disable-l7-retry unless safe_method || is_post messages_path
server-template api- 8 api:8080 resolvers docker init-addr none resolve-prefer ipv4
backend api_live
balance roundrobin
option httpchk
http-check send meth GET uri /health/live
http-check expect status 200
default-server check inter 1s fall 2 rise 2
server-template live- 8 api:8080 resolvers docker init-addr none resolve-prefer ipv4
# Наблюдаемость LB: состояние backend-ов и метрики. Публикуется только на 127.0.0.1 хоста.
frontend stats
bind :8404
http-request use-service prometheus-exporter if { path /metrics }
stats enable
stats uri /stats
stats refresh 2s
stats show-legends
+59
View File
@@ -0,0 +1,59 @@
-- 0001: базовая схема мессенджера lab2.
-- Применяется раннером app/migrate.py внутри одной транзакции; версия пишется в schema_migrations.
CREATE TABLE users (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
username text NOT NULL,
display_name text NOT NULL,
password_hash text NOT NULL, -- строка Argon2id ($argon2id$v=19$m=...,t=...,p=...$salt$hash)
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT users_username_key UNIQUE (username), -- защита от гонки регистраций: решает БД, а не приложение
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
);
-- Серверные сессии. Источник истины; Valkey хранит только копию с TTL.
-- В БД лежит SHA-256 от токена, а не сам токен: утечка дампа не даёт войти.
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY CHECK (octet_length(token_hash) = 32),
user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
expires_at timestamptz NOT NULL,
revoked_at timestamptz,
CONSTRAINT sessions_expiry_after_create CHECK (expires_at > created_at)
);
CREATE INDEX sessions_user_id_idx ON sessions (user_id);
CREATE INDEX sessions_expires_at_idx ON sessions (expires_at); -- для периодической очистки истёкших
CREATE TABLE chats (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_by uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
-- Список чатов сортируется по (created_at, id).
CREATE INDEX chats_created_at_id_idx ON chats (created_at, id);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users (id),
joined_at timestamptz NOT NULL DEFAULT clock_timestamp(),
PRIMARY KEY (chat_id, user_id) -- один пользователь входит в чат один раз
);
-- "Чаты пользователя": поиск по user_id (PK начинается с chat_id и тут не помогает).
CREATE INDEX chat_members_user_id_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
chat_id uuid NOT NULL,
sender_id uuid NOT NULL,
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
-- Отправитель обязан быть участником этого чата: гарантирует сама БД.
CONSTRAINT messages_sender_is_member FOREIGN KEY (chat_id, sender_id)
REFERENCES chat_members (chat_id, user_id)
);
-- Индекс под keyset-пагинацию истории:
-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT n
-- Равенство по chat_id + диапазон по (created_at, id) читаются одним проходом индекса без сортировки.
CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id);
+21
View File
@@ -0,0 +1,21 @@
-- 0002: общая идемпотентность POST /chats/{chat_id}/messages (lab3).
-- Только добавляет таблицу (expand): версия lab2 продолжает работать на этой схеме, пока идёт замена реплик.
-- Область уникальности контракта: пользователь + метод + путь чата + ключ.
-- Метод один (POST), путь однозначно задаётся chat_id, поэтому PK = (user_id, chat_id, key).
CREATE TABLE idempotency_keys (
user_id uuid NOT NULL,
chat_id uuid NOT NULL,
key text NOT NULL CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'),
request_hash bytea NOT NULL CHECK (octet_length(request_hash) = 32), -- SHA-256 канонического JSON тела
message_id uuid NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
PRIMARY KEY (user_id, chat_id, key),
CONSTRAINT idempotency_sender_is_member FOREIGN KEY (chat_id, user_id)
REFERENCES chat_members (chat_id, user_id),
-- Ключ вставляется ДО сообщения (он и есть "замок" против гонки), поэтому FK проверяется при COMMIT.
CONSTRAINT idempotency_message_fk FOREIGN KEY (message_id)
REFERENCES messages (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED
);
-- Периодическая очистка ключей старше IDEMPOTENCY_TTL_SECONDS.
CREATE INDEX idempotency_keys_created_at_idx ON idempotency_keys (created_at);
+10
View File
@@ -0,0 +1,10 @@
-- 0003: общий для всех реплик признак "кэшу сессий не доверять до ...".
-- В lab2 окно недоверия после сбоя Valkey жило в памяти единственного процесса. С несколькими репликами
-- это локальное состояние, от которого зависит корректность: реплика, не видевшая сбоя, отдала бы
-- копию отозванной сессии. Теперь реплика, получившая ошибку Valkey, публикует окно здесь.
-- Только добавление (expand): версии без этой таблицы её просто не используют.
CREATE TABLE cache_state (
id smallint PRIMARY KEY CHECK (id = 1), -- одна строка на весь стенд
distrust_until timestamptz NOT NULL
);
INSERT INTO cache_state (id, distrust_until) VALUES (1, '-infinity');
+50
View File
@@ -0,0 +1,50 @@
-- 0004: вложения (lab4). Метаданные — здесь, в PostgreSQL; байты — в приватном S3-bucket.
-- Только expand: версия lab3 продолжает работать на этой схеме (новые таблицы она не читает).
-- Одно вложение = один оригинал в S3. Файл заранее привязан к чату (chat_id), а не к сообщению:
-- сначала upload, потом POST сообщения с attachment_ids.
CREATE TABLE attachments (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats (id),
owner_id uuid NOT NULL,
filename text NOT NULL CHECK (char_length(filename) BETWEEN 1 AND 255), -- только для отображения
content_type text NOT NULL CHECK (content_type IN ('image/png', 'image/jpeg')),
size_bytes bigint NOT NULL CHECK (size_bytes BETWEEN 1 AND 10485760),
sha256 text NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'),
width integer NOT NULL CHECK (width > 0),
height integer NOT NULL CHECK (height > 0),
-- Ключ объекта назначает сервер (attachments/<uuid>), имя файла клиента в нём не участвует.
-- В публичный API ключ не попадает.
object_key text NOT NULL UNIQUE,
status text NOT NULL DEFAULT 'ready' CHECK (status IN ('ready')),
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
updated_at timestamptz NOT NULL DEFAULT clock_timestamp(),
-- Загрузивший обязан быть участником чата.
CONSTRAINT attachments_owner_is_member FOREIGN KEY (chat_id, owner_id)
REFERENCES chat_members (chat_id, user_id),
-- Цель для составного FK из message_attachments: вложение и сообщение — из одного чата.
CONSTRAINT attachments_id_chat_key UNIQUE (id, chat_id)
);
CREATE INDEX attachments_chat_id_idx ON attachments (chat_id);
-- Связь сообщение -> вложения (0..10, порядок как в запросе).
-- chat_id входит в оба FK: БД сама не даст прикрепить вложение другого чата.
CREATE TABLE message_attachments (
message_id uuid NOT NULL,
attachment_id uuid NOT NULL,
chat_id uuid NOT NULL,
position smallint NOT NULL CHECK (position BETWEEN 0 AND 9),
PRIMARY KEY (message_id, attachment_id),
UNIQUE (message_id, position),
CONSTRAINT message_attachments_attachment_fk FOREIGN KEY (attachment_id, chat_id)
REFERENCES attachments (id, chat_id)
);
CREATE INDEX message_attachments_attachment_idx ON message_attachments (attachment_id);
-- Сообщение может состоять только из вложений: text="" допустим (непустота text ИЛИ вложений
-- проверяется в API, т.к. вложения вставляются отдельной строкой в той же транзакции).
ALTER TABLE messages DROP CONSTRAINT messages_text_check;
ALTER TABLE messages ADD CONSTRAINT messages_text_check CHECK (char_length(text) BETWEEN 0 AND 4000);
ALTER TABLE messages ADD CONSTRAINT messages_id_chat_key UNIQUE (id, chat_id);
ALTER TABLE message_attachments ADD CONSTRAINT message_attachments_message_fk
FOREIGN KEY (message_id, chat_id) REFERENCES messages (id, chat_id) ON DELETE CASCADE;
+7
View File
@@ -0,0 +1,7 @@
-- 0005_nul_safe_text: точное хранение строк с U+0000 (замечание к lab3, PR #99: "abc\u0000def" давал 500).
-- PostgreSQL text не хранит 0x00. Если строка содержит U+0000, её точные UTF-8 байты пишутся в *_raw,
-- а в основной столбец — та же строка с U+FFFD вместо U+0000 (см. app/pgtext.py).
-- Только expand: столбцы nullable, версия без них продолжает работать на этой схеме.
ALTER TABLE users ADD COLUMN display_name_raw bytea CHECK (octet_length(display_name_raw) <= 400);
ALTER TABLE chats ADD COLUMN title_raw bytea CHECK (octet_length(title_raw) <= 400);
ALTER TABLE messages ADD COLUMN text_raw bytea CHECK (octet_length(text_raw) <= 16000);
+26
View File
@@ -0,0 +1,26 @@
# Полный lock (pip freeze в python:3.12.12-slim-bookworm); устанавливается с --no-deps.
# Прямые зависимости: fastapi, uvicorn, asyncpg, argon2-cffi, redis (клиент совместим с Valkey),
# lab4: minio (S3-клиент, работает с RustFS по S3 API), pillow (разбор заголовка и проверка PNG/JPEG).
annotated-types==0.8.0
anyio==4.15.1
argon2-cffi==23.1.0
argon2-cffi-bindings==26.1.0
asyncpg==0.30.0
certifi==2026.10.23
cffi==2.1.1
click==8.5.0
fastapi==0.115.12
h11==0.16.0
idna==3.20
minio==7.2.18
pillow==11.3.0
pycparser==3.12
pycryptodome==4.4.0
pydantic==2.14.1
pydantic_core==2.50.1
redis==5.2.1
starlette==0.46.2
typing-inspection==0.4.4
typing_extensions==4.16.0
urllib3==2.8.0
uvicorn==0.34.2
+48
View File
@@ -0,0 +1,48 @@
#!/bin/sh
# Повторяемый сбор доказательств уровня 3 lab4 в evidence/ (запуск на хосте из корня, стенд уже поднят).
# Токены/пароли/ключи S3 в вывод не попадают: тесты их не печатают, hook-вывод подавлен тестом.
set -eu
cd "$(dirname "$0")/.."
export MSYS_NO_PATHCONV=1 PYTHONUTF8=1
compose() { docker compose --env-file .env "$@"; }
tester() { compose --profile tools run --rm tester sh -c "$1" 2>&1 | grep -v '^ Container'; }
stamp() { echo "# $(date -u +%Y-%m-%dT%H:%M:%SZ), commit $(git rev-parse --short HEAD 2>/dev/null || echo uncommitted)"; }
mkdir -p evidence
: > evidence/stop-one.log
echo '== stand and S3 bootstrap'
{ stamp
compose ps -a --format 'table {{.Name}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}'
echo; echo '# s3-init (idempotent bucket bootstrap + anonymous access check):'
compose logs --no-log-prefix s3-init
echo; echo '# repeated bootstrap run (must not touch existing bucket):'
compose run --rm -T s3-init 2>&1 | grep -v '^ Container'
echo; echo '# volumes:'
docker volume ls --filter label=com.docker.compose.project=mtusi-lab4 --format '{{.Name}}'
} | tee evidence/stand.txt
echo '== public checks'
{ stamp
tester 'pip install -q --disable-pip-version-check --root-user-action=ignore -r requirements-dev.txt && make check && make validate PYTHON=python3 && make test'
} | tee evidence/public-tests.txt
echo '== failover: stop-one for each replica (restore between runs)'
{ stamp
for i in 1 2 3 4; do
tester 'make test-failover ACTION_SCRIPT=scripts/stop-one.sh'
tester 'sh scripts/restore.sh && curl -s -o /dev/null http://lb:8080/health/live'
[ "$(cut -d' ' -f4 evidence/stop-one.log | sort -u | wc -l)" -ge 2 ] && break
done
echo; echo '# evidence/stop-one.log (what the hook really stopped):'; cat evidence/stop-one.log
} | tee evidence/failover-hook.txt
echo '== persistence: restart of lb, api, postgres, s3, valkey with volumes'
{ stamp
tester 'make test-persistence ACTION_SCRIPT=scripts/restart.sh'
echo; echo '# hook scope (StartedAt before/after of every process):'
sh scripts/restart.sh
tester 'until curl -fs http://lb:8080/health/ready >/dev/null; do sleep 0.5; done; echo ready'
} | tee evidence/persistence.txt
echo '== student tests (lab4 + lab3/lab2 regression)'
{ stamp; sh scripts/test-lab4.sh 2>&1 | grep -v '^ Container'; } | tee evidence/student-tests.txt
+42
View File
@@ -0,0 +1,42 @@
#!/bin/sh
# Создаёт локальные секреты в ./secrets (каталог в .gitignore). Повторный запуск ничего не перезаписывает.
set -eu
cd "$(dirname "$0")/.."
# Каталог закрыт для других пользователей хоста; сами файлы 0644, т.к. compose монтирует их
# в контейнеры с правами хоста, а процессы там работают под непривилегированными uid.
umask 022
mkdir -p secrets
chmod 700 secrets
random_hex() { od -An -tx1 -N24 /dev/urandom | tr -d ' \n'; }
if [ ! -f secrets/postgres_password ]; then
pg=$(random_hex)
printf '%s' "$pg" > secrets/postgres_password
printf 'postgresql://app:%s@postgres:5432/messenger' "$pg" > secrets/database_url
echo 'created secrets/postgres_password, secrets/database_url'
fi
if [ ! -f secrets/valkey.conf ]; then
vk=$(random_hex)
# Valkey — только кэш сессий: persistence выключена намеренно, источник истины — PostgreSQL.
cat > secrets/valkey.conf <<EOF
requirepass $vk
save ""
appendonly no
maxmemory 64mb
maxmemory-policy volatile-lru
EOF
printf 'redis://:%s@valkey:6379/0' "$vk" > secrets/cache_url
echo 'created secrets/valkey.conf, secrets/cache_url'
fi
if [ ! -f secrets/s3_secret_access_key ]; then
# Учётные данные S3 (RustFS): access key — не секретный идентификатор, но тоже вне Git.
printf 'msg%s' "$(od -An -tx1 -N8 /dev/urandom | tr -d ' \n')" > secrets/s3_access_key_id
random_hex > secrets/s3_secret_access_key
echo 'created secrets/s3_access_key_id, secrets/s3_secret_access_key'
fi
if [ ! -f .env ]; then
cp .env.example .env
echo 'created .env from .env.example'
fi
echo 'secrets ready (values are not printed)'
+14
View File
@@ -0,0 +1,14 @@
#!/bin/sh
# Перезапуск ВСЕГО стенда: lb, все API-реплики, PostgreSQL, S3 (RustFS), Valkey — с сохранением volumes.
# Не выполняет down -v, FLUSHALL и повторный seed. Готовность API ожидает сам тест.
set -eu
cd "$(dirname "$0")/.."
compose() { docker compose --env-file .env "$@"; }
started_at() { docker inspect -f '{{.Name}} {{.State.StartedAt}}' $(compose ps -q lb api postgres s3 valkey); }
echo 'before:'; started_at
compose stop lb api # сначала входная точка и клиенты хранилищ
compose restart postgres s3 valkey # обычный restart контейнеров: volumes pgdata и s3data остаются
compose start api lb
echo 'after:'; started_at
+13
View File
@@ -0,0 +1,13 @@
#!/bin/sh
# Возвращает остановленные API-реплики (после stop-one.sh) и ждёт их healthcheck.
set -eu
project=${COMPOSE_PROJECT_NAME:-mtusi-lab4}
filter="--filter label=com.docker.compose.project=$project --filter label=com.docker.compose.service=api"
stopped=$(docker ps -aq $filter --filter status=exited)
[ -n "$stopped" ] && docker start $stopped >/dev/null
for _ in $(seq 1 60); do
unhealthy=$(docker ps -q $filter | xargs docker inspect -f '{{.State.Health.Status}}' | grep -vc healthy || true)
[ "$unhealthy" = 0 ] && break
sleep 1
done
docker ps $filter --format '{{.Names}} {{.Status}}'
+36
View File
@@ -0,0 +1,36 @@
#!/bin/sh
# Поочерёдная замена API-реплик без остановки сервиса (Compose не умеет rolling update сам).
# 1. собрать новый образ (BUILD_ID попадает в label образа);
# 2. применить миграции ОДИН раз (только expand-миграции: старая версия работает на новой схеме);
# 3. поднять столько же новых реплик рядом со старыми (surge x2) и дождаться их healthcheck;
# 4. по одной останавливать старые: docker stop -> SIGTERM -> drain -> graceful shutdown, затем удалить.
# HAProxy сам находит новые реплики через DNS и исключает старые по /health/ready.
# Запускать на хосте из корня репозитория (нужны bind-пути compose.yaml). NO_BUILD=1 — без пересборки.
set -eu
cd "$(dirname "$0")/.."
compose() { docker compose --env-file .env "$@"; }
project=mtusi-lab4
filter="--filter label=com.docker.compose.project=$project --filter label=com.docker.compose.service=api"
old=$(docker ps -q $filter)
n=$(echo "$old" | wc -w)
[ "$n" -ge 1 ] || { echo 'no running api replicas' >&2; exit 2; }
build_id=${BUILD_ID:-$(git rev-parse --short HEAD 2>/dev/null || echo dev)-$(date +%s)}
echo "$(date -u +%H:%M:%S) old replicas ($n): $(docker inspect -f '{{.Name}}={{index .Config.Labels "org.opencontainers.image.revision"}}' $old | tr -d / | tr '\n' ' ')"
if [ "${NO_BUILD:-0}" != 1 ]; then
compose build -q --build-arg BUILD_ID="$build_id" api
fi
compose run --rm -T migrate # однократно, под advisory lock
compose up -d --wait --no-deps --no-recreate --scale api=$((n * 2)) api 2>&1 | grep -v '^ Container' || true
new=$(docker ps -q $filter | grep -vxF "$old" || true)
[ "$(echo "$new" | wc -w)" -eq "$n" ] || { echo 'new replicas did not start' >&2; exit 3; }
echo "$(date -u +%H:%M:%S) new replicas healthy: $(docker inspect -f '{{.Name}}={{index .Config.Labels "org.opencontainers.image.revision"}}' $new | tr -d / | tr '\n' ' ')"
sleep "${SETTLE_SECONDS:-3}" # LB: rise 2 x inter 1 s + DNS 1 с
for c in $old; do
name=$(docker inspect -f '{{.Name}}' "$c" | tr -d /)
docker stop -t 20 "$c" >/dev/null
docker rm "$c" >/dev/null
echo "$(date -u +%H:%M:%S) replaced $name"
done
docker ps $filter --format '{{.Names}} {{.Status}} {{.Label "org.opencontainers.image.revision"}}'
+29
View File
@@ -0,0 +1,29 @@
#!/bin/sh
# Останавливает ОДНУ API-реплику — ту, что обслужила тест, — и оставляет её остановленной.
# TARGET_INSTANCE_ID = "<hostname контейнера>-<случайный суффикс>", hostname = короткий ID контейнера.
# STOP_MODE=stop (по умолчанию): docker stop -> SIGTERM -> drain -> graceful shutdown.
# STOP_MODE=kill: SIGKILL, внезапная смерть процесса без drain.
# БД, LB и volumes не трогает. Восстановление — отдельно: sh scripts/restore.sh
set -eu
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
cd "$(dirname "$0")/.."
project=${COMPOSE_PROJECT_NAME:-mtusi-lab4}
cid=${TARGET_INSTANCE_ID%-*}
case "$cid" in ''|*[!0-9a-f]*) echo 'TARGET_INSTANCE_ID has unexpected format' >&2; exit 2 ;; esac
# Защита от остановки чужого контейнера: только сервис api этого проекта.
owner=$(docker inspect -f '{{index .Config.Labels "com.docker.compose.project"}}/{{index .Config.Labels "com.docker.compose.service"}}' "$cid")
[ "$owner" = "$project/api" ] || { echo "container $cid is not $project/api" >&2; exit 3; }
name=$(docker inspect -f '{{.Name}}' "$cid" | tr -d /)
started=$(date -u +%Y-%m-%dT%H:%M:%SZ)
if [ "${STOP_MODE:-stop}" = kill ]; then
docker kill "$cid" >/dev/null
else
docker stop -t 20 "$cid" >/dev/null
fi
state=$(docker inspect -f '{{.State.Status}} exit={{.State.ExitCode}} finished={{.State.FinishedAt}}' "$cid")
mkdir -p evidence
printf '%s mode=%s instance=%s container=%s state=%s\n' \
"$started" "${STOP_MODE:-stop}" "$TARGET_INSTANCE_ID" "$name" "$state" >> evidence/stop-one.log
echo "stopped $name: $state"
+12
View File
@@ -0,0 +1,12 @@
#!/bin/sh
# Собственные проверки lab4 + регрессия lab3 и уровня 4 lab2. Запускать на хосте (Linux/macOS/Git Bash) из корня.
# Поднимает api-ttl (SESSION_TTL_SECONDS=2), запускает student-tests в контейнере tester, гасит api-ttl.
set -eu
cd "$(dirname "$0")/.."
compose() { docker compose --env-file .env "$@"; }
compose --profile test up -d --wait api-ttl
status=0
MSYS_NO_PATHCONV=1 compose --profile tools run --rm tester sh -c \
'python student-tests/test_lab4.py; a=$?; python student-tests/test_lab3.py; b=$?; python student-tests/test_lab2_regression.py; c=$?; exit $((a | b | c))' || status=$?
compose --profile test stop api-ttl
exit $status
+312
View File
@@ -0,0 +1,312 @@
#!/usr/bin/env python3
"""Серии отказов под нагрузкой (уровень 4): RPS, ошибки, время обнаружения и восстановления.
Запускается на ХОСТЕ из корня репозитория (нужны docker CLI и, для rolling, compose с bind-путями):
python student-tests/failover_series.py --scenario stop # graceful stop каждой реплики по очереди
python student-tests/failover_series.py --scenario kill # SIGKILL каждой реплики по очереди
python student-tests/failover_series.py --scenario rolling # scripts/rolling-update.sh под нагрузкой
Нагрузка closed-loop: W писателей (POST сообщения; неопределённый результат повторяется с ТЕМ ЖЕ ключом,
как в tests/resilience.py) и R читателей (GET истории). Параллельно раз в 200 мс опрашивается
CSV-статистика HAProxy: когда слот целевой реплики перестал быть UP — это время обнаружения отказа LB.
После серии проверяется, что все подтверждённые сообщения на месте и нет дублей.
Токены остаются в памяти процесса; в отчёт попадают только агрегаты.
"""
import argparse
import csv
import io
import json
import math
import os
import subprocess
import sys
import threading
import time
import urllib.parse
import urllib.request
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, Failure, check # noqa: E402
PROJECT = 'mtusi-lab4'
EDGE_NETWORK = PROJECT + '_edge'
API_FILTER = ['--filter', f'label=com.docker.compose.project={PROJECT}',
'--filter', 'label=com.docker.compose.service=api']
def docker(*args: str) -> str:
return subprocess.run(['docker', *args], check=True, text=True, capture_output=True).stdout.strip()
def api_containers() -> list[str]:
names = docker('ps', *API_FILTER, '--format', '{{.Names}}').split()
return sorted(names)
def container_info(name: str) -> dict:
fmt = ('{{.Config.Hostname}}|{{index .Config.Labels "org.opencontainers.image.revision"}}|'
'{{(index .NetworkSettings.Networks "%s").IPAddress}}') % EDGE_NETWORK
hostname, revision, ip = docker('inspect', '-f', fmt, name).split('|')
return {'name': name, 'hostname': hostname, 'revision': revision, 'ip': ip}
def percentile(values: list[float], p: float):
values = sorted(values)
return round(1000 * values[max(0, math.ceil(p * len(values)) - 1)], 1) if values else None
class LbWatcher(threading.Thread):
"""Опрос /stats;csv: состояние слотов backend `api` и счётчики retry/redispatch."""
def __init__(self, stats_url: str, t0: float):
super().__init__(daemon=True)
self.url = stats_url.rstrip('/') + ';csv'
self.t0 = t0
self.stop_flag = threading.Event()
self.samples = [] # (t, {addr: status})
self.first = self.last = None
def snapshot(self):
with urllib.request.urlopen(self.url, timeout=1) as r:
rows = list(csv.DictReader(io.StringIO(r.read().decode().lstrip('# '))))
servers = {row['addr']: row['status'] for row in rows
if row['pxname'] == 'api' and row['svname'] not in ('FRONTEND', 'BACKEND') and row.get('addr')}
backend = next(row for row in rows if row['pxname'] == 'api' and row['svname'] == 'BACKEND')
return servers, {'retries': int(backend['wretr'] or 0), 'redispatches': int(backend['wredis'] or 0)}
def run(self):
while not self.stop_flag.is_set():
try:
servers, counters = self.snapshot()
self.samples.append((time.monotonic() - self.t0, servers))
self.first = self.first or counters
self.last = counters
except Exception: # LB-статистика — вспомогательная, не влияет на результат серии
pass
time.sleep(0.2)
def first_not_up(self, ip: str, after: float):
"""Первый момент после `after`, когда слот с этим IP не UP (DOWN/MAINT/исчез из DNS)."""
addr = ip + ':8080'
for t, servers in self.samples:
if t >= after and not servers.get(addr, 'MISSING').startswith('UP'):
return round(t - after, 3), servers.get(addr, 'removed from DNS')
return None, None
def run_probe(base_url: str, stats_url: str, action, targets: list[dict], duration: float,
action_at: float, writers: int, readers: int) -> dict:
c = Client(base_url)
alice, bob, _eve, chat = c.bootstrap()
events = [] # (t, kind, ok, instance, latency)
confirmed = [] # подтверждённые сообщения
lock = threading.Lock()
retries_with_same_key = [0]
t0 = time.monotonic()
deadline = t0 + duration
watcher = LbWatcher(stats_url, t0)
watcher.start()
def record(kind, ok, instance, latency):
with lock:
events.append((time.monotonic() - t0, kind, ok, instance, latency))
def writer(i):
local = Client(base_url, timeout=3)
key, n = uuid.uuid4().hex, 0
text = f'probe-{i}-{n}'
while time.monotonic() < deadline:
start = time.monotonic()
try:
r = local.message(alice, chat, text, key=key)
record('write', True, r['headers'].get('X-Instance-Id', ''), time.monotonic() - start)
with lock:
confirmed.append(r['json'])
n += 1
key, text = uuid.uuid4().hex, f'probe-{i}-{n}'
except Failure:
record('write', False, '', time.monotonic() - start)
with lock:
retries_with_same_key[0] += 1
time.sleep(0.05) # тот же key и тот же body при следующей попытке
def reader(_i):
local = Client(base_url, timeout=3)
path = f"/api/v1/chats/{chat['id']}/messages?limit=20"
while time.monotonic() < deadline:
start = time.monotonic()
try:
r = local.call('GET', path, actor=bob, schema='MessagePage')
record('read', True, r['headers'].get('X-Instance-Id', ''), time.monotonic() - start)
except Failure:
record('read', False, '', time.monotonic() - start)
time.sleep(0.05)
threads = [threading.Thread(target=writer, args=(i,)) for i in range(writers)]
threads += [threading.Thread(target=reader, args=(i,)) for i in range(readers)]
for t in threads:
t.start()
time.sleep(max(0.0, t0 + action_at - time.monotonic()))
a_start = time.monotonic() - t0
action_output = action()
a_end = time.monotonic() - t0
for t in threads:
t.join()
watcher.stop_flag.set()
watcher.join()
# Сохранность: тот же токен, полная история через LB, без дублей.
history, cursor = [], None
while True:
path = f"/api/v1/chats/{chat['id']}/messages?limit=100" + (f'&cursor={urllib.parse.quote(cursor, safe="")}' if cursor else '')
page = c.call('GET', path, actor=bob, schema='MessagePage')['json']
history += page['items']
cursor = page['next_cursor']
if cursor is None:
break
ids = {m['id'] for m in history}
texts = [m['text'] for m in history]
lost = sum(1 for m in confirmed if m['id'] not in ids)
check(len(ids) == len(history), 'duplicated message id in history')
check(len(texts) == len(set(texts)), 'retry with same key produced a duplicate message')
check(lost == 0, f'{lost} confirmed messages lost')
def window(lo, hi):
sel = [e for e in events if lo <= e[0] < hi]
ok = [e for e in sel if e[2]]
span = max(hi - lo, 1e-9)
return {'seconds': round(span, 2), 'ok_rps': round(len(ok) / span, 1),
'write_rps': round(sum(1 for e in ok if e[1] == 'write') / span, 1),
'read_rps': round(sum(1 for e in ok if e[1] == 'read') / span, 1),
'errors': len(sel) - len(ok),
'p50_ms': percentile([e[4] for e in ok], .50), 'p95_ms': percentile([e[4] for e in ok], .95),
'p99_ms': percentile([e[4] for e in ok], .99), 'max_ms': percentile([e[4] for e in ok], 1.0)}
errors = [e for e in events if not e[2]]
target_prefixes = tuple(t['hostname'] + '-' for t in targets)
served_by_target = [e[0] for e in events if e[2] and e[3].startswith(target_prefixes)]
per_second = []
for s in range(int(duration)):
sel = [e for e in events if s <= e[0] < s + 1]
per_second.append({'t': s, 'ok': sum(1 for e in sel if e[2]), 'err': sum(1 for e in sel if not e[2]),
'instances': len({e[3] for e in sel if e[2]})})
detection = {}
for t in targets:
seconds, state = watcher.first_not_up(t['ip'], a_start)
detection[t['name']] = {'lb_marked_not_up_after_s': seconds, 'lb_state': state}
lb_counters = None
if watcher.first and watcher.last:
lb_counters = {k: watcher.last[k] - watcher.first[k] for k in watcher.last}
return {
'targets': [{k: t[k] for k in ('name', 'hostname', 'revision')} for t in targets],
'action_started_s': round(a_start, 3), 'action_duration_s': round(a_end - a_start, 3),
'action_output': action_output,
'before': window(1, a_start), 'during_action_plus_5s': window(a_start, a_end + 5),
'after': window(a_end + 5, duration),
'errors_total': len(errors),
'write_attempts_retried_same_key': retries_with_same_key[0],
'error_window_s': ([round(errors[0][0] - a_start, 3), round(errors[-1][0] - a_start, 3)] if errors else None),
'recovery_s': round(errors[-1][0] - a_start, 3) if errors else 0.0,
'target_last_served_after_action_s': (round(max(served_by_target) - a_start, 3)
if served_by_target and max(served_by_target) >= a_start else None),
'lb_detection': detection,
'lb_retries_redispatches': lb_counters,
'instances_after': sorted({e[3] for e in events if e[2] and e[0] > a_end + 5}),
'confirmed_writes': len(confirmed), 'history_messages': len(history),
'duplicates': 0, 'lost_confirmed': lost,
'timeline_per_second': per_second,
}
def wait_lb_up(stats_url: str, ip: str, seconds: float = 60) -> None:
deadline = time.monotonic() + seconds
url = stats_url.rstrip('/') + ';csv'
while time.monotonic() < deadline:
try:
with urllib.request.urlopen(url, timeout=1) as r:
rows = csv.DictReader(io.StringIO(r.read().decode().lstrip('# ')))
if any(row['pxname'] == 'api' and row.get('addr') == ip + ':8080' and row['status'].startswith('UP')
for row in rows):
return
except OSError:
pass
time.sleep(0.5)
raise Failure('replica did not return to LB rotation')
def restore(stats_url: str) -> None:
subprocess.run(['sh', str(ROOT / 'scripts/restore.sh')], check=True, capture_output=True)
for name in api_containers():
wait_lb_up(stats_url, container_info(name)['ip'])
def main() -> int:
p = argparse.ArgumentParser(description=__doc__.split('\n')[0])
p.add_argument('--scenario', choices=['stop', 'kill', 'rolling'], required=True)
p.add_argument('--base-url', default=os.environ.get('BASE_URL', 'http://localhost:8080'))
p.add_argument('--stats-url', default=os.environ.get('LB_STATS_URL', 'http://localhost:8404/stats'))
p.add_argument('--duration', type=float, default=None)
p.add_argument('--action-at', type=float, default=8)
p.add_argument('--writers', type=int, default=4)
p.add_argument('--readers', type=int, default=2)
p.add_argument('--output', default=None)
args = p.parse_args()
duration = args.duration or (45 if args.scenario == 'rolling' else 25)
runs = []
if args.scenario == 'rolling':
targets = [container_info(n) for n in api_containers()]
def action():
r = subprocess.run(['sh', str(ROOT / 'scripts/rolling-update.sh')], text=True, capture_output=True)
check(r.returncode == 0, 'rolling-update.sh failed: ' + r.stderr[-500:])
return r.stdout.strip().splitlines()
result = run_probe(args.base_url, args.stats_url, action, targets, duration, args.action_at,
args.writers, args.readers)
result['replicas_after'] = [container_info(n) for n in api_containers()]
runs.append(result)
else:
for name in api_containers(): # по очереди каждую реплику, восстанавливая предыдущую
restore(args.stats_url)
target = container_info(name)
def action(name=name):
started = time.monotonic()
if args.scenario == 'kill':
docker('kill', name)
else:
docker('stop', '-t', '20', name)
state = docker('inspect', '-f', '{{.State.Status}} exit={{.State.ExitCode}}', name)
return [f'{args.scenario} {name}: {state} in {time.monotonic() - started:.2f}s']
result = run_probe(args.base_url, args.stats_url, action, [target], duration, args.action_at,
args.writers, args.readers)
runs.append(result)
print(f"{args.scenario} {name}: errors={result['errors_total']} recovery={result['recovery_s']}s "
f"lb_detection={result['lb_detection'][name]['lb_marked_not_up_after_s']}s "
f"rps before/after={result['before']['ok_rps']}/{result['after']['ok_rps']}", flush=True)
restore(args.stats_url)
report = {
'scenario': args.scenario, 'date_utc': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
'profile': {'duration_s': duration, 'action_at_s': args.action_at, 'writers': args.writers,
'readers': args.readers, 'client_timeout_s': 3,
'workload': 'closed-loop: POST message (retry same key on failure) + GET history limit=20'},
'runs': runs,
}
text = json.dumps(report, ensure_ascii=False, indent=2)
if args.output:
Path(args.output).parent.mkdir(parents=True, exist_ok=True)
Path(args.output).write_text(text + '\n', encoding='utf-8')
summary = [{k: r[k] for k in ('targets', 'errors_total', 'recovery_s', 'lb_detection', 'action_duration_s',
'target_last_served_after_action_s', 'lb_retries_redispatches')}
| {'rps_before': r['before']['ok_rps'], 'rps_after': r['after']['ok_rps'],
'p99_during_ms': r['during_action_plus_5s']['p99_ms']} for r in runs]
print(json.dumps(summary, ensure_ascii=False, indent=1))
return 0
if __name__ == '__main__':
sys.exit(main())
Binary file not shown.

After

Width:  |  Height:  |  Size: 1.9 KiB

+15
View File
@@ -0,0 +1,15 @@
#!/usr/bin/env python3
"""Один вход (одна сессия) -> 10 запросов через LB: какие реплики обслужили. Токен не печатается."""
import os
import sys
from collections import Counter
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
from client import Client # noqa: E402
c = Client(os.environ.get('BASE_URL', 'http://lb:8080'))
alice = c.user('instances')
served = [c.call('GET', '/api/v1/users/me', actor=alice, schema='User')['headers']['X-Instance-Id'] for _ in range(10)]
print('X-Instance-Id sequence:', ' '.join(served))
print('distinct replicas for one session without re-login:', dict(Counter(served)))
+256
View File
@@ -0,0 +1,256 @@
#!/usr/bin/env python3
"""Регрессия: собственные проверки уровня 4 из lab2, перенесённые на стенд lab3 (через LB).
Запуск: sh scripts/test-lab3.sh (внутри сервиса tester).
Требуют запущенный стенд и доступ к docker (останавливают/ставят на паузу valkey и postgres,
затем возвращают их). Используют только синтетические данные.
"""
import base64
import hashlib
import os
import subprocess
import sys
import threading
import time
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, Failure, check # noqa: E402
BASE_URL = os.environ.get('BASE_URL', 'http://lb:8080')
TTL_BASE_URL = os.environ.get('TTL_BASE_URL', 'http://api-ttl:8080')
VALKEY_CLI = 'valkey-cli --no-auth-warning -a "$(sed -n "s/^requirepass //p" /run/secrets/valkey_conf)" '
def compose(*args: str, capture: bool = False) -> str:
result = subprocess.run(['docker', 'compose', '--env-file', str(ROOT / '.env'), *args],
cwd=ROOT, check=True, text=True,
stdout=subprocess.PIPE if capture else subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
return (result.stdout or '').strip()
def sql(query: str) -> str:
return compose('exec', '-T', 'postgres', 'psql', '-U', 'app', '-d', 'messenger', '-tAc', query, capture=True)
def valkey(command: str) -> str:
return compose('exec', '-T', 'valkey', 'sh', '-c', VALKEY_CLI + command, capture=True)
def basic(username: str, password: str) -> dict:
return {'Authorization': 'Basic ' + base64.b64encode(f'{username}:{password}'.encode()).decode()}
def wait_ready(c: Client, seconds: float = 60) -> None:
deadline = time.monotonic() + seconds
while True:
try:
c.call('GET', '/health/ready', schema='Health')
return
except Failure:
check(time.monotonic() < deadline, 'API did not become ready')
time.sleep(0.5)
def wait_healthy(service: str, seconds: float = 60) -> None:
deadline = time.monotonic() + seconds
container = compose('ps', '-q', service, capture=True)
while subprocess.run(['docker', 'inspect', '-f', '{{.State.Health.Status}}', container],
text=True, capture_output=True).stdout.strip() != 'healthy':
check(time.monotonic() < deadline, service + ' did not become healthy')
time.sleep(0.5)
def cache_key(actor: dict) -> str:
return 'session:' + hashlib.sha256(actor['token'].encode()).hexdigest()
def wait_cache_used(c: Client, actor: dict, seconds: float = 75) -> None:
"""После недавнего сбоя Valkey API законно не доверяет кэшу SESSION_CACHE_TTL_SECONDS — ждём конца окна."""
deadline = time.monotonic() + seconds
while True:
c.call('GET', '/api/v1/users/me', actor=actor, schema='User')
if valkey('EXISTS ' + cache_key(actor)) == '1':
return
check(time.monotonic() < deadline, 'session was never cached in Valkey')
time.sleep(2)
def bearer(token: str) -> dict:
return {'Authorization': 'Bearer ' + token}
# ---------------------------------------------------------------- тесты
def test_wrong_password(c: Client):
alice = c.user('wrongpw')
username = alice['registration']['username']
wrong = c.call('POST', '/api/v1/auth/sessions', 401, headers=basic(username, 'definitely-wrong-password'))
unknown = c.call('POST', '/api/v1/auth/sessions', 401, headers=basic('no_such_' + uuid.uuid4().hex[:8], 'whatever-password-123'))
# Одинаковый ответ: по нему нельзя узнать, существует ли username.
check(wrong['json']['error']['message'] == unknown['json']['error']['message'], 'different 401 for unknown user')
check(wrong['headers']['WWW-Authenticate'] == 'Basic realm="messenger", charset="UTF-8"', 'wrong Basic challenge')
c.call('POST', '/api/v1/auth/sessions', 401, headers={'Authorization': 'Basic !!!not-base64'})
c.call('POST', '/api/v1/auth/sessions', 401, headers=bearer(alice['token'])) # Bearer на входе не принимается
def test_logout(c: Client):
alice = c.user('logout')
c.call('GET', '/api/v1/users/me', actor=alice, schema='User')
c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=alice)
r = c.call('GET', '/api/v1/users/me', 401, actor=alice)
check(r['headers']['WWW-Authenticate'] == 'Bearer realm="messenger"', 'wrong Bearer challenge')
c.call('DELETE', '/api/v1/auth/sessions/current', 401, actor=alice)
revoked = sql("SELECT count(*) FROM sessions s JOIN users u ON u.id = s.user_id "
f"WHERE u.username = '{alice['registration']['username']}' AND s.revoked_at IS NOT NULL")
check(revoked == '1', 'revocation not recorded in PostgreSQL')
def test_short_ttl(_c: Client):
# Отдельная реплика api-ttl с SESSION_TTL_SECONDS=2, общая БД и кэш.
c = Client(TTL_BASE_URL)
wait_ready(c)
alice = c.user('ttl')
c.call('GET', '/api/v1/users/me', actor=alice, schema='User')
time.sleep(3)
c.call('GET', '/api/v1/users/me', 401, actor=alice)
def test_username_race(c: Client):
username = 'race_' + uuid.uuid4().hex[:12]
body = {'username': username, 'display_name': 'Гонка', 'password': 'Race-password-' + uuid.uuid4().hex}
statuses, barrier = [], threading.Barrier(16)
def register():
barrier.wait()
statuses.append(Client(BASE_URL, timeout=30).call('POST', '/api/v1/users', [201, 409], body=body)['status'])
threads = [threading.Thread(target=register) for _ in range(16)]
for t in threads:
t.start()
for t in threads:
t.join()
check(sorted(statuses) == [201] + [409] * 15, f'race result {sorted(statuses)}')
check(sql(f"SELECT count(*) FROM users WHERE username = '{username}'") == '1', 'duplicate username row')
def test_chat_rollback(c: Client):
alice = c.user('rollback')
before = sql('SELECT (SELECT count(*) FROM chats) || \' \' || (SELECT count(*) FROM chat_members)')
# Второй участник не существует: INSERT chats уже выполнен, INSERT chat_members вставит 1 из 2 -> ROLLBACK.
c.call('POST', '/api/v1/chats', 400, actor=alice,
body={'title': 'Откат', 'member_ids': [alice['id'], str(uuid.uuid4())]})
after = sql('SELECT (SELECT count(*) FROM chats) || \' \' || (SELECT count(*) FROM chat_members)')
check(before == after, f'partial chat left after failure: {before} -> {after}')
listed = c.call('GET', '/api/v1/chats', actor=alice, schema='ChatPage')['json']
check(listed['items'] == [], 'failed chat is visible')
def test_cursor_rules(c: Client):
alice, bob, _eve, chat = c.bootstrap()
other = c.call('POST', '/api/v1/chats', 201, actor=alice, body={'title': 'Другой', 'member_ids': [alice['id']]},
schema='Chat')['json']
for i in range(3):
c.message(alice, chat, f'm{i}')
c.message(alice, other, f'o{i}')
page = c.call('GET', f'/api/v1/chats/{chat["id"]}/messages?limit=1', actor=alice, schema='MessagePage')['json']
from urllib.parse import quote
cursor = quote(page['next_cursor'], safe='')
c.call('GET', f'/api/v1/chats/{other["id"]}/messages?cursor={cursor}', 400, actor=alice) # курсор чужого чата
c.call('GET', f'/api/v1/chats/{chat["id"]}/messages?cursor=garbage', 400, actor=alice)
c.call('GET', f'/api/v1/chats/{chat["id"]}/messages?limit=101', 400, actor=alice)
c.call('POST', '/api/v1/chats', 400, actor=alice, body={'title': 'x', 'member_ids': [alice['id']], 'extra': 1})
c.call('POST', f'/api/v1/chats/{chat["id"]}/messages', 400, actor=bob, body={'text': 'x', 'sender_id': alice['id']})
def test_valkey_cache_role(c: Client):
alice = c.user('cache')
wait_cache_used(c, alice)
ttl = int(valkey('TTL ' + cache_key(alice)))
check(0 < ttl <= 60, f'unexpected cache TTL {ttl}')
valkey('FLUSHALL') # потеря всего кэша
c.call('GET', '/api/v1/users/me', actor=alice, schema='User') # источник истины — PostgreSQL
check(valkey('EXISTS ' + cache_key(alice)) == '1', 'cache was not refilled on miss')
def test_valkey_down(c: Client):
alice = c.user('vkdown')
try:
compose('stop', 'valkey')
c.call('GET', '/api/v1/users/me', actor=alice, schema='User') # обход кэша через PostgreSQL
c.call('GET', '/api/v1/users/me', 401, headers=bearer('A' * 43)) # неизвестный токен — не доверяем
c.call('GET', '/api/v1/users/me', 401) # аноним — 401
bob = c.user('vkdown_login') # вход работает без кэша
c.call('GET', '/health/ready', schema='Health') # Valkey не критичен
c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=bob)
c.call('GET', '/api/v1/users/me', 401, actor=bob)
finally:
compose('start', 'valkey')
wait_healthy('valkey')
def test_revoke_during_cache_partition(c: Client):
# Худший случай инвалидации: logout во время разрыва API <-> Valkey, DEL потерян, а копия отозванной
# сессии в Valkey пережила разрыв. Окно недоверия к кэшу (SESSION_CACHE_TTL_SECONDS после ошибки)
# не даёт её использовать. TCP может доставить DEL повторной передачей после восстановления сети,
# поэтому потерю DEL моделируем явно: возвращаем сохранённую до разрыва копию записи.
alice = c.user('partition')
wait_cache_used(c, alice)
key = cache_key(alice)
stale_value = valkey('GET ' + key)
container = compose('ps', '-q', 'valkey', capture=True)
network = 'mtusi-lab4_data' # Valkey в lab3 только во внутренней сети data
subprocess.run(['docker', 'network', 'disconnect', network, container], check=True)
try:
c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=alice) # COMMIT в PostgreSQL прошёл
finally:
subprocess.run(['docker', 'network', 'connect', '--alias', 'valkey', network, container], check=True)
valkey(f"SET {key} '{stale_value}' EX 60")
c.call('GET', '/api/v1/users/me', 401, actor=alice)
def test_postgres_down(c: Client):
alice = c.user('pgdown')
c.call('GET', '/api/v1/users/me', actor=alice, schema='User')
try:
compose('stop', 'postgres')
c.call('GET', '/health/live', schema='Health')
c.call('GET', '/health/ready', 503)
r = c.call('GET', '/api/v1/users/me', 503, actor=alice) # ограниченная ошибка, не 500/200
check(r['json']['error']['code'] == 'unavailable', 'expected unavailable')
c.call('GET', '/api/v1/users/me', 503, headers=bearer('B' * 43)) # неизвестный токен не проходит
c.call('GET', '/api/v1/chats', 401) # аноним не пропускается
c.call('POST', '/api/v1/users', 503, body={'username': 'pg_' + uuid.uuid4().hex[:8],
'display_name': 'x', 'password': 'Password-123456'})
finally:
compose('start', 'postgres')
wait_ready(c)
c.call('GET', '/api/v1/users/me', actor=alice, schema='User') # та же сессия жива после рестарта БД
TESTS = [test_wrong_password, test_logout, test_short_ttl, test_username_race, test_chat_rollback,
test_cursor_rules, test_valkey_cache_role, test_revoke_during_cache_partition, test_valkey_down,
test_postgres_down]
def main() -> int:
c = Client(BASE_URL)
wait_ready(c)
failed = 0
for test in TESTS:
started = time.monotonic()
try:
test(c)
print(f'PASS {test.__name__} ({time.monotonic() - started:.1f}s)')
except (Failure, subprocess.CalledProcessError, OSError) as exc:
failed += 1
print(f'FAIL {test.__name__}: {exc}')
print(f'{len(TESTS) - failed}/{len(TESTS)} passed')
return 1 if failed else 0
if __name__ == '__main__':
sys.exit(main())
+307
View File
@@ -0,0 +1,307 @@
#!/usr/bin/env python3
"""Собственные проверки lab3 (уровни 3–4), в lab4 — регрессия. Запуск: sh scripts/test-lab4.sh (внутри сервиса tester).
Обращаются к репликам и НАПРЯМУЮ (по IP из DNS Docker внутри сети edge), чтобы гарантировать, что
конкурентные повторы действительно приходят в разные процессы, а не полагаться на round-robin LB.
Требуют доступ к docker (останавливают postgres, шлют SIGTERM реплике и возвращают всё обратно).
"""
import json
import os
import socket
import subprocess
import sys
import threading
import time
import urllib.request
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, Failure, check # noqa: E402
BASE_URL = os.environ.get('BASE_URL', 'http://lb:8080')
PROJECT = 'mtusi-lab4'
API_FILTER = ['--filter', f'label=com.docker.compose.project={PROJECT}',
'--filter', 'label=com.docker.compose.service=api']
def compose(*args: str, capture: bool = False) -> str:
result = subprocess.run(['docker', 'compose', '--env-file', str(ROOT / '.env'), *args],
cwd=ROOT, check=True, text=True,
stdout=subprocess.PIPE if capture else subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
return (result.stdout or '').strip()
def docker(*args: str) -> str:
return subprocess.run(['docker', *args], check=True, text=True, capture_output=True).stdout.strip()
def sql(query: str) -> str:
return compose('exec', '-T', 'postgres', 'psql', '-U', 'app', '-d', 'messenger', '-tAc', query, capture=True)
def replica_urls() -> list[str]:
"""Все IP сервиса api из DNS Docker -> прямые адреса реплик (порты наружу не опубликованы)."""
ips = sorted({info[4][0] for info in socket.getaddrinfo('api', 8080, socket.AF_INET, socket.SOCK_STREAM)})
check(len(ips) >= 2, f'expected >= 2 api replicas in DNS, got {len(ips)}')
return [f'http://{ip}:8080' for ip in ips]
def wait_ready(c: Client, seconds: float = 60) -> None:
deadline = time.monotonic() + seconds
while True:
try:
c.call('GET', '/health/ready', schema='Health')
return
except Failure:
check(time.monotonic() < deadline, 'API did not become ready')
time.sleep(0.5)
def raw_post(base: str, path: str, actor: dict, raw: bytes, key: str | None):
"""POST с заданными байтами тела (для проверки семантического равенства JSON)."""
headers = {'Content-Type': 'application/json', 'Authorization': 'Bearer ' + actor['token']}
if key is not None:
headers['Idempotency-Key'] = key
return Client(base).call('POST', path, [201, 400, 409], raw=raw, headers=headers, schema='Message')
def concurrent(calls: list) -> list:
"""Запускает функции одновременно (barrier) и возвращает результаты в исходном порядке."""
results = [None] * len(calls)
barrier = threading.Barrier(len(calls))
def run(i):
barrier.wait()
try:
results[i] = calls[i]()
except Exception as exc: # результат проверяет вызывающий тест
results[i] = exc
threads = [threading.Thread(target=run, args=(i,)) for i in range(len(calls))]
for t in threads:
t.start()
for t in threads:
t.join()
return results
def count_messages(chat: dict) -> int:
return int(sql(f"SELECT count(*) FROM messages WHERE chat_id = '{chat['id']}'"))
# ---------------------------------------------------------------- тесты
def test_session_across_replicas(c: Client):
alice = c.user('xrepl') # вход через LB (обслужила какая-то одна реплика)
seen = {c.call('GET', '/api/v1/users/me', actor=alice, schema='User')['headers']['X-Instance-Id']
for _ in range(20)}
check(len(seen) >= 2, f'one session must be served by >= 2 replicas, saw {seen}')
urls = replica_urls()
for url in urls: # каждая реплика напрямую принимает тот же токен
me = Client(url).call('GET', '/api/v1/users/me', actor=alice, schema='User')['json']
check(me['id'] == alice['id'], 'replica resolved another user')
Client(urls[0]).call('DELETE', '/api/v1/auth/sessions/current', 204, actor=alice)
for url in urls: # logout на одной реплике виден всем (общий store)
Client(url).call('GET', '/api/v1/users/me', 401, actor=alice)
def test_same_key_concurrent_across_replicas(c: Client):
alice, _bob, _eve, chat = c.bootstrap()
urls, key = replica_urls(), uuid.uuid4().hex
calls = [lambda u=urls[i % len(urls)]: Client(u, timeout=15).message(alice, chat, 'один раз', key=key)
for i in range(24)]
results = concurrent(calls)
failures = [r for r in results if isinstance(r, Exception)]
check(not failures, f'concurrent retry failed: {failures[:1]}')
bodies = {json.dumps(r['json'], sort_keys=True) for r in results}
instances = {r['headers']['X-Instance-Id'] for r in results}
check(len(bodies) == 1, f'{len(bodies)} different messages returned for one key')
check(len(instances) >= 2, 'retries did not hit different replicas')
check(count_messages(chat) == 1, f'{count_messages(chat)} messages stored for one key')
via_lb = c.message(alice, chat, 'один раз', key=key)['json'] # и позже через LB — тот же ответ
check(json.dumps(via_lb, sort_keys=True) in bodies, 'later replay differs')
def test_same_key_concurrent_different_bodies(c: Client):
alice, _bob, _eve, chat = c.bootstrap()
urls, key = replica_urls(), uuid.uuid4().hex
path = f"/api/v1/chats/{chat['id']}/messages"
def send(url, text):
return Client(url, timeout=15).call('POST', path, [201, 409], actor=alice, body={'text': text},
headers={'Idempotency-Key': key}, schema='Message')
calls = [lambda u=urls[i % len(urls)], t=('A' if i % 2 else 'B'): send(u, t) for i in range(20)]
results = concurrent(calls)
check(not any(isinstance(r, Exception) for r in results), 'unexpected status in conflicting retries')
winners = {r['json']['text'] for r in results if r['status'] == 201}
check(len(winners) == 1, f'both bodies accepted for one key: {winners}')
loser_statuses = {r['status'] for r in results if r['status'] != 201}
check(loser_statuses <= {409}, 'different body must be 409')
check(sum(r['status'] == 409 for r in results) == 10, 'every other-body request must get 409')
check(count_messages(chat) == 1, 'conflicting retries stored more than one message')
def test_key_scope_and_format(c: Client):
alice, bob, _eve, chat = c.bootstrap()
other = c.call('POST', '/api/v1/chats', 201, actor=alice, body={'title': 'Другой', 'member_ids': [alice['id']]},
schema='Chat')['json']
path = f"/api/v1/chats/{chat['id']}/messages"
key = 'scope.' + uuid.uuid4().hex + ':1-x_y' # все допустимые символы
first = c.message(alice, chat, 'область', key=key)['json']
check(c.message(bob, chat, 'область', key=key)['json']['id'] != first['id'], 'key shared between users')
check(c.message(alice, other, 'область', key=key)['json']['id'] != first['id'], 'key shared between chats')
# Семантически тот же JSON другими байтами (пробелы, \u-экранирование) — тот же ответ.
same = raw_post(BASE_URL, path, alice, b'{ "text" : "\\u043e\\u0431\\u043b\\u0430\\u0441\\u0442\\u044c" }', key)
check(same['status'] == 201 and same['json'] == first, 'semantically equal JSON was not a replay')
conflict = raw_post(BASE_URL, path, alice, json.dumps({'text': 'иначе'}).encode(), key)
check(conflict['status'] == 409 and conflict['json']['error']['code'] == 'conflict', 'expected 409 conflict')
check(c.message(alice, chat, 'область', key=key)['json'] == first, '409 must not replace stored result')
for bad in (None, '', 'has space', 'café', 'x' * 129, 'a/b'):
r = raw_post(BASE_URL, path, alice, b'{"text":"bad key"}', bad)
check(r['status'] == 400, f'invalid key {bad!r} accepted')
check(len(c.message(alice, chat, 'max', key='k' * 128)['json']['id']) == 36, '128-char key rejected')
check(count_messages(chat) == 3, 'unexpected number of messages in scope test') # alice x2, bob x1
def test_replay_rechecks_session(c: Client):
alice, _bob, eve, chat = c.bootstrap()
key = uuid.uuid4().hex
c.message(alice, chat, 'до выхода', key=key)
path = f"/api/v1/chats/{chat['id']}/messages"
# Посторонний с тем же ключом не получает чужой результат.
c.call('POST', path, 404, actor=eve, body={'text': 'до выхода'}, headers={'Idempotency-Key': key})
c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=alice)
c.call('POST', path, 401, actor=alice, body={'text': 'до выхода'}, headers={'Idempotency-Key': key})
def test_transient_failure_not_recorded(c: Client):
alice, _bob, _eve, chat = c.bootstrap()
key = uuid.uuid4().hex
try:
compose('stop', 'postgres')
r = c.call('POST', f"/api/v1/chats/{chat['id']}/messages", 503, actor=alice,
body={'text': 'после сбоя'}, headers={'Idempotency-Key': key})
check(r['json']['error']['code'] == 'unavailable', 'expected unavailable')
check(bool(r['headers'].get('X-Instance-Id')), '503 must come from API (fallback backend), not LB')
c.call('GET', '/health/live', schema='Health')
finally:
compose('start', 'postgres')
wait_ready(c)
first = c.message(alice, chat, 'после сбоя', key=key)['json'] # повтор с тем же ключом создаёт запись
check(c.message(alice, chat, 'после сбоя', key=key)['json'] == first, 'replay after recovery differs')
check(count_messages(chat) == 1, 'transient failure produced extra message')
def test_sigterm_drain(c: Client):
"""SIGTERM: реплика сначала отвечает ready=503, но ещё обслуживает запросы, затем завершается с кодом 0."""
alice = c.user('drain')
names = docker('ps', *API_FILTER, '--format', '{{.Names}}').split()
name = sorted(names)[0]
ip = docker('inspect', '-f', '{{(index .NetworkSettings.Networks "%s_edge").IPAddress}}' % PROJECT, name)
direct = Client(f'http://{ip}:8080', timeout=2)
docker('kill', '-s', 'TERM', name)
signalled = time.monotonic()
try:
time.sleep(0.3)
direct.call('GET', '/health/ready', 503)
direct.call('GET', '/health/live', schema='Health')
r = direct.call('GET', '/api/v1/users/me', actor=alice, schema='User')
check(r['headers'].get('Connection', '').lower() == 'close', 'draining replica must close keep-alive')
time.sleep(max(0.0, signalled + 2.0 - time.monotonic())) # окно обнаружения LB: fall 2 x 0.5-1 с
served = {c.call('GET', '/api/v1/users/me', actor=alice, schema='User')['headers']['X-Instance-Id']
for _ in range(10)} # LB уже не отправляет на неё запросы
deadline = time.monotonic() + 20
while docker('inspect', '-f', '{{.State.Status}}', name) != 'exited':
check(time.monotonic() < deadline, 'replica did not exit after drain')
time.sleep(0.2)
code = docker('inspect', '-f', '{{.State.ExitCode}}', name)
check(code in ('0', '143'), f'unclean exit code {code}')
hostname = docker('inspect', '-f', '{{.Config.Hostname}}', name)
check(not any(i.startswith(hostname) for i in served), 'LB still routes to the draining replica')
finally:
subprocess.run(['sh', str(ROOT / 'scripts/restore.sh')], check=True, capture_output=True)
deadline = time.monotonic() + 30
while len({c.call('GET', '/health/live', schema='Health')['headers']['X-Instance-Id'] for _ in range(10)}) < 2:
check(time.monotonic() < deadline, 'restored replica did not return to LB')
time.sleep(0.5)
def test_infrastructure_rules(_c: Client):
containers = docker('ps', '--filter', f'label=com.docker.compose.project={PROJECT}', '--format', '{{.Names}}').split()
for name in containers:
cfg = json.loads(docker('inspect', name))[0]
service = cfg['Config']['Labels']['com.docker.compose.service']
if service == 'tester':
continue
host = cfg['HostConfig']
check(host['NanoCpus'] > 0 and host['Memory'] > 0, f'{name}: no CPU/RAM limit')
check(name.startswith(f'{PROJECT}-{service}-'), f'{name}: fixed container_name prevents scaling')
bindings = host.get('PortBindings') or {}
if service == 'lb':
check(all(b['HostIp'] == '127.0.0.1' for v in bindings.values() for b in v), 'LB published beyond loopback')
else:
check(not bindings, f'{name} publishes ports in bypass of LB')
if service == 'api':
check(cfg['HostConfig']['ReadonlyRootfs'], 'api root fs must be read-only (no local state)')
mounts = {m['Destination'] for m in cfg['Mounts']}
check(mounts <= {'/run/secrets/database_url', '/run/secrets/cache_url', '/run/secrets/s3_access_key_id',
'/run/secrets/s3_secret_access_key'}, f'api has unexpected mounts {mounts}') # lab4: + S3
check(sql('SELECT count(*) FROM schema_migrations') == '5', 'unexpected migration count') # lab4: + 0004_attachments, 0005_nul_safe_text
with urllib.request.urlopen(os.environ.get('LB_STATS_URL', 'http://lb:8404/stats') + ';csv', timeout=2) as r:
text = r.read().decode()
check(',UP,' in text or ',UP ' in text, 'LB stats show no UP backend')
def test_nul_in_text_roundtrip(c: Client):
"""Замечание к PR #99: {"text":"abc\\u0000def"} давал 500. Строка с U+0000 сохраняется точно."""
alice, bob, _eve, _chat = c.bootstrap()
text = 'abc\u0000def'
chat = c.call('POST', '/api/v1/chats', 201, actor=alice,
body={'title': 'чат\u0000NUL', 'member_ids': [alice['id'], bob['id']]}, schema='Chat')['json']
check(chat['title'] == 'чат\u0000NUL', 'title with NUL changed in response')
got = c.call('GET', '/api/v1/chats/' + chat['id'], actor=bob, schema='Chat')['json']
check(got['title'] == 'чат\u0000NUL', 'title with NUL changed on read')
key = uuid.uuid4().hex
first = c.message(alice, chat, text, key=key)['json']
check(first['text'] == text, 'response text differs')
replay = c.message(alice, chat, text, key=key)['json']
check(replay == first, 'idempotent replay differs')
c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 409, actor=alice,
body={'text': 'abc\ufffddef'}, headers={'Idempotency-Key': key}) # U+FFFD — другой текст
c.message(alice, chat, '\u0000') # только NUL — не пробел, допустим
history = c.call('GET', '/api/v1/chats/' + chat['id'] + '/messages', actor=bob,
schema='MessagePage')['json']['items']
check([m['text'] for m in history] == [text, '\u0000'], 'history lost NUL')
name = 'Имя\u0000Фамилия'
user = c.call('POST', '/api/v1/users', 201, body={'username': 'nul_' + uuid.uuid4().hex[:12],
'display_name': name, 'password': 'T3st-' + uuid.uuid4().hex}, schema='User')['json']
check(user['display_name'] == name, 'display_name with NUL changed')
TESTS = [test_session_across_replicas, test_same_key_concurrent_across_replicas,
test_same_key_concurrent_different_bodies, test_key_scope_and_format, test_replay_rechecks_session,
test_transient_failure_not_recorded, test_sigterm_drain, test_infrastructure_rules,
test_nul_in_text_roundtrip]
def main() -> int:
c = Client(BASE_URL)
wait_ready(c)
failed = 0
for test in TESTS:
started = time.monotonic()
try:
test(c)
print(f'PASS {test.__name__} ({time.monotonic() - started:.1f}s)', flush=True)
except (Failure, subprocess.CalledProcessError, OSError) as exc:
failed += 1
print(f'FAIL {test.__name__}: {exc}', flush=True)
print(f'{len(TESTS) - failed}/{len(TESTS)} passed')
return 1 if failed else 0
if __name__ == '__main__':
sys.exit(main())
+278
View File
@@ -0,0 +1,278 @@
#!/usr/bin/env python3
"""Собственные проверки lab4 (уровень 3). Запуск: sh scripts/test-lab4.sh (внутри сервиса tester).
Покрывают критерии README «3»: PNG/JPEG upload -> 201 ready, побайтный download с SHA-256, доступ только
участникам, сообщение с attachment_ids, лимиты (10 MiB, 40 Мпикс до декодирования), MIME по содержимому,
опасные filename, failover загрузившей реплики, недоступность S3, приватность bucket вне API и отсутствие
локальной копии файла на API. Требуют доступ к docker: останавливают реплику и S3, затем возвращают.
"""
import hashlib
import os
import struct
import subprocess
import sys
import time
import uuid
import zlib
from pathlib import Path
from urllib.parse import quote
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, Failure, check # noqa: E402
BASE_URL = os.environ.get('BASE_URL', 'http://lb:8080')
PROJECT = 'mtusi-lab4'
PNG = (ROOT / 'tests/fixtures/sample.png').read_bytes()
JPEG = (ROOT / 'student-tests/fixtures/sample.jpg').read_bytes()
def docker(*args: str) -> str:
return subprocess.run(['docker', *args], check=True, text=True, capture_output=True).stdout.strip()
def service_containers(service: str, running_only: bool = True) -> list[str]:
args = ['ps', '-q', '--filter', f'label=com.docker.compose.project={PROJECT}',
'--filter', f'label=com.docker.compose.service={service}']
if not running_only:
args.insert(1, '-a')
return docker(*args).split()
def wait_ready(c: Client, seconds: float = 60) -> None:
deadline = time.monotonic() + seconds
while True:
try:
c.call('GET', '/health/ready', schema='Health')
return
except Failure:
check(time.monotonic() < deadline, 'API did not become ready')
time.sleep(0.5)
def upload(c: Client, actor: dict, chat: dict, data: bytes, ctype: str, filename: str = 'photo.png',
expected=201) -> dict:
path = f"/api/v1/chats/{chat['id']}/attachments?filename={quote(filename, safe='')}"
return c.call('POST', path, expected, actor=actor, raw=data, headers={'Content-Type': ctype},
schema='Attachment' if expected == 201 else None)
def download(c: Client, actor: dict, att_id: str, expected=200) -> dict:
return c.call('GET', f'/api/v1/attachments/{att_id}/content', expected, actor=actor)
def png_chunk(kind: bytes, data: bytes) -> bytes:
return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data) & 0xffffffff)
def png_header_only(width: int, height: int) -> bytes:
"""Валидная сигнатура и IHDR (с верным CRC) огромного изображения, без пиксельных данных."""
ihdr = struct.pack('>IIBBBBB', width, height, 8, 2, 0, 0, 0)
idat = zlib.compress(b'\x00' * 64) # заведомо меньше, чем нужно: декодировать сервер не должен
return b'\x89PNG\r\n\x1a\n' + png_chunk(b'IHDR', ihdr) + png_chunk(b'IDAT', idat) + png_chunk(b'IEND', b'')
# ---------- тесты ----------
def test_png_and_jpeg_roundtrip(c: Client):
alice, bob, eve, chat = c.bootstrap()
for data, ctype, name in ((PNG, 'image/png', 'Фото 1.png'), (JPEG, 'image/jpeg', 'кадр.jpg')):
att = upload(c, alice, chat, data, ctype, name)['json']
check(att['status'] == 'ready' and att['variants'] == [] and att['error_code'] is None, 'not ready')
check(att['filename'] == name and att['content_type'] == ctype, 'metadata mismatch')
check(att['sha256'] == hashlib.sha256(data).hexdigest() and att['size_bytes'] == len(data), 'checksum')
meta = c.call('GET', f"/api/v1/attachments/{att['id']}", actor=bob, schema='Attachment')['json']
check(meta == att, 'metadata via GET differs from upload response')
got = download(c, bob, att['id'])
check(got['bytes'] == data, 'downloaded bytes differ')
check(got['headers'].get_content_type() == ctype, 'wrong Content-Type on download')
check(hashlib.sha256(got['bytes']).hexdigest() == att['sha256'], 'sha256 mismatch')
for suffix in ('', '/content'):
c.call('GET', f"/api/v1/attachments/{att['id']}{suffix}", 404, actor=eve)
c.call('GET', f"/api/v1/attachments/{att['id']}/content", 401)
def test_message_with_attachments(c: Client):
alice, bob, _eve, chat = c.bootstrap()
a1 = upload(c, alice, chat, PNG, 'image/png')['json']
a2 = upload(c, bob, chat, JPEG, 'image/jpeg', 'b.jpg')['json']
key = uuid.uuid4().hex
msg = c.message(bob, chat, '', key=key, attachments=[a2['id'], a1['id']])['json'] # любой участник
check(msg['attachment_ids'] == [a2['id'], a1['id']] and msg['text'] == '', 'attachment order lost')
replay = c.message(bob, chat, '', key=key, attachments=[a2['id'], a1['id']])['json']
check(replay == msg, 'idempotent replay with attachments differs')
plain = c.message(alice, chat, 'только текст')['json']
check(plain['attachment_ids'] == [], 'text message must have attachment_ids=[]')
history = c.call('GET', f"/api/v1/chats/{chat['id']}/messages?limit=100", actor=alice,
schema='MessagePage')['json']['items']
check([m['attachment_ids'] for m in history] == [[a2['id'], a1['id']], []], 'history lost attachments')
h = {'Idempotency-Key': uuid.uuid4().hex}
c.call('POST', f"/api/v1/chats/{chat['id']}/messages", 400, actor=alice, body={'text': ' '}, headers=h)
c.call('POST', f"/api/v1/chats/{chat['id']}/messages", 400, actor=alice,
body={'text': '', 'attachment_ids': [a1['id'], a1['id']]}, headers=h)
def test_foreign_attachment_rejected(c: Client):
alice, bob, eve, chat = c.bootstrap()
other = c.call('POST', '/api/v1/chats', 201, actor=eve, body={'title': 'чужой', 'member_ids': [eve['id']]},
schema='Chat')['json']
foreign = upload(c, eve, other, PNG, 'image/png')['json']
h = {'Idempotency-Key': uuid.uuid4().hex}
# Вложение другого чата и несуществующее — 404, сообщение не создаётся.
for ids in ([foreign['id']], [str(uuid.uuid4())]):
c.call('POST', f"/api/v1/chats/{chat['id']}/messages", 404, actor=alice,
body={'text': 'x', 'attachment_ids': ids}, headers={'Idempotency-Key': uuid.uuid4().hex})
items = c.call('GET', f"/api/v1/chats/{chat['id']}/messages", actor=alice, schema='MessagePage')['json']['items']
check(items == [], 'message with foreign attachment was created')
# Посторонний не может загрузить файл в чужой чат.
upload(c, eve, chat, PNG, 'image/png', expected=404)
c.call('POST', f"/api/v1/chats/{chat['id']}/messages", 404, actor=eve,
body={'text': 'x'}, headers=h)
def test_limits_and_mime(c: Client):
alice, _bob, _eve, chat = c.bootstrap()
# 10 MiB + 1 байт: 413 (тело дальше лимита сервер не читает).
upload(c, alice, chat, PNG[:8] + b'\0' * (10 * 1024 * 1024 - 7), 'image/png', expected=413)
# Ровно 10 MiB проходит проверку размера (а затем отклоняется как повреждённый PNG — 415, не 413).
upload(c, alice, chat, PNG[:8] + b'\0' * (10 * 1024 * 1024 - 8), 'image/png', expected=415)
# 10000 x 5000 = 50 Мпикс по заголовку -> 413 до декодирования (файл всего ~100 байт).
upload(c, alice, chat, png_header_only(10000, 5000), 'image/png', expected=413)
# 6000 x 6000 = 36 Мпикс укладывается в лимит, но пикселей нет -> повреждённый -> 415.
upload(c, alice, chat, png_header_only(6000, 6000), 'image/png', expected=415)
# MIME по содержимому: PNG с Content-Type image/jpeg и наоборот -> 415.
upload(c, alice, chat, PNG, 'image/jpeg', expected=415)
upload(c, alice, chat, JPEG, 'image/png', expected=415)
# Не изображение, обрезанные файлы, пустое тело, чужие Content-Type.
upload(c, alice, chat, b'GIF89a' + b'\0' * 100, 'image/png', expected=415)
upload(c, alice, chat, PNG[:len(PNG) // 2], 'image/png', expected=415)
upload(c, alice, chat, JPEG[:len(JPEG) // 2], 'image/jpeg', expected=415)
upload(c, alice, chat, b'', 'image/png', expected=415)
upload(c, alice, chat, PNG, 'text/plain', expected=415)
upload(c, alice, chat, PNG, 'multipart/form-data; boundary=x', expected=415)
def test_dangerous_filenames(c: Client):
alice, _bob, _eve, chat = c.bootstrap()
for name in ('../etc/passwd', 'a/b.png', 'a\\b.png', 'nul\x00.png', 'tab\t.png', 'new\nline.png',
'\x7f.png', '', ' ', '..', 'x' * 256):
upload(c, alice, chat, PNG, 'image/png', name, expected=400)
c.call('POST', f"/api/v1/chats/{chat['id']}/attachments", 400, actor=alice, raw=PNG,
headers={'Content-Type': 'image/png'}) # без filename
ok = upload(c, alice, chat, PNG, 'image/png', 'отчёт (финал) ✓.png')['json']
check(ok['filename'] == 'отчёт (финал) ✓.png', 'unicode filename changed')
upload(c, alice, chat, PNG, 'image/png', 'x' * 255)
def test_failover_of_uploading_replica(c: Client):
"""Upload -> остановить реплику, которая его обслужила -> download через другую = тот же файл."""
alice, bob, _eve, chat = c.bootstrap()
response = upload(c, alice, chat, PNG, 'image/png')
att = response['json']
served_by = response['headers']['X-Instance-Id']
cid = served_by.rsplit('-', 1)[0]
check(cid in [x[:12] for x in service_containers('api')], 'uploader replica not found among containers')
docker('stop', '-t', '20', cid)
try:
time.sleep(2)
got = download(c, bob, att['id'])
check(got['headers']['X-Instance-Id'] != served_by, 'download served by stopped replica')
check(got['bytes'] == PNG and hashlib.sha256(got['bytes']).hexdigest() == att['sha256'],
'file differs after uploader replica stopped')
print(f' uploaded via {served_by}, downloaded via {got["headers"]["X-Instance-Id"]}')
finally:
docker('start', cid)
wait_ready(c)
def test_s3_unavailable(c: Client):
"""S3 остановлен: upload/download -> 503 без 500, текстовые сообщения работают, после старта — всё снова."""
alice, bob, _eve, chat = c.bootstrap()
att = upload(c, alice, chat, PNG, 'image/png')['json']
s3 = service_containers('s3')
check(len(s3) == 1, 'expected one s3 container')
docker('stop', s3[0])
try:
started = time.monotonic()
upload(c, alice, chat, PNG, 'image/png', expected=503)
download(c, bob, att['id'], expected=503)
check(time.monotonic() - started < 15, 'S3 failure is not bounded by timeouts')
c.message(alice, chat, 'S3 недоступен, а текст отправляется')
c.call('GET', f"/api/v1/attachments/{att['id']}", actor=bob, schema='Attachment') # метаданные в БД
c.call('GET', '/health/ready', schema='Health')
finally:
docker('start', s3[0])
deadline = time.monotonic() + 60
while True:
try:
check(download(c, bob, att['id'])['bytes'] == PNG, 'file changed after S3 restart')
break
except Failure:
check(time.monotonic() < deadline, 'S3 did not come back')
time.sleep(1)
upload(c, alice, chat, JPEG, 'image/jpeg', 'after.jpg')
def test_bucket_private_outside_api(c: Client):
"""Прямой анонимный GET объекта в S3 (в обход API) отклоняется; ключ в API не раскрывается."""
alice, _bob, _eve, chat = c.bootstrap()
att = upload(c, alice, chat, PNG, 'image/png')['json']
check('object_key' not in att and 'attachments/' not in str(att), 'object key leaked to API')
api = service_containers('api')[0]
code = docker('exec', api, 'python', '-c',
'import urllib.request,urllib.error,sys\n'
'try:\n'
f' urllib.request.urlopen("http://s3:9000/messenger-attachments/attachments/{att["id"]}", timeout=5)\n'
' print(200)\n'
'except urllib.error.HTTPError as e:\n'
' print(e.code)\n')
check(code in ('401', '403'), f'anonymous S3 GET returned {code}')
# Листинг bucket анонимно тоже запрещён.
code = docker('exec', api, 'python', '-c',
'import urllib.request,urllib.error\n'
'try:\n'
' urllib.request.urlopen("http://s3:9000/messenger-attachments", timeout=5); print(200)\n'
'except urllib.error.HTTPError as e:\n'
' print(e.code)\n')
check(code in ('401', '403'), f'anonymous S3 list returned {code}')
print(f' anonymous GET object/list -> {code}')
def test_no_local_copy_on_api(c: Client):
"""У API read-only корневая ФС и пустой tmpfs: оригинал не хранится локально."""
alice, _bob, _eve, chat = c.bootstrap()
upload(c, alice, chat, PNG, 'image/png')
for cid in service_containers('api'):
check(docker('inspect', '-f', '{{.HostConfig.ReadonlyRootfs}}', cid) == 'true', 'api rootfs is writable')
# Допустимы только read-only секреты compose (/run/secrets/*); volume и записываемых bind нет.
mounts = docker('inspect', '-f', '{{range .Mounts}}{{.Type}}:{{.Destination}}:{{.RW}} {{end}}', cid).split()
writable = [m for m in mounts if m.startswith('volume:') or
(m.startswith('bind:') and not (m.startswith('bind:/run/secrets/') and m.endswith(':false')))]
check(not writable, f'api has persistent/writable mounts: {writable}')
files = docker('exec', cid, 'find', '/tmp', '-type', 'f')
check(files == '', f'unexpected files in api /tmp: {files}')
TESTS = [test_png_and_jpeg_roundtrip, test_message_with_attachments, test_foreign_attachment_rejected,
test_limits_and_mime, test_dangerous_filenames, test_bucket_private_outside_api,
test_no_local_copy_on_api, test_failover_of_uploading_replica, test_s3_unavailable]
def main() -> int:
c = Client(BASE_URL, timeout=30)
wait_ready(c)
failed = 0
for test in TESTS:
started = time.monotonic()
try:
test(c)
print(f'PASS {test.__name__} ({time.monotonic() - started:.1f}s)', flush=True)
except (Failure, subprocess.CalledProcessError, OSError) as exc:
failed += 1
print(f'FAIL {test.__name__}: {exc}', flush=True)
print(f'{len(TESTS) - failed}/{len(TESTS)} passed')
return 1 if failed else 0
if __name__ == '__main__':
sys.exit(main())
+4
View File
@@ -0,0 +1,4 @@
# Служебный образ для запуска make check / make test / hook-скриптов из Linux на любой ОС хоста.
FROM python:3.12.12-alpine3.22
RUN apk add --no-cache make curl docker-cli docker-cli-compose
WORKDIR /work