Compare commits

1 Commits
Author SHA1 Message Date
ferraronp 87ce432b81 Implement lab4 private S3 attachments and reconciliation track 2026-11-12 18:15:42 +03:00
56 changed files with 2465 additions and 41 deletions
+10 -17
View File
@@ -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
+7
View File
@@ -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
+16
View File
@@ -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.
+10
View File
@@ -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"]
+62
View File
@@ -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 содержит инструкцию решения.
+17
View File
@@ -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 после копирования.
+103
View File
@@ -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 не нужно.
+151 -24
View File
@@ -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/<uuid>/original` и `recovery/<uuid>/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 <uuid>` под `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/<uuid>/original` → `attachments/<uuid>/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.
+1
View File
@@ -0,0 +1 @@
"""Lab 3 messenger API."""
+4
View File
@@ -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)
+191
View File
@@ -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}
+241
View File
@@ -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"])})
+104
View File
@@ -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
+79
View File
@@ -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)}}
+84
View File
@@ -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"))
+23
View File
@@ -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()
+77
View File
@@ -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
+130
View File
@@ -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()
+36
View File
@@ -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()
+61
View File
@@ -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()
+35
View File
@@ -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()
+32
View File
@@ -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()
+40
View File
@@ -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()
+64
View File
@@ -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
+185
View File
@@ -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:
+33
View File
@@ -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);
+12
View File
@@ -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);
+25
View File
@@ -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);
+11
View File
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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"
1 stage repeat s3_keys_scanned db_rows_scanned scan_elapsed_seconds
2 0 1 36 18 0,624
3 0 2 36 18 0,294
4 0 3 36 18 0,207
5 0 4 36 18 0,234
6 0 5 36 18 0,245
7 1 1 136 68 0,27
8 1 2 136 68 0,284
9 1 3 136 68 0,285
10 1 4 136 68 0,294
11 1 5 136 68 0,401
12 2 1 236 118 0,568
13 2 2 236 118 0,341
14 2 3 236 118 0,289
15 2 4 236 118 0,409
16 2 5 236 118 0,3
@@ -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`.
+110
View File
@@ -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.
+4
View File
@@ -0,0 +1,4 @@
# Persistent SeaweedFS filer metadata for the single-node lab stack.
[leveldb2]
enabled = true
dir = "/data/filerldb2"
+32
View File
@@ -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
+10
View File
@@ -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
+84
View File
@@ -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.'
+11
View File
@@ -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%
+21
View File
@@ -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
+17
View File
@@ -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
+10
View File
@@ -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%
+8
View File
@@ -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
+14
View File
@@ -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")
+42
View File
@@ -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()
+41
View File
@@ -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)
+38
View File
@@ -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)
+42
View File
@@ -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()