diff --git a/.env.example b/.env.example index d99d26a2..4854b2ec 100644 --- a/.env.example +++ b/.env.example @@ -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 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..30523add --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +*.sh text eol=lf +*.cmd text eol=crlf +# Читаются внутри Linux-контейнеров: всегда LF, даже при checkout на Windows. +*.cfg text eol=lf +Dockerfile text eol=lf diff --git a/.gitignore b/.gitignore index b5a71896..0d2ee4ed 100644 --- a/.gitignore +++ b/.gitignore @@ -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/ diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..ac4ec83b --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/REPORT.md b/REPORT.md index 9ad2b84f..95642ad6 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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, релиз больше не получает обновлений (см. «Хранилище файлов»). diff --git a/app/alembic.ini b/app/alembic.ini new file mode 100644 index 00000000..26749615 --- /dev/null +++ b/app/alembic.ini @@ -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 diff --git a/app/api/dependencies.py b/app/api/dependencies.py new file mode 100644 index 00000000..79777b4e --- /dev/null +++ b/app/api/dependencies.py @@ -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 diff --git a/app/api/health.py b/app/api/health.py new file mode 100644 index 00000000..102c59bf --- /dev/null +++ b/app/api/health.py @@ -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") diff --git a/app/api/v1/attachments_rout.py b/app/api/v1/attachments_rout.py new file mode 100644 index 00000000..6a9d0069 --- /dev/null +++ b/app/api/v1/attachments_rout.py @@ -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", + }, + ) diff --git a/app/api/v1/auth_rout.py b/app/api/v1/auth_rout.py new file mode 100644 index 00000000..89e1abbc --- /dev/null +++ b/app/api/v1/auth_rout.py @@ -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) diff --git a/app/api/v1/chats_rout.py b/app/api/v1/chats_rout.py new file mode 100644 index 00000000..c09b080f --- /dev/null +++ b/app/api/v1/chats_rout.py @@ -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) diff --git a/app/api/v1/messages_rout.py b/app/api/v1/messages_rout.py new file mode 100644 index 00000000..1a066417 --- /dev/null +++ b/app/api/v1/messages_rout.py @@ -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) diff --git a/app/api/v1/users_rout.py b/app/api/v1/users_rout.py new file mode 100644 index 00000000..59b2d3a8 --- /dev/null +++ b/app/api/v1/users_rout.py @@ -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) diff --git a/app/core/config.py b/app/core/config.py new file mode 100644 index 00000000..78170494 --- /dev/null +++ b/app/core/config.py @@ -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() diff --git a/app/core/db.py b/app/core/db.py new file mode 100644 index 00000000..655b3de8 --- /dev/null +++ b/app/core/db.py @@ -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)}") diff --git a/app/core/logger.py b/app/core/logger.py new file mode 100644 index 00000000..5c1d8d8f --- /dev/null +++ b/app/core/logger.py @@ -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() diff --git a/app/core/s3.py b/app/core/s3.py new file mode 100644 index 00000000..dfad435e --- /dev/null +++ b/app/core/s3.py @@ -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() diff --git a/app/database_functions/attachments_functions.py b/app/database_functions/attachments_functions.py new file mode 100644 index 00000000..4764c058 --- /dev/null +++ b/app/database_functions/attachments_functions.py @@ -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)) diff --git a/app/database_functions/chats_functions.py b/app/database_functions/chats_functions.py new file mode 100644 index 00000000..2f307f34 --- /dev/null +++ b/app/database_functions/chats_functions.py @@ -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)) diff --git a/app/database_functions/messages_functions.py b/app/database_functions/messages_functions.py new file mode 100644 index 00000000..73392533 --- /dev/null +++ b/app/database_functions/messages_functions.py @@ -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)) diff --git a/app/database_functions/sessions_functions.py b/app/database_functions/sessions_functions.py new file mode 100644 index 00000000..092d87e7 --- /dev/null +++ b/app/database_functions/sessions_functions.py @@ -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 diff --git a/app/database_functions/users_functions.py b/app/database_functions/users_functions.py new file mode 100644 index 00000000..2aa8c1d4 --- /dev/null +++ b/app/database_functions/users_functions.py @@ -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)) diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..b8489c2d --- /dev/null +++ b/app/main.py @@ -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() diff --git a/app/maintenance/__init__.py b/app/maintenance/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/maintenance/reconcile.py b/app/maintenance/reconcile.py new file mode 100644 index 00000000..068fd5a9 --- /dev/null +++ b/app/maintenance/reconcile.py @@ -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()) diff --git a/app/migrations/env.py b/app/migrations/env.py new file mode 100644 index 00000000..e5f91aa3 --- /dev/null +++ b/app/migrations/env.py @@ -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() diff --git a/app/migrations/script.py.mako b/app/migrations/script.py.mako new file mode 100644 index 00000000..11016301 --- /dev/null +++ b/app/migrations/script.py.mako @@ -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"} diff --git a/app/migrations/versions/0001_initial_schema.py b/app/migrations/versions/0001_initial_schema.py new file mode 100644 index 00000000..254d2257 --- /dev/null +++ b/app/migrations/versions/0001_initial_schema.py @@ -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 ### diff --git a/app/migrations/versions/0002_idempotency_keys.py b/app/migrations/versions/0002_idempotency_keys.py new file mode 100644 index 00000000..9862483a --- /dev/null +++ b/app/migrations/versions/0002_idempotency_keys.py @@ -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') diff --git a/app/migrations/versions/0003_attachments.py b/app/migrations/versions/0003_attachments.py new file mode 100644 index 00000000..6f706013 --- /dev/null +++ b/app/migrations/versions/0003_attachments.py @@ -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') diff --git a/app/migrations/versions/0004_object_key_collation.py b/app/migrations/versions/0004_object_key_collation.py new file mode 100644 index 00000000..617fa2bb --- /dev/null +++ b/app/migrations/versions/0004_object_key_collation.py @@ -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) diff --git a/app/models/__init__.py b/app/models/__init__.py new file mode 100644 index 00000000..0bc46133 --- /dev/null +++ b/app/models/__init__.py @@ -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"] diff --git a/app/models/attachments_models.py b/app/models/attachments_models.py new file mode 100644 index 00000000..68614f9d --- /dev/null +++ b/app/models/attachments_models.py @@ -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) diff --git a/app/models/base.py b/app/models/base.py new file mode 100644 index 00000000..2f98d6c4 --- /dev/null +++ b/app/models/base.py @@ -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) diff --git a/app/models/chats_models.py b/app/models/chats_models.py new file mode 100644 index 00000000..a086d791 --- /dev/null +++ b/app/models/chats_models.py @@ -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) diff --git a/app/models/idempotency_models.py b/app/models/idempotency_models.py new file mode 100644 index 00000000..073bcbdb --- /dev/null +++ b/app/models/idempotency_models.py @@ -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()")) diff --git a/app/models/messages_models.py b/app/models/messages_models.py new file mode 100644 index 00000000..6e2941ba --- /dev/null +++ b/app/models/messages_models.py @@ -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] diff --git a/app/models/sessions_models.py b/app/models/sessions_models.py new file mode 100644 index 00000000..ca350258 --- /dev/null +++ b/app/models/sessions_models.py @@ -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") diff --git a/app/models/users_models.py b/app/models/users_models.py new file mode 100644 index 00000000..07884a16 --- /dev/null +++ b/app/models/users_models.py @@ -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()")) diff --git a/app/schemas/attachments_schemas.py b/app/schemas/attachments_schemas.py new file mode 100644 index 00000000..0cd9599b --- /dev/null +++ b/app/schemas/attachments_schemas.py @@ -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 diff --git a/app/schemas/auth_schemas.py b/app/schemas/auth_schemas.py new file mode 100644 index 00000000..9f45dfb7 --- /dev/null +++ b/app/schemas/auth_schemas.py @@ -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 diff --git a/app/schemas/chats_schemas.py b/app/schemas/chats_schemas.py new file mode 100644 index 00000000..fbc3eb43 --- /dev/null +++ b/app/schemas/chats_schemas.py @@ -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 diff --git a/app/schemas/error_schemas.py b/app/schemas/error_schemas.py new file mode 100644 index 00000000..b93b00af --- /dev/null +++ b/app/schemas/error_schemas.py @@ -0,0 +1,11 @@ +from pydantic import BaseModel + + +class ErrorBody(BaseModel): + code: str + message: str + request_id: str + + +class ErrorResponse(BaseModel): + error: ErrorBody diff --git a/app/schemas/health_schemas.py b/app/schemas/health_schemas.py new file mode 100644 index 00000000..9b69dec6 --- /dev/null +++ b/app/schemas/health_schemas.py @@ -0,0 +1,7 @@ +from typing import Literal + +from pydantic import BaseModel + + +class HealthResponse(BaseModel): + status: Literal["ok"] diff --git a/app/schemas/messages_schemas.py b/app/schemas/messages_schemas.py new file mode 100644 index 00000000..a2675210 --- /dev/null +++ b/app/schemas/messages_schemas.py @@ -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 diff --git a/app/schemas/users_schemas.py b/app/schemas/users_schemas.py new file mode 100644 index 00000000..ff37a7b8 --- /dev/null +++ b/app/schemas/users_schemas.py @@ -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 diff --git a/app/utils/dates.py b/app/utils/dates.py new file mode 100644 index 00000000..851217bc --- /dev/null +++ b/app/utils/dates.py @@ -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)] diff --git a/app/utils/errors.py b/app/utils/errors.py new file mode 100644 index 00000000..152c8c35 --- /dev/null +++ b/app/utils/errors.py @@ -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) diff --git a/app/utils/images.py b/app/utils/images.py new file mode 100644 index 00000000..0b962f44 --- /dev/null +++ b/app/utils/images.py @@ -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) diff --git a/app/utils/lifecycle.py b/app/utils/lifecycle.py new file mode 100644 index 00000000..f7f45855 --- /dev/null +++ b/app/utils/lifecycle.py @@ -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() diff --git a/app/utils/middleware.py b/app/utils/middleware.py new file mode 100644 index 00000000..ea44730b --- /dev/null +++ b/app/utils/middleware.py @@ -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 diff --git a/app/utils/pagination.py b/app/utils/pagination.py new file mode 100644 index 00000000..9cc34214 --- /dev/null +++ b/app/utils/pagination.py @@ -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 diff --git a/app/utils/security.py b/app/utils/security.py new file mode 100644 index 00000000..e3b1fb2f --- /dev/null +++ b/app/utils/security.py @@ -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() diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..ba75ae7b --- /dev/null +++ b/compose.yaml @@ -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 diff --git a/evidence/attachment-checks.json b/evidence/attachment-checks.json new file mode 100644 index 00000000..bfcf1260 --- /dev/null +++ b/evidence/attachment-checks.json @@ -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" +} diff --git a/evidence/compose-config.txt b/evidence/compose-config.txt new file mode 100644 index 00000000..a3305eb0 --- /dev/null +++ b/evidence/compose-config.txt @@ -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'] diff --git a/evidence/failover-hook.txt b/evidence/failover-hook.txt new file mode 100644 index 00000000..9e50c88e --- /dev/null +++ b/evidence/failover-hook.txt @@ -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) diff --git a/evidence/orphan-cleanup.json b/evidence/orphan-cleanup.json new file mode 100644 index 00000000..71ab1017 --- /dev/null +++ b/evidence/orphan-cleanup.json @@ -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" +} diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..8086b1a8 --- /dev/null +++ b/evidence/persistence.txt @@ -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 diff --git a/evidence/pytest.txt b/evidence/pytest.txt new file mode 100644 index 00000000..f7d595a3 --- /dev/null +++ b/evidence/pytest.txt @@ -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) ======================== diff --git a/evidence/reconcile-cost.json b/evidence/reconcile-cost.json new file mode 100644 index 00000000..a91724dc --- /dev/null +++ b/evidence/reconcile-cost.json @@ -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 + } + ] +} diff --git a/evidence/reconcile-faults.json b/evidence/reconcile-faults.json new file mode 100644 index 00000000..de01e3cd --- /dev/null +++ b/evidence/reconcile-faults.json @@ -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" +} diff --git a/evidence/s3-outage.json b/evidence/s3-outage.json new file mode 100644 index 00000000..96088298 --- /dev/null +++ b/evidence/s3-outage.json @@ -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" +} diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..98d0e448 --- /dev/null +++ b/evidence/smoke.txt @@ -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 diff --git a/evidence/upload-memory-repeat.json b/evidence/upload-memory-repeat.json new file mode 100644 index 00000000..606233e6 --- /dev/null +++ b/evidence/upload-memory-repeat.json @@ -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 + } + ] +} diff --git a/evidence/upload-memory.json b/evidence/upload-memory.json new file mode 100644 index 00000000..99c57c16 --- /dev/null +++ b/evidence/upload-memory.json @@ -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 + } + ] +} diff --git a/infra/haproxy/haproxy.cfg b/infra/haproxy/haproxy.cfg new file mode 100644 index 00000000..ab9e1e31 --- /dev/null +++ b/infra/haproxy/haproxy.cfg @@ -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 diff --git a/infra/minio/bootstrap.sh b/infra/minio/bootstrap.sh new file mode 100644 index 00000000..1d6070a8 --- /dev/null +++ b/infra/minio/bootstrap.sh @@ -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 </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" diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 00000000..78b8685f --- /dev/null +++ b/pytest.ini @@ -0,0 +1,5 @@ +[pytest] +testpaths = student-tests +pythonpath = app +filterwarnings = + ignore:Using .httpx. with .starlette.testclient. is deprecated diff --git a/requirements-test.txt b/requirements-test.txt new file mode 100644 index 00000000..9b5d2815 --- /dev/null +++ b/requirements-test.txt @@ -0,0 +1,3 @@ +-r requirements.txt +pytest==9.1.1 +httpx==0.28.1 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..9992671d --- /dev/null +++ b/requirements.txt @@ -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 diff --git a/scripts/attachment_checks.py b/scripts/attachment_checks.py new file mode 100644 index 00000000..6ef49e25 --- /dev/null +++ b/scripts/attachment_checks.py @@ -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()) diff --git a/scripts/compose_summary.py b/scripts/compose_summary.py new file mode 100644 index 00000000..db2a4ba4 --- /dev/null +++ b/scripts/compose_summary.py @@ -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", {}))) diff --git a/scripts/experiments.py b/scripts/experiments.py new file mode 100644 index 00000000..6a291249 --- /dev/null +++ b/scripts/experiments.py @@ -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() diff --git a/scripts/init-secrets.ps1 b/scripts/init-secrets.ps1 new file mode 100644 index 00000000..7a49e35e --- /dev/null +++ b/scripts/init-secrets.ps1 @@ -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' } diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh new file mode 100644 index 00000000..762cb4d5 --- /dev/null +++ b/scripts/init-secrets.sh @@ -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"; } diff --git a/scripts/orphan_experiment.py b/scripts/orphan_experiment.py new file mode 100644 index 00000000..a68cc642 --- /dev/null +++ b/scripts/orphan_experiment.py @@ -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()) diff --git a/scripts/reconcile_experiment.py b/scripts/reconcile_experiment.py new file mode 100644 index 00000000..3370bccd --- /dev/null +++ b/scripts/reconcile_experiment.py @@ -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) diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..5dee1597 --- /dev/null +++ b/scripts/restart.cmd @@ -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}}" diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..72318d16 --- /dev/null +++ b/scripts/restart.sh @@ -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}}' diff --git a/scripts/restore-replicas.cmd b/scripts/restore-replicas.cmd new file mode 100644 index 00000000..62c94535 --- /dev/null +++ b/scripts/restore-replicas.cmd @@ -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 diff --git a/scripts/restore-replicas.sh b/scripts/restore-replicas.sh new file mode 100644 index 00000000..755ca724 --- /dev/null +++ b/scripts/restore-replicas.sh @@ -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 diff --git a/scripts/s3_outage_check.py b/scripts/s3_outage_check.py new file mode 100644 index 00000000..c5c3ea3f --- /dev/null +++ b/scripts/s3_outage_check.py @@ -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()) diff --git a/scripts/stop-one.cmd b/scripts/stop-one.cmd new file mode 100644 index 00000000..fa2770e8 --- /dev/null +++ b/scripts/stop-one.cmd @@ -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% diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..071d6ca7 --- /dev/null +++ b/scripts/stop-one.sh @@ -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" diff --git a/scripts/upload_memory_experiment.py b/scripts/upload_memory_experiment.py new file mode 100644 index 00000000..bfb36a66 --- /dev/null +++ b/scripts/upload_memory_experiment.py @@ -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() diff --git a/student-tests/conftest.py b/student-tests/conftest.py new file mode 100644 index 00000000..5ed38fa7 --- /dev/null +++ b/student-tests/conftest.py @@ -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"] diff --git a/student-tests/test_attachments_api.py b/student-tests/test_attachments_api.py new file mode 100644 index 00000000..874ffdfd --- /dev/null +++ b/student-tests/test_attachments_api.py @@ -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" diff --git a/student-tests/test_auth_api.py b/student-tests/test_auth_api.py new file mode 100644 index 00000000..57a6866c --- /dev/null +++ b/student-tests/test_auth_api.py @@ -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") diff --git a/student-tests/test_chats_api.py b/student-tests/test_chats_api.py new file mode 100644 index 00000000..7fb89a62 --- /dev/null +++ b/student-tests/test_chats_api.py @@ -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") diff --git a/student-tests/test_idempotency_api.py b/student-tests/test_idempotency_api.py new file mode 100644 index 00000000..952d7b21 --- /dev/null +++ b/student-tests/test_idempotency_api.py @@ -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 diff --git a/student-tests/test_messages_api.py b/student-tests/test_messages_api.py new file mode 100644 index 00000000..fcbcad67 --- /dev/null +++ b/student-tests/test_messages_api.py @@ -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") diff --git a/student-tests/test_reconcile.py b/student-tests/test_reconcile.py new file mode 100644 index 00000000..14362a55 --- /dev/null +++ b/student-tests/test_reconcile.py @@ -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")) diff --git a/student-tests/test_users_api.py b/student-tests/test_users_api.py new file mode 100644 index 00000000..8593c408 --- /dev/null +++ b/student-tests/test_users_api.py @@ -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")