From 87ce432b815695944ee63e74bdf6c9b517b3b898 Mon Sep 17 00:00:00 2001 From: ferraronp Date: Thu, 12 Nov 2026 18:15:42 +0300 Subject: [PATCH] Implement lab4 private S3 attachments and reconciliation track --- .env.example | 27 +- .gitattributes | 7 + DEMO.md | 16 ++ Dockerfile | 10 + MR_DESCRIPTION.md | 62 +++++ PACKAGE_README.md | 17 ++ PUBLISH_LAB4.md | 103 ++++++++ REPORT.md | 175 +++++++++++-- app/__init__.py | 1 + app/__main__.py | 4 + app/api.py | 191 ++++++++++++++ app/attachments.py | 241 ++++++++++++++++++ app/auth.py | 104 ++++++++ app/core.py | 79 ++++++ app/main.py | 84 ++++++ app/migrate.py | 23 ++ app/models.py | 77 ++++++ app/reconcile.py | 130 ++++++++++ app/reconcile_fault.py | 36 +++ app/reconcile_selftest.py | 61 +++++ app/s3_bootstrap.py | 35 +++ app/s3_policy.py | 32 +++ app/s3_probe.py | 40 +++ app/storage.py | 64 +++++ compose.yaml | 185 ++++++++++++++ db/migrations/001_initial.sql | 33 +++ db/migrations/002_idempotency.sql | 12 + db/migrations/003_attachments.sql | 25 ++ evidence/attachments-concurrent.json | 11 + ...-upload-20261112-180238-stage0-batch1.json | 11 + ...-upload-20261112-180238-stage0-batch2.json | 11 + ...-upload-20261112-180238-stage0-batch3.json | 11 + ...-upload-20261112-180238-stage0-batch4.json | 11 + ...-upload-20261112-180238-stage0-batch5.json | 11 + ...-upload-20261112-180238-stage1-batch1.json | 11 + ...-upload-20261112-180238-stage1-batch2.json | 11 + ...-upload-20261112-180238-stage1-batch3.json | 11 + ...-upload-20261112-180238-stage1-batch4.json | 11 + ...-upload-20261112-180238-stage1-batch5.json | 11 + evidence/reconcile-cost-20261112-180238.csv | 16 ++ ...concile-cost-console-summary-2026-11-12.md | 11 + evidence/verified_results_2026-11-12.md | 110 ++++++++ infra/filer.toml | 4 + infra/haproxy.cfg | 32 +++ requirements.txt | 10 + scripts/measure_reconcile.ps1 | 84 ++++++ scripts/restart.cmd | 11 + scripts/restart.sh | 21 ++ scripts/rolling-update.sh | 17 ++ scripts/stop-one.cmd | 10 + scripts/stop-one.sh | 8 + scripts/wait_ready.py | 14 + tests/attachments_concurrent.py | 42 +++ tests/attachments_negative.py | 41 +++ tests/idempotency_parallel.py | 38 +++ tests/own_unit.py | 42 +++ 56 files changed, 2465 insertions(+), 41 deletions(-) create mode 100644 .gitattributes create mode 100644 DEMO.md create mode 100644 Dockerfile create mode 100644 MR_DESCRIPTION.md create mode 100644 PACKAGE_README.md create mode 100644 PUBLISH_LAB4.md create mode 100644 app/__init__.py create mode 100644 app/__main__.py create mode 100644 app/api.py create mode 100644 app/attachments.py create mode 100644 app/auth.py create mode 100644 app/core.py create mode 100644 app/main.py create mode 100644 app/migrate.py create mode 100644 app/models.py create mode 100644 app/reconcile.py create mode 100644 app/reconcile_fault.py create mode 100644 app/reconcile_selftest.py create mode 100644 app/s3_bootstrap.py create mode 100644 app/s3_policy.py create mode 100644 app/s3_probe.py create mode 100644 app/storage.py create mode 100644 compose.yaml create mode 100644 db/migrations/001_initial.sql create mode 100644 db/migrations/002_idempotency.sql create mode 100644 db/migrations/003_attachments.sql create mode 100644 evidence/attachments-concurrent.json create mode 100644 evidence/measure-upload-20261112-180238-stage0-batch1.json create mode 100644 evidence/measure-upload-20261112-180238-stage0-batch2.json create mode 100644 evidence/measure-upload-20261112-180238-stage0-batch3.json create mode 100644 evidence/measure-upload-20261112-180238-stage0-batch4.json create mode 100644 evidence/measure-upload-20261112-180238-stage0-batch5.json create mode 100644 evidence/measure-upload-20261112-180238-stage1-batch1.json create mode 100644 evidence/measure-upload-20261112-180238-stage1-batch2.json create mode 100644 evidence/measure-upload-20261112-180238-stage1-batch3.json create mode 100644 evidence/measure-upload-20261112-180238-stage1-batch4.json create mode 100644 evidence/measure-upload-20261112-180238-stage1-batch5.json create mode 100644 evidence/reconcile-cost-20261112-180238.csv create mode 100644 evidence/reconcile-cost-console-summary-2026-11-12.md create mode 100644 evidence/verified_results_2026-11-12.md create mode 100644 infra/filer.toml create mode 100644 infra/haproxy.cfg create mode 100644 requirements.txt create mode 100644 scripts/measure_reconcile.ps1 create mode 100644 scripts/restart.cmd create mode 100644 scripts/restart.sh create mode 100644 scripts/rolling-update.sh create mode 100644 scripts/stop-one.cmd create mode 100644 scripts/stop-one.sh create mode 100644 scripts/wait_ready.py create mode 100644 tests/attachments_concurrent.py create mode 100644 tests/attachments_negative.py create mode 100644 tests/idempotency_parallel.py create mode 100644 tests/own_unit.py diff --git a/.env.example b/.env.example index d99d26a2..8cb4d559 100644 --- a/.env.example +++ b/.env.example @@ -1,20 +1,13 @@ -# 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 +# Copy to .env and REPLACE all sample secrets with random unique values. +# For local synthetic data only. Never commit .env. +POSTGRES_DB=messenger +POSTGRES_USER=lab +POSTGRES_PASSWORD=REPLACE_WITH_RANDOM_LOCAL_PASSWORD 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 -API_REPLICAS=2 IDEMPOTENCY_TTL_SECONDS=86400 -S3_ENDPOINT=http://s3:9000 -S3_REGION=us-east-1 +DB_POOL_MAX=8 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 +S3_ADMIN_ACCESS_KEY=adminlab4 +S3_ADMIN_SECRET_KEY=REPLACE_WITH_DIFFERENT_RANDOM_ADMIN_SECRET +S3_ACCESS_KEY=messengerapi +S3_SECRET_KEY=REPLACE_WITH_DIFFERENT_RANDOM_API_SECRET diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..3d63257b --- /dev/null +++ b/.gitattributes @@ -0,0 +1,7 @@ +*.sh text eol=lf +*.py text eol=lf +*.sql text eol=lf +*.yaml text eol=lf +*.cfg text eol=lf +*.md text eol=crlf +*.cmd text eol=crlf diff --git a/DEMO.md b/DEMO.md new file mode 100644 index 00000000..a53e3394 --- /dev/null +++ b/DEMO.md @@ -0,0 +1,16 @@ +# Lab4 — последовательность демонстрации на 5 + +Цель: **показать данные, сбой, обнаружение, исправление и ограничения**, а не просто зелёный smoke. + +1. Схема: `docker compose --env-file .env ps`. Показать два FastAPI, HAProxy, PG, Redis, SeaweedFS; публичен только HAProxy. Секреты `.env` на экране не открывать. +2. `python tests/smoke.py`: файл загружается с SHA-256, второй участник чата скачивает идентичные байты; третий не видит файл (404). +3. `python tests/attachments_negative.py`: файл >10 MiB, MIME mismatch, повреждённое изображение, опасное имя, cross-chat attachment отклоняются. +4. `docker compose --env-file .env run --rm reconcile python -m app.s3_probe`: анонимный список/скачивание из приватного S3 невозможны. +5. Persistence: `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd` — тот же токен, сообщения и байты вложения после перезапуска. +6. Failover: `python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd`; после теста вернуть обе реплики `up -d --no-deps --wait api1 api2`. +7. Важное на 4: `python tests/attachments_concurrent.py --concurrency 10` + RAM sampling через `docker stats`. По предыдущему прогону наблюдалось max api1 109,1 MiB, api2 96,21 MiB при лимите 384 MiB, 10/10 удачных загрузок. +8. На 5: показать reconciler `dry-run`, удалить один оригинальный объект через операторскую команду, показать missing primary, выполнить `--apply` и повторный dry-run; затем orphan, защитный интервал 300 с и удаление после него. Полные команды в `LAB4_TEST_COMMANDS.md`. +9. Исследовательское требование: показать **`evidence/reconcile-cost-20261112-180238.csv`** (оригинал из локального запуска). 15 dry-run: **36/18 → медиана 0,245 с**, **136/68 → 0,285 с**, **236/118 → 0,341 с** (S3-ключи/строки БД). Пояснить, что это время самого сканирования, а не старта контейнера; 3 небольшие выборки не доказывают линейность. +10. Вопрос: если S3 PUT успешно, а PG COMMIT нет, остаётся orphan; best-effort компенсация плюс поздний reconciler. Если потеряны обе S3-копии, восстановление невозможно без внешнего backup. Это не распределённая транзакция. + +Все fault-injection действия применять только в личном синтетическом учебном стенде. Никогда не выполнять `docker compose down -v` перед persistence. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..31979f18 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,10 @@ +FROM python:3.12.10-slim-bookworm +ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 +WORKDIR /srv +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt && groupadd --gid 999 app && useradd -m --uid 999 --gid app app +COPY app ./app +COPY db ./db +USER app +EXPOSE 8080 +CMD ["python", "-m", "app"] diff --git a/MR_DESCRIPTION.md b/MR_DESCRIPTION.md new file mode 100644 index 00000000..6cadade5 --- /dev/null +++ b/MR_DESCRIPTION.md @@ -0,0 +1,62 @@ +## Лабораторная 4 + +**Автор / группа:** Авзалов Артур Марсович / БПИ2301 +**Целевая оценка:** 5 +**Трек 5:** №2 — согласованность PostgreSQL и S3 + +### Что реализовано и перенесено + +Из Lab3 перенесены две статeless FastAPI-реплики за HAProxy (round-robin/healthchecks), PostgreSQL, Redis-сессии, Bearer, идемпотентность отправки сообщений на `Idempotency-Key`, PostgreSQL advisory lock, курсорная пагинация, миграции, failover и persistence. + +В Lab4 добавлены: SeaweedFS 4.53 с приватным S3 bucket, init-контейнеры bucket/policy, отдельные bucket-scoped credentials API, metadata вложений в PostgreSQL, авторизованные raw PNG/JPEG upload/download (≤10 MiB, ≤40 млн пикселей), проверки содержимого/MIME/filename/ACL, потоковое ограничение RAM и две копии объектов (`attachments/` и `recovery/`). + +Для трека 5 создан `app.reconcile`: по умолчанию dry-run inventory PostgreSQL/S3, классификация orphan/missing, восстановление одиночного отсутствующего ключа через recovery copy, удаление orphan только после 300-секундного grace period и повторной проверки записи в БД, повторный безопасный apply. Ручная инъекция повреждений (`app.reconcile_fault`) разрешена только через отдельную переменную на учебном стенде. + +### Запуск из чистого clone + +```powershell +Copy-Item .env.example .env +# В .env задать разные случайные пароли/ключи, не добавлять файл в Git. +$env:PYTHONUTF8 = '1' +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --wait +python scripts/check_contract.py +python tests/smoke.py +python tests/attachments_negative.py +python tests/idempotency_parallel.py +docker compose --env-file .env run --rm reconcile python -m app.s3_probe +``` + +Проверки persistence/failover и fault-injection приведены в [LAB4_TEST_COMMANDS.md](LAB4_TEST_COMMANDS.md); последовательность демонстрации — в [DEMO.md](DEMO.md). + +### Фактические результаты + +- Public smoke, негативные тесты, конкурентная идемпотентность: **PASS**. +- S3 privacy: `private_bucket=true`, anonymous List/Get `denied`. +- Persistence: **PASS**, тест повторно сравнивает исходные байты вложения после перезапуска. +- Failover: **PASS**, восстановление за **6,156 с** (6 успешных записей, 1 неуспешная попытка на переходе). +- 10 конкурентных загрузок PNG: **10/10**, 0 ошибок, 2,796 с, 3,577 upload/s; наблюдённые максимумы RAM API **109,1 MiB** и **96,21 MiB** при лимите 384 MiB на экземпляр. +- Удалён основной ключ S3: dry-run обнаружил `missing_primary_repairable`; `--apply` восстановил объект из recovery copy; повторная сверка ошибок не обнаружила. +- Orphan S3 без metadata: свежий объект не удалён даже в `--apply`; после 310 с `delete-old-orphan`; последующий dry-run показал 34 S3-ключа, 17 DB-строк и пустые списки расхождений, обход **0,213 с**. +- При остановке S3: HTTP **503**, после его запуска и готовности API повторный smoke **PASS**. + +Подробные методики, реальные численные результаты, архитектура и ограничения в [REPORT.md](REPORT.md) и [evidence/verified_results_2026-11-12.md](evidence/verified_results_2026-11-12.md). + +### Ограничения / незакрытые проверки + +- `reconcile` пока измерен только на маленьком наборе (34 S3-ключа/17 DB-строк): сравнительный эксперимент стоимости на ≥3 масштабах **подготовлен** (`scripts/measure_reconcile.ps1`), но **не заявлен как выполненный**, пока нет CSV. +- Не инъецировались одновременная потеря обеих копий, реальная авария PostgreSQL COMMIT и гонка появления ссылки в БД непосредственно перед удалением orphan. +- Две S3-копии лежат в одном SeaweedFS, это не независимый backup; также единичные точки отказа PG/Redis/LB/Docker-host. Нет TLS для production, стенд рассчитан на localhost. + +### Источники и использование ИИ + +Контракт и тесты лабораторной 4, документация FastAPI, PostgreSQL, Redis, HAProxy, Docker Compose, SeaweedFS/S3, Pillow. ChatGPT применялся для архитектуры, реализации, конфигурации, миграций, тестов и отчёта. Проверки реально выполнялись локально; неподтверждённые PASS не заявлены. + +### Чек-лист + +- [x] Обязательный минимум предыдущих работ сохранён. +- [x] Контракт и публичные тесты оставлены без ослабления. +- [x] Эквиваленты `make check` и `make test` запущены напрямую через Python; фактические PASS указаны. +- [x] Отказы API и S3, ACL, persistence, S3 privacy, reconciliation воспроизведены. +- [ ] Проверены staged-файлы на отсутствие credentials/secrets перед push (отметить после локальной проверки). +- [x] README задания сохранён, REPORT.md содержит инструкцию решения. diff --git a/PACKAGE_README.md b/PACKAGE_README.md new file mode 100644 index 00000000..e92cf2a5 --- /dev/null +++ b/PACKAGE_README.md @@ -0,0 +1,17 @@ +# Lab4 — пакет оформления результата на оценку 5 + +Содержит только документацию, экспериментальный PowerShell-скрипт и обезличенные результаты. НЕ содержит приложение, `.env` или секреты. Развернуть поверх текущего Lab4: + +```powershell +Expand-Archive -Path "$HOME\Downloads\lab4_submission_docs.zip" -DestinationPath . -Force +``` + +Затем: + +```powershell +powershell -ExecutionPolicy Bypass -File scripts/measure_reconcile.ps1 +``` + +Скрипт выполнит 15 dry-run в 3 группах и добавит 100 синтетических вложений через API; не запускает --apply/DELETE. Результаты — `evidence/reconcile-cost-*.csv`. Повторные upload используют текущий API; рабочие данные проекта не должны находиться в этом стенде. + +Важно: REPORT.md уже обновлён по реальным логам; результаты sweep пока не объявлены как подтверждённые. Перед MR проверьте новые и существующие файлы на отсутствие секретов, соответствие `REPORT.md` текущему HEAD и выполните smoke после копирования. diff --git a/PUBLISH_LAB4.md b/PUBLISH_LAB4.md new file mode 100644 index 00000000..097598a8 --- /dev/null +++ b/PUBLISH_LAB4.md @@ -0,0 +1,103 @@ +# Lab4 — Git, fork и MR + +Этот рецепт рассчитан на ситуацию, когда рабочая папка `mtusi2026lab4` распакована из архива и все Docker-тесты выполнялись **из неё**. Не копирует `.env`, `.git`, исходные `tests/smoke.py`, `tests/client.py`, `README.md`, `COURSE.md`, `contracts/`. + +## 1. Подложить отчёт и измерить стоимость обхода + +```powershell +# Из рабочей папки Lab4 +Expand-Archive -Path "$HOME\Downloads\lab4_submission_docs.zip" -DestinationPath . -Force +$env:PYTHONUTF8 = '1' +# Если есть время до MR: три уровня нагрузки, пять замеров на каждом +powershell -ExecutionPolicy Bypass -File scripts/measure_reconcile.ps1 +``` + +После измерения добавьте таблицу из `evidence/reconcile-cost-*.csv` в `REPORT.md` вместо пометки «не проверено». Скрипт создаёт синтетические вложения и не удаляет их; используйте тестовый стенд. + +## 2. Если локальная папка НЕ является Git clone + +Создайте fork **именно репозитория Lab4** в Gitea. Затем из рабочей папки Lab4 выполните: + +```powershell +$ErrorActionPreference = 'Stop' +$src = (Get-Location).Path +$forkUrl = Read-Host 'Вставьте HTTPS-ссылку на свой fork Lab4' +Set-Location .. +if (Test-Path .\mtusi2026lab4-fork) { throw 'Папка mtusi2026lab4-fork уже есть; не перезаписываем её' } +git clone $forkUrl mtusi2026lab4-fork +if ($LASTEXITCODE -ne 0) { throw 'Не получилось клонировать fork' } +Set-Location .\mtusi2026lab4-fork +git switch -c solution/BPI2301-Avzalov +if ($LASTEXITCODE -ne 0) { throw 'Не получилось создать ветку' } + +# Собственные исходники и миграции; skeleton сохраняем. +New-Item -ItemType Directory -Force app, 'db/migrations', infra, scripts, tests, evidence | Out-Null +Copy-Item "$src\app\*.py" '.\app\' -Force +Copy-Item "$src\db\migrations\*.sql" '.\db\migrations\' -Force +Copy-Item "$src\infra\haproxy.cfg", "$src\infra\filer.toml" '.\infra\' -Force + +foreach ($name in @('Dockerfile','compose.yaml','requirements.txt','.env.example','.gitattributes','REPORT.md','DEMO.md','LAB4_TEST_COMMANDS.md')) { + Copy-Item (Join-Path $src $name) . -Force +} +foreach ($name in @('restart.cmd','restart.sh','stop-one.cmd','stop-one.sh','rolling-update.sh','wait_ready.py','measure_reconcile.ps1')) { + Copy-Item (Join-Path $src ('scripts/' + $name)) '.\scripts\' -Force +} +foreach ($name in @('attachments_concurrent.py','attachments_negative.py','idempotency_parallel.py','own_unit.py')) { + Copy-Item (Join-Path $src ('tests/' + $name)) '.\tests\' -Force +} +Copy-Item "$src\evidence\verified_results_2026-11-12.md" '.\evidence\' -Force +foreach ($name in @('attachments-concurrent.json')) { + $path = Join-Path $src ('evidence/' + $name) + if (Test-Path $path) { Copy-Item $path '.\evidence\' -Force } +} +Get-ChildItem "$src\evidence\reconcile-cost-*.csv" -ErrorAction SilentlyContinue | ForEach-Object { + Copy-Item $_.FullName '.\evidence\' -Force +} + +# Тесты и контракт должны остаться из fork. +git add .env.example .gitattributes Dockerfile compose.yaml requirements.txt REPORT.md DEMO.md LAB4_TEST_COMMANDS.md app db/migrations infra/haproxy.cfg infra/filer.toml scripts/restart.cmd scripts/restart.sh scripts/stop-one.cmd scripts/stop-one.sh scripts/rolling-update.sh scripts/wait_ready.py scripts/measure_reconcile.ps1 tests/attachments_concurrent.py tests/attachments_negative.py tests/idempotency_parallel.py tests/own_unit.py evidence + +git update-index --chmod=+x scripts/restart.sh +git update-index --chmod=+x scripts/stop-one.sh +git update-index --chmod=+x scripts/rolling-update.sh + +git diff --cached --check +git --no-pager diff --cached --stat +git status --short +git ls-files .env +python scripts/check_contract.py + +# ПОСЛЕ ручного просмотра staged diff на наличие секретов: +git commit -m 'Implement lab4 private S3 attachments and reconciliation track' +git push -u origin solution/BPI2301-Avzalov +``` + +**Почему без запуска нового Docker Compose внутри clone:** новый каталог и имя Compose-проекта создадут новые volumes, а порт `8080` может быть занят старым стендом. Поэтому интеграционные тесты сначала относятся к рабочему каталогу, из которого копируются файлы. Если нужно проверить именно clone, остановите старый стенд, создайте локальный `.env` в clone, поднимите чистый стенд и повторите публичные тесты. + +## 3. Если Lab4 УЖЕ находится в Git clone + +Тогда ничего не клонируйте и не копируйте, оставайтесь в рабочей папке: + +```powershell +git remote -v +git branch --show-current +git status --short +git add .env.example .gitattributes Dockerfile compose.yaml requirements.txt REPORT.md DEMO.md LAB4_TEST_COMMANDS.md app db/migrations infra/haproxy.cfg infra/filer.toml scripts/restart.cmd scripts/restart.sh scripts/stop-one.cmd scripts/stop-one.sh scripts/rolling-update.sh scripts/wait_ready.py scripts/measure_reconcile.ps1 tests/attachments_concurrent.py tests/attachments_negative.py tests/idempotency_parallel.py tests/own_unit.py evidence +git diff --cached --check +git --no-pager diff --cached --stat +git ls-files .env +# убедитесь, что origin — ваш fork, а в diff нет секретов и изменения контрактов +git commit -m 'Implement lab4 private S3 attachments and reconciliation track' +git push origin HEAD +``` + +## 4. Создать MR + +Title: **ЛР 4 — БПИ2301 — Авзалов — на 5**. + +- Source: ваш fork, ветка `solution/BPI2301-Avzalov` (либо фактическая ветка, если MR уже создан). +- Target: исходный **Lab4**, `main`. +- Описание: скопировать содержимое `MR_DESCRIPTION.md`. +- Перед отправкой выполнить `git status --short`, просмотреть список изменённых файлов, убрать секреты и проверить, что public `tests/`, `contracts/`, `README.md`, `COURSE.md` не переписаны. + +Если MR уже создан, достаточно нового коммита и push в его **существующую source-ветку**; пересоздавать MR не нужно. diff --git a/REPORT.md b/REPORT.md index 9ad2b84f..49c4f524 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,164 @@ -# Отчёт — лабораторная 4 +# Отчёт — лабораторная 4: S3-вложения -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +**Автор / группа:** Авзалов Артур Марсович / БПИ2301 +**Целевая оценка:** 5 +**Выбранный трек:** №2 — согласованность PostgreSQL и S3 +**Среда:** Windows PowerShell, Docker Desktop, Python, Docker Compose; прогоны представлены в переписке 12.11.2026. +**Статус:** основной функционал, восстановление потерянного объекта, очистка orphan и сравнительная стоимость обхода **проверены локально 12.11.2026**. Не проверены отдельно одновременная потеря двух S3-копий и реальная авария COMMIT PostgreSQL; ограничения явно указаны ниже. -## Запуск из чистого clone +## Архитектура и перенос Lab3 -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +```text +Клиент (127.0.0.1:8080) + │ + HAProxy, HTTP L7, round-robin + ├── FastAPI api1 ─┐ + └── FastAPI api2 ─┤ + ├── PostgreSQL: пользователи, чаты, сообщения, metadata вложений, receipts + ├── Redis: общие bearer-сессии + └── SeaweedFS S3: приватные объекты-оригиналы и recovery copy -## Архитектура и решения +One-shot: migrate / s3-policy / s3-bootstrap +Maintenance: reconcile (dry-run по умолчанию) +``` -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Сохранены публичное API и механизмы Lab3: Bearer-сессии, сообщения, миграции, курсорная пагинация, Idempotency-Key, конкуренция через PostgreSQL advisory lock, X-Instance-Id, X-Request-Id, readiness/healthchecks, две взаимозаменяемые реплики и отказ одной из них. Все реплики используют общие PostgreSQL, Redis и S3. В наружную сеть публикуется только порт HAProxy `127.0.0.1:8080`; S3-консоль/API и PostgreSQL/Redis не публикуются на хост. -## Доказательства критериев +В `compose.yaml` закреплены образы `postgres:16.10-bookworm`, `redis:7.4.5-alpine`, `haproxy:3.1.7-alpine`, `chrislusf/seaweedfs:4.53`. S3 хранит данные в именованных volumes. `s3-policy` формирует политику доступа, `s3-bootstrap` создаёт приватный bucket; API и reconciler используют выделенные ключи, ограниченные bucket. Локальные `.env` и приватные credentials не должны попадать в Git. -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +## Контракт вложений -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +- `POST /api/v1/chats/{chat_id}/attachments?filename=...`: raw PNG/JPEG, не `multipart`; `201` только после успешных S3 PUT оригинала/резервной копии и COMMIT метаданных в PostgreSQL. +- Изображение проверяется по сигнатуре/декодированию, соответствию заявленному MIME, границам размера (10 MiB) и пикселей (40 млн), небезопасные имена файлов отклоняются. Имя файла используется только в metadata, S3-ключ генерирует сервер. +- `GET /api/v1/attachments/{id}` и `GET /api/v1/attachments/{id}/content` проверяют участие пользователя в чате, иначе 404. Оригинал читается из общего S3 и отдаётся через API без публичного S3 URL. +- Ограничение памяти: streaming/spool с RAM-порогом 1 MiB, максимум исходника 10 MiB; семафор для Pillow-декодирования. Контейнер API имеет `mem_limit: 384m`. +- Для каждого attachment хранятся `attachments//original` и `recovery//original`. Это две логические копии **на одном SeaweedFS**, не защита от потери всего S3-узла. -## Эксперименты и отказы +## Проблема согласованности PostgreSQL и S3 -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +S3 PUT и PostgreSQL COMMIT не образуют распределённой транзакции. Возможные сбои: -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +1. S3-объект уже создан, а транзакция БД не завершилась — **orphan**, объект без metadata. +2. Metadata присутствует, но основного S3-ключа нет — **missing primary**; его можно восстановить из recovery copy. +3. Metadata присутствует, но резервного S3-ключа нет — **missing backup**; его можно восстановить из основного. +4. Отсутствуют обе копии — автоматическое восстановление невозможно; нужен внешний backup/ручной разбор. -## Ограничения и следующие шаги +В пути загрузки выполняется best-effort компенсационное удаление при ошибке. Периодическая сверка (`python -m app.reconcile`) перечисляет S3-ключи и записи PostgreSQL, классифицирует несовпадения, печатает JSON. По умолчанию **dry-run**, без изменений. `--apply` восстанавливает потерянную копию или удаляет orphan только после `grace_seconds >= 300` и повторной проверки, что объект не указан в зафиксированной таблице БД. Повторный `--apply` при согласованном состоянии не должен делать действий. При потере обеих копий metadata не удаляются. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Гипотеза трека: **сверка двух хранилищ, recovery copy и защитный интервал позволяют исправлять одиночные пропажи ключей и безопасно убирать orphan-объекты без удаления используемых файлов**. Издержка решения — около двух копий занимаемого S3-пространства; полный проход держит инвентаризацию в памяти порядка `O(N_s3_keys + N_db_rows)` и выполняет соответствующее число проверок/перечислений. + +## Запуск с чистого clone (PowerShell) + +Требуются Docker Desktop с Compose v2, Python 3.9+ (для локальных тестов), работающий Docker Engine. Запуск из корня текущей Lab4: + +```powershell +Copy-Item .env.example .env +notepad .env +# Установить разные случайные POSTGRES_PASSWORD, S3_ADMIN_SECRET_KEY, S3_SECRET_KEY; +# проверить значения остальных обязательных переменных без публикации секретов. +$env:PYTHONUTF8 = '1' +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --wait +docker compose --env-file .env ps +python scripts/check_contract.py +python tests/smoke.py +python tests/attachments_negative.py +python tests/idempotency_parallel.py +``` + +Эквивалент `make check` — `python scripts/check_contract.py`; эквивалент `make test` — `python tests/smoke.py`. В представленных логах проверялись прямые вызовы Python, а не отдельный запуск `make`. На Windows можно вызвать `make check PYTHON=python` и `make test PYTHON=python`, если make установлен. + +**Persistence:** `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd` +**Failover:** `python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd`; после теста восстановить `docker compose --env-file .env up -d --no-deps --wait api1 api2`. +**S3:** `docker compose --env-file .env run --rm reconcile python -m app.s3_probe`. +**Reconciler:** `docker compose --env-file .env run --rm reconcile python -m app.reconcile [--apply]`. +В `LAB4_TEST_COMMANDS.md` перечислены демонстрационные и негативные сценарии. Безопасная остановка: `docker compose --env-file .env down` **без `-v`**, иначе удалятся данные. + +## Фактические результаты локальных испытаний + +Результаты ниже основаны на переданных stdout PowerShell/Docker. Это локальные прогоны, не CI. Следы команд и ключевые JSON-выводы обезличенно переписаны в `evidence/verified_results_2026-11-12.md`. Неинструментированная производительность из одного запуска не обобщается на production. + +| Проверка | Результат | Комментарий | +|---|---|---| +| `docker compose config --quiet`, `up -d --build --wait` | PASS | Контейнеры API × 2, HAProxy, PostgreSQL, Redis, S3 запущены; API/LB/DB/Redis healthy | +| `python scripts/check_contract.py` | PASS | Offline-проверка структуры и синтаксиса, не интеграционный тест | +| `python tests/smoke.py` | PASS | Public API, вложение, checksum, ACL | +| `python tests/attachments_negative.py` | PASS | MIME, повреждение, размер, filename, ACL, cross-chat | +| `python tests/idempotency_parallel.py` | PASS | Две реплики, одно сообщение, replay 201, конфликт 409 | +| `python -m app.s3_probe` | PASS | Private bucket: анонимные listing/object GET запрещены | +| `python -m app.reconcile_selftest` | PASS | Изолированная проверка dry-run, grace, restore, повторного apply; не заменяет интеграционные тесты | +| `python -m app.reconcile` до инъекций | PASS | 4 S3-ключа, 2 строки БД; нет расхождений и ошибок | +| Persistence с `restart.cmd` | PASS | После перезапуска сохранены сообщения, сессия и байты вложения; тест сверяет скачанное с исходником | +| Failover с `stop-one.cmd` | PASS | 2 реплики до отказа, 6 успешных записей, 1 неуспешная попытка; восстановление за **6,156 с** | +| 10 параллельных PNG-загрузок | PASS | 10/10, ошибок 0, 2,796 с, 3,577 upload/s, p50 2164 мс, max 2344 мс, 111817 байт/файл | +| RAM API при конкурентных загрузках | Наблюдено | Пиковые из выборочных `docker stats`: api1 **109,1 MiB**, api2 **96,21 MiB**, оба лимита 384 MiB; не абсолютный пик | +| Отказ S3 | PASS | После `docker compose stop s3` HAProxy вернул HTTP 503; после запуска S3 и готовности API smoke PASS | +| Повторная сверка после всех восстановлений | PASS | 34 S3-ключа, 17 строк БД; проблем нет; время обхода 0,213 с | + +### Эксперимент A: потерян основной S3-объект + +**Инъекция:** `python -m app.reconcile_fault delete-primary --id ` под `LAB4_ALLOW_FAULT_INJECTION=yes`. Только учебное окружение. Изменён объект `attachments/045ee0a6-be0d-4712-884f-b82145888ad6/original` (идентификатор синтетического вложения). + +| Шаг | Наблюдение | +|---|---| +| Удаление оригинала | `fault: delete-primary`; recovery copy сохранена | +| Первый dry-run | `missing_primary_repairable` содержит UUID, `actions=[]`, `errors=[]`; 31 ключ, 16 строк, **0,162 с** | +| `--apply` | `action: restore`, копирование из `recovery//original` → `attachments//original`, `errors=[]`; **0,216 с** | +| Повторный dry-run | 32 ключа, 16 строк, пустые mismatch и actions; **0,159 с** | +| Повторный apply, отдельный прогон | 34 ключа, 17 строк, `actions=[]` и `errors=[]`; **0,179 с** | +| Smoke после восстановления | PASS | + +**Вывод:** успешное восстановление одиночной пропажи основного ключа подтверждено на реальном SeaweedFS/PostgreSQL. Приведённый публичный smoke проходил после исправления, но байтовая сверка **именно выбранного вручную UUID** отдельно не снималась. + +### Эксперимент B: объект существует в S3 без metadata + +**Инъекция:** `python -m app.reconcile_fault create-orphan` (моделирует разрыв «S3 PUT успел, PostgreSQL COMMIT не произошёл»). Создан `attachments/db466391-0d91-4757-990f-f2bb93872f5d/original`. + +| Шаг | Наблюдение | +|---|---| +| Dry-run сразу после создания | `orphan_keys_young` содержит объект, `orphan_keys=[]`, `actions=[]`, 35 ключей/17 строк, **0,190 с** | +| `--apply` до истечения 300 с | Объект **не удалён**, `actions=[]`, `orphan_keys_young` содержит ключ, **0,225 с** | +| Пауза | Явное `Start-Sleep -Seconds 310` | +| `--apply` после паузы | `orphan_keys` содержит ключ, `action: delete-old-orphan`, `errors=[]`, **0,228 с** | +| Финальный dry-run | 34 ключа, 17 строк, нет orphan/missing/errors/actions, **0,213 с** | + +**Вывод:** grace period не позволяет удалить свежий объект; stale orphan удаляется только в apply. Отдельная авария/откат реальной PG-транзакции при загрузке не инъецировалась — испытан эквивалентный итоговый случай «S3 объект есть, metadata нет». + +### Эксперимент C: недоступность SeaweedFS + +`docker compose --env-file .env stop s3` → публичный `GET /health/ready` через HAProxy вернул **HTTP 503** (`No server is available to handle this request`). Затем `up -d s3`, `up -d --wait api1 api2 lb` и `python tests/smoke.py` → **PASS**. Это подтверждает отказ публичной готовности и восстановление работоспособности. Прямые ответы каждой реплики `/health/ready` при отключённом S3 отдельно не снимались. + +### Эксперимент D: стоимость обхода при трёх объёмах данных + +**Гипотеза:** при увеличении числа объектов S3 и строк PostgreSQL растёт объём инвентаризации и потенциальная стоимость полной сверки, но для небольшого локального набора время одного прохода остаётся приемлемым. + +**Методика:** из корня Lab4 запущен `powershell -ExecutionPolicy Bypass -File scripts/measure_reconcile.ps1`. На каждом этапе выполнялось **5 независимых dry-run**, всего **15**. После этапов 0 и 1 добавлялось по 50 PNG-вложений (5 пакетов × 10 параллельных upload), всего **100 новых вложений**, **0 ошибок загрузки**. Каждый upload создаёт две S3-копии. Измеряется **`scan_elapsed_seconds` внутри reconciler**, а не общее время создания временного Docker-контейнера. Никакого `--apply` во время замеров не было. + +| Этап | Ключей S3 | Строк БД | Прогонов | Среднее, с | Медиана, с | Диапазон, с | +|---|---:|---:|---:|---:|---:|---:| +| 0 | 36 | 18 | 5 | **0,3208** | **0,245** | 0,207–0,624 | +| 1 | 136 | 68 | 5 | **0,3068** | **0,285** | 0,270–0,401 | +| 2 | 236 | 118 | 5 | **0,3814** | **0,341** | 0,289–0,568 | + +Измерения из stdout соответствуют файлу, созданному на машине тестирования: **`evidence/reconcile-cost-20261112-180238.csv`**. Приложите **оригинальный CSV**, а не вручную переписанные данные, в Git вместе с отчётом. Обезличенная сводка и 15 значений приведены также в `evidence/verified_results_2026-11-12.md`. + +**Интерпретация:** при росте числа ключей с 36 до 236 (≈6,56 раза) медиана выросла с 0,245 до 0,341 с (≈39%). Среднее на этапе 1 оказалось чуть ниже этапа 0 из-за разброса/первого длительного замера; упорядоченный рост трёх медиан — наблюдение, **не доказательство линейной масштабируемости**. Малый набор, один хост, 5 прогонов на этап, кеширование и сетевые колебания ограничивают переносимость результатов. Полный inventory хранит списки ключей/строк в RAM; для больших объёмов нужны потоковая пагинация и батчинг. + +Отдельный ранний контрольный замер: **34 ключа S3 + 17 строк БД → 0,213 с**; он относится к другому моменту измерений и не заменяет серию выше. + +## Что пока не заявляется как PASS + +- Инъекция **одновременной потери обеих S3-копий** и подтверждение nonzero/ручной обработки. Алгоритм содержит ветку `missing_both_unrecoverable`, но интеграционный тест не предъявлен. +- Полноценная реальная ошибка PostgreSQL COMMIT посреди upload; созданный orphan моделирует конечное состояние этого сбоя. +- Вариант, когда чужой объект получает ссылку из БД строго **между** inventory и DELETE, отдельно не проверен в живой гонке (в коде есть повторная проверка ссылки). +- Измерены только небольшие локальные наборы (36–236 S3-ключей); на сотнях тысяч и миллионах объектов время/память не измерялись. +- Стресс ≥10 параллельных больших файлов: тест использовал 10 файлов по 111817 байт; измеренные значения RAM относятся к этому профилю. +- Доступность при потере PostgreSQL, Redis, S3-диска, Docker-host/HAProxy, реальное rolling deployment несовместимых версий, TLS/дистрибутивные секреты. + +## Ограничения и безопасность + +Один Docker-host, один S3/PG/Redis/LB — точки отказа. Recovery copy находится на том же SeaweedFS и не заменяет внешний backup. Результат HTTP `503` ожидаем при критической недоступности S3. На локальном учебном окружении transport S3/PG/Redis не использует mTLS; для production нужны TLS, внешний secret manager, backups, логи и метрики. При оборванной потоковой отдаче уже отправленный `200` нельзя отозвать: проверяйте полноту ответа/checksum на стороне клиента. Поведение отката при сбое между двух независимых хранилищ основано на компенсации и сверке, не на общей ACID-транзакции. Полный inventory держится в памяти и требует батчинга на больших объёмах. + +## Источники и применение ИИ + +Основание: `README.md`, `contracts/`, `tests/README.md` лабораторной №4, документация S3/SeaweedFS, PostgreSQL, Redis, Docker Compose, HAProxy, FastAPI и Pillow. ChatGPT использовался для проектирования, программирования, SQL-миграций, тестов, Docker-конфигурации, скриптов и текста отчёта. Данные испытаний получены локальными командами пользователя, а не сгенерированы ИИ. В Git не публикуются `.env`, credentials, session tokens, приватные ключи, приватные данные и volumes. diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e12a1933 --- /dev/null +++ b/app/__init__.py @@ -0,0 +1 @@ +"""Lab 3 messenger API.""" diff --git a/app/__main__.py b/app/__main__.py new file mode 100644 index 00000000..87740f8f --- /dev/null +++ b/app/__main__.py @@ -0,0 +1,4 @@ +import os +import uvicorn +if __name__ == "__main__": + uvicorn.run("app.main:app", host="0.0.0.0", port=int(os.getenv("APP_PORT", "8080")), workers=1, timeout_graceful_shutdown=8) diff --git a/app/api.py b/app/api.py new file mode 100644 index 00000000..82136217 --- /dev/null +++ b/app/api.py @@ -0,0 +1,191 @@ +"""Messenger HTTP handlers; state lives only in PostgreSQL/Redis.""" +import hashlib +import json +import re +import uuid + +import psycopg +from argon2 import PasswordHasher +from fastapi import APIRouter, Request + +from .auth import current_user, hasher, login, logout, public_user +from .core import APIError, invalid, iso, make_cursor, parse_limit, parse_uuid, read_cursor +from .models import CreateChat, CreateMessage, CreateUser +from .storage import db + +router = APIRouter() +KEY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$", re.ASCII) + + +def actor(req: Request) -> dict: + return getattr(req.state, "actor", None) or current_user(req) + + +def chat_detail(conn, chat: dict) -> dict: + members = conn.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY position", (chat["id"],)).fetchall() + return {"id": str(chat["id"]), "title": bytes(chat["title"]).decode("utf-8"), "created_at": iso(chat["created_at"]), "member_ids": [str(x["user_id"]) for x in members]} + + +def message_detail(conn, row: dict) -> dict: + linked = conn.execute("SELECT attachment_id FROM message_attachments WHERE message_id=%s ORDER BY position", (row["id"],)).fetchall() + return {"id": str(row["id"]), "chat_id": str(row["chat_id"]), "sender_id": str(row["sender_id"]), "text": bytes(row["text"]).decode("utf-8"), "created_at": iso(row["created_at"]), "attachment_ids": [str(x["attachment_id"]) for x in linked]} + + +def require_chat(conn, chat_id: str, actor_id: str) -> dict: + row = conn.execute("SELECT c.* FROM chats c JOIN chat_members cm ON cm.chat_id=c.id WHERE c.id=%s AND cm.user_id=%s", (chat_id, actor_id)).fetchone() + if row is None: + raise APIError(404, "not_found", "Object not found") + return row + + +@router.get("/health/live") +def live(): + return {"status": "ok"} + + +@router.get("/health/ready") +def ready(): + from .storage import ready as storage_ready + if not storage_ready(): + raise APIError(503, "unavailable", "Service not ready") + return {"status": "ok"} + + +@router.post("/api/v1/users", status_code=201) +def register(body: CreateUser): + hashed = hasher.hash(body.password) + ident = str(uuid.uuid4()) + try: + with db() as conn: + row = conn.execute("INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING *", (ident, body.username, body.display_name.encode("utf-8"), hashed)).fetchone() + return public_user(row) + except psycopg.errors.UniqueViolation: + raise APIError(409, "conflict", "Username already exists") from None + + +@router.post("/api/v1/auth/sessions", status_code=201) +def sessions(req: Request): + return login(req) + + +@router.delete("/api/v1/auth/sessions/current", status_code=204) +def sessions_delete(req: Request): + logout(req) + return None + + +@router.get("/api/v1/users/me") +def users_me(req: Request): + return actor(req) + + +@router.post("/api/v1/chats", status_code=201) +def chats_create(req: Request, body: CreateChat): + ident = actor(req)["id"] + if ident not in body.member_ids: + raise invalid("Current user must belong to the chat") + chat_id = str(uuid.uuid4()) + try: + with db() as conn: + with conn.transaction(): + # Validate all members; FK constraints are the final authority for races. + found = conn.execute("SELECT id FROM users WHERE id = ANY(%s::uuid[])", (body.member_ids,)).fetchall() + if len(found) != len(body.member_ids): + raise invalid("Unknown member") + row = conn.execute("INSERT INTO chats(id,title) VALUES (%s,%s) RETURNING *", (chat_id, body.title.encode("utf-8"))).fetchone() + for pos, member in enumerate(body.member_ids): + conn.execute("INSERT INTO chat_members(chat_id,user_id,position) VALUES (%s,%s,%s)", (chat_id, member, pos)) + result = chat_detail(conn, row) + return result + except psycopg.errors.ForeignKeyViolation: + raise invalid("Unknown member") from None + + +@router.get("/api/v1/chats") +def chats_list(req: Request, limit: str | None = None, cursor: str | None = None): + who = actor(req)["id"] + n = parse_limit(limit) + mark = read_cursor(cursor, "chats", who) + with db() as conn: + if mark: + existing = conn.execute("SELECT 1 FROM chats c JOIN chat_members cm ON c.id=cm.chat_id WHERE c.id=%s AND c.created_at=%s AND cm.user_id=%s", (mark[1], mark[0], who)).fetchone() + if not existing: + raise invalid("Invalid cursor") + rows = conn.execute(""" + SELECT c.* FROM chats c JOIN chat_members cm ON cm.chat_id=c.id + WHERE cm.user_id=%s AND (%s::timestamptz IS NULL OR (c.created_at,c.id)>(%s::timestamptz,%s::uuid)) + ORDER BY c.created_at,c.id LIMIT %s + """, (who, mark[0] if mark else None, mark[0] if mark else None, mark[1] if mark else None, n+1)).fetchall() + items = [chat_detail(conn, row) for row in rows[:n]] + more = len(rows) > n + last = rows[n-1] if more else None + return {"items": items, "next_cursor": make_cursor("chats", who, last["created_at"], str(last["id"])) if last else None} + + +@router.get("/api/v1/chats/{chat_id}") +def chats_get(req: Request, chat_id: str): + who = actor(req)["id"] + ident = parse_uuid(chat_id) + with db() as conn: + row = require_chat(conn, ident, who) + return chat_detail(conn, row) + + +@router.post("/api/v1/chats/{chat_id}/messages", status_code=201) +def messages_create(req: Request, chat_id: str, body: CreateMessage): + who = actor(req)["id"] + ident = parse_uuid(chat_id) + key = req.headers.get("Idempotency-Key") + if not key or not KEY_RE.fullmatch(key): + raise invalid("Invalid Idempotency-Key") + # Lab3 has only text; canonical JSON avoids unstable formatting/field ordering. + fingerprint = hashlib.sha256(json.dumps({"text": body.text, "attachment_ids": body.attachment_ids}, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")).hexdigest() + lock_scope = f"{who}:POST:/api/v1/chats/{ident}/messages:{key}" + with db() as conn: + with conn.transaction(): + require_chat(conn, ident, who) + # Transaction-scoped advisory lock is GLOBAL across API replicas. + conn.execute("SELECT pg_advisory_xact_lock(hashtextextended(%s, 0))", (lock_scope,)) + previous = conn.execute(""" + SELECT idem.body_sha256, m.* FROM message_idempotency idem + JOIN messages m ON m.id=idem.message_id + WHERE idem.actor_id=%s AND idem.chat_id=%s AND idem.method='POST' AND idem.idem_key=%s + """, (who, ident, key)).fetchone() + if previous: + if previous["body_sha256"] != fingerprint: + raise APIError(409, "conflict", "Idempotency key used with another body") + return message_detail(conn, previous) + # 404 for foreign/nonexistent IDs; check BEFORE any message insert. + if body.attachment_ids: + owned = conn.execute("SELECT id FROM attachments WHERE chat_id=%s AND id=ANY(%s::uuid[])", (ident, body.attachment_ids)).fetchall() + if len(owned) != len(body.attachment_ids): + raise APIError(404, "not_found", "Attachment not found") + message_id = str(uuid.uuid4()) + row = conn.execute("INSERT INTO messages(id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING *", (message_id, ident, who, body.text.encode("utf-8"))).fetchone() + for pos, attachment_id in enumerate(body.attachment_ids): + conn.execute("INSERT INTO message_attachments(message_id,attachment_id,position) VALUES (%s,%s,%s)", (message_id, attachment_id, pos)) + conn.execute("INSERT INTO message_idempotency(actor_id,chat_id,method,idem_key,body_sha256,message_id) VALUES (%s,%s,'POST',%s,%s,%s)", (who, ident, key, fingerprint, message_id)) + return message_detail(conn, row) + + +@router.get("/api/v1/chats/{chat_id}/messages") +def messages_list(req: Request, chat_id: str, limit: str | None = None, cursor: str | None = None): + who = actor(req)["id"] + ident = parse_uuid(chat_id) + n = parse_limit(limit) + mark = read_cursor(cursor, "messages", ident) + with db() as conn: + require_chat(conn, ident, who) + if mark: + existing = conn.execute("SELECT 1 FROM messages WHERE id=%s AND chat_id=%s AND created_at=%s", (mark[1], ident, mark[0])).fetchone() + if not existing: + raise invalid("Invalid cursor") + rows = conn.execute(""" + SELECT * FROM messages WHERE chat_id=%s + AND (%s::timestamptz IS NULL OR (created_at,id)>(%s::timestamptz,%s::uuid)) + ORDER BY created_at,id LIMIT %s + """, (ident, mark[0] if mark else None, mark[0] if mark else None, mark[1] if mark else None, n+1)).fetchall() + with db() as conn: + items = [message_detail(conn, row) for row in rows[:n]] + last = rows[n-1] if len(rows)>n else None + return {"items": items, "next_cursor": make_cursor("messages", ident, last["created_at"], str(last["id"])) if last else None} diff --git a/app/attachments.py b/app/attachments.py new file mode 100644 index 00000000..612da66f --- /dev/null +++ b/app/attachments.py @@ -0,0 +1,241 @@ +"""Lab4 synchronous attachment API: streamed ingress, S3 storage and per-chat ACL. + +The spool is temporary request workspace, not an authoritative file store. No +original survives a completed request on either API replica's local disk. +""" +import hashlib +import io +import os +import tempfile +import threading +import uuid +from contextlib import closing + +import boto3 +from botocore.config import Config +from botocore.exceptions import BotoCoreError, ClientError, EndpointConnectionError +from fastapi import APIRouter, Query, Request +from fastapi.responses import StreamingResponse +from PIL import Image, ImageFile, UnidentifiedImageError +from starlette.concurrency import run_in_threadpool + +from .auth import current_user +from .core import APIError, invalid, iso, parse_uuid +from .storage import db + +router = APIRouter() +BUCKET = os.getenv("S3_BUCKET", "messenger-attachments") +MAX_BYTES = 10 * 1024 * 1024 +MAX_PIXELS = 40_000_000 +SPOOL_MEMORY_BYTES = 1024 * 1024 +S3_BUFFER_BYTES = 256 * 1024 +DECODE_LIMIT = threading.BoundedSemaphore(1) # bound expensive Pillow decoding per replica +Image.MAX_IMAGE_PIXELS = MAX_PIXELS +ImageFile.LOAD_TRUNCATED_IMAGES = False + + +def s3_client(): + return boto3.client( + "s3", endpoint_url=os.environ["S3_ENDPOINT"], + aws_access_key_id=os.environ["S3_ACCESS_KEY"], + aws_secret_access_key=os.environ["S3_SECRET_KEY"], + region_name="us-east-1", use_ssl=False, + config=Config(s3={"addressing_style": "path"}, + connect_timeout=3, read_timeout=10, retries={"max_attempts": 1}), + ) + + +def s3_error(exc): + return APIError(503, "unavailable", "Object storage unavailable") + + +def format_attachment(row): + return { + "id": str(row["id"]), "chat_id": str(row["chat_id"]), + "owner_id": str(row["owner_id"]), "filename": row["filename"], + "content_type": row["content_type"], "size_bytes": row["size_bytes"], + "sha256": row["sha256"], "status": "ready", "variants": [], + "error_code": None, "created_at": iso(row["created_at"]), + "updated_at": iso(row["updated_at"]), + } + + +def require_member(conn, chat_id, user_id): + row = conn.execute( + "SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s", (chat_id, user_id) + ).fetchone() + if not row: + raise APIError(404, "not_found", "Object not found") + + +def attachment_row(conn, attachment_id, user_id): + row = conn.execute(""" + SELECT a.* FROM attachments a + JOIN chat_members cm ON cm.chat_id=a.chat_id + WHERE a.id=%s AND cm.user_id=%s + """, (attachment_id, user_id)).fetchone() + if not row: + raise APIError(404, "not_found", "Object not found") + return row + + +def validate_filename(filename: str): + if not (1 <= len(filename) <= 255) or any( + c in "/\\" or ord(c) < 32 or ord(c) == 127 for c in filename + ): + raise invalid("Invalid filename") + + +def validate_image(fileobj, mime: str): + """Check full decode, dimensions, magic and MIME before writing to S3.""" + try: + fileobj.seek(0) + with Image.open(fileobj) as im: + fmt = im.format + if fmt not in ("PNG", "JPEG"): + raise APIError(415, "unsupported_media_type", "Unsupported image encoding") + actual_mime = "image/png" if fmt == "PNG" else "image/jpeg" + if actual_mime != mime: + raise APIError(415, "unsupported_media_type", "Content-Type does not match image") + if im.width * im.height > MAX_PIXELS: + raise APIError(413, "payload_too_large", "Image dimensions too large") + im.verify() + fileobj.seek(0) + with DECODE_LIMIT: + with Image.open(fileobj) as im: + im.load() # reject corrupt/truncated pixel data, not just headers + except APIError: + raise + except Image.DecompressionBombError: + raise APIError(413, "payload_too_large", "Image dimensions too large") from None + except (UnidentifiedImageError, OSError, ValueError, SyntaxError): + raise APIError(415, "unsupported_media_type", "Invalid image") from None + except Image.DecompressionBombWarning: + raise APIError(413, "payload_too_large", "Image dimensions too large") from None + finally: + fileobj.seek(0) + + +def _upload_checked(spool, *, attachment_id, chat_id, user_id, filename, mime, size, digest): + """Blocking S3 and DB steps run outside the event loop.""" + key = f"attachments/{attachment_id}/original" + backup = f"recovery/{attachment_id}/original" + client = s3_client() + wrote_original = False + wrote_backup = False + committed = False + try: + # A recovery copy enables non-destructive repair if the primary key is lost. + spool.seek(0) + client.upload_fileobj(spool, BUCKET, key, ExtraArgs={"ContentType": mime}, + Config=__import__('boto3.s3.transfer', fromlist=['TransferConfig']).TransferConfig( + use_threads=False, multipart_threshold=16*1024*1024, + io_chunksize=S3_BUFFER_BYTES)) + wrote_original = True + client.copy_object(Bucket=BUCKET, Key=backup, + CopySource={"Bucket": BUCKET, "Key": key}, ContentType=mime, + MetadataDirective="REPLACE") + wrote_backup = True + with db() as conn: + with conn.transaction(): + require_member(conn, chat_id, user_id) + row = conn.execute(""" + INSERT INTO attachments(id,chat_id,owner_id,object_key,backup_key,filename, + content_type,size_bytes,sha256) + VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s) RETURNING * + """, (attachment_id, chat_id, user_id, key, backup, filename, mime, size, digest)).fetchone() + committed = True + return format_attachment(row) + except (BotoCoreError, ClientError, EndpointConnectionError) as exc: + raise s3_error(exc) from exc + finally: + # Never delete after an ambiguous COMMIT unless a fresh read proves + # metadata is absent. A lost COMMIT acknowledgement can still mean + # PostgreSQL committed successfully. Reconciler handles uncertainty. + if not committed: + confirmed_absent = False + try: + with db() as conn: + confirmed_absent = conn.execute( + "SELECT 1 FROM attachments WHERE id=%s", (attachment_id,) + ).fetchone() is None + except Exception: + pass + if confirmed_absent: + for written, object_key in ((wrote_backup, backup), (wrote_original, key)): + if written: + try: + client.delete_object(Bucket=BUCKET, Key=object_key) + except (BotoCoreError, ClientError, EndpointConnectionError): + pass + + +@router.post("/api/v1/chats/{chat_id}/attachments", status_code=201) +async def upload_attachment(req: Request, chat_id: str, filename: str = Query(...)): + from .api import actor, require_chat + who = actor(req)["id"] + chat_id = parse_uuid(chat_id) + validate_filename(filename) + mime = req.headers.get("content-type", "").split(";", 1)[0].strip().lower() + if mime not in ("image/png", "image/jpeg"): + raise APIError(415, "unsupported_media_type", "Only PNG and JPEG are supported") + with db() as conn: + require_chat(conn, chat_id, who) + announced_size = req.headers.get("content-length") + if announced_size: + try: + if int(announced_size) > MAX_BYTES: + raise APIError(413, "payload_too_large", "Image too large") + except ValueError: + raise invalid("Invalid Content-Length") from None + size = 0 + digest = hashlib.sha256() + with tempfile.SpooledTemporaryFile(max_size=SPOOL_MEMORY_BYTES, mode="w+b") as spool: + async for chunk in req.stream(): + size += len(chunk) + if size > MAX_BYTES: + raise APIError(413, "payload_too_large", "Image too large") + digest.update(chunk) + spool.write(chunk) + if size == 0: + raise APIError(415, "unsupported_media_type", "Empty image") + await run_in_threadpool(validate_image, spool, mime) + return await run_in_threadpool(_upload_checked, spool, + attachment_id=str(uuid.uuid4()), chat_id=chat_id, user_id=who, + filename=filename, mime=mime, size=size, digest=digest.hexdigest()) + + +@router.get("/api/v1/attachments/{attachment_id}") +def get_attachment(req: Request, attachment_id: str): + who = getattr(req.state, "actor", None) or current_user(req) + with db() as conn: + return format_attachment(attachment_row(conn, parse_uuid(attachment_id), who["id"])) + + +@router.get("/api/v1/attachments/{attachment_id}/content") +def download_attachment(req: Request, attachment_id: str, variant: str = "original"): + who = getattr(req.state, "actor", None) or current_user(req) + with db() as conn: + row = attachment_row(conn, parse_uuid(attachment_id), who["id"]) + if variant != "original": + raise APIError(404, "not_found", "Object not found") + client = s3_client() + try: + response = client.get_object(Bucket=BUCKET, Key=row["object_key"]) + except ClientError as exc: + if exc.response.get("Error", {}).get("Code") in ("NoSuchKey", "404", "NotFound"): + raise APIError(503, "unavailable", "Stored object missing") from exc + raise s3_error(exc) from exc + except BotoCoreError as exc: + raise s3_error(exc) from exc + + def iterator(): + with closing(response["Body"]) as body: + while True: + chunk = body.read(S3_BUFFER_BYTES) + if not chunk: + break + yield chunk + + return StreamingResponse(iterator(), media_type=row["content_type"], + headers={"Content-Length": str(row["size_bytes"])}) diff --git a/app/auth.py b/app/auth.py new file mode 100644 index 00000000..8286fb31 --- /dev/null +++ b/app/auth.py @@ -0,0 +1,104 @@ +"""HTTP Basic only on login; bearer sessions shared by all API replicas.""" +import base64 +import binascii +import hashlib +import re +import secrets +import uuid +from datetime import datetime, timedelta, timezone + +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError, VerificationError +from fastapi import Request +from redis.exceptions import RedisError + +from .core import APIError, SESSION_TTL, iso +from .storage import cache, db + +hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1) +PASSWORD_RE = re.compile(r"^[a-z0-9_]{3,32}$") + + +def public_user(row: dict): + return {"id": str(row["id"]), "username": row["username"], "display_name": bytes(row["display_name"]).decode("utf-8"), "created_at": iso(row["created_at"])} + + +def unauthorized() -> APIError: + return APIError(401, "unauthorized", "Unauthorized") + + +def challenge(req: Request) -> str: + return 'Basic realm="messenger", charset="UTF-8"' if req.url.path == "/api/v1/auth/sessions" else 'Bearer realm="messenger"' + + +def bearer_token(req: Request) -> str: + value = req.headers.get("Authorization", "") + if not value.startswith("Bearer ") or len(value) <= 7 or " " in value[7:] or len(value) > 512: + raise unauthorized() + try: + value[7:].encode("ascii") + except UnicodeEncodeError: + raise unauthorized() from None + return value[7:] + + +def session_key(token: str) -> str: + return "session:" + hashlib.sha256(token.encode("ascii")).hexdigest() + + +def current_user(req: Request) -> dict: + token = bearer_token(req) + try: + raw = cache().get(session_key(token)) + except (RedisError, UnicodeError) as exc: + raise APIError(503, "unavailable", "Session store unavailable") from exc + if not raw: + raise unauthorized() + try: + ident = str(uuid.UUID(raw)) + except (ValueError, TypeError): + try: + cache().delete(session_key(token)) + except RedisError as exc: + raise APIError(503, "unavailable", "Session store unavailable") from exc + raise unauthorized() from None + with db() as conn: + row = conn.execute("SELECT * FROM users WHERE id = %s", (ident,)).fetchone() + if row is None: + raise unauthorized() + return public_user(row) + + +def login(req: Request): + auth = req.headers.get("Authorization", "") + if not auth.startswith("Basic "): + raise unauthorized() + try: + decoded = base64.b64decode(auth[6:].encode("ascii"), validate=True).decode("utf-8") + username, password = decoded.split(":", 1) + if not PASSWORD_RE.fullmatch(username): + raise ValueError() + except (ValueError, UnicodeError, binascii.Error): + raise unauthorized() from None + with db() as conn: + row = conn.execute("SELECT * FROM users WHERE username=%s", (username,)).fetchone() + if not row: + raise unauthorized() + try: + hasher.verify(row["password_hash"], password) + except (VerifyMismatchError, VerificationError): + raise unauthorized() from None + token = secrets.token_urlsafe(32) + try: + cache().set(session_key(token), str(row["id"]), ex=SESSION_TTL) + except RedisError as exc: + raise APIError(503, "unavailable", "Session store unavailable") from exc + return {"token": token, "token_type": "Bearer", "expires_at": iso(datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL)), "user": public_user(row)} + + +def logout(req: Request): + current_user(req) + try: + cache().delete(session_key(bearer_token(req))) + except RedisError as exc: + raise APIError(503, "unavailable", "Session store unavailable") from exc diff --git a/app/core.py b/app/core.py new file mode 100644 index 00000000..7a85e52a --- /dev/null +++ b/app/core.py @@ -0,0 +1,79 @@ +"""Configuration, HTTP errors and shared representation helpers.""" +import base64 +import json +import os +import uuid +from datetime import datetime, timezone + +from fastapi import Request + +INSTANCE_ID = os.getenv("API_INSTANCE_ID", uuid.uuid4().hex[:12]) +SESSION_TTL = int(os.getenv("SESSION_TTL_SECONDS", "3600")) +IDEMPOTENCY_TTL = max(86400, int(os.getenv("IDEMPOTENCY_TTL_SECONDS", "86400"))) + +class APIError(Exception): + def __init__(self, status: int, code: str, message: str): + super().__init__(message) + self.status = status + self.code = code + self.message = message + + +def iso(value: datetime) -> str: + return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z") + + +def invalid(message: str = "Invalid request") -> APIError: + return APIError(400, "invalid_request", message) + + +def parse_uuid(value: str) -> str: + try: + return str(uuid.UUID(value)) + except (ValueError, TypeError, AttributeError): + raise invalid("Invalid UUID") from None + + +def parse_limit(raw: str | None) -> int: + if raw is None: + return 50 + try: + if not raw.isascii() or not raw.isdecimal(): + raise ValueError() + value = int(raw) + except (ValueError, AttributeError): + raise invalid("Invalid limit") from None + if not 1 <= value <= 100: + raise invalid("Invalid limit") + return value + + +def make_cursor(kind: str, scope: str, created: datetime, ident: str) -> str: + b = json.dumps({"kind": kind, "scope": scope, "created_at": iso(created), "id": ident}, separators=(",", ":")).encode() + return base64.urlsafe_b64encode(b).decode().rstrip("=") + + +def read_cursor(raw: str | None, kind: str, scope: str): + if raw is None: + return None + try: + if not raw or len(raw) > 2048 or any(ch not in "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" for ch in raw): + raise ValueError() + data = json.loads(base64.b64decode(raw + "=" * (-len(raw) % 4), altchars=b"-_", validate=True)) + if not isinstance(data, dict) or data.get("kind") != kind or data.get("scope") != scope: + raise ValueError() + created = datetime.fromisoformat(data["created_at"].replace("Z", "+00:00")) + if created.tzinfo is None: + raise ValueError() + ident = str(uuid.UUID(data["id"])) + return created, ident + except (ValueError, TypeError, KeyError, UnicodeError, json.JSONDecodeError): + raise invalid("Invalid cursor") from None + + +def request_id(req: Request) -> str: + return getattr(req.state, "request_id", uuid.uuid4().hex) + + +def error_body(req: Request, code: str, message: str): + return {"error": {"code": code, "message": message, "request_id": request_id(req)}} diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..c16ce18e --- /dev/null +++ b/app/main.py @@ -0,0 +1,84 @@ +"""FastAPI process: one stateless replica. No auto-migration on startup.""" +import logging +import uuid +from contextlib import asynccontextmanager + +import psycopg +from fastapi import FastAPI, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from starlette.concurrency import run_in_threadpool +from redis.exceptions import RedisError + +from .api import router +from .attachments import router as attachment_router +from .auth import challenge, current_user +from .core import APIError, INSTANCE_ID, error_body, invalid, request_id +from .storage import start, stop + +logging.basicConfig(level="INFO") +logger = logging.getLogger("lab3") + +@asynccontextmanager +async def lifespan(app: FastAPI): + start() + try: + yield + finally: + stop() + +app = FastAPI(title="MTUCI Messenger Lab 4", docs_url=None, redoc_url=None, openapi_url=None, lifespan=lifespan) +app.include_router(router) +app.include_router(attachment_router) + +PROTECTED = ("/api/v1/chats", "/api/v1/attachments", "/api/v1/users/me", "/api/v1/auth/sessions/current") +JSON_POST = ("/api/v1/users", "/api/v1/chats") + + +@app.middleware("http") +async def request_context(req: Request, call_next): + req.state.request_id = uuid.uuid4().hex + try: + path = req.url.path + # Authenticate before parsing the request body or resource-specific fields. + if any(path == p or path.startswith(p + "/") for p in PROTECTED): + req.state.actor = await run_in_threadpool(current_user, req) + if req.method == "POST" and (path in JSON_POST or (path.startswith("/api/v1/chats/") and path.endswith("/messages"))): + if req.headers.get("content-type", "").split(";", 1)[0].strip().lower() != "application/json": + raise APIError(415, "unsupported_media_type", "Content-Type must be application/json") + if req.method == "POST" and path == "/api/v1/auth/sessions" and await req.body(): + raise invalid("Login body is not allowed") + response = await call_next(req) + except APIError as exc: + response = api_error(req, exc) + except (RedisError, psycopg.OperationalError, psycopg.InterfaceError): + response = api_error(req, APIError(503, "unavailable", "Dependency unavailable")) + except Exception: + logger.exception("unexpected request failure id=%s", request_id(req)) + response = api_error(req, APIError(500, "internal_error", "Internal server error")) + response.headers["X-Request-Id"] = request_id(req) + response.headers["X-Instance-Id"] = INSTANCE_ID + return response + + +def api_error(req: Request, exc: APIError) -> JSONResponse: + headers = {"WWW-Authenticate": challenge(req)} if exc.status == 401 else {} + return JSONResponse(status_code=exc.status, content=error_body(req, exc.code, exc.message), headers=headers) + + +@app.exception_handler(APIError) +async def api_error_handler(req: Request, exc: APIError): + return api_error(req, exc) + + +@app.exception_handler(RequestValidationError) +async def validation_error_handler(req: Request, exc: RequestValidationError): + return api_error(req, invalid()) + + +@app.exception_handler(Exception) +async def unexpected_error_handler(req: Request, exc: Exception): + logger.exception("handler failure id=%s", request_id(req)) + if isinstance(exc, (psycopg.OperationalError, psycopg.InterfaceError, RedisError)): + return api_error(req, APIError(503, "unavailable", "Dependency unavailable")) + return api_error(req, APIError(500, "internal_error", "Internal server error")) diff --git a/app/migrate.py b/app/migrate.py new file mode 100644 index 00000000..5f624e33 --- /dev/null +++ b/app/migrate.py @@ -0,0 +1,23 @@ +"""Run once before API instances; transactional and advisory-lock coordinated migrations.""" +import os +from pathlib import Path +import psycopg + +MIGRATIONS = Path(__file__).resolve().parents[1] / "db" / "migrations" + +def main(): + with psycopg.connect(os.environ["DATABASE_URL"], autocommit=False) as conn: + with conn.transaction(): + conn.execute("SELECT pg_advisory_xact_lock(62132103)") + conn.execute("CREATE TABLE IF NOT EXISTS schema_migrations(version TEXT PRIMARY KEY, applied_at TIMESTAMPTZ NOT NULL DEFAULT now())") + for path in sorted(MIGRATIONS.glob("[0-9]*.sql")): + applied = conn.execute("SELECT 1 FROM schema_migrations WHERE version=%s", (path.name,)).fetchone() + if applied: + continue + conn.execute(path.read_text(encoding="utf-8")) + conn.execute("INSERT INTO schema_migrations(version) VALUES (%s)", (path.name,)) + print("Applied", path.name, flush=True) + print("Migrations up to date", flush=True) + +if __name__ == "__main__": + main() diff --git a/app/models.py b/app/models.py new file mode 100644 index 00000000..d0018c58 --- /dev/null +++ b/app/models.py @@ -0,0 +1,77 @@ +"""HTTP request models; all strings use Unicode code point limits.""" +import re +import uuid +from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") + +class StrictModel(BaseModel): + model_config = ConfigDict(extra="forbid", strict=True) + +class CreateUser(StrictModel): + username: str + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + @field_validator("username") + @classmethod + def username_valid(cls, value: str) -> str: + if not USERNAME_RE.fullmatch(value): + raise ValueError("Invalid username") + return value + + @field_validator("display_name", "password") + @classmethod + def non_blank(cls, value: str) -> str: + if not value.strip(): + raise ValueError("Blank value") + value.encode("utf-8", errors="strict") + return value + +class CreateChat(StrictModel): + title: str = Field(min_length=1, max_length=100) + member_ids: list[str] = Field(min_length=1, max_length=100) + + @field_validator("title") + @classmethod + def non_blank(cls, value: str) -> str: + if not value.strip(): + raise ValueError("Blank title") + value.encode("utf-8", errors="strict") + return value + + @field_validator("member_ids") + @classmethod + def uuid_members(cls, value: list[str]) -> list[str]: + for member in value: + if not isinstance(member, str) or str(uuid.UUID(member)) != member: + raise ValueError("Invalid member UUID") + if len(value) != len(set(value)): + raise ValueError("Duplicate member") + return value + +class CreateMessage(StrictModel): + text: str = Field(min_length=0, max_length=4000) + attachment_ids: list[str] = Field(default_factory=list, max_length=10) + + @field_validator("text") + @classmethod + def non_blank(cls, value: str) -> str: + value.encode("utf-8", errors="strict") + return value + + @field_validator("attachment_ids") + @classmethod + def valid_attachments(cls, value: list[str]) -> list[str]: + if len(value) != len(set(value)): + raise ValueError("Duplicate attachment IDs") + for item in value: + if not isinstance(item, str) or str(uuid.UUID(item)) != item: + raise ValueError("Invalid attachment UUID") + return value + + @model_validator(mode="after") + def nonempty_message(self): + if not self.text.strip() and not self.attachment_ids: + raise ValueError("Empty message") + return self diff --git a/app/reconcile.py b/app/reconcile.py new file mode 100644 index 00000000..4220f375 --- /dev/null +++ b/app/reconcile.py @@ -0,0 +1,130 @@ +"""Lab4 grade-5 track 2: repeatable DB/S3 reconciliation. + +Dry-run is default. Apply never drops metadata when BOTH object copies are gone: +without a trustworthy copy or external backup, deletion would destroy evidence. +""" +import argparse +import json +import sys +import time +from datetime import datetime, timezone + +import psycopg +from psycopg.rows import dict_row +from botocore.exceptions import BotoCoreError, ClientError + +from .attachments import BUCKET, s3_client + + +def inventory(client): + result = {} + for page in client.get_paginator("list_objects_v2").paginate(Bucket=BUCKET): + for obj in page.get("Contents", []): + # Only reconciliation-owned prefixes; never mutate arbitrary S3 keys. + key = obj["Key"] + if key.startswith(("attachments/", "recovery/")): + result[key] = obj["LastModified"] + return result + + +def get_db_rows(conn): + return conn.execute("SELECT id, object_key, backup_key FROM attachments").fetchall() + + +def current_reference(conn, key): + return conn.execute( + "SELECT 1 FROM attachments WHERE object_key=%s OR backup_key=%s", (key, key) + ).fetchone() is not None + + +def reconcile(*, apply=False, grace_seconds=300, now=None, client=None, connect=None): + if grace_seconds < 300 and apply: + raise ValueError("Apply requires >=300 s grace period to protect in-flight uploads") + started = time.monotonic() + now = now or datetime.now(timezone.utc) + client = client or s3_client() + connect = connect or (lambda: psycopg.connect(__import__('os').environ['DATABASE_URL'], row_factory=dict_row)) + objects = inventory(client) + stats = { + "mode": "apply" if apply else "dry-run", "grace_seconds": grace_seconds, + "s3_keys_scanned": len(objects), "db_rows_scanned": 0, + "orphan_keys": [], "orphan_keys_young": [], + "missing_primary_repairable": [], "missing_backup_repairable": [], + "missing_both_unrecoverable": [], "actions": [], "errors": [], + } + with connect() as conn: + rows = get_db_rows(conn) + stats["db_rows_scanned"] = len(rows) + references = {key for row in rows for key in (row["object_key"], row["backup_key"])} + for row in rows: + primary, backup = row["object_key"], row["backup_key"] + have_primary, have_backup = primary in objects, backup in objects + rid = str(row["id"]) + if have_primary and have_backup: + continue + if not have_primary and not have_backup: + stats["missing_both_unrecoverable"].append(rid) + continue + dest, source, typ = (primary, backup, "missing_primary_repairable") if not have_primary else (backup, primary, "missing_backup_repairable") + stats[typ].append(rid) + if apply: + # Defensive recheck. Object may have reappeared after inventory. + try: + client.head_object(Bucket=BUCKET, Key=dest) + stats["actions"].append({"action": "already-restored", "key": dest}) + continue + except ClientError as exc: + code = exc.response.get("Error", {}).get("Code") + if code not in ("404", "NotFound", "NoSuchKey"): + raise + try: + client.copy_object(Bucket=BUCKET, Key=dest, + CopySource={"Bucket": BUCKET, "Key": source}) + stats["actions"].append({"action": "restore", "key": dest, "from": source}) + except (BotoCoreError, ClientError) as exc: + stats["errors"].append({"action": "restore", "key": dest, "error_type": type(exc).__name__}) + for key, modified in objects.items(): + if key in references: + continue + age = (now - modified).total_seconds() + if age < grace_seconds: + stats["orphan_keys_young"].append(key) + continue + stats["orphan_keys"].append(key) + if apply: + # Query again immediately before destructive action; never delete + # an object now referenced by a committed metadata row. + if current_reference(conn, key): + stats["actions"].append({"action": "skip-now-referenced", "key": key}) + continue + try: + client.delete_object(Bucket=BUCKET, Key=key) + stats["actions"].append({"action": "delete-old-orphan", "key": key}) + except (BotoCoreError, ClientError) as exc: + stats["errors"].append({"action": "delete-old-orphan", "key": key, "error_type": type(exc).__name__}) + stats["scan_elapsed_seconds"] = round(time.monotonic() - started, 3) + return stats + + +def main(): + parser = argparse.ArgumentParser(description="Reconcile S3 attachments vs PostgreSQL (dry-run default)") + parser.add_argument("--apply", action="store_true", help="Make safe changes; orphans older than 300 seconds only") + parser.add_argument("--grace-seconds", type=int, default=300) + parser.add_argument("--output", help="Write JSON summary (no credentials)") + args = parser.parse_args() + try: + result = reconcile(apply=args.apply, grace_seconds=args.grace_seconds) + except Exception as exc: + # No exception string: botocore errors may contain signed credentials/URLs. + print(json.dumps({"status":"failed", "error_type":type(exc).__name__}), file=sys.stderr) + raise SystemExit(2) from None + rendered = json.dumps(result, ensure_ascii=False, indent=2) + print(rendered) + if args.output: + with open(args.output, "w", encoding="utf-8") as fh: + fh.write(rendered + "\n") + if result["errors"] or result["missing_both_unrecoverable"]: + raise SystemExit(1) + +if __name__ == "__main__": + main() diff --git a/app/reconcile_fault.py b/app/reconcile_fault.py new file mode 100644 index 00000000..fce1eea4 --- /dev/null +++ b/app/reconcile_fault.py @@ -0,0 +1,36 @@ +"""Operator-only fault injection in a LOCAL TEST stack; never exposed as HTTP.""" +import argparse +import json +import os +import uuid +import psycopg +from psycopg.rows import dict_row +from .attachments import BUCKET, s3_client + + +def main(): + p = argparse.ArgumentParser() + p.add_argument("action", choices=["delete-primary", "delete-backup", "create-orphan"]) + p.add_argument("--id", help="Attachment UUID for the delete actions") + args = p.parse_args() + if os.environ.get("LAB4_ALLOW_FAULT_INJECTION") != "yes": + raise SystemExit("Fault injection disabled; use LAB4_ALLOW_FAULT_INJECTION=yes in isolated test") + client = s3_client() + if args.action == "create-orphan": + key = f"attachments/{uuid.uuid4()}/original" + client.put_object(Bucket=BUCKET, Key=key, Body=b"synthetic orphan") + print(json.dumps({"fault":"orphan-created", "object_key":key})) + return + if not args.id: + raise SystemExit("--id is required") + ident = str(uuid.UUID(args.id)) + with psycopg.connect(os.environ["DATABASE_URL"], row_factory=dict_row) as conn: + row = conn.execute("SELECT object_key,backup_key FROM attachments WHERE id=%s", (ident,)).fetchone() + if not row: + raise SystemExit("Attachment does not exist") + key = row["object_key"] if args.action == "delete-primary" else row["backup_key"] + client.delete_object(Bucket=BUCKET, Key=key) + print(json.dumps({"fault":args.action, "object_key":key})) + +if __name__ == "__main__": + main() diff --git a/app/reconcile_selftest.py b/app/reconcile_selftest.py new file mode 100644 index 00000000..9d4c0442 --- /dev/null +++ b/app/reconcile_selftest.py @@ -0,0 +1,61 @@ +"""Fast isolated tests for reconciliation safety; run in application image.""" +import uuid +from datetime import datetime, timezone, timedelta +from .reconcile import reconcile +from .attachments import BUCKET + +NOW = datetime.now(timezone.utc) + +class FakeConn: + def __init__(self, rows): self.rows=rows + def __enter__(self): return self + def __exit__(self,*a): return False + def execute(self, sql, args=None): + self.sql=sql + self.args=args + return self + def fetchall(self): return self.rows + def fetchone(self): + key=self.args[0] + return {'id': 1} if any(key in (row['object_key'],row['backup_key']) for row in self.rows) else None + +class FakeS3: + def __init__(self,objects): self.objects=objects + def get_paginator(self,op): return self + def paginate(self,**kwargs): + yield {'Contents':[{'Key':k,'LastModified':t} for k,t in self.objects.items()]} + def head_object(self,**kw): + if kw['Key'] not in self.objects: + from botocore.exceptions import ClientError + raise ClientError({'Error':{'Code':'404'}},'HeadObject') + def copy_object(self,**kw): + assert kw['CopySource']['Key'] in self.objects + self.objects[kw['Key']]=NOW + def delete_object(self,**kw): + self.objects.pop(kw['Key'],None) + + +def test(): + i=str(uuid.uuid4()) + primary=f'attachments/{i}/original';backup=f'recovery/{i}/original' + young=f'attachments/{uuid.uuid4()}/original' + old=f'attachments/{uuid.uuid4()}/original' + rows=[{'id':i,'object_key':primary,'backup_key':backup}] + fake=FakeS3({backup: NOW-timedelta(days=1),young:NOW-timedelta(seconds=10),old:NOW-timedelta(days=1)}) + kwargs={'now':NOW,'client':fake,'connect':lambda:FakeConn(rows)} + first=reconcile(apply=False,**kwargs) + assert first['missing_primary_repairable']==[i] + assert old in first['orphan_keys'] and young in first['orphan_keys_young'] + assert primary not in fake.objects and old in fake.objects, 'Dry run mutated objects' + second=reconcile(apply=True,**kwargs) + assert primary in fake.objects and old not in fake.objects and young in fake.objects + assert any(x['action']=='restore' for x in second['actions']) + third=reconcile(apply=True,**kwargs) + assert not third['actions'], 'Re-run unexpectedly mutated objects' + assert rows[0]['object_key']==primary, 'Metadata destroyed' + try: reconcile(apply=True, grace_seconds=0, **kwargs) + except ValueError: pass + else: raise AssertionError('Unsafe zero-grace apply accepted') + print('PASS: dry-run, orphan grace, recover primary from backup, apply idempotence') + +if __name__ == '__main__': test() diff --git a/app/s3_bootstrap.py b/app/s3_bootstrap.py new file mode 100644 index 00000000..da81f64e --- /dev/null +++ b/app/s3_bootstrap.py @@ -0,0 +1,35 @@ +"""Idempotently create the private S3 bucket with bootstrap-only credentials.""" +import os +import time +import boto3 +from botocore.config import Config +from botocore.exceptions import ClientError, BotoCoreError + + +def main(): + bucket = os.environ["S3_BUCKET"] + client = boto3.client("s3", endpoint_url=os.environ["S3_ENDPOINT"], + aws_access_key_id=os.environ["S3_ADMIN_ACCESS_KEY"], + aws_secret_access_key=os.environ["S3_ADMIN_SECRET_KEY"], + region_name="us-east-1", + config=Config(s3={"addressing_style": "path"}, + connect_timeout=2, read_timeout=4, retries={"max_attempts": 1})) + for attempt in range(70): + try: + try: + client.head_bucket(Bucket=bucket) + except ClientError as exc: + code = exc.response.get("Error", {}).get("Code", "") + if code not in ("404", "NoSuchBucket", "NotFound"): + raise + client.create_bucket(Bucket=bucket) + # PRIVATE: no public bucket policy, ACL or anonymous identity. + print(f"Private bucket {bucket} ready", flush=True) + return + except (ClientError, BotoCoreError, OSError) as exc: + if attempt == 69: + raise RuntimeError("S3 bootstrap failed; inspect S3 container") from exc + time.sleep(1) + +if __name__ == "__main__": + main() diff --git a/app/s3_policy.py b/app/s3_policy.py new file mode 100644 index 00000000..b51dead4 --- /dev/null +++ b/app/s3_policy.py @@ -0,0 +1,32 @@ +"""One-off creation of private SeaweedFS S3 identities; secrets stay in Docker volume.""" +import json +import os +from pathlib import Path + + +def main(): + bucket = os.environ["S3_BUCKET"] + identities = [ + {"name": "bucket-bootstrap", "credentials": [{"accessKey": os.environ["S3_ADMIN_ACCESS_KEY"], + "secretKey": os.environ["S3_ADMIN_SECRET_KEY"]}], + "actions": ["Admin", "Read", "Write", "List"]}, + {"name": "messenger-api", "credentials": [{"accessKey": os.environ["S3_ACCESS_KEY"], + "secretKey": os.environ["S3_SECRET_KEY"]}], + "actions": [f"Read:{bucket}", f"Write:{bucket}", f"List:{bucket}"]}, + ] + if len({entry["credentials"][0]["accessKey"] for entry in identities}) != 2: + raise ValueError("Admin and API credentials must differ") + path = Path("/s3-config/config.json") + path.parent.mkdir(parents=True, exist_ok=True) + tmp = path.with_suffix(".tmp") + old_umask = os.umask(0o077) + try: + tmp.write_text(json.dumps({"identities": identities}, separators=(",", ":")), encoding="utf-8") + os.chmod(tmp, 0o644) # readable by the SeaweedFS runtime UID; Docker volume stays private + os.replace(tmp, path) + finally: + os.umask(old_umask) + print("S3 identities configured (no secrets printed)", flush=True) + +if __name__ == "__main__": + main() diff --git a/app/s3_probe.py b/app/s3_probe.py new file mode 100644 index 00000000..ef6d441e --- /dev/null +++ b/app/s3_probe.py @@ -0,0 +1,40 @@ +"""Verify bucket is private at S3 boundary (not merely hidden behind HTTP API).""" +import json +import os +import boto3 +from botocore import UNSIGNED +from botocore.config import Config +from botocore.exceptions import ClientError +from .attachments import BUCKET, s3_client + + +def main(): + client = s3_client() + client.head_bucket(Bucket=BUCKET) # restricted app identity works + unauth = boto3.client("s3", endpoint_url=os.environ["S3_ENDPOINT"], + region_name="us-east-1", config=Config(signature_version=UNSIGNED, + s3={"addressing_style":"path"})) + try: + unauth.list_objects_v2(Bucket=BUCKET, MaxKeys=1) + except ClientError as exc: + status = exc.response.get("ResponseMetadata", {}).get("HTTPStatusCode") + if status not in (401,403): + raise RuntimeError("Unexpected anonymous S3 response") from None + else: + raise RuntimeError("Private bucket leaked object list to anonymous caller") + listing = client.list_objects_v2(Bucket=BUCKET, MaxKeys=1) + keys = [entry["Key"] for entry in listing.get("Contents", [])] + if keys: + try: + unauth.get_object(Bucket=BUCKET, Key=keys[0]) + except ClientError as exc: + status = exc.response.get("ResponseMetadata", {}).get("HTTPStatusCode") + if status not in (401, 403): + raise RuntimeError("Unexpected anonymous object GET response") from None + else: + raise RuntimeError("Private S3 object downloadable anonymously") + print(json.dumps({"private_bucket": True, "anonymous_listing": "denied", + "anonymous_object_get": "denied" if keys else "not_tested_empty_bucket"})) + +if __name__ == "__main__": + main() diff --git a/app/storage.py b/app/storage.py new file mode 100644 index 00000000..2ab0d05a --- /dev/null +++ b/app/storage.py @@ -0,0 +1,64 @@ +"""Shared external state: psycopg connection pool and Redis session store.""" +import os +from contextlib import contextmanager + +import psycopg +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool, PoolTimeout +from redis import Redis +from redis.exceptions import RedisError + +from .core import APIError + +pool: ConnectionPool | None = None +redis_client: Redis | None = None + + +def start() -> None: + global pool, redis_client + url = os.environ["DATABASE_URL"] + size = int(os.getenv("DB_POOL_MAX", "8")) + pool = ConnectionPool(conninfo=url, min_size=1, max_size=size, timeout=3, kwargs={"row_factory": dict_row, "connect_timeout": 5, "options": "-c statement_timeout=5000"}, open=False) + pool.open(wait=True, timeout=30) + redis_client = Redis.from_url(os.environ.get("REDIS_URL", "redis://redis:6379/0"), socket_connect_timeout=2, socket_timeout=2, decode_responses=True) + redis_client.ping() + + +def stop() -> None: + global pool, redis_client + if pool is not None: + pool.close() + pool = None + if redis_client is not None: + redis_client.close() + redis_client = None + + +@contextmanager +def db(): + if pool is None: + raise APIError(503, "unavailable", "Database unavailable") + try: + with pool.connection() as conn: + yield conn + except (psycopg.OperationalError, psycopg.InterfaceError, PoolTimeout) as exc: + raise APIError(503, "unavailable", "Database unavailable") from exc + + +def cache() -> Redis: + if redis_client is None: + raise APIError(503, "unavailable", "Session store unavailable") + return redis_client + + +def ready() -> bool: + try: + with db() as conn: + conn.execute("SELECT 1").fetchone() + cache().ping() + # S3 is needed for the mandatory synchronous upload/download path. + from .attachments import s3_client, BUCKET + s3_client().head_bucket(Bucket=BUCKET) + return True + except Exception: + return False diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..890da7f3 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,185 @@ +services: + postgres: + image: postgres:16.10-bookworm + environment: + POSTGRES_DB: ${POSTGRES_DB:-messenger} + POSTGRES_USER: ${POSTGRES_USER:-lab} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env} + volumes: ["postgres_data:/var/lib/postgresql/data"] + healthcheck: + test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"] + interval: 2s + timeout: 2s + retries: 30 + mem_limit: 512m + cpus: 1.0 + restart: unless-stopped + networks: [storage] + + redis: + image: redis:7.4.5-alpine + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always", "--save", "60", "1"] + volumes: ["redis_data:/data"] + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 2s + timeout: 2s + retries: 30 + mem_limit: 256m + cpus: 0.5 + restart: unless-stopped + networks: [storage] + + s3-policy: + build: . + user: "0:0" + command: ["python", "-m", "app.s3_policy"] + environment: + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ADMIN_ACCESS_KEY: ${S3_ADMIN_ACCESS_KEY:?Set S3_ADMIN_ACCESS_KEY} + S3_ADMIN_SECRET_KEY: ${S3_ADMIN_SECRET_KEY:?Set S3_ADMIN_SECRET_KEY} + S3_ACCESS_KEY: ${S3_ACCESS_KEY:?Set S3_ACCESS_KEY} + S3_SECRET_KEY: ${S3_SECRET_KEY:?Set S3_SECRET_KEY} + volumes: ["s3_config:/s3-config"] + restart: "no" + networks: [storage] + + s3: + image: chrislusf/seaweedfs:4.53 + command: ["server", "-dir=/data", "-ip=s3", "-ip.bind=0.0.0.0", "-s3", "-s3.port=8333", "-s3.iam=false", "-s3.config=/s3-config/config.json"] + volumes: + - s3_data:/data + - s3_config:/s3-config:ro + - ./infra/filer.toml:/etc/seaweedfs/filer.toml:ro + depends_on: + s3-policy: + condition: service_completed_successfully + expose: ["8333"] + mem_limit: 640m + cpus: 1.0 + restart: unless-stopped + networks: [storage] + + s3-bootstrap: + build: . + command: ["python", "-m", "app.s3_bootstrap"] + environment: + S3_ENDPOINT: http://s3:8333 + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ADMIN_ACCESS_KEY: ${S3_ADMIN_ACCESS_KEY:?Set S3_ADMIN_ACCESS_KEY} + S3_ADMIN_SECRET_KEY: ${S3_ADMIN_SECRET_KEY:?Set S3_ADMIN_SECRET_KEY} + depends_on: + s3: + condition: service_started + restart: "no" + networks: [storage] + + migrate: + build: . + command: ["python", "-m", "app.migrate"] + environment: + DATABASE_URL: postgresql://${POSTGRES_USER:-lab}:${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}@postgres:5432/${POSTGRES_DB:-messenger} + depends_on: + postgres: + condition: service_healthy + restart: "no" + networks: [storage] + + reconcile: + profiles: [maintenance] + build: . + command: ["python", "-m", "app.reconcile"] + environment: + DATABASE_URL: postgresql://${POSTGRES_USER:-lab}:${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}@postgres:5432/${POSTGRES_DB:-messenger} + S3_ENDPOINT: http://s3:8333 + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ACCESS_KEY: ${S3_ACCESS_KEY:?Set S3_ACCESS_KEY} + S3_SECRET_KEY: ${S3_SECRET_KEY:?Set S3_SECRET_KEY} + depends_on: + postgres: + condition: service_healthy + s3-bootstrap: + condition: service_completed_successfully + migrate: + condition: service_completed_successfully + restart: "no" + networks: [storage] + + api1: + build: . + environment: &api_env + APP_PORT: "8080" + API_INSTANCE_ID: api1 + DATABASE_URL: postgresql://${POSTGRES_USER:-lab}:${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}@postgres:5432/${POSTGRES_DB:-messenger} + REDIS_URL: redis://redis:6379/0 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + DB_POOL_MAX: ${DB_POOL_MAX:-8} + S3_ENDPOINT: http://s3:8333 + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ACCESS_KEY: ${S3_ACCESS_KEY:?Set S3_ACCESS_KEY} + S3_SECRET_KEY: ${S3_SECRET_KEY:?Set S3_SECRET_KEY} + depends_on: &api_depends + postgres: + condition: service_healthy + redis: + condition: service_healthy + migrate: + condition: service_completed_successfully + s3-bootstrap: + condition: service_completed_successfully + expose: ["8080"] + healthcheck: &api_health + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"] + interval: 2s + timeout: 3s + retries: 15 + start_period: 10s + mem_limit: 384m + cpus: 0.75 + stop_grace_period: 12s + restart: unless-stopped + networks: [frontend, storage] + + api2: + build: . + environment: + <<: *api_env + API_INSTANCE_ID: api2 + depends_on: *api_depends + expose: ["8080"] + healthcheck: *api_health + mem_limit: 384m + cpus: 0.75 + stop_grace_period: 12s + restart: unless-stopped + networks: [frontend, storage] + + lb: + image: haproxy:3.1.7-alpine + volumes: ["./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro"] + ports: ["127.0.0.1:8080:8080"] + depends_on: + api1: + condition: service_healthy + api2: + condition: service_healthy + healthcheck: + test: ["CMD", "haproxy", "-c", "-f", "/usr/local/etc/haproxy/haproxy.cfg"] + interval: 10s + timeout: 3s + retries: 3 + mem_limit: 128m + cpus: 0.5 + restart: unless-stopped + networks: [frontend] + +networks: + frontend: + storage: + internal: true +volumes: + postgres_data: + redis_data: + s3_data: + s3_config: diff --git a/db/migrations/001_initial.sql b/db/migrations/001_initial.sql new file mode 100644 index 00000000..203b012f --- /dev/null +++ b/db/migrations/001_initial.sql @@ -0,0 +1,33 @@ +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY, + username VARCHAR(32) NOT NULL UNIQUE, + display_name BYTEA NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT users_display_bytes CHECK (octet_length(display_name) BETWEEN 1 AND 400) +); +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY, + title BYTEA NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT chats_title_bytes CHECK (octet_length(title) BETWEEN 1 AND 400) +); +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id), + user_id UUID NOT NULL REFERENCES users(id), + position INTEGER NOT NULL, + PRIMARY KEY (chat_id, user_id), + UNIQUE (chat_id, position) +); +CREATE INDEX IF NOT EXISTS idx_members_user ON chat_members (user_id, chat_id); +CREATE TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id), + sender_id UUID NOT NULL, + text BYTEA NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members(chat_id, user_id), + CONSTRAINT messages_text_bytes CHECK (octet_length(text) BETWEEN 1 AND 16000) +); +CREATE INDEX IF NOT EXISTS idx_messages_chat_history ON messages (chat_id, created_at, id); +CREATE INDEX IF NOT EXISTS idx_chats_history ON chats (created_at, id); diff --git a/db/migrations/002_idempotency.sql b/db/migrations/002_idempotency.sql new file mode 100644 index 00000000..04a000ad --- /dev/null +++ b/db/migrations/002_idempotency.sql @@ -0,0 +1,12 @@ +-- Same transaction creates message and idempotency receipt. Unique key arbitrates concurrent replicas. +CREATE TABLE IF NOT EXISTS message_idempotency ( + actor_id UUID NOT NULL REFERENCES users(id), + chat_id UUID NOT NULL REFERENCES chats(id), + method VARCHAR(8) NOT NULL DEFAULT 'POST', + idem_key VARCHAR(128) NOT NULL, + body_sha256 CHAR(64) NOT NULL, + message_id UUID NOT NULL REFERENCES messages(id), + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + PRIMARY KEY (actor_id, chat_id, method, idem_key) +); +CREATE INDEX IF NOT EXISTS idx_idempotency_age ON message_idempotency (created_at); diff --git a/db/migrations/003_attachments.sql b/db/migrations/003_attachments.sql new file mode 100644 index 00000000..ed8e0ea9 --- /dev/null +++ b/db/migrations/003_attachments.sql @@ -0,0 +1,25 @@ +ALTER TABLE messages DROP CONSTRAINT IF EXISTS messages_text_bytes; +ALTER TABLE messages ADD CONSTRAINT messages_text_bytes CHECK (octet_length(text) BETWEEN 0 AND 16000); +CREATE TABLE IF NOT EXISTS attachments ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id), + owner_id UUID NOT NULL REFERENCES users(id), + object_key TEXT NOT NULL UNIQUE, + backup_key TEXT NOT NULL UNIQUE, + filename TEXT NOT NULL, + content_type VARCHAR(32) NOT NULL CHECK(content_type IN ('image/png','image/jpeg')), + size_bytes BIGINT NOT NULL CHECK(size_bytes BETWEEN 1 AND 10485760), + sha256 CHAR(64) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + FOREIGN KEY (chat_id,owner_id) REFERENCES chat_members(chat_id,user_id) +); +CREATE INDEX IF NOT EXISTS idx_attachments_chat ON attachments(chat_id); +CREATE TABLE IF NOT EXISTS message_attachments ( + message_id UUID NOT NULL REFERENCES messages(id), + attachment_id UUID NOT NULL REFERENCES attachments(id), + position INTEGER NOT NULL CHECK(position BETWEEN 0 AND 9), + PRIMARY KEY (message_id, attachment_id), + UNIQUE (message_id,position) +); +CREATE INDEX IF NOT EXISTS idx_message_attachments_attachment ON message_attachments(attachment_id); diff --git a/evidence/attachments-concurrent.json b/evidence/attachments-concurrent.json new file mode 100644 index 00000000..554b4e5e --- /dev/null +++ b/evidence/attachments-concurrent.json @@ -0,0 +1,11 @@ +{ + "concurrency": 10, + "uploads": 10, + "failed_requests": 0, + "elapsed_seconds": 2.796, + "upload_rps": 3.577, + "latency_p50_ms": 2164.0, + "latency_max_ms": 2344.0, + "bytes_per_file": 111817, + "note": "Capture peak API RSS with docker stats; this script is client-side only." +} \ No newline at end of file diff --git a/evidence/measure-upload-20261112-180238-stage0-batch1.json b/evidence/measure-upload-20261112-180238-stage0-batch1.json new file mode 100644 index 00000000..b3b34d62 --- /dev/null +++ b/evidence/measure-upload-20261112-180238-stage0-batch1.json @@ -0,0 +1,11 @@ +{ + "concurrency": 10, + "uploads": 10, + "failed_requests": 0, + "elapsed_seconds": 2.985, + "upload_rps": 3.35, + "latency_p50_ms": 2312.5, + "latency_max_ms": 2453.0, + "bytes_per_file": 111817, + "note": "Capture peak API RSS with docker stats; this script is client-side only." +} \ No newline at end of file diff --git a/evidence/measure-upload-20261112-180238-stage0-batch2.json b/evidence/measure-upload-20261112-180238-stage0-batch2.json new file mode 100644 index 00000000..a34b1f94 --- /dev/null +++ b/evidence/measure-upload-20261112-180238-stage0-batch2.json @@ -0,0 +1,11 @@ +{ + "concurrency": 10, + "uploads": 10, + "failed_requests": 0, + "elapsed_seconds": 3.031, + "upload_rps": 3.299, + "latency_p50_ms": 2296.0, + "latency_max_ms": 2546.0, + "bytes_per_file": 111817, + "note": "Capture peak API RSS with docker stats; this script is client-side only." +} \ No newline at end of file diff --git a/evidence/measure-upload-20261112-180238-stage0-batch3.json b/evidence/measure-upload-20261112-180238-stage0-batch3.json new file mode 100644 index 00000000..236751b8 --- /dev/null +++ b/evidence/measure-upload-20261112-180238-stage0-batch3.json @@ -0,0 +1,11 @@ +{ + "concurrency": 10, + "uploads": 10, + "failed_requests": 0, + "elapsed_seconds": 3.203, + "upload_rps": 3.122, + "latency_p50_ms": 2461.0, + "latency_max_ms": 2750.0, + "bytes_per_file": 111817, + "note": "Capture peak API RSS with docker stats; this script is client-side only." +} \ No newline at end of file diff --git a/evidence/measure-upload-20261112-180238-stage0-batch4.json b/evidence/measure-upload-20261112-180238-stage0-batch4.json new file mode 100644 index 00000000..dd8ced24 --- /dev/null +++ b/evidence/measure-upload-20261112-180238-stage0-batch4.json @@ -0,0 +1,11 @@ +{ + "concurrency": 10, + "uploads": 10, + "failed_requests": 0, + "elapsed_seconds": 3.5, + "upload_rps": 2.857, + "latency_p50_ms": 2523.5, + "latency_max_ms": 2907.0, + "bytes_per_file": 111817, + "note": "Capture peak API RSS with docker stats; this script is client-side only." +} \ No newline at end of file diff --git a/evidence/measure-upload-20261112-180238-stage0-batch5.json b/evidence/measure-upload-20261112-180238-stage0-batch5.json new file mode 100644 index 00000000..6e233fa2 --- /dev/null +++ b/evidence/measure-upload-20261112-180238-stage0-batch5.json @@ -0,0 +1,11 @@ +{ + "concurrency": 10, + "uploads": 10, + "failed_requests": 0, + "elapsed_seconds": 2.64, + "upload_rps": 3.788, + "latency_p50_ms": 2242.0, + "latency_max_ms": 2297.0, + "bytes_per_file": 111817, + "note": "Capture peak API RSS with docker stats; this script is client-side only." +} \ No newline at end of file diff --git a/evidence/measure-upload-20261112-180238-stage1-batch1.json b/evidence/measure-upload-20261112-180238-stage1-batch1.json new file mode 100644 index 00000000..24d7c2a1 --- /dev/null +++ b/evidence/measure-upload-20261112-180238-stage1-batch1.json @@ -0,0 +1,11 @@ +{ + "concurrency": 10, + "uploads": 10, + "failed_requests": 0, + "elapsed_seconds": 2.969, + "upload_rps": 3.368, + "latency_p50_ms": 2281.0, + "latency_max_ms": 2453.0, + "bytes_per_file": 111817, + "note": "Capture peak API RSS with docker stats; this script is client-side only." +} \ No newline at end of file diff --git a/evidence/measure-upload-20261112-180238-stage1-batch2.json b/evidence/measure-upload-20261112-180238-stage1-batch2.json new file mode 100644 index 00000000..d0a46547 --- /dev/null +++ b/evidence/measure-upload-20261112-180238-stage1-batch2.json @@ -0,0 +1,11 @@ +{ + "concurrency": 10, + "uploads": 10, + "failed_requests": 0, + "elapsed_seconds": 2.64, + "upload_rps": 3.788, + "latency_p50_ms": 2187.5, + "latency_max_ms": 2281.0, + "bytes_per_file": 111817, + "note": "Capture peak API RSS with docker stats; this script is client-side only." +} \ No newline at end of file diff --git a/evidence/measure-upload-20261112-180238-stage1-batch3.json b/evidence/measure-upload-20261112-180238-stage1-batch3.json new file mode 100644 index 00000000..1c885aaa --- /dev/null +++ b/evidence/measure-upload-20261112-180238-stage1-batch3.json @@ -0,0 +1,11 @@ +{ + "concurrency": 10, + "uploads": 10, + "failed_requests": 0, + "elapsed_seconds": 2.843, + "upload_rps": 3.517, + "latency_p50_ms": 2336.0, + "latency_max_ms": 2406.0, + "bytes_per_file": 111817, + "note": "Capture peak API RSS with docker stats; this script is client-side only." +} \ No newline at end of file diff --git a/evidence/measure-upload-20261112-180238-stage1-batch4.json b/evidence/measure-upload-20261112-180238-stage1-batch4.json new file mode 100644 index 00000000..12f505dc --- /dev/null +++ b/evidence/measure-upload-20261112-180238-stage1-batch4.json @@ -0,0 +1,11 @@ +{ + "concurrency": 10, + "uploads": 10, + "failed_requests": 0, + "elapsed_seconds": 3.031, + "upload_rps": 3.299, + "latency_p50_ms": 2398.5, + "latency_max_ms": 2578.0, + "bytes_per_file": 111817, + "note": "Capture peak API RSS with docker stats; this script is client-side only." +} \ No newline at end of file diff --git a/evidence/measure-upload-20261112-180238-stage1-batch5.json b/evidence/measure-upload-20261112-180238-stage1-batch5.json new file mode 100644 index 00000000..1e62d418 --- /dev/null +++ b/evidence/measure-upload-20261112-180238-stage1-batch5.json @@ -0,0 +1,11 @@ +{ + "concurrency": 10, + "uploads": 10, + "failed_requests": 0, + "elapsed_seconds": 3.281, + "upload_rps": 3.048, + "latency_p50_ms": 2390.5, + "latency_max_ms": 2735.0, + "bytes_per_file": 111817, + "note": "Capture peak API RSS with docker stats; this script is client-side only." +} \ No newline at end of file diff --git a/evidence/reconcile-cost-20261112-180238.csv b/evidence/reconcile-cost-20261112-180238.csv new file mode 100644 index 00000000..8e52fdd7 --- /dev/null +++ b/evidence/reconcile-cost-20261112-180238.csv @@ -0,0 +1,16 @@ +"stage";"repeat";"s3_keys_scanned";"db_rows_scanned";"scan_elapsed_seconds" +"0";"1";"36";"18";"0,624" +"0";"2";"36";"18";"0,294" +"0";"3";"36";"18";"0,207" +"0";"4";"36";"18";"0,234" +"0";"5";"36";"18";"0,245" +"1";"1";"136";"68";"0,27" +"1";"2";"136";"68";"0,284" +"1";"3";"136";"68";"0,285" +"1";"4";"136";"68";"0,294" +"1";"5";"136";"68";"0,401" +"2";"1";"236";"118";"0,568" +"2";"2";"236";"118";"0,341" +"2";"3";"236";"118";"0,289" +"2";"4";"236";"118";"0,409" +"2";"5";"236";"118";"0,3" diff --git a/evidence/reconcile-cost-console-summary-2026-11-12.md b/evidence/reconcile-cost-console-summary-2026-11-12.md new file mode 100644 index 00000000..fbcef550 --- /dev/null +++ b/evidence/reconcile-cost-console-summary-2026-11-12.md @@ -0,0 +1,11 @@ +# Reconcile cost — verified series, 12.11.2026 + +The 15 values below were transcribed from the pasted PowerShell stdout. The original CSV was saved on the user's Windows computer at `evidence/reconcile-cost-20261112-180238.csv` and is **not contained in this package**. + +| Stage | S3 keys | DB rows | Runs | Mean (s) | Median (s) | +|---:|---:|---:|---:|---:|---:| +| 0 | 36 | 18 | 5 | 0.3208 | 0.245 | +| 1 | 136 | 68 | 5 | 0.3068 | 0.285 | +| 2 | 236 | 118 | 5 | 0.3814 | 0.341 | + +No `--apply` or DELETE was executed during the cost sweep. Each measured value is internal `scan_elapsed_seconds`. diff --git a/evidence/verified_results_2026-11-12.md b/evidence/verified_results_2026-11-12.md new file mode 100644 index 00000000..9c5a897a --- /dev/null +++ b/evidence/verified_results_2026-11-12.md @@ -0,0 +1,110 @@ +# Lab4 — фактические свидетельства локального запуска + +**Источник:** обезличенные выдержки из переданных stdout PowerShell/Docker, 12 ноября 2026. +**Статус:** результаты переписаны вручную из консольных логов, не являются сырым автоматическим CI-протоколом. Не содержат токенов и паролей. + +## Функциональность и инфраструктура + +```text +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. +PASS: lab4 public API scenario; infrastructure and grading evidence remain separate. +PASS: lab4 negative image, MIME, size, filename, ACL and cross-chat checks +PASS: parallel idempotency across 2 replicas; one message, replay 201, conflicting body 409 +{"private_bucket": true, "anonymous_listing": "denied", "anonymous_object_get": "denied"} +PASS: dry-run, orphan grace, recover primary from backup, apply idempotence +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +{"observed_instances_before": 2, "successful_writes": 6, "failed_attempts": 1, "first_recovery_seconds": 6.156} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +``` + +## 10 конкурентных загрузок + +```json +{ + "concurrency": 10, + "uploads": 10, + "failed_requests": 0, + "elapsed_seconds": 2.796, + "upload_rps": 3.577, + "latency_p50_ms": 2164.0, + "latency_max_ms": 2344.0, + "bytes_per_file": 111817 +} +``` + +Наблюдения Docker stats (выборочно, не непрерывный max): +- `api1`: максимум **109.1 MiB / 384 MiB** +- `api2`: максимум **96.21 MiB / 384 MiB** + +## Удаление оригинала и восстановление + +```text +fault: delete-primary +object_key: attachments/045ee0a6-be0d-4712-884f-b82145888ad6/original + +dry-run: s3_keys_scanned=31, db_rows_scanned=16, + missing_primary_repairable=[045ee0a6-be0d-4712-884f-b82145888ad6], + actions=[], errors=[], scan_elapsed_seconds=0.162 + +apply: action=restore, + key=attachments/045ee0a6-be0d-4712-884f-b82145888ad6/original, + from=recovery/045ee0a6-be0d-4712-884f-b82145888ad6/original, + errors=[], scan_elapsed_seconds=0.216 + +verify dry-run: s3_keys_scanned=32, db_rows_scanned=16, + missing_primary_repairable=[], actions=[], errors=[], scan_elapsed_seconds=0.159 + +repeat apply (following extra uploads): s3_keys_scanned=34, db_rows_scanned=17, + actions=[], errors=[], scan_elapsed_seconds=0.179 +``` + +## Создание и зачистка orphan + +```text +fault: orphan-created +key: attachments/db466391-0d91-4757-990f-f2bb93872f5d/original + +dry-run: s3_keys_scanned=35, db_rows_scanned=17, + orphan_keys_young=[attachments/db466391-0d91-4757-990f-f2bb93872f5d/original], + orphan_keys=[], actions=[], errors=[], scan_elapsed_seconds=0.190 + +apply before grace: orphan_keys_young=[...], actions=[], errors=[], scan_elapsed_seconds=0.225 + +Start-Sleep -Seconds 310 + +apply after grace: orphan_keys=[attachments/db466391-0d91-4757-990f-f2bb93872f5d/original], + actions=[{"action":"delete-old-orphan","key":"attachments/db466391-0d91-4757-990f-f2bb93872f5d/original"}], + errors=[], scan_elapsed_seconds=0.228 + +final dry-run: s3_keys_scanned=34, db_rows_scanned=17, + orphan_keys=[], orphan_keys_young=[], + missing_primary_repairable=[], missing_backup_repairable=[], + missing_both_unrecoverable=[], actions=[], errors=[], + scan_elapsed_seconds=0.213 +``` + +## S3 downtime + +```text +docker compose --env-file .env stop s3 +# HTTP/1.1 503 Service Unavailable via localhost:8080/health/ready + +docker compose --env-file .env up -d s3 +docker compose --env-file .env up -d --wait api1 api2 lb +python tests/smoke.py +PASS: lab4 public API scenario; infrastructure and grading evidence remain separate. +``` + +## Сравнительная стоимость reconciler: 3 размера, 15 dry-run + +Методика: `scripts/measure_reconcile.ps1` (5 повторов на этап, 5 пакетов × 10 upload перед следующим этапом). 10 пакетов по 10 PNG-файлов прошли с `failed_requests: 0`; данные добавлялись только через публичное API. Измерен `scan_elapsed_seconds` самого reconciler, без времени запуска Compose. Исходный файл с машины тестирования: `evidence/reconcile-cost-20261112-180238.csv`. + +| Этап | S3 keys | DB rows | Значения, с | Mean, с | Median, с | +|---|---:|---:|---|---:|---:| +| 0 | 36 | 18 | 0,624; 0,294; 0,207; 0,234; 0,245 | 0,3208 | 0,245 | +| 1 | 136 | 68 | 0,270; 0,284; 0,285; 0,294; 0,401 | 0,3068 | 0,285 | +| 2 | 236 | 118 | 0,568; 0,341; 0,289; 0,409; 0,300 | 0,3814 | 0,341 | + +Итог: +100 записей БД и +200 ключей S3, 15 проходов. Медианы возрастают при увеличении числа объектов, но на этих малых локальных выборках нельзя утверждать асимптотику или throughput production. Числа переписаны из пользовательского stdout; оригинальный CSV хранится у пользователя. + +**Не проверено:** интеграционная имитация одновременной потери обеих S3-копий, реальный отказ PG COMMIT во время upload. Отдельные успешные `smoke.py` не подтверждают автоматически все критерии на 5. diff --git a/infra/filer.toml b/infra/filer.toml new file mode 100644 index 00000000..f3f385a4 --- /dev/null +++ b/infra/filer.toml @@ -0,0 +1,4 @@ +# Persistent SeaweedFS filer metadata for the single-node lab stack. +[leveldb2] +enabled = true +dir = "/data/filerldb2" diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg new file mode 100644 index 00000000..62b0dba5 --- /dev/null +++ b/infra/haproxy.cfg @@ -0,0 +1,32 @@ +global + log stdout format raw local0 + maxconn 1000 + +defaults + log global + mode http + option httplog + option dontlognull + timeout connect 2s + timeout client 60s + timeout server 60s + timeout http-request 5s + +resolvers docker + nameserver localdns 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + hold valid 1s + +frontend messenger + bind *:8080 + default_backend api_nodes + +backend api_nodes + balance roundrobin + option httpchk GET /health/ready + http-check expect status 200 + default-server inter 1s fall 2 rise 1 slowstart 2s + server api1 api1:8080 check resolvers docker init-addr none + server api2 api2:8080 check resolvers docker init-addr none diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..432d9945 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,10 @@ +fastapi==0.115.12 +uvicorn==0.34.2 +pydantic==2.11.4 +psycopg[binary]==3.2.6 +psycopg-pool==3.2.6 +redis==5.2.1 +argon2-cffi==23.1.0 + +boto3==1.40.0 +Pillow==11.3.0 diff --git a/scripts/measure_reconcile.ps1 b/scripts/measure_reconcile.ps1 new file mode 100644 index 00000000..256f8eea --- /dev/null +++ b/scripts/measure_reconcile.ps1 @@ -0,0 +1,84 @@ +<# +.SYNOPSIS + Лабораторная 4, трек 5: стоимость полного reconcile на нескольких масштабах. +.DESCRIPTION + Не делает --apply и НЕ удаляет объекты. На каждом этапе делает 5 dry-run, + создаёт синтетические вложения через HTTP API и сохраняет CSV. + Запуск из корня lab4 при поднятом docker compose. +.EXAMPLE + powershell -ExecutionPolicy Bypass -File scripts/measure_reconcile.ps1 +#> +param( + [ValidateRange(1,100)][int]$ConcurrentUploads = 10, + [ValidateRange(1,20)][int]$BatchesPerStage = 5, + [ValidateRange(2,30)][int]$ScanRepeats = 5, + [ValidateRange(2,6)][int]$Stages = 3 +) +$ErrorActionPreference = 'Stop' +$env:PYTHONUTF8 = '1' +if (!(Test-Path '.env') -or !(Test-Path 'tests/attachments_concurrent.py')) { + throw 'Запустите скрипт из корня Lab4, где есть .env и tests/attachments_concurrent.py' +} +New-Item -ItemType Directory -Force evidence | Out-Null +$stamp = Get-Date -Format 'yyyyMMdd-HHmmss' +$rows = New-Object 'System.Collections.Generic.List[object]' + +for ($stage = 0; $stage -lt $Stages; $stage++) { + Write-Host "`n=== Stage ${stage}: measuring $ScanRepeats dry-runs ===" -ForegroundColor Cyan + for ($repeat = 1; $repeat -le $ScanRepeats; $repeat++) { + # Docker Compose может печатать сообщения о контейнерах в stderr; JSON из CLI — stdout. + $raw = @(& docker compose --env-file .env run --rm -T reconcile python -m app.reconcile) + if ($LASTEXITCODE -ne 0) { + throw "Reconcile dry-run failed at stage=$stage repeat=$repeat" + } + $s = ($raw -join "`n").Trim() + try { + $parsed = $s | ConvertFrom-Json + } catch { + # На некоторых версиях Compose в stdout бывают служебные строки. + $a = $s.IndexOf('{'); $b = $s.LastIndexOf('}') + if ($a -lt 0 -or $b -le $a) { throw "No JSON in reconcile output: $s" } + $parsed = $s.Substring($a, $b-$a+1) | ConvertFrom-Json + } + if ($parsed.mode -ne 'dry-run' -or $parsed.errors.Count -ne 0 -or + $parsed.missing_both_unrecoverable.Count -ne 0) { + throw 'Unexpected reconciliation state: inspect output before continuing' + } + $item = [pscustomobject]@{ + stage = $stage + repeat = $repeat + s3_keys_scanned = [int]$parsed.s3_keys_scanned + db_rows_scanned = [int]$parsed.db_rows_scanned + scan_elapsed_seconds = [double]$parsed.scan_elapsed_seconds + } + $rows.Add($item) + Write-Host ("scan {0}/{1}: S3={2}, DB={3}, t={4}s" -f $repeat,$ScanRepeats,$item.s3_keys_scanned,$item.db_rows_scanned,$item.scan_elapsed_seconds) + } + + if ($stage -eq ($Stages - 1)) { break } + Write-Host "Creating $BatchesPerStage batches x $ConcurrentUploads synthetic attachments..." -ForegroundColor Yellow + for ($batch = 1; $batch -le $BatchesPerStage; $batch++) { + $outPath = "evidence/measure-upload-$stamp-stage$stage-batch$batch.json" + & python tests/attachments_concurrent.py --concurrency $ConcurrentUploads --output $outPath + if ($LASTEXITCODE -ne 0) { throw "Upload failed at stage=$stage batch=$batch" } + } +} + +$csv = "evidence/reconcile-cost-$stamp.csv" +$rows | Export-Csv -Path $csv -Encoding UTF8 -NoTypeInformation -Delimiter ';' +Write-Host "`nSaved $csv" -ForegroundColor Green +$rows | Group-Object stage | ForEach-Object { + $items = @($_.Group) + $avg = ($items | Measure-Object scan_elapsed_seconds -Average).Average + $sorted = @($items | Sort-Object scan_elapsed_seconds) + $median = $sorted[[int][Math]::Floor($sorted.Count / 2)].scan_elapsed_seconds + [pscustomobject]@{ + stage = $_.Name + keys = $items[0].s3_keys_scanned + rows = $items[0].db_rows_scanned + runs = $items.Count + mean_seconds = [Math]::Round($avg, 4) + median_seconds = [Math]::Round($median, 4) + } +} | Format-Table -AutoSize +Write-Host 'Measurements done. These are small-sample local observations, not scalability proof.' diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..b6ef8de2 --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,11 @@ +@echo off +setlocal +cd /d "%~dp0.." +docker compose --env-file .env stop --timeout 5 lb api1 api2 s3 redis postgres +if errorlevel 1 exit /b 1 +docker compose --env-file .env up -d --wait postgres redis s3 s3-bootstrap +if errorlevel 1 exit /b 1 +docker compose --env-file .env up -d --no-deps api1 api2 lb +if errorlevel 1 exit /b 1 +python scripts\wait_ready.py +exit /b %ERRORLEVEL% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..076ae23e --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,21 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +# Preserve named volumes. Restart all state stores and both API processes. +docker compose --env-file .env stop --timeout 5 lb api1 api2 s3 redis postgres +docker compose --env-file .env up -d --wait postgres redis s3 s3-bootstrap +docker compose --env-file .env up -d --no-deps api1 api2 lb +python - <<'PY' +import time, urllib.request +for i in range(120): + try: + with urllib.request.urlopen('http://localhost:8080/health/ready', timeout=2) as response: + if response.status == 200: + print('[restart] all services ready') + break + except Exception: + pass + time.sleep(.5) +else: + raise SystemExit('[restart] health timeout') +PY diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100644 index 00000000..77f8d2a2 --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,17 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +# Run tests/load.py in a second terminal while this script recreates API instances. +for replica in api1 api2; do + docker compose --env-file .env up -d --no-deps --force-recreate "$replica" + docker compose --env-file .env exec -T "$replica" python - <<'PY' +import time,urllib.request +for _ in range(40): + try: + if urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=2).status==200:break + except Exception:pass + time.sleep(.5) +else:raise SystemExit('replica did not recover') +PY + sleep 3 + done diff --git a/scripts/stop-one.cmd b/scripts/stop-one.cmd new file mode 100644 index 00000000..e3f21f0e --- /dev/null +++ b/scripts/stop-one.cmd @@ -0,0 +1,10 @@ +@echo off +setlocal +cd /d "%~dp0.." +if "%TARGET_INSTANCE_ID%"=="api1" goto stop +if "%TARGET_INSTANCE_ID%"=="api2" goto stop +echo Unexpected TARGET_INSTANCE_ID 1>&2 +exit /b 2 +:stop +docker compose --env-file .env stop --timeout 1 %TARGET_INSTANCE_ID% +exit /b %ERRORLEVEL% diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..344d6905 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,8 @@ +#!/bin/sh +# The public failover test sets TARGET_INSTANCE_ID from the actual response header. +set -eu +cd "$(dirname "$0")/.." +case "${TARGET_INSTANCE_ID:?missing TARGET_INSTANCE_ID}" in + api1|api2) docker compose --env-file .env stop --timeout 1 "$TARGET_INSTANCE_ID" ;; + *) echo 'Unexpected instance alias' >&2; exit 2 ;; +esac diff --git a/scripts/wait_ready.py b/scripts/wait_ready.py new file mode 100644 index 00000000..86d0318b --- /dev/null +++ b/scripts/wait_ready.py @@ -0,0 +1,14 @@ +"""Operator-facing readiness wait after container replacement.""" +import time +import urllib.request +for _ in range(120): + try: + with urllib.request.urlopen("http://localhost:8080/health/ready", timeout=2) as response: + if response.status == 200: + print("[restart] all services ready") + break + except Exception: + pass + time.sleep(.5) +else: + raise SystemExit("[restart] health timeout") diff --git a/tests/attachments_concurrent.py b/tests/attachments_concurrent.py new file mode 100644 index 00000000..232097c5 --- /dev/null +++ b/tests/attachments_concurrent.py @@ -0,0 +1,42 @@ +#!/usr/bin/env python3 +"""10 parallel uploads, report timings (capture Docker memory separately).""" +import argparse +import concurrent.futures +import json +import statistics +import time +from pathlib import Path +from client import Client, check + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--concurrency',type=int,default=10) + parser.add_argument('--output',default='evidence/attachments-concurrent.json') + parser.add_argument('--base-url',default='http://localhost:8080') + args = parser.parse_args() + c = Client(args.base_url) + alice,bob,eve,chat = c.bootstrap() + source = (Path(__file__).parent/'fixtures/sample.png').read_bytes() + path = '/api/v1/chats/'+chat['id']+'/attachments?filename=parallel.png' + def upload(i): + cli = Client(args.base_url) + res=cli.call('POST',path,201,actor=alice,raw=source,headers={'Content-Type':'image/png'},schema='Attachment') + check(res['json']['size_bytes']==len(source), 'Size mismatch') + return res['elapsed'] + t=time.monotonic() + with concurrent.futures.ThreadPoolExecutor(max_workers=args.concurrency) as pool: + values=list(pool.map(upload,range(args.concurrency))) + elapsed=time.monotonic()-t + data={'concurrency':args.concurrency,'uploads':len(values),'failed_requests':0, + 'elapsed_seconds':round(elapsed,3),'upload_rps':round(len(values)/elapsed,3), + 'latency_p50_ms':round(statistics.median(values)*1000,1), + 'latency_max_ms':round(max(values)*1000,1), + 'bytes_per_file':len(source), + 'note':'Capture peak API RSS with docker stats; this script is client-side only.'} + Path(args.output).parent.mkdir(exist_ok=True,parents=True) + Path(args.output).write_text(json.dumps(data,indent=2),encoding='utf-8') + print(json.dumps(data,indent=2)) + +if __name__=='__main__': + main() diff --git a/tests/attachments_negative.py b/tests/attachments_negative.py new file mode 100644 index 00000000..ba8b57b0 --- /dev/null +++ b/tests/attachments_negative.py @@ -0,0 +1,41 @@ +#!/usr/bin/env python3 +"""Lab4 negative API tests with isolated synthetic users (requires live stack).""" +from urllib.parse import quote +import uuid +from client import Client, arguments, run, check +from pathlib import Path + + +def main(): + args = arguments('Lab4 negative file/ACL/security tests') + c = Client(args.base_url, args.ca_file) + alice, bob, eve, chat = c.bootstrap() + base = '/api/v1/chats/' + chat['id'] + '/attachments?filename=' + data = (Path(__file__).parent / 'fixtures/sample.png').read_bytes() + c.call('POST', base+'big.png', 413, actor=alice, raw=data+b'\x00'*(10*1024*1024+1-len(data)), headers={'Content-Type':'image/png'}) + c.call('POST', base+'bad.png', 415, actor=alice, raw=b'not-an-image', headers={'Content-Type':'image/png'}) + c.call('POST', base+'fake.jpg', 415, actor=alice, raw=data, headers={'Content-Type':'image/jpeg'}) + c.call('POST', base+quote('../escape.png',safe=''), 400, actor=alice, raw=data, headers={'Content-Type':'image/png'}) + c.call('POST', base+'x.png', 404, actor=eve, raw=data, headers={'Content-Type':'image/png'}) + c.call('POST', base+'x.png', 401, raw=data, headers={'Content-Type':'image/png'}) + uploaded = c.attachment(alice,chat)[0] + unknown = str(uuid.uuid4()) + c.call('GET','/api/v1/attachments/'+unknown,404,actor=alice) + c.call('GET','/api/v1/attachments/'+uploaded['id'],404,actor=eve) + c.call('GET','/api/v1/attachments/'+uploaded['id']+'/content',404,actor=eve) + c.call('GET','/api/v1/attachments/'+uploaded['id']+'/content?variant=thumbnail',404,actor=alice) + other_chat = c.call('POST','/api/v1/chats',201,actor=alice, + body={'title':'Другой чат','member_ids':[alice['id'],bob['id']]},schema='Chat')['json'] + path = '/api/v1/chats/'+other_chat['id']+'/messages' + c.call('POST',path,404,actor=alice, + body={'text':'cross-chat','attachment_ids':[uploaded['id']]}, + headers={'Idempotency-Key':uuid.uuid4().hex}) + c.call('POST','/api/v1/chats/'+chat['id']+'/messages',404,actor=alice, + body={'text':'unknown','attachment_ids':[unknown]}, + headers={'Idempotency-Key':uuid.uuid4().hex}) + ok = c.message(bob,chat,'',attachments=[uploaded['id']])['json'] + check(ok['attachment_ids']==[uploaded['id']], 'valid attachment not linked') + print('PASS: lab4 negative image, MIME, size, filename, ACL and cross-chat checks') + +if __name__=='__main__': + run(main) diff --git a/tests/idempotency_parallel.py b/tests/idempotency_parallel.py new file mode 100644 index 00000000..3edffd75 --- /dev/null +++ b/tests/idempotency_parallel.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +"""Lab3 own test: 30 requests using identical actor/chat/key/body across both replicas.""" +import concurrent.futures +import sys +import uuid +from client import Client, Failure, arguments, check, run + + +def main(): + args = arguments("Check atomic idempotency across API replicas") + c = Client(args.base_url, args.ca_file) + alice, bob, _, chat = c.bootstrap() + key = uuid.uuid4().hex + body = {"text": "Concurrent replay " + key} + path = f"/api/v1/chats/{chat['id']}/messages" + + def worker(_): + # Independent request client; one shared bearer token and idempotency key. + client = Client(args.base_url, args.ca_file) + return client.call("POST", path, expected=201, actor=alice, body=body, + headers={"Idempotency-Key": key}, schema="Message") + + with concurrent.futures.ThreadPoolExecutor(max_workers=12) as executor: + results = list(executor.map(worker, range(30))) + ids = {result["json"]["id"] for result in results} + instances = {result["headers"]["X-Instance-Id"] for result in results} + check(len(ids) == 1, "parallel replay created different messages") + check(len(instances) >= 2, "LB did not serve requests via both API replicas") + check(all(r["json"] == results[0]["json"] for r in results), "replay returned altered result") + c.call("POST", path, 409, actor=alice, body={"text": "different body"}, headers={"Idempotency-Key": key}) + c.call("POST", path, 201, actor=bob, body=body, headers={"Idempotency-Key": key}, schema="Message") + history = c.call("GET", path + "?limit=100", actor=bob, schema="MessagePage")["json"]["items"] + check(sum(x["id"] in ids for x in history) == 1, "message duplicated in history") + print("PASS: parallel idempotency across", len(instances), "replicas; one message, replay 201, conflicting body 409") + + +if __name__ == "__main__": + run(main) diff --git a/tests/own_unit.py b/tests/own_unit.py new file mode 100644 index 00000000..bad78c17 --- /dev/null +++ b/tests/own_unit.py @@ -0,0 +1,42 @@ +#!/usr/bin/env python3 +"""Fast non-Docker checks for input contracts and cursor scoping.""" +import sys +from pathlib import Path +from datetime import datetime, timezone +import uuid + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from app.core import make_cursor, read_cursor, parse_limit, APIError +from app.models import CreateUser, CreateChat, CreateMessage +from pydantic import ValidationError + + +def reject(fn): + try: + fn() + except (APIError, ValidationError, ValueError): + return + raise AssertionError("Expected invalid input") + + +def main(): + token = str(uuid.uuid4()) + dt = datetime.now(timezone.utc) + cursor = make_cursor("messages", token, dt, str(uuid.uuid4())) + assert read_cursor(cursor, "messages", token)[0] == dt + reject(lambda: read_cursor(cursor, "messages", str(uuid.uuid4()))) + reject(lambda: read_cursor(cursor, "chats", token)) + assert parse_limit(None) == 50 + reject(lambda: parse_limit("0")) + reject(lambda: parse_limit("101")) + reject(lambda: CreateUser(username="user_name", display_name=" \t", password="Long-enough-secret")) + reject(lambda: CreateUser(username="user_name", display_name="Test", password=" " * 3)) + assert CreateMessage(text="A\u0000B").text == "A\u0000B" + reject(lambda: CreateMessage(text=" \t")) + reject(lambda: CreateChat(title="title", member_ids=[token] * 2)) + reject(lambda: CreateChat(title="title", member_ids=[token] * 101)) + print("PASS: models, cursor scoping, limits, Unicode U+0000") + + +if __name__ == "__main__": + main() -- 2.54.0