forked from mtusi2026/mtusi2026lab4
Compare commits
3
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7844e7d4b8 | ||
|
|
25d59bbcb2 | ||
|
|
2dca5c114b |
+27
-1
@@ -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
|
||||
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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 не заявлены.
|
||||
|
||||
@@ -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()
|
||||
@@ -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),
|
||||
)
|
||||
@@ -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
|
||||
@@ -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
@@ -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')
|
||||
@@ -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
@@ -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'] + '"',
|
||||
})
|
||||
@@ -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())
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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
@@ -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])
|
||||
|
||||
@@ -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)
|
||||
@@ -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
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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.
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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');
|
||||
@@ -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;
|
||||
@@ -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);
|
||||
@@ -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
|
||||
Executable
+48
@@ -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
|
||||
Executable
+42
@@ -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)'
|
||||
Executable
+14
@@ -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
|
||||
Executable
+13
@@ -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}}'
|
||||
Executable
+36
@@ -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"}}'
|
||||
Executable
+29
@@ -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"
|
||||
Executable
+12
@@ -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
|
||||
Executable
+312
@@ -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 |
Executable
+15
@@ -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)))
|
||||
Executable
+256
@@ -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())
|
||||
Executable
+307
@@ -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())
|
||||
Executable
+278
@@ -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())
|
||||
@@ -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
|
||||
Reference in New Issue
Block a user