Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
87ce432b81 |
+10
-17
@@ -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
|
||||
|
||||
@@ -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
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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 содержит инструкцию решения.
|
||||
@@ -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
@@ -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 не нужно.
|
||||
@@ -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.
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
"""Lab 3 messenger API."""
|
||||
@@ -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
@@ -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}
|
||||
@@ -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
@@ -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
@@ -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
@@ -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"))
|
||||
@@ -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()
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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
@@ -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:
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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"
|
||||
|
@@ -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`.
|
||||
@@ -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.
|
||||
@@ -0,0 +1,4 @@
|
||||
# Persistent SeaweedFS filer metadata for the single-node lab stack.
|
||||
[leveldb2]
|
||||
enabled = true
|
||||
dir = "/data/filerldb2"
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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.'
|
||||
@@ -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%
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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%
|
||||
@@ -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
|
||||
@@ -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")
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user