forked from mtusi2026/mtusi2026lab4
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
44ae7b2472 |
+48
-17
@@ -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
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
*.sh text eol=lf
|
||||
*.cmd text eol=crlf
|
||||
# Читаются внутри Linux-контейнеров: всегда LF, даже при checkout на Windows.
|
||||
*.cfg text eol=lf
|
||||
Dockerfile text eol=lf
|
||||
@@ -1,3 +1,5 @@
|
||||
# Personal study notes, not part of the submission
|
||||
report_help.md
|
||||
# Local/private state
|
||||
.env
|
||||
.env.*
|
||||
@@ -16,6 +18,7 @@ backups/
|
||||
# Runtime/build artifacts
|
||||
.venv/
|
||||
__pycache__/
|
||||
.pytest_cache/
|
||||
*.py[cod]
|
||||
node_modules/
|
||||
dist/
|
||||
|
||||
+27
@@ -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"]
|
||||
@@ -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, релиз больше не получает обновлений (см. «Хранилище файлов»).
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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")
|
||||
@@ -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",
|
||||
},
|
||||
)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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)}")
|
||||
@@ -0,0 +1,15 @@
|
||||
import logging
|
||||
|
||||
from core.config import settings
|
||||
|
||||
|
||||
def setup_logger():
|
||||
logging.basicConfig(
|
||||
level=settings.logging.level,
|
||||
format=settings.logging.format,
|
||||
datefmt=settings.logging.datefmt,
|
||||
)
|
||||
return logging.getLogger("messenger")
|
||||
|
||||
|
||||
logger = setup_logger()
|
||||
+127
@@ -0,0 +1,127 @@
|
||||
"""Клиент приватного S3-bucket (MinIO). Байты вложений живут только здесь, метаданные — в PostgreSQL."""
|
||||
import io
|
||||
from collections.abc import Iterator
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime
|
||||
from functools import lru_cache
|
||||
from urllib.parse import urlsplit
|
||||
|
||||
import urllib3
|
||||
from minio import Minio
|
||||
from minio.error import MinioException, S3Error
|
||||
|
||||
from core.config import settings
|
||||
from core.logger import logger
|
||||
|
||||
CHUNK_SIZE = 64 * 1024
|
||||
MIN_PART_SIZE = 5 * 1024 * 1024
|
||||
|
||||
|
||||
class StorageUnavailable(Exception):
|
||||
"""S3 недоступен или отказал: клиент получает 503."""
|
||||
|
||||
|
||||
class ObjectMissing(Exception):
|
||||
"""Метаданные есть, а объекта в bucket нет (рассинхронизация хранилищ)."""
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def get_client() -> Minio:
|
||||
# Создаётся при первом обращении: health и текстовые запросы не зависят от S3 и его секретов.
|
||||
url = urlsplit(settings.s3.endpoint)
|
||||
http_client = urllib3.PoolManager(
|
||||
timeout=urllib3.Timeout(connect=settings.s3.connect_timeout, read=settings.s3.read_timeout),
|
||||
# Без повторов: при недоступном S3 клиент быстрее получает 503 и повторяет сам, если нужно.
|
||||
retries=urllib3.Retry(total=0, redirect=0),
|
||||
maxsize=10,
|
||||
)
|
||||
return Minio(
|
||||
url.netloc,
|
||||
access_key=settings.s3.read_access_key(),
|
||||
secret_key=settings.s3.read_secret_key(),
|
||||
secure=url.scheme == "https",
|
||||
region=settings.s3.region,
|
||||
http_client=http_client,
|
||||
)
|
||||
|
||||
|
||||
def _unavailable(action: str, exc: Exception) -> StorageUnavailable:
|
||||
# В лог — только тип и код ошибки: в тексте исключения бывают адреса и подписи запросов.
|
||||
code = exc.code if isinstance(exc, S3Error) else type(exc).__name__
|
||||
if isinstance(exc, urllib3.exceptions.MaxRetryError) and exc.reason is not None:
|
||||
code += f"/{type(exc.reason).__name__}"
|
||||
# ProtocolError оборачивает исходную причину (обрыв, сброс соединения) — её тип тоже полезен.
|
||||
inner = [arg for arg in getattr(exc.reason, "args", ()) if isinstance(arg, BaseException)]
|
||||
if inner:
|
||||
code += f"/{type(inner[0]).__name__}"
|
||||
logger.warning(f"S3 {action} не удалось: {code}")
|
||||
return StorageUnavailable()
|
||||
|
||||
|
||||
def put_object(key: str, data: bytes, content_type: str, sha256_hex: str) -> None:
|
||||
try:
|
||||
get_client().put_object(
|
||||
settings.s3.bucket, key, io.BytesIO(data), len(data),
|
||||
content_type=content_type, metadata={"sha256": sha256_hex},
|
||||
# Одна часть на весь файл = один атомарный PUT. С частями по 5 MiB (по умолчанию) обрыв посреди
|
||||
# загрузки оставил бы в bucket незавершённый multipart upload.
|
||||
part_size=max(settings.attachments.max_bytes, MIN_PART_SIZE),
|
||||
)
|
||||
except (MinioException, urllib3.exceptions.HTTPError, OSError) as exc:
|
||||
raise _unavailable("PUT", exc) from exc
|
||||
|
||||
|
||||
def delete_object(key: str) -> None:
|
||||
try:
|
||||
get_client().remove_object(settings.s3.bucket, key)
|
||||
except (MinioException, urllib3.exceptions.HTTPError, OSError) as exc:
|
||||
raise _unavailable("DELETE", exc) from exc
|
||||
|
||||
|
||||
@dataclass
|
||||
class StoredObject:
|
||||
key: str
|
||||
size: int
|
||||
last_modified: datetime
|
||||
|
||||
|
||||
def list_objects(prefix: str) -> Iterator[StoredObject]:
|
||||
"""Все объекты под prefix; MinIO отдаёт их страницами по 1000, итератор подгружает следующие сам."""
|
||||
try:
|
||||
for item in get_client().list_objects(settings.s3.bucket, prefix=prefix, recursive=True):
|
||||
yield StoredObject(key=item.object_name, size=item.size, last_modified=item.last_modified)
|
||||
except (MinioException, urllib3.exceptions.HTTPError, OSError) as exc:
|
||||
raise _unavailable("LIST", exc) from exc
|
||||
|
||||
|
||||
def object_exists(key: str) -> bool:
|
||||
try:
|
||||
get_client().stat_object(settings.s3.bucket, key)
|
||||
return True
|
||||
except S3Error as exc:
|
||||
if exc.code in ("NoSuchKey", "NoSuchObject"):
|
||||
return False
|
||||
raise _unavailable("HEAD", exc) from exc
|
||||
except (MinioException, urllib3.exceptions.HTTPError, OSError) as exc:
|
||||
raise _unavailable("HEAD", exc) from exc
|
||||
|
||||
|
||||
def open_object(key: str) -> urllib3.BaseHTTPResponse:
|
||||
"""Начать чтение объекта. Ошибки (нет S3, нет объекта) возникают здесь, до отправки статуса 200."""
|
||||
try:
|
||||
return get_client().get_object(settings.s3.bucket, key)
|
||||
except S3Error as exc:
|
||||
if exc.code == "NoSuchKey":
|
||||
raise ObjectMissing() from exc
|
||||
raise _unavailable("GET", exc) from exc
|
||||
except (MinioException, urllib3.exceptions.HTTPError, OSError) as exc:
|
||||
raise _unavailable("GET", exc) from exc
|
||||
|
||||
|
||||
def iter_object(response: urllib3.BaseHTTPResponse) -> Iterator[bytes]:
|
||||
"""Отдать объект кусками по 64 KiB: файл целиком в память API не загружается."""
|
||||
try:
|
||||
yield from response.stream(CHUNK_SIZE)
|
||||
finally:
|
||||
response.close()
|
||||
response.release_conn()
|
||||
@@ -0,0 +1,44 @@
|
||||
import uuid
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from models import Attachment, ChatMember
|
||||
|
||||
|
||||
def object_key_for(attachment_id: uuid.UUID) -> str:
|
||||
# Ключ назначает сервер: случайный UUID, без имени файла и без данных пользователя.
|
||||
return f"originals/{attachment_id}"
|
||||
|
||||
|
||||
def create_attachment(db: Session, attachment_id: uuid.UUID, chat_id: uuid.UUID, owner_id: uuid.UUID,
|
||||
filename: str, content_type: str, size_bytes: int, sha256: str, object_key: str) -> Attachment:
|
||||
attachment = Attachment(
|
||||
id=attachment_id, chat_id=chat_id, owner_id=owner_id, filename=filename, content_type=content_type,
|
||||
size_bytes=size_bytes, sha256=sha256, object_key=object_key,
|
||||
)
|
||||
db.add(attachment)
|
||||
db.commit()
|
||||
return attachment
|
||||
|
||||
|
||||
def get_member_attachment(db: Session, attachment_id: uuid.UUID, user_id: uuid.UUID) -> Attachment | None:
|
||||
"""Вложение, если пользователь — участник его чата. Чужое и несуществующее неразличимы (None -> 404)."""
|
||||
query = (
|
||||
select(Attachment)
|
||||
.join(ChatMember, ChatMember.chat_id == Attachment.chat_id)
|
||||
.where(Attachment.id == attachment_id, ChatMember.user_id == user_id)
|
||||
)
|
||||
return db.scalar(query)
|
||||
|
||||
|
||||
def find_chat_attachments(db: Session, chat_id: uuid.UUID, attachment_ids: list[uuid.UUID]) -> list[Attachment]:
|
||||
# Вложения других чатов сюда не попадают: для отправителя они «не найдены».
|
||||
if not attachment_ids:
|
||||
return []
|
||||
# FOR KEY SHARE: пока сообщение со ссылкой не закоммичено, сверка хранилищ не может удалить эти строки
|
||||
# (её DELETE ждёт, а потом откажет по FK); если сверка удалила раньше — вложение просто «не найдено».
|
||||
query = (select(Attachment)
|
||||
.where(Attachment.chat_id == chat_id, Attachment.id.in_(attachment_ids))
|
||||
.with_for_update(key_share=True, read=True))
|
||||
return list(db.scalars(query))
|
||||
@@ -0,0 +1,50 @@
|
||||
import uuid
|
||||
|
||||
from sqlalchemy import func, select, tuple_
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from models import Chat, ChatMember, User
|
||||
from utils.pagination import Position
|
||||
|
||||
|
||||
def create_chat(db: Session, title: str, member_ids: list[uuid.UUID]) -> Chat | None:
|
||||
"""Чат и участники — одна транзакция. None — есть несуществующий участник."""
|
||||
found = db.scalar(select(func.count()).select_from(User).where(User.id.in_(member_ids)))
|
||||
if found != len(member_ids):
|
||||
return None
|
||||
|
||||
chat = Chat(title=title, members=[ChatMember(user_id=user_id) for user_id in sorted(member_ids)])
|
||||
db.add(chat)
|
||||
try:
|
||||
db.commit()
|
||||
except IntegrityError:
|
||||
db.rollback()
|
||||
return None
|
||||
return chat
|
||||
|
||||
|
||||
def is_chat_member(db: Session, chat_id: uuid.UUID, user_id: uuid.UUID) -> bool:
|
||||
return db.get(ChatMember, (chat_id, user_id)) is not None
|
||||
|
||||
|
||||
def get_member_chat(db: Session, chat_id: uuid.UUID, user_id: uuid.UUID) -> Chat | None:
|
||||
query = (
|
||||
select(Chat)
|
||||
.join(ChatMember, ChatMember.chat_id == Chat.id)
|
||||
.where(Chat.id == chat_id, ChatMember.user_id == user_id)
|
||||
)
|
||||
return db.scalar(query)
|
||||
|
||||
|
||||
def list_user_chats(db: Session, user_id: uuid.UUID, limit: int, after: Position | None) -> list[Chat]:
|
||||
query = (
|
||||
select(Chat)
|
||||
.join(ChatMember, ChatMember.chat_id == Chat.id)
|
||||
.where(ChatMember.user_id == user_id)
|
||||
.order_by(Chat.created_at, Chat.id)
|
||||
.limit(limit + 1)
|
||||
)
|
||||
if after is not None:
|
||||
query = query.where(tuple_(Chat.created_at, Chat.id) > tuple_(*after))
|
||||
return list(db.scalars(query))
|
||||
@@ -0,0 +1,87 @@
|
||||
import uuid
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
from sqlalchemy import func, select, tuple_, update
|
||||
from sqlalchemy.dialects.postgresql import insert
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from database_functions.attachments_functions import find_chat_attachments
|
||||
from models import IdempotencyKey, Message, MessageAttachment
|
||||
from utils.pagination import Position
|
||||
|
||||
|
||||
class IdempotencyKeyReused(Exception):
|
||||
"""Тот же Idempotency-Key уже использован с другим телом запроса."""
|
||||
|
||||
|
||||
class AttachmentNotFound(Exception):
|
||||
"""Вложения нет или оно из другого чата (для клиента это 404)."""
|
||||
|
||||
|
||||
class AttachmentNotReady(Exception):
|
||||
"""Вложение ещё не готово или с ошибкой обработки (409)."""
|
||||
|
||||
|
||||
def create_message_once(db: Session, chat_id: uuid.UUID, sender_id: uuid.UUID, text: str,
|
||||
attachment_ids: list[uuid.UUID],
|
||||
key: str, request_hash: bytes, ttl_seconds: int) -> Message:
|
||||
"""Создать сообщение ровно один раз для (пользователь, чат, ключ), в том числе при конкурентных повторах.
|
||||
|
||||
Всё в одной транзакции: «заявка» на ключ, сообщение и ссылка ключа на сообщение фиксируются вместе.
|
||||
Если транзакция откатится (5xx, обрыв), ключ не сохранится и клиент безопасно повторит запрос.
|
||||
Параллельный повтор через другую реплику блокируется на уникальном индексе до COMMIT первой
|
||||
транзакции, затем видит её строку и возвращает то же сообщение.
|
||||
"""
|
||||
cutoff = datetime.now(timezone.utc) - timedelta(seconds=ttl_seconds)
|
||||
claim = (
|
||||
insert(IdempotencyKey)
|
||||
.values(user_id=sender_id, chat_id=chat_id, key=key, request_hash=request_hash)
|
||||
# Строка старше TTL считается свободной ключом: перехватываем её, остальные конфликты не меняем.
|
||||
.on_conflict_do_update(
|
||||
index_elements=[IdempotencyKey.user_id, IdempotencyKey.chat_id, IdempotencyKey.key],
|
||||
set_={"request_hash": request_hash, "message_id": None, "created_at": func.clock_timestamp()},
|
||||
where=IdempotencyKey.created_at < cutoff,
|
||||
)
|
||||
.returning(IdempotencyKey.key)
|
||||
)
|
||||
if db.execute(claim).first() is None:
|
||||
existing = db.scalars(select(IdempotencyKey).where(
|
||||
IdempotencyKey.user_id == sender_id, IdempotencyKey.chat_id == chat_id, IdempotencyKey.key == key,
|
||||
)).one()
|
||||
if existing.request_hash != request_hash:
|
||||
raise IdempotencyKeyReused()
|
||||
return db.get_one(Message, existing.message_id)
|
||||
|
||||
attachments = {a.id: a for a in find_chat_attachments(db, chat_id, attachment_ids)}
|
||||
if len(attachments) != len(attachment_ids):
|
||||
# Откат снимает и «заявку» на ключ: исправленный запрос с тем же ключом пройдёт.
|
||||
db.rollback()
|
||||
raise AttachmentNotFound()
|
||||
if any(a.status != "ready" for a in attachments.values()):
|
||||
db.rollback()
|
||||
raise AttachmentNotReady()
|
||||
|
||||
message = Message(chat_id=chat_id, sender_id=sender_id, text=text, attachment_links=[
|
||||
MessageAttachment(attachment_id=attachment_id, chat_id=chat_id, position=position)
|
||||
for position, attachment_id in enumerate(attachment_ids)
|
||||
])
|
||||
db.add(message)
|
||||
db.flush()
|
||||
db.execute(update(IdempotencyKey).where(
|
||||
IdempotencyKey.user_id == sender_id, IdempotencyKey.chat_id == chat_id, IdempotencyKey.key == key,
|
||||
).values(message_id=message.id))
|
||||
db.commit()
|
||||
return message
|
||||
|
||||
|
||||
def list_messages(db: Session, chat_id: uuid.UUID, limit: int, after: Position | None) -> list[Message]:
|
||||
# Keyset-пагинация по индексу messages_chat_history_idx (chat_id, created_at, id).
|
||||
query = (
|
||||
select(Message)
|
||||
.where(Message.chat_id == chat_id)
|
||||
.order_by(Message.created_at, Message.id)
|
||||
.limit(limit + 1)
|
||||
)
|
||||
if after is not None:
|
||||
query = query.where(tuple_(Message.created_at, Message.id) > tuple_(*after))
|
||||
return list(db.scalars(query))
|
||||
@@ -0,0 +1,29 @@
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
|
||||
from sqlalchemy import delete, func, select
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from models import AuthSession
|
||||
|
||||
|
||||
def create_session(db: Session, token_hash: bytes, user_id: uuid.UUID,
|
||||
created_at: datetime, expires_at: datetime) -> AuthSession:
|
||||
auth_session = AuthSession(token_hash=token_hash, user_id=user_id, created_at=created_at, expires_at=expires_at)
|
||||
db.add(auth_session)
|
||||
db.commit()
|
||||
return auth_session
|
||||
|
||||
|
||||
def get_active_session(db: Session, token_hash: bytes) -> AuthSession | None:
|
||||
query = select(AuthSession).where(
|
||||
AuthSession.token_hash == token_hash,
|
||||
AuthSession.expires_at > func.now(),
|
||||
)
|
||||
return db.scalar(query)
|
||||
|
||||
|
||||
def delete_session(db: Session, token_hash: bytes) -> bool:
|
||||
result = db.execute(delete(AuthSession).where(AuthSession.token_hash == token_hash))
|
||||
db.commit()
|
||||
return result.rowcount > 0
|
||||
@@ -0,0 +1,30 @@
|
||||
import uuid
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from models import User
|
||||
|
||||
|
||||
def create_user(db: Session, username: str, display_name: str, password_hash: str) -> User | None:
|
||||
"""None — username уже занят."""
|
||||
user = User(username=username, display_name=display_name, password_hash=password_hash)
|
||||
db.add(user)
|
||||
try:
|
||||
db.commit()
|
||||
except IntegrityError as exc:
|
||||
db.rollback()
|
||||
# Уникальность проверяет сама БД, поэтому гонка регистрации невозможна.
|
||||
if exc.orig.diag.constraint_name == "users_username_key":
|
||||
return None
|
||||
raise
|
||||
return user
|
||||
|
||||
|
||||
def get_user(db: Session, user_id: uuid.UUID) -> User | None:
|
||||
return db.get(User, user_id)
|
||||
|
||||
|
||||
def get_user_by_username(db: Session, username: str) -> User | None:
|
||||
return db.scalar(select(User).where(User.username == username))
|
||||
+76
@@ -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()
|
||||
@@ -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())
|
||||
@@ -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()
|
||||
@@ -0,0 +1,28 @@
|
||||
"""${message}
|
||||
|
||||
Revision ID: ${up_revision}
|
||||
Revises: ${down_revision | comma,n}
|
||||
Create Date: ${create_date}
|
||||
|
||||
"""
|
||||
from typing import Sequence, Union
|
||||
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
${imports if imports else ""}
|
||||
|
||||
# revision identifiers, used by Alembic.
|
||||
revision: str = ${repr(up_revision)}
|
||||
down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)}
|
||||
branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
|
||||
depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
"""Upgrade schema."""
|
||||
${upgrades if upgrades else "pass"}
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
"""Downgrade schema."""
|
||||
${downgrades if downgrades else "pass"}
|
||||
@@ -0,0 +1,85 @@
|
||||
"""initial schema
|
||||
|
||||
Revision ID: 0001
|
||||
Revises:
|
||||
Create Date: 2026-10-15 17:30:37.825446
|
||||
|
||||
"""
|
||||
from typing import Sequence, Union
|
||||
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
|
||||
|
||||
# revision identifiers, used by Alembic.
|
||||
revision: str = '0001'
|
||||
down_revision: Union[str, Sequence[str], None] = None
|
||||
branch_labels: Union[str, Sequence[str], None] = None
|
||||
depends_on: Union[str, Sequence[str], None] = None
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
"""Upgrade schema."""
|
||||
# ### commands auto generated by Alembic - please adjust! ###
|
||||
op.create_table('chats',
|
||||
sa.Column('id', sa.Uuid(), server_default=sa.text('gen_random_uuid()'), nullable=False),
|
||||
sa.Column('title', sa.Text(), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
|
||||
sa.CheckConstraint('char_length(title) BETWEEN 1 AND 100', name=op.f('chats_title_len')),
|
||||
sa.PrimaryKeyConstraint('id', name=op.f('chats_pkey'))
|
||||
)
|
||||
op.create_table('users',
|
||||
sa.Column('id', sa.Uuid(), server_default=sa.text('gen_random_uuid()'), nullable=False),
|
||||
sa.Column('username', sa.Text(), nullable=False),
|
||||
sa.Column('display_name', sa.Text(), nullable=False),
|
||||
sa.Column('password_hash', sa.Text(), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
|
||||
sa.CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'", name=op.f('users_username_format')),
|
||||
sa.CheckConstraint('char_length(display_name) BETWEEN 1 AND 100', name=op.f('users_display_name_len')),
|
||||
sa.PrimaryKeyConstraint('id', name=op.f('users_pkey')),
|
||||
sa.UniqueConstraint('username', name=op.f('users_username_key'))
|
||||
)
|
||||
op.create_table('chat_members',
|
||||
sa.Column('chat_id', sa.Uuid(), nullable=False),
|
||||
sa.Column('user_id', sa.Uuid(), nullable=False),
|
||||
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], name=op.f('chat_members_chat_id_fkey')),
|
||||
sa.ForeignKeyConstraint(['user_id'], ['users.id'], name=op.f('chat_members_user_id_fkey')),
|
||||
sa.PrimaryKeyConstraint('chat_id', 'user_id', name=op.f('chat_members_pkey'))
|
||||
)
|
||||
op.create_index(op.f('chat_members_user_id_chat_id_idx'), 'chat_members', ['user_id', 'chat_id'], unique=False)
|
||||
op.create_table('sessions',
|
||||
sa.Column('token_hash', sa.LargeBinary(), nullable=False),
|
||||
sa.Column('user_id', sa.Uuid(), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
|
||||
sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False),
|
||||
sa.CheckConstraint('expires_at > created_at', name=op.f('sessions_expiry_after_creation')),
|
||||
sa.ForeignKeyConstraint(['user_id'], ['users.id'], name=op.f('sessions_user_id_fkey'), ondelete='CASCADE'),
|
||||
sa.PrimaryKeyConstraint('token_hash', name=op.f('sessions_pkey'))
|
||||
)
|
||||
op.create_index(op.f('sessions_expires_at_idx'), 'sessions', ['expires_at'], unique=False)
|
||||
op.create_table('messages',
|
||||
sa.Column('id', sa.Uuid(), server_default=sa.text('gen_random_uuid()'), nullable=False),
|
||||
sa.Column('chat_id', sa.Uuid(), nullable=False),
|
||||
sa.Column('sender_id', sa.Uuid(), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
|
||||
sa.Column('text', sa.Text(), nullable=False),
|
||||
sa.CheckConstraint('char_length(text) BETWEEN 1 AND 4000', name=op.f('messages_text_len')),
|
||||
sa.ForeignKeyConstraint(['chat_id', 'sender_id'], ['chat_members.chat_id', 'chat_members.user_id'], name='messages_sender_is_member'),
|
||||
sa.PrimaryKeyConstraint('id', name=op.f('messages_pkey'))
|
||||
)
|
||||
op.create_index('messages_chat_history_idx', 'messages', ['chat_id', 'created_at', 'id'], unique=False)
|
||||
# ### end Alembic commands ###
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
"""Downgrade schema."""
|
||||
# ### commands auto generated by Alembic - please adjust! ###
|
||||
op.drop_index('messages_chat_history_idx', table_name='messages')
|
||||
op.drop_table('messages')
|
||||
op.drop_index(op.f('sessions_expires_at_idx'), table_name='sessions')
|
||||
op.drop_table('sessions')
|
||||
op.drop_index(op.f('chat_members_user_id_chat_id_idx'), table_name='chat_members')
|
||||
op.drop_table('chat_members')
|
||||
op.drop_table('users')
|
||||
op.drop_table('chats')
|
||||
# ### end Alembic commands ###
|
||||
@@ -0,0 +1,44 @@
|
||||
"""idempotency keys
|
||||
|
||||
Revision ID: 0002
|
||||
Revises: 0001
|
||||
Create Date: 2026-10-28 12:00:00.000000
|
||||
|
||||
Только добавляет таблицу: версия приложения до этой миграции её не использует и продолжает работать,
|
||||
поэтому миграцию можно применять перед rolling update (expand-фаза).
|
||||
"""
|
||||
from typing import Sequence, Union
|
||||
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
|
||||
|
||||
# revision identifiers, used by Alembic.
|
||||
revision: str = '0002'
|
||||
down_revision: Union[str, Sequence[str], None] = '0001'
|
||||
branch_labels: Union[str, Sequence[str], None] = None
|
||||
depends_on: Union[str, Sequence[str], None] = None
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
"""Upgrade schema."""
|
||||
op.create_table('idempotency_keys',
|
||||
sa.Column('user_id', sa.Uuid(), nullable=False),
|
||||
sa.Column('chat_id', sa.Uuid(), nullable=False),
|
||||
sa.Column('key', sa.Text(), nullable=False),
|
||||
sa.Column('request_hash', sa.LargeBinary(), nullable=False),
|
||||
sa.Column('message_id', sa.Uuid(), nullable=True),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
|
||||
sa.CheckConstraint("key ~ '^[A-Za-z0-9._:-]{1,128}$'", name=op.f('idempotency_keys_key_format')),
|
||||
sa.ForeignKeyConstraint(['user_id'], ['users.id'], name=op.f('idempotency_keys_user_id_fkey')),
|
||||
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], name=op.f('idempotency_keys_chat_id_fkey')),
|
||||
sa.ForeignKeyConstraint(['message_id'], ['messages.id'], name=op.f('idempotency_keys_message_id_fkey')),
|
||||
sa.PrimaryKeyConstraint('user_id', 'chat_id', 'key', name=op.f('idempotency_keys_pkey'))
|
||||
)
|
||||
op.create_index('idempotency_keys_created_at_idx', 'idempotency_keys', ['created_at'], unique=False)
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
"""Downgrade schema."""
|
||||
op.drop_index('idempotency_keys_created_at_idx', table_name='idempotency_keys')
|
||||
op.drop_table('idempotency_keys')
|
||||
@@ -0,0 +1,72 @@
|
||||
"""attachments
|
||||
|
||||
Revision ID: 0003
|
||||
Revises: 0002
|
||||
Create Date: 2026-11-12 12:00:00.000000
|
||||
|
||||
Expand-миграция: новые таблицы и ослабление CHECK у messages.text (пустой текст при наличии вложений).
|
||||
Версия lab3 продолжает работать с этой схемой, поэтому миграцию можно применять до замены реплик.
|
||||
"""
|
||||
from typing import Sequence, Union
|
||||
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
|
||||
|
||||
# revision identifiers, used by Alembic.
|
||||
revision: str = '0003'
|
||||
down_revision: Union[str, Sequence[str], None] = '0002'
|
||||
branch_labels: Union[str, Sequence[str], None] = None
|
||||
depends_on: Union[str, Sequence[str], None] = None
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
"""Upgrade schema."""
|
||||
op.create_table('attachments',
|
||||
sa.Column('id', sa.Uuid(), nullable=False),
|
||||
sa.Column('chat_id', sa.Uuid(), nullable=False),
|
||||
sa.Column('owner_id', sa.Uuid(), nullable=False),
|
||||
sa.Column('filename', sa.Text(), nullable=False),
|
||||
sa.Column('content_type', sa.Text(), nullable=False),
|
||||
sa.Column('size_bytes', sa.BigInteger(), nullable=False),
|
||||
sa.Column('sha256', sa.Text(), nullable=False),
|
||||
sa.Column('object_key', sa.Text(), nullable=False),
|
||||
sa.Column('status', sa.Text(), server_default=sa.text("'ready'"), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
|
||||
sa.Column('updated_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
|
||||
sa.CheckConstraint("content_type IN ('image/png', 'image/jpeg')", name=op.f('attachments_content_type')),
|
||||
sa.CheckConstraint('size_bytes BETWEEN 1 AND 10485760', name=op.f('attachments_size')),
|
||||
sa.CheckConstraint("sha256 ~ '^[0-9a-f]{64}$'", name=op.f('attachments_sha256_format')),
|
||||
sa.CheckConstraint('char_length(filename) BETWEEN 1 AND 255', name=op.f('attachments_filename_len')),
|
||||
sa.CheckConstraint("status IN ('ready')", name=op.f('attachments_status')),
|
||||
sa.ForeignKeyConstraint(['chat_id', 'owner_id'], ['chat_members.chat_id', 'chat_members.user_id'], name='attachments_owner_is_member'),
|
||||
sa.PrimaryKeyConstraint('id', name=op.f('attachments_pkey')),
|
||||
sa.UniqueConstraint('id', 'chat_id', name='attachments_id_chat_id_key'),
|
||||
sa.UniqueConstraint('object_key', name=op.f('attachments_object_key_key'))
|
||||
)
|
||||
op.create_index(op.f('attachments_created_at_idx'), 'attachments', ['created_at'], unique=False)
|
||||
op.create_table('message_attachments',
|
||||
sa.Column('message_id', sa.Uuid(), nullable=False),
|
||||
sa.Column('attachment_id', sa.Uuid(), nullable=False),
|
||||
sa.Column('chat_id', sa.Uuid(), nullable=False),
|
||||
sa.Column('position', sa.SmallInteger(), nullable=False),
|
||||
sa.CheckConstraint('position BETWEEN 0 AND 9', name=op.f('message_attachments_position_range')),
|
||||
sa.ForeignKeyConstraint(['attachment_id', 'chat_id'], ['attachments.id', 'attachments.chat_id'], name='message_attachments_same_chat'),
|
||||
sa.ForeignKeyConstraint(['message_id'], ['messages.id'], name=op.f('message_attachments_message_id_fkey')),
|
||||
sa.PrimaryKeyConstraint('message_id', 'attachment_id', name=op.f('message_attachments_pkey'))
|
||||
)
|
||||
op.create_index(op.f('message_attachments_attachment_id_idx'), 'message_attachments', ['attachment_id'], unique=False)
|
||||
op.drop_constraint(op.f('messages_text_len'), 'messages', type_='check')
|
||||
op.create_check_constraint(op.f('messages_text_len'), 'messages', 'char_length(text) BETWEEN 0 AND 4000')
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
"""Downgrade schema."""
|
||||
op.drop_index(op.f('message_attachments_attachment_id_idx'), table_name='message_attachments')
|
||||
op.drop_table('message_attachments')
|
||||
op.drop_index(op.f('attachments_created_at_idx'), table_name='attachments')
|
||||
op.drop_table('attachments')
|
||||
op.drop_constraint(op.f('messages_text_len'), 'messages', type_='check')
|
||||
# Сообщения только с вложениями нарушили бы прежнее ограничение; удалять их нельзя (на них ссылаются ключи идемпотентности).
|
||||
op.execute("UPDATE messages SET text = '[вложение]' WHERE text = ''")
|
||||
op.create_check_constraint(op.f('messages_text_len'), 'messages', 'char_length(text) BETWEEN 1 AND 4000')
|
||||
@@ -0,0 +1,31 @@
|
||||
"""attachments.object_key collation C
|
||||
|
||||
Revision ID: 0004
|
||||
Revises: 0003
|
||||
Create Date: 2026-11-12 14:00:00.000000
|
||||
|
||||
Сверка хранилищ сравнивает листинг S3 (ключи в побайтовом порядке UTF-8) с attachments, отсортированной
|
||||
по object_key. С collation "C" порядок совпадает, и уникальный индекс по ключу пересобирается в нём же,
|
||||
поэтому ORDER BY object_key идёт по индексу. Ключи назначает сервер и они ASCII, значения не меняются.
|
||||
"""
|
||||
from typing import Sequence, Union
|
||||
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
|
||||
|
||||
# revision identifiers, used by Alembic.
|
||||
revision: str = '0004'
|
||||
down_revision: Union[str, Sequence[str], None] = '0003'
|
||||
branch_labels: Union[str, Sequence[str], None] = None
|
||||
depends_on: Union[str, Sequence[str], None] = None
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
"""Upgrade schema."""
|
||||
op.alter_column('attachments', 'object_key', type_=sa.Text(collation='C'), existing_nullable=False)
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
"""Downgrade schema."""
|
||||
op.alter_column('attachments', 'object_key', type_=sa.Text(), existing_nullable=False)
|
||||
@@ -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"]
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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()"))
|
||||
@@ -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]
|
||||
@@ -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")
|
||||
@@ -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()"))
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,11 @@
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class ErrorBody(BaseModel):
|
||||
code: str
|
||||
message: str
|
||||
request_id: str
|
||||
|
||||
|
||||
class ErrorResponse(BaseModel):
|
||||
error: ErrorBody
|
||||
@@ -0,0 +1,7 @@
|
||||
from typing import Literal
|
||||
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class HealthResponse(BaseModel):
|
||||
status: Literal["ok"]
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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)]
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,65 @@
|
||||
import hashlib
|
||||
import secrets
|
||||
import uuid
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
import jwt
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import InvalidHashError, VerificationError
|
||||
|
||||
from core.config import settings
|
||||
|
||||
# Argon2id: 64 MiB, 3 прохода (как по умолчанию), но 1 поток вместо 4: реплика ограничена 1 CPU,
|
||||
# и 4 потока только ждали бы квоту. Параметры записаны в самом хеше, старые хеши проверяются как раньше.
|
||||
password_hasher = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=1)
|
||||
|
||||
# Проверяется, когда пользователя нет: время ответа такое же, как при неверном пароле.
|
||||
DUMMY_PASSWORD_HASH = password_hasher.hash(secrets.token_urlsafe(16))
|
||||
|
||||
|
||||
def hash_password(password: str) -> str:
|
||||
return password_hasher.hash(password)
|
||||
|
||||
|
||||
def verify_password(password_hash: str | None, password: str) -> bool:
|
||||
try:
|
||||
password_hasher.verify(password_hash or DUMMY_PASSWORD_HASH, password)
|
||||
return password_hash is not None
|
||||
except (VerificationError, InvalidHashError):
|
||||
return False
|
||||
|
||||
|
||||
JWT_SECRET_KEY = settings.jwt.read_secret_key()
|
||||
|
||||
|
||||
def create_access_token(user_id: uuid.UUID) -> tuple[str, datetime, datetime]:
|
||||
"""Возвращает (токен, время выдачи, время истечения)."""
|
||||
# Целые секунды, чтобы expires_at совпадал с exp в токене.
|
||||
issued_at = datetime.now(timezone.utc).replace(microsecond=0)
|
||||
expires_at = issued_at + timedelta(seconds=settings.jwt.session_ttl_seconds)
|
||||
payload = {
|
||||
"sub": str(user_id),
|
||||
"iat": issued_at,
|
||||
"exp": expires_at,
|
||||
"jti": secrets.token_urlsafe(32), # 256 бит случайности, токен всегда уникален
|
||||
}
|
||||
token = jwt.encode(payload, JWT_SECRET_KEY, algorithm=settings.jwt.algorithm)
|
||||
return token, issued_at, expires_at
|
||||
|
||||
|
||||
def decode_access_token(token: str) -> dict | None:
|
||||
"""None — подпись неверна, токен испорчен или истёк."""
|
||||
try:
|
||||
return jwt.decode(
|
||||
token,
|
||||
JWT_SECRET_KEY,
|
||||
algorithms=[settings.jwt.algorithm], # явно, чтобы не принять alg=none
|
||||
options={"require": ["sub", "exp", "iat", "jti"]},
|
||||
)
|
||||
except jwt.InvalidTokenError:
|
||||
return None
|
||||
|
||||
|
||||
def token_hash(token: str) -> bytes:
|
||||
# В БД хранится только хеш токена.
|
||||
return hashlib.sha256(token.encode()).digest()
|
||||
+257
@@ -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
|
||||
@@ -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"
|
||||
}
|
||||
@@ -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']
|
||||
@@ -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)
|
||||
@@ -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"
|
||||
}
|
||||
@@ -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
|
||||
@@ -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) ========================
|
||||
@@ -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
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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"
|
||||
}
|
||||
@@ -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"
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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
|
||||
@@ -0,0 +1,57 @@
|
||||
#!/bin/sh
|
||||
# Разовая идемпотентная настройка MinIO (сервис minio-init). Повторный запуск ничего не ломает:
|
||||
# bucket создаётся только если его нет, политика и пользователь перезаписываются теми же значениями.
|
||||
set -eu
|
||||
|
||||
BUCKET="${S3_BUCKET:-messenger-attachments}"
|
||||
# Отдельный bucket для своих pytest-тестов: тестовые объекты не смешиваются с рабочими.
|
||||
TEST_BUCKET="${S3_TEST_BUCKET:-messenger-attachments-test}"
|
||||
# Bucket экспериментов сверки хранилищ (трек 2): синтетические данные и внедрённые ошибки.
|
||||
BENCH_BUCKET="${S3_BENCH_BUCKET:-messenger-attachments-bench}"
|
||||
ROOT_USER="$(cat /run/secrets/minio_root_user)"
|
||||
ROOT_PASSWORD="$(cat /run/secrets/minio_root_password)"
|
||||
API_ACCESS_KEY="$(cat /run/secrets/s3_access_key_id)"
|
||||
API_SECRET_KEY="$(cat /run/secrets/s3_secret_access_key)"
|
||||
|
||||
# Alias через переменную окружения: credentials не пишутся в конфиг mc на диске.
|
||||
# Секреты из init-secrets состоят только из [A-Za-z0-9], поэтому их можно вставить в URL как есть.
|
||||
export MC_HOST_root="http://${ROOT_USER}:${ROOT_PASSWORD}@minio:9000"
|
||||
|
||||
# 1. Приватные bucket: анонимный доступ выключен явно.
|
||||
for name in "${BUCKET}" "${TEST_BUCKET}" "${BENCH_BUCKET}"; do
|
||||
mc mb --ignore-existing "root/${name}"
|
||||
mc anonymous set private "root/${name}"
|
||||
done
|
||||
|
||||
# 2. Политика API: только объекты своих bucket, без админских прав и без доступа к другим bucket.
|
||||
# ListBucket нужен очистке объектов без метаданных.
|
||||
cat > /tmp/messenger-api-policy.json <<EOF
|
||||
{
|
||||
"Version": "2012-10-17",
|
||||
"Statement": [
|
||||
{
|
||||
"Effect": "Allow",
|
||||
"Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
|
||||
"Resource": ["arn:aws:s3:::${BUCKET}/*", "arn:aws:s3:::${TEST_BUCKET}/*", "arn:aws:s3:::${BENCH_BUCKET}/*"]
|
||||
},
|
||||
{
|
||||
"Effect": "Allow",
|
||||
"Action": ["s3:ListBucket", "s3:GetBucketLocation"],
|
||||
"Resource": ["arn:aws:s3:::${BUCKET}", "arn:aws:s3:::${TEST_BUCKET}", "arn:aws:s3:::${BENCH_BUCKET}"]
|
||||
}
|
||||
]
|
||||
}
|
||||
EOF
|
||||
mc admin policy create root messenger-api /tmp/messenger-api-policy.json
|
||||
|
||||
# 3. Отдельный пользователь для API (не root). add с тем же ключом обновляет секрет.
|
||||
mc admin user add root "${API_ACCESS_KEY}" "${API_SECRET_KEY}" >/dev/null
|
||||
# Повторный attach той же политики mc считает ошибкой, поэтому сначала проверяем (grep в образе нет — case).
|
||||
USER_INFO="$(mc admin user info root "${API_ACCESS_KEY}" --json)"
|
||||
case "${USER_INFO}" in
|
||||
*'"messenger-api"'*) echo "policy messenger-api already attached" ;;
|
||||
# Вывод mc содержит access key — в лог его не пишем.
|
||||
*) mc admin policy attach root messenger-api --user "${API_ACCESS_KEY}" >/dev/null ;;
|
||||
esac
|
||||
|
||||
echo "bootstrap ok: buckets=${BUCKET},${TEST_BUCKET},${BENCH_BUCKET} (private), api user with policy messenger-api"
|
||||
@@ -0,0 +1,5 @@
|
||||
[pytest]
|
||||
testpaths = student-tests
|
||||
pythonpath = app
|
||||
filterwarnings =
|
||||
ignore:Using .httpx. with .starlette.testclient. is deprecated
|
||||
@@ -0,0 +1,3 @@
|
||||
-r requirements.txt
|
||||
pytest==9.1.1
|
||||
httpx==0.28.1
|
||||
@@ -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
|
||||
@@ -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())
|
||||
@@ -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", {})))
|
||||
@@ -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()
|
||||
@@ -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' }
|
||||
@@ -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"; }
|
||||
@@ -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())
|
||||
@@ -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)
|
||||
@@ -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}}"
|
||||
@@ -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}}'
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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())
|
||||
@@ -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%
|
||||
@@ -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"
|
||||
@@ -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()
|
||||
@@ -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"]
|
||||
@@ -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"
|
||||
@@ -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")
|
||||
@@ -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")
|
||||
@@ -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
|
||||
@@ -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")
|
||||
@@ -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"))
|
||||
@@ -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")
|
||||
Reference in New Issue
Block a user