Author SHA1 Message Date
vest1ter 44ae7b2472 ЛР4 на 5: вложения в MinIO, отказоустойчивость, трек 2 (сверка S3 и PostgreSQL)
Уровень 3:
- код lab3 перенесён; MinIO (сборка релиза 2025-10-15, по digest) в общем Compose,
  идемпотентный bootstrap: приватные bucket, отдельный пользователь API с ограниченной политикой
- метаданные вложений в PostgreSQL (миграции 0003, 0004), байты в S3; ключ назначает сервер
- upload PNG/JPEG: лимиты до чтения/декодирования, MIME по содержимому, проверка целостности,
  безопасный filename; 201 только после PUT и COMMIT; download потоком через API
- attachment_ids в сообщениях (только файлы своего чата, FK в БД)
- 503 API больше не повторяется в HAProxy (отказ общей зависимости), S3 не входит в readiness

Уровень 4:
- 45 тестов вложений: размер, повреждение, подмена MIME, чужой id, файл другого чата, отказы S3/БД
- компенсация при сбое COMMIT; слоты загрузки (8 на реплику) против неограниченной памяти
- эксперименты: пик RAM при 10-40 одновременных загрузках, оборванная загрузка и сироты;
  исправлены удержание соединения БД во время загрузки и таймаут отправки в S3

Уровень 5, трек 2:
- reconciler: слияние листинга S3 и курсора БД, 7 категорий расхождений, dry-run, grace period,
  перепроверка перед действием, тормоз --max-deletes, advisory lock; сервис reconciler в Compose
- 8 тестов сверки; эксперимент с 70 внедрёнными ошибками на 10 000 объектах (точное обнаружение,
  безопасное исправление, идемпотентность) и замер стоимости обхода на 1k/10k/50k
2026-11-12 17:38:00 +03:00
94 changed files with 7471 additions and 31 deletions
+48 -17
View File
@@ -1,20 +1,51 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
# Names follow pydantic-settings: prefix APP_CONFIG__, nesting via "__" (see app/core/config.py).
# Mapping to the skeleton's logical names: APP_HOST -> APP_CONFIG__RUN__HOST, APP_PORT -> APP_CONFIG__RUN__PORT,
# DATABASE_URL_FILE -> APP_CONFIG__DB__* (host/port/name/user + password file),
# SESSION_TTL_SECONDS -> APP_CONFIG__JWT__SESSION_TTL_SECONDS, SESSION_STORE=postgres (sessions table),
# IDEMPOTENCY_TTL_SECONDS -> APP_CONFIG__IDEMPOTENCY__TTL_SECONDS, API_REPLICAS -> API_REPLICAS (compose.yaml).
# S3_ENDPOINT/S3_REGION -> APP_CONFIG__S3__ENDPOINT/REGION, S3_BUCKET -> S3_BUCKET (compose.yaml),
# S3_ACCESS_KEY_ID_FILE/S3_SECRET_ACCESS_KEY_FILE -> APP_CONFIG__S3__ACCESS_KEY_FILE/SECRET_KEY_FILE,
# MAX_UPLOAD_BYTES/MAX_IMAGE_PIXELS -> APP_CONFIG__ATTACHMENTS__MAX_BYTES/MAX_PIXELS (defaults = contract limits).
APP_CONFIG__RUN__HOST=0.0.0.0
APP_CONFIG__RUN__PORT=8080
APP_CONFIG__LOGGING__LEVEL=INFO
# PostgreSQL. Values below are for running the API from the venv on the host;
# inside Compose the defaults (host=postgres, /run/secrets/postgres_password) are used.
APP_CONFIG__DB__HOST=127.0.0.1
APP_CONFIG__DB__PORT=5432
APP_CONFIG__DB__NAME=messenger
APP_CONFIG__DB__USER=messenger
# Path only, never the password itself. Relative paths are resolved from the project root.
APP_CONFIG__DB__PASSWORD_FILE=secrets/postgres_password
# Sessions: JWT signed with a key from a secret file + server-side session row in PostgreSQL
# (shared by all API replicas, so no sticky sessions are needed).
APP_CONFIG__JWT__SECRET_FILE=secrets/jwt_secret
APP_CONFIG__JWT__SESSION_TTL_SECONDS=3600
# Idempotency-Key: a repeat within this window returns the original message (contract: 24 h).
APP_CONFIG__IDEMPOTENCY__TTL_SECONDS=86400
# Graceful shutdown: after SIGTERM /health/ready answers 503 for DRAIN seconds, then the port closes
# and in-flight requests get GRACEFUL seconds. DRAIN must exceed the LB detection time (fall*inter + check timeout = 2.5 s).
APP_CONFIG__RUN__DRAIN_SECONDS=3
APP_CONFIG__RUN__GRACEFUL_TIMEOUT=5
# Used by compose.yaml.
# Host port for PostgreSQL (bound to 127.0.0.1 only); API replicas publish no ports at all.
POSTGRES_HOST_PORT=5432
# Number of API replicas behind the load balancer.
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
S3_ENDPOINT=http://s3:9000
S3_REGION=us-east-1
# S3 (MinIO). Values below are for running the API or scripts from the venv on the host;
# inside Compose the API uses http://minio:9000 and the s3_* Docker secrets.
APP_CONFIG__S3__ENDPOINT=http://127.0.0.1:9000
APP_CONFIG__S3__REGION=us-east-1
APP_CONFIG__S3__BUCKET=messenger-attachments
APP_CONFIG__S3__ACCESS_KEY_FILE=secrets/s3_access_key_id
APP_CONFIG__S3__SECRET_KEY_FILE=secrets/s3_secret_access_key
# Used by compose.yaml: bucket name and host port of MinIO (bound to 127.0.0.1 only).
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
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
MINIO_HOST_PORT=9000
+5
View File
@@ -0,0 +1,5 @@
*.sh text eol=lf
*.cmd text eol=crlf
# Читаются внутри Linux-контейнеров: всегда LF, даже при checkout на Windows.
*.cfg text eol=lf
Dockerfile text eol=lf
+3
View File
@@ -1,3 +1,5 @@
# Personal study notes, not part of the submission
report_help.md
# Local/private state
.env
.env.*
@@ -16,6 +18,7 @@ backups/
# Runtime/build artifacts
.venv/
__pycache__/
.pytest_cache/
*.py[cod]
node_modules/
dist/
+27
View File
@@ -0,0 +1,27 @@
FROM python:3.14.3-slim@sha256:5e59aae31ff0e87511226be8e2b94d78c58f05216efda3b07dbbed938ec8583b
ARG APP_VERSION=dev
ENV PYTHONUNBUFFERED=1 \
PYTHONDONTWRITEBYTECODE=1 \
APP_CONFIG__RUN__VERSION=${APP_VERSION}
LABEL app.version=${APP_VERSION}
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app/ .
RUN useradd --no-create-home --shell /usr/sbin/nologin appuser
USER appuser
EXPOSE 8080
# Liveness не зависит от БД; готовность (/health/ready) проверяют тесты и restart-скрипт.
HEALTHCHECK --interval=5s --timeout=3s --start-period=10s \
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/live')"
CMD ["python", "main.py"]
+298 -14
View File
@@ -1,37 +1,321 @@
# Отчёт — лабораторная 4
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Автор, группа: Мякишев Владислав, БПИ2302
- Целевая оценка; выбранный трек 5, если нужен: цель — 5, трек 2 «Согласованность двух хранилищ». выполнены уровни 3, 4 и трек 2.
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Использованные источники, библиотеки и помощь ИИ: документация FastAPI, SQLAlchemy, Alembic, MinIO (`mc`, политики IAM), Pillow, urllib3, AWS S3 (object keys, bucket policy, multipart upload); библиотеки `minio` 7.2.20, `pillow` 13.0.0. При разработке использовался ИИ-ассистент Claude; все запуски и измерения выполнены на стенде автора.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Prerequisites: Docker Engine 29.x + Compose v2, Python 3.9+ для публичных тестов (3.11+ для своих тестов и экспериментов — нужен venv), свободные `127.0.0.1:8080` (LB), `127.0.0.1:5432` (PostgreSQL, для своих pytest) и `127.0.0.1:9000` (MinIO, для проверок приватности и экспериментов). На Windows для Python-скриптов задайте `PYTHONUTF8=1`. Команды для Windows; на Linux вместо `.cmd`/`.ps1` — одноимённые `.sh`, вместо `.venv\Scripts\python.exe` — `.venv/bin/python`.
Образы закреплены по digest: `postgres:17.10-alpine`, `haproxy:3.0.29-alpine`, `python:3.14.3-slim` (сборка API), `coollabsio/minio:RELEASE.2025-10-15T17-29-55Z` (сервер и `mc` для bootstrap).
```sh
# 1. Локальные секреты (вне Git) и .env. Существующие файлы не перезаписываются.
# postgres_password, jwt_secret, minio_root_user/password (root MinIO), s3_access_key_id/s3_secret_access_key (пользователь API)
powershell -ExecutionPolicy Bypass -File scripts\init-secrets.ps1 # Linux: sh scripts/init-secrets.sh
# 2. Запуск: postgres, minio (healthy) -> migrate, minio-init (один раз, exit 0) -> api x2 (healthy) -> lb (healthy);
# reconciler — фоновая сверка S3 и PostgreSQL (трек 2)
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait
# 3. Проверки уровня 3
python scripts/check_contract.py # = make check
python tests/smoke.py --base-url http://localhost:8080 # = make test
python tests/resilience.py --mode persistence --action-script scripts/restart.cmd
python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd
scripts\restore-replicas.cmd # вернуть реплику, остановленную хуком
python scripts/attachment_checks.py --s3-url http://127.0.0.1:9000
python scripts/s3_outage_check.py
# 4. Свои тесты (база messenger_test и bucket messenger-attachments-test создаются автоматически)
python -m venv .venv
.venv\Scripts\python.exe -m pip install -r requirements-test.txt
.venv\Scripts\python.exe -m pytest -v
# 5. Эксперименты уровня 4 (пишут evidence/*.json без токенов)
.venv\Scripts\python.exe scripts/upload_memory_experiment.py --limits 8,64 --concurrency 1,10,20,40
.venv\Scripts\python.exe scripts/orphan_experiment.py
python scripts/compose_summary.py
# 6. Трек 2: сверка хранилищ (отдельные база messenger_bench и bucket messenger-attachments-bench)
docker compose run --rm reconciler python -m maintenance.reconcile # dry-run по рабочим данным
.venv\Scripts\python.exe scripts/reconcile_experiment.py faults --objects 10000 --grace 180 # ~20 мин
.venv\Scripts\python.exe scripts/reconcile_experiment.py cost --sizes 1000,10000,50000 --deep-repeats 1 # ~30 мин
```
- Порты на хосте меняются без правки файлов: `LB_HOST_PORT` (8080), `MINIO_HOST_PORT` (9000), `POSTGRES_HOST_PORT` (5432). При смене `MINIO_HOST_PORT` поменяйте и `APP_CONFIG__S3__ENDPOINT` в `.env` (им пользуются тесты и эксперименты с хоста). На стенде автора 9000 занят другой программой, evidence снят с `MINIO_HOST_PORT=19000`.
- Bootstrap MinIO — разовый сервис `minio-init` (`infra/minio/bootstrap.sh`), запускается при каждом `up` и идемпотентен: bucket создаются только если их нет, политика и пользователь перезаписываются теми же значениями, повторная привязка политики пропускается. Ручных действий не нужно.
- Миграции — разовый сервис `migrate` (`alembic upgrade head`), как в lab3.
- Остановка без потери данных: `docker compose down`. Намеренное удаление всех учебных данных (PostgreSQL и файлов MinIO): `docker compose down -v`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
Клиент -> lb (HAProxy, 127.0.0.1:8080) -> api x2 (без портов на хосте) -> PostgreSQL: пользователи, чаты, сообщения, сессии,
ключи идемпотентности, МЕТАДАННЫЕ вложений
-> MinIO, bucket messenger-attachments: БАЙТЫ вложений
reconciler (раз в 10 мин) -> сверяет листинг S3 и attachments, безопасно исправляет старше 1 ч
```
**Перенесено из lab3 без изменений:** 2 реплики API за HAProxy, сессии и Idempotency-Key в PostgreSQL, drain по SIGTERM, хуки `restart`/`stop-one`/`restore-replicas`. Изменено: имя Compose-проекта `mtusi-lab4`; HAProxy больше не повторяет запрос при ответе API 503 (см. «Отказы»); в `stop-one.cmd` убран кириллический комментарий — `cmd` неверно разбирал UTF-8-строку без CRLF; тест истечения сессии получил запас по времени (TTL 3 с вместо 1 с — изредка падал, если вход под нагрузкой занимал почти секунду).
**Хранилище файлов.** Официальные образы MinIO (`minio/minio` на Docker Hub, `quay.io/minio/minio`) больше не публикуются. Выбрана сборка последнего официального релиза `RELEASE.2025-10-15T17-29-55Z` из исходников без изменений (`coollabsio/minio`), закреплённая по digest; в ней же есть `mc` того же поколения. Ограничение: это сторонняя сборка и релиз больше не обновляется — для учебного локального стенда допустимо, для production нужен поддерживаемый S3-сервер.
**Bucket и права (уровень 4).**
- Bucket `messenger-attachments` (рабочий) и `messenger-attachments-test` (для своих pytest) приватные: анонимный доступ выключен явно (`mc anonymous set private`).
- API ходит в MinIO **не под root**, а под отдельным пользователем с политикой `messenger-api`: `GetObject/PutObject/DeleteObject` на объекты двух bucket и `ListBucket/GetBucketLocation` на сами bucket. Создавать bucket, менять политики, видеть чужие bucket он не может (тест `test_api_credentials_cannot_administer_storage`). Root-credentials есть только у `minio` и `minio-init`.
- Веб-консоль MinIO выключена (`MINIO_BROWSER=off`), порт консоли не публикуется. Порт S3 — только на loopback, для проверок вне API; клиенты получают файлы только через API.
**Модель данных (миграция `0003`).**
- `attachments`: `id`, `chat_id`, `owner_id`, `filename` (только для отображения), `content_type`, `size_bytes`, `sha256`, `object_key` (UNIQUE), `status`, `created_at`, `updated_at`. FK `(chat_id, owner_id) -> chat_members`: загрузить может только участник. CHECK на тип, размер ≤ 10 MiB, формат sha256, длину имени.
- `message_attachments(message_id, attachment_id, chat_id, position)`: порядок `attachment_ids` сохраняется. Составной FK `(attachment_id, chat_id) -> attachments(id, chat_id)` на уровне БД запрещает прикрепить файл другого чата (тест `test_database_rejects_link_to_attachment_of_other_chat`).
- `messages.text` теперь `0..4000` символов: пустой текст допустим только вместе с вложениями (проверяет API). Миграция expand-only: версия lab3 работает с новой схемой.
- Object key назначает сервер: `originals/<случайный UUID вложения>`. Имя файла в ключ и пути не попадает.
**Загрузка `POST /chats/{id}/attachments?filename=...` (синхронная, 201 ready).** Порядок:
1. Bearer-сессия (401) и членство в чате (404) — до чтения тела. После проверки соединение с БД сразу возвращается в пул.
2. Слот загрузки: не больше `max_concurrent_uploads` (8) одновременных загрузок на реплику; нет свободного слота за 3 с — **503 `Retry-After: 1`**, тело не читается.
3. `Content-Type` только `image/png`/`image/jpeg` (415). `Content-Length` > 10 MiB — сразу 413, тело не читается.
4. Тело читается потоком с подсчётом байт; на 10 MiB + 1 байте чтение прекращается (413). `Content-Length` может отсутствовать или врать — лимит всё равно соблюдается. Обрыв соединения клиентом — запись в лог, в S3 и БД ничего не попадает.
5. Тип определяется по сигнатуре содержимого; несовпадение с заявленным `Content-Type`, не PNG/JPEG — 415.
6. Размеры берутся из заголовка изображения (Pillow `open` не декодирует пиксели); больше 40 млн пикселей — 413 **до распаковки**.
7. Целостность: PNG — `verify()` (все чанки и CRC до IEND); JPEG — декодирование в масштабе 1/8 (`draft`), что ловит обрезанный поток при памяти в 64 раза меньше полного декодирования. Битый файл — 415.
8. `filename`: 1–255 символов, не пробельный, без `/`, `\`, управляющих символов (в т.ч. NUL), не `.`/`..` — иначе 400.
9. PUT в S3 **одним запросом** (`part_size` ≥ 10 MiB; по умолчанию minio-py резал бы файл >5 MiB на multipart, и обрыв посреди оставил бы незавершённую multipart-загрузку) → INSERT метаданных → COMMIT → **201**.
**Согласованность S3 и PostgreSQL (уровень 4): компенсация + очистка с grace period.**
| Где оборвалось | Что остаётся | Как убирается |
| --- | --- | --- |
| Клиент оборвал передачу тела | ничего: байты копятся в памяти до PUT | — |
| Ошибка проверки (413/415/400) | ничего | — |
| S3 недоступен на PUT | ничего (503) | — |
| PUT прошёл, COMMIT в PostgreSQL — нет | объект без строки | **компенсация**: API сразу удаляет объект |
| …и удаление тоже не удалось / процесс API упал между PUT и COMMIT | объект-сирота, невидимый через API | **сверка** `reconciler` удаляет после grace |
| Внешнее удаление объекта из bucket | строка без объекта; скачивание — 500 + ошибка в логе | `reconciler`: не прикреплена — строка удаляется после grace; прикреплена — только отчёт (восстановление из бэкапа) |
Очистка сирот — часть сверки хранилищ (`app/maintenance/reconcile.py`, сервис `reconciler` раз в 10 минут; вручную — `docker compose run --rm reconciler python -m maintenance.reconcile [--apply] [--grace-seconds N]`; полностью — в разделе «Трек 2»). Для объектов без строки:
- обходит объекты под `originals/` страницами по 1000 и одним запросом на страницу проверяет, есть ли их `object_key` в `attachments`;
- удаляет объект, только если строки нет **и** объект старше **grace period = 1 ч** (по `LastModified` в S3); перед удалением отсутствие строки проверяется ещё раз;
- по умолчанию dry-run (только отчёт), удаление — с `--apply`; строки БД не трогает никогда; при недоступности БД или S3 цикл пропускается.
Почему 1 ч безопасно: свежий объект без строки может принадлежать загрузке, которая сейчас между PUT и COMMIT. Это окно ограничено таймаутами БД (ожидание пула 5 с + соединение 3 с + `statement_timeout` 5 с) — порядка 15 с; час больше в сотни раз и покрывает расхождение часов MinIO и очистки. Цена — сирота занимает место до часа с небольшим (≤ 10 MiB каждая).
**Память и таймауты (уровень 4).**
- Одна загрузка держит в памяти тело (≤ 10 MiB) плюс временные копии: измерено ~20 MiB пика RSS на файл 9.9 MiB (буфер + `bytes` + буфер отправки в S3).
- Лимит слотов 8 на реплику ограничивает пик ~8 × 20 + ~110 (база процесса) ≈ 270 MiB при лимите контейнера 512 MiB. Значение задаётся `UPLOAD_CONCURRENCY`.
- Таймауты S3: соединение 5 с, чтение 8 с (меньше `timeout server` 10 с в HAProxy), без повторов в клиенте. В urllib3 таймаут соединения действует и на **отправку тела**: при 2 с занятый MinIO обрывал часть одновременных PUT (см. «Эксперименты»).
- `dns_opt timeout:1 attempts:1` у API и очистки: имя остановленного контейнера резолвится в ошибку за 1 с.
- Скачивание отдаёт файл кусками по 64 KiB из S3 (не загружая целиком), соединение с БД освобождается до начала передачи.
**Скачивание `GET /attachments/{id}/content`.** Проверка участника чата по метаданным (чужое и несуществующее неразличимы — 404), затем байты потоком из S3 через API, без redirect: `Content-Type` из метаданных, `Content-Length`, `X-Content-Type-Options: nosniff`, `Cache-Control: private, no-store`. `variant` по умолчанию `original`; производных вариантов в lab4 нет — 404. Приватный bucket и случайный ключ не заменяют эту проверку: ключ можно получить из лога, бэкапа или от бывшего участника, а права в чате меняются — решает только ACL приложения.
**Сообщения.** `attachment_ids`: 0–10 уникальных UUID; все должны принадлежать этому чату (иначе 404); неготовое вложение — 409. Отсутствующее поле и `[]` равны, в том числе для Idempotency-Key: пустой список не входит в хеш тела, поэтому ключи, выданные до lab4, остаются действительными. Отказ 404 не «занимает» ключ — исправленный запрос с тем же ключом проходит.
**Readiness.** `/health/ready` зависит от PostgreSQL и drain, **но не от S3**: при отказе S3 все реплики стали бы not ready и LB отключил бы весь API, хотя чаты и сообщения работают. Загрузка/скачивание в этом случае сами быстро отвечают 503.
**Соответствие `.env.example` skeleton → реальная конфигурация.** `S3_ENDPOINT/S3_REGION` → `APP_CONFIG__S3__ENDPOINT/REGION`; `S3_BUCKET` → `S3_BUCKET` (Compose, общий для API и bootstrap); `S3_ACCESS_KEY_ID_FILE/S3_SECRET_ACCESS_KEY_FILE` → `APP_CONFIG__S3__ACCESS_KEY_FILE/SECRET_KEY_FILE` (Docker secrets `s3_access_key_id`, `s3_secret_access_key`); `MAX_UPLOAD_BYTES/MAX_IMAGE_PIXELS` → `APP_CONFIG__ATTACHMENTS__MAX_BYTES/MAX_PIXELS` (по умолчанию значения контракта). Новые: `UPLOAD_CONCURRENCY` (слоты на реплику), `RECONCILE_GRACE_SECONDS`, `RECONCILE_INTERVAL_SECONDS`. Остальное — как в lab3.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke | `python scripts/check_contract.py`; `python tests/smoke.py` | оба `PASS`: upload 201 ready, message с `attachment_ids`, скачивание вторым участником побайтно (SHA-256), посторонний — 404 на метаданные и bytes | `evidence/smoke.txt` |
| 3: S3 в общем стенде; метаданные в PostgreSQL, байты в приватном bucket, не в БД и не на диске API | `docker compose up`; `attachment_checks.py`; `compose_summary.py` | `minio` + `minio-init` в `compose.yaml`, volume `minio_data`; у API-контейнеров нет volume — только `/run/secrets/*`; анонимный GET объекта и листинг bucket в MinIO — **403** | `evidence/attachment-checks.json`, `evidence/compose-config.txt` |
| 3: POST 201 ready после сохранения; оригинал побайтно; message с `attachment_ids` читается участниками | smoke; pytest | 201, `status=ready`, `variants=[]`, sha256 и размер совпадают; скачивание побайтно; порядок `attachment_ids` сохраняется в истории | `evidence/smoke.txt`, `evidence/pytest.txt` |
| 3: PNG/JPEG ≤10 MiB, ≤40 млн px; MIME по содержимому; опасные filename; лимиты до чтения/декодирования | pytest `test_attachments_api.py` | см. строки уровня 4 ниже; ровно 10 MiB — 201, PNG-заголовок 10000×5000 (~100 Б) — 413 без распаковки | `evidence/pytest.txt` |
| 3: upload → остановка обслужившей реплики → download через другую | `attachment_checks.py` | загрузка через `e4717834ab4f`, после её `docker stop` файл скачан через `aeca84df3cdc` (через 0.09 с), SHA-256 совпал | `evidence/attachment-checks.json` |
| 3: публичный failover (с lab4 проверяет оригинал) | `resilience.py --mode failover` + `stop-one.cmd`, затем `restore-replicas` и повтор | 2 прогона, остановлены **обе** реплики (`Exited (0)`): `failed_attempts` 0 и 0, `first_recovery_seconds` 4.72 и 5.74, `PASS` | `evidence/failover-hook.txt` |
| 3: restart с volumes сохраняет метаданные и оригинал | `resilience.py --mode persistence` + `restart.cmd` (stop lb, api, postgres, minio) | `PASS` с прежним токеном и тем же файлом; новые `StartedAt` у postgres и minio; volumes те же | `evidence/persistence.txt` |
| 3: недоступность S3 | `s3_outage_check.py` (`docker compose stop minio`) | ready 200, сообщения 201, метаданные 200; upload и download — 503 за 1.1 с; после `start minio` загрузка снова 201 через 1.2 с без рестарта API | `evidence/s3-outage.json` |
| 4: тесты — слишком большой файл | `test_too_large_file_is_rejected_before_reading`, `test_too_large_stream_without_content_length`, `test_exactly_max_bytes_is_accepted` | 413 и по `Content-Length`, и по фактическим байтам без него; граница 10 MiB включительно; ни объекта, ни строки | `evidence/pytest.txt` |
| 4: тесты — повреждённое изображение | `test_corrupted_image_is_415` ×5 | обрезанный PNG, PNG с испорченным байтом (CRC), обрезанный JPEG, только сигнатура, текст — 415, в S3 пусто | `evidence/pytest.txt` |
| 4: тесты — подмена MIME | `test_mime_spoofing_is_415` ×5 | PNG как jpeg/text/gif, JPEG как png, GIF как png — 415 | `evidence/pytest.txt` |
| 4: тесты — чужое `attachment_id` | `test_outsider_cannot_upload_or_read`, `test_unknown_and_unauthenticated` | посторонний: upload в чат, метаданные, bytes — 404; неизвестный id — 404; без токена — 401 | `evidence/pytest.txt` |
| 4: тесты — привязка файла другого чата | `test_foreign_attachment_id_in_message_is_404`, `test_database_rejects_link_to_attachment_of_other_chat` | 404, сообщение не создано, ключ идемпотентности не занят; прямой INSERT в обход API отклоняет FK БД | `evidence/pytest.txt` |
| 4: пользовательская ошибка не превращается в 500 | весь `test_attachments_api.py` (45 тестов), опасные filename ×8, неверные `attachment_ids` ×5 | все ответы — 400/401/404/409/413/415/503 в общем формате ошибки с `request_id`; **97 passed** всего (с 8 тестами сверки) | `evidence/pytest.txt` |
| 4: прерывание загрузки и отказ между S3/БД не оставляют вечных объектов; компенсация/очистка с grace period | pytest `test_commit_failure_after_put_deletes_object`, `test_orphan_left_by_failed_compensation_is_removed_only_after_grace`; `orphan_experiment.py` | обрыв посреди тела — ни объекта, ни строки; COMMIT не прошёл — объект удалён сразу; удаление тоже не удалось — сирота: свежая (grace 1 ч) **не тронута**, dry-run только показывает, apply удаляет, повтор находит 0; используемые файлы целы | `evidence/pytest.txt`, `evidence/orphan-cleanup.json` |
| 4: лимиты/таймауты/потоковая обработка; ≥10 одновременных загрузок с пиком памяти | `upload_memory_experiment.py` (2 прогона) | 10 одновременных по 9.9 MiB: все 201, пик RSS 188–202 MiB; с лимитом 8 слотов пик не выше 259 MiB при 20 и 40 загрузках (лишние — 503 `Retry-After`); без лимита 40 загрузок — **437 MiB** из 512 | `evidence/upload-memory.json`, `evidence/upload-memory-repeat.json` |
| 4: bootstrap идемпотентен | `docker compose run --rm minio-init` повторно; каждый `up` | `policy messenger-api already attached`, exit 0 | `infra/minio/bootstrap.sh` |
| 4: отдельные S3 credentials с ограниченными правами | `compose_summary.py`; `test_api_credentials_cannot_administer_storage` | у `api` только `s3_access_key_id/s3_secret_access_key`; root — только у `minio`, `minio-init`; API не может создать bucket, видит только свои | `evidence/compose-config.txt`, `evidence/pytest.txt` |
| 4: админ-консоль не открыта в общей сети | `compose_summary.py` | `MINIO_BROWSER=off`; опубликован только S3-порт и только на 127.0.0.1 | `evidence/compose-config.txt` |
| 4: проверка private bucket вне API | `test_bucket_is_private_outside_api`; `attachment_checks.py` | анонимный GET объекта и листинг bucket напрямую в MinIO — 403 | `evidence/pytest.txt`, `evidence/attachment-checks.json` |
| Модели совпадают с миграциями | `docker compose run --rm --no-deps migrate python -m alembic check` | `No new upgrade operations detected.` | — |
| 5, трек 2: повторяемый reconciler orphan/missing объектов и метаданных | `app/maintenance/reconcile.py`; сервис `reconciler`; `student-tests/test_reconcile.py` (8 тестов) | обход слиянием листинга S3 и курсора БД; 7 категорий; dry-run по умолчанию; перепроверка перед действием, `--max-deletes`, advisory lock; на рабочем стенде — 0 расхождений | `evidence/pytest.txt` |
| 5, трек 2: ошибки на обеих сторонах, обнаружение и безопасное исправление с dry-run/повтором | `reconcile_experiment.py faults --objects 10000 --grace 180` | 70 внедрённых расхождений найдены **точно** (множества id/ключей совпали во всех 7 категориях); dry-run и сработавший тормоз ничего не меняют; apply удалил ровно 20 сирот и 10 строк; повтор — 0 действий; `PASS` | `evidence/reconcile-faults.json` |
| 5, трек 2: свежие и используемые вложения не удаляются | тот же эксперимент; `test_detects_both_sides_and_fixes_only_safe_cases`, `test_recheck_*` | 5000 прикреплённых строк — все на месте; 10 свежих объектов и 10 свежих строк пережили apply и были исправлены только после истечения grace; перепроверка не дала удалить объект, у которого появилась строка, и строку, к которой прикрепили сообщение | `evidence/reconcile-faults.json`, `evidence/pytest.txt` |
| 5, трек 2: стоимость обхода | `reconcile_experiment.py cost --sizes 1000,10000,50000` | обычный проход линеен: 1.27 / 6.39 / 34.3 с на 1k / 10k / 50k (~1 500 объектов/с на 0.25 CPU), пик памяти 88–90 MiB при любом N; SHA-256 — ~100 объектов/с (в 14 раз дороже); с 10k — Index Only Scan по `object_key` | `evidence/reconcile-cost.json` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
### Пик памяти при одновременных загрузках (`upload_memory_experiment.py`)
**Гипотеза.** Без ограничения одновременных загрузок память реплики растёт линейно с их числом (~2 размера файла на загрузку) и при нескольких десятках подходит к лимиту контейнера; лимит слотов делает пик постоянным, а лишние запросы получают быстрый 503.
**Методика.** Файл — PNG из случайного шума 9.9 MiB (10 393 739 Б, почти не сжимается). 2 реплики API (1 CPU, 512 MiB каждая) за HAProxy, MinIO 2 CPU. Перед каждым сценарием — прогрев (маленькая загрузка на каждую реплику), затем сброс пика RSS процесса (`echo 5 > /proc/1/clear_refs`); после — `VmHWM` процесса API. N потоков стартуют одновременно (barrier), клиент на той же машине. Два значения лимита слотов (8 и 64 — фактически без лимита), N = 1, 10, 20, 40. Весь прогон повторён дважды.
**Результаты (прогон 1 / прогон 2), пик RSS самой загруженной реплики:**
| Слотов на реплику | Одновременно | Ответы | Пик RSS, MiB | Рост от базы, MiB | p50 / max, с |
| --- | --- | --- | --- | --- | --- |
| 8 | 1 | 1×201 / 1×201 | 128 / 127 | 21 / 20 | 0.50 / 0.49 |
| 8 | 10 | 10×201 / 10×201 | 188 / 202 | 80 / 95 | 2.7–2.8 |
| 8 | 20 | 16×201 + 4×503 / 19×201 + 1×503 | 241 / 227 | 133 / 113 | 4.1–4.5 |
| 8 | 40 | 16×201 + 24×503 / 16×201 + 24×503 | 242 / 259 | 130 / 145 | 6.6–7.0 |
| 64 | 10 | 10×201 / 10×201 | 186 / 188 | 79 / 79 | 2.7–3.0 |
| 64 | 20 | 20×201 / 20×201 | 250 / 275 | 141 / 167 | 4.7–4.9 |
| 64 | 40 | 40×201 / 40×201 | **437 / 422** | 297 / 308 | 9.6–10.5 |
**Выводы.** Гипотеза подтверждена. Одна загрузка 9.9 MiB добавляет ~20 MiB пика (≈ 2 размера файла). С лимитом 8 пик перестаёт расти после 16 одновременных загрузок (~240–260 MiB): при 40 запросах обработано 16 (по 8 на реплику), остальные 24 получили 503 с `Retry-After: 1` через ~3 с ожидания слота. Без лимита 40 загрузок довели реплику до 422–437 MiB из 512 — ещё немного, и контейнер убил бы OOM вместе со всеми запросами на нём, а latency подошла к `timeout server` HAProxy (10 с). Выбранный лимит 8 — компромисс: 10 одновременных загрузок (по 5 на реплику) проходят без отказов.
**Найдено и исправлено по ходу эксперимента:**
1. *Пул соединений БД.* Загрузка держала соединение из пула PostgreSQL всё время приёма тела и PUT в S3 (секунды). При 20 одновременных загрузках пул (10 на реплику) кончался, и часть запросов получала 503 по таймауту пула. Исправлено: соединение возвращается в пул сразу после проверки доступа (и при скачивании — до передачи файла).
2. *Таймаут отправки в S3.* При 20+ одновременных PUT часть падала с `ProtocolError/TimeoutError`: в urllib3 таймаут соединения (был 2 с) действует и на отправку тела, а MinIO на 1 CPU иногда не принимал данные дольше. Исправлено: таймаут соединения 5 с, MinIO 2 CPU; в логе теперь видна вложенная причина ошибки. После исправления: 20/20 и 40/40 без лимита — все 201.
**Ограничения.** Один хост, клиент на той же машине; пик RSS процесса не включает память MinIO и page cache. Абсолютные значения зависят от размера файла и версии Pillow/urllib3; линейный рост и «полка» при лимите повторились в обоих прогонах.
### Оборванная загрузка и сироты (`orphan_experiment.py`)
| Шаг | Объектов в bucket / строк `attachments` | Отчёт сверки (`reconciler`) |
| --- | --- | --- |
| начало | 545 / 545 | — |
| клиент заявил 9 MiB, отправил 2 MiB и закрыл соединение | 545 / 545 (в логе API «Загрузка прервана клиентом») | — |
| 3 объекта положены в bucket без строк (как «PUT прошёл, COMMIT и компенсация — нет») | 548 / 545 | — |
| dry-run, grace 1 ч | 548 / 545 | scanned 548, ok 545, **orphan_object_fresh 3**, deleted 0 |
| dry-run, grace 0 | 548 / 545 | orphan_object 3, deleted 0 |
| apply, grace 0 | 545 / 545 | objects_deleted 3 за 0.9 с |
| apply повторно | 545 / 545 | orphan_object 0 |
Используемое вложение, прикреплённое к сообщению, после очистки скачивается побайтно. Сам путь «откат COMMIT → попытка удаления → сирота» в работающем API воспроизводят pytest-тесты с подменой функций (`test_commit_failure_after_put_deletes_object`, `test_orphan_left_by_failed_compensation_is_removed_only_after_grace`); в эксперименте на стенде сироты созданы напрямую, потому что вызвать сбой ровно между PUT и COMMIT снаружи нельзя без отладочного кода в приложении.
### Отказы
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `docker stop` реплики, загрузившей файл | файл скачивается через другую | скачан через вторую реплику, SHA-256 совпал | сразу (0.09 с после остановки); потерь нет |
| `docker stop` каждой реплики (публичный тест) | запись продолжается ≤10 с | PASS ×2, `failed_attempts` 0 | хук 4.7–5.7 с; потерь нет |
| restart lb, api, postgres, minio | данные, сессия и файл на месте | PASS, файл совпал побайтно | потерь нет |
| `docker compose stop minio` | API жив, файлы — быстрый 503 | upload и download — 503 за 1.1 с; до исправления download шёл 9.1 с | 1.2 с после старта MinIO |
| обрыв клиента посреди тела | ничего не остаётся | 0 новых объектов и строк | — |
| COMMIT не прошёл после PUT (pytest) | объект удалён компенсацией | объект удалён | — |
| COMMIT и удаление не прошли (pytest, эксперимент) | сирота удаляется только после grace | свежая не тронута; после grace удалена, повтор — 0 | ≤ grace + интервал (1 ч 10 мин) |
| ошибки с обеих сторон хранилищ (трек 2, 10 000 объектов) | точное обнаружение, исправление только безопасного | 70/70 найдены по категориям, удалено 20 объектов и 10 строк, прикреплённые к сообщениям не тронуты | см. «Трек 2» |
| 40 одновременных загрузок по 10 MiB | память ограничена, лишние — 503 | пик ≤ 259 MiB, 24 × 503 `Retry-After` | клиент повторяет через 1 с |
**503 при отказе S3 шёл 9 с.** В lab3 HAProxy повторял запрос на другой реплике при ответе 503 (`retry-on ... 503`). При отказе общей зависимости (S3 или PostgreSQL) другая реплика отвечает тем же 503, так что 3 повтора только растягивали ответ до ~9 с. Исправлено: 503 исключён из `retry-on` (повтор остаётся для обрыва соединения, пустого ответа, таймаута, 502/504 — это и есть отказ реплики), повторы в S3-клиенте выключены. Failover после изменения: по-прежнему 0 ошибок.
## Трек 2 (оценка «5»): согласованность двух хранилищ
### Гипотезы
- **H1.** Расхождения S3 ↔ PostgreSQL на обеих сторонах можно найти за один проход без ложных срабатываний: если идти по двум одинаково отсортированным потокам (листинг S3 и `attachments` по `object_key`), каждое расхождение попадает ровно в одну категорию.
- **H2.** Безопасное исправление возможно, если действовать только на расхождения старше grace period и не трогать прикреплённые к сообщениям строки: свежие (загрузка между PUT и COMMIT) и используемые вложения не пострадают, а повторный запуск ничего не изменит.
- **H3.** Стоимость обычного обхода линейна по числу объектов и определяется листингом S3 (1000 ключей на запрос), память постоянна. Проверка SHA-256 (чтение каждого объекта) дороже на порядок и пропорциональна объёму данных.
### Как устроена сверка (`app/maintenance/reconcile.py`)
**Обход.** Листинг S3 под `originals/` (страницы по 1000, ключи в побайтовом порядке) и серверный курсор по `attachments ORDER BY object_key` (порции по 1000) идут слиянием, как два отсортированных списка. Чтобы порядок совпадал, `object_key` переведён на collation `"C"` (миграция `0004`, expand-only: ключи ASCII). Если в любом из потоков порядок нарушен, сверка останавливается: иначе слияние дало бы ложные расхождения. Память не зависит от числа объектов. Время отсечки — начало сверки минус grace.
**Категории и действия `--apply`:**
| Категория | Что это | Действие |
| --- | --- | --- |
| `orphan_object` | объект без строки, старше grace | объект удаляется |
| `orphan_object_fresh` | объект без строки, моложе grace | не трогаем: может быть загрузка между PUT и COMMIT |
| `missing_object` | строка без объекта, не прикреплена к сообщениям, старше grace | строка удаляется: файла нет и прикрепить его уже нельзя |
| `missing_object_referenced` | строка без объекта, прикреплена к сообщениям | только отчёт: нужен бэкап, удаление сломало бы сообщения |
| `missing_object_fresh` | строка без объекта, моложе grace | не трогаем: строка новее листинга |
| `size_mismatch` | размер объекта ≠ `size_bytes` | только отчёт |
| `checksum_mismatch` | SHA-256 объекта ≠ `sha256` (только `--verify-checksums`) | только отчёт |
**Защиты.**
1. По умолчанию dry-run: только отчёт с числом расхождений и их id/ключами.
2. Перед каждым удалением состояние перепроверяется. Для объекта: нет ли уже строки. Для строки: под `SELECT ... FOR UPDATE` проверяется, что к ней не прикреплено сообщение и объекта действительно нет (HEAD).
3. Гонка с отправкой сообщения закрыта блокировками. Сообщение читает вложения `FOR KEY SHARE`: если сверка удалила строку раньше, сообщение получает 404; если сообщение закоммитилось раньше, сверка видит ссылку и строку не трогает. Иначе удаление отклонил бы FK.
4. `--max-deletes` (по умолчанию 100) — тормоз: если удалить нужно больше, apply отменяется целиком. Защищает от массового удаления при ошибке конфигурации (например, перепутан bucket и все строки «без объектов»).
5. Advisory lock в PostgreSQL: два запуска одновременно не идут.
6. Повторный запуск после apply не находит, что исправлять (идемпотентность).
В работе сверку раз в 10 минут запускает сервис `reconciler` (`--apply`, grace 1 ч). Вручную: `docker compose run --rm reconciler python -m maintenance.reconcile [--apply] [--verify-checksums] [--grace-seconds N] [--max-deletes N]`.
### Методика
`scripts/reconcile_experiment.py` работает на отдельных базе `messenger_bench` и bucket `messenger-attachments-bench` (создаёт `minio-init`). Схема берётся миграциями. Сверка запускается как в работе: `docker compose run reconciler` (лимит 0.25 CPU / 128 MiB) с переопределёнными базой и bucket. Данные: N вложений по 1 KiB случайных байт, половина прикреплена к сообщениям (по 10 на сообщение). Внедрение ошибок фиксировано `random.seed(42)`.
**Эксперимент ошибок (`faults`, N = 10 000, grace 180 с).** Внедряется 70 расхождений:
- сироты: 10 объектов положены без строк + у 10 объектов удалены строки (сторона БД);
- 10 объектов удалены у свободных строк, 10 — у прикреплённых (сторона S3);
- у 10 строк изменён `size_bytes` (сторона БД), 10 объектов перезаписаны случайными байтами того же размера (сторона S3).
Затем ожидание дольше grace, после чего внедряются свежие расхождения: 10 объектов без строк и 10 строк без объектов. Шаги:
1. dry-run;
2. apply с `--max-deletes 10` (тормоз);
3. apply;
4. повторный apply;
5. dry-run с `--verify-checksums`;
6. ожидание grace, apply;
7. финальный dry-run с проверкой SHA-256.
Найденное сравнивается с внедрённым **поэлементно** (множества id/ключей), а не только по счётчикам.
**Эксперимент стоимости (`cost`).** N = 1 000, 10 000, 50 000 без расхождений. По 3 запуска обычной сверки (берётся медиана времени скана) и 1 запуск с проверкой SHA-256; пик RSS процесса сверки (`VmHWM`).
### Результаты: ошибки (`evidence/reconcile-faults.json`)
| Шаг | Расхождения (orphan / orphan_fresh / missing / missing_ref / missing_fresh / size / checksum) | Действия | Объектов / строк после |
| --- | --- | --- | --- |
| до внедрения | 0 / 0 / 0 / 0 / 0 / 0 / 0 | — | 10 000 / 10 000 |
| dry-run | **20 / 10 / 10 / 10 / 10 / 10** / — | нет | 10 000 / 10 000 (без изменений) |
| apply, `--max-deletes 10` | то же | **отменён**: к удалению 30 > 10 | 10 000 / 10 000 (без изменений) |
| apply | то же | удалено 20 объектов, 10 строк; перепроверка не отменила ни одного | 9 980 / 9 990 |
| apply повторно | 0 / 10 / 0 / 10 / 10 / 10 / — | 0 | 9 980 / 9 990 |
| dry-run + SHA-256 | 0 / 10 / 0 / 10 / 10 / 10 / **10** | нет | — |
| через grace, apply | 10 / 0 / 10 / 10 / 0 / 10 / — | удалено 10 объектов, 10 строк | 9 970 / 9 980 |
| финальный dry-run + SHA-256 | 0 / 0 / 0 / 10 / 0 / 10 / 10 | нет | 9 970 / 9 980 |
- Обнаружение: во всех 7 категориях множество найденного **совпало** с внедрённым (70/70, лишних 0). Подмену байтов того же размера находит только режим SHA-256: обычный проход видит такие объекты как исправные.
- Безопасность: из 5 000 прикреплённых к сообщениям строк не удалена ни одна. Удалены ровно 20 внедрённых сирот. Удалены ровно 10 свободных строк без объектов. Свежие объекты и строки пережили apply и были исправлены тем же путём только после истечения grace.
- В конце остаются только расхождения «нужен бэкап»: 10 прикреплённых строк без объектов, 10 с неверным размером, 10 с неверным содержимым.
- Пик RSS процесса сверки — 89 MiB во всех запусках (лимит контейнера 128 MiB).
### Результаты: стоимость обхода (`evidence/reconcile-cost.json`)
Сверка в контейнере с лимитом 0.25 CPU / 128 MiB; объекты по 1 KiB; расхождений нет (все запуски: `ok` = N, 0 расхождений).
| Объектов | Обычный проход: 3 запуска, с (медиана) | объектов/с | SHA-256: 1 запуск, с | объектов/с | Пик RSS, MiB | Запросов LIST к S3 | План запроса к БД |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 1 000 | 1.52 / 1.22 / 1.27 (**1.27**) | 787 | 10.1 | 99 | 87.7 | 1 | Seq Scan + Sort (таблица мала) |
| 10 000 | 6.32 / 6.39 / 7.30 (**6.39**) | 1 566 | 89.2 | 112 | 89.5 | 10 | Index Only Scan по `object_key` |
| 50 000 | 35.8 / 34.3 / 33.6 (**34.3**) | 1 457 | 487.6 | 103 | 89.3 | 50 | Index Only Scan по `object_key` |
- **H3 подтверждена.** Обычный проход линеен: 10k → 50k объектов дают ×5.4 времени при постоянной скорости ~1 500 объектов/с (на 1 000 заметна доля старта процесса и соединений). Пик памяти **не зависит от N** (88–90 MiB — это сам Python с SQLAlchemy, minio и Pillow): потоки читаются порциями по 1000.
- Режим SHA-256 в 14 раз дороже (~100 объектов/с). Он делает отдельный GET на каждый объект, и при объектах по 1 KiB время определяется числом запросов, а не байтами. Для реальных вложений до 10 MiB он будет ограничен ещё и объёмом чтения: весь bucket через сеть.
- Экстраполяция для рабочих лимитов: 1 млн объектов — ~11 мин обычным проходом и ~3 ч с SHA-256 на 0.25 CPU. Значит, обычная сверка каждые 10 минут подходит до сотен тысяч объектов, а проверку SHA-256 нужно делать редко, по частям (по префиксу) или с большим CPU.
- План запроса: на 1 000 строк планировщику дешевле прочитать таблицу и отсортировать; с 10 000 — Index Only Scan по уникальному индексу `object_key` в collation "C", без сортировки (ради этого миграция `0004`).
### Выводы
- **H1 подтверждена.** Один проход слиянием находит расхождения обеих сторон без ложных срабатываний. Для подмены содержимого того же размера нужен режим SHA-256: дешёвый проход сравнивает только наличие и размер.
- **H2 подтверждена.** Исправления делаются только для расхождений старше grace и только там, где удаление ничего не ломает. Используемые и свежие вложения не пострадали. Dry-run и тормоз ничего не меняют. Повторный запуск идемпотентен.
- **H3 подтверждена.** Обычный проход линеен (~1 500 объектов/с на 0.25 CPU) при постоянной памяти ~89 MiB; проверка SHA-256 в 14 раз дороже.
- Выбор частоты: обычная сверка дёшева и идёт каждые 10 минут. Проверку SHA-256 разумно запускать реже (например, раз в сутки ночью) или по частям, потому что она читает весь bucket.
### Ограничения трека
- Grace защищает свежие расхождения, только если часы MinIO и PostgreSQL близки (на одном хосте — одни часы). При разнесённых узлах grace должен быть заметно больше их расхождения.
- Сверка не восстанавливает байты: для `missing_object_referenced`, `size_mismatch`, `checksum_mismatch` нужен бэкап bucket, которого в стенде нет. Здесь сверка только отчитывается.
- Во время долгого прохода (SHA-256 на большом bucket) новые расхождения появляются уже после листинга. Их ловит следующий запуск, а grace не даёт принять «ещё не закоммиченную» загрузку за сироту.
- Синтетические объекты по 1 KiB: время обычного прохода от размера объектов почти не зависит, а режим SHA-256 на реальных файлах (до 10 MiB) будет пропорционально дольше.
- Один хост, по 1 эксперименту ошибок (детерминированное внедрение, `seed=42`) и по 3 запуска замера стоимости. Первые попытки эксперимента ошибок с grace 20 и 60 с показали, что каждый `docker compose run` занимает ~20 с, а проверка SHA-256 — ~95 с: «свежие» расхождения успевали устареть до apply. Поэтому grace эксперимента 180 с, а проверка SHA-256 идёт после apply.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Сделаны уровни 3, 4 и трек 2 (ограничения трека — в его разделе).
- Строку без объекта, прикреплённую к сообщению, и повреждённый объект сверка только находит: байты не восстановить без бэкапа bucket, а удаление строки сломало бы сообщения. Скачивание такого файла отвечает 500 до ручного восстановления.
- Загрузка держит тело в памяти (до 10 MiB, ~20 MiB пика с копиями) — ограничено слотами, но не потоковая запись в S3. Уменьшить можно, считая SHA-256 и отправляя в S3 по мере чтения, но тогда проверка изображения шла бы после PUT.
- Сирота живёт до grace + интервал очистки (~1 ч 10 мин) и занимает до 10 MiB.
- MinIO — один узел без репликации и erasure coding: потеря volume означает потерю файлов. Бэкап bucket не настроен.
- Сторонняя сборка MinIO, релиз больше не получает обновлений (см. «Хранилище файлов»).
+43
View File
@@ -0,0 +1,43 @@
# ASCII only: Alembic reads this file in the OS locale encoding.
# Database URL is built in env.py from app/core/config.py.
[alembic]
script_location = %(here)s/migrations
file_template = %%(rev)s_%%(slug)s
prepend_sys_path = .
path_separator = os
output_encoding = utf-8
[loggers]
keys = root,sqlalchemy,alembic
[handlers]
keys = console
[formatters]
keys = generic
[logger_root]
level = WARNING
handlers = console
qualname =
[logger_sqlalchemy]
level = WARNING
handlers =
qualname = sqlalchemy.engine
[logger_alembic]
level = INFO
handlers =
qualname = alembic
[handler_console]
class = StreamHandler
args = (sys.stderr,)
level = NOTSET
formatter = generic
[formatter_generic]
format = %(levelname)-5.5s [%(name)s] %(message)s
datefmt = %H:%M:%S
+57
View File
@@ -0,0 +1,57 @@
from fastapi import Depends, HTTPException, Request, Security
from fastapi.security import HTTPBasic, HTTPBearer
from sqlalchemy.orm import Session
from core.db import get_db
from database_functions.sessions_functions import get_active_session
from models import AuthSession, User
from utils.security import decode_access_token, token_hash
BEARER_CHALLENGE = {"WWW-Authenticate": 'Bearer realm="messenger"'}
# Security-схемы нужны, чтобы в Swagger появилась кнопка Authorize.
# Заголовок разбираем сами: стандартный HTTPBasic понимает пароль только в ASCII.
class RawBasicHeader(HTTPBasic):
async def __call__(self, request: Request) -> str | None:
return request.headers.get("Authorization")
class RawBearerHeader(HTTPBearer):
async def __call__(self, request: Request) -> str | None:
return request.headers.get("Authorization")
basic_scheme = RawBasicHeader(scheme_name="basicAuth", auto_error=False)
bearer_scheme = RawBearerHeader(scheme_name="bearerAuth", auto_error=False)
async def require_empty_body(request: Request) -> None:
# Контракт задаёт вход без тела: лишний JSON не игнорируем молча, а отклоняем.
if await request.body():
raise HTTPException(status_code=400, detail="Тело запроса не допускается")
def unauthorized() -> HTTPException:
return HTTPException(status_code=401, detail="Нужен действительный Bearer-токен", headers=BEARER_CHALLENGE)
def get_current_session(authorization: str | None = Security(bearer_scheme),
db: Session = Depends(get_db)) -> AuthSession:
scheme, _, token = (authorization or "").partition(" ")
if scheme.lower() != "bearer" or not token:
raise unauthorized()
# Подпись и exp проверяются без базы, отзыв (logout) — по таблице sessions.
payload = decode_access_token(token)
if payload is None:
raise unauthorized()
auth_session = get_active_session(db, token_hash(token))
if auth_session is None or str(auth_session.user_id) != payload["sub"]:
raise unauthorized()
return auth_session
def get_current_user(auth_session: AuthSession = Depends(get_current_session)) -> User:
return auth_session.user
+25
View File
@@ -0,0 +1,25 @@
from fastapi import APIRouter, HTTPException
from core.db import check_database
from schemas.health_schemas import HealthResponse
from utils.lifecycle import is_draining
router = APIRouter(prefix="/health", tags=["health"])
@router.get("/live", response_model=HealthResponse)
def live_api():
return HealthResponse(status="ok")
# В отличие от live, ready зависит от PostgreSQL и от того, не останавливается ли реплика:
# после SIGTERM ответ 503 выводит её из балансировки, пока она ещё дообслуживает запросы.
# S3 сюда намеренно не входит: при его отказе все реплики стали бы not ready и LB отключил бы весь API,
# хотя чаты и сообщения работают. Загрузка и скачивание файлов в этом случае отвечают 503 сами.
@router.get("/ready", response_model=HealthResponse)
def ready_api():
if is_draining():
raise HTTPException(status_code=503, detail="Реплика останавливается")
if not check_database():
raise HTTPException(status_code=503, detail="База данных недоступна")
return HealthResponse(status="ok")
+180
View File
@@ -0,0 +1,180 @@
import asyncio
import hashlib
import uuid
from collections.abc import AsyncIterator
from dataclasses import dataclass
from typing import Literal
from urllib.parse import quote
from fastapi import APIRouter, Depends, HTTPException, Query, Request
from fastapi.responses import StreamingResponse
from sqlalchemy.orm import Session
from starlette.requests import ClientDisconnect
from api.dependencies import get_current_user
from core import s3
from core.config import settings
from core.db import get_db
from core.logger import logger
from database_functions.attachments_functions import create_attachment, get_member_attachment, object_key_for
from database_functions.chats_functions import is_chat_member
from models import User
from schemas.attachments_schemas import AttachmentResponse
from utils.images import ImageRejected, inspect_image, validate_filename
upload_router = APIRouter(
prefix=settings.api.prefix + settings.api.v1.prefix + settings.api.v1.chats,
tags=["attachments"],
)
roter = APIRouter(
prefix=settings.api.prefix + settings.api.v1.prefix + settings.api.v1.attachments,
tags=["attachments"],
)
ALLOWED_TYPES = {"image/png", "image/jpeg"}
@dataclass
class UploadBody:
data: bytes
declared_type: str
def member_chat_id(chat_id: uuid.UUID, current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)) -> uuid.UUID:
# Сначала аутентификация и доступ к чату — и только потом чтение тела запроса.
if not is_chat_member(db, chat_id, current_user.id):
raise HTTPException(status_code=404, detail="Чат не найден")
# Вернуть соединение в пул до приёма тела и PUT в S3 (секунды): иначе одновременные загрузки
# выбирали весь пул (10 на реплику) и остальные запросы получали 503 по таймауту пула.
db.commit()
return chat_id
# Слоты загрузки на процесс: пик памяти реплики ~ max_concurrent_uploads * max_bytes, а не число соединений.
upload_slots = asyncio.Semaphore(settings.attachments.max_concurrent_uploads)
async def upload_slot() -> AsyncIterator[None]:
"""Занять слот до чтения тела и держать до конца обработки; нет слота за slot_wait_seconds — 503."""
try:
await asyncio.wait_for(upload_slots.acquire(), timeout=settings.attachments.slot_wait_seconds)
except TimeoutError:
raise HTTPException(status_code=503, detail="Слишком много одновременных загрузок, повторите позже",
headers={"Retry-After": "1"})
try:
yield
finally:
upload_slots.release()
async def read_upload(request: Request) -> UploadBody:
"""Прочитать сырые байты не больше лимита: лишнее не читается и в память не попадает."""
limit = settings.attachments.max_bytes
declared_type = request.headers.get("content-type", "").split(";")[0].strip().lower()
if declared_type not in ALLOWED_TYPES:
raise HTTPException(status_code=415, detail="Content-Type должен быть image/png или image/jpeg")
# Заявленная длина больше лимита — отказ сразу, без чтения тела.
content_length = request.headers.get("content-length")
if content_length is not None and content_length.isdigit() and int(content_length) > limit:
raise HTTPException(status_code=413, detail="Файл больше 10 MiB")
# Content-Length может отсутствовать или врать: считаем фактически полученные байты.
buffer = bytearray()
try:
async for chunk in request.stream():
buffer.extend(chunk)
if len(buffer) > limit:
raise HTTPException(status_code=413, detail="Файл больше 10 MiB")
except ClientDisconnect:
# Клиент оборвал передачу: в S3 и БД ещё ничего не записано, следов не остаётся.
logger.info(f"Загрузка прервана клиентом после {len(buffer)} байт")
raise HTTPException(status_code=400, detail="Загрузка прервана")
if not buffer:
raise HTTPException(status_code=400, detail="Пустой файл")
return UploadBody(data=bytes(buffer), declared_type=declared_type)
@upload_router.post("/{chat_id}/attachments", status_code=201, response_model=AttachmentResponse)
def upload_attachment_api(
filename: str = Query(min_length=1, max_length=255),
chat_id: uuid.UUID = Depends(member_chat_id),
_slot: None = Depends(upload_slot),
body: UploadBody = Depends(read_upload),
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
):
try:
validate_filename(filename)
image = inspect_image(body.data, body.declared_type, settings.attachments.max_pixels)
except ImageRejected as exc:
raise HTTPException(status_code=exc.status_code, detail=exc.message)
attachment_id = uuid.uuid4()
object_key = object_key_for(attachment_id)
sha256 = hashlib.sha256(body.data).hexdigest()
# 1) байты в S3; при ошибке в БД ничего не записано, клиент получает 503.
s3.put_object(object_key, body.data, image.content_type, sha256)
# 2) метаданные в PostgreSQL. 201 — только после COMMIT: тогда файл и скачивается, и прикрепляется.
try:
attachment = create_attachment(
db, attachment_id=attachment_id, chat_id=chat_id, owner_id=current_user.id, filename=filename,
content_type=image.content_type, size_bytes=len(body.data), sha256=sha256, object_key=object_key,
)
except Exception:
# COMMIT не прошёл: объект без метаданных никому не виден. Пытаемся удалить его сразу;
# если и это не вышло, его найдёт сверка хранилищ.
try:
s3.delete_object(object_key)
except s3.StorageUnavailable:
logger.warning(f"Не удалось удалить объект после отката БД: attachment_id={attachment_id}")
raise
return AttachmentResponse.model_validate(attachment)
def find_attachment(attachment_id: uuid.UUID, current_user: User, db: Session):
attachment = get_member_attachment(db, attachment_id, current_user.id)
if attachment is None:
raise HTTPException(status_code=404, detail="Вложение не найдено")
return attachment
@roter.get("/{attachment_id}", response_model=AttachmentResponse)
def get_attachment_api(attachment_id: uuid.UUID, current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)):
return AttachmentResponse.model_validate(find_attachment(attachment_id, current_user, db))
@roter.get("/{attachment_id}/content")
def download_attachment_api(
attachment_id: uuid.UUID,
variant: Literal["original", "thumbnail", "crop", "optimized"] = "original",
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
):
attachment = find_attachment(attachment_id, current_user, db)
# Соединение с БД больше не нужно: не держать его, пока файл идёт клиенту.
db.commit()
if variant != "original":
# Производных вариантов в lab4 нет.
raise HTTPException(status_code=404, detail="Вариант не найден")
try:
response = s3.open_object(attachment.object_key)
except s3.ObjectMissing:
logger.error(f"Объект вложения отсутствует в S3: attachment_id={attachment.id}")
raise HTTPException(status_code=500, detail="Содержимое вложения недоступно")
# Байты идут из S3 клиенту потоком через API, без redirect и без открытия bucket наружу.
return StreamingResponse(
s3.iter_object(response),
media_type=attachment.content_type,
headers={
"Content-Length": str(attachment.size_bytes),
"Content-Disposition": f"inline; filename*=UTF-8''{quote(attachment.filename)}",
"X-Content-Type-Options": "nosniff",
"Cache-Control": "private, no-store",
},
)
+66
View File
@@ -0,0 +1,66 @@
import base64
import binascii
from fastapi import APIRouter, Depends, HTTPException, Response, Security
from sqlalchemy.orm import Session
from api.dependencies import basic_scheme, get_current_session, require_empty_body
from core.config import settings
from core.db import get_db
from core.logger import logger
from database_functions.sessions_functions import create_session, delete_session
from database_functions.users_functions import get_user_by_username
from models import AuthSession
from schemas.auth_schemas import SessionResponse
from schemas.users_schemas import UserResponse
from utils.security import create_access_token, token_hash, verify_password
roter = APIRouter(
prefix=settings.api.prefix + settings.api.v1.prefix + settings.api.v1.auth,
tags=["auth"],
)
BASIC_CHALLENGE = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
def invalid_credentials() -> HTTPException:
# Один ответ и для неизвестного username, и для неверного пароля.
return HTTPException(status_code=401, detail="Неверное имя пользователя или пароль", headers=BASIC_CHALLENGE)
def parse_basic(authorization: str | None) -> tuple[str, str]:
scheme, _, encoded = (authorization or "").partition(" ")
if scheme.lower() != "basic" or not encoded:
raise invalid_credentials()
try:
decoded = base64.b64decode(encoded, validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError):
raise invalid_credentials()
# По первому двоеточию: в пароле двоеточие допустимо.
username, separator, password = decoded.partition(":")
if not separator:
raise invalid_credentials()
return username, password
# Тело проверяется до пароля: зависимости маршрута выполняются раньше параметров.
@roter.post("/sessions", status_code=201, response_model=SessionResponse, dependencies=[Depends(require_empty_body)])
def create_session_api(authorization: str | None = Security(basic_scheme), db: Session = Depends(get_db)):
username, password = parse_basic(authorization)
user = get_user_by_username(db, username)
if not verify_password(user.password_hash if user else None, password):
logger.info("Неудачная попытка входа")
raise invalid_credentials()
token, issued_at, expires_at = create_access_token(user.id)
create_session(db, token_hash(token), user.id, created_at=issued_at, expires_at=expires_at)
logger.info(f"Вход выполнен: user_id={user.id}")
return SessionResponse(token=token, expires_at=expires_at, user=UserResponse.model_validate(user))
@roter.delete("/sessions/current", status_code=204)
def delete_session_api(auth_session: AuthSession = Depends(get_current_session), db: Session = Depends(get_db)):
delete_session(db, auth_session.token_hash)
logger.info(f"Выход выполнен: user_id={auth_session.user_id}")
return Response(status_code=204)
+54
View File
@@ -0,0 +1,54 @@
import uuid
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session
from api.dependencies import get_current_user
from core.config import settings
from core.db import get_db
from core.logger import logger
from database_functions.chats_functions import create_chat, get_member_chat, list_user_chats
from models import User
from schemas.chats_schemas import ChatPageResponse, ChatResponse, CreateChatRequest
from utils.pagination import read_cursor, split_page
roter = APIRouter(
prefix=settings.api.prefix + settings.api.v1.prefix + settings.api.v1.chats,
tags=["chats"],
)
@roter.post("", status_code=201, response_model=ChatResponse)
def create_chat_api(request: CreateChatRequest, current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)):
if current_user.id not in request.member_ids:
raise HTTPException(status_code=400, detail="Создатель должен быть участником чата")
chat = create_chat(db, title=request.title, member_ids=request.member_ids)
if chat is None:
raise HTTPException(status_code=400, detail="Неизвестный участник")
logger.info(f"Чат создан: id={chat.id} участников={len(request.member_ids)}")
return ChatResponse.model_validate(chat)
@roter.get("", response_model=ChatPageResponse)
def list_chats_api(
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None, min_length=1),
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
):
scope = f"chats:{current_user.id}"
chats = list_user_chats(db, current_user.id, limit=limit, after=read_cursor(scope, cursor))
page, next_cursor = split_page(chats, limit, scope)
return ChatPageResponse(items=[ChatResponse.model_validate(chat) for chat in page], next_cursor=next_cursor)
@roter.get("/{chat_id}", response_model=ChatResponse)
def get_chat_api(chat_id: uuid.UUID, current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)):
chat = get_member_chat(db, chat_id, current_user.id)
if chat is None:
# Чужой чат неотличим от несуществующего.
raise HTTPException(status_code=404, detail="Чат не найден")
return ChatResponse.model_validate(chat)
+72
View File
@@ -0,0 +1,72 @@
import hashlib
import json
import uuid
from fastapi import APIRouter, Depends, Header, HTTPException, Query
from sqlalchemy.orm import Session
from api.dependencies import get_current_user
from core.config import settings
from core.db import get_db
from database_functions.chats_functions import is_chat_member
from database_functions.messages_functions import (AttachmentNotFound, AttachmentNotReady, IdempotencyKeyReused,
create_message_once, list_messages)
from models import User
from schemas.messages_schemas import CreateMessageRequest, MessagePageResponse, MessageResponse
from utils.pagination import read_cursor, split_page
roter = APIRouter(
prefix=settings.api.prefix + settings.api.v1.prefix + settings.api.v1.chats,
tags=["messages"],
)
def ensure_member(db: Session, chat_id: uuid.UUID, user: User):
if not is_chat_member(db, chat_id, user.id):
raise HTTPException(status_code=404, detail="Чат не найден")
def hash_request(request: CreateMessageRequest) -> bytes:
# Канонический вид: порядок ключей JSON и пробелы в запросе на хеш не влияют.
body = request.model_dump(mode="json")
# Пустой attachment_ids не входит в хеш: отсутствующее поле и [] равны, а ключи времён lab3 остаются валидными.
if not body["attachment_ids"]:
del body["attachment_ids"]
canonical = json.dumps(body, sort_keys=True, ensure_ascii=False, separators=(",", ":"))
return hashlib.sha256(canonical.encode("utf-8")).digest()
@roter.post("/{chat_id}/messages", status_code=201, response_model=MessageResponse)
def create_message_api(chat_id: uuid.UUID, request: CreateMessageRequest,
idempotency_key: str = Header(pattern=r"^[A-Za-z0-9._:-]{1,128}$"),
current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
# Повтор тоже проходит проверку сессии и членства: ключ не даёт доступа к чужому чату.
ensure_member(db, chat_id, current_user)
try:
message = create_message_once(
db, chat_id=chat_id, sender_id=current_user.id, text=request.text,
attachment_ids=request.attachment_ids, key=idempotency_key, request_hash=hash_request(request),
ttl_seconds=settings.idempotency.ttl_seconds,
)
except IdempotencyKeyReused:
raise HTTPException(status_code=409, detail="Idempotency-Key уже использован с другим телом запроса")
except AttachmentNotFound:
raise HTTPException(status_code=404, detail="Вложение не найдено")
except AttachmentNotReady:
raise HTTPException(status_code=409, detail="Вложение не готово")
return MessageResponse.model_validate(message)
@roter.get("/{chat_id}/messages", response_model=MessagePageResponse)
def list_messages_api(
chat_id: uuid.UUID,
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None, min_length=1),
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
):
ensure_member(db, chat_id, current_user)
scope = f"chat:{chat_id}"
messages = list_messages(db, chat_id, limit=limit, after=read_cursor(scope, cursor))
page, next_cursor = split_page(messages, limit, scope)
return MessagePageResponse(items=[MessageResponse.model_validate(m) for m in page], next_cursor=next_cursor)
+31
View File
@@ -0,0 +1,31 @@
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from api.dependencies import get_current_user
from core.config import settings
from core.db import get_db
from core.logger import logger
from database_functions.users_functions import create_user
from models import User
from schemas.users_schemas import CreateUserRequest, UserResponse
from utils.security import hash_password
roter = APIRouter(
prefix=settings.api.prefix + settings.api.v1.prefix + settings.api.v1.users,
tags=["users"],
)
@roter.post("", status_code=201, response_model=UserResponse)
def register_user_api(request: CreateUserRequest, db: Session = Depends(get_db)):
user = create_user(db, username=request.username, display_name=request.display_name,
password_hash=hash_password(request.password))
if user is None:
raise HTTPException(status_code=409, detail="Username уже занят")
logger.info(f"Пользователь создан: id={user.id}")
return UserResponse.model_validate(user)
@roter.get("/me", response_model=UserResponse)
def get_me_api(current_user: User = Depends(get_current_user)):
return UserResponse.model_validate(current_user)
+145
View File
@@ -0,0 +1,145 @@
import socket
from pathlib import Path
from typing import Literal
from pydantic import BaseModel
from pydantic_settings import BaseSettings, SettingsConfigDict
# Корень проекта (в контейнере код лежит в /app, и это будет "/").
BASE_DIR = Path(__file__).resolve().parents[2]
class RunConfig(BaseModel):
host: str = "0.0.0.0"
port: int = 8080
# Docker кладёт в hostname короткий ID контейнера: по X-Instance-Id его можно остановить через `docker stop`.
instance_id: str = socket.gethostname()
# SIGTERM -> сразу /health/ready=503, но порт закрывается только через drain_seconds:
# за это время балансировщик успевает вывести реплику из ротации
# (должно быть больше худшего времени обнаружения в haproxy.cfg: fall*inter + timeout check = 2.5 с).
drain_seconds: int = 3
# Версия сборки (build-arg APP_VERSION): видна в логе, различает старую и новую реплику при rolling update.
version: str = "dev"
# Время на завершение уже принятых запросов после закрытия порта.
graceful_timeout: int = 5
class LoggingConfig(BaseModel):
level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO"
format: str = "[%(asctime)s] [%(levelname)s] [%(name)s] %(message)s"
datefmt: str = "%Y-%m-%d %H:%M:%S"
class DatabaseConfig(BaseModel):
# Значения по умолчанию — для запуска внутри Compose.
host: str = "postgres"
port: int = 5432
name: str = "messenger"
user: str = "messenger"
password_file: Path = Path("/run/secrets/postgres_password")
pool_size: int = 5
max_overflow: int = 5
pool_timeout: int = 5
connect_timeout: int = 3
statement_timeout_ms: int = 5000
echo: bool = False
def read_password(self) -> str:
return read_secret(self.password_file)
class JWTConfig(BaseModel):
# Ключ должен сохраняться между перезапусками, иначе выданные токены станут недействительны.
secret_file: Path = Path("/run/secrets/jwt_secret")
algorithm: str = "HS256"
session_ttl_seconds: int = 3600
def read_secret_key(self) -> str:
return read_secret(self.secret_file)
class IdempotencyConfig(BaseModel):
# Контракт: повтор с тем же ключом в течение 24 часов возвращает исходный ответ.
ttl_seconds: int = 86400
class S3Config(BaseModel):
# Внутренний адрес MinIO в сети Compose; наружу API его не раскрывает.
endpoint: str = "http://minio:9000"
region: str = "us-east-1"
bucket: str = "messenger-attachments"
# Отдельный пользователь MinIO с правами только на этот bucket (не root).
access_key_file: Path = Path("/run/secrets/s3_access_key_id")
secret_key_file: Path = Path("/run/secrets/s3_secret_access_key")
# В urllib3 этот таймаут действует и на отправку тела запроса (read включается после неё):
# при 2 с занятый MinIO обрывал часть одновременных PUT по 10 MiB (эксперимент с памятью).
connect_timeout: float = 5
# Меньше timeout server в HAProxy (10 с): при зависшем S3 API успевает ответить 503 сам.
read_timeout: float = 8
def read_access_key(self) -> str:
return read_secret(self.access_key_file)
def read_secret_key(self) -> str:
return read_secret(self.secret_key_file)
class AttachmentsConfig(BaseModel):
# Контракт: не больше 10 MiB и 40 млн пикселей.
max_bytes: int = 10 * 1024 * 1024
max_pixels: int = 40_000_000
# Одновременных загрузок на реплику: каждая держит в памяти до max_bytes, поэтому без лимита
# 40 потоков uvicorn могли бы занять ~0.8 GiB при лимите контейнера 512 MiB.
max_concurrent_uploads: int = 8
# Сколько ждать свободного слота до ответа 503 (меньше timeout server в HAProxy).
slot_wait_seconds: float = 3
class ReconcileConfig(BaseModel):
# Сверка S3 и БД исправляет расхождение, только если объект/строка старше grace period. Окно между PUT в S3
# и COMMIT в PostgreSQL ограничено таймаутами БД (пул 5 с + соединение 3 с + запрос 5 с), час — запас в сотни раз.
grace_seconds: int = 3600
prefix: str = "originals/"
def read_secret(path: Path) -> str:
"""Прочитать файл-секрет. Относительный путь считается от корня проекта."""
full_path = path if path.is_absolute() else BASE_DIR / path
return full_path.read_text(encoding="utf-8").strip()
class ApiV1Prefix(BaseModel):
prefix: str = "/v1"
users: str = "/users"
chats: str = "/chats"
auth: str = "/auth"
attachments: str = "/attachments"
class ApiPrefix(BaseModel):
prefix: str = "/api"
v1: ApiV1Prefix = ApiV1Prefix()
class Settings(BaseSettings):
model_config = SettingsConfigDict(
env_file=BASE_DIR / ".env",
case_sensitive=False,
env_nested_delimiter="__",
env_prefix="APP_CONFIG__",
extra="ignore",
)
run: RunConfig = RunConfig()
api: ApiPrefix = ApiPrefix()
logging: LoggingConfig = LoggingConfig()
db: DatabaseConfig = DatabaseConfig()
jwt: JWTConfig = JWTConfig()
idempotency: IdempotencyConfig = IdempotencyConfig()
s3: S3Config = S3Config()
attachments: AttachmentsConfig = AttachmentsConfig()
reconcile: ReconcileConfig = ReconcileConfig()
settings = Settings()
+57
View File
@@ -0,0 +1,57 @@
from collections.abc import Iterator
from sqlalchemy import URL, create_engine, text
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.orm import Session, sessionmaker
from core.config import settings
from core.logger import logger
def build_url() -> URL:
return URL.create(
drivername="postgresql+psycopg",
username=settings.db.user,
password=settings.db.read_password(),
host=settings.db.host,
port=settings.db.port,
database=settings.db.name,
)
engine = create_engine(
build_url(),
pool_size=settings.db.pool_size,
max_overflow=settings.db.max_overflow,
pool_timeout=settings.db.pool_timeout,
# Проверять соединение перед выдачей из пула (нужно после рестарта PostgreSQL).
pool_pre_ping=True,
connect_args={
"connect_timeout": settings.db.connect_timeout,
"options": f"-c statement_timeout={settings.db.statement_timeout_ms}",
},
echo=settings.db.echo,
)
SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
def get_db() -> Iterator[Session]:
"""Одна ORM-сессия на HTTP-запрос."""
with SessionLocal() as session:
yield session
def check_database() -> bool:
try:
with engine.connect() as connection:
connection.execute(text("SELECT 1"))
return True
except SQLAlchemyError as exc:
# Только тип ошибки: в тексте может оказаться адрес БД.
logger.warning(f"PostgreSQL недоступен: {type(exc).__name__}")
return False
def log_database_target():
logger.info(f"База данных: {engine.url.render_as_string(hide_password=True)}")
+15
View File
@@ -0,0 +1,15 @@
import logging
from core.config import settings
def setup_logger():
logging.basicConfig(
level=settings.logging.level,
format=settings.logging.format,
datefmt=settings.logging.datefmt,
)
return logging.getLogger("messenger")
logger = setup_logger()
+127
View File
@@ -0,0 +1,127 @@
"""Клиент приватного S3-bucket (MinIO). Байты вложений живут только здесь, метаданные — в PostgreSQL."""
import io
from collections.abc import Iterator
from dataclasses import dataclass
from datetime import datetime
from functools import lru_cache
from urllib.parse import urlsplit
import urllib3
from minio import Minio
from minio.error import MinioException, S3Error
from core.config import settings
from core.logger import logger
CHUNK_SIZE = 64 * 1024
MIN_PART_SIZE = 5 * 1024 * 1024
class StorageUnavailable(Exception):
"""S3 недоступен или отказал: клиент получает 503."""
class ObjectMissing(Exception):
"""Метаданные есть, а объекта в bucket нет (рассинхронизация хранилищ)."""
@lru_cache(maxsize=1)
def get_client() -> Minio:
# Создаётся при первом обращении: health и текстовые запросы не зависят от S3 и его секретов.
url = urlsplit(settings.s3.endpoint)
http_client = urllib3.PoolManager(
timeout=urllib3.Timeout(connect=settings.s3.connect_timeout, read=settings.s3.read_timeout),
# Без повторов: при недоступном S3 клиент быстрее получает 503 и повторяет сам, если нужно.
retries=urllib3.Retry(total=0, redirect=0),
maxsize=10,
)
return Minio(
url.netloc,
access_key=settings.s3.read_access_key(),
secret_key=settings.s3.read_secret_key(),
secure=url.scheme == "https",
region=settings.s3.region,
http_client=http_client,
)
def _unavailable(action: str, exc: Exception) -> StorageUnavailable:
# В лог — только тип и код ошибки: в тексте исключения бывают адреса и подписи запросов.
code = exc.code if isinstance(exc, S3Error) else type(exc).__name__
if isinstance(exc, urllib3.exceptions.MaxRetryError) and exc.reason is not None:
code += f"/{type(exc.reason).__name__}"
# ProtocolError оборачивает исходную причину (обрыв, сброс соединения) — её тип тоже полезен.
inner = [arg for arg in getattr(exc.reason, "args", ()) if isinstance(arg, BaseException)]
if inner:
code += f"/{type(inner[0]).__name__}"
logger.warning(f"S3 {action} не удалось: {code}")
return StorageUnavailable()
def put_object(key: str, data: bytes, content_type: str, sha256_hex: str) -> None:
try:
get_client().put_object(
settings.s3.bucket, key, io.BytesIO(data), len(data),
content_type=content_type, metadata={"sha256": sha256_hex},
# Одна часть на весь файл = один атомарный PUT. С частями по 5 MiB (по умолчанию) обрыв посреди
# загрузки оставил бы в bucket незавершённый multipart upload.
part_size=max(settings.attachments.max_bytes, MIN_PART_SIZE),
)
except (MinioException, urllib3.exceptions.HTTPError, OSError) as exc:
raise _unavailable("PUT", exc) from exc
def delete_object(key: str) -> None:
try:
get_client().remove_object(settings.s3.bucket, key)
except (MinioException, urllib3.exceptions.HTTPError, OSError) as exc:
raise _unavailable("DELETE", exc) from exc
@dataclass
class StoredObject:
key: str
size: int
last_modified: datetime
def list_objects(prefix: str) -> Iterator[StoredObject]:
"""Все объекты под prefix; MinIO отдаёт их страницами по 1000, итератор подгружает следующие сам."""
try:
for item in get_client().list_objects(settings.s3.bucket, prefix=prefix, recursive=True):
yield StoredObject(key=item.object_name, size=item.size, last_modified=item.last_modified)
except (MinioException, urllib3.exceptions.HTTPError, OSError) as exc:
raise _unavailable("LIST", exc) from exc
def object_exists(key: str) -> bool:
try:
get_client().stat_object(settings.s3.bucket, key)
return True
except S3Error as exc:
if exc.code in ("NoSuchKey", "NoSuchObject"):
return False
raise _unavailable("HEAD", exc) from exc
except (MinioException, urllib3.exceptions.HTTPError, OSError) as exc:
raise _unavailable("HEAD", exc) from exc
def open_object(key: str) -> urllib3.BaseHTTPResponse:
"""Начать чтение объекта. Ошибки (нет S3, нет объекта) возникают здесь, до отправки статуса 200."""
try:
return get_client().get_object(settings.s3.bucket, key)
except S3Error as exc:
if exc.code == "NoSuchKey":
raise ObjectMissing() from exc
raise _unavailable("GET", exc) from exc
except (MinioException, urllib3.exceptions.HTTPError, OSError) as exc:
raise _unavailable("GET", exc) from exc
def iter_object(response: urllib3.BaseHTTPResponse) -> Iterator[bytes]:
"""Отдать объект кусками по 64 KiB: файл целиком в память API не загружается."""
try:
yield from response.stream(CHUNK_SIZE)
finally:
response.close()
response.release_conn()
@@ -0,0 +1,44 @@
import uuid
from sqlalchemy import select
from sqlalchemy.orm import Session
from models import Attachment, ChatMember
def object_key_for(attachment_id: uuid.UUID) -> str:
# Ключ назначает сервер: случайный UUID, без имени файла и без данных пользователя.
return f"originals/{attachment_id}"
def create_attachment(db: Session, attachment_id: uuid.UUID, chat_id: uuid.UUID, owner_id: uuid.UUID,
filename: str, content_type: str, size_bytes: int, sha256: str, object_key: str) -> Attachment:
attachment = Attachment(
id=attachment_id, chat_id=chat_id, owner_id=owner_id, filename=filename, content_type=content_type,
size_bytes=size_bytes, sha256=sha256, object_key=object_key,
)
db.add(attachment)
db.commit()
return attachment
def get_member_attachment(db: Session, attachment_id: uuid.UUID, user_id: uuid.UUID) -> Attachment | None:
"""Вложение, если пользователь — участник его чата. Чужое и несуществующее неразличимы (None -> 404)."""
query = (
select(Attachment)
.join(ChatMember, ChatMember.chat_id == Attachment.chat_id)
.where(Attachment.id == attachment_id, ChatMember.user_id == user_id)
)
return db.scalar(query)
def find_chat_attachments(db: Session, chat_id: uuid.UUID, attachment_ids: list[uuid.UUID]) -> list[Attachment]:
# Вложения других чатов сюда не попадают: для отправителя они «не найдены».
if not attachment_ids:
return []
# FOR KEY SHARE: пока сообщение со ссылкой не закоммичено, сверка хранилищ не может удалить эти строки
# (её DELETE ждёт, а потом откажет по FK); если сверка удалила раньше — вложение просто «не найдено».
query = (select(Attachment)
.where(Attachment.chat_id == chat_id, Attachment.id.in_(attachment_ids))
.with_for_update(key_share=True, read=True))
return list(db.scalars(query))
+50
View File
@@ -0,0 +1,50 @@
import uuid
from sqlalchemy import func, select, tuple_
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
from models import Chat, ChatMember, User
from utils.pagination import Position
def create_chat(db: Session, title: str, member_ids: list[uuid.UUID]) -> Chat | None:
"""Чат и участники — одна транзакция. None — есть несуществующий участник."""
found = db.scalar(select(func.count()).select_from(User).where(User.id.in_(member_ids)))
if found != len(member_ids):
return None
chat = Chat(title=title, members=[ChatMember(user_id=user_id) for user_id in sorted(member_ids)])
db.add(chat)
try:
db.commit()
except IntegrityError:
db.rollback()
return None
return chat
def is_chat_member(db: Session, chat_id: uuid.UUID, user_id: uuid.UUID) -> bool:
return db.get(ChatMember, (chat_id, user_id)) is not None
def get_member_chat(db: Session, chat_id: uuid.UUID, user_id: uuid.UUID) -> Chat | None:
query = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(Chat.id == chat_id, ChatMember.user_id == user_id)
)
return db.scalar(query)
def list_user_chats(db: Session, user_id: uuid.UUID, limit: int, after: Position | None) -> list[Chat]:
query = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(ChatMember.user_id == user_id)
.order_by(Chat.created_at, Chat.id)
.limit(limit + 1)
)
if after is not None:
query = query.where(tuple_(Chat.created_at, Chat.id) > tuple_(*after))
return list(db.scalars(query))
@@ -0,0 +1,87 @@
import uuid
from datetime import datetime, timedelta, timezone
from sqlalchemy import func, select, tuple_, update
from sqlalchemy.dialects.postgresql import insert
from sqlalchemy.orm import Session
from database_functions.attachments_functions import find_chat_attachments
from models import IdempotencyKey, Message, MessageAttachment
from utils.pagination import Position
class IdempotencyKeyReused(Exception):
"""Тот же Idempotency-Key уже использован с другим телом запроса."""
class AttachmentNotFound(Exception):
"""Вложения нет или оно из другого чата (для клиента это 404)."""
class AttachmentNotReady(Exception):
"""Вложение ещё не готово или с ошибкой обработки (409)."""
def create_message_once(db: Session, chat_id: uuid.UUID, sender_id: uuid.UUID, text: str,
attachment_ids: list[uuid.UUID],
key: str, request_hash: bytes, ttl_seconds: int) -> Message:
"""Создать сообщение ровно один раз для (пользователь, чат, ключ), в том числе при конкурентных повторах.
Всё в одной транзакции: «заявка» на ключ, сообщение и ссылка ключа на сообщение фиксируются вместе.
Если транзакция откатится (5xx, обрыв), ключ не сохранится и клиент безопасно повторит запрос.
Параллельный повтор через другую реплику блокируется на уникальном индексе до COMMIT первой
транзакции, затем видит её строку и возвращает то же сообщение.
"""
cutoff = datetime.now(timezone.utc) - timedelta(seconds=ttl_seconds)
claim = (
insert(IdempotencyKey)
.values(user_id=sender_id, chat_id=chat_id, key=key, request_hash=request_hash)
# Строка старше TTL считается свободной ключом: перехватываем её, остальные конфликты не меняем.
.on_conflict_do_update(
index_elements=[IdempotencyKey.user_id, IdempotencyKey.chat_id, IdempotencyKey.key],
set_={"request_hash": request_hash, "message_id": None, "created_at": func.clock_timestamp()},
where=IdempotencyKey.created_at < cutoff,
)
.returning(IdempotencyKey.key)
)
if db.execute(claim).first() is None:
existing = db.scalars(select(IdempotencyKey).where(
IdempotencyKey.user_id == sender_id, IdempotencyKey.chat_id == chat_id, IdempotencyKey.key == key,
)).one()
if existing.request_hash != request_hash:
raise IdempotencyKeyReused()
return db.get_one(Message, existing.message_id)
attachments = {a.id: a for a in find_chat_attachments(db, chat_id, attachment_ids)}
if len(attachments) != len(attachment_ids):
# Откат снимает и «заявку» на ключ: исправленный запрос с тем же ключом пройдёт.
db.rollback()
raise AttachmentNotFound()
if any(a.status != "ready" for a in attachments.values()):
db.rollback()
raise AttachmentNotReady()
message = Message(chat_id=chat_id, sender_id=sender_id, text=text, attachment_links=[
MessageAttachment(attachment_id=attachment_id, chat_id=chat_id, position=position)
for position, attachment_id in enumerate(attachment_ids)
])
db.add(message)
db.flush()
db.execute(update(IdempotencyKey).where(
IdempotencyKey.user_id == sender_id, IdempotencyKey.chat_id == chat_id, IdempotencyKey.key == key,
).values(message_id=message.id))
db.commit()
return message
def list_messages(db: Session, chat_id: uuid.UUID, limit: int, after: Position | None) -> list[Message]:
# Keyset-пагинация по индексу messages_chat_history_idx (chat_id, created_at, id).
query = (
select(Message)
.where(Message.chat_id == chat_id)
.order_by(Message.created_at, Message.id)
.limit(limit + 1)
)
if after is not None:
query = query.where(tuple_(Message.created_at, Message.id) > tuple_(*after))
return list(db.scalars(query))
@@ -0,0 +1,29 @@
import uuid
from datetime import datetime
from sqlalchemy import delete, func, select
from sqlalchemy.orm import Session
from models import AuthSession
def create_session(db: Session, token_hash: bytes, user_id: uuid.UUID,
created_at: datetime, expires_at: datetime) -> AuthSession:
auth_session = AuthSession(token_hash=token_hash, user_id=user_id, created_at=created_at, expires_at=expires_at)
db.add(auth_session)
db.commit()
return auth_session
def get_active_session(db: Session, token_hash: bytes) -> AuthSession | None:
query = select(AuthSession).where(
AuthSession.token_hash == token_hash,
AuthSession.expires_at > func.now(),
)
return db.scalar(query)
def delete_session(db: Session, token_hash: bytes) -> bool:
result = db.execute(delete(AuthSession).where(AuthSession.token_hash == token_hash))
db.commit()
return result.rowcount > 0
+30
View File
@@ -0,0 +1,30 @@
import uuid
from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
from models import User
def create_user(db: Session, username: str, display_name: str, password_hash: str) -> User | None:
"""None — username уже занят."""
user = User(username=username, display_name=display_name, password_hash=password_hash)
db.add(user)
try:
db.commit()
except IntegrityError as exc:
db.rollback()
# Уникальность проверяет сама БД, поэтому гонка регистрации невозможна.
if exc.orig.diag.constraint_name == "users_username_key":
return None
raise
return user
def get_user(db: Session, user_id: uuid.UUID) -> User | None:
return db.get(User, user_id)
def get_user_by_username(db: Session, username: str) -> User | None:
return db.scalar(select(User).where(User.username == username))
+76
View File
@@ -0,0 +1,76 @@
import signal
import threading
from contextlib import asynccontextmanager
import uvicorn
from fastapi import FastAPI
from starlette.middleware.base import BaseHTTPMiddleware
from api.health import router as health_router
from api.v1.attachments_rout import roter as attachments_router
from api.v1.attachments_rout import upload_router as attachments_upload_router
from api.v1.auth_rout import roter as auth_router
from api.v1.chats_rout import roter as chats_router
from api.v1.messages_rout import roter as messages_router
from api.v1.users_rout import roter as users_router
from core.config import settings
from core.db import engine, log_database_target
from core.logger import logger
from utils.errors import register_error_handlers
from utils.lifecycle import is_draining, start_draining
from utils.middleware import request_id_middleware
@asynccontextmanager
async def lifespan(app: FastAPI):
log_database_target()
logger.info(f"Экземпляр API: {settings.run.instance_id}, версия {settings.run.version}")
yield
# Остановка (в том числе по SIGTERM): закрываем соединения пула.
engine.dispose()
logger.info("Соединения с базой данных закрыты")
app = FastAPI(title="MTUSI Messenger lab4", lifespan=lifespan)
app.add_middleware(BaseHTTPMiddleware, dispatch=request_id_middleware)
register_error_handlers(app)
app.include_router(health_router)
app.include_router(auth_router)
app.include_router(users_router)
app.include_router(chats_router)
app.include_router(messages_router)
app.include_router(attachments_upload_router)
app.include_router(attachments_router)
class DrainingServer(uvicorn.Server):
"""Graceful shutdown в два этапа.
1. SIGTERM: /health/ready начинает отвечать 503, балансировщик выводит реплику из ротации,
а сервер продолжает принимать и обслуживать запросы.
2. Через drain_seconds uvicorn перестаёт принимать соединения и дообслуживает начатые запросы
(не дольше graceful_timeout).
Повторный сигнал (или Ctrl+C) останавливает сервер сразу.
"""
def handle_exit(self, sig, frame):
if sig == signal.SIGTERM and not is_draining() and settings.run.drain_seconds > 0:
start_draining()
logger.info(f"SIGTERM: реплика выводится из балансировки, остановка через {settings.run.drain_seconds} c")
threading.Timer(settings.run.drain_seconds, super().handle_exit, args=(sig, frame)).start()
return
super().handle_exit(sig, frame)
if __name__ == "__main__":
logger.info(f"Запуск сервера на {settings.run.host}:{settings.run.port}")
config = uvicorn.Config(
"main:app",
host=settings.run.host,
port=settings.run.port,
timeout_graceful_shutdown=settings.run.graceful_timeout,
access_log=False, # запросы логирует наш middleware
)
DrainingServer(config).run()
View File
+271
View File
@@ -0,0 +1,271 @@
"""Сверка двух хранилищ: объекты S3 (prefix originals/) и метаданные attachments в PostgreSQL.
Обход — слиянием двух потоков, отсортированных одинаково (побайтово): листинг S3 страницами по 1000
и серверный курсор по индексу object_key (collation "C"). Память не зависит от числа объектов.
Категории расхождений и что с ними делает --apply:
orphan_object объект без строки, старше grace -> объект удаляется
orphan_object_fresh объект без строки, моложе grace -> не трогаем (загрузка между PUT и COMMIT)
missing_object строка без объекта, ни к чему не прикреплена, старше grace -> строка удаляется
missing_object_referenced строка без объекта, прикреплена к сообщениям -> только отчёт (нужен бэкап)
missing_object_fresh строка без объекта, моложе grace -> не трогаем (строка новее листинга)
size_mismatch размер объекта != size_bytes -> только отчёт
checksum_mismatch SHA-256 объекта != sha256 (--verify-checksums) -> только отчёт
Защиты: dry-run по умолчанию; перед каждым удалением состояние перепроверяется (HEAD объекта, строка,
ссылки из сообщений — под блокировкой строки); --max-deletes останавливает apply, если удалить нужно
подозрительно много (например, перепутан bucket); advisory lock — два запуска одновременно не идут.
python -m maintenance.reconcile # dry-run
python -m maintenance.reconcile --apply
python -m maintenance.reconcile --verify-checksums # плюс чтение и SHA-256 каждого объекта
"""
import argparse
import hashlib
import json
import sys
import time
from collections import Counter
from dataclasses import dataclass, field
from datetime import datetime, timedelta, timezone
from pathlib import Path
from sqlalchemy import delete, exists, select, text
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
from core import s3
from core.config import settings
from core.db import SessionLocal, engine
from core.logger import logger
from models import Attachment, MessageAttachment
ADVISORY_LOCK_ID = 4_040_404
SAMPLE_SIZE = 10
FETCH_SIZE = 1000
ACTIONABLE = ("orphan_object", "missing_object")
CATEGORIES = ("orphan_object", "orphan_object_fresh", "missing_object", "missing_object_referenced",
"missing_object_fresh", "size_mismatch", "checksum_mismatch")
class ReconcileAborted(Exception):
pass
@dataclass
class Row:
object_key: str
id: str
size_bytes: int
sha256: str
created_at: datetime
referenced: bool
@dataclass
class Findings:
sample_size: int = SAMPLE_SIZE
counts: Counter = field(default_factory=Counter)
samples: dict = field(default_factory=dict)
actionable: dict = field(default_factory=lambda: {name: [] for name in ACTIONABLE})
def add(self, category: str, item):
self.counts[category] += 1
sample = item.key if isinstance(item, s3.StoredObject) else str(item.id)
bucket = self.samples.setdefault(category, [])
if len(bucket) < self.sample_size:
bucket.append(sample)
if category in self.actionable:
self.actionable[category].append(item)
def stream_rows(db: Session, prefix: str):
referenced = exists().where(MessageAttachment.attachment_id == Attachment.id)
query = (select(Attachment.object_key, Attachment.id, Attachment.size_bytes, Attachment.sha256,
Attachment.created_at, referenced.label("referenced"))
.where(Attachment.object_key.startswith(prefix, autoescape=True))
.order_by(Attachment.object_key)
.execution_options(yield_per=FETCH_SIZE))
for row in db.execute(query):
yield Row(row.object_key, row.id, row.size_bytes, row.sha256, row.created_at, row.referenced)
def ordered(iterator, key, source: str):
"""Проверка порядка: слияние верно, только если оба потока отсортированы одинаково."""
previous = None
for item in iterator:
current = key(item)
if previous is not None and current <= previous:
raise ReconcileAborted(f"{source}: ключи не по возрастанию ({previous!r} -> {current!r})")
previous = current
yield item
def object_sha256(key: str) -> tuple[str, int]:
digest, size = hashlib.sha256(), 0
response = s3.open_object(key)
for chunk in s3.iter_object(response):
digest.update(chunk)
size += len(chunk)
return digest.hexdigest(), size
def scan(db: Session, prefix: str, cutoff: datetime, verify_checksums: bool, stats: Counter,
sample_size: int = SAMPLE_SIZE) -> Findings:
findings = Findings(sample_size=sample_size)
objects = ordered(s3.list_objects(prefix), lambda o: o.key.encode(), "S3")
rows = ordered(stream_rows(db, prefix), lambda r: r.object_key.encode(), "PostgreSQL")
obj, row = next(objects, None), next(rows, None)
while obj is not None or row is not None:
if row is None or (obj is not None and obj.key.encode() < row.object_key.encode()):
stats["objects_scanned"] += 1
findings.add("orphan_object" if obj.last_modified <= cutoff else "orphan_object_fresh", obj)
obj = next(objects, None)
elif obj is None or row.object_key.encode() < obj.key.encode():
stats["rows_scanned"] += 1
if row.created_at > cutoff:
findings.add("missing_object_fresh", row)
else:
findings.add("missing_object_referenced" if row.referenced else "missing_object", row)
row = next(rows, None)
else:
stats["objects_scanned"] += 1
stats["rows_scanned"] += 1
if obj.size != row.size_bytes:
findings.add("size_mismatch", row)
elif verify_checksums:
digest, size = object_sha256(obj.key)
stats["bytes_read"] += size
if digest != row.sha256:
findings.add("checksum_mismatch", row)
else:
stats["ok"] += 1
else:
stats["ok"] += 1
obj, row = next(objects, None), next(rows, None)
return findings
def row_exists(db: Session, key: str) -> bool:
return db.scalar(select(exists().where(Attachment.object_key == key)))
def delete_orphan_object(db: Session, obj: s3.StoredObject) -> bool:
# Строка могла появиться после листинга (загрузка закоммитилась) — тогда объект не сирота.
if row_exists(db, obj.key):
return False
s3.delete_object(obj.key)
return True
def delete_missing_row(db: Session, row: Row) -> bool:
# Блокируем строку: параллельное сообщение со ссылкой на неё либо дождётся нас (и получит 404),
# либо закоммитится раньше — тогда ссылка появится и строку удалять нельзя.
attachment = db.scalar(select(Attachment).where(Attachment.id == row.id).with_for_update())
if attachment is None:
db.rollback()
return False
referenced = db.scalar(select(exists().where(MessageAttachment.attachment_id == row.id)))
if referenced or s3.object_exists(row.object_key):
db.rollback()
return False
try:
db.execute(delete(Attachment).where(Attachment.id == row.id))
db.commit()
except IntegrityError:
db.rollback()
return False
return True
def reconcile(db: Session, apply: bool = False, grace_seconds: int | None = None, verify_checksums: bool = False,
max_deletes: int = 100, prefix: str | None = None, sample_size: int = SAMPLE_SIZE) -> dict:
grace_seconds = settings.reconcile.grace_seconds if grace_seconds is None else grace_seconds
prefix = settings.reconcile.prefix if prefix is None else prefix
started_at = datetime.now(timezone.utc)
cutoff = started_at - timedelta(seconds=grace_seconds)
stats = Counter()
report = {"mode": "apply" if apply else "dry-run", "bucket": settings.s3.bucket, "prefix": prefix,
"grace_seconds": grace_seconds, "verify_checksums": verify_checksums, "max_deletes": max_deletes}
clock = time.monotonic()
findings = scan(db, prefix, cutoff, verify_checksums, stats, sample_size)
db.commit() # закрыть транзакцию серверного курсора
scan_seconds = time.monotonic() - clock
actions = Counter()
planned = sum(len(items) for items in findings.actionable.values())
if apply and planned > max_deletes:
report["aborted"] = f"к удалению {planned} > --max-deletes {max_deletes}: ничего не изменено"
elif apply:
for obj in findings.actionable["orphan_object"]:
actions["objects_deleted" if delete_orphan_object(db, obj) else "skipped_on_recheck"] += 1
for row in findings.actionable["missing_object"]:
actions["rows_deleted" if delete_missing_row(db, row) else "skipped_on_recheck"] += 1
report.update({
"objects_scanned": stats["objects_scanned"], "rows_scanned": stats["rows_scanned"], "ok": stats["ok"],
"issues": {name: findings.counts.get(name, 0) for name in CATEGORIES},
"samples": findings.samples,
"actions": {name: actions.get(name, 0) for name in ("objects_deleted", "rows_deleted", "skipped_on_recheck")},
"bytes_read": stats["bytes_read"],
"seconds": {"scan": round(scan_seconds, 3), "total": round(time.monotonic() - clock, 3)},
})
report["peak_rss_mib"] = peak_rss_mib()
return report
def peak_rss_mib() -> float | None:
status = Path("/proc/self/status")
if not status.exists():
return None
for line in status.read_text().splitlines():
if line.startswith("VmHWM"):
return round(int(line.split()[1]) / 1024, 1)
return None
def run_locked(**kwargs) -> dict:
"""Один запуск за раз: session-level advisory lock на отдельном соединении."""
with engine.connect() as lock_connection:
if not lock_connection.scalar(text("SELECT pg_try_advisory_lock(:id)"), {"id": ADVISORY_LOCK_ID}):
raise ReconcileAborted("уже идёт другая сверка")
try:
with SessionLocal() as db:
return reconcile(db, **kwargs)
finally:
lock_connection.execute(text("SELECT pg_advisory_unlock(:id)"), {"id": ADVISORY_LOCK_ID})
def main() -> int:
parser = argparse.ArgumentParser(description="Сверка объектов S3 и метаданных вложений")
parser.add_argument("--apply", action="store_true", help="исправлять (по умолчанию только отчёт)")
parser.add_argument("--grace-seconds", type=int, default=settings.reconcile.grace_seconds)
parser.add_argument("--verify-checksums", action="store_true", help="читать объекты и сверять SHA-256")
parser.add_argument("--max-deletes", type=int, default=100)
parser.add_argument("--samples", type=int, default=SAMPLE_SIZE, help="сколько id/ключей каждой категории в отчёте")
args = parser.parse_args()
try:
report = run_locked(apply=args.apply, grace_seconds=args.grace_seconds,
verify_checksums=args.verify_checksums, max_deletes=args.max_deletes,
sample_size=args.samples)
except ReconcileAborted as exc:
logger.warning(f"Сверка остановлена: {exc}")
return 1
except s3.StorageUnavailable:
logger.warning("Сверка пропущена: S3 недоступен")
return 1
except Exception as exc:
logger.warning(f"Сверка пропущена: {type(exc).__name__}")
return 1
summary = {k: report[k] for k in ("mode", "objects_scanned", "rows_scanned", "issues", "actions", "seconds")}
logger.info(f"Сверка: {json.dumps(summary, ensure_ascii=False)}")
if report.get("aborted"):
logger.warning(f"Сверка: apply отменён — {report['aborted']}")
print(json.dumps(report, ensure_ascii=False, default=str))
return 1 if report.get("aborted") else 0
if __name__ == "__main__":
sys.exit(main())
+52
View File
@@ -0,0 +1,52 @@
from logging.config import fileConfig
from alembic import context
from sqlalchemy import create_engine, pool, text
from core.config import settings
from core.db import build_url
from models import Base
config = context.config
if config.config_file_name is not None:
fileConfig(config.config_file_name)
target_metadata = Base.metadata
# Ключ advisory lock: параллельные запуски миграций выполнятся по очереди.
MIGRATION_LOCK_KEY = 2_026_002
def run_migrations_offline() -> None:
context.configure(
url=build_url(),
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online() -> None:
engine = create_engine(
build_url(),
poolclass=pool.NullPool,
connect_args={"connect_timeout": settings.db.connect_timeout},
)
with engine.connect() as connection:
context.configure(
connection=connection,
target_metadata=target_metadata,
compare_server_default=True,
)
with context.begin_transaction():
connection.execute(text("SELECT pg_advisory_xact_lock(:key)"), {"key": MIGRATION_LOCK_KEY})
context.run_migrations()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
+28
View File
@@ -0,0 +1,28 @@
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
# revision identifiers, used by Alembic.
revision: str = ${repr(up_revision)}
down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)}
branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
def upgrade() -> None:
"""Upgrade schema."""
${upgrades if upgrades else "pass"}
def downgrade() -> None:
"""Downgrade schema."""
${downgrades if downgrades else "pass"}
@@ -0,0 +1,85 @@
"""initial schema
Revision ID: 0001
Revises:
Create Date: 2026-10-15 17:30:37.825446
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision: str = '0001'
down_revision: Union[str, Sequence[str], None] = None
branch_labels: Union[str, Sequence[str], None] = None
depends_on: Union[str, Sequence[str], None] = None
def upgrade() -> None:
"""Upgrade schema."""
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('chats',
sa.Column('id', sa.Uuid(), server_default=sa.text('gen_random_uuid()'), nullable=False),
sa.Column('title', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
sa.CheckConstraint('char_length(title) BETWEEN 1 AND 100', name=op.f('chats_title_len')),
sa.PrimaryKeyConstraint('id', name=op.f('chats_pkey'))
)
op.create_table('users',
sa.Column('id', sa.Uuid(), server_default=sa.text('gen_random_uuid()'), nullable=False),
sa.Column('username', sa.Text(), nullable=False),
sa.Column('display_name', sa.Text(), nullable=False),
sa.Column('password_hash', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
sa.CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'", name=op.f('users_username_format')),
sa.CheckConstraint('char_length(display_name) BETWEEN 1 AND 100', name=op.f('users_display_name_len')),
sa.PrimaryKeyConstraint('id', name=op.f('users_pkey')),
sa.UniqueConstraint('username', name=op.f('users_username_key'))
)
op.create_table('chat_members',
sa.Column('chat_id', sa.Uuid(), nullable=False),
sa.Column('user_id', sa.Uuid(), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], name=op.f('chat_members_chat_id_fkey')),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], name=op.f('chat_members_user_id_fkey')),
sa.PrimaryKeyConstraint('chat_id', 'user_id', name=op.f('chat_members_pkey'))
)
op.create_index(op.f('chat_members_user_id_chat_id_idx'), 'chat_members', ['user_id', 'chat_id'], unique=False)
op.create_table('sessions',
sa.Column('token_hash', sa.LargeBinary(), nullable=False),
sa.Column('user_id', sa.Uuid(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False),
sa.CheckConstraint('expires_at > created_at', name=op.f('sessions_expiry_after_creation')),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], name=op.f('sessions_user_id_fkey'), ondelete='CASCADE'),
sa.PrimaryKeyConstraint('token_hash', name=op.f('sessions_pkey'))
)
op.create_index(op.f('sessions_expires_at_idx'), 'sessions', ['expires_at'], unique=False)
op.create_table('messages',
sa.Column('id', sa.Uuid(), server_default=sa.text('gen_random_uuid()'), nullable=False),
sa.Column('chat_id', sa.Uuid(), nullable=False),
sa.Column('sender_id', sa.Uuid(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
sa.Column('text', sa.Text(), nullable=False),
sa.CheckConstraint('char_length(text) BETWEEN 1 AND 4000', name=op.f('messages_text_len')),
sa.ForeignKeyConstraint(['chat_id', 'sender_id'], ['chat_members.chat_id', 'chat_members.user_id'], name='messages_sender_is_member'),
sa.PrimaryKeyConstraint('id', name=op.f('messages_pkey'))
)
op.create_index('messages_chat_history_idx', 'messages', ['chat_id', 'created_at', 'id'], unique=False)
# ### end Alembic commands ###
def downgrade() -> None:
"""Downgrade schema."""
# ### commands auto generated by Alembic - please adjust! ###
op.drop_index('messages_chat_history_idx', table_name='messages')
op.drop_table('messages')
op.drop_index(op.f('sessions_expires_at_idx'), table_name='sessions')
op.drop_table('sessions')
op.drop_index(op.f('chat_members_user_id_chat_id_idx'), table_name='chat_members')
op.drop_table('chat_members')
op.drop_table('users')
op.drop_table('chats')
# ### end Alembic commands ###
@@ -0,0 +1,44 @@
"""idempotency keys
Revision ID: 0002
Revises: 0001
Create Date: 2026-10-28 12:00:00.000000
Только добавляет таблицу: версия приложения до этой миграции её не использует и продолжает работать,
поэтому миграцию можно применять перед rolling update (expand-фаза).
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision: str = '0002'
down_revision: Union[str, Sequence[str], None] = '0001'
branch_labels: Union[str, Sequence[str], None] = None
depends_on: Union[str, Sequence[str], None] = None
def upgrade() -> None:
"""Upgrade schema."""
op.create_table('idempotency_keys',
sa.Column('user_id', sa.Uuid(), nullable=False),
sa.Column('chat_id', sa.Uuid(), nullable=False),
sa.Column('key', sa.Text(), nullable=False),
sa.Column('request_hash', sa.LargeBinary(), nullable=False),
sa.Column('message_id', sa.Uuid(), nullable=True),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
sa.CheckConstraint("key ~ '^[A-Za-z0-9._:-]{1,128}$'", name=op.f('idempotency_keys_key_format')),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], name=op.f('idempotency_keys_user_id_fkey')),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], name=op.f('idempotency_keys_chat_id_fkey')),
sa.ForeignKeyConstraint(['message_id'], ['messages.id'], name=op.f('idempotency_keys_message_id_fkey')),
sa.PrimaryKeyConstraint('user_id', 'chat_id', 'key', name=op.f('idempotency_keys_pkey'))
)
op.create_index('idempotency_keys_created_at_idx', 'idempotency_keys', ['created_at'], unique=False)
def downgrade() -> None:
"""Downgrade schema."""
op.drop_index('idempotency_keys_created_at_idx', table_name='idempotency_keys')
op.drop_table('idempotency_keys')
@@ -0,0 +1,72 @@
"""attachments
Revision ID: 0003
Revises: 0002
Create Date: 2026-11-12 12:00:00.000000
Expand-миграция: новые таблицы и ослабление CHECK у messages.text (пустой текст при наличии вложений).
Версия lab3 продолжает работать с этой схемой, поэтому миграцию можно применять до замены реплик.
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision: str = '0003'
down_revision: Union[str, Sequence[str], None] = '0002'
branch_labels: Union[str, Sequence[str], None] = None
depends_on: Union[str, Sequence[str], None] = None
def upgrade() -> None:
"""Upgrade schema."""
op.create_table('attachments',
sa.Column('id', sa.Uuid(), nullable=False),
sa.Column('chat_id', sa.Uuid(), nullable=False),
sa.Column('owner_id', sa.Uuid(), nullable=False),
sa.Column('filename', sa.Text(), nullable=False),
sa.Column('content_type', sa.Text(), nullable=False),
sa.Column('size_bytes', sa.BigInteger(), nullable=False),
sa.Column('sha256', sa.Text(), nullable=False),
sa.Column('object_key', sa.Text(), nullable=False),
sa.Column('status', sa.Text(), server_default=sa.text("'ready'"), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
sa.Column('updated_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
sa.CheckConstraint("content_type IN ('image/png', 'image/jpeg')", name=op.f('attachments_content_type')),
sa.CheckConstraint('size_bytes BETWEEN 1 AND 10485760', name=op.f('attachments_size')),
sa.CheckConstraint("sha256 ~ '^[0-9a-f]{64}$'", name=op.f('attachments_sha256_format')),
sa.CheckConstraint('char_length(filename) BETWEEN 1 AND 255', name=op.f('attachments_filename_len')),
sa.CheckConstraint("status IN ('ready')", name=op.f('attachments_status')),
sa.ForeignKeyConstraint(['chat_id', 'owner_id'], ['chat_members.chat_id', 'chat_members.user_id'], name='attachments_owner_is_member'),
sa.PrimaryKeyConstraint('id', name=op.f('attachments_pkey')),
sa.UniqueConstraint('id', 'chat_id', name='attachments_id_chat_id_key'),
sa.UniqueConstraint('object_key', name=op.f('attachments_object_key_key'))
)
op.create_index(op.f('attachments_created_at_idx'), 'attachments', ['created_at'], unique=False)
op.create_table('message_attachments',
sa.Column('message_id', sa.Uuid(), nullable=False),
sa.Column('attachment_id', sa.Uuid(), nullable=False),
sa.Column('chat_id', sa.Uuid(), nullable=False),
sa.Column('position', sa.SmallInteger(), nullable=False),
sa.CheckConstraint('position BETWEEN 0 AND 9', name=op.f('message_attachments_position_range')),
sa.ForeignKeyConstraint(['attachment_id', 'chat_id'], ['attachments.id', 'attachments.chat_id'], name='message_attachments_same_chat'),
sa.ForeignKeyConstraint(['message_id'], ['messages.id'], name=op.f('message_attachments_message_id_fkey')),
sa.PrimaryKeyConstraint('message_id', 'attachment_id', name=op.f('message_attachments_pkey'))
)
op.create_index(op.f('message_attachments_attachment_id_idx'), 'message_attachments', ['attachment_id'], unique=False)
op.drop_constraint(op.f('messages_text_len'), 'messages', type_='check')
op.create_check_constraint(op.f('messages_text_len'), 'messages', 'char_length(text) BETWEEN 0 AND 4000')
def downgrade() -> None:
"""Downgrade schema."""
op.drop_index(op.f('message_attachments_attachment_id_idx'), table_name='message_attachments')
op.drop_table('message_attachments')
op.drop_index(op.f('attachments_created_at_idx'), table_name='attachments')
op.drop_table('attachments')
op.drop_constraint(op.f('messages_text_len'), 'messages', type_='check')
# Сообщения только с вложениями нарушили бы прежнее ограничение; удалять их нельзя (на них ссылаются ключи идемпотентности).
op.execute("UPDATE messages SET text = '[вложение]' WHERE text = ''")
op.create_check_constraint(op.f('messages_text_len'), 'messages', 'char_length(text) BETWEEN 1 AND 4000')
@@ -0,0 +1,31 @@
"""attachments.object_key collation C
Revision ID: 0004
Revises: 0003
Create Date: 2026-11-12 14:00:00.000000
Сверка хранилищ сравнивает листинг S3 (ключи в побайтовом порядке UTF-8) с attachments, отсортированной
по object_key. С collation "C" порядок совпадает, и уникальный индекс по ключу пересобирается в нём же,
поэтому ORDER BY object_key идёт по индексу. Ключи назначает сервер и они ASCII, значения не меняются.
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision: str = '0004'
down_revision: Union[str, Sequence[str], None] = '0003'
branch_labels: Union[str, Sequence[str], None] = None
depends_on: Union[str, Sequence[str], None] = None
def upgrade() -> None:
"""Upgrade schema."""
op.alter_column('attachments', 'object_key', type_=sa.Text(collation='C'), existing_nullable=False)
def downgrade() -> None:
"""Downgrade schema."""
op.alter_column('attachments', 'object_key', type_=sa.Text(), existing_nullable=False)
+11
View File
@@ -0,0 +1,11 @@
# Все модели импортируются здесь, чтобы Base.metadata (и Alembic) видел все таблицы.
from models.attachments_models import Attachment, MessageAttachment
from models.base import Base
from models.chats_models import Chat, ChatMember
from models.idempotency_models import IdempotencyKey
from models.messages_models import Message
from models.sessions_models import AuthSession
from models.users_models import User
__all__ = ["Base", "User", "AuthSession", "Chat", "ChatMember", "Message", "IdempotencyKey",
"Attachment", "MessageAttachment"]
+65
View File
@@ -0,0 +1,65 @@
import uuid
from datetime import datetime
from sqlalchemy import (BigInteger, CheckConstraint, DateTime, ForeignKey, ForeignKeyConstraint, Index, SmallInteger,
Text, UniqueConstraint, Uuid, text)
from sqlalchemy.orm import Mapped, mapped_column
from models.base import Base
class Attachment(Base):
"""Метаданные вложения. Байты оригинала лежат в приватном S3-bucket под object_key."""
__tablename__ = "attachments"
__table_args__ = (
# Загрузить файл может только участник чата.
ForeignKeyConstraint(
["chat_id", "owner_id"],
["chat_members.chat_id", "chat_members.user_id"],
name="attachments_owner_is_member",
),
# Цель составного внешнего ключа из message_attachments: вложение и сообщение из одного чата.
UniqueConstraint("id", "chat_id", name="attachments_id_chat_id_key"),
CheckConstraint("content_type IN ('image/png', 'image/jpeg')", name="content_type"),
CheckConstraint("size_bytes BETWEEN 1 AND 10485760", name="size"),
CheckConstraint("sha256 ~ '^[0-9a-f]{64}$'", name="sha256_format"),
CheckConstraint("char_length(filename) BETWEEN 1 AND 255", name="filename_len"),
# В lab4 загрузка синхронная: строка появляется только после сохранения объекта в S3.
CheckConstraint("status IN ('ready')", name="status"),
Index(None, "created_at"),
)
id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
chat_id: Mapped[uuid.UUID] = mapped_column(Uuid)
owner_id: Mapped[uuid.UUID] = mapped_column(Uuid)
# Только для отображения; ключ в S3 назначает сервер.
filename: Mapped[str] = mapped_column(Text)
content_type: Mapped[str] = mapped_column(Text)
size_bytes: Mapped[int] = mapped_column(BigInteger)
sha256: Mapped[str] = mapped_column(Text)
# Collation "C" (побайтовая) = порядок листинга S3: сверка идёт слиянием двух отсортированных потоков,
# и уникальный индекс по ключу сразу отдаёт строки в нужном порядке, без сортировки.
object_key: Mapped[str] = mapped_column(Text(collation="C"), unique=True)
status: Mapped[str] = mapped_column(Text, server_default=text("'ready'"))
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=text("clock_timestamp()"))
updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=text("clock_timestamp()"))
class MessageAttachment(Base):
"""Связь сообщения с вложениями; position сохраняет порядок attachment_ids из запроса."""
__tablename__ = "message_attachments"
__table_args__ = (
ForeignKeyConstraint(
["attachment_id", "chat_id"],
["attachments.id", "attachments.chat_id"],
name="message_attachments_same_chat",
),
CheckConstraint("position BETWEEN 0 AND 9", name="position_range"),
# Найти сообщения, которые ссылаются на вложение (проверка «используется ли объект»).
Index(None, "attachment_id"),
)
message_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("messages.id"), primary_key=True)
attachment_id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
chat_id: Mapped[uuid.UUID] = mapped_column(Uuid)
position: Mapped[int] = mapped_column(SmallInteger)
+15
View File
@@ -0,0 +1,15 @@
from sqlalchemy import MetaData
from sqlalchemy.orm import DeclarativeBase
# Предсказуемые имена ограничений: по ним разбираем ошибки БД (users_username_key -> 409).
NAMING_CONVENTION = {
"pk": "%(table_name)s_pkey",
"uq": "%(table_name)s_%(column_0_name)s_key",
"ck": "%(table_name)s_%(constraint_name)s",
"fk": "%(table_name)s_%(column_0_name)s_fkey",
"ix": "%(table_name)s_%(column_0_N_name)s_idx",
}
class Base(DeclarativeBase):
metadata = MetaData(naming_convention=NAMING_CONVENTION)
+35
View File
@@ -0,0 +1,35 @@
import uuid
from datetime import datetime
from sqlalchemy import CheckConstraint, DateTime, ForeignKey, Index, Text, Uuid, text
from sqlalchemy.orm import Mapped, mapped_column, relationship
from models.base import Base
class Chat(Base):
__tablename__ = "chats"
__table_args__ = (
CheckConstraint("char_length(title) BETWEEN 1 AND 100", name="title_len"),
)
id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, server_default=text("gen_random_uuid()"))
title: Mapped[str] = mapped_column(Text)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=text("clock_timestamp()"))
# selectin: участники всех чатов страницы грузятся одним запросом (без N+1).
members: Mapped[list["ChatMember"]] = relationship(lazy="selectin", order_by="ChatMember.user_id")
@property
def member_ids(self) -> list[uuid.UUID]:
return [member.user_id for member in self.members]
class ChatMember(Base):
__tablename__ = "chat_members"
__table_args__ = (
Index(None, "user_id", "chat_id"), # для «моих чатов»
)
chat_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("chats.id"), primary_key=True)
user_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id"), primary_key=True)
+29
View File
@@ -0,0 +1,29 @@
import uuid
from datetime import datetime
from sqlalchemy import CheckConstraint, DateTime, ForeignKey, Index, LargeBinary, Text, Uuid, text
from sqlalchemy.orm import Mapped, mapped_column
from models.base import Base
class IdempotencyKey(Base):
"""Результат отправки сообщения по Idempotency-Key.
Область уникальности по контракту: пользователь + метод + путь чата + ключ.
Метод у маршрута один (POST), путь однозначно задаётся chat_id, поэтому ключ таблицы — (user_id, chat_id, key).
"""
__tablename__ = "idempotency_keys"
__table_args__ = (
CheckConstraint(r"key ~ '^[A-Za-z0-9._:-]{1,128}$'", name="key_format"),
Index("idempotency_keys_created_at_idx", "created_at"),
)
user_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id"), primary_key=True)
chat_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("chats.id"), primary_key=True)
key: Mapped[str] = mapped_column(Text, primary_key=True)
# SHA-256 канонического тела запроса: тот же ключ с другим телом -> 409.
request_hash: Mapped[bytes] = mapped_column(LargeBinary)
# Заполняется в той же транзакции, что и вставка сообщения; видимой строки с NULL не бывает.
message_id: Mapped[uuid.UUID | None] = mapped_column(Uuid, ForeignKey("messages.id"))
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=text("clock_timestamp()"))
+40
View File
@@ -0,0 +1,40 @@
import uuid
from datetime import datetime
from sqlalchemy import CheckConstraint, DateTime, ForeignKeyConstraint, Index, Text, Uuid
# Псевдоним: столбец `text` ниже перекрыл бы функцию text().
from sqlalchemy import text as sql_text
from sqlalchemy.orm import Mapped, mapped_column, relationship
from models.attachments_models import MessageAttachment
from models.base import Base
class Message(Base):
__tablename__ = "messages"
__table_args__ = (
# С lab4 текст может быть пустым, если есть вложения (это проверяет API).
CheckConstraint("char_length(text) BETWEEN 0 AND 4000", name="text_len"),
# Отправитель обязан быть участником чата.
ForeignKeyConstraint(
["chat_id", "sender_id"],
["chat_members.chat_id", "chat_members.user_id"],
name="messages_sender_is_member",
),
Index("messages_chat_history_idx", "chat_id", "created_at", "id"),
)
id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, server_default=sql_text("gen_random_uuid()"))
chat_id: Mapped[uuid.UUID] = mapped_column(Uuid)
sender_id: Mapped[uuid.UUID] = mapped_column(Uuid)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), server_default=sql_text("clock_timestamp()"))
text: Mapped[str] = mapped_column(Text)
# selectin: вложения всех сообщений страницы истории грузятся одним запросом (без N+1).
attachment_links: Mapped[list[MessageAttachment]] = relationship(
lazy="selectin", order_by=MessageAttachment.position)
@property
def attachment_ids(self) -> list[uuid.UUID]:
return [link.attachment_id for link in self.attachment_links]
+25
View File
@@ -0,0 +1,25 @@
import uuid
from datetime import datetime
from sqlalchemy import CheckConstraint, DateTime, ForeignKey, Index, LargeBinary, Uuid, text
from sqlalchemy.orm import Mapped, mapped_column, relationship
from models.base import Base
from models.users_models import User
class AuthSession(Base):
"""Сессия входа (не путать с ORM-сессией SQLAlchemy)."""
__tablename__ = "sessions"
__table_args__ = (
CheckConstraint("expires_at > created_at", name="expiry_after_creation"),
Index(None, "expires_at"),
)
# SHA-256 от токена, сам токен не храним.
token_hash: Mapped[bytes] = mapped_column(LargeBinary, primary_key=True)
user_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id", ondelete="CASCADE"))
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=text("clock_timestamp()"))
expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
user: Mapped[User] = relationship(lazy="joined")
+21
View File
@@ -0,0 +1,21 @@
import uuid
from datetime import datetime
from sqlalchemy import CheckConstraint, DateTime, Text, Uuid, text
from sqlalchemy.orm import Mapped, mapped_column
from models.base import Base
class User(Base):
__tablename__ = "users"
__table_args__ = (
CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'", name="username_format"),
CheckConstraint("char_length(display_name) BETWEEN 1 AND 100", name="display_name_len"),
)
id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, server_default=text("gen_random_uuid()"))
username: Mapped[str] = mapped_column(Text, unique=True)
display_name: Mapped[str] = mapped_column(Text)
password_hash: Mapped[str] = mapped_column(Text)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=text("clock_timestamp()"))
+34
View File
@@ -0,0 +1,34 @@
from typing import Literal
from uuid import UUID
from pydantic import BaseModel, ConfigDict
from utils.dates import UtcDatetime
class VariantResponse(BaseModel):
# Производные варианты (thumbnail и др.) появятся с lab5; в lab4 список всегда пуст.
name: Literal["thumbnail", "crop", "optimized"]
content_type: Literal["image/jpeg", "image/png", "image/webp"]
size_bytes: int
width: int
height: int
sha256: str
class AttachmentResponse(BaseModel):
# Ключ объекта в S3 и прочие внутренние поля наружу не отдаются.
model_config = ConfigDict(from_attributes=True)
id: UUID
chat_id: UUID
owner_id: UUID
filename: str
content_type: Literal["image/png", "image/jpeg"]
size_bytes: int
sha256: str
status: Literal["ready"]
variants: list[VariantResponse] = []
error_code: str | None = None
created_at: UtcDatetime
updated_at: UtcDatetime
+13
View File
@@ -0,0 +1,13 @@
from typing import Literal
from pydantic import BaseModel
from schemas.users_schemas import UserResponse
from utils.dates import UtcDatetime
class SessionResponse(BaseModel):
token: str
token_type: Literal["Bearer"] = "Bearer"
expires_at: UtcDatetime
user: UserResponse
+38
View File
@@ -0,0 +1,38 @@
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
from utils.dates import UtcDatetime
class CreateChatRequest(BaseModel):
model_config = ConfigDict(extra="forbid")
title: StrictStr = Field(min_length=1, max_length=100)
member_ids: list[UUID] = Field(min_length=1, max_length=100)
@field_validator("title")
def validate_title(cls, v):
if not v.strip():
raise ValueError("title must not be blank")
return v
@field_validator("member_ids")
def validate_member_ids(cls, v):
if len(set(v)) != len(v):
raise ValueError("member_ids must be unique")
return v
class ChatResponse(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: UUID
title: str
member_ids: list[UUID]
created_at: UtcDatetime
class ChatPageResponse(BaseModel):
items: list[ChatResponse]
next_cursor: str | None
+11
View File
@@ -0,0 +1,11 @@
from pydantic import BaseModel
class ErrorBody(BaseModel):
code: str
message: str
request_id: str
class ErrorResponse(BaseModel):
error: ErrorBody
+7
View File
@@ -0,0 +1,7 @@
from typing import Literal
from pydantic import BaseModel
class HealthResponse(BaseModel):
status: Literal["ok"]
+39
View File
@@ -0,0 +1,39 @@
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, StrictStr, model_validator
from utils.dates import UtcDatetime
class CreateMessageRequest(BaseModel):
# extra="forbid": клиент не может прислать sender_id.
model_config = ConfigDict(extra="forbid")
text: StrictStr = Field(max_length=4000)
# Отсутствующее поле и [] равнозначны (в том числе для Idempotency-Key).
attachment_ids: list[UUID] = Field(default_factory=list, max_length=10)
@model_validator(mode="after")
def validate_content(self):
if len(set(self.attachment_ids)) != len(self.attachment_ids):
raise ValueError("attachment_ids must be unique")
# Пустой или пробельный текст допустим только вместе с вложениями.
if not self.attachment_ids and not self.text.strip():
raise ValueError("text must not be blank without attachments")
return self
class MessageResponse(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: UUID
chat_id: UUID
sender_id: UUID
text: str
created_at: UtcDatetime
attachment_ids: list[UUID]
class MessagePageResponse(BaseModel):
items: list[MessageResponse]
next_cursor: str | None
+29
View File
@@ -0,0 +1,29 @@
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
from utils.dates import UtcDatetime
class CreateUserRequest(BaseModel):
model_config = ConfigDict(extra="forbid")
username: StrictStr = Field(pattern=r"^[a-z0-9_]{3,32}$")
display_name: StrictStr = Field(min_length=1, max_length=100)
password: StrictStr = Field(min_length=12, max_length=128)
@field_validator("display_name")
def validate_display_name(cls, v):
if not v.strip():
raise ValueError("display_name must not be blank")
return v
class UserResponse(BaseModel):
# Собирается из ORM-объекта; password_hash сюда не попадает.
model_config = ConfigDict(from_attributes=True)
id: UUID
username: str
display_name: str
created_at: UtcDatetime
+18
View File
@@ -0,0 +1,18 @@
from datetime import datetime, timezone
from typing import Annotated
from pydantic import PlainSerializer
TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
def format_utc(value: datetime) -> str:
return value.astimezone(timezone.utc).strftime(TIME_FORMAT)
def parse_utc(value: str) -> datetime:
return datetime.strptime(value, TIME_FORMAT).replace(tzinfo=timezone.utc)
# datetime, который в JSON превращается в строку вида 2026-09-01T12:00:00.123456Z.
UtcDatetime = Annotated[datetime, PlainSerializer(format_utc, return_type=str)]
+57
View File
@@ -0,0 +1,57 @@
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from sqlalchemy.exc import OperationalError
from sqlalchemy.exc import TimeoutError as PoolTimeoutError
from starlette.exceptions import HTTPException
from core.logger import logger
from core.s3 import StorageUnavailable
from schemas.error_schemas import ErrorBody, ErrorResponse
ERROR_CODES = {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
413: "payload_too_large",
415: "unsupported_media_type",
429: "rate_limited",
500: "internal_error",
503: "unavailable",
}
def error_response(request: Request, status_code: int, message: str,
headers: dict[str, str] | None = None) -> JSONResponse:
code = ERROR_CODES.get(status_code, "internal_error" if status_code >= 500 else "invalid_request")
body = ErrorResponse(error=ErrorBody(code=code, message=message, request_id=request.state.request_id))
return JSONResponse(status_code=status_code, content=body.model_dump(), headers=headers)
def http_error_handler(request: Request, exc: HTTPException) -> JSONResponse:
message = exc.detail if isinstance(exc.detail, str) and exc.detail else "Ошибка запроса"
return error_response(request, exc.status_code, message, headers=exc.headers)
def validation_error_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
return error_response(request, 400, "Неверный запрос")
# БД недоступна, statement_timeout или пул исчерпан -> 503 без подробностей.
def database_error_handler(request: Request, exc: Exception) -> JSONResponse:
logger.warning(f"Ошибка базы данных: {type(exc).__name__} request_id={request.state.request_id}")
return error_response(request, 503, "База данных недоступна")
# S3 недоступен: метаданные и текстовые запросы работают, файлы — 503 без подробностей.
def storage_error_handler(request: Request, exc: Exception) -> JSONResponse:
return error_response(request, 503, "Хранилище файлов недоступно")
def register_error_handlers(app: FastAPI):
app.add_exception_handler(HTTPException, http_error_handler)
app.add_exception_handler(RequestValidationError, validation_error_handler)
app.add_exception_handler(OperationalError, database_error_handler)
app.add_exception_handler(PoolTimeoutError, database_error_handler)
app.add_exception_handler(StorageUnavailable, storage_error_handler)
+72
View File
@@ -0,0 +1,72 @@
"""Проверка загружаемого изображения по содержимому, без полного декодирования."""
import io
import unicodedata
from dataclasses import dataclass
from PIL import Image
# Лимит пикселей проверяем сами по заголовку (ниже), до любой распаковки.
Image.MAX_IMAGE_PIXELS = None
SIGNATURES = {
b"\x89PNG\r\n\x1a\n": ("image/png", "PNG"),
b"\xff\xd8\xff": ("image/jpeg", "JPEG"),
}
class ImageRejected(Exception):
def __init__(self, status_code: int, message: str):
self.status_code = status_code
self.message = message
@dataclass
class ImageInfo:
content_type: str
width: int
height: int
def validate_filename(filename: str) -> str:
"""filename только отображается: в путь или ключ S3 он не попадает, но опасные символы отклоняем."""
if not filename.strip() or filename in {".", ".."}:
raise ImageRejected(400, "Недопустимое имя файла")
for char in filename:
if char in "/\\" or unicodedata.category(char) == "Cc":
raise ImageRejected(400, "Недопустимое имя файла")
return filename
def inspect_image(data: bytes, declared_type: str, max_pixels: int) -> ImageInfo:
"""Определить формат по сигнатуре, проверить размеры и целостность.
415 — не PNG/JPEG, Content-Type не совпадает с содержимым или файл повреждён;
413 — больше max_pixels (проверяется по заголовку до распаковки пикселей).
"""
detected = next((value for magic, value in SIGNATURES.items() if data.startswith(magic)), None)
if detected is None:
raise ImageRejected(415, "Поддерживаются только PNG и JPEG")
content_type, pil_format = detected
if content_type != declared_type:
raise ImageRejected(415, "Content-Type не совпадает с содержимым файла")
try:
# open читает только заголовок: width/height известны без декодирования.
with Image.open(io.BytesIO(data), formats=[pil_format]) as image:
width, height = image.size
if width * height > max_pixels:
raise ImageRejected(413, "Изображение больше 40 млн пикселей")
with Image.open(io.BytesIO(data), formats=[pil_format]) as image:
if pil_format == "PNG":
# Все чанки до IEND и их CRC; обрезанный или испорченный файл не пройдёт.
image.verify()
else:
# JPEG декодируется в масштабе 1/8: битый поток обнаружится, а памяти нужно в 64 раза меньше.
image.draft("RGB", (max(1, width // 8), max(1, height // 8)))
image.load()
except ImageRejected:
raise
except Exception as exc:
# Pillow бросает разные типы (OSError, SyntaxError, ValueError...) — для клиента это всё «битый файл».
raise ImageRejected(415, "Файл повреждён или не является изображением") from exc
return ImageInfo(content_type=content_type, width=width, height=height)
+13
View File
@@ -0,0 +1,13 @@
import threading
# Флаг живёт в отдельном модуле: main.py запускается как __main__ и ещё раз импортируется как "main",
# а общее состояние должно быть одно.
_draining = threading.Event()
def start_draining() -> None:
_draining.set()
def is_draining() -> bool:
return _draining.is_set()
+30
View File
@@ -0,0 +1,30 @@
import time
import uuid
from fastapi import Request
from core.config import settings
from core.logger import logger
from utils.errors import error_response
async def request_id_middleware(request: Request, call_next):
request.state.request_id = str(uuid.uuid4())
start = time.monotonic()
try:
response = await call_next(request)
except Exception:
# Подробности пишем только в лог сервера, клиенту — общий текст.
logger.exception(f"Непредвиденная ошибка request_id={request.state.request_id}")
response = error_response(request, 500, "Внутренняя ошибка сервера")
response.headers["X-Request-Id"] = request.state.request_id
# Какая реплика ответила (стабильно на всё время жизни процесса).
response.headers["X-Instance-Id"] = settings.run.instance_id
# Тело запроса не логируем, чтобы текст сообщений не попадал в логи.
duration_ms = (time.monotonic() - start) * 1000
logger.info(f"{request.method} {request.url.path} {response.status_code} "
f"{duration_ms:.1f}ms request_id={request.state.request_id} instance={settings.run.instance_id}")
return response
+35
View File
@@ -0,0 +1,35 @@
import base64
import json
import uuid
from datetime import datetime
from fastapi import HTTPException
from utils.dates import format_utc, parse_utc
# Позиция в списке: (created_at, id) последнего выданного элемента.
Position = tuple[datetime, uuid.UUID]
def make_cursor(scope: str, created_at: datetime, item_id: uuid.UUID) -> str:
data = json.dumps({"scope": scope, "created_at": format_utc(created_at), "id": str(item_id)})
return base64.urlsafe_b64encode(data.encode()).decode()
def read_cursor(scope: str, cursor: str | None) -> Position | None:
if cursor is None:
return None
try:
data = json.loads(base64.urlsafe_b64decode(cursor.encode()))
if data["scope"] != scope:
raise ValueError("cursor from another resource")
return parse_utc(data["created_at"]), uuid.UUID(data["id"])
except Exception:
raise HTTPException(status_code=400, detail="Неверный cursor")
def split_page(rows: list, limit: int, scope: str) -> tuple[list, str | None]:
"""rows получены с LIMIT limit + 1: лишняя строка значит, что есть следующая страница."""
page = rows[:limit]
next_cursor = make_cursor(scope, page[-1].created_at, page[-1].id) if len(rows) > limit else None
return page, next_cursor
+65
View File
@@ -0,0 +1,65 @@
import hashlib
import secrets
import uuid
from datetime import datetime, timedelta, timezone
import jwt
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
from core.config import settings
# Argon2id: 64 MiB, 3 прохода (как по умолчанию), но 1 поток вместо 4: реплика ограничена 1 CPU,
# и 4 потока только ждали бы квоту. Параметры записаны в самом хеше, старые хеши проверяются как раньше.
password_hasher = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=1)
# Проверяется, когда пользователя нет: время ответа такое же, как при неверном пароле.
DUMMY_PASSWORD_HASH = password_hasher.hash(secrets.token_urlsafe(16))
def hash_password(password: str) -> str:
return password_hasher.hash(password)
def verify_password(password_hash: str | None, password: str) -> bool:
try:
password_hasher.verify(password_hash or DUMMY_PASSWORD_HASH, password)
return password_hash is not None
except (VerificationError, InvalidHashError):
return False
JWT_SECRET_KEY = settings.jwt.read_secret_key()
def create_access_token(user_id: uuid.UUID) -> tuple[str, datetime, datetime]:
"""Возвращает (токен, время выдачи, время истечения)."""
# Целые секунды, чтобы expires_at совпадал с exp в токене.
issued_at = datetime.now(timezone.utc).replace(microsecond=0)
expires_at = issued_at + timedelta(seconds=settings.jwt.session_ttl_seconds)
payload = {
"sub": str(user_id),
"iat": issued_at,
"exp": expires_at,
"jti": secrets.token_urlsafe(32), # 256 бит случайности, токен всегда уникален
}
token = jwt.encode(payload, JWT_SECRET_KEY, algorithm=settings.jwt.algorithm)
return token, issued_at, expires_at
def decode_access_token(token: str) -> dict | None:
"""None — подпись неверна, токен испорчен или истёк."""
try:
return jwt.decode(
token,
JWT_SECRET_KEY,
algorithms=[settings.jwt.algorithm], # явно, чтобы не принять alg=none
options={"require": ["sub", "exp", "iat", "jti"]},
)
except jwt.InvalidTokenError:
return None
def token_hash(token: str) -> bytes:
# В БД хранится только хеш токена.
return hashlib.sha256(token.encode()).digest()
+257
View File
@@ -0,0 +1,257 @@
# Запуск: docker compose up -d --build --wait (или scripts/init-secrets.* перед первым запуском)
# Остановка: docker compose down — данные остаются в volume
# Удаление данных намеренно: docker compose down -v
#
# Клиент -> lb (HAProxy, единственный опубликованный порт) -> api x N (без портов на хосте) -> postgres (метаданные)
# -> minio (байты файлов)
# Порядок старта: postgres (healthy) -> migrate (один раз, exit 0) -> api (healthy) -> lb (healthy);
# minio (healthy) -> minio-init (один раз, exit 0) -> api.
name: mtusi-lab4
x-app-build: &app-build
context: .
args:
APP_VERSION: ${APP_VERSION:-dev}
services:
postgres:
image: postgres:17.10-alpine@sha256:979c4379dd698aba0b890599a6104e082035f98ef31d9b9291ec22f2b13059ca
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets:
- postgres_password
volumes:
- postgres_data:/var/lib/postgresql/data
# Только loopback, для своих pytest-тестов из venv. API-реплики ходят в БД по внутренней сети.
ports:
- "127.0.0.1:${POSTGRES_HOST_PORT:-5432}:5432"
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 10
start_period: 10s
deploy:
resources:
limits:
cpus: "1.0"
memory: 512M
restart: unless-stopped
# Разовая задача: ОДИН контейнер применяет миграции и завершается с кодом 0.
# Реплики API миграции не запускают, поэтому гонки при старте нет (плюс advisory lock в migrations/env.py).
migrate:
build: *app-build
image: mtusi-messenger:lab4
command: ["python", "-m", "alembic", "upgrade", "head"]
# HEALTHCHECK образа проверяет HTTP-сервер API, а здесь сервера нет: иначе статус был бы unhealthy.
healthcheck:
disable: true
environment: &app-env
APP_CONFIG__DB__HOST: postgres
APP_CONFIG__DB__PORT: "5432"
APP_CONFIG__DB__NAME: messenger
APP_CONFIG__DB__USER: messenger
APP_CONFIG__DB__PASSWORD_FILE: /run/secrets/postgres_password
APP_CONFIG__JWT__SECRET_FILE: /run/secrets/jwt_secret
APP_CONFIG__JWT__SESSION_TTL_SECONDS: ${APP_CONFIG__JWT__SESSION_TTL_SECONDS:-3600}
APP_CONFIG__LOGGING__LEVEL: ${APP_CONFIG__LOGGING__LEVEL:-INFO}
APP_CONFIG__S3__ENDPOINT: http://minio:9000
APP_CONFIG__S3__BUCKET: ${S3_BUCKET:-messenger-attachments}
APP_CONFIG__S3__ACCESS_KEY_FILE: /run/secrets/s3_access_key_id
APP_CONFIG__S3__SECRET_KEY_FILE: /run/secrets/s3_secret_access_key
APP_CONFIG__ATTACHMENTS__MAX_CONCURRENT_UPLOADS: ${UPLOAD_CONCURRENCY:-8}
APP_CONFIG__RECONCILE__GRACE_SECONDS: ${RECONCILE_GRACE_SECONDS:-3600}
secrets:
- postgres_password
depends_on:
postgres:
condition: service_healthy
deploy:
resources:
limits:
cpus: "0.5"
memory: 256M
restart: "no"
# Периодическая сверка S3 и PostgreSQL (app/maintenance/reconcile.py): удаляет объекты без метаданных
# и метаданные без объекта, не прикреплённые к сообщениям, — только старше grace period (1 ч) и не больше
# 100 за запуск; остальные расхождения только в лог. Отказ БД/S3 — пропуск цикла.
reconciler:
build: *app-build
image: mtusi-messenger:lab4
command:
- /bin/sh
- -c
- >-
while true; do
python -m maintenance.reconcile --apply > /dev/null;
sleep $${RECONCILE_INTERVAL_SECONDS};
done
healthcheck:
disable: true
environment:
<<: *app-env
RECONCILE_INTERVAL_SECONDS: ${RECONCILE_INTERVAL_SECONDS:-600}
secrets:
- postgres_password
- s3_access_key_id
- s3_secret_access_key
dns_opt:
- "timeout:1"
- "attempts:1"
depends_on:
migrate:
condition: service_completed_successfully
minio-init:
condition: service_completed_successfully
deploy:
resources:
limits:
cpus: "0.25"
memory: 128M
# SIGTERM для sh в цикле не прерывает sleep; ждать незачем — состояния нет.
stop_grace_period: 2s
restart: unless-stopped
# S3-совместимое хранилище. Официальные образы MinIO больше не публикуются; это сборка последнего
# официального релиза RELEASE.2025-10-15T17-29-55Z (coollabsio), закреплённая по digest.
minio:
image: coollabsio/minio:RELEASE.2025-10-15T17-29-55Z@sha256:69b55a1c1c5dc285ce04db96689f5b2102317fc77a50680a1874ca6efd1c87f9
# Root-credentials читаются из Docker secrets внутри контейнера и в конфигурации Compose не видны.
entrypoint: ["/bin/sh", "-c"]
command:
- >-
MINIO_ROOT_USER="$$(cat /run/secrets/minio_root_user)"
MINIO_ROOT_PASSWORD="$$(cat /run/secrets/minio_root_password)"
exec minio server /data --address :9000
environment:
# Веб-консоль выключена: администрирование только через mc из minio-init.
MINIO_BROWSER: "off"
secrets:
- minio_root_user
- minio_root_password
volumes:
- minio_data:/data
# Только loopback: проверка «прямой анонимный GET не отдаёт объект» и сверка хранилищ с хоста.
# API ходит в MinIO по внутренней сети, клиенты — только через API.
ports:
- "127.0.0.1:${MINIO_HOST_PORT:-9000}:9000"
healthcheck:
# /minio/health/live без авторизации; mc уже есть в образе (curl/wget нет).
test: ["CMD", "mc", "ready", "local"]
interval: 5s
timeout: 3s
retries: 10
start_period: 10s
deploy:
resources:
limits:
# MinIO считает хеши каждого объекта; на 1 CPU 20 одновременных PUT по 10 MiB шли рывками.
cpus: "2.0"
memory: 1G
restart: unless-stopped
# Разовая идемпотентная настройка: приватный bucket, политика и отдельный пользователь для API.
minio-init:
image: coollabsio/minio:RELEASE.2025-10-15T17-29-55Z@sha256:69b55a1c1c5dc285ce04db96689f5b2102317fc77a50680a1874ca6efd1c87f9
entrypoint: ["/bin/sh", "/bootstrap.sh"]
environment:
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
S3_TEST_BUCKET: ${S3_TEST_BUCKET:-messenger-attachments-test}
S3_BENCH_BUCKET: ${S3_BENCH_BUCKET:-messenger-attachments-bench}
volumes:
- ./infra/minio/bootstrap.sh:/bootstrap.sh:ro
secrets:
- minio_root_user
- minio_root_password
- s3_access_key_id
- s3_secret_access_key
healthcheck:
disable: true
depends_on:
minio:
condition: service_healthy
restart: "no"
# Масштабируется: API_REPLICAS (по умолчанию 2). Нет container_name и нет published ports.
# Локального состояния нет: данные и сессии в PostgreSQL, байты вложений в MinIO.
api:
build: *app-build
image: mtusi-messenger:lab4
# Без env_file: в .env адреса для запуска из venv, а не из контейнера.
environment: *app-env
secrets:
- postgres_password
- jwt_secret
# Только ключи пользователя messenger-api; root-credentials MinIO у API нет.
- s3_access_key_id
- s3_secret_access_key
# Имя остановленного контейнера (minio, postgres) должно резолвиться в ошибку за 1 с, а не ~8 с.
dns_opt:
- "timeout:1"
- "attempts:1"
expose:
- "8080"
depends_on:
postgres:
condition: service_healthy
migrate:
condition: service_completed_successfully
minio-init:
condition: service_completed_successfully
deploy:
replicas: ${API_REPLICAS:-2}
resources:
limits:
# Argon2id (64 MiB на каждый одновременный хеш) — самое тяжёлое место: на 0.5 CPU вход занимал 1.2–1.7 с.
cpus: "1.0"
memory: 512M
pids: 200
# SIGTERM: drain_seconds (3) + graceful_timeout (5) = 8 с, запас до SIGKILL.
stop_grace_period: 15s
restart: unless-stopped
lb:
image: haproxy:3.0.29-alpine@sha256:56b887da77428b7a6621e59e480cdbd330cc805c22d3cedb66ceea76ffdea2c6
volumes:
- ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
ports:
# Публичная точка входа; порт на хосте меняется через LB_HOST_PORT, если 8080 занят.
- "127.0.0.1:${LB_HOST_PORT:-8080}:8080"
depends_on:
api:
condition: service_healthy
healthcheck:
# Через собственный порт LB: 200 только если есть хотя бы одна живая реплика.
test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1:8080/health/live"]
interval: 5s
timeout: 3s
retries: 5
start_period: 5s
deploy:
resources:
limits:
cpus: "0.5"
memory: 128M
restart: unless-stopped
volumes:
postgres_data:
minio_data:
secrets:
postgres_password:
file: ./secrets/postgres_password
jwt_secret:
file: ./secrets/jwt_secret
minio_root_user:
file: ./secrets/minio_root_user
minio_root_password:
file: ./secrets/minio_root_password
s3_access_key_id:
file: ./secrets/s3_access_key_id
s3_secret_access_key:
file: ./secrets/s3_secret_access_key
+47
View File
@@ -0,0 +1,47 @@
{
"fixture_bytes": 111817,
"fixture_sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75",
"upload": {
"status": 201,
"instance": "e4717834ab4f",
"sha256_matches": true
},
"download_after_stop": {
"status": 200,
"instance": "aeca84df3cdc",
"sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75",
"content_type": "image/png",
"seconds_after_stop": 0.09,
"different_instance": true,
"sha256_matches": true
},
"outsider": {
"metadata_status": 404,
"content_status": 404
},
"direct_s3_anonymous": {
"get_object_status": 403,
"list_bucket_status": 403
},
"api_mounts": {
"aeca84df3cdc": [
{
"type": "bind",
"destination": "/run/secrets/jwt_secret"
},
{
"type": "bind",
"destination": "/run/secrets/postgres_password"
},
{
"type": "bind",
"destination": "/run/secrets/s3_access_key_id"
},
{
"type": "bind",
"destination": "/run/secrets/s3_secret_access_key"
}
]
},
"result": "PASS"
}
+9
View File
@@ -0,0 +1,9 @@
api: image=mtusi-messenger:lab4 replicas=2 published_ports=[] container_name=None limits={cpus: 1, memory: 536870912, pids: 200} secrets=['postgres_password', 'jwt_secret', 's3_access_key_id', 's3_secret_access_key']
lb: image=haproxy:3.0.29-alpine@sha256:56b887da77428b7a6621e59e480cdbd330cc805c22d3cedb66ceea76ffdea2c6 replicas=1 published_ports=['127.0.0.1:8080->8080'] container_name=None limits={cpus: 0.5, memory: 134217728, pids: None} secrets=[]
migrate: image=mtusi-messenger:lab4 replicas=1 published_ports=[] container_name=None limits={cpus: 0.5, memory: 268435456, pids: None} secrets=['postgres_password']
minio: image=coollabsio/minio:RELEASE.2025-10-15T17-29-55Z@sha256:69b55a1c1c5dc285ce04db96689f5b2102317fc77a50680a1874ca6efd1c87f9 replicas=1 published_ports=['127.0.0.1:19000->9000'] container_name=None limits={cpus: 2, memory: 1073741824, pids: None} secrets=['minio_root_user', 'minio_root_password']
MINIO_BROWSER=off
minio-init: image=coollabsio/minio:RELEASE.2025-10-15T17-29-55Z@sha256:69b55a1c1c5dc285ce04db96689f5b2102317fc77a50680a1874ca6efd1c87f9 replicas=1 published_ports=[] container_name=None limits={cpus: None, memory: None, pids: None} secrets=['minio_root_user', 'minio_root_password', 's3_access_key_id', 's3_secret_access_key']
postgres: image=postgres:17.10-alpine@sha256:979c4379dd698aba0b890599a6104e082035f98ef31d9b9291ec22f2b13059ca replicas=1 published_ports=['127.0.0.1:5432->5432'] container_name=None limits={cpus: 1, memory: 536870912, pids: None} secrets=['postgres_password']
reconciler: image=mtusi-messenger:lab4 replicas=1 published_ports=[] container_name=None limits={cpus: 0.25, memory: 134217728, pids: None} secrets=['postgres_password', 's3_access_key_id', 's3_secret_access_key']
volumes: ['minio_data', 'postgres_data']
+24
View File
@@ -0,0 +1,24 @@
# make test-failover ACTION_SCRIPT=scripts/stop-one.cmd; then restore-replicas and repeat for the other replica
## run 1, before
mtusi-lab4-api-1 e4717834ab4f | Up 15 seconds (healthy)
mtusi-lab4-api-2 aeca84df3cdc | Up 14 seconds (healthy)
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 82, "failed_attempts": 0, "first_recovery_seconds": 4.716}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
exit=0
## run 1, after hook
mtusi-lab4-api-1 e4717834ab4f | Exited (0) 11 seconds ago
mtusi-lab4-api-2 aeca84df3cdc | Up 36 seconds (healthy)
## run 2, before
mtusi-lab4-api-1 e4717834ab4f | Up 7 seconds (healthy)
mtusi-lab4-api-2 aeca84df3cdc | Up 55 seconds (healthy)
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 83, "failed_attempts": 0, "first_recovery_seconds": 5.739}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
exit=0
## run 2, after hook
mtusi-lab4-api-1 e4717834ab4f | Up 30 seconds (healthy)
mtusi-lab4-api-2 aeca84df3cdc | Exited (0) 10 seconds ago
## restored
mtusi-lab4-api-1 e4717834ab4f | Up 48 seconds (healthy)
mtusi-lab4-api-2 aeca84df3cdc | Up 8 seconds (healthy)
+68
View File
@@ -0,0 +1,68 @@
{
"start": {
"attachment_rows": 545,
"objects": 545
},
"after_interrupted_upload": {
"attachment_rows": 545,
"objects": 545
},
"api_logged_interrupt": true,
"after_orphans_injected": {
"attachment_rows": 545,
"objects": 548
},
"cleanup_dry_run_grace_default": {
"mode": "dry-run",
"grace_seconds": 3600,
"objects_scanned": 548,
"ok": 545,
"orphans_fresh_kept": 3,
"orphans_found": 0,
"deleted": 0,
"seconds": 0.762
},
"cleanup_dry_run_grace_0": {
"mode": "dry-run",
"grace_seconds": 0,
"objects_scanned": 548,
"ok": 545,
"orphans_fresh_kept": 0,
"orphans_found": 3,
"deleted": 0,
"seconds": 0.988
},
"after_dry_runs": {
"attachment_rows": 545,
"objects": 548
},
"cleanup_apply_grace_0": {
"mode": "apply",
"grace_seconds": 0,
"objects_scanned": 548,
"ok": 545,
"orphans_fresh_kept": 0,
"orphans_found": 3,
"deleted": 3,
"seconds": 0.934
},
"cleanup_apply_again": {
"mode": "apply",
"grace_seconds": 0,
"objects_scanned": 545,
"ok": 545,
"orphans_fresh_kept": 0,
"orphans_found": 0,
"deleted": 0,
"seconds": 0.968
},
"end": {
"attachment_rows": 545,
"objects": 545
},
"kept_attachment_download": {
"status": 200,
"sha256_matches": true
},
"result": "PASS"
}
+29
View File
@@ -0,0 +1,29 @@
# make test-persistence ACTION_SCRIPT=scripts/restart.cmd (stops lb, api, postgres, minio; volumes kept)
## before
mtusi-lab4-api-1 | Up 20 seconds (healthy)
mtusi-lab4-api-2 | Up 20 seconds (healthy)
mtusi-lab4-lb-1 | Up 2 hours (healthy)
mtusi-lab4-migrate-1 | Exited (0) 21 seconds ago
mtusi-lab4-minio-1 | Up 2 hours (healthy)
mtusi-lab4-minio-init-1 | Exited (0) 27 seconds ago
mtusi-lab4-postgres-1 | Up 3 hours (healthy)
mtusi-lab4-reconciler-1 | Up 19 seconds
/mtusi-lab4-postgres-1 StartedAt=2026-11-12T10:59:08.23975453Z
/mtusi-lab4-minio-1 StartedAt=2026-11-12T11:01:27.455198717Z
## test
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
exit=0
## after
mtusi-lab4-api-1 | Up 14 seconds (healthy)
mtusi-lab4-api-2 | Up 14 seconds (healthy)
mtusi-lab4-lb-1 | Up 6 seconds (healthy)
mtusi-lab4-migrate-1 | Exited (0) 15 seconds ago
mtusi-lab4-minio-1 | Up 32 seconds (healthy)
mtusi-lab4-minio-init-1 | Exited (0) 22 seconds ago
mtusi-lab4-postgres-1 | Up 31 seconds (healthy)
mtusi-lab4-reconciler-1 | Up About a minute
/mtusi-lab4-postgres-1 StartedAt=2026-11-12T13:29:39.704778557Z
/mtusi-lab4-minio-1 StartedAt=2026-11-12T13:29:38.729925744Z
volume mtusi-lab4_minio_data
volume mtusi-lab4_postgres_data
+107
View File
@@ -0,0 +1,107 @@
============================= test session starts =============================
platform win32 -- Python 3.14.3, pytest-9.1.1, pluggy-1.7.0 -- D:\диск С\Документы\unic\VP\lab4\mtusi2026lab4\.venv\Scripts\python.exe
rootdir: D:\диск С\Документы\unic\VP\lab4\mtusi2026lab4
configfile: pytest.ini
testpaths: student-tests
plugins: anyio-4.15.1
collecting ... collected 97 items
student-tests/test_attachments_api.py::test_upload_png_and_download_by_other_member PASSED [ 1%]
student-tests/test_attachments_api.py::test_upload_jpeg_with_unicode_filename PASSED [ 2%]
student-tests/test_attachments_api.py::test_message_with_attachments_keeps_order_and_is_readable PASSED [ 3%]
student-tests/test_attachments_api.py::test_missing_attachment_ids_equals_empty_list_for_idempotency PASSED [ 4%]
student-tests/test_attachments_api.py::test_too_large_file_is_rejected_before_reading PASSED [ 5%]
student-tests/test_attachments_api.py::test_too_large_stream_without_content_length PASSED [ 6%]
student-tests/test_attachments_api.py::test_exactly_max_bytes_is_accepted PASSED [ 7%]
student-tests/test_attachments_api.py::test_pixel_limit_checked_from_header PASSED [ 8%]
student-tests/test_attachments_api.py::test_corrupted_image_is_415[truncated-png] PASSED [ 9%]
student-tests/test_attachments_api.py::test_corrupted_image_is_415[png-bad-crc] PASSED [ 10%]
student-tests/test_attachments_api.py::test_corrupted_image_is_415[truncated-jpeg] PASSED [ 11%]
student-tests/test_attachments_api.py::test_corrupted_image_is_415[png-signature-only] PASSED [ 12%]
student-tests/test_attachments_api.py::test_corrupted_image_is_415[text] PASSED [ 13%]
student-tests/test_attachments_api.py::test_mime_spoofing_is_415[png-as-jpeg] PASSED [ 14%]
student-tests/test_attachments_api.py::test_mime_spoofing_is_415[jpeg-as-png] PASSED [ 15%]
student-tests/test_attachments_api.py::test_mime_spoofing_is_415[png-as-text] PASSED [ 16%]
student-tests/test_attachments_api.py::test_mime_spoofing_is_415[png-as-gif] PASSED [ 17%]
student-tests/test_attachments_api.py::test_mime_spoofing_is_415[gif-as-png] PASSED [ 18%]
student-tests/test_attachments_api.py::test_empty_body_is_400 PASSED [ 19%]
student-tests/test_attachments_api.py::test_dangerous_filename_is_400[a/b.png] PASSED [ 20%]
student-tests/test_attachments_api.py::test_dangerous_filename_is_400[..\\evil.png] PASSED [ 21%]
student-tests/test_attachments_api.py::test_dangerous_filename_is_400[a\x00b.png] PASSED [ 22%]
student-tests/test_attachments_api.py::test_dangerous_filename_is_400[line\nbreak.png] PASSED [ 23%]
student-tests/test_attachments_api.py::test_dangerous_filename_is_400[tab\t.png] PASSED [ 24%]
student-tests/test_attachments_api.py::test_dangerous_filename_is_400[ ] PASSED [ 25%]
student-tests/test_attachments_api.py::test_dangerous_filename_is_400[..] PASSED [ 26%]
student-tests/test_attachments_api.py::test_dangerous_filename_is_400[xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx] PASSED [ 27%]
student-tests/test_attachments_api.py::test_missing_filename_is_400 PASSED [ 28%]
student-tests/test_attachments_api.py::test_outsider_cannot_upload_or_read PASSED [ 29%]
student-tests/test_attachments_api.py::test_unknown_and_unauthenticated PASSED [ 30%]
student-tests/test_attachments_api.py::test_missing_variant_is_404_and_bad_variant_is_400 PASSED [ 31%]
student-tests/test_attachments_api.py::test_foreign_attachment_id_in_message_is_404 PASSED [ 32%]
student-tests/test_attachments_api.py::test_database_rejects_link_to_attachment_of_other_chat PASSED [ 34%]
student-tests/test_attachments_api.py::test_invalid_message_attachments_are_400[11-ids] PASSED [ 35%]
student-tests/test_attachments_api.py::test_invalid_message_attachments_are_400[blank-text] PASSED [ 36%]
student-tests/test_attachments_api.py::test_invalid_message_attachments_are_400[empty-without-attachments] PASSED [ 37%]
student-tests/test_attachments_api.py::test_invalid_message_attachments_are_400[bad-uuid] PASSED [ 38%]
student-tests/test_attachments_api.py::test_duplicate_attachment_ids_are_400 PASSED [ 39%]
student-tests/test_attachments_api.py::test_storage_down_on_upload_is_503_without_metadata PASSED [ 40%]
student-tests/test_attachments_api.py::test_storage_down_on_download_is_503 PASSED [ 41%]
student-tests/test_attachments_api.py::test_commit_failure_after_put_deletes_object PASSED [ 42%]
student-tests/test_attachments_api.py::test_orphan_left_by_failed_compensation_is_removed_only_after_grace PASSED [ 43%]
student-tests/test_attachments_api.py::test_upload_slots_exhausted_is_503 PASSED [ 44%]
student-tests/test_attachments_api.py::test_bucket_is_private_outside_api PASSED [ 45%]
student-tests/test_attachments_api.py::test_api_credentials_cannot_administer_storage PASSED [ 46%]
student-tests/test_auth_api.py::test_login_returns_session PASSED [ 47%]
student-tests/test_auth_api.py::test_jwt_payload_contains_sub_exp_jti PASSED [ 48%]
student-tests/test_auth_api.py::test_wrong_password_and_unknown_user_give_same_401 PASSED [ 49%]
student-tests/test_auth_api.py::test_malformed_basic_returns_401 PASSED [ 50%]
student-tests/test_auth_api.py::test_login_with_body_returns_400_and_creates_no_session PASSED [ 51%]
student-tests/test_auth_api.py::test_password_with_colon_and_unicode PASSED [ 52%]
student-tests/test_auth_api.py::test_protected_endpoint_requires_bearer PASSED [ 53%]
student-tests/test_auth_api.py::test_x_user_id_does_not_override_token PASSED [ 54%]
student-tests/test_auth_api.py::test_forged_token_is_rejected PASSED [ 55%]
student-tests/test_auth_api.py::test_logout_revokes_only_current_token PASSED [ 56%]
student-tests/test_auth_api.py::test_session_expires PASSED [ 57%]
student-tests/test_chats_api.py::test_unknown_member_returns_400_and_nothing_is_saved PASSED [ 58%]
student-tests/test_chats_api.py::test_created_chat_is_stored_with_members PASSED [ 59%]
student-tests/test_chats_api.py::test_foreign_chat_returns_404 PASSED [ 60%]
student-tests/test_chats_api.py::test_member_sees_chat PASSED [ 61%]
student-tests/test_chats_api.py::test_creator_must_be_member PASSED [ 62%]
student-tests/test_chats_api.py::test_duplicate_members_return_400 PASSED [ 63%]
student-tests/test_idempotency_api.py::test_missing_or_invalid_key_returns_400 PASSED [ 64%]
student-tests/test_idempotency_api.py::test_valid_key_alphabet_and_max_length PASSED [ 65%]
student-tests/test_idempotency_api.py::test_replay_returns_same_message_without_duplicate PASSED [ 67%]
student-tests/test_idempotency_api.py::test_json_key_order_and_whitespace_do_not_matter PASSED [ 68%]
student-tests/test_idempotency_api.py::test_same_key_with_other_body_returns_409 PASSED [ 69%]
student-tests/test_idempotency_api.py::test_key_scope_is_user_and_chat PASSED [ 70%]
student-tests/test_idempotency_api.py::test_replay_still_checks_session_and_membership PASSED [ 71%]
student-tests/test_idempotency_api.py::test_failed_request_does_not_consume_key PASSED [ 72%]
student-tests/test_idempotency_api.py::test_expired_key_is_reusable PASSED [ 73%]
student-tests/test_idempotency_api.py::test_concurrent_requests_with_one_key_create_one_message PASSED [ 74%]
student-tests/test_idempotency_api.py::test_concurrent_different_bodies_one_key_only_one_wins PASSED [ 75%]
student-tests/test_idempotency_api.py::test_instance_id_header_is_present_and_stable PASSED [ 76%]
student-tests/test_idempotency_api.py::test_ready_returns_503_while_draining PASSED [ 77%]
student-tests/test_messages_api.py::test_empty_message_returns_400 PASSED [ 78%]
student-tests/test_messages_api.py::test_sender_is_taken_from_token PASSED [ 79%]
student-tests/test_messages_api.py::test_pagination_over_several_pages PASSED [ 80%]
student-tests/test_messages_api.py::test_cursor_from_another_chat_returns_400 PASSED [ 81%]
student-tests/test_messages_api.py::test_invalid_limit_returns_400 PASSED [ 82%]
student-tests/test_reconcile.py::test_detects_both_sides_and_fixes_only_safe_cases PASSED [ 83%]
student-tests/test_reconcile.py::test_message_cannot_use_attachment_removed_by_reconcile PASSED [ 84%]
student-tests/test_reconcile.py::test_old_orphans_deleted_and_used_objects_kept PASSED [ 85%]
student-tests/test_reconcile.py::test_apply_refuses_mass_delete PASSED [ 86%]
student-tests/test_reconcile.py::test_recheck_keeps_object_whose_metadata_appeared_after_listing PASSED [ 87%]
student-tests/test_reconcile.py::test_recheck_keeps_row_that_got_referenced PASSED [ 88%]
student-tests/test_reconcile.py::test_second_run_is_refused_while_first_holds_lock PASSED [ 89%]
student-tests/test_reconcile.py::test_unordered_stream_aborts PASSED [ 90%]
student-tests/test_users_api.py::test_invalid_json_returns_400 PASSED [ 91%]
student-tests/test_users_api.py::test_extra_field_and_wrong_type_return_400 PASSED [ 92%]
student-tests/test_users_api.py::test_duplicate_username_returns_409 PASSED [ 93%]
student-tests/test_users_api.py::test_unicode_display_name_is_kept PASSED [ 94%]
student-tests/test_users_api.py::test_password_is_required_and_length_checked PASSED [ 95%]
student-tests/test_users_api.py::test_password_is_hashed_and_never_returned PASSED [ 96%]
student-tests/test_users_api.py::test_me_returns_current_user PASSED [ 97%]
student-tests/test_users_api.py::test_x_user_id_no_longer_authenticates PASSED [ 98%]
student-tests/test_users_api.py::test_every_response_has_request_id PASSED [100%]
======================= 97 passed in 170.00s (0:02:50) ========================
+396
View File
@@ -0,0 +1,396 @@
{
"object_size_bytes": 1024,
"reconciler_limits": "0.25 CPU, 128 MiB",
"runs": [
{
"objects": 1000,
"seed_seconds": 23.4,
"rows_plan": "Sort (cost=92.33..94.83 rows=1000 width=47)",
"s3_list_requests": 1,
"shallow": [
{
"mode": "dry-run",
"grace_seconds": 0,
"verify_checksums": false,
"objects_scanned": 1000,
"rows_scanned": 1000,
"ok": 1000,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 0,
"missing_object": 0,
"missing_object_referenced": 0,
"missing_object_fresh": 0,
"size_mismatch": 0,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 1.524,
"total": 1.524
},
"bytes_read": 0,
"peak_rss_mib": 87.7
},
{
"mode": "dry-run",
"grace_seconds": 0,
"verify_checksums": false,
"objects_scanned": 1000,
"rows_scanned": 1000,
"ok": 1000,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 0,
"missing_object": 0,
"missing_object_referenced": 0,
"missing_object_fresh": 0,
"size_mismatch": 0,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 1.215,
"total": 1.215
},
"bytes_read": 0,
"peak_rss_mib": 87.6
},
{
"mode": "dry-run",
"grace_seconds": 0,
"verify_checksums": false,
"objects_scanned": 1000,
"rows_scanned": 1000,
"ok": 1000,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 0,
"missing_object": 0,
"missing_object_referenced": 0,
"missing_object_fresh": 0,
"size_mismatch": 0,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 1.27,
"total": 1.27
},
"bytes_read": 0,
"peak_rss_mib": 87.1
}
],
"deep": [
{
"mode": "dry-run",
"grace_seconds": 0,
"verify_checksums": true,
"objects_scanned": 1000,
"rows_scanned": 1000,
"ok": 1000,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 0,
"missing_object": 0,
"missing_object_referenced": 0,
"missing_object_fresh": 0,
"size_mismatch": 0,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 10.076,
"total": 10.076
},
"bytes_read": 1024000,
"peak_rss_mib": 87.6
}
],
"shallow_median_seconds": 1.27,
"shallow_objects_per_second": 787,
"shallow_peak_rss_mib": 87.7,
"shallow_all_ok": true,
"deep_median_seconds": 10.076,
"deep_objects_per_second": 99,
"deep_peak_rss_mib": 87.6,
"deep_all_ok": true
},
{
"objects": 10000,
"seed_seconds": 93.8,
"rows_plan": "Index Only Scan using attachments_object_key_key on attachments (cost=0.29..685.28 rows=9999 width=47)",
"s3_list_requests": 10,
"shallow": [
{
"mode": "dry-run",
"grace_seconds": 0,
"verify_checksums": false,
"objects_scanned": 10000,
"rows_scanned": 10000,
"ok": 10000,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 0,
"missing_object": 0,
"missing_object_referenced": 0,
"missing_object_fresh": 0,
"size_mismatch": 0,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 6.315,
"total": 6.315
},
"bytes_read": 0,
"peak_rss_mib": 88.9
},
{
"mode": "dry-run",
"grace_seconds": 0,
"verify_checksums": false,
"objects_scanned": 10000,
"rows_scanned": 10000,
"ok": 10000,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 0,
"missing_object": 0,
"missing_object_referenced": 0,
"missing_object_fresh": 0,
"size_mismatch": 0,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 6.387,
"total": 6.387
},
"bytes_read": 0,
"peak_rss_mib": 89.5
},
{
"mode": "dry-run",
"grace_seconds": 0,
"verify_checksums": false,
"objects_scanned": 10000,
"rows_scanned": 10000,
"ok": 10000,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 0,
"missing_object": 0,
"missing_object_referenced": 0,
"missing_object_fresh": 0,
"size_mismatch": 0,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 7.298,
"total": 7.298
},
"bytes_read": 0,
"peak_rss_mib": 89.1
}
],
"deep": [
{
"mode": "dry-run",
"grace_seconds": 0,
"verify_checksums": true,
"objects_scanned": 10000,
"rows_scanned": 10000,
"ok": 10000,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 0,
"missing_object": 0,
"missing_object_referenced": 0,
"missing_object_fresh": 0,
"size_mismatch": 0,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 89.196,
"total": 89.196
},
"bytes_read": 10240000,
"peak_rss_mib": 88.9
}
],
"shallow_median_seconds": 6.387,
"shallow_objects_per_second": 1566,
"shallow_peak_rss_mib": 89.5,
"shallow_all_ok": true,
"deep_median_seconds": 89.196,
"deep_objects_per_second": 112,
"deep_peak_rss_mib": 88.9,
"deep_all_ok": true
},
{
"objects": 50000,
"seed_seconds": 481.7,
"rows_plan": "Index Only Scan using attachments_object_key_key on attachments (cost=0.41..3341.41 rows=49995 width=47)",
"s3_list_requests": 50,
"shallow": [
{
"mode": "dry-run",
"grace_seconds": 0,
"verify_checksums": false,
"objects_scanned": 50000,
"rows_scanned": 50000,
"ok": 50000,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 0,
"missing_object": 0,
"missing_object_referenced": 0,
"missing_object_fresh": 0,
"size_mismatch": 0,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 35.798,
"total": 35.798
},
"bytes_read": 0,
"peak_rss_mib": 89.0
},
{
"mode": "dry-run",
"grace_seconds": 0,
"verify_checksums": false,
"objects_scanned": 50000,
"rows_scanned": 50000,
"ok": 50000,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 0,
"missing_object": 0,
"missing_object_referenced": 0,
"missing_object_fresh": 0,
"size_mismatch": 0,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 34.315,
"total": 34.316
},
"bytes_read": 0,
"peak_rss_mib": 89.1
},
{
"mode": "dry-run",
"grace_seconds": 0,
"verify_checksums": false,
"objects_scanned": 50000,
"rows_scanned": 50000,
"ok": 50000,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 0,
"missing_object": 0,
"missing_object_referenced": 0,
"missing_object_fresh": 0,
"size_mismatch": 0,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 33.576,
"total": 33.576
},
"bytes_read": 0,
"peak_rss_mib": 89.3
}
],
"deep": [
{
"mode": "dry-run",
"grace_seconds": 0,
"verify_checksums": true,
"objects_scanned": 50000,
"rows_scanned": 50000,
"ok": 50000,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 0,
"missing_object": 0,
"missing_object_referenced": 0,
"missing_object_fresh": 0,
"size_mismatch": 0,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 487.616,
"total": 487.616
},
"bytes_read": 51200000,
"peak_rss_mib": 88.8
}
],
"shallow_median_seconds": 34.315,
"shallow_objects_per_second": 1457,
"shallow_peak_rss_mib": 89.3,
"shallow_all_ok": true,
"deep_median_seconds": 487.616,
"deep_objects_per_second": 103,
"deep_peak_rss_mib": 88.8,
"deep_all_ok": true
}
]
}
+278
View File
@@ -0,0 +1,278 @@
{
"objects": 10000,
"grace_seconds": 180,
"seed_seconds": 115.1,
"baseline": {
"objects": 10000,
"rows": 10000,
"referenced_rows": 5000
},
"baseline_reconcile": {
"mode": "dry-run",
"grace_seconds": 180,
"verify_checksums": false,
"objects_scanned": 10000,
"rows_scanned": 10000,
"ok": 10000,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 0,
"missing_object": 0,
"missing_object_referenced": 0,
"missing_object_fresh": 0,
"size_mismatch": 0,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 7.061,
"total": 7.061
},
"bytes_read": 0,
"peak_rss_mib": 88.8
},
"injected": {
"orphan_object": 20,
"missing_object": 10,
"missing_object_referenced": 10,
"size_mismatch": 10,
"checksum_mismatch": 10,
"orphan_object_fresh": 10,
"missing_object_fresh": 10
},
"after_injection": {
"objects": 10000,
"rows": 10000,
"referenced_rows": 5000
},
"dry_run_shallow": {
"mode": "dry-run",
"grace_seconds": 180,
"verify_checksums": false,
"objects_scanned": 10000,
"rows_scanned": 10000,
"ok": 9960,
"issues": {
"orphan_object": 20,
"orphan_object_fresh": 10,
"missing_object": 10,
"missing_object_referenced": 10,
"missing_object_fresh": 10,
"size_mismatch": 10,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 7.299,
"total": 7.299
},
"bytes_read": 0,
"peak_rss_mib": 89.6
},
"state_unchanged_after_dry_run": true,
"apply_with_brake": {
"mode": "apply",
"grace_seconds": 180,
"verify_checksums": false,
"objects_scanned": 10000,
"rows_scanned": 10000,
"ok": 9960,
"issues": {
"orphan_object": 20,
"orphan_object_fresh": 10,
"missing_object": 10,
"missing_object_referenced": 10,
"missing_object_fresh": 10,
"size_mismatch": 10,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 7.39,
"total": 7.39
},
"bytes_read": 0,
"peak_rss_mib": 89.1,
"aborted": "к удалению 30 > --max-deletes 10: ничего не изменено"
},
"state_unchanged_after_brake": true,
"apply": {
"mode": "apply",
"grace_seconds": 180,
"verify_checksums": false,
"objects_scanned": 10000,
"rows_scanned": 10000,
"ok": 9960,
"issues": {
"orphan_object": 20,
"orphan_object_fresh": 10,
"missing_object": 10,
"missing_object_referenced": 10,
"missing_object_fresh": 10,
"size_mismatch": 10,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 20,
"rows_deleted": 10,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 6.581,
"total": 7.297
},
"bytes_read": 0,
"peak_rss_mib": 89.0
},
"after_apply": {
"objects": 9980,
"rows": 9990,
"referenced_rows": 5000
},
"apply_again": {
"mode": "apply",
"grace_seconds": 180,
"verify_checksums": false,
"objects_scanned": 9980,
"rows_scanned": 9990,
"ok": 9960,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 10,
"missing_object": 0,
"missing_object_referenced": 10,
"missing_object_fresh": 10,
"size_mismatch": 10,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 7.485,
"total": 7.486
},
"bytes_read": 0,
"peak_rss_mib": 89.4
},
"fresh_still_fresh_at_apply": true,
"dry_run_deep": {
"mode": "dry-run",
"grace_seconds": 180,
"verify_checksums": true,
"objects_scanned": 9980,
"rows_scanned": 9990,
"ok": 9950,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 10,
"missing_object": 0,
"missing_object_referenced": 10,
"missing_object_fresh": 10,
"size_mismatch": 10,
"checksum_mismatch": 10
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 93.089,
"total": 93.09
},
"bytes_read": 10199040,
"peak_rss_mib": 88.8
},
"detection_exact": {
"orphan_object": true,
"missing_object": true,
"missing_object_referenced": true,
"size_mismatch": true,
"checksum_mismatch": true,
"orphan_object_fresh": true,
"missing_object_fresh": true
},
"safety": {
"referenced_rows_kept": true,
"deleted_objects_are_exactly_orphans": true,
"fresh_objects_kept": true,
"rows_deleted_exactly_missing_free": true
},
"after_grace_apply": {
"mode": "apply",
"grace_seconds": 180,
"verify_checksums": false,
"objects_scanned": 9980,
"rows_scanned": 9990,
"ok": 9960,
"issues": {
"orphan_object": 10,
"orphan_object_fresh": 0,
"missing_object": 10,
"missing_object_referenced": 10,
"missing_object_fresh": 0,
"size_mismatch": 10,
"checksum_mismatch": 0
},
"actions": {
"objects_deleted": 10,
"rows_deleted": 10,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 6.671,
"total": 7.272
},
"bytes_read": 0,
"peak_rss_mib": 89.1
},
"final_dry_run": {
"mode": "dry-run",
"grace_seconds": 180,
"verify_checksums": true,
"objects_scanned": 9970,
"rows_scanned": 9980,
"ok": 9950,
"issues": {
"orphan_object": 0,
"orphan_object_fresh": 0,
"missing_object": 0,
"missing_object_referenced": 10,
"missing_object_fresh": 0,
"size_mismatch": 10,
"checksum_mismatch": 10
},
"actions": {
"objects_deleted": 0,
"rows_deleted": 0,
"skipped_on_recheck": 0
},
"seconds": {
"scan": 95.407,
"total": 95.407
},
"bytes_read": 10199040,
"peak_rss_mib": 89.2
},
"final": {
"objects": 9970,
"rows": 9980,
"referenced_rows": 5000
},
"result": "PASS"
}
+26
View File
@@ -0,0 +1,26 @@
{
"before": {
"upload_status": 201
},
"minio_stopped": {
"ready_status": 200,
"message_status": 201,
"metadata_status": 200,
"upload": {
"status": 503,
"seconds": 1.06,
"error": "unavailable"
},
"download": {
"status": 503,
"seconds": 1.08,
"error": "unavailable"
}
},
"after_start": {
"upload_status": 201,
"recovery_seconds": 1.2,
"download_status": 200
},
"result": "PASS"
}
+6
View File
@@ -0,0 +1,6 @@
$ python scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
exit=0
$ python tests/smoke.py --base-url http://localhost:8080
PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.
exit=0
+329
View File
@@ -0,0 +1,329 @@
{
"file_bytes": 10393871,
"api_limits": "1 CPU, 512M per replica, 2 replicas",
"method": "peak RSS (VmHWM) of the API process, reset after warm-up; growth = peak after - RSS before",
"runs": [
{
"concurrency": 1,
"statuses": {
"201": 1
},
"wall_seconds": 0.49,
"latency_201_seconds": {
"p50": 0.49,
"max": 0.49
},
"replicas": {
"fd29b4d34164": {
"uploads_201": 1,
"before": {
"rss_peak_mib": 107.0,
"rss_now_mib": 107.0
},
"after": {
"rss_peak_mib": 127.1,
"rss_now_mib": 107.4
},
"rss_peak_growth_mib": 20.1
},
"43dcfb7f57f5": {
"uploads_201": 0,
"before": {
"rss_peak_mib": 107.7,
"rss_now_mib": 107.7
},
"after": {
"rss_peak_mib": 107.7,
"rss_now_mib": 107.7
},
"rss_peak_growth_mib": 0.0
}
},
"max_rss_peak_mib": 127.1,
"max_rss_peak_growth_mib": 20.1,
"upload_slots_per_replica": 8
},
{
"concurrency": 10,
"statuses": {
"201": 10
},
"wall_seconds": 2.72,
"latency_201_seconds": {
"p50": 2.66,
"max": 2.71
},
"replicas": {
"fd29b4d34164": {
"uploads_201": 5,
"before": {
"rss_peak_mib": 107.4,
"rss_now_mib": 107.4
},
"after": {
"rss_peak_mib": 201.9,
"rss_now_mib": 125.2
},
"rss_peak_growth_mib": 94.5
},
"43dcfb7f57f5": {
"uploads_201": 5,
"before": {
"rss_peak_mib": 107.7,
"rss_now_mib": 107.7
},
"after": {
"rss_peak_mib": 169.2,
"rss_now_mib": 108.6
},
"rss_peak_growth_mib": 61.5
}
},
"max_rss_peak_mib": 201.9,
"max_rss_peak_growth_mib": 94.5,
"upload_slots_per_replica": 8
},
{
"concurrency": 20,
"statuses": {
"201": 19,
"503": 1
},
"wall_seconds": 4.48,
"latency_201_seconds": {
"p50": 4.08,
"max": 4.47
},
"replicas": {
"fd29b4d34164": {
"uploads_201": 9,
"before": {
"rss_peak_mib": 125.2,
"rss_now_mib": 125.2
},
"after": {
"rss_peak_mib": 227.3,
"rss_now_mib": 116.7
},
"rss_peak_growth_mib": 102.1
},
"43dcfb7f57f5": {
"uploads_201": 10,
"before": {
"rss_peak_mib": 108.6,
"rss_now_mib": 108.6
},
"after": {
"rss_peak_mib": 221.5,
"rss_now_mib": 114.1
},
"rss_peak_growth_mib": 112.9
}
},
"max_rss_peak_mib": 227.3,
"max_rss_peak_growth_mib": 112.9,
"upload_slots_per_replica": 8
},
{
"concurrency": 40,
"statuses": {
"503": 24,
"201": 16
},
"wall_seconds": 6.7,
"latency_201_seconds": {
"p50": 6.58,
"max": 6.68
},
"replicas": {
"fd29b4d34164": {
"uploads_201": 8,
"before": {
"rss_peak_mib": 116.7,
"rss_now_mib": 116.7
},
"after": {
"rss_peak_mib": 241.6,
"rss_now_mib": 123.3
},
"rss_peak_growth_mib": 124.9
},
"43dcfb7f57f5": {
"uploads_201": 8,
"before": {
"rss_peak_mib": 114.1,
"rss_now_mib": 114.1
},
"after": {
"rss_peak_mib": 258.9,
"rss_now_mib": 137.2
},
"rss_peak_growth_mib": 144.8
}
},
"max_rss_peak_mib": 258.9,
"max_rss_peak_growth_mib": 144.8,
"upload_slots_per_replica": 8
},
{
"concurrency": 1,
"statuses": {
"201": 1
},
"wall_seconds": 0.51,
"latency_201_seconds": {
"p50": 0.51,
"max": 0.51
},
"replicas": {
"f9df3bf3edcf": {
"uploads_201": 1,
"before": {
"rss_peak_mib": 106.9,
"rss_now_mib": 106.9
},
"after": {
"rss_peak_mib": 127.9,
"rss_now_mib": 108.1
},
"rss_peak_growth_mib": 21.0
},
"efd46bda36cc": {
"uploads_201": 0,
"before": {
"rss_peak_mib": 107.3,
"rss_now_mib": 107.3
},
"after": {
"rss_peak_mib": 107.3,
"rss_now_mib": 107.3
},
"rss_peak_growth_mib": 0.0
}
},
"max_rss_peak_mib": 127.9,
"max_rss_peak_growth_mib": 21.0,
"upload_slots_per_replica": 64
},
{
"concurrency": 10,
"statuses": {
"201": 10
},
"wall_seconds": 2.99,
"latency_201_seconds": {
"p50": 2.96,
"max": 2.98
},
"replicas": {
"f9df3bf3edcf": {
"uploads_201": 5,
"before": {
"rss_peak_mib": 108.1,
"rss_now_mib": 108.1
},
"after": {
"rss_peak_mib": 187.5,
"rss_now_mib": 108.3
},
"rss_peak_growth_mib": 79.4
},
"efd46bda36cc": {
"uploads_201": 5,
"before": {
"rss_peak_mib": 107.3,
"rss_now_mib": 107.3
},
"after": {
"rss_peak_mib": 171.6,
"rss_now_mib": 112.4
},
"rss_peak_growth_mib": 64.3
}
},
"max_rss_peak_mib": 187.5,
"max_rss_peak_growth_mib": 79.4,
"upload_slots_per_replica": 64
},
{
"concurrency": 20,
"statuses": {
"201": 20
},
"wall_seconds": 4.9,
"latency_201_seconds": {
"p50": 4.74,
"max": 4.89
},
"replicas": {
"f9df3bf3edcf": {
"uploads_201": 10,
"before": {
"rss_peak_mib": 108.3,
"rss_now_mib": 108.3
},
"after": {
"rss_peak_mib": 274.8,
"rss_now_mib": 196.9
},
"rss_peak_growth_mib": 166.5
},
"efd46bda36cc": {
"uploads_201": 10,
"before": {
"rss_peak_mib": 112.4,
"rss_now_mib": 112.4
},
"after": {
"rss_peak_mib": 258.3,
"rss_now_mib": 114.2
},
"rss_peak_growth_mib": 145.9
}
},
"max_rss_peak_mib": 274.8,
"max_rss_peak_growth_mib": 166.5,
"upload_slots_per_replica": 64
},
{
"concurrency": 40,
"statuses": {
"201": 40
},
"wall_seconds": 10.49,
"latency_201_seconds": {
"p50": 10.06,
"max": 10.47
},
"replicas": {
"f9df3bf3edcf": {
"uploads_201": 20,
"before": {
"rss_peak_mib": 196.9,
"rss_now_mib": 196.9
},
"after": {
"rss_peak_mib": 400.1,
"rss_now_mib": 216.1
},
"rss_peak_growth_mib": 203.2
},
"efd46bda36cc": {
"uploads_201": 20,
"before": {
"rss_peak_mib": 114.2,
"rss_now_mib": 114.2
},
"after": {
"rss_peak_mib": 422.3,
"rss_now_mib": 193.2
},
"rss_peak_growth_mib": 308.1
}
},
"max_rss_peak_mib": 422.3,
"max_rss_peak_growth_mib": 308.1,
"upload_slots_per_replica": 64
}
]
}
+329
View File
@@ -0,0 +1,329 @@
{
"file_bytes": 10393739,
"api_limits": "1 CPU, 512M per replica, 2 replicas",
"method": "peak RSS (VmHWM) of the API process, reset after warm-up; growth = peak after - RSS before",
"runs": [
{
"concurrency": 1,
"statuses": {
"201": 1
},
"wall_seconds": 0.51,
"latency_201_seconds": {
"p50": 0.5,
"max": 0.5
},
"replicas": {
"968e3b02a6f8": {
"uploads_201": 1,
"before": {
"rss_peak_mib": 106.8,
"rss_now_mib": 106.8
},
"after": {
"rss_peak_mib": 127.7,
"rss_now_mib": 107.9
},
"rss_peak_growth_mib": 20.9
},
"f0da4f198ba9": {
"uploads_201": 0,
"before": {
"rss_peak_mib": 107.1,
"rss_now_mib": 107.1
},
"after": {
"rss_peak_mib": 107.1,
"rss_now_mib": 107.1
},
"rss_peak_growth_mib": 0.0
}
},
"max_rss_peak_mib": 127.7,
"max_rss_peak_growth_mib": 20.9,
"upload_slots_per_replica": 8
},
{
"concurrency": 10,
"statuses": {
"201": 10
},
"wall_seconds": 2.82,
"latency_201_seconds": {
"p50": 2.71,
"max": 2.81
},
"replicas": {
"968e3b02a6f8": {
"uploads_201": 5,
"before": {
"rss_peak_mib": 107.9,
"rss_now_mib": 107.9
},
"after": {
"rss_peak_mib": 188.3,
"rss_now_mib": 107.9
},
"rss_peak_growth_mib": 80.4
},
"f0da4f198ba9": {
"uploads_201": 5,
"before": {
"rss_peak_mib": 107.1,
"rss_now_mib": 107.1
},
"after": {
"rss_peak_mib": 167.8,
"rss_now_mib": 108.3
},
"rss_peak_growth_mib": 60.7
}
},
"max_rss_peak_mib": 188.3,
"max_rss_peak_growth_mib": 80.4,
"upload_slots_per_replica": 8
},
{
"concurrency": 20,
"statuses": {
"503": 4,
"201": 16
},
"wall_seconds": 4.49,
"latency_201_seconds": {
"p50": 4.33,
"max": 4.48
},
"replicas": {
"968e3b02a6f8": {
"uploads_201": 8,
"before": {
"rss_peak_mib": 107.9,
"rss_now_mib": 107.9
},
"after": {
"rss_peak_mib": 227.3,
"rss_now_mib": 110.5
},
"rss_peak_growth_mib": 119.4
},
"f0da4f198ba9": {
"uploads_201": 8,
"before": {
"rss_peak_mib": 108.3,
"rss_now_mib": 108.3
},
"after": {
"rss_peak_mib": 241.4,
"rss_now_mib": 111.3
},
"rss_peak_growth_mib": 133.1
}
},
"max_rss_peak_mib": 241.4,
"max_rss_peak_growth_mib": 133.1,
"upload_slots_per_replica": 8
},
{
"concurrency": 40,
"statuses": {
"503": 24,
"201": 16
},
"wall_seconds": 7.03,
"latency_201_seconds": {
"p50": 6.92,
"max": 7.01
},
"replicas": {
"968e3b02a6f8": {
"uploads_201": 8,
"before": {
"rss_peak_mib": 110.5,
"rss_now_mib": 110.5
},
"after": {
"rss_peak_mib": 230.3,
"rss_now_mib": 120.3
},
"rss_peak_growth_mib": 119.8
},
"f0da4f198ba9": {
"uploads_201": 8,
"before": {
"rss_peak_mib": 111.3,
"rss_now_mib": 111.3
},
"after": {
"rss_peak_mib": 241.7,
"rss_now_mib": 123.9
},
"rss_peak_growth_mib": 130.4
}
},
"max_rss_peak_mib": 241.7,
"max_rss_peak_growth_mib": 130.4,
"upload_slots_per_replica": 8
},
{
"concurrency": 1,
"statuses": {
"201": 1
},
"wall_seconds": 0.44,
"latency_201_seconds": {
"p50": 0.44,
"max": 0.44
},
"replicas": {
"c66fca7855ac": {
"uploads_201": 1,
"before": {
"rss_peak_mib": 107.2,
"rss_now_mib": 107.2
},
"after": {
"rss_peak_mib": 126.9,
"rss_now_mib": 107.1
},
"rss_peak_growth_mib": 19.7
},
"0758884d110a": {
"uploads_201": 0,
"before": {
"rss_peak_mib": 107.0,
"rss_now_mib": 107.0
},
"after": {
"rss_peak_mib": 107.0,
"rss_now_mib": 107.0
},
"rss_peak_growth_mib": 0.0
}
},
"max_rss_peak_mib": 126.9,
"max_rss_peak_growth_mib": 19.7,
"upload_slots_per_replica": 64
},
{
"concurrency": 10,
"statuses": {
"201": 10
},
"wall_seconds": 2.79,
"latency_201_seconds": {
"p50": 2.72,
"max": 2.79
},
"replicas": {
"c66fca7855ac": {
"uploads_201": 5,
"before": {
"rss_peak_mib": 107.1,
"rss_now_mib": 107.1
},
"after": {
"rss_peak_mib": 186.4,
"rss_now_mib": 108.5
},
"rss_peak_growth_mib": 79.3
},
"0758884d110a": {
"uploads_201": 5,
"before": {
"rss_peak_mib": 107.0,
"rss_now_mib": 107.0
},
"after": {
"rss_peak_mib": 168.6,
"rss_now_mib": 108.0
},
"rss_peak_growth_mib": 61.6
}
},
"max_rss_peak_mib": 186.4,
"max_rss_peak_growth_mib": 79.3,
"upload_slots_per_replica": 64
},
{
"concurrency": 20,
"statuses": {
"201": 20
},
"wall_seconds": 4.85,
"latency_201_seconds": {
"p50": 4.73,
"max": 4.84
},
"replicas": {
"c66fca7855ac": {
"uploads_201": 10,
"before": {
"rss_peak_mib": 108.5,
"rss_now_mib": 108.5
},
"after": {
"rss_peak_mib": 249.6,
"rss_now_mib": 139.7
},
"rss_peak_growth_mib": 141.1
},
"0758884d110a": {
"uploads_201": 10,
"before": {
"rss_peak_mib": 108.0,
"rss_now_mib": 108.0
},
"after": {
"rss_peak_mib": 242.8,
"rss_now_mib": 110.0
},
"rss_peak_growth_mib": 134.8
}
},
"max_rss_peak_mib": 249.6,
"max_rss_peak_growth_mib": 141.1,
"upload_slots_per_replica": 64
},
{
"concurrency": 40,
"statuses": {
"201": 40
},
"wall_seconds": 10.07,
"latency_201_seconds": {
"p50": 9.64,
"max": 10.05
},
"replicas": {
"c66fca7855ac": {
"uploads_201": 20,
"before": {
"rss_peak_mib": 139.7,
"rss_now_mib": 139.7
},
"after": {
"rss_peak_mib": 436.9,
"rss_now_mib": 245.9
},
"rss_peak_growth_mib": 297.2
},
"0758884d110a": {
"uploads_201": 20,
"before": {
"rss_peak_mib": 110.0,
"rss_now_mib": 110.0
},
"after": {
"rss_peak_mib": 404.7,
"rss_now_mib": 210.4
},
"rss_peak_growth_mib": 294.7
}
},
"max_rss_peak_mib": 436.9,
"max_rss_peak_growth_mib": 297.2,
"upload_slots_per_replica": 64
}
]
}
+68
View File
@@ -0,0 +1,68 @@
# Единственная публичная точка входа. Реплики API находятся по DNS-имени сервиса `api`
# (Docker DNS отдаёт IP всех реплик) и перечитываются каждые ~2 с, поэтому новые/пересозданные
# контейнеры подхватываются без перезапуска LB.
#
# Обнаружение отказа: проверка GET /health/ready каждую 1 с (inter), 2 неудачи подряд (fall),
# после первой неудачи период 0.5 с (fastinter) => реплика исключается за ~1.5 с, в худшем случае
# за inter + fastinter + timeout check = 1 + 0.5 + 0.5 ≈ 2 с (оценка сверху fall*inter + timeout = 2.5 с).
# Возврат в ротацию после 2 успешных проверок (rise), т.е. ~2 с после готовности реплики.
# Пока реплика не исключена, соединение к ней обрывается/отказывает и запрос сразу
# повторяется на другой реплике (retries + redispatch), поэтому клиент видит единицы ошибок.
global
log stdout format raw local0
maxconn 2000
defaults
mode http
log global
option httplog
option dontlognull
timeout connect 1s
# Больше statement_timeout БД (5 с): API успевает ответить 503 сам, а не получить обрыв от LB.
timeout server 10s
timeout client 15s
timeout http-request 10s
timeout http-keep-alive 5s
timeout queue 5s
timeout check 500ms
retries 3
# Повторять на другой реплике при каждой попытке (а не только на последней).
option redispatch 1
# 503 самого API не повторяем (lab4): он означает отказ общей зависимости (PostgreSQL или S3),
# другая реплика ответит так же, а 3 повтора только растягивают ответ до ~10 с.
retry-on conn-failure empty-response response-timeout 502 504
resolvers docker
nameserver dns 127.0.0.11:53
accepted_payload_size 8192
resolve_retries 3
timeout resolve 1s
timeout retry 1s
hold valid 2s
hold nx 2s
hold other 2s
hold refused 2s
hold timeout 2s
hold obsolete 2s
frontend public
bind :8080
default_backend api
backend api
balance roundrobin
# Никакой привязки клиента к реплике (sticky): состояние общее, сессии лежат в PostgreSQL.
# Повтор на уровне HTTP безопасен только для GET и для POST сообщения (защищён Idempotency-Key).
# Остальные POST (регистрация, вход, создание чата) повторять нельзя: сервер мог уже выполнить запрос.
acl is_message_post path_reg ^/api/v1/chats/[^/]+/messages$
http-request disable-l7-retry if METH_POST !is_message_post
option httpchk
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host api
http-check expect status 200
# Без `on-marked-down shutdown-sessions`: при выводе реплики из ротации начатые запросы не обрываются,
# реплика (drain) их дообслуживает. С этой опцией эксперимент давал 6–8 RemoteDisconnected на каждую остановку.
default-server check inter 1s fastinter 500ms downinter 1s fall 2 rise 2 resolvers docker resolve-prefer ipv4 init-addr none
server-template api 6 api:8080
+57
View File
@@ -0,0 +1,57 @@
#!/bin/sh
# Разовая идемпотентная настройка MinIO (сервис minio-init). Повторный запуск ничего не ломает:
# bucket создаётся только если его нет, политика и пользователь перезаписываются теми же значениями.
set -eu
BUCKET="${S3_BUCKET:-messenger-attachments}"
# Отдельный bucket для своих pytest-тестов: тестовые объекты не смешиваются с рабочими.
TEST_BUCKET="${S3_TEST_BUCKET:-messenger-attachments-test}"
# Bucket экспериментов сверки хранилищ (трек 2): синтетические данные и внедрённые ошибки.
BENCH_BUCKET="${S3_BENCH_BUCKET:-messenger-attachments-bench}"
ROOT_USER="$(cat /run/secrets/minio_root_user)"
ROOT_PASSWORD="$(cat /run/secrets/minio_root_password)"
API_ACCESS_KEY="$(cat /run/secrets/s3_access_key_id)"
API_SECRET_KEY="$(cat /run/secrets/s3_secret_access_key)"
# Alias через переменную окружения: credentials не пишутся в конфиг mc на диске.
# Секреты из init-secrets состоят только из [A-Za-z0-9], поэтому их можно вставить в URL как есть.
export MC_HOST_root="http://${ROOT_USER}:${ROOT_PASSWORD}@minio:9000"
# 1. Приватные bucket: анонимный доступ выключен явно.
for name in "${BUCKET}" "${TEST_BUCKET}" "${BENCH_BUCKET}"; do
mc mb --ignore-existing "root/${name}"
mc anonymous set private "root/${name}"
done
# 2. Политика API: только объекты своих bucket, без админских прав и без доступа к другим bucket.
# ListBucket нужен очистке объектов без метаданных.
cat > /tmp/messenger-api-policy.json <<EOF
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
"Resource": ["arn:aws:s3:::${BUCKET}/*", "arn:aws:s3:::${TEST_BUCKET}/*", "arn:aws:s3:::${BENCH_BUCKET}/*"]
},
{
"Effect": "Allow",
"Action": ["s3:ListBucket", "s3:GetBucketLocation"],
"Resource": ["arn:aws:s3:::${BUCKET}", "arn:aws:s3:::${TEST_BUCKET}", "arn:aws:s3:::${BENCH_BUCKET}"]
}
]
}
EOF
mc admin policy create root messenger-api /tmp/messenger-api-policy.json
# 3. Отдельный пользователь для API (не root). add с тем же ключом обновляет секрет.
mc admin user add root "${API_ACCESS_KEY}" "${API_SECRET_KEY}" >/dev/null
# Повторный attach той же политики mc считает ошибкой, поэтому сначала проверяем (grep в образе нет — case).
USER_INFO="$(mc admin user info root "${API_ACCESS_KEY}" --json)"
case "${USER_INFO}" in
*'"messenger-api"'*) echo "policy messenger-api already attached" ;;
# Вывод mc содержит access key — в лог его не пишем.
*) mc admin policy attach root messenger-api --user "${API_ACCESS_KEY}" >/dev/null ;;
esac
echo "bootstrap ok: buckets=${BUCKET},${TEST_BUCKET},${BENCH_BUCKET} (private), api user with policy messenger-api"
+5
View File
@@ -0,0 +1,5 @@
[pytest]
testpaths = student-tests
pythonpath = app
filterwarnings =
ignore:Using .httpx. with .starlette.testclient. is deprecated
+3
View File
@@ -0,0 +1,3 @@
-r requirements.txt
pytest==9.1.1
httpx==0.28.1
+31
View File
@@ -0,0 +1,31 @@
fastapi==0.141.1
starlette==1.7.0
pydantic==2.13.5
pydantic_core==2.46.5
pydantic-settings==2.15.0
python-dotenv==1.2.3
uvicorn==0.54.0
annotated-doc==0.0.5
annotated-types==0.8.0
anyio==4.15.1
click==8.5.0
h11==0.16.0
idna==3.20
typing-inspection==0.4.4
typing_extensions==4.16.0
SQLAlchemy==2.1.4
psycopg==3.3.6
psycopg-binary==3.3.6
alembic==1.20.0
Mako==1.4.3
MarkupSafe==3.0.4
argon2-cffi==25.1.0
argon2-cffi-bindings==26.1.0
cffi==2.1.1
pycparser==3.11
PyJWT==2.15.1
minio==7.2.20
urllib3==2.8.0
certifi==2026.10.23
pycryptodome==4.4.0
pillow==13.0.0
+167
View File
@@ -0,0 +1,167 @@
#!/usr/bin/env python3
"""Доказательства уровня 3 по вложениям (стенд уже запущен; только стандартная библиотека).
1. Загрузка через LB -> запоминаем X-Instance-Id обслужившей реплики -> останавливаем именно её
(scripts/stop-one.*) -> второй участник скачивает файл через LB: отвечает другая реплика, SHA-256 тот же.
2. Посторонний получает 404 на метаданные и на байты.
3. Прямой анонимный GET объекта и листинг bucket в MinIO (минуя API) отклоняются.
4. У API-контейнеров нет volume: единственные монтирования — Docker secrets.
В конце остановленная реплика возвращается (docker compose up --no-recreate). Токены не печатаются.
python scripts/attachment_checks.py --base-url http://localhost:8080 --s3-url http://127.0.0.1:9000
"""
import argparse
import base64
import hashlib
import json
import os
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
FIXTURE = ROOT / "tests" / "fixtures" / "sample.png"
PROJECT = "mtusi-lab4"
def request(method, url, body=None, headers=None, timeout=15):
req = urllib.request.Request(url, data=body, method=method, headers=headers or {})
try:
with urllib.request.urlopen(req, timeout=timeout) as resp:
return resp.status, resp.headers, resp.read()
except urllib.error.HTTPError as exc:
return exc.code, exc.headers, exc.read()
def api_json(base, method, path, token=None, payload=None, headers=None, expect=200):
all_headers = dict(headers or {})
body = None
if payload is not None:
body = json.dumps(payload).encode()
all_headers["Content-Type"] = "application/json"
if token:
all_headers["Authorization"] = "Bearer " + token
status, resp_headers, data = request(method, base + path, body, all_headers)
if status != expect:
raise SystemExit(f"{method} {path}: ожидали {expect}, получили {status}")
return resp_headers, json.loads(data) if data else None
def new_user(base, name):
username = f"{name}_{uuid.uuid4().hex[:10]}"
password = "attachment-check-" + uuid.uuid4().hex[:8]
_, user = api_json(base, "POST", "/api/v1/users", expect=201,
payload={"username": username, "display_name": name, "password": password})
basic = base64.b64encode(f"{username}:{password}".encode()).decode()
_, session = api_json(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + basic}, expect=201)
return user["id"], session["token"]
def stop_replica(instance_id):
script = ROOT / "scripts" / ("stop-one.cmd" if os.name == "nt" else "stop-one.sh")
env = dict(os.environ, TARGET_INSTANCE_ID=instance_id)
subprocess.run([str(script)], check=True, env=env, cwd=ROOT, stdout=subprocess.DEVNULL)
def api_mounts():
ids = subprocess.run(["docker", "ps", "-q", "--filter", f"label=com.docker.compose.project={PROJECT}",
"--filter", "label=com.docker.compose.service=api"],
check=True, capture_output=True, text=True).stdout.split()
result = {}
for cid in ids:
out = subprocess.run(["docker", "inspect", cid, "--format", "{{json .Mounts}}"],
check=True, capture_output=True, text=True).stdout
result[cid] = [{"type": m["Type"], "destination": m["Destination"]} for m in json.loads(out)]
return result
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--s3-url", default="http://127.0.0.1:9000")
parser.add_argument("--bucket", default="messenger-attachments")
parser.add_argument("--output", default=str(ROOT / "evidence" / "attachment-checks.json"))
args = parser.parse_args()
base = args.base_url.rstrip("/")
content = FIXTURE.read_bytes()
expected_sha = hashlib.sha256(content).hexdigest()
report = {"fixture_bytes": len(content), "fixture_sha256": expected_sha}
alice_id, alice = new_user(base, "alice")
bob_id, bob = new_user(base, "bob")
_, eve = new_user(base, "eve")
_, chat = api_json(base, "POST", "/api/v1/chats", alice, {"title": "attachments", "member_ids": [alice_id, bob_id]},
expect=201)
# 1. Загрузка и остановка обслужившей реплики.
status, headers, data = request(
"POST", f"{base}/api/v1/chats/{chat['id']}/attachments?filename=sample.png", content,
{"Authorization": "Bearer " + alice, "Content-Type": "image/png"})
if status != 201:
raise SystemExit(f"upload: {status}")
attachment = json.loads(data)
uploaded_by = headers.get("X-Instance-Id")
report["upload"] = {"status": status, "instance": uploaded_by, "sha256_matches": attachment["sha256"] == expected_sha}
api_json(base, "POST", f"/api/v1/chats/{chat['id']}/messages", alice,
{"text": "", "attachment_ids": [attachment["id"]]}, {"Idempotency-Key": uuid.uuid4().hex}, expect=201)
stop_replica(uploaded_by)
stopped_at = time.monotonic()
download = None
while time.monotonic() - stopped_at < 15:
status, headers, data = request("GET", f"{base}/api/v1/attachments/{attachment['id']}/content",
headers={"Authorization": "Bearer " + bob})
if status == 200 and headers.get("X-Instance-Id") != uploaded_by:
download = {"status": status, "instance": headers.get("X-Instance-Id"),
"sha256": hashlib.sha256(data).hexdigest(), "content_type": headers.get("Content-Type"),
"seconds_after_stop": round(time.monotonic() - stopped_at, 2)}
break
time.sleep(0.5)
if download is None:
raise SystemExit("файл не скачался через другую реплику за 15 с")
download["different_instance"] = download["instance"] != uploaded_by
download["sha256_matches"] = download["sha256"] == expected_sha
report["download_after_stop"] = download
# 2. Посторонний.
report["outsider"] = {
"metadata_status": request("GET", f"{base}/api/v1/attachments/{attachment['id']}",
headers={"Authorization": "Bearer " + eve})[0],
"content_status": request("GET", f"{base}/api/v1/attachments/{attachment['id']}/content",
headers={"Authorization": "Bearer " + eve})[0],
}
# 3. Прямой доступ к MinIO без credentials. Ключ объекта знает только сервер; здесь — по его схеме.
s3 = args.s3_url.rstrip("/")
report["direct_s3_anonymous"] = {
"get_object_status": request("GET", f"{s3}/{args.bucket}/originals/{attachment['id']}")[0],
"list_bucket_status": request("GET", f"{s3}/{args.bucket}?list-type=2")[0],
}
# 4. Монтирования API-контейнеров (оставшаяся реплика).
report["api_mounts"] = api_mounts()
# Вернуть остановленную реплику.
subprocess.run(["docker", "compose", "up", "-d", "--no-recreate", "--wait", "api", "lb"], check=True, cwd=ROOT,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
checks = [
report["upload"]["sha256_matches"],
download["different_instance"] and download["sha256_matches"] and download["content_type"] == "image/png",
report["outsider"] == {"metadata_status": 404, "content_status": 404},
report["direct_s3_anonymous"]["get_object_status"] == 403
and report["direct_s3_anonymous"]["list_bucket_status"] == 403,
all(m["destination"].startswith("/run/secrets/") for mounts in report["api_mounts"].values() for m in mounts),
]
report["result"] = "PASS" if all(checks) else "FAIL"
Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print(json.dumps(report, ensure_ascii=False, indent=2))
return 0 if all(checks) else 1
if __name__ == "__main__":
sys.exit(main())
+25
View File
@@ -0,0 +1,25 @@
#!/usr/bin/env python3
"""Сводка `docker compose config`: опубликованные порты, container_name, лимиты, какие секреты у какого сервиса.
Значений секретов в конфигурации нет (только пути к файлам), поэтому вывод можно класть в evidence.
python scripts/compose_summary.py > evidence/compose-config.txt
"""
import json
import subprocess
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
config = json.loads(subprocess.run(["docker", "compose", "config", "--format", "json"], cwd=ROOT, check=True,
capture_output=True, text=True).stdout)
for name, service in config["services"].items():
ports = [f"{p.get('host_ip', '0.0.0.0')}:{p.get('published')}->{p.get('target')}" for p in service.get("ports", [])]
limits = service.get("deploy", {}).get("resources", {}).get("limits", {})
print(f"{name}: image={service.get('image')} replicas={service.get('deploy', {}).get('replicas', 1)} "
f"published_ports={ports} container_name={service.get('container_name')} "
f"limits={{cpus: {limits.get('cpus')}, memory: {limits.get('memory')}, pids: {limits.get('pids')}}} "
f"secrets={[s['source'] for s in service.get('secrets', [])]}")
env = service.get("environment") or {}
if "MINIO_BROWSER" in env:
print(f" MINIO_BROWSER={env['MINIO_BROWSER']}")
print("volumes:", sorted(config.get("volumes", {})))
+413
View File
@@ -0,0 +1,413 @@
#!/usr/bin/env python3
"""Эксперименты балансировки (перенесены из lab3: idempotency, failover, rolling). Стенд (docker compose up -d --build --wait) должен быть уже запущен.
failover останавливает каждую API-реплику по очереди под нагрузкой, восстанавливает её и
только потом берёт следующую; считает RPS, ошибки и время восстановления
idempotency параллельно шлёт один Idempotency-Key через LB (разные реплики): должно быть ровно 1 сообщение
rolling поочерёдная замена всех реплик на новую сборку под нагрузкой (migrate запускается один раз)
Результаты (без токенов) пишутся в evidence/*.json. Данные создаются синтетические и не удаляются.
Использует публичный tests/client.py и docker CLI из каталога проекта.
"""
import argparse
import json
import math
import os
from pathlib import Path
import subprocess
import sys
import threading
import time
import uuid
from concurrent.futures import ThreadPoolExecutor
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
PROJECT = 'mtusi-lab4'
# ---------- docker ----------
def docker(*args, env=None, timeout=180, ok=True, with_stderr=False):
proc = subprocess.run(['docker', *args], cwd=ROOT, capture_output=True, text=True, encoding='utf-8',
errors='replace', timeout=timeout, env=env)
if ok and proc.returncode != 0:
raise Failure('docker ' + ' '.join(args[:3]) + ' failed: ' + proc.stderr.strip()[:300])
return (proc.stdout + proc.stderr).strip() if with_stderr else proc.stdout.strip()
def api_containers(all_states=False):
"""Короткие ID контейнеров сервиса api. Совпадают с X-Instance-Id (hostname контейнера)."""
args = ['ps', '-q', '--filter', 'label=com.docker.compose.project=' + PROJECT,
'--filter', 'label=com.docker.compose.service=api']
if all_states:
args.insert(1, '-a')
return sorted(x for x in docker(*args).split() if x)
def wait_healthy(ids, timeout=90):
deadline = time.monotonic() + timeout
while True:
states = {i: docker('inspect', '-f', '{{.State.Health.Status}}', i) for i in ids}
if all(s == 'healthy' for s in states.values()):
return
check(time.monotonic() < deadline, 'containers did not become healthy: ' + str(states))
time.sleep(1)
def wait_instances(c, actor, expected, timeout=60):
"""Ждать, пока через LB ответят все ожидаемые реплики (т.е. LB включил их в ротацию)."""
deadline = time.monotonic() + timeout
seen = set()
while True:
for _ in range(20):
try:
seen.add(c.call('GET', '/api/v1/users/me', actor=actor)['headers'].get('X-Instance-Id'))
except Failure:
pass
if set(expected) <= seen:
return
check(time.monotonic() < deadline, 'LB did not route to all replicas: missing ' + str(set(expected) - seen))
time.sleep(0.5)
def resource_snapshot():
out = docker('stats', '--no-stream', '--format', '{{.Name}}: cpu {{.CPUPerc}}, mem {{.MemUsage}}', ok=False)
return [line for line in out.splitlines() if line]
# ---------- нагрузка ----------
class Load:
"""Замкнутая нагрузка: запись сообщения (с ретраями ТОГО ЖЕ ключа при ошибке) + чтение страницы истории."""
def __init__(self, base_url, ca_file, actor, chat, workers):
self.base_url, self.ca_file, self.actor, self.chat, self.workers = base_url, ca_file, actor, chat, workers
self.events, self.acked = [], [] # events: (t_start, t_end, kind, ok, instance, error_reason)
self.stop_event = threading.Event()
self.lock = threading.Lock()
self.threads = []
self.t0 = time.monotonic()
def now(self):
return time.monotonic() - self.t0
def record(self, start, kind, ok, instance, error=None):
# Причина без пути (в нём id чата): "expected [201], received 503" или "connection/TLS failure (...)".
reason = str(error).split(': ', 1)[-1] if error else None
with self.lock:
self.events.append((start, self.now(), kind, ok, instance, reason))
def worker(self, wid):
c = Client(self.base_url, self.ca_file, timeout=2)
path = '/api/v1/chats/' + self.chat['id'] + '/messages'
i = 0
while not self.stop_event.is_set():
key = uuid.uuid4().hex
text = 'exp-%d-%d-%s' % (wid, i, key)
i += 1
for _ in range(10):
start = self.now()
try:
r = c.message(self.actor, self.chat, text, key=key)
self.record(start, 'write', True, r['headers'].get('X-Instance-Id'))
with self.lock:
self.acked.append(r['json'])
break
except Failure as exc:
self.record(start, 'write', False, None, exc) # неопределённый результат: повтор с тем же ключом
if self.stop_event.wait(0.1):
break
start = self.now()
try:
r = c.call('GET', path + '?limit=1', actor=self.actor, schema='MessagePage')
self.record(start, 'read', True, r['headers'].get('X-Instance-Id'))
except Failure as exc:
self.record(start, 'read', False, None, exc)
def start(self):
self.threads = [threading.Thread(target=self.worker, args=(n,), daemon=True) for n in range(self.workers)]
for t in self.threads:
t.start()
def stop(self):
self.stop_event.set()
for t in self.threads:
t.join(timeout=15)
def percentile(sorted_values, p):
if not sorted_values:
return None
return round(1000 * sorted_values[max(0, math.ceil(p * len(sorted_values)) - 1)], 1)
def window(events, lo, hi):
"""Метрики по запросам, завершившимся в [lo, hi)."""
sel = [e for e in events if lo <= e[1] < hi]
ok = [e for e in sel if e[3]]
errors = [e for e in sel if not e[3]]
lat = sorted(e[1] - e[0] for e in ok)
span = max(hi - lo, 1e-9)
reasons = {}
for e in errors:
key = e[2] + ': ' + (e[5] or 'unknown')
reasons[key] = reasons.get(key, 0) + 1
return {
'seconds': round(span, 2),
'successful_requests': len(ok), 'failed_requests': len(errors), 'error_reasons': reasons,
'error_ratio': round(len(errors) / len(sel), 4) if sel else None,
'successful_rps': round(len(ok) / span, 1),
'latency_ms': {'p50': percentile(lat, .5), 'p95': percentile(lat, .95), 'p99': percentile(lat, .99)},
}
def timeline(events, end):
rows = []
for s in range(int(end) + 1):
sel = [e for e in events if s <= e[1] < s + 1]
rows.append({'t': s, 'ok': sum(1 for e in sel if e[3]), 'errors': sum(1 for e in sel if not e[3])})
return rows
def last_error_after(events, moment):
late = [e[1] for e in events if not e[3] and e[1] >= moment]
return round(max(late) - moment, 2) if late else 0.0
def history(c, actor, chat):
path = '/api/v1/chats/' + chat['id'] + '/messages?limit=100'
result, seen = [], set()
for _ in range(100000):
page = c.call('GET', path, actor=actor, schema='MessagePage')['json']
result.extend(page['items'])
cursor = page['next_cursor']
if cursor is None:
return result
check(cursor not in seen, 'cursor cycle')
seen.add(cursor)
path = '/api/v1/chats/' + chat['id'] + '/messages?limit=100&cursor=' + quote(cursor, safe='')
raise Failure('history pagination exceeded safety bound')
def verify(c, actor, chat, acked):
"""Подтверждённые сообщения не потеряны, а повторы с тем же ключом не создали дублей."""
messages = history(c, actor, chat)
by_id = {m['id']: m for m in messages}
lost = sum(1 for a in acked if by_id.get(a['id']) != a)
texts = [m['text'] for m in messages if m['text'].startswith('exp-')]
duplicates = len(texts) - len(set(texts))
return {'acked_messages': len(acked), 'messages_in_history': len(messages),
'lost_acked_messages': lost, 'duplicate_messages': duplicates}
def write_evidence(out_dir, name, data):
out_dir.mkdir(parents=True, exist_ok=True)
path = out_dir / name
path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + '\n', encoding='utf-8')
print('written', path)
def setup(args):
c = Client(args.base_url, args.ca_file)
alice, bob, eve, chat = c.bootstrap()
return c, alice, bob, chat
# ---------- эксперименты ----------
def run_failover(args):
c, alice, bob, chat = setup(args)
containers = api_containers()
check(len(containers) >= 2, 'need at least 2 running API replicas, found %d' % len(containers))
results = []
for target in containers:
# Предыдущая реплика уже восстановлена; убеждаемся, что в ротации все.
docker('compose', 'up', '-d', '--no-recreate', '--wait', 'api', 'lb', timeout=300)
wait_instances(c, alice, containers)
load = Load(args.base_url, args.ca_file, alice, chat, args.workers)
load.start()
time.sleep(args.warmup)
resources = resource_snapshot()
t_stop = load.now()
docker('stop', '-t', '8', target)
stop_command_seconds = round(load.now() - t_stop, 2)
time.sleep(args.after)
t_restore = load.now()
docker('compose', 'up', '-d', '--no-recreate', '--wait', 'api', 'lb', timeout=300)
wait_instances(c, alice, containers)
t_back = load.now()
time.sleep(args.settle)
load.stop()
end = load.now()
stats = verify(c, bob, chat, load.acked)
after_stop = [e for e in load.events if e[1] >= t_stop and e[3]]
first_other = min((e[1] for e in after_stop if e[4] != target and e[2] == 'write'), default=None)
# Сколько запросов остановленная реплика обслужила после возврата `docker stop` и до восстановления: должно быть 0.
served_by_target_after_stop = sum(1 for e in load.events
if t_stop + stop_command_seconds <= e[0] < t_restore and e[3] and e[4] == target)
results.append({
'stopped_replica': target,
'baseline_before_stop': window(load.events, 0, t_stop),
'stop_to_restore': window(load.events, t_stop, t_restore),
'after_restore': window(load.events, t_restore, end),
'docker_stop_seconds': stop_command_seconds,
'last_error_seconds_after_stop': last_error_after(load.events, t_stop),
'first_success_on_other_replica_seconds': round(first_other - t_stop, 2) if first_other else None,
'requests_served_by_stopped_replica_after_stop_returned': served_by_target_after_stop,
# Включает `docker compose up --wait` (повторный migrate, start_period healthcheck) и rise 2 в LB.
'seconds_until_replica_back_in_rotation': round(t_back - t_restore, 2),
'instances_seen': sorted({e[4] for e in load.events if e[4]}),
'resource_snapshot_under_load': resources,
'timeline_per_second': timeline(load.events, end),
**stats,
})
print('replica %s: errors=%d, last error %.2fs after stop, lost=%d, dup=%d' % (
target, results[-1]['stop_to_restore']['failed_requests'],
results[-1]['last_error_seconds_after_stop'], stats['lost_acked_messages'], stats['duplicate_messages']))
write_evidence(Path(args.output), 'failover-sequential.json', {
'method': 'closed loop %d workers: POST message (retry same Idempotency-Key on error) + GET page; '
'client timeout 2s; each replica stopped with docker stop -t 8, restored, then the next' % args.workers,
'replicas': containers, 'warmup_seconds': args.warmup, 'seconds_down': args.after, 'runs': results})
for r in results:
check(r['lost_acked_messages'] == 0 and r['duplicate_messages'] == 0, 'data integrity violated')
def run_idempotency(args):
c, alice, bob, chat = setup(args)
path = '/api/v1/chats/' + chat['id'] + '/messages'
instances, rounds = set(), []
for _ in range(args.rounds):
key = uuid.uuid4().hex
text = 'idem-' + key
barrier = threading.Barrier(args.parallel)
def send(_):
local = Client(args.base_url, args.ca_file, timeout=10)
barrier.wait()
try:
r = local.message(alice, chat, text, key=key)
return r['status'], r['json']['id'], r['headers'].get('X-Instance-Id')
except Failure as exc:
return None, str(exc), None
with ThreadPoolExecutor(max_workers=args.parallel) as pool:
answers = list(pool.map(send, range(args.parallel)))
ok = [a for a in answers if a[0] == 201]
instances.update(a[2] for a in ok)
rounds.append({'responses_201': len(ok), 'failures': len(answers) - len(ok),
'distinct_message_ids': len({a[1] for a in ok}),
'distinct_instances': len({a[2] for a in ok})})
messages = history(c, bob, chat)
texts = [m['text'] for m in messages]
created = [texts.count(m['text']) for m in messages if m['text'].startswith('idem-')]
# Тот же ключ с другим телом -> 409.
key = uuid.uuid4().hex
c.message(alice, chat, 'idem-first-' + key, key=key)
other_body = c.call('POST', path, 409, actor=alice, body={'text': 'idem-other-' + key},
headers={'Idempotency-Key': key})
report = {
'method': '%d rounds; each round %d simultaneous identical POSTs with one Idempotency-Key through the LB '
'(separate connections, released by a barrier)' % (args.rounds, args.parallel),
'rounds': args.rounds, 'parallel_requests_per_round': args.parallel,
'instances_seen': sorted(i for i in instances if i),
'all_rounds_single_message_id': all(r['distinct_message_ids'] == 1 for r in rounds),
'failed_requests': sum(r['failures'] for r in rounds),
'rounds_with_requests_on_2plus_replicas': sum(1 for r in rounds if r['distinct_instances'] >= 2),
'messages_created_per_key_max': max(created) if created else 0,
'same_key_other_body_status': other_body['status'],
'per_round': rounds,
}
write_evidence(Path(args.output), 'idempotency-parallel.json', report)
check(report['all_rounds_single_message_id'], 'a key produced several message ids')
check(report['messages_created_per_key_max'] == 1, 'a key created several messages')
check(report['failed_requests'] == 0, 'some parallel requests failed')
def run_rolling(args):
c, alice, bob, chat = setup(args)
old = api_containers()
n = len(old)
check(n >= 2, 'need at least 2 running API replicas')
old_image = {i: docker('inspect', '-f', '{{.Image}}', i) for i in old}
# Migrate запускается один раз, до замены; миграции только добавляют (expand), старые реплики их переживают.
# Alembic пишет журнал в stderr.
migrate_log = docker('compose', 'run', '--rm', 'migrate', timeout=300, with_stderr=True)
load = Load(args.base_url, args.ca_file, alice, chat, args.workers)
load.start()
time.sleep(args.warmup)
t_start = load.now()
env = dict(os.environ, APP_VERSION='rolling-' + time.strftime('%H%M%S'))
docker('compose', 'build', 'api', env=env, timeout=600)
docker('compose', 'up', '-d', '--no-deps', '--no-recreate', '--scale', 'api=%d' % (2 * n), 'api',
env=env, timeout=300)
new = [i for i in api_containers() if i not in old]
check(len(new) == n, 'expected %d new replicas, found %d' % (n, len(new)))
wait_healthy(new)
wait_instances(c, alice, new)
steps = []
for victim in old:
t = load.now()
docker('stop', '-t', '15', victim)
docker('rm', victim)
steps.append({'replaced': victim, 'seconds_into_update': round(t - t_start, 2)})
time.sleep(args.step_pause)
docker('compose', 'up', '-d', '--no-deps', '--no-recreate', '--scale', 'api=%d' % n, 'api', env=env, timeout=300)
t_done = load.now()
time.sleep(args.settle)
load.stop()
end = load.now()
stats = verify(c, bob, chat, load.acked)
seen_old = [e for e in load.events if e[3] and e[4] in old]
seen_new = [e for e in load.events if e[3] and e[4] in new]
report = {
'method': 'closed loop %d workers under rolling replacement: start N new replicas of the new build, '
'wait until healthy and routed by LB, then stop+remove old replicas one at a time' % args.workers,
'replicas_before': old, 'replicas_after': api_containers(), 'new_replicas': new,
'old_image_ids': old_image, 'new_image_ids': {i: docker('inspect', '-f', '{{.Image}}', i) for i in new},
'app_version_build_arg': env['APP_VERSION'],
'update_seconds': round(t_done - t_start, 2),
'steps': steps,
'before_update': window(load.events, 0, t_start),
'during_update': window(load.events, t_start, t_done),
'after_update': window(load.events, t_done, end),
# Все моменты — секунды от начала обновления, как и steps[].seconds_into_update.
'first_new_replica_response_seconds_into_update': round(min((e[1] for e in seen_new), default=t_start) - t_start, 2),
'last_old_replica_response_seconds_into_update': round(max((e[1] for e in seen_old), default=t_start) - t_start, 2),
'migrate_output_tail': migrate_log.splitlines()[-3:],
'timeline_per_second': timeline(load.events, end),
**stats,
}
write_evidence(Path(args.output), 'rolling-update.json', report)
print('rolling: errors during update=%d, lost=%d, dup=%d' % (
report['during_update']['failed_requests'], stats['lost_acked_messages'], stats['duplicate_messages']))
check(stats['lost_acked_messages'] == 0 and stats['duplicate_messages'] == 0, 'data integrity violated')
def main():
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument('experiment', choices=['failover', 'idempotency', 'rolling'])
p.add_argument('--base-url', default=None)
p.add_argument('--ca-file', default=None)
p.add_argument('--workers', type=int, default=8, help='closed-loop workers (failover, rolling)')
p.add_argument('--warmup', type=float, default=5, help='seconds of load before the action')
p.add_argument('--after', type=float, default=15, help='failover: seconds the replica stays down under load')
p.add_argument('--settle', type=float, default=8, help='seconds of load after the action')
p.add_argument('--step-pause', type=float, default=3, help='rolling: pause between replacing replicas')
p.add_argument('--rounds', type=int, default=30, help='idempotency: number of keys')
p.add_argument('--parallel', type=int, default=16, help='idempotency: simultaneous requests per key')
p.add_argument('--output', default=str(ROOT / 'evidence'))
args = p.parse_args()
try:
{'failover': run_failover, 'idempotency': run_idempotency, 'rolling': run_rolling}[args.experiment](args)
except (Failure, RuntimeError, subprocess.TimeoutExpired) as exc:
print('FAIL:', exc)
raise SystemExit(1)
print('PASS:', args.experiment)
if __name__ == '__main__':
main()
+24
View File
@@ -0,0 +1,24 @@
# Windows twin of scripts/init-secrets.sh. Existing files are kept.
$ErrorActionPreference = 'Stop'
Set-Location (Join-Path $PSScriptRoot '..')
New-Item -ItemType Directory -Force secrets | Out-Null
function New-Secret($name, $bytes) {
$path = Join-Path 'secrets' $name
if ((Test-Path $path) -and (Get-Item $path).Length -gt 0) { "kept secrets/$name"; return }
$buffer = New-Object byte[] $bytes
[Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($buffer)
$value = [Convert]::ToBase64String($buffer) -replace '[+/=]', ''
# ASCII, no BOM, no trailing newline.
[IO.File]::WriteAllText((Join-Path (Get-Location) $path), $value, [Text.Encoding]::ASCII)
"created secrets/$name"
}
New-Secret 'postgres_password' 32
New-Secret 'jwt_secret' 64
# MinIO: user/access key up to 20 chars, password/secret up to 40.
New-Secret 'minio_root_user' 15
New-Secret 'minio_root_password' 30
New-Secret 's3_access_key_id' 15
New-Secret 's3_secret_access_key' 30
if (-not (Test-Path .env)) { Copy-Item .env.example .env; 'created .env' }
+23
View File
@@ -0,0 +1,23 @@
#!/bin/sh
# Создать локальные секреты после clone. Существующие файлы не перезаписываются.
set -eu
cd "$(dirname "$0")/.."
mkdir -p secrets
make_secret() {
if [ ! -s "secrets/$1" ]; then
head -c "$2" /dev/urandom | base64 | tr -d '\n+/=' > "secrets/$1"
echo "created secrets/$1"
else
echo "kept secrets/$1"
fi
}
make_secret postgres_password 32
make_secret jwt_secret 64
# MinIO: имя пользователя/access key не длиннее 20 символов, пароль/secret — не длиннее 40.
make_secret minio_root_user 15
make_secret minio_root_password 30
make_secret s3_access_key_id 15
make_secret s3_secret_access_key 30
[ -f .env ] || { cp .env.example .env; echo "created .env"; }
+149
View File
@@ -0,0 +1,149 @@
#!/usr/bin/env python3
"""Оборванная загрузка и объекты-сироты: что остаётся в хранилищах и как это убирается.
1. Клиент обрывает соединение посреди тела запроса -> ни объекта в S3, ни строки в БД.
2. «PUT прошёл, COMMIT и компенсация — нет»: такие объекты кладутся в bucket напрямую (credentials API),
без строк в attachments. Сам путь кода (откат БД -> попытка удаления -> сирота) проверяют pytest-тесты
test_commit_failure_after_put_deletes_object и test_orphan_left_by_failed_compensation_*.
3. Сверка (тот же образ и команда, что у сервиса reconciler):
dry-run с grace 1 ч (сироты свежие — не трогаем) -> dry-run с grace 0 (видим, не удаляем)
-> apply с grace 0 (удаляем) -> повторный apply (ничего не находит). Используемые файлы целы.
Запуск из venv при поднятом стенде: python scripts/orphan_experiment.py
"""
import argparse
import base64
import hashlib
import io
import json
import os
import socket
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
from pathlib import Path
from urllib.parse import urlsplit
ROOT = Path(__file__).resolve().parents[1]
os.chdir(ROOT) # .env и secrets/ читаются относительно корня
sys.path.insert(0, str(ROOT / "app"))
from core import s3 # noqa: E402 (настройки из .env: MinIO на 127.0.0.1, рабочий bucket)
PNG = (ROOT / "tests" / "fixtures" / "sample.png").read_bytes()
def call(base, method, path, body=None, headers=None):
req = urllib.request.Request(base + path, data=body, method=method, headers=headers or {})
try:
with urllib.request.urlopen(req, timeout=30) as resp:
return resp.status, resp.read()
except urllib.error.HTTPError as exc:
return exc.code, exc.read()
def run(*args):
return subprocess.run(list(args), check=True, cwd=ROOT, capture_output=True, text=True).stdout
def snapshot():
rows = int(run("docker", "compose", "exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger",
"-tAc", "SELECT count(*) FROM attachments").strip())
return {"attachment_rows": rows, "objects": sum(1 for _ in s3.list_objects("originals/"))}
def cleaner(*flags):
out = run("docker", "compose", "run", "--rm", "--no-deps", "reconciler",
"python", "-m", "maintenance.reconcile", *flags)
report = json.loads(out.strip().splitlines()[-1])
return {"mode": report["mode"], "grace_seconds": report["grace_seconds"],
"objects_scanned": report["objects_scanned"], "ok": report["ok"],
"orphans_fresh_kept": report["issues"]["orphan_object_fresh"],
"orphans_found": report["issues"]["orphan_object"],
"deleted": report["actions"]["objects_deleted"], "seconds": report["seconds"]["total"]}
def interrupted_upload(base, token, chat_id, declared, sent):
"""Заявить Content-Length=declared, отправить sent байт и закрыть соединение."""
url = urlsplit(base)
head = (f"POST /api/v1/chats/{chat_id}/attachments?filename=cut.png HTTP/1.1\r\n"
f"Host: {url.netloc}\r\nAuthorization: Bearer {token}\r\nContent-Type: image/png\r\n"
f"Content-Length: {declared}\r\n\r\n").encode()
with socket.create_connection((url.hostname, url.port or 80), timeout=10) as sock:
sock.sendall(head + (PNG * (sent // len(PNG) + 1))[:sent])
time.sleep(0.5)
# with закрыл сокет посреди тела.
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--orphans", type=int, default=3)
parser.add_argument("--output", default=str(ROOT / "evidence" / "orphan-cleanup.json"))
args = parser.parse_args()
base = args.base_url.rstrip("/")
username, password = f"orph_{uuid.uuid4().hex[:8]}", "orphan-experiment-pass"
user = json.loads(call(base, "POST", "/api/v1/users", json.dumps(
{"username": username, "display_name": "orph", "password": password}).encode(),
{"Content-Type": "application/json"})[1])
basic = base64.b64encode(f"{username}:{password}".encode()).decode()
token = json.loads(call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + basic})[1])["token"]
auth = {"Authorization": "Bearer " + token}
chat_id = json.loads(call(base, "POST", "/api/v1/chats", json.dumps(
{"title": "orphans", "member_ids": [user["id"]]}).encode(), {"Content-Type": "application/json", **auth})[1])["id"]
# Используемый файл: загружен и прикреплён к сообщению — очистка не должна его тронуть.
status, data = call(base, "POST", f"/api/v1/chats/{chat_id}/attachments?filename=keep.png", PNG,
{"Content-Type": "image/png", **auth})
kept = json.loads(data)["id"]
call(base, "POST", f"/api/v1/chats/{chat_id}/messages", json.dumps({"text": "", "attachment_ids": [kept]}).encode(),
{"Content-Type": "application/json", "Idempotency-Key": uuid.uuid4().hex, **auth})
report = {"start": snapshot()}
# 1. Оборванная загрузка.
interrupted_upload(base, token, chat_id, declared=9 * 1024 * 1024, sent=2 * 1024 * 1024)
time.sleep(2)
report["after_interrupted_upload"] = snapshot()
logs = run("docker", "compose", "logs", "api", "--since", "1m")
report["api_logged_interrupt"] = "Загрузка прервана клиентом" in logs
# 2. Сироты: объект в S3 без строки в БД.
for _ in range(args.orphans):
s3.put_object(f"originals/{uuid.uuid4()}", PNG, "image/png", hashlib.sha256(PNG).hexdigest())
report["after_orphans_injected"] = snapshot()
# 3. Очистка.
report["cleanup_dry_run_grace_default"] = cleaner()
report["cleanup_dry_run_grace_0"] = cleaner("--grace-seconds", "0")
report["after_dry_runs"] = snapshot()
report["cleanup_apply_grace_0"] = cleaner("--apply", "--grace-seconds", "0")
report["cleanup_apply_again"] = cleaner("--apply", "--grace-seconds", "0")
report["end"] = snapshot()
status, data = call(base, "GET", f"/api/v1/attachments/{kept}/content", headers=auth)
report["kept_attachment_download"] = {"status": status, "sha256_matches": hashlib.sha256(data).digest()
== hashlib.sha256(PNG).digest()}
start, end = report["start"], report["end"]
ok = (report["after_interrupted_upload"] == start
and report["after_orphans_injected"]["objects"] == start["objects"] + args.orphans
and report["cleanup_dry_run_grace_default"]["orphans_fresh_kept"] == args.orphans
and report["cleanup_dry_run_grace_default"]["deleted"] == 0
and report["cleanup_dry_run_grace_0"]["orphans_found"] == args.orphans
and report["after_dry_runs"] == report["after_orphans_injected"]
and report["cleanup_apply_grace_0"]["deleted"] == args.orphans
and report["cleanup_apply_again"]["orphans_found"] == 0
and end == start
and report["kept_attachment_download"] == {"status": 200, "sha256_matches": True})
report["result"] = "PASS" if ok else "FAIL"
Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print(json.dumps(report, ensure_ascii=False, indent=2))
return 0 if ok else 1
if __name__ == "__main__":
sys.exit(main())
+319
View File
@@ -0,0 +1,319 @@
#!/usr/bin/env python3
"""Трек 2: эксперименты сверки хранилищ на отдельных базе messenger_bench и bucket messenger-attachments-bench.
python scripts/reconcile_experiment.py faults --objects 10000 # внедрение ошибок с обеих сторон
python scripts/reconcile_experiment.py cost --sizes 1000,10000,50000
Данные: N вложений по 1 KiB (случайные байты), половина прикреплена к сообщениям (по 10 на сообщение).
Сверка запускается так же, как в работе: `docker compose run reconciler python -m maintenance.reconcile`
(контейнер с лимитом 0.25 CPU / 128 MiB), с переопределёнными базой и bucket. Хост — только для генерации
данных и внедрения ошибок (venv, настройки из .env). Рабочие данные не затрагиваются.
"""
import argparse
import hashlib
import json
import logging
import os
import random
import statistics
import subprocess
import sys
import time
import uuid
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
BENCH_DB = "messenger_bench"
BENCH_BUCKET = "messenger-attachments-bench"
os.chdir(ROOT)
os.environ["APP_CONFIG__DB__NAME"] = BENCH_DB
os.environ["APP_CONFIG__S3__BUCKET"] = BENCH_BUCKET
sys.path.insert(0, str(ROOT / "app"))
from alembic import command # noqa: E402
from alembic.config import Config # noqa: E402
from minio.deleteobjects import DeleteObject # noqa: E402
from sqlalchemy import create_engine, delete, func, insert, select, text, update # noqa: E402
from core import s3 # noqa: E402
from core.config import settings # noqa: E402
from core.db import SessionLocal, build_url, engine # noqa: E402
from models import Attachment, Chat, ChatMember, Message, MessageAttachment, User # noqa: E402
logging.getLogger("urllib3").setLevel(logging.ERROR)
OBJECT_SIZE = 1024
PREFIX = "originals/"
# --- данные ---
def recreate_database():
engine.dispose()
admin = create_engine(build_url().set(database="postgres"), isolation_level="AUTOCOMMIT")
with admin.connect() as connection:
connection.execute(text(f'DROP DATABASE IF EXISTS "{BENCH_DB}" WITH (FORCE)'))
connection.execute(text(f'CREATE DATABASE "{BENCH_DB}"'))
admin.dispose()
command.upgrade(Config(str(ROOT / "app" / "alembic.ini")), "head")
def empty_bucket():
client = s3.get_client()
batch = []
for stored in s3.list_objects(""):
batch.append(DeleteObject(stored.key))
if len(batch) == 1000:
list(client.remove_objects(BENCH_BUCKET, batch))
batch = []
if batch:
list(client.remove_objects(BENCH_BUCKET, batch))
def put_many(items):
"""items: [(key, bytes)] — параллельно, 16 потоков."""
def put(item):
key, data = item
s3.put_object(key, data, "image/png", hashlib.sha256(data).hexdigest())
with ThreadPoolExecutor(16) as pool:
list(pool.map(put, items))
def seed(n: int) -> dict:
started = time.monotonic()
recreate_database()
empty_bucket()
owner, other, chat = uuid.uuid4(), uuid.uuid4(), uuid.uuid4()
blobs = {uuid.uuid4(): os.urandom(OBJECT_SIZE) for _ in range(n)}
ids = list(blobs)
with SessionLocal() as db:
db.execute(insert(User), [{"id": owner, "username": "bench_owner", "display_name": "o", "password_hash": "x"},
{"id": other, "username": "bench_other", "display_name": "x", "password_hash": "x"}])
db.execute(insert(Chat), [{"id": chat, "title": "bench"}])
db.execute(insert(ChatMember), [{"chat_id": chat, "user_id": owner}, {"chat_id": chat, "user_id": other}])
rows = [{"id": i, "chat_id": chat, "owner_id": owner, "filename": "f.png", "content_type": "image/png",
"size_bytes": OBJECT_SIZE, "sha256": hashlib.sha256(blobs[i]).hexdigest(),
"object_key": f"{PREFIX}{i}"} for i in ids]
for start in range(0, n, 5000):
db.execute(insert(Attachment), rows[start:start + 5000])
# Первая половина прикреплена к сообщениям, по 10 вложений на сообщение.
referenced = ids[: n // 2]
messages, links = [], []
for start in range(0, len(referenced), 10):
message_id = uuid.uuid4()
messages.append({"id": message_id, "chat_id": chat, "sender_id": owner, "text": ""})
links += [{"message_id": message_id, "attachment_id": a, "chat_id": chat, "position": p}
for p, a in enumerate(referenced[start:start + 10])]
for start in range(0, len(messages), 5000):
db.execute(insert(Message), messages[start:start + 5000])
for start in range(0, len(links), 5000):
db.execute(insert(MessageAttachment), links[start:start + 5000])
db.commit()
db.execute(text("ANALYZE"))
db.commit()
put_many([(f"{PREFIX}{i}", data) for i, data in blobs.items()])
return {"objects": n, "referenced": n // 2, "chat": chat, "owner": owner, "ids": ids,
"seed_seconds": round(time.monotonic() - started, 1)}
def snapshot() -> dict:
with SessionLocal() as db:
rows = db.scalar(select(func.count()).select_from(Attachment))
referenced = db.scalar(select(func.count(func.distinct(MessageAttachment.attachment_id))))
return {"objects": sum(1 for _ in s3.list_objects(PREFIX)), "rows": rows, "referenced_rows": referenced}
def existing_keys() -> set:
return {stored.key for stored in s3.list_objects(PREFIX)}
# --- запуск сверки так же, как в работе ---
def reconcile(*flags) -> dict:
out = subprocess.run(
["docker", "compose", "run", "--rm", "--no-deps",
"-e", f"APP_CONFIG__DB__NAME={BENCH_DB}", "-e", f"APP_CONFIG__S3__BUCKET={BENCH_BUCKET}",
"reconciler", "python", "-m", "maintenance.reconcile", "--samples", "100000", *flags],
cwd=ROOT, capture_output=True, text=True)
lines = [line for line in out.stdout.splitlines() if line.startswith("{")]
if not lines:
raise SystemExit(f"сверка не вернула отчёт (exit {out.returncode}): {out.stderr[-500:]}")
return json.loads(lines[-1])
def brief(report: dict) -> dict:
keep = ("mode", "grace_seconds", "verify_checksums", "objects_scanned", "rows_scanned", "ok", "issues", "actions",
"seconds", "bytes_read", "peak_rss_mib", "aborted")
return {k: report[k] for k in keep if k in report}
# --- эксперимент 1: внедрение ошибок ---
def faults(args):
grace = args.grace
base = seed(args.objects)
ids, chat, owner = base["ids"], base["chat"], base["owner"]
random.seed(42)
referenced, free = ids[: len(ids) // 2], ids[len(ids) // 2:]
pick_ref = random.sample(referenced, 20)
pick_free = random.sample(free, 40)
injected = {
"orphan_object": set(), # 10 PUT без строки + 10 строк удалено из БД
"missing_object": set(), # объект удалён, строка не прикреплена
"missing_object_referenced": set(),
"size_mismatch": set(),
"checksum_mismatch": set(),
"orphan_object_fresh": set(),
"missing_object_fresh": set(),
}
report = {"objects": args.objects, "grace_seconds": grace, "seed_seconds": base["seed_seconds"]}
# Базовые данные должны стать «старыми» относительно grace.
time.sleep(grace + 2)
report["baseline"] = snapshot()
report["baseline_reconcile"] = brief(reconcile("--grace-seconds", str(grace)))
# Старые ошибки: S3-сторона и БД-сторона.
extra = [f"{PREFIX}{uuid.uuid4()}" for _ in range(10)]
put_many([(key, os.urandom(OBJECT_SIZE)) for key in extra])
injected["orphan_object"] |= set(extra)
with SessionLocal() as db:
lost_rows = pick_free[:10] # строки потеряны, объекты остались
db.execute(delete(Attachment).where(Attachment.id.in_(lost_rows)))
injected["orphan_object"] |= {f"{PREFIX}{i}" for i in lost_rows}
size_rows = pick_free[10:15] + pick_ref[10:15]
db.execute(update(Attachment).where(Attachment.id.in_(size_rows)).values(size_bytes=OBJECT_SIZE + 1))
injected["size_mismatch"] |= {str(i) for i in size_rows}
db.commit()
for i in pick_free[15:25]:
s3.delete_object(f"{PREFIX}{i}")
injected["missing_object"].add(str(i))
for i in pick_ref[:10]:
s3.delete_object(f"{PREFIX}{i}")
injected["missing_object_referenced"].add(str(i))
checksum_rows = pick_free[25:30] + pick_ref[15:20]
put_many([(f"{PREFIX}{i}", os.urandom(OBJECT_SIZE)) for i in checksum_rows]) # тот же размер, другие байты
injected["checksum_mismatch"] |= {str(i) for i in checksum_rows}
time.sleep(grace + 2)
# Свежие: загрузка «между PUT и COMMIT» и строка новее листинга.
fresh_objects = [f"{PREFIX}{uuid.uuid4()}" for _ in range(10)]
put_many([(key, os.urandom(OBJECT_SIZE)) for key in fresh_objects])
injected["orphan_object_fresh"] |= set(fresh_objects)
fresh_rows = [uuid.uuid4() for _ in range(10)]
with SessionLocal() as db:
db.execute(insert(Attachment), [{"id": i, "chat_id": chat, "owner_id": owner, "filename": "f.png",
"content_type": "image/png", "size_bytes": OBJECT_SIZE, "sha256": "0" * 64,
"object_key": f"{PREFIX}{i}"} for i in fresh_rows])
db.commit()
injected["missing_object_fresh"] |= {str(i) for i in fresh_rows}
report["injected"] = {k: len(v) for k, v in injected.items()}
report["after_injection"] = before = snapshot()
keys_before = existing_keys()
# Быстрые шаги идут подряд, пока «свежие» расхождения моложе grace (каждый запуск ~5 с);
# глубокая проверка (чтение каждого объекта, ~80 с на 10k) — после apply: она меняет только checksum_mismatch.
g = ("--grace-seconds", str(grace))
shallow = reconcile(*g)
detected = {k: set(v) for k, v in shallow["samples"].items()}
report["dry_run_shallow"] = brief(shallow)
report["state_unchanged_after_dry_run"] = snapshot() == before
report["apply_with_brake"] = brief(reconcile(*g, "--apply", "--max-deletes", "10"))
report["state_unchanged_after_brake"] = snapshot() == before
report["apply"] = brief(reconcile(*g, "--apply"))
after = snapshot()
keys_after = existing_keys()
report["after_apply"] = after
report["apply_again"] = brief(reconcile(*g, "--apply"))
report["fresh_still_fresh_at_apply"] = (report["apply_again"]["issues"]["orphan_object_fresh"] == 10
and report["apply_again"]["issues"]["missing_object_fresh"] == 10)
deep = reconcile(*g, "--verify-checksums")
report["dry_run_deep"] = brief(deep)
detected["checksum_mismatch"] = set(deep["samples"].get("checksum_mismatch", []))
report["detection_exact"] = {k: detected.get(k, set()) == injected[k] for k in injected}
report["safety"] = {
# Ни одна строка, прикреплённая к сообщению, не удалена.
"referenced_rows_kept": after["referenced_rows"] == before["referenced_rows"],
# Удалены ровно сироты; свежие объекты и объекты со строками на месте.
"deleted_objects_are_exactly_orphans": keys_before - keys_after == injected["orphan_object"],
"fresh_objects_kept": injected["orphan_object_fresh"] <= keys_after,
"rows_deleted_exactly_missing_free": before["rows"] - after["rows"] == len(injected["missing_object"]),
}
# Когда grace истёк, «свежие» расхождения становятся обычными и исправляются тем же путём.
time.sleep(grace + 2)
report["after_grace_apply"] = brief(reconcile(*g, "--apply"))
report["final_dry_run"] = brief(reconcile(*g, "--verify-checksums"))
report["final"] = snapshot()
final = report["final_dry_run"]["issues"]
ok = (all(report["detection_exact"].values()) and report["state_unchanged_after_dry_run"]
and report["fresh_still_fresh_at_apply"]
and "aborted" in report["apply_with_brake"] and report["state_unchanged_after_brake"]
and report["apply"]["actions"] == {"objects_deleted": 20, "rows_deleted": 10, "skipped_on_recheck": 0}
and report["apply_again"]["actions"] == {"objects_deleted": 0, "rows_deleted": 0, "skipped_on_recheck": 0}
and all(report["safety"].values())
and report["after_grace_apply"]["actions"]["objects_deleted"] == 10
and report["after_grace_apply"]["actions"]["rows_deleted"] == 10
and final == {"orphan_object": 0, "orphan_object_fresh": 0, "missing_object": 0,
"missing_object_referenced": 10, "missing_object_fresh": 0,
"size_mismatch": 10, "checksum_mismatch": 10})
report["result"] = "PASS" if ok else "FAIL"
Path(args.output or ROOT / "evidence" / "reconcile-faults.json").write_text(
json.dumps(report, ensure_ascii=False, indent=2, default=str) + "\n", encoding="utf-8")
print(json.dumps({k: report[k] for k in ("injected", "detection_exact", "safety", "result")}, ensure_ascii=False))
return 0 if ok else 1
# --- эксперимент 2: стоимость обхода ---
def plan_for_rows() -> str:
with SessionLocal() as db:
rows = db.execute(text("EXPLAIN SELECT object_key FROM attachments WHERE object_key LIKE 'originals/%' "
"ORDER BY object_key")).scalars().all()
return rows[0]
def cost(args):
report = {"object_size_bytes": OBJECT_SIZE, "reconciler_limits": "0.25 CPU, 128 MiB", "runs": []}
for n in [int(x) for x in args.sizes.split(",")]:
base = seed(n)
entry = {"objects": n, "seed_seconds": base["seed_seconds"], "rows_plan": plan_for_rows(),
"s3_list_requests": -(-n // 1000), "shallow": [], "deep": []}
for _ in range(args.repeats):
entry["shallow"].append(brief(reconcile("--grace-seconds", "0")))
for _ in range(args.deep_repeats):
entry["deep"].append(brief(reconcile("--grace-seconds", "0", "--verify-checksums")))
for mode in ("shallow", "deep"):
runs = entry[mode]
if runs:
seconds = statistics.median(r["seconds"]["scan"] for r in runs)
entry[f"{mode}_median_seconds"] = round(seconds, 3)
entry[f"{mode}_objects_per_second"] = round(n / seconds)
entry[f"{mode}_peak_rss_mib"] = max(r["peak_rss_mib"] for r in runs)
entry[f"{mode}_all_ok"] = all(r["ok"] == n and sum(r["issues"].values()) == 0 for r in runs)
report["runs"].append(entry)
print(json.dumps({k: v for k, v in entry.items() if k not in ("shallow", "deep")}, ensure_ascii=False))
Path(args.output or ROOT / "evidence" / "reconcile-cost.json").write_text(
json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
def main():
parser = argparse.ArgumentParser()
sub = parser.add_subparsers(dest="cmd", required=True)
f = sub.add_parser("faults")
f.add_argument("--objects", type=int, default=10000)
f.add_argument("--grace", type=int, default=20)
f.add_argument("--output")
c = sub.add_parser("cost")
c.add_argument("--sizes", default="1000,10000,50000")
c.add_argument("--repeats", type=int, default=3)
c.add_argument("--deep-repeats", type=int, default=2)
c.add_argument("--output")
args = parser.parse_args()
return faults(args) if args.cmd == "faults" else cost(args)
if __name__ == "__main__":
sys.exit(main() or 0)
+8
View File
@@ -0,0 +1,8 @@
@echo off
rem Windows twin of scripts/restart.sh: the test cannot execute .sh on Windows.
setlocal
cd /d "%~dp0.."
docker compose stop lb api postgres minio || exit /b 1
docker compose up -d --wait || exit /b 1
docker compose ps --format "{{.Name}} {{.Status}}"
+9
View File
@@ -0,0 +1,9 @@
#!/bin/sh
# Hook для make test-persistence: перезапуск всего стенда (LB, API, PostgreSQL, MinIO) с сохранением volumes.
set -eu
cd "$(dirname "$0")/.."
docker compose stop lb api postgres minio
# Порядок: postgres, minio (healthy) -> migrate, minio-init (exit 0) -> api (healthy) -> lb (healthy).
docker compose up -d --wait
docker compose ps --format '{{.Name}} {{.Status}}'
+7
View File
@@ -0,0 +1,7 @@
@echo off
rem Windows twin of scripts/restore-replicas.sh
setlocal
cd /d "%~dp0.."
docker compose up -d --no-recreate --wait api lb || exit /b 1
docker compose ps --format "{{.Name}} {{.Status}}" api lb
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
# Запустить остановленные реплики API (после stop-one) и дождаться готовности. Данные не затрагиваются.
set -eu
cd "$(dirname "$0")/.."
docker compose up -d --no-recreate --wait api lb
docker compose ps --format '{{.Name}} {{.Status}}' api lb
+99
View File
@@ -0,0 +1,99 @@
#!/usr/bin/env python3
"""Отказ S3: docker compose stop minio -> что отвечает API -> start minio -> загрузка снова работает.
Ожидание: /health/ready = 200 (S3 не критичен для readiness), текстовые сообщения и метаданные работают,
upload и download быстро отвечают 503 в общем формате ошибки, после старта MinIO всё восстанавливается без рестарта API.
python scripts/s3_outage_check.py --base-url http://localhost:8080
"""
import argparse
import base64
import json
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
PNG = (ROOT / "tests" / "fixtures" / "sample.png").read_bytes()
def call(base, method, path, body=None, headers=None):
start = time.monotonic()
req = urllib.request.Request(base + path, data=body, method=method, headers=headers or {})
try:
with urllib.request.urlopen(req, timeout=20) as resp:
status, data = resp.status, resp.read()
except urllib.error.HTTPError as exc:
status, data = exc.code, exc.read()
return status, data, round(time.monotonic() - start, 2)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--output", default=str(ROOT / "evidence" / "s3-outage.json"))
args = parser.parse_args()
base = args.base_url.rstrip("/")
username, password = f"s3down_{uuid.uuid4().hex[:8]}", "s3-outage-check-pass"
user = json.loads(call(base, "POST", "/api/v1/users", json.dumps(
{"username": username, "display_name": "s3", "password": password}).encode(),
{"Content-Type": "application/json"})[1])
basic = base64.b64encode(f"{username}:{password}".encode()).decode()
token = json.loads(call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + basic})[1])["token"]
auth = {"Authorization": "Bearer " + token}
chat = json.loads(call(base, "POST", "/api/v1/chats", json.dumps({"title": "s3", "member_ids": [user["id"]]}).encode(),
{"Content-Type": "application/json", **auth})[1])["id"]
def upload():
return call(base, "POST", f"/api/v1/chats/{chat}/attachments?filename=sample.png", PNG,
{"Content-Type": "image/png", **auth})
status, data, _ = upload()
attachment_id = json.loads(data)["id"]
report = {"before": {"upload_status": status}}
subprocess.run(["docker", "compose", "stop", "minio"], check=True, cwd=ROOT,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
try:
up_status, up_body, up_time = upload()
dl_status, dl_body, dl_time = call(base, "GET", f"/api/v1/attachments/{attachment_id}/content", headers=auth)
report["minio_stopped"] = {
"ready_status": call(base, "GET", "/health/ready")[0],
"message_status": call(base, "POST", f"/api/v1/chats/{chat}/messages", json.dumps({"text": "без S3"}).encode(),
{"Content-Type": "application/json", "Idempotency-Key": uuid.uuid4().hex, **auth})[0],
"metadata_status": call(base, "GET", f"/api/v1/attachments/{attachment_id}", headers=auth)[0],
"upload": {"status": up_status, "seconds": up_time, "error": json.loads(up_body)["error"]["code"]},
"download": {"status": dl_status, "seconds": dl_time, "error": json.loads(dl_body)["error"]["code"]},
}
finally:
subprocess.run(["docker", "compose", "start", "minio"], check=True, cwd=ROOT,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
# Восстановление без рестарта API: ждём первую успешную загрузку.
started = time.monotonic()
while True:
status, _, _ = upload()
if status == 201 or time.monotonic() - started > 60:
break
time.sleep(0.5)
report["after_start"] = {"upload_status": status, "recovery_seconds": round(time.monotonic() - started, 1),
"download_status": call(base, "GET", f"/api/v1/attachments/{attachment_id}/content",
headers=auth)[0]}
stopped = report["minio_stopped"]
ok = (stopped["ready_status"] == 200 and stopped["message_status"] == 201 and stopped["metadata_status"] == 200
and stopped["upload"]["status"] == 503 and stopped["download"]["status"] == 503
and report["after_start"]["upload_status"] == 201 and report["after_start"]["download_status"] == 200)
report["result"] = "PASS" if ok else "FAIL"
Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print(json.dumps(report, ensure_ascii=False, indent=2))
return 0 if ok else 1
if __name__ == "__main__":
sys.exit(main())
+16
View File
@@ -0,0 +1,16 @@
@echo off
rem Windows twin of scripts/stop-one.sh: the test cannot execute .sh on Windows.
setlocal
cd /d "%~dp0.."
if "%TARGET_INSTANCE_ID%"=="" exit /b 2
rem Hex only: the value is substituted into a docker command.
echo %TARGET_INSTANCE_ID%|findstr /r /x "[0-9a-f][0-9a-f]*" >nul || exit /b 2
set "CONTAINER="
for /f %%i in ('docker ps -q --filter "label=com.docker.compose.project=mtusi-lab4" --filter "label=com.docker.compose.service=api" --filter "id=%TARGET_INSTANCE_ID%"') do set "CONTAINER=%%i"
if not defined CONTAINER exit /b 3
rem SIGTERM -> drain (3 s) -> exit; -t 8 keeps the hook inside the 10 s budget.
docker stop -t 8 %CONTAINER% >nul || exit /b 1
echo stopped %CONTAINER%
+21
View File
@@ -0,0 +1,21 @@
#!/bin/sh
# Hook для make test-failover: остановить ОДНУ API-реплику и оставить её остановленной.
# TARGET_INSTANCE_ID = X-Instance-Id реплики = hostname контейнера = первые 12 символов его ID.
# БД, LB и volumes не трогаем. Вернуть реплику: scripts/restore-replicas.sh
set -eu
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
case "$TARGET_INSTANCE_ID" in
""|*[!0-9a-f]*) echo "bad TARGET_INSTANCE_ID" >&2; exit 2 ;;
esac
# Только контейнер сервиса api нашего проекта: чужой/неизвестный ID не остановим.
container=$(docker ps -q \
--filter "label=com.docker.compose.project=mtusi-lab4" \
--filter "label=com.docker.compose.service=api" \
--filter "id=$TARGET_INSTANCE_ID")
[ -n "$container" ] || { echo "no running api container for the instance" >&2; exit 3; }
[ "$(printf '%s\n' "$container" | wc -l)" -eq 1 ] || { echo "ambiguous instance id" >&2; exit 4; }
# SIGTERM -> drain (3 с) -> завершение; -t 8: не дольше 8 с, чтобы уложиться в 10 с контракта теста.
docker stop -t 8 "$container" >/dev/null
echo "stopped $container"
+185
View File
@@ -0,0 +1,185 @@
#!/usr/bin/env python3
"""Пик памяти API при одновременных загрузках файлов ~9.4 MiB.
Для каждого значения лимита слотов (APP_CONFIG__ATTACHMENTS__MAX_CONCURRENT_UPLOADS через UPLOAD_CONCURRENCY)
реплики API пересоздаются с этим лимитом. Перед каждым сценарием: прогрев (маленькие загрузки, пока каждая
реплика не обслужит хотя бы одну) -> сброс пика RSS процесса (echo 5 > /proc/1/clear_refs) -> базовый VmHWM ->
N одновременных загрузок через LB -> VmHWM после. Разница — сколько памяти добавили сами загрузки.
Запуск из venv (нужен Pillow для генерации файла), стенд уже поднят:
python scripts/upload_memory_experiment.py --limits 8,64 --concurrency 1,10,20
"""
import argparse
import base64
import io
import json
import os
import statistics
import subprocess
import threading
import time
import urllib.error
import urllib.request
import uuid
from collections import Counter
from pathlib import Path
from PIL import Image
ROOT = Path(__file__).resolve().parents[1]
PROJECT = "mtusi-lab4"
MIB = 1024 * 1024
def call(base, method, path, body=None, headers=None, timeout=60):
req = urllib.request.Request(base + path, data=body, method=method, headers=headers or {})
start = time.monotonic()
try:
with urllib.request.urlopen(req, timeout=timeout) as resp:
status, resp_headers, data = resp.status, resp.headers, resp.read()
except urllib.error.HTTPError as exc:
status, resp_headers, data = exc.code, exc.headers, exc.read()
except OSError as exc:
return type(exc).__name__, {}, b"", time.monotonic() - start
return status, resp_headers, data, time.monotonic() - start
def compose(*args, env=None):
subprocess.run(["docker", "compose", *args], check=True, cwd=ROOT, env=env,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
def api_containers():
out = subprocess.run(["docker", "ps", "-q", "--filter", f"label=com.docker.compose.project={PROJECT}",
"--filter", "label=com.docker.compose.service=api"],
check=True, capture_output=True, text=True).stdout
return out.split()
def reset_peak(container):
# Сбросить VmHWM процесса API (PID 1 = python main.py; владелец — тот же appuser).
subprocess.run(["docker", "exec", container, "sh", "-c", "echo 5 > /proc/1/clear_refs"], check=True)
def memory_of(container):
"""VmHWM/VmRSS процесса API, MiB."""
status = subprocess.run(["docker", "exec", container, "cat", "/proc/1/status"],
check=True, capture_output=True, text=True).stdout
values = {line.split(":")[0]: int(line.split()[1]) / 1024 for line in status.splitlines()
if line.startswith(("VmHWM", "VmRSS"))}
return {"rss_peak_mib": round(values["VmHWM"], 1), "rss_now_mib": round(values["VmRSS"], 1)}
def make_noise_png(target_mib):
# Случайный шум почти не сжимается: файл PNG ~ размер сырых пикселей.
side = int((target_mib * MIB / 3) ** 0.5)
image = Image.frombytes("RGB", (side, side), os.urandom(side * side * 3))
buffer = io.BytesIO()
image.save(buffer, "PNG", compress_level=1)
return buffer.getvalue()
def warm_up(base, auth, small_png, chat_id, expected):
"""Маленькие загрузки, пока каждая реплика не обслужит хотя бы одну (импорты, пулы соединений)."""
seen = set()
deadline = time.monotonic() + 60
while len(seen) < expected and time.monotonic() < deadline:
status, headers, _, _ = call(base, "POST", f"/api/v1/chats/{chat_id}/attachments?filename=warm.png",
small_png, {**auth, "Content-Type": "image/png"})
if status == 201:
seen.add(headers.get("X-Instance-Id"))
else:
time.sleep(0.5)
if len(seen) < expected:
raise SystemExit("не дождались обеих реплик")
def run_scenario(base, auth, chat_id, payload, small_png, concurrency):
containers = api_containers()
warm_up(base, auth, small_png, chat_id, len(containers))
for container in containers:
reset_peak(container)
before = {c: memory_of(c) for c in containers}
results = []
barrier = threading.Barrier(concurrency)
def worker():
barrier.wait()
status, headers, _, seconds = call(base, "POST", f"/api/v1/chats/{chat_id}/attachments?filename=big.png",
payload, {**auth, "Content-Type": "image/png"})
results.append({"status": status, "instance": headers.get("X-Instance-Id") if headers else None,
"seconds": seconds})
started = time.monotonic()
threads = [threading.Thread(target=worker) for _ in range(concurrency)]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
wall = time.monotonic() - started
after = {c: memory_of(c) for c in containers}
ok = sorted(r["seconds"] for r in results if r["status"] == 201)
served = Counter(r["instance"] for r in results if r["status"] == 201)
replicas = {}
for c in containers:
replicas[c] = {"uploads_201": served.get(c, 0), "before": before[c], "after": after[c],
"rss_peak_growth_mib": round(after[c]["rss_peak_mib"] - before[c]["rss_now_mib"], 1)}
return {
"concurrency": concurrency,
"statuses": dict(Counter(str(r["status"]) for r in results)),
"wall_seconds": round(wall, 2),
"latency_201_seconds": {"p50": round(statistics.median(ok), 2), "max": round(ok[-1], 2)} if ok else None,
"replicas": replicas,
"max_rss_peak_mib": max(r["after"]["rss_peak_mib"] for r in replicas.values()),
"max_rss_peak_growth_mib": max(r["rss_peak_growth_mib"] for r in replicas.values()),
}
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--limits", default="8,64", help="значения лимита слотов на реплику")
parser.add_argument("--concurrency", default="1,10,20")
parser.add_argument("--file-mib", type=float, default=9.4)
parser.add_argument("--output", default=str(ROOT / "evidence" / "upload-memory.json"))
args = parser.parse_args()
base = args.base_url.rstrip("/")
payload = make_noise_png(args.file_mib)
small_png = make_noise_png(0.01)
if len(payload) > 10 * MIB:
raise SystemExit("файл больше 10 MiB")
username, password = f"mem_{uuid.uuid4().hex[:8]}", "memory-experiment-pass"
user = json.loads(call(base, "POST", "/api/v1/users", json.dumps(
{"username": username, "display_name": "mem", "password": password}).encode(),
{"Content-Type": "application/json"})[2])
basic = base64.b64encode(f"{username}:{password}".encode()).decode()
token = json.loads(call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + basic})[2])["token"]
auth = {"Authorization": "Bearer " + token}
chat_id = json.loads(call(base, "POST", "/api/v1/chats", json.dumps(
{"title": "memory", "member_ids": [user["id"]]}).encode(), {"Content-Type": "application/json", **auth})[2])["id"]
report = {"file_bytes": len(payload), "api_limits": "1 CPU, 512M per replica, 2 replicas",
"method": "peak RSS (VmHWM) of the API process, reset after warm-up; growth = peak after - RSS before",
"runs": []}
try:
for limit in [int(x) for x in args.limits.split(",")]:
env = dict(os.environ, UPLOAD_CONCURRENCY=str(limit))
compose("up", "-d", "--wait", "api", "lb", env=env)
for concurrency in [int(x) for x in args.concurrency.split(",")]:
result = run_scenario(base, auth, chat_id, payload, small_png, concurrency)
result["upload_slots_per_replica"] = limit
report["runs"].append(result)
print(json.dumps({k: v for k, v in result.items() if k != "replicas"}, ensure_ascii=False))
finally:
# Вернуть реплики к лимиту по умолчанию.
env = {k: v for k, v in os.environ.items() if k != "UPLOAD_CONCURRENCY"}
compose("up", "-d", "--wait", "api", "lb", env=env)
Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
if __name__ == "__main__":
main()
+115
View File
@@ -0,0 +1,115 @@
import base64
import os
import uuid
from pathlib import Path
# Отдельная тестовая база; задаётся до импорта приложения (настройки читаются при импорте).
TEST_DB_NAME = "messenger_test"
os.environ["APP_CONFIG__DB__NAME"] = TEST_DB_NAME
# Отдельный приватный bucket (создаёт minio-init): тестовые объекты не смешиваются с рабочими.
os.environ["APP_CONFIG__S3__BUCKET"] = "messenger-attachments-test"
import pytest
from alembic import command
from alembic.config import Config
from fastapi.testclient import TestClient
from sqlalchemy import create_engine, text
from core import s3
from core.db import build_url, engine
from main import app
APP_DIR = Path(__file__).resolve().parents[1] / "app"
PASSWORD = "Test-password-123"
@pytest.fixture(scope="session", autouse=True)
def test_database():
# CREATE DATABASE нельзя выполнить в транзакции, поэтому AUTOCOMMIT.
admin = create_engine(build_url().set(database="postgres"), isolation_level="AUTOCOMMIT")
with admin.connect() as connection:
exists = connection.scalar(text("SELECT 1 FROM pg_database WHERE datname = :name"), {"name": TEST_DB_NAME})
if not exists:
connection.execute(text(f'CREATE DATABASE "{TEST_DB_NAME}"'))
admin.dispose()
command.upgrade(Config(str(APP_DIR / "alembic.ini")), "head")
yield
engine.dispose()
@pytest.fixture(autouse=True)
def clean_database():
with engine.begin() as connection:
connection.execute(text("TRUNCATE users, sessions, chats, chat_members, messages, idempotency_keys, "
"attachments, message_attachments"))
# Вместе с метаданными — и объекты тестового bucket.
for stored in s3.list_objects(""):
s3.delete_object(stored.key)
@pytest.fixture
def client():
return TestClient(app)
def basic(username, password):
credential = base64.b64encode(f"{username}:{password}".encode()).decode()
return {"Authorization": "Basic " + credential}
def login(client, username, password=PASSWORD):
response = client.post("/api/v1/auth/sessions", headers=basic(username, password))
assert response.status_code == 201
return response.json()
def bearer(token):
return {"Authorization": "Bearer " + token}
def with_key(headers, key=None):
"""Добавить обязательный с lab3 Idempotency-Key (по умолчанию — новый уникальный)."""
return {**headers, "Idempotency-Key": key or uuid.uuid4().hex}
def create_user(client, username):
"""Регистрация + вход; заголовок авторизации — в поле "auth"."""
response = client.post("/api/v1/users", json={"username": username, "display_name": "Имя " + username,
"password": PASSWORD})
assert response.status_code == 201
user = response.json()
user["token"] = login(client, username)["token"]
user["auth"] = bearer(user["token"])
return user
@pytest.fixture
def alice(client):
return create_user(client, "alice")
@pytest.fixture
def bob(client):
return create_user(client, "bob")
@pytest.fixture
def eve(client):
return create_user(client, "eve")
@pytest.fixture
def chat(client, alice, bob):
"""Чат alice и bob; eve в него не входит."""
response = client.post("/api/v1/chats", headers=alice["auth"],
json={"title": "Тестовый чат", "member_ids": [alice["id"], bob["id"]]})
assert response.status_code == 201
return response.json()
def assert_error(response, status_code, code):
assert response.status_code == status_code
body = response.json()
assert body["error"]["code"] == code
assert body["error"]["request_id"] == response.headers["X-Request-Id"]
+355
View File
@@ -0,0 +1,355 @@
"""Вложения: загрузка, скачивание, негативные сценарии, отказ S3/БД и очистка объектов-сирот.
Нужны запущенные postgres и minio (docker compose up). Объекты пишутся в отдельный bucket
messenger-attachments-test, метаданные — в базу messenger_test.
"""
import asyncio
import hashlib
import io
import struct
import urllib.error
import urllib.request
import uuid
import zlib
import pytest
from minio.error import S3Error
from PIL import Image
from sqlalchemy import func, select
from sqlalchemy.exc import IntegrityError, OperationalError
from api.v1 import attachments_rout
from conftest import assert_error, with_key
from core import s3
from core.config import settings
from core.db import SessionLocal
from maintenance.reconcile import reconcile
from models import Attachment, MessageAttachment
def make_image(fmt="PNG", size=(64, 48), color=(10, 200, 30)) -> bytes:
buffer = io.BytesIO()
Image.new("RGB", size, color).save(buffer, fmt)
return buffer.getvalue()
def png_header_only(width: int, height: int) -> bytes:
"""Корректный по структуре PNG, который заявляет огромные размеры, но почти ничего не содержит."""
def chunk(kind: bytes, data: bytes) -> bytes:
return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data))
ihdr = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)
return b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", ihdr) + chunk(b"IDAT", zlib.compress(b"\x00" * 16)) + chunk(b"IEND", b"")
PNG = make_image("PNG")
JPEG = make_image("JPEG", size=(320, 200))
def upload(client, user, chat_id, data, content_type="image/png", filename="photo.png"):
return client.post(f"/api/v1/chats/{chat_id}/attachments", params={"filename": filename}, content=data,
headers={**user["auth"], "Content-Type": content_type})
def attachments_in_db() -> int:
with SessionLocal() as db:
return db.scalar(select(func.count()).select_from(Attachment))
def objects_in_bucket() -> list[str]:
return [stored.key for stored in s3.list_objects("")]
def send_message(client, user, chat_id, body, key=None):
return client.post(f"/api/v1/chats/{chat_id}/messages", headers=with_key(user["auth"], key), json=body)
# --- Успешный путь ---
def test_upload_png_and_download_by_other_member(client, alice, bob, chat):
response = upload(client, alice, chat["id"], PNG)
assert response.status_code == 201
attachment = response.json()
assert attachment["status"] == "ready" and attachment["variants"] == [] and attachment["error_code"] is None
assert attachment["chat_id"] == chat["id"] and attachment["owner_id"] == alice["id"]
assert attachment["sha256"] == hashlib.sha256(PNG).hexdigest() and attachment["size_bytes"] == len(PNG)
assert attachment["content_type"] == "image/png" and attachment["filename"] == "photo.png"
# Внутренний ключ S3 наружу не отдаётся; ключ назначен сервером, имя файла в него не входит.
assert "object_key" not in attachment
assert objects_in_bucket() == [f"originals/{attachment['id']}"]
assert client.get(f"/api/v1/attachments/{attachment['id']}", headers=bob["auth"]).json() == attachment
content = client.get(f"/api/v1/attachments/{attachment['id']}/content", headers=bob["auth"])
assert content.status_code == 200
assert content.content == PNG
assert content.headers["content-type"] == "image/png"
def test_upload_jpeg_with_unicode_filename(client, alice, chat):
response = upload(client, alice, chat["id"], JPEG, "image/jpeg", "фото отпуск.jpg")
assert response.status_code == 201
assert response.json()["filename"] == "фото отпуск.jpg"
content = client.get(f"/api/v1/attachments/{response.json()['id']}/content", headers=alice["auth"])
assert content.content == JPEG and content.headers["content-type"] == "image/jpeg"
def test_message_with_attachments_keeps_order_and_is_readable(client, alice, bob, chat):
first = upload(client, alice, chat["id"], PNG).json()["id"]
second = upload(client, alice, chat["id"], JPEG, "image/jpeg").json()["id"]
response = send_message(client, alice, chat["id"], {"text": "", "attachment_ids": [second, first]})
assert response.status_code == 201
assert response.json()["attachment_ids"] == [second, first]
history = client.get(f"/api/v1/chats/{chat['id']}/messages", headers=bob["auth"]).json()
assert history["items"][0]["attachment_ids"] == [second, first]
def test_missing_attachment_ids_equals_empty_list_for_idempotency(client, alice, chat):
key = uuid.uuid4().hex
first = send_message(client, alice, chat["id"], {"text": "привет"}, key)
replay = send_message(client, alice, chat["id"], {"attachment_ids": [], "text": "привет"}, key)
assert first.status_code == replay.status_code == 201
assert replay.json() == first.json() and first.json()["attachment_ids"] == []
# --- Размер, повреждение, подмена MIME, пиксели ---
def test_too_large_file_is_rejected_before_reading(client, alice, chat):
too_large = PNG + b"\x00" * settings.attachments.max_bytes
assert_error(upload(client, alice, chat["id"], too_large), 413, "payload_too_large")
assert attachments_in_db() == 0 and objects_in_bucket() == []
def test_too_large_stream_without_content_length(client, alice, chat):
# Без Content-Length сервер считает фактические байты и обрывает чтение на лимите.
def chunks():
yield PNG
for _ in range(11):
yield b"\x00" * (1024 * 1024)
response = client.post(f"/api/v1/chats/{chat['id']}/attachments", params={"filename": "big.png"},
content=chunks(), headers={**alice["auth"], "Content-Type": "image/png"})
assert_error(response, 413, "payload_too_large")
assert attachments_in_db() == 0
def test_exactly_max_bytes_is_accepted(client, alice, chat):
# Граница включительно: ровно 10 MiB (PNG + данные после IEND, которые декодеры игнорируют).
data = PNG + b"\x00" * (settings.attachments.max_bytes - len(PNG))
response = upload(client, alice, chat["id"], data)
assert response.status_code == 201 and response.json()["size_bytes"] == settings.attachments.max_bytes
def test_pixel_limit_checked_from_header(client, alice, chat):
# 10000 x 5000 = 50 млн пикселей при размере файла ~100 байт: отказ до распаковки.
assert_error(upload(client, alice, chat["id"], png_header_only(10000, 5000)), 413, "payload_too_large")
def broken_crc(data: bytes) -> bytes:
position = data.index(b"IDAT") + 6
return data[:position] + bytes([data[position] ^ 0xFF]) + data[position + 1:]
@pytest.mark.parametrize("data,content_type", [
(PNG[: len(PNG) // 2], "image/png"), # обрезанный PNG
(broken_crc(PNG), "image/png"), # испорченный байт в данных
(JPEG[: len(JPEG) // 3], "image/jpeg"), # обрезанный JPEG
(b"\x89PNG\r\n\x1a\n" + b"\x00" * 64, "image/png"), # только сигнатура
(b"not an image at all", "image/png"),
], ids=["truncated-png", "png-bad-crc", "truncated-jpeg", "png-signature-only", "text"])
def test_corrupted_image_is_415(client, alice, chat, data, content_type):
assert_error(upload(client, alice, chat["id"], data, content_type), 415, "unsupported_media_type")
assert attachments_in_db() == 0 and objects_in_bucket() == []
@pytest.mark.parametrize("data,content_type", [
(PNG, "image/jpeg"),
(JPEG, "image/png"),
(PNG, "text/plain"),
(PNG, "image/gif"),
(b"GIF89a" + b"\x00" * 32, "image/png"),
], ids=["png-as-jpeg", "jpeg-as-png", "png-as-text", "png-as-gif", "gif-as-png"])
def test_mime_spoofing_is_415(client, alice, chat, data, content_type):
assert_error(upload(client, alice, chat["id"], data, content_type), 415, "unsupported_media_type")
def test_empty_body_is_400(client, alice, chat):
assert_error(upload(client, alice, chat["id"], b""), 400, "invalid_request")
@pytest.mark.parametrize("filename", ["a/b.png", "..\\evil.png", "a\x00b.png", "line\nbreak.png", "tab\t.png",
" ", "..", "x" * 256])
def test_dangerous_filename_is_400(client, alice, chat, filename):
assert_error(upload(client, alice, chat["id"], PNG, filename=filename), 400, "invalid_request")
assert objects_in_bucket() == []
def test_missing_filename_is_400(client, alice, chat):
response = client.post(f"/api/v1/chats/{chat['id']}/attachments", content=PNG,
headers={**alice["auth"], "Content-Type": "image/png"})
assert_error(response, 400, "invalid_request")
# --- Доступ: чужой чат, чужое attachment_id, файл другого чата ---
def test_outsider_cannot_upload_or_read(client, alice, eve, chat):
assert_error(upload(client, eve, chat["id"], PNG), 404, "not_found")
attachment_id = upload(client, alice, chat["id"], PNG).json()["id"]
assert_error(client.get(f"/api/v1/attachments/{attachment_id}", headers=eve["auth"]), 404, "not_found")
assert_error(client.get(f"/api/v1/attachments/{attachment_id}/content", headers=eve["auth"]), 404, "not_found")
def test_unknown_and_unauthenticated(client, alice, chat):
unknown = uuid.uuid4()
assert_error(client.get(f"/api/v1/attachments/{unknown}", headers=alice["auth"]), 404, "not_found")
assert_error(client.get(f"/api/v1/attachments/{unknown}/content", headers=alice["auth"]), 404, "not_found")
response = client.post(f"/api/v1/chats/{chat['id']}/attachments", params={"filename": "a.png"}, content=PNG,
headers={"Content-Type": "image/png"})
assert_error(response, 401, "unauthorized")
assert_error(client.get(f"/api/v1/attachments/{unknown}", headers={}), 401, "unauthorized")
def test_missing_variant_is_404_and_bad_variant_is_400(client, alice, chat):
attachment_id = upload(client, alice, chat["id"], PNG).json()["id"]
path = f"/api/v1/attachments/{attachment_id}/content"
assert_error(client.get(path, params={"variant": "thumbnail"}, headers=alice["auth"]), 404, "not_found")
assert_error(client.get(path, params={"variant": "huge"}, headers=alice["auth"]), 400, "invalid_request")
def test_foreign_attachment_id_in_message_is_404(client, alice, bob, eve, chat):
# Файл из чата alice+eve нельзя прикрепить к сообщению в чате alice+bob, хотя alice состоит в обоих.
other_chat = client.post("/api/v1/chats", headers=alice["auth"],
json={"title": "другой", "member_ids": [alice["id"], eve["id"]]}).json()
foreign = upload(client, alice, other_chat["id"], PNG).json()["id"]
key = uuid.uuid4().hex
assert_error(send_message(client, alice, chat["id"], {"text": "", "attachment_ids": [foreign]}, key),
404, "not_found")
assert_error(send_message(client, bob, chat["id"], {"text": "x", "attachment_ids": [str(uuid.uuid4())]}),
404, "not_found")
assert client.get(f"/api/v1/chats/{chat['id']}/messages", headers=alice["auth"]).json()["items"] == []
# Отказ не «занял» ключ: исправленный запрос с тем же ключом проходит.
own = upload(client, alice, chat["id"], PNG).json()["id"]
assert send_message(client, alice, chat["id"], {"text": "", "attachment_ids": [own]}, key).status_code == 201
def test_database_rejects_link_to_attachment_of_other_chat(client, alice, eve, chat):
other_chat = client.post("/api/v1/chats", headers=alice["auth"],
json={"title": "другой", "member_ids": [alice["id"], eve["id"]]}).json()
foreign = upload(client, alice, other_chat["id"], PNG).json()["id"]
message_id = send_message(client, alice, chat["id"], {"text": "hi"}).json()["id"]
with SessionLocal() as db, pytest.raises(IntegrityError):
db.add(MessageAttachment(message_id=message_id, attachment_id=foreign, chat_id=chat["id"], position=0))
db.commit()
@pytest.mark.parametrize("body", [
{"text": "x", "attachment_ids": [str(uuid.uuid4()) for _ in range(11)]},
{"text": " "},
{"text": "", "attachment_ids": []},
{"text": "x", "attachment_ids": ["not-a-uuid"]},
], ids=["11-ids", "blank-text", "empty-without-attachments", "bad-uuid"])
def test_invalid_message_attachments_are_400(client, alice, chat, body):
assert_error(send_message(client, alice, chat["id"], body), 400, "invalid_request")
def test_duplicate_attachment_ids_are_400(client, alice, chat):
attachment_id = upload(client, alice, chat["id"], PNG).json()["id"]
body = {"text": "", "attachment_ids": [attachment_id, attachment_id]}
assert_error(send_message(client, alice, chat["id"], body), 400, "invalid_request")
# --- Отказы S3 и БД, компенсация и очистка сирот ---
def test_storage_down_on_upload_is_503_without_metadata(client, alice, chat, monkeypatch):
def fail(*args, **kwargs):
raise s3.StorageUnavailable()
monkeypatch.setattr(s3, "put_object", fail)
assert_error(upload(client, alice, chat["id"], PNG), 503, "unavailable")
assert attachments_in_db() == 0
def test_storage_down_on_download_is_503(client, alice, chat, monkeypatch):
attachment_id = upload(client, alice, chat["id"], PNG).json()["id"]
def fail(*args, **kwargs):
raise s3.StorageUnavailable()
monkeypatch.setattr(s3, "open_object", fail)
assert_error(client.get(f"/api/v1/attachments/{attachment_id}/content", headers=alice["auth"]), 503, "unavailable")
def db_commit_fails(*args, **kwargs):
raise OperationalError("INSERT INTO attachments", {}, Exception("connection lost"))
def test_commit_failure_after_put_deletes_object(client, alice, chat, monkeypatch):
# PUT в S3 прошёл, COMMIT — нет: API сразу удаляет объект (компенсация).
monkeypatch.setattr(attachments_rout, "create_attachment", db_commit_fails)
assert_error(upload(client, alice, chat["id"], PNG), 503, "unavailable")
assert attachments_in_db() == 0
assert objects_in_bucket() == []
def test_orphan_left_by_failed_compensation_is_removed_only_after_grace(client, alice, bob, chat, monkeypatch):
# Используемое вложение и прикреплённое к сообщению — не должны пострадать.
kept = upload(client, alice, chat["id"], PNG).json()["id"]
send_message(client, alice, chat["id"], {"text": "", "attachment_ids": [kept]})
# COMMIT не прошёл, и удалить объект тоже не удалось (S3 «моргнул»): остаётся сирота.
monkeypatch.setattr(attachments_rout, "create_attachment", db_commit_fails)
def delete_fails(key):
raise s3.StorageUnavailable()
monkeypatch.setattr(s3, "delete_object", delete_fails)
assert_error(upload(client, bob, chat["id"], JPEG, "image/jpeg"), 503, "unavailable")
monkeypatch.undo()
assert attachments_in_db() == 1 and len(objects_in_bucket()) == 2
with SessionLocal() as db:
# Свежая сирота может принадлежать загрузке «между PUT и COMMIT» — не трогаем.
fresh = reconcile(db, apply=True, grace_seconds=3600)
assert fresh["issues"]["orphan_object_fresh"] == 1 and fresh["ok"] == 1
assert fresh["actions"]["objects_deleted"] == 0
# Dry-run показывает, но не удаляет.
dry = reconcile(db, apply=False, grace_seconds=0)
assert dry["issues"]["orphan_object"] == 1 and len(objects_in_bucket()) == 2
applied = reconcile(db, apply=True, grace_seconds=0)
assert applied["actions"]["objects_deleted"] == 1
# Повторный запуск ничего не находит.
again = reconcile(db, apply=True, grace_seconds=0)
assert sum(again["issues"].values()) == 0 and again["ok"] == 1
assert objects_in_bucket() == [f"originals/{kept}"]
content = client.get(f"/api/v1/attachments/{kept}/content", headers=bob["auth"])
assert content.status_code == 200 and content.content == PNG
def test_upload_slots_exhausted_is_503(client, alice, chat, monkeypatch):
monkeypatch.setattr(attachments_rout, "upload_slots", asyncio.Semaphore(0))
monkeypatch.setattr(settings.attachments, "slot_wait_seconds", 0.1)
response = upload(client, alice, chat["id"], PNG)
assert_error(response, 503, "unavailable")
assert response.headers["Retry-After"] == "1"
# --- Приватность bucket и права credentials API (проверки вне API) ---
def anonymous_get(url):
try:
with urllib.request.urlopen(url, timeout=5) as response:
return response.status
except urllib.error.HTTPError as exc:
return exc.code
def test_bucket_is_private_outside_api(client, alice, chat):
attachment_id = upload(client, alice, chat["id"], PNG).json()["id"]
base = f"{settings.s3.endpoint}/{settings.s3.bucket}"
assert anonymous_get(f"{base}/originals/{attachment_id}") == 403
assert anonymous_get(f"{base}?list-type=2") == 403
def test_api_credentials_cannot_administer_storage():
# Пользователь API не root: MinIO показывает ему только bucket из его политики, создавать новые нельзя.
client = s3.get_client()
assert {bucket.name for bucket in client.list_buckets()} <= {"messenger-attachments", "messenger-attachments-test",
"messenger-attachments-bench"}
with pytest.raises(S3Error) as creating:
client.make_bucket("not-allowed-" + uuid.uuid4().hex[:8])
assert creating.value.code == "AccessDenied"
+107
View File
@@ -0,0 +1,107 @@
import time
import jwt
from sqlalchemy import text
from conftest import PASSWORD, assert_error, basic, bearer, login
from core.config import settings
from core.db import engine
def assert_challenge(response, scheme):
assert response.headers["WWW-Authenticate"].startswith(scheme + ' realm="messenger"')
def test_login_returns_session(client, alice):
session = login(client, "alice")
assert session["token_type"] == "Bearer"
assert len(session["token"]) >= 32
assert session["expires_at"].endswith("Z")
assert session["user"]["id"] == alice["id"]
assert "password" not in session["user"] and "password_hash" not in session["user"]
assert login(client, "alice")["token"] != session["token"]
def test_jwt_payload_contains_sub_exp_jti(client, alice):
payload = jwt.decode(alice["token"], options={"verify_signature": False})
assert payload["sub"] == alice["id"]
assert payload["exp"] - payload["iat"] == settings.jwt.session_ttl_seconds
assert len(payload["jti"]) >= 43
def test_wrong_password_and_unknown_user_give_same_401(client, alice):
wrong = client.post("/api/v1/auth/sessions", headers=basic("alice", "Wrong-password-1"))
unknown = client.post("/api/v1/auth/sessions", headers=basic("nobody", PASSWORD))
for response in (wrong, unknown):
assert_error(response, 401, "unauthorized")
assert_challenge(response, "Basic")
assert 'charset="UTF-8"' in response.headers["WWW-Authenticate"]
assert wrong.json()["error"]["message"] == unknown.json()["error"]["message"]
def test_malformed_basic_returns_401(client):
for header in ("", "Basic", "Basic !!!not-base64!!!", "Bearer abc", "Basic " + "YWxpY2U="): # последний — без ':'
response = client.post("/api/v1/auth/sessions", headers={"Authorization": header})
assert_error(response, 401, "unauthorized")
assert_challenge(response, "Basic")
def test_login_with_body_returns_400_and_creates_no_session(client, alice):
with engine.connect() as connection:
before = connection.scalar(text("SELECT count(*) FROM sessions"))
for kwargs in ({"json": {"unexpected": True}}, {"json": {}}, {"content": b"x"}):
response = client.post("/api/v1/auth/sessions", headers=basic("alice", PASSWORD), **kwargs)
assert_error(response, 400, "invalid_request")
with engine.connect() as connection:
assert connection.scalar(text("SELECT count(*) FROM sessions")) == before
# Без тела вход по-прежнему работает.
assert login(client, "alice")["user"]["id"] == alice["id"]
def test_password_with_colon_and_unicode(client):
password = "пароль:с:двоеточиями 👋"
client.post("/api/v1/users", json={"username": "colon", "display_name": "C", "password": password})
assert login(client, "colon", password)["user"]["username"] == "colon"
def test_protected_endpoint_requires_bearer(client, alice):
cases = [{}, basic("alice", PASSWORD), bearer("not-a-jwt"), {"Authorization": "Bearer"}]
for headers in cases:
response = client.get("/api/v1/users/me", headers=headers)
assert_error(response, 401, "unauthorized")
assert_challenge(response, "Bearer")
def test_x_user_id_does_not_override_token(client, alice, eve):
response = client.get("/api/v1/users/me", headers={**alice["auth"], "X-User-Id": eve["id"]})
assert response.json()["id"] == alice["id"]
def test_forged_token_is_rejected(client, alice):
payload = jwt.decode(alice["token"], options={"verify_signature": False})
forged = jwt.encode(payload, "attacker-key-attacker-key-attacker-key!!", algorithm="HS256")
assert_error(client.get("/api/v1/users/me", headers=bearer(forged)), 401, "unauthorized")
unsigned = jwt.encode(payload, None, algorithm="none")
assert_error(client.get("/api/v1/users/me", headers=bearer(unsigned)), 401, "unauthorized")
def test_logout_revokes_only_current_token(client, alice):
second = login(client, "alice")["token"]
response = client.delete("/api/v1/auth/sessions/current", headers=alice["auth"])
assert response.status_code == 204
assert response.content == b""
assert_error(client.get("/api/v1/users/me", headers=alice["auth"]), 401, "unauthorized")
assert_error(client.delete("/api/v1/auth/sessions/current", headers=alice["auth"]), 401, "unauthorized")
# Другая сессия того же пользователя продолжает работать.
assert client.get("/api/v1/users/me", headers=bearer(second)).status_code == 200
def test_session_expires(client, alice, monkeypatch):
# TTL с запасом на вход (Argon2 под нагрузкой бывает ~1 с): с TTL 1 с тест изредка падал до первой проверки.
monkeypatch.setattr(settings.jwt, "session_ttl_seconds", 3)
token = login(client, "alice")["token"]
assert client.get("/api/v1/users/me", headers=bearer(token)).status_code == 200
time.sleep(4.1)
response = client.get("/api/v1/users/me", headers=bearer(token))
assert_error(response, 401, "unauthorized")
assert_challenge(response, "Bearer")
+54
View File
@@ -0,0 +1,54 @@
import uuid
from sqlalchemy import text
from conftest import assert_error, with_key
from core.db import engine
def count_rows(table):
with engine.connect() as connection:
return connection.scalar(text(f"SELECT count(*) FROM {table}"))
def test_unknown_member_returns_400_and_nothing_is_saved(client, alice):
response = client.post("/api/v1/chats", headers=alice["auth"],
json={"title": "С призраком", "member_ids": [alice["id"], str(uuid.uuid4())]})
assert_error(response, 400, "invalid_request")
assert count_rows("chats") == 0
assert count_rows("chat_members") == 0
def test_created_chat_is_stored_with_members(client, chat, alice, bob):
assert sorted(chat["member_ids"]) == sorted([alice["id"], bob["id"]])
assert count_rows("chats") == 1
assert count_rows("chat_members") == 2
again = client.get("/api/v1/chats/" + chat["id"], headers=bob["auth"]).json()
assert again == chat
def test_foreign_chat_returns_404(client, chat, eve):
headers = eve["auth"]
path = "/api/v1/chats/" + chat["id"]
assert_error(client.get(path, headers=headers), 404, "not_found")
assert_error(client.get(path + "/messages", headers=headers), 404, "not_found")
assert_error(client.post(path + "/messages", headers=with_key(headers), json={"text": "чужое"}), 404, "not_found")
assert client.get("/api/v1/chats", headers=headers).json()["items"] == []
def test_member_sees_chat(client, chat, bob):
response = client.get("/api/v1/chats", headers=bob["auth"])
assert [c["id"] for c in response.json()["items"]] == [chat["id"]]
def test_creator_must_be_member(client, alice, bob):
response = client.post("/api/v1/chats", headers=alice["auth"],
json={"title": "Без меня", "member_ids": [bob["id"]]})
assert_error(response, 400, "invalid_request")
def test_duplicate_members_return_400(client, alice):
response = client.post("/api/v1/chats", headers=alice["auth"],
json={"title": "Дубли", "member_ids": [alice["id"], alice["id"]]})
assert_error(response, 400, "invalid_request")
+162
View File
@@ -0,0 +1,162 @@
import datetime as dt
from concurrent.futures import ThreadPoolExecutor
from fastapi.testclient import TestClient
from sqlalchemy import text
from conftest import assert_error, with_key
from core.config import settings
from core.db import engine
from main import app
from utils import lifecycle
def messages_path(chat):
return "/api/v1/chats/" + chat["id"] + "/messages"
def count_messages():
with engine.connect() as connection:
return connection.scalar(text("SELECT count(*) FROM messages"))
def test_missing_or_invalid_key_returns_400(client, chat, alice):
path = messages_path(chat)
assert_error(client.post(path, headers=alice["auth"], json={"text": "без ключа"}), 400, "invalid_request")
# Только ASCII: HTTP-заголовок с кириллицей тестовый клиент отправить не может.
for key in ("", "a b", "x" * 129, "bad/key", "bad,key"):
response = client.post(path, headers={**alice["auth"], "Idempotency-Key": key}, json={"text": "плохой ключ"})
assert_error(response, 400, "invalid_request")
assert count_messages() == 0
def test_valid_key_alphabet_and_max_length(client, chat, alice):
path = messages_path(chat)
for key in ("A-z_0.9:x", "k" * 128):
assert client.post(path, headers=with_key(alice["auth"], key), json={"text": key[:5]}).status_code == 201
def test_replay_returns_same_message_without_duplicate(client, chat, alice):
path = messages_path(chat)
headers = with_key(alice["auth"], "replay-1")
first = client.post(path, headers=headers, json={"text": "один раз"})
second = client.post(path, headers=headers, json={"text": "один раз"})
assert first.status_code == second.status_code == 201
assert first.json() == second.json()
assert count_messages() == 1
def test_json_key_order_and_whitespace_do_not_matter(client, chat, alice):
path = messages_path(chat)
headers = {**with_key(alice["auth"], "order-1"), "Content-Type": "application/json"}
first = client.post(path, headers=headers, content='{"text": "тот же текст"}')
second = client.post(path, headers=headers, content='{ "text" :"тот же текст" }')
assert first.status_code == second.status_code == 201
assert first.json() == second.json()
assert count_messages() == 1
def test_same_key_with_other_body_returns_409(client, chat, alice):
path = messages_path(chat)
headers = with_key(alice["auth"], "conflict-1")
assert client.post(path, headers=headers, json={"text": "первое"}).status_code == 201
assert_error(client.post(path, headers=headers, json={"text": "другое"}), 409, "conflict")
assert count_messages() == 1
def test_key_scope_is_user_and_chat(client, chat, alice, bob):
path = messages_path(chat)
a = client.post(path, headers=with_key(alice["auth"], "shared"), json={"text": "alice"})
b = client.post(path, headers=with_key(bob["auth"], "shared"), json={"text": "bob"})
assert a.status_code == b.status_code == 201
assert a.json()["id"] != b.json()["id"]
other = client.post("/api/v1/chats", headers=alice["auth"],
json={"title": "Другой", "member_ids": [alice["id"]]}).json()
c = client.post(messages_path(other), headers=with_key(alice["auth"], "shared"), json={"text": "alice"})
assert c.status_code == 201
assert c.json()["id"] != a.json()["id"]
assert count_messages() == 3
def test_replay_still_checks_session_and_membership(client, chat, alice, eve):
path = messages_path(chat)
assert client.post(path, headers=with_key(alice["auth"], "k1"), json={"text": "секрет"}).status_code == 201
# Посторонний с тем же ключом не получает чужое сообщение.
assert_error(client.post(path, headers=with_key(eve["auth"], "k1"), json={"text": "секрет"}), 404, "not_found")
# Без токена повтор тоже отклоняется.
assert_error(client.post(path, headers={"Idempotency-Key": "k1"}, json={"text": "секрет"}), 401, "unauthorized")
def test_failed_request_does_not_consume_key(client, chat, alice):
path = messages_path(chat)
headers = with_key(alice["auth"], "retry-after-error")
assert_error(client.post(path, headers=headers, json={"text": ""}), 400, "invalid_request")
# Тот же ключ после ошибки валидации можно использовать для корректного запроса.
assert client.post(path, headers=headers, json={"text": "теперь верно"}).status_code == 201
def test_expired_key_is_reusable(client, chat, alice):
path = messages_path(chat)
headers = with_key(alice["auth"], "ttl-1")
first = client.post(path, headers=headers, json={"text": "старое"}).json()
old = dt.datetime.now(dt.timezone.utc) - dt.timedelta(seconds=settings.idempotency.ttl_seconds + 60)
with engine.begin() as connection:
connection.execute(text("UPDATE idempotency_keys SET created_at = :old"), {"old": old})
# Спустя TTL тот же ключ может описывать уже другое сообщение.
second = client.post(path, headers=headers, json={"text": "новое"})
assert second.status_code == 201
assert second.json()["id"] != first["id"]
assert client.post(path, headers=headers, json={"text": "новое"}).json() == second.json()
def test_concurrent_requests_with_one_key_create_one_message(chat, alice):
path = messages_path(chat)
headers = with_key(alice["auth"], "parallel-1")
def send(_):
# Отдельный клиент на поток (без `with`: lifespan закрыл бы общий пул соединений).
return TestClient(app).post(path, headers=headers, json={"text": "гонка"})
with ThreadPoolExecutor(max_workers=16) as pool:
responses = list(pool.map(send, range(16)))
assert {r.status_code for r in responses} == {201}
assert len({r.json()["id"] for r in responses}) == 1
assert count_messages() == 1
def test_concurrent_different_bodies_one_key_only_one_wins(chat, alice):
path = messages_path(chat)
headers = with_key(alice["auth"], "parallel-2")
def send(i):
return TestClient(app).post(path, headers=headers, json={"text": f"вариант {i % 2}"})
with ThreadPoolExecutor(max_workers=8) as pool:
responses = list(pool.map(send, range(8)))
statuses = sorted(r.status_code for r in responses)
assert set(statuses) <= {201, 409} and 201 in statuses
assert count_messages() == 1
def test_instance_id_header_is_present_and_stable(client, alice):
first = client.get("/health/live")
second = client.get("/api/v1/users/me", headers=alice["auth"])
error = client.get("/api/v1/users/me")
assert first.headers["X-Instance-Id"] == settings.run.instance_id
assert second.headers["X-Instance-Id"] == error.headers["X-Instance-Id"] == first.headers["X-Instance-Id"]
assert error.status_code == 401
def test_ready_returns_503_while_draining(client):
assert client.get("/health/ready").status_code == 200
lifecycle._draining.set()
try:
ready = client.get("/health/ready")
assert_error(ready, 503, "unavailable")
assert client.get("/health/live").status_code == 200 # процесс жив и обслуживает запросы
finally:
lifecycle._draining.clear()
assert client.get("/health/ready").status_code == 200
+66
View File
@@ -0,0 +1,66 @@
from conftest import assert_error, with_key
def test_empty_message_returns_400(client, chat, alice):
path = "/api/v1/chats/" + chat["id"] + "/messages"
headers = with_key(alice["auth"])
assert_error(client.post(path, headers=headers, json={"text": ""}), 400, "invalid_request")
assert_error(client.post(path, headers=headers, json={"text": " \n\t"}), 400, "invalid_request")
def test_sender_is_taken_from_token(client, chat, alice, bob):
path = "/api/v1/chats/" + chat["id"] + "/messages"
response = client.post(path, headers=with_key(bob["auth"]), json={"text": "Привет 👋"})
assert response.status_code == 201
assert response.json()["sender_id"] == bob["id"]
assert response.json()["text"] == "Привет 👋"
spoof = client.post(path, headers=with_key(bob["auth"]), json={"text": "x", "sender_id": alice["id"]})
assert_error(spoof, 400, "invalid_request")
def test_pagination_over_several_pages(client, chat, alice):
path = "/api/v1/chats/" + chat["id"] + "/messages"
headers = alice["auth"]
sent = [client.post(path, headers=with_key(headers), json={"text": f"сообщение {i}"}).json() for i in range(7)]
received = []
pages = 0
cursor = None
while True:
params = {"limit": 3}
if cursor:
params["cursor"] = cursor
page = client.get(path, headers=headers, params=params).json()
received += page["items"]
pages += 1
cursor = page["next_cursor"]
if cursor is None:
break
assert pages == 3 # 3 + 3 + 1
assert received == sent # тот же порядок, ничего не потеряно
assert len({m["id"] for m in received}) == 7 # без повторов
def test_cursor_from_another_chat_returns_400(client, chat, alice):
headers = alice["auth"]
path = "/api/v1/chats/" + chat["id"] + "/messages"
for i in range(2):
client.post(path, headers=with_key(headers), json={"text": f"m{i}"})
cursor = client.get(path, headers=headers, params={"limit": 1}).json()["next_cursor"]
other = client.post("/api/v1/chats", headers=headers, json={"title": "Другой", "member_ids": [alice["id"]]}).json()
response = client.get("/api/v1/chats/" + other["id"] + "/messages", headers=headers, params={"cursor": cursor})
assert_error(response, 400, "invalid_request")
response = client.get(path, headers=headers, params={"cursor": "мусор"})
assert_error(response, 400, "invalid_request")
def test_invalid_limit_returns_400(client, chat, alice):
path = "/api/v1/chats/" + chat["id"] + "/messages"
for limit in (0, 101, "abc"):
response = client.get(path, headers=alice["auth"], params={"limit": limit})
assert_error(response, 400, "invalid_request")
+148
View File
@@ -0,0 +1,148 @@
"""Сверка хранилищ (трек 2): обнаружение расхождений с обеих сторон и безопасное исправление."""
import uuid
import pytest
from sqlalchemy import text, update
from conftest import with_key
from core import s3
from core.db import SessionLocal, engine
from maintenance import reconcile as rec
from models import Attachment
from test_attachments_api import JPEG, PNG, objects_in_bucket, upload
HOUR_AGO = text("clock_timestamp() - interval '2 hours'")
def attach(client, user, chat_id, attachment_ids):
response = client.post(f"/api/v1/chats/{chat_id}/messages", headers=with_key(user["auth"]),
json={"text": "", "attachment_ids": attachment_ids})
assert response.status_code == 201
def backdate(*attachment_ids):
with SessionLocal() as db:
db.execute(update(Attachment).where(Attachment.id.in_(attachment_ids)).values(created_at=HOUR_AGO))
db.commit()
@pytest.fixture
def broken_state(client, alice, chat):
"""По одному вложению каждого вида. Объекты S3 изменить «задним числом» нельзя, поэтому все сироты свежие."""
ids = {name: upload(client, alice, chat["id"], PNG).json()["id"]
for name in ("ok_referenced", "ok_free", "missing_free", "missing_referenced", "missing_fresh",
"size_mismatch", "checksum_mismatch")}
attach(client, alice, chat["id"], [ids["ok_referenced"], ids["missing_referenced"]])
for name in ("missing_free", "missing_referenced", "missing_fresh"):
s3.delete_object(f"originals/{ids[name]}")
with SessionLocal() as db:
db.execute(update(Attachment).where(Attachment.id == ids["size_mismatch"])
.values(size_bytes=Attachment.size_bytes + 1))
db.commit()
# Тот же размер, другие байты: заметит только проверка SHA-256.
s3.put_object(f"originals/{ids['checksum_mismatch']}", bytes(len(PNG)), "image/png", "0" * 64)
ids["orphan_fresh"] = str(uuid.uuid4())
s3.put_object(f"originals/{ids['orphan_fresh']}", JPEG, "image/jpeg", "0" * 64)
backdate(*(ids[name] for name in ids if name not in ("missing_fresh", "orphan_fresh")))
return ids
def test_detects_both_sides_and_fixes_only_safe_cases(client, alice, chat, broken_state):
ids = broken_state
with SessionLocal() as db:
dry = rec.reconcile(db, apply=False, grace_seconds=3600, verify_checksums=True)
assert dry["issues"] == {"orphan_object": 0, "orphan_object_fresh": 1, "missing_object": 1,
"missing_object_referenced": 1, "missing_object_fresh": 1,
"size_mismatch": 1, "checksum_mismatch": 1}
assert dry["ok"] == 2 and dry["samples"]["missing_object"] == [ids["missing_free"]]
assert dry["actions"] == {"objects_deleted": 0, "rows_deleted": 0, "skipped_on_recheck": 0}
applied = rec.reconcile(db, apply=True, grace_seconds=3600, verify_checksums=True)
# Исправляется только безопасное: строка без объекта, ни к чему не прикреплённая и не свежая.
assert applied["actions"] == {"objects_deleted": 0, "rows_deleted": 1, "skipped_on_recheck": 0}
again = rec.reconcile(db, apply=True, grace_seconds=3600, verify_checksums=True)
assert again["issues"]["missing_object"] == 0
assert again["actions"] == {"objects_deleted": 0, "rows_deleted": 0, "skipped_on_recheck": 0}
# Без чтения объектов подмену содержимого того же размера не видно.
shallow = rec.reconcile(db, apply=False, grace_seconds=3600)
assert shallow["issues"]["checksum_mismatch"] == 0 and shallow["ok"] == 3
get = lambda name: client.get(f"/api/v1/attachments/{ids[name]}", headers=alice["auth"]).status_code
assert get("missing_free") == 404
# Прикреплённое к сообщению, свежее и повреждённые — на месте (их чинят из бэкапа, а не удалением).
for name in ("ok_referenced", "ok_free", "missing_referenced", "missing_fresh", "size_mismatch",
"checksum_mismatch"):
assert get(name) == 200
for name in ("ok_referenced", "ok_free"):
content = client.get(f"/api/v1/attachments/{ids[name]}/content", headers=alice["auth"])
assert content.status_code == 200 and content.content == PNG
assert f"originals/{ids['orphan_fresh']}" in objects_in_bucket()
def test_message_cannot_use_attachment_removed_by_reconcile(client, alice, chat, broken_state):
with SessionLocal() as db:
rec.reconcile(db, apply=True, grace_seconds=3600)
response = client.post(f"/api/v1/chats/{chat['id']}/messages", headers=with_key(alice["auth"]),
json={"text": "", "attachment_ids": [broken_state["missing_free"]]})
assert response.status_code == 404
def test_old_orphans_deleted_and_used_objects_kept(client, alice, chat):
used = upload(client, alice, chat["id"], PNG).json()["id"]
attach(client, alice, chat["id"], [used])
orphans = [f"originals/{uuid.uuid4()}" for _ in range(3)]
for key in orphans:
s3.put_object(key, PNG, "image/png", "0" * 64)
with SessionLocal() as db:
# grace 0: все сироты «старые».
report = rec.reconcile(db, apply=True, grace_seconds=0)
assert report["issues"]["orphan_object"] == 3 and report["actions"]["objects_deleted"] == 3
assert objects_in_bucket() == [f"originals/{used}"]
def test_apply_refuses_mass_delete(client, alice, chat):
for _ in range(3):
s3.put_object(f"originals/{uuid.uuid4()}", PNG, "image/png", "0" * 64)
with SessionLocal() as db:
report = rec.reconcile(db, apply=True, grace_seconds=0, max_deletes=2)
assert "aborted" in report and report["actions"]["objects_deleted"] == 0
assert len(objects_in_bucket()) == 3
def test_recheck_keeps_object_whose_metadata_appeared_after_listing(client, alice, chat):
# Объект попал в листинг без строки, а до удаления загрузка успела закоммитить метаданные.
attachment_id = upload(client, alice, chat["id"], PNG).json()["id"]
key = f"originals/{attachment_id}"
stored = next(o for o in s3.list_objects("originals/") if o.key == key)
with SessionLocal() as db:
assert rec.delete_orphan_object(db, stored) is False
assert key in objects_in_bucket()
def test_recheck_keeps_row_that_got_referenced(client, alice, chat):
attachment_id = upload(client, alice, chat["id"], PNG).json()["id"]
s3.delete_object(f"originals/{attachment_id}")
with SessionLocal() as db:
row = next(r for r in rec.stream_rows(db, "originals/") if str(r.id) == attachment_id)
db.commit()
# После сканирования строку прикрепили к сообщению — удалять её уже нельзя.
attach(client, alice, chat["id"], [attachment_id])
with SessionLocal() as db:
assert rec.delete_missing_row(db, row) is False
assert client.get(f"/api/v1/attachments/{attachment_id}", headers=alice["auth"]).status_code == 200
def test_second_run_is_refused_while_first_holds_lock():
with engine.connect() as other:
other.execute(text("SELECT pg_advisory_lock(:id)"), {"id": rec.ADVISORY_LOCK_ID})
try:
with pytest.raises(rec.ReconcileAborted):
rec.run_locked(apply=True)
finally:
other.execute(text("SELECT pg_advisory_unlock(:id)"), {"id": rec.ADVISORY_LOCK_ID})
def test_unordered_stream_aborts():
with pytest.raises(rec.ReconcileAborted):
list(rec.ordered(iter(["b", "a"]), lambda k: k.encode(), "S3"))
+69
View File
@@ -0,0 +1,69 @@
import uuid
from sqlalchemy import text
from conftest import PASSWORD, assert_error
from core.db import engine
def test_invalid_json_returns_400(client):
response = client.post("/api/v1/users", content=b'{"username": "bob",',
headers={"Content-Type": "application/json"})
assert_error(response, 400, "invalid_request")
def test_extra_field_and_wrong_type_return_400(client):
response = client.post("/api/v1/users", json={"username": "bob", "display_name": "Bob", "password": PASSWORD,
"admin": True})
assert_error(response, 400, "invalid_request")
response = client.post("/api/v1/users", json={"username": "bob", "display_name": 123, "password": PASSWORD})
assert_error(response, 400, "invalid_request")
def test_duplicate_username_returns_409(client, alice):
response = client.post("/api/v1/users", json={"username": "alice", "display_name": "Другая Алиса",
"password": PASSWORD})
assert_error(response, 409, "conflict")
def test_unicode_display_name_is_kept(client):
response = client.post("/api/v1/users", json={"username": "uni", "display_name": "Алиса 👋",
"password": PASSWORD})
assert response.status_code == 201
assert response.json()["display_name"] == "Алиса 👋"
def test_password_is_required_and_length_checked(client):
for password in (None, "short", "x" * 129):
body = {"username": "pwd", "display_name": "P"}
if password is not None:
body["password"] = password
assert_error(client.post("/api/v1/users", json=body), 400, "invalid_request")
# 12 символов (не байт) — допустимо.
response = client.post("/api/v1/users", json={"username": "pwd", "display_name": "P", "password": "пароль123456"})
assert response.status_code == 201
def test_password_is_hashed_and_never_returned(client, alice):
assert "password" not in alice and "password_hash" not in alice
with engine.connect() as connection:
stored = connection.scalar(text("SELECT password_hash FROM users WHERE username = 'alice'"))
assert stored.startswith("$argon2id$")
assert PASSWORD not in stored
def test_me_returns_current_user(client, alice):
response = client.get("/api/v1/users/me", headers=alice["auth"])
assert response.status_code == 200
assert response.json() == {key: alice[key] for key in ("id", "username", "display_name", "created_at")}
def test_x_user_id_no_longer_authenticates(client, alice):
assert_error(client.get("/api/v1/users/me", headers={"X-User-Id": alice["id"]}), 401, "unauthorized")
assert_error(client.get("/api/v1/users/me", headers={"X-User-Id": str(uuid.uuid4())}), 401, "unauthorized")
def test_every_response_has_request_id(client):
assert client.get("/health/live").headers["X-Request-Id"]
assert client.get("/health/ready").headers["X-Request-Id"]
assert_error(client.get("/no/such/path"), 404, "not_found")