ЛР 4 — БВТ2301 — Маслов — на 5 #144

Closed
wh1tet3a wants to merge 12 commits from wh1tet3a/mtusi2026lab4:solution/bvt2301-maslov into main
71 changed files with 16744 additions and 38 deletions
+15
View File
@@ -18,3 +18,18 @@ __pycache__
node_modules
evidence
.DS_Store
**/__pycache__
**/*.py[cod]
.work
.pytest_cache
.ruff_cache
tests
student-tests
research
scripts
contracts
*.md
Makefile
compose.yaml
.work*
+9 -3
View File
@@ -13,8 +13,14 @@ API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
S3_ENDPOINT=http://s3:9000
S3_REGION=us-east-1
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
S3_BUCKET=messenger
S3_ACCESS_KEY_FILE=/run/secrets/s3_access_key
S3_SECRET_KEY_FILE=/run/secrets/s3_secret_key
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
PUBLIC_PORT=8084
API_CPUS=0.5
API_MEMORY=768m
DB_POOL_SIZE=10
RECONCILE_GRACE_SECONDS=300
+18 -14
View File
@@ -1,18 +1,22 @@
## Лабораторная 4
Автор / группа: TODO
Целевая оценка (3/4/5): TODO
Трек 5, если заявлен: TODO
Автор / группа: Маслов / БВТ2301
Целевая оценка: 5
Трек: 2 — согласованность PostgreSQL/S3
Что реализовано и что перенесено: TODO
Команды запуска из чистого clone: TODO
Результаты проверок и ссылка на REPORT.md: TODO
Ограничения / известные ошибки: TODO
Источники и использование ИИ: TODO
Перенесена собственная база ЛР3: Bearer, ACL, PostgreSQL/Valkey, две API, HAProxy и идемпотентность сообщений. Добавлены private MinIO, синхронный upload201ready, byte/pixel/MIME/filename limits, авторизованный streaming download, atomic Message links, durable pending intent и dry-run/apply reconciler с grace≥300s.
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
- [ ] make check и make test выполнены; приложен реальный вывод.
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
Запуск: `uv sync --locked`, `make bootstrap`, `VCS_REF=$(git rev-parse HEAD) docker compose up -d --build --wait`. Полные команды и архитектура — [REPORT.md](../REPORT.md), [SCHEMA.md](../SCHEMA.md).
Результаты: public smoke PASS; 108 HTTP tests PASS; реальные отказы двух API,
rolling/persistence PASS; private S3/IAM/bootstrap, PG/S3 faults, dry-run/apply/repeat
и 10 concurrent uploads PASS. Контролируемое исследование: 26/126/1126objects,
30rows/8HEAD/0GETbytes, 3 измерения на размер +warmup; медианы0.194/0.204/0.409s.
Raw: evidence/http-first.json, storage-first.json, cluster-first.json,
cost-controlled-first.json. Отчёт содержит SHA, методы, RAM/CPU, ограничения и
ответы защиты. Clean clone PASS: 108 tests, cluster/storage matrix, runtime hashes/OCI revision обеих API, fsck; receipt evidence/clean-clone-first.json.
Контракт и публичные tests сохранены.
Ограничения: один host, LB/PG/S3 — SPOF; HEAD не заменяет periodic checksum audit; inventory reconciler O(objects+rows); удалённый CI не подтверждён.
Источники: актуальное задание/контракты, собственная ЛР3, официальные библиотеки и исходники MinIO/mc. При разработке кода, тестов и отчёта использовалась помощь ИИ; результаты измерений получаются реальными командами.
+23
View File
@@ -0,0 +1,23 @@
name: Application integration
on: [push, pull_request, workflow_dispatch]
permissions:
contents: read
jobs:
application:
runs-on: ubuntu-latest
timeout-minutes: 60
steps:
- uses: actions/checkout@v4
- uses: astral-sh/setup-uv@v6
with:
version: 0.13.7
- run: uv sync --locked
- run: make bootstrap check validate lint PYTHON=.venv/bin/python
- run: VCS_REF=$(git rev-parse HEAD) docker compose up -d --build --wait
- run: make test test-student PYTHON=.venv/bin/python BASE_URL=http://127.0.0.1:8084
env:
NO_PROXY: localhost,127.0.0.1
no_proxy: localhost,127.0.0.1
- run: make verify VERIFY_OUTPUT=evidence/storage-ci.json
- if: always()
run: docker compose down --volumes --remove-orphans
+5
View File
@@ -30,3 +30,8 @@ coverage/
.vscode/
# Keep small, sanitized evidence summaries in evidence/ under version control.
# Inspect git diff --cached: ignore rules are not a secret scanner.
.work/
.work-*.txt
.pytest_cache/
.ruff_cache/
+1
View File
@@ -0,0 +1 @@
3.14.7
+22
View File
@@ -0,0 +1,22 @@
FROM ghcr.io/astral-sh/uv:0.13.7@sha256:96f40d3904aad8d0bd010539001d36c8e2188b981e1334471a90c4a1d93bb490 AS uv
FROM python:3.14.7-slim-trixie@sha256:51dafde81dbdb6ebde285137a295cf18a47ca95234fe388a343719cb97305b3d AS builder
COPY --from=uv /uv /usr/local/bin/uv
WORKDIR /app
ENV UV_PYTHON_DOWNLOADS=never UV_LINK_MODE=copy
COPY pyproject.toml uv.lock ./
RUN --mount=type=cache,target=/root/.cache/uv uv sync --locked --no-dev --no-install-project
FROM python:3.14.7-slim-trixie@sha256:51dafde81dbdb6ebde285137a295cf18a47ca95234fe388a343719cb97305b3d AS runtime
ARG VCS_REF=unknown
LABEL org.opencontainers.image.revision=$VCS_REF
WORKDIR /app
ENV PATH="/app/.venv/bin:$PATH" PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 APP_HOST=0.0.0.0 APP_PORT=8080
RUN groupadd --gid 10001 app && useradd --uid 10001 --gid app --no-create-home app
COPY --from=builder /app/.venv /app/.venv
COPY src /app/src
COPY migrations /app/migrations
USER 10001:10001
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=2s --start-period=10s --start-interval=1s --retries=3 CMD ["python", "-c", "import os,urllib.request; urllib.request.urlopen('http://127.0.0.1:'+os.getenv('APP_PORT','8080')+'/health/ready',timeout=1).read()"]
STOPSIGNAL SIGTERM
CMD ["python", "-m", "src"]
+18
View File
@@ -28,3 +28,21 @@ test-persistence:
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
UV ?= uv
BASE_URL = http://127.0.0.1:8084
VERIFY_OUTPUT ?= evidence/storage-repeat.json
.PHONY: bootstrap up down lint test-student verify
bootstrap:
$(PYTHON) scripts/bootstrap.py
up: bootstrap
VCS_REF=$$(git rev-parse HEAD) docker compose up -d --build --wait
down:
docker compose down
lint:
$(UV) run --locked ruff format src student-tests scripts/bootstrap.py scripts/stand.py scripts/cluster.py $(wildcard scripts/verify_*.py)
$(UV) run --locked ruff check src student-tests scripts/bootstrap.py scripts/stand.py scripts/cluster.py $(wildcard scripts/verify_*.py)
test-student:
BASE_URL="$(BASE_URL)" $(UV) run --locked pytest student-tests
verify:
$(UV) run --locked python -m scripts.verify_storage --output "$(VERIFY_OUTPUT)"
+252 -21
View File
@@ -1,37 +1,268 @@
# Отчёт — лабораторная 4
# Лабораторная 4 — Маслов, БВТ2301
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
Цель — **5, трек 2: согласованность PostgreSQL и S3**. Основа — собственная
реализация ЛР3. Сохранены Bearer-сессии в PostgreSQL, Argon2id, ACL,
keyset pagination, общий Idempotency-Key, HAProxy и две независимые API.
Добавлены приватный S3, вложения и повторяемый reconciler.
В clean-clone проверке обнаружена и исправлена гонка регистрации: все
конкуренты одного username без пользы выполняли Argon2, один мог получить
503 при лимите CPU. Теперь 64 bounded locks сериализуют локальные повторы,
перед KDF проверяется существование имени. Между API арбитр — прежний
PostgreSQL UNIQUE, хеширование остаётся вне SQL-транзакции. Argon2id и
лимит двух KDF/process не ослаблены. [Первый отказ](evidence/registration-race-first-failure.txt)
сохранён; после исправления [10 повторов по10 запросов](evidence/registration-race-fixed.json)
дали каждый раз один201/девять409, без503. Полный повтор из чистого clone прошёл: [receipt](evidence/clean-clone-first.json).
Проверки и исследование завершены. PR: [ЛР4 №144](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab4/pulls/144).
Публичный smoke и 108 собственных HTTP-проверок прошли на полном стенде
(362.40 s). Проверки отказов/исследование прошли; повтор в чистом clone также PASS (108 tests, 380.09 s).
Runtime проверен на двух API; receipt содержит исходный commit.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Git, Docker с Compose v2 и uv 0.13.7. Python 3.14.7 загружается через uv.
Docker Desktop использует около 6 GiB памяти на Apple M1 (8 CPU, 8 GiB host).
Первичная компиляция MinIO/клиента требует сеть и время. Исходный ZIP
MinIO с точным module version скачивается восемью потоками HTTP Range,
с ограниченным timeout/числом повторов; затем стандартный `go mod download`
проверяет h1 через Go checksum database перед сборкой. Проверки TLS и
checksum не отключены. Go parallelism
задан `GOMAXPROCS=2` и `GOFLAGS=-p=2`; зависимости и компилятор
используют BuildKit cache.
## Архитектура и решения
```sh
uv sync --locked
make bootstrap
VCS_REF=$(git rev-parse HEAD) docker compose up -d --build --wait
make check validate lint PYTHON=.venv/bin/python
make test test-student PYTHON=.venv/bin/python BASE_URL=http://127.0.0.1:8084
uv run python -m scripts.verify_storage --research --output evidence/storage-repeat.json
uv run python -m scripts.verify_cluster --output evidence/cluster-repeat.json
```
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
`bootstrap` создаёт отсутствующие `.env`/secret files, существующие сохраняет.
Secret directory имеет mode 0700; files читаются непривилегированными UID
контейнеров через read-only mounts. Их значения не должны попадать в Git.
Сначала стартует PostgreSQL, одноразовый migration применяет SQL по порядку
с checksum и advisory lock. Bootstrap S3 создаёт private bucket/app-user/policy
и переносит повторный запуск. После этого две API, reconciler и LB.
## Доказательства критериев
URL стенда: `http://127.0.0.1:8084`. API/S3/PG/cache не имеют host ports.
Безопасная остановка: `docker compose down` (volumes остаются).
Намеренное удаление **данных только текущего учебного проекта**:
`docker compose down --volumes`; это не обычный restart.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
```sh
# Dry-run: без изменений
docker compose run --rm --no-deps reconciler python -m src.reconcile
# Оператор явно разрешает изменения
docker compose run --rm --no-deps reconciler python -m src.reconcile --apply
# Реальные рестарты всех state services, с прежними volumes
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8084
make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://127.0.0.1:8084
```
Не запускать fault scripts параллельно друг с другом или HTTP pytest:
они намеренно останавливают реальные сервисы и временно устанавливают
PostgreSQL triggers. Все их пользователи/картинки синтетические.
Evidence filename должен быть новым, предыдущие результаты сохраняются.
## Версии и ограничения ресурсов
Полные image digests закреплены в Dockerfile/compose.yaml/infra/s3.Dockerfile:
Python 3.14.7 slim-trixie, uv 0.13.7, PostgreSQL 18.3, Valkey 8.1.3,
HAProxy 3.2.1 alpine. MinIO собирается из commit
`9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a`, release
`2025-10-15T17-29-55Z`; mc — из
`7394ce0dd2a80935aded936b09fa12cbb3cb8096` (2025-08-13).
Go 1.24.8 bookworm закреплён digest, исходные LICENSE включены в образы.
Python dependency lock включает minio 7.2.20 и Pillow 13.0.0.
| Процесс | CPU | RAM |
| --- | --- | --- |
| Каждая из двух API | 0.5 | 768 MiB |
| PostgreSQL | 1 | 512 MiB |
| MinIO | 1 | 1024 MiB |
| Valkey | 0.25 | 128 MiB |
| HAProxy | 0.5 | 128 MiB |
| Reconciler | 0.25 | 256 MiB |
API: read-only root, UID 10001, no capabilities, no-new-privileges,
128 PIDs, bounded `/tmp` tmpfs 128 MiB. At most two uploads/process,
одна декодируемая картинка/process. Spooled file после 1 MiB переносится в
tmpfs; максимум bytes 10 MiB, pixels 40 млн до decode. Проверяются формат
содержимого, фактический decode, filename; SHA-256 считается на входе.
S3 timeout connect 1/read 3 s, без transparent retry; DB transaction budget
4 s, statement 2.5 s; async ingress deadline 20 s. Отмена Python thread не
прерывает нативный decode, поэтому существенны также pixel/RAM limits.
Download передаёт chunks 64 KiB с закрытием S3 connection.
`.env.example`: PUBLIC_PORT/API_REPLICAS/API_CPUS/API_MEMORY/DB_POOL_SIZE/
SESSION_TTL_SECONDS/RECONCILE_GRACE_SECONDS используются Compose. Secret file
names указаны в compose.yaml. APP_HOST/APP_PORT задаются для API в Compose;
endpoint `s3:9000`, region us-east-1, bucket messenger, byte/pixel limits и
24 h idempotency заданы сервером. Это фиксированные параметры реализации,
логические подсказки skeleton не делают их автоматически настраиваемыми.
Сессии — PostgreSQL; Valkey хранит только disposable user cache.
## Архитектура и критерии
Подробные переходы и схема: [SCHEMA.md](SCHEMA.md).
`src/attachments.py` коммитит pending intent **до PUT**, затем ready;
201 означает подтверждённые bytes и metadata. Общей PG/S3 транзакции нет.
Readiness проверяет PG и S3. При потере S3 HAProxy может исключить все API и
вернуть собственный 503; прямой внутренний API возвращает JSON unavailable.
| Проверка | Команда | Наблюдение | Доказательство |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| SQL migrations | `docker compose run --rm --no-deps migrate`, повтор | 3 migrations, checksum match, repeat idempotent | [migrations-first.json](evidence/migrations-first.json) |
| Публичный API | `make test` | PASS: upload201, Message, original SHA-256 и ACL | [http-first.json](evidence/http-first.json) |
| Прежние возможности и негативные файлы | `uv run pytest student-tests -q` | 108 passed, 362.40 s; в том числе chunked >10 MiB, corrupt/MIME/pixels/filename/foreign chat | [http-first.json](evidence/http-first.json) |
| Закреплённый S3 | `go mod download`, `minio --version`, inspect | module h1 verified; binary 2025-10-15/go1.24.8/arm64; 2 API, реальные CPU/RAM/ports | [minio-source-verification.json](evidence/minio-source-verification.json) |
| Failover файла | `uv run python -m scripts.verify_storage --research --output evidence/storage-repeat.json` | API загрузившая файл реально остановлена, другая вернула прежний SHA-256 | [storage-first.json](evidence/storage-first.json) |
| Ограниченные credentials/private bucket/bootstrap | Та же storage-проверка | anonymous403, forbidden operations AccessDenied, denied HEAD→503, console недоступна из сети, повтор bootstrap сохранил файл | [storage-first.json](evidence/storage-first.json) |
| Обрыв и ошибки PG/S3 | Та же storage-проверка | частичный upload2MiB без intent/bytes; INSERT failure без PUT; pending после PUT/ошибки UPDATE восстановлен; S3down→503 | [storage-first.json](evidence/storage-first.json) |
| Пределы RAM | Та же storage-проверка | 10/10 uploads и 10/10 originals; память/CPU/latencies записаны | [storage-first.json](evidence/storage-first.json) |
| Orphan/missing, dry-run/apply/repeat | Та же storage-проверка | 5 ожидаемых действий, все применены; повтор0 действий; fresh/ready/used защищены, ID/links сохранены | [storage-first.json](evidence/storage-first.json) |
| Реальные отказы/идемпотентность/rolling | `uv run python -m scripts.verify_cluster --output evidence/cluster-repeat.json` | две API остановлены по очереди; общий replay и rollback; rolling; подтверждённые сообщения без дублей | [cluster-first.json](evidence/cluster-first.json) |
| Полный restart с volumes | Та же cluster-проверка, public resilience | API/PG/cache/S3/LB изменили StartedAt, прежние token/metadata/bytes сохранены | [cluster-first.json](evidence/cluster-first.json) |
| Стоимость обхода | `uv run python -m research.cost --output evidence/cost-repeat.json` | 9 измерений +3 warmups, фиксированные 30rows/8HEAD/0GETbytes, 0/100/1100extra | [cost-controlled-first.json](evidence/cost-controlled-first.json) |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Source первых HTTP/storage/cluster = `f5a7a74`, OCI revision API совпадает с ним.
Контролируемый cost harness — `3fd912f`, исполняемый `src/reconcile.py` тот же.
В чистом clone дополнительно проверяются module hashes/OCI revision обеих API
и полный набор сценариев; итоговый receipt — evidence/clean-clone-first.json.
## Эксперименты и отказы
## Методика исследования
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Гипотеза: сохранённое до PUT намерение и grace позволяют повторной сверкой
исправлять окна отказов PG/S3 без удаления свежих/используемых bytes.
Полный обход имеет линейную стоимость по числу объектов и metadata.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
`scripts/verify_storage.py --research`: реальные отказы INSERT/ready UPDATE
через временные PG triggers, недоступность S3, abort HTTP, отсутствие
используемого оригинала, old orphan и fresh orphan. Объект orphan реально
стареет ≥300 s по S3 LastModified. Dry-run, apply, повторный apply.
Первичный cost в storage-first.json оставлен как разведочный: между
повторами HEAD count менялся 6→10→16, когда concurrent upload rows достигли
300s. Его время нельзя приписать одному размеру inventory при прочих равных.
Для окончательного исследования используется `research/cost.py`:
8 PNG-fixtures с metadata, намеренно состаренными в PG на 2 дня; grace 3600 s,
0/100/1100 добавочных свежих объектов по 1 byte. Остальные реальные строки
стенда учитываются; invariant фиксирует 30rows/8HEAD/0GETbytes во всех 9 cells.
Один warmup на dataset, затем 3 измеряемых dry-run, по возрастанию размера.
Каждый probe — новый контейнер **reconciler .25 CPU / 256 MiB**, не API.
Duration измеряется внутри reconcile (не включает запуск контейнера/seed),
CPU — process_time, RSS peak — Linux ru_maxrss, cgroup peak включает startup.
Временные fixtures и bytes удаляются только по собственным chat/prefix.
Это стоимость обхода, не максимальная пропускная способность S3.
10 потоков одновременно загружают одинаковое синтетическое PNG 1700×1700,
каждый сравнивает оригинал. Измеряются upload p50/p95/p99, ошибки/RPS,
cgroup memory.current samples и lifetime memory.peak обеих API, cpu.stat
до/после. Duration/RPS включают downloads и sampler; latency — upload only.
memory.peak может включать прежние запросы, поэтому отдельно показан
максимум memory.current в окне. Небольшая серия не является production SLA.
## Наблюдения и границы эксперимента
Storage: orphan действительно старел 331.301s; часы S3 не менялись.
Dry-run нашёл по одному delete_orphan/recover_pending/fail_pending_missing/
delete_failed_object/mark_missing. Apply выполнил их, повторный apply не
изменил ничего. Fresh orphan, fresh failed и ready без Message сохранились;
у missing used сохранены metadata ID и Message link, внешний GET→409.
Данные пропавшего original не «восстановлены» по checksum.
10 одновременных uploads: PNG 6,017,095 bytes, 2,890,000 pixels; 10/10 успехов,
ошибок 0, оригиналы совпали. Серия 5.149 s, 1.942successful uploads/s с учётом
скачивания и sampler; upload p50=2162.965ms, p95=p99=4465.512ms.
Это одна короткая серия, p95/p99 на 10 запросах совпадают с максимумом.
Sampled cgroup memory.current max по API 123.01/155.93 MiB; memory.peak
145.66/205.13 MiB. Последнее включает предыдущую работу, поэтому это верхняя
граница для данной серии. В clean-clone повторе API специально рестартуют
перед экспериментом, чтобы peak относился к новым cgroups.
| Дополнительные объекты | Фактически scanned | Медиана времени, s | Диапазон 3 повторов, s |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| 0 | 26 | 0.193719 | 0.189185–0.210146 |
| 100 | 126 | 0.204344 | 0.196670–0.210975 |
| 1100 | 1126 | 0.409094 | 0.391053–0.610401 |
## Ограничения и следующие шаги
При этих условиях увеличение inventory повысило стоимость. Код хранит
inventory в dict и обходит его целиком: O(objects+rows) времени/памяти.
Три размера и три повтора не доказывают точную линейную зависимость:
есть fixed HEAD cost, pagination LIST после 1000 keys, quota scheduling и
нагрузка общего ноутбука. CPU процесса 0.0368–0.1059 s; RSS peak 58.82–59.82 MiB,
cgroup peak 41.60–43.10 MiB. RSS и cgroup учитывают общие страницы по-разному;
это разные показатели. Небольшой dataset не доказывает пригодность полного
inventory для миллионов объектов. Следующий шаг — пагинация/partitioning
и ограниченные пачки metadata; это предложение, не измеренная оптимизация.
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
![Measured inventory cost and sampled API memory](evidence/storage-research-controlled.png)
Process failover: первая API: 194 подтверждённых записи / 8 временных ошибок,
восстановление 4.086 s; вторая: 217 / 7 / 2.720 s. Rolling: 609 записей / 34 ошибки,
подтверждённые записи сохранены. Public failover: 123 записи / 3 ошибки,
восстановление 2.635 s. Это не zero-error rolling и не HA единственного host.
## Вопросы защиты
**Почему volume API не равно S3?** Volume принадлежит контейнеру/host и сам
по себе не задаёт объектный HTTP API, bucket policy, общую адресацию и
независимый lifecycle. В этой реализации у API вообще нет persistent volume;
другая реплика читает общий S3 по metadata PostgreSQL.
**Когда можно вернуть 201?** После фактической проверки изображения,
успешного PUT и COMMIT ready. Если COMMIT не подтверждён, нельзя обещать
201. Клиент может потерять ответ после успешной записи; upload не имеет
Idempotency-Key, поэтому слепой повтор может создать другое вложение.
**PUT прошёл, COMMIT не прошёл?** Уже есть durable pending intent. После
grace reconciler проверяет размер/checksum и переводит в ready. При
отсутствующих/других bytes ставит internal failed. Очищать файл вслепую
при неизвестном результате COMMIT опасно. Восстановление уже пропавших
bytes только из checksum невозможно.
**Почему случайный key/private bucket не заменяют ACL?** Пользователи
могут узнать ID из сообщения; key не доказывает membership. Каждый GET
сначала проверяет Bearer и JOIN members, чужой/отсутствующий объект — 404.
Private bucket защищает обход API; application IAM ограничивает последствия
ошибок backend, но не принимает пользовательские решения о доступе.
## Источники, помощь и границы
Использованы задание и неизменённые контракты текущего репозитория,
собственный код ЛР3, FastAPI/Pydantic, psycopg, minio SDK, Pillow,
[исходники MinIO](https://github.com/minio/minio),
[исходники mc](https://github.com/minio/mc),
[S3 uploads](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html).
При проектировании, написании кода, тестов и отчёта использована помощь ИИ;
фактические результаты должны подтверждаться сохранёнными командами.
Код и данные других студентов не использовались.
Один host/LB/PG/S3 — SPOF; нет защиты от потери единственного диска,
backup/restore S3, TLS и monitoring. Ready HEAD не проверяет весь checksum
на каждом проходе. Reconciler хранит полный inventory в RAM, metadata failed
сохраняет для диагностики. Повреждение S3 нельзя исправить без резервной копии.
CI workflow приложен; удалённый запуск не подтверждён.
## Итоговая проверка из чистого clone
[evidence/clean-clone-first.json](evidence/clean-clone-first.json): PASS,
source `6f8e4f127dee8857a3af908a9fb1d575f8907d90`. Новые secrets, env,
volumes, API image и фиксированный случайный host port; check/validate/lint,
public smoke, 108 HTTP tests (380.09 s), полная cluster/storage матрица,
hashes исходников и OCI revision обеих API совпали; git fsck PASS.
Временный стенд и только его volumes удалены в finally.
Реальное старение S3 334.035 s; пять ожидаемых действий dry-run/apply,
повтор 0; fresh/ready/used данные защищены. C10: 10/10, ошибок0,
6,017,095 bytes/image, 5.429 s включая verified downloads/sampler;
1.842 successful uploads/s, upload p50 2767.956 ms, p95=p99 5002.469 ms.
После рестарта API новые cgroups: sampled memory.current max 138.30 MiB,
memory.peak max 143.94 MiB (включает startup до серии).
Контролируемое исследование 9cells выполнено отдельно и не выдаётся
за повторённое в clean clone. Старый failed receipt сохранён для истории.
Последующие коммиты меняют только отчёт/evidence, проверенный runtime сохранён.
+76
View File
@@ -0,0 +1,76 @@
# Бинарные данные и два независимых хранилища
```mermaid
flowchart LR
C[Клиент] --> L[HAProxy :8084]
L --> A[API × 2]
A --> P[(PostgreSQL)]
A --> S[(Приватный MinIO)]
A --> V[(Valkey: кэш пользователей)]
R[Reconciler: 60 секунд] --> P
R --> S
```
`users/chats/members/messages/sessions/idempotency` перенесены из собственной
ЛР3. Новые таблицы: `attachments` и `message_attachments`. Состав участников
чата неизменяемый. PostgreSQL хранит metadata и ACL, S3 — оригинальные bytes.
Временный файл в API ограничен размером, удаляется при закрытии запроса и
не является источником истины. API-процессы не обмениваются локальными файлами.
```mermaid
sequenceDiagram
participant C as Клиент
participant A as API
participant P as PostgreSQL
participant S as S3
C->>A: Bearer, filename, PNG/JPEG bytes
A->>A: ACL, лимиты bytes/pixels, decode, SHA-256
A->>P: COMMIT pending intent, UUID/key, срок 120 с
A->>S: PUT оригинала
A->>P: COMMIT ready при действующем намерении
A-->>C: 201 ready
```
Общей транзакции PostgreSQL+S3 нет. Если INSERT намерения не прошёл, PUT не
выполняется. Если PUT не прошёл, остаётся pending без объекта. Если PUT
прошёл, а ready UPDATE/COMMIT нет, остаётся pending с bytes. Неопределённый
результат COMMIT нельзя исправлять безусловным DELETE файла: COMMIT мог
успешно завершиться, хотя клиент потерял ответ.
Reconciler по умолчанию выполняет **dry-run**. `--apply` разрешает изменения.
Автоматический процесс запускает apply каждые 60 секунд. Grace не менее
300 секунд; возраст берётся из PostgreSQL clock и S3 LastModified.
| Состояние | Действие после grace |
| --- | --- |
| Объект без metadata | Повторная проверка metadata и HEAD; удалить старый orphan |
| pending + корректные размер/SHA-256 bytes | ready |
| pending без bytes / с другим размером/checksum | failed с безопасной причиной |
| ready с bytes, включая файл без Message | Сохранить |
| ready без bytes | failed, сохранить ID, metadata и Message links |
| failed, связанный с Message | Сохранить |
| failed без Message со старым объектом | Повторно проверить свежесть HEAD; удалить bytes |
| Свежий объект | Сохранить |
| AccessDenied / 5xx / network error | Завершить проход с ошибкой; не считать объект отсутствующим |
Во внешнем контракте ЛР4 Attachment имеет только статус `ready`. Внутренние
pending/failed возвращают `409 conflict`, после проверки ACL. ЛР5 меняет
этот контракт на четыре публичных состояния и требует другого обработчика.
Связь Message↔Attachment вставляется в одной PostgreSQL-транзакции с Message
и Idempotency-Key. Композитные FK проверяют одинаковый chat_id; FOR SHARE
на вложении защищает проверку ready от конкурентного изменения состояния.
Несколько сообщений могут использовать одно вложение своего чата.
S3 app-user разрешены ListBucket/GetBucketLocation и object CRUD только
`messenger/objects/*`. Root credentials доступны лишь серверу и bootstrap.
Bucket private, S3-порт не опубликован на host, console слушает container
loopback. Авторизованный download проксируется через API; случайный key
не заменяет проверку membership.
Ограничения: полный LIST и выборка metadata имеют стоимость O(objects+rows)
и линейную память reconciler. Ready-проверка использует HEAD, не полный
периодический аудит битовой целостности. Metadata failed сохраняются для
диагностики. Reconciler обнаруживает пропажу bytes, но не восстанавливает
данные из checksum. Единственный Docker-host, LB, PostgreSQL и MinIO —
общие точки отказа; репликация API этого не устраняет.
+152
View File
@@ -0,0 +1,152 @@
name: mtusi-lab4-maslov
services:
postgres:
image: postgres:18.3@sha256:7e32e9833a6fb1c92c32552794cb6ed569d51b445a54907d35fc112ef39684db
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
PGDATA: /var/lib/postgresql/data/pgdata
secrets: [postgres_password]
volumes:
- postgres_data:/var/lib/postgresql
healthcheck:
test: [CMD-SHELL, 'pg_isready -U messenger -d messenger']
interval: 2s
timeout: 2s
retries: 20
cpus: 1
mem_limit: 512m
memswap_limit: 512m
cache:
image: valkey/valkey:8.1.3@sha256:fea8b3e67b15729d4bb70589eb03367bab9ad1ee89c876f54327fc7c6e618571
command: [valkey-server, /run/secrets/valkey.conf]
secrets:
- cache_password
- source: valkey_config
target: valkey.conf
healthcheck:
test: [CMD-SHELL, 'REDISCLI_AUTH="$$(cat /run/secrets/cache_password)" valkey-cli ping']
interval: 2s
timeout: 2s
retries: 20
cpus: 0.25
mem_limit: 128m
memswap_limit: 128m
migrate:
image: ${API_IMAGE:-mtusi-messenger:lab4}
pull_policy: never
command: [python, -m, src.migrate]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
secrets: [database_url]
depends_on:
postgres: {condition: service_healthy}
cpus: 0.5
mem_limit: 256m
read_only: true
api:
image: ${API_IMAGE:-mtusi-messenger:lab4}
build:
context: .
args:
VCS_REF: ${VCS_REF:-unknown}
scale: ${API_REPLICAS:-2}
environment:
APP_HOST: 0.0.0.0
APP_PORT: 8080
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
S3_ACCESS_KEY_FILE: /run/secrets/s3_access_key
S3_SECRET_KEY_FILE: /run/secrets/s3_secret_key
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
DB_POOL_SIZE: ${DB_POOL_SIZE:-10}
secrets: [database_url, cache_url, s3_access_key, s3_secret_key]
depends_on:
migrate: {condition: service_completed_successfully}
cache: {condition: service_healthy}
s3-bootstrap: {condition: service_completed_successfully}
cpus: ${API_CPUS:-0.5}
mem_limit: ${API_MEMORY:-384m}
memswap_limit: ${API_MEMORY:-384m}
pids_limit: 128
read_only: true
tmpfs: ["/tmp:rw,noexec,nosuid,size=128m"]
cap_drop: [ALL]
security_opt: [no-new-privileges:true]
stop_grace_period: 10s
s3:
image: ${S3_IMAGE:-mtusi-storage:minio-20251015}
build: {context: ., dockerfile: infra/s3.Dockerfile, target: server}
secrets: [s3_root_user, s3_root_password]
volumes: [s3_data:/data]
cpus: 1
mem_limit: 1024m
memswap_limit: 1024m
read_only: true
tmpfs: ["/tmp:rw,nosuid,size=32m"]
environment:
HOME: /tmp
security_opt: [no-new-privileges:true]
s3-bootstrap:
image: ${MC_IMAGE:-mtusi-storage:mc-20250813}
build: {context: ., dockerfile: infra/s3.Dockerfile, target: bootstrap}
secrets: [s3_root_user, s3_root_password, s3_access_key, s3_secret_key]
depends_on:
s3: {condition: service_healthy}
cpus: 0.25
mem_limit: 128m
read_only: true
tmpfs: ["/tmp:rw,nosuid,size=16m"]
reconciler:
image: ${API_IMAGE:-mtusi-messenger:lab4}
pull_policy: never
command: [python, -m, src.reconcile, --apply, --loop]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
S3_ACCESS_KEY_FILE: /run/secrets/s3_access_key
S3_SECRET_KEY_FILE: /run/secrets/s3_secret_key
RECONCILE_GRACE_SECONDS: ${RECONCILE_GRACE_SECONDS:-300}
secrets: [database_url, s3_access_key, s3_secret_key]
depends_on:
migrate: {condition: service_completed_successfully}
s3-bootstrap: {condition: service_completed_successfully}
cpus: 0.25
mem_limit: 256m
memswap_limit: 256m
read_only: true
healthcheck: {disable: true}
lb:
image: haproxy:3.2.1-alpine@sha256:ac79fe145f2bb6626ff26b584a2d0a34e791906c01015f2ae037aa3137b683d9
ports:
- "127.0.0.1:${PUBLIC_PORT:-8084}:8080"
volumes:
- ./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
depends_on:
api: {condition: service_healthy}
cpus: 0.5
mem_limit: 128m
memswap_limit: 128m
read_only: true
tmpfs: ["/tmp:rw,nosuid,size=4m"]
security_opt: [no-new-privileges:true]
stop_grace_period: 10s
secrets:
s3_root_user: {file: ./secrets/s3_root_user}
s3_root_password: {file: ./secrets/s3_root_password}
s3_access_key: {file: ./secrets/s3_access_key}
s3_secret_key: {file: ./secrets/s3_secret_key}
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
cache_password:
file: ./secrets/cache_password
cache_url:
file: ./secrets/cache_url
valkey_config:
file: ./secrets/valkey.conf
name: valkey.conf
volumes:
s3_data:
postgres_data:
+11
View File
@@ -0,0 +1,11 @@
{
"date": "2026-11-15T18:42:26.500607+00:00",
"source_commit": "869cff59d9878ce98640a71382c79e5f94c2bf76",
"fresh_secrets_environment_and_volumes": true,
"command": "python scripts/verify_clean.py",
"fixed_host_port_for_restart": 49840,
"static_checks": ".venv/bin/python scripts/check_contract.py\nPASS: offline skeleton structure, local refs and Python syntax; application NOT tested.\n.venv/bin/python scripts/validate_openapi.py\nPASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.\n<home>/.local/bin/uv run --locked ruff format src student-tests scripts/bootstrap.py scripts/stand.py scripts/cluster.py scripts/verify_clean.py scripts/verify_cluster.py scripts/verify_storage.py\n32 files left unchanged\n<home>/.local/bin/uv run --locked ruff check src student-tests scripts/bootstrap.py scripts/stand.py scripts/cluster.py scripts/verify_clean.py scripts/verify_cluster.py scripts/verify_storage.py\nAll checks passed!",
"smoke": "python3 tests/smoke.py --base-url \"http://127.0.0.1:49840\" \nPASS: lab4 public API scenario; infrastructure and grading evidence remain separate.",
"failed_action": ".venv/bin/pytest student-tests -q",
"result": "INCOMPLETE"
}
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+271
View File
@@ -0,0 +1,271 @@
{
"date": "2026-11-15T18:28:56.018046+00:00",
"source_commit": "3fd912fccb761d7010783363fa49337542ffa4e0",
"complete": true,
"cells": [
{
"extra_objects": 0,
"repetition": 1,
"apply": false,
"grace_seconds": 3600,
"objects_scanned": 26,
"rows_scanned": 30,
"head_requests": 8,
"bytes_read": 0,
"fresh_protected": 26,
"ready_protected": 8,
"linked_protected": 0,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.189185,
"complete": true,
"cpu_seconds": 0.039170499000000136,
"rss_peak_bytes": 61718528,
"cgroup_memory_peak_bytes": 43945984
},
{
"extra_objects": 0,
"repetition": 2,
"apply": false,
"grace_seconds": 3600,
"objects_scanned": 26,
"rows_scanned": 30,
"head_requests": 8,
"bytes_read": 0,
"fresh_protected": 26,
"ready_protected": 8,
"linked_protected": 0,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.210146,
"complete": true,
"cpu_seconds": 0.05308141700000002,
"rss_peak_bytes": 61693952,
"cgroup_memory_peak_bytes": 43950080
},
{
"extra_objects": 0,
"repetition": 3,
"apply": false,
"grace_seconds": 3600,
"objects_scanned": 26,
"rows_scanned": 30,
"head_requests": 8,
"bytes_read": 0,
"fresh_protected": 26,
"ready_protected": 8,
"linked_protected": 0,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.193719,
"complete": true,
"cpu_seconds": 0.036812661999999996,
"rss_peak_bytes": 61718528,
"cgroup_memory_peak_bytes": 44134400
},
{
"extra_objects": 100,
"repetition": 1,
"apply": false,
"grace_seconds": 3600,
"objects_scanned": 126,
"rows_scanned": 30,
"head_requests": 8,
"bytes_read": 0,
"fresh_protected": 126,
"ready_protected": 8,
"linked_protected": 0,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.19667,
"complete": true,
"cpu_seconds": 0.03935812599999999,
"rss_peak_bytes": 62033920,
"cgroup_memory_peak_bytes": 43622400
},
{
"extra_objects": 100,
"repetition": 2,
"apply": false,
"grace_seconds": 3600,
"objects_scanned": 126,
"rows_scanned": 30,
"head_requests": 8,
"bytes_read": 0,
"fresh_protected": 126,
"ready_protected": 8,
"linked_protected": 0,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.210975,
"complete": true,
"cpu_seconds": 0.05283020999999999,
"rss_peak_bytes": 61865984,
"cgroup_memory_peak_bytes": 44126208
},
{
"extra_objects": 100,
"repetition": 3,
"apply": false,
"grace_seconds": 3600,
"objects_scanned": 126,
"rows_scanned": 30,
"head_requests": 8,
"bytes_read": 0,
"fresh_protected": 126,
"ready_protected": 8,
"linked_protected": 0,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.204344,
"complete": true,
"cpu_seconds": 0.05048583700000009,
"rss_peak_bytes": 61677568,
"cgroup_memory_peak_bytes": 43831296
},
{
"extra_objects": 1100,
"repetition": 1,
"apply": false,
"grace_seconds": 3600,
"objects_scanned": 1126,
"rows_scanned": 30,
"head_requests": 8,
"bytes_read": 0,
"fresh_protected": 1126,
"ready_protected": 8,
"linked_protected": 0,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.409094,
"complete": true,
"cpu_seconds": 0.0955386250000001,
"rss_peak_bytes": 62730240,
"cgroup_memory_peak_bytes": 44974080
},
{
"extra_objects": 1100,
"repetition": 2,
"apply": false,
"grace_seconds": 3600,
"objects_scanned": 1126,
"rows_scanned": 30,
"head_requests": 8,
"bytes_read": 0,
"fresh_protected": 1126,
"ready_protected": 8,
"linked_protected": 0,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.391053,
"complete": true,
"cpu_seconds": 0.09063437099999994,
"rss_peak_bytes": 62652416,
"cgroup_memory_peak_bytes": 45195264
},
{
"extra_objects": 1100,
"repetition": 3,
"apply": false,
"grace_seconds": 3600,
"objects_scanned": 1126,
"rows_scanned": 30,
"head_requests": 8,
"bytes_read": 0,
"fresh_protected": 1126,
"ready_protected": 8,
"linked_protected": 0,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.610401,
"complete": true,
"cpu_seconds": 0.10586249599999986,
"rss_peak_bytes": 62672896,
"cgroup_memory_peak_bytes": 44793856
}
],
"warmups": [
{
"extra_objects": 0,
"apply": false,
"grace_seconds": 3600,
"objects_scanned": 26,
"rows_scanned": 30,
"head_requests": 8,
"bytes_read": 0,
"fresh_protected": 26,
"ready_protected": 8,
"linked_protected": 0,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.20732,
"complete": true,
"cpu_seconds": 0.05440116500000003,
"rss_peak_bytes": 61632512,
"cgroup_memory_peak_bytes": 44158976
},
{
"extra_objects": 100,
"apply": false,
"grace_seconds": 3600,
"objects_scanned": 126,
"rows_scanned": 30,
"head_requests": 8,
"bytes_read": 0,
"fresh_protected": 126,
"ready_protected": 8,
"linked_protected": 0,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.198799,
"complete": true,
"cpu_seconds": 0.04178633399999998,
"rss_peak_bytes": 61964288,
"cgroup_memory_peak_bytes": 43732992
},
{
"extra_objects": 1100,
"apply": false,
"grace_seconds": 3600,
"objects_scanned": 1126,
"rows_scanned": 30,
"head_requests": 8,
"bytes_read": 0,
"fresh_protected": 1126,
"ready_protected": 8,
"linked_protected": 0,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.31776,
"complete": true,
"cpu_seconds": 0.08349883400000002,
"rss_peak_bytes": 62627840,
"cgroup_memory_peak_bytes": 45318144
}
],
"method": "0/100/1100 extra fresh one-byte objects; one warmup then 3 repeats per dataset; real reconciler service .25 CPU/256MiB; grace3600; 8 PNG fixtures with deliberately aged PG metadata (2days); other runtime objects remain real",
"fixture_rows": 8,
"grace_seconds": 3600,
"stable_rows_head_bytes": [
30,
8,
0
],
"median_seconds": {
"0": 0.193719,
"100": 0.204344,
"1100": 0.409094
}
}
+17
View File
@@ -0,0 +1,17 @@
{
"date": "2026-11-15T18:04:52.576254+00:00",
"source_commit": "f5a7a74f679d936d851fa0e58f6cfb59dcd62c50",
"result": "PASS",
"smoke": {
"command": "make test PYTHON=.venv/bin/python BASE_URL=http://127.0.0.1:8084",
"seconds": 8.702,
"exit_code": 0,
"output": ".venv/bin/python tests/smoke.py --base-url \"http://127.0.0.1:8084\" \nPASS: lab4 public API scenario; infrastructure and grading evidence remain separate.\n"
},
"http": {
"command": ".venv/bin/pytest student-tests -q",
"seconds": 362.959,
"exit_code": 0,
"output": "........................................................................ [ 66%]\n.................................... [100%]\n108 passed in 362.40s (0:06:02)\n"
}
}
+23
View File
@@ -0,0 +1,23 @@
{
"date": "2026-11-15T17:40:32.062021+00:00",
"source_commit": "fba6b6334e32653bf38576ec7e4dbff4e0626034",
"runtime_image_revision": "f449033e15f989aeaf35c776245cb4286e1f0ed5",
"command": "docker compose run --rm --no-deps migrate; repeat",
"migrations": [
{
"name": "001_core.sql",
"checksum": "4f91a73b92b768c48703b1adc1752b8c65f5e9da3da7c1f8b2db6d3dcb3c9efe"
},
{
"name": "002_idempotency.sql",
"checksum": "b24f77687546b4f8d68cabb7009fc2b3db3d138c3c7a1eab32357e41cc0d6b13"
},
{
"name": "003_attachments.sql",
"checksum": "6558f17559d4f96878400915d80a09a1fe5e9bcf7eeb6b0b04794d63ba03f3bd"
}
],
"fresh_postgres_volume": true,
"repeat_idempotent": true,
"result": "PASS"
}
+92
View File
@@ -0,0 +1,92 @@
{
"source_origin": {
"VCS": "git",
"URL": "https://github.com/minio/minio",
"Hash": "9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a"
},
"version": "v0.0.0-20251015172955-9e49d5e7a648",
"module_checksum": "h1:6TdolSCLSs2nwm8i0PpWDqf9iX2Ty9WQK8wmr7dCnUM=",
"go_mod_checksum": "h1:yCWDkwWO9IWpGsT4mreDDN/B/QVmK2zC666uInRAcqE=",
"validation": "standard go mod download with default Go checksum database after ranged HTTPS download",
"compiler_build_status": "PASS",
"runtime_version": "minio version RELEASE.2025-10-15T17-29-55Z (commit-id=9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a)\nRuntime: go1.24.8 linux/arm64\nLicense: GNU AGPLv3 - https://www.gnu.org/licenses/agpl-3.0.html\nCopyright: 2015-0000 MinIO, Inc.",
"runtime_snapshot": [
{
"role": "api",
"container": "c9c495521bf2",
"pid": 39030,
"started_at": "2026-11-15T18:03:15.404279669Z",
"ports": {},
"cpu_nano": 500000000,
"memory_limit": 805306368,
"instance": "e91b8ff7122d4842abb3aa0ff38e0352"
},
{
"role": "api",
"container": "2af84f3c87dd",
"pid": 39163,
"started_at": "2026-11-15T18:03:15.735686586Z",
"ports": {},
"cpu_nano": 500000000,
"memory_limit": 805306368,
"instance": "17cd27ba20064c5eb9580379e963f419"
},
{
"role": "cache",
"container": "e33ddf35f293",
"pid": 5356,
"started_at": "2026-11-15T17:39:31.281698344Z",
"ports": {},
"cpu_nano": 250000000,
"memory_limit": 134217728
},
{
"role": "lb",
"container": "6d7d02d323ed",
"pid": 39796,
"started_at": "2026-11-15T18:03:26.954206841Z",
"ports": {
"8080/tcp": [
{
"HostIp": "127.0.0.1",
"HostPort": "8084"
}
]
},
"cpu_nano": 500000000,
"memory_limit": 134217728
},
{
"role": "postgres",
"container": "a5ffac5a4228",
"pid": 5418,
"started_at": "2026-11-15T17:39:31.614022427Z",
"ports": {},
"cpu_nano": 1000000000,
"memory_limit": 536870912
},
{
"role": "reconciler",
"container": "c94b86137075",
"pid": 39092,
"started_at": "2026-11-15T18:03:15.578851294Z",
"ports": {},
"cpu_nano": 250000000,
"memory_limit": 268435456
},
{
"role": "s3",
"container": "acc08930aff2",
"pid": 38412,
"started_at": "2026-11-15T18:03:03.039434803Z",
"ports": {},
"cpu_nano": 1000000000,
"memory_limit": 1073741824
}
],
"runtime_image_revision": {
"api": "f5a7a74f679d936d851fa0e58f6cfb59dcd62c50",
"s3": "9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a",
"bootstrap": "7394ce0dd2a80935aded936b09fa12cbb3cb8096"
}
}
@@ -0,0 +1,102 @@
Traceback (most recent call last):
File "<repository>/scripts/verify_clean.py", line 215, in <module>
main()
~~~~^^
File "<repository>/scripts/verify_clean.py", line 130, in main
receipt["http_tests"] = run(
~~~^
[".venv/bin/pytest", "student-tests", "-q"], cwd=clone, env=env
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
)
^
File "<repository>/scripts/verify_clean.py", line 55, in run
raise RuntimeError(redact(result.stdout + result.stderr))
RuntimeError: ...........................................................F............ [ 66%]
.................................... [100%]
=================================== FAILURES ===================================
____________________________ test_registration_race ____________________________
client = <httpx.Client object at 0x120c15790>
def test_registration_race(client):
username = "race_" + uuid4().hex[:20]
barrier = threading.Barrier(10)
def worker(_):
with httpx.Client(
base_url=BASE_URL, timeout=15, trust_env=False
) as conn:
barrier.wait(timeout=15)
result = conn.post(
"/api/v1/users",
json={
"username": username,
"display_name": "Test",
"password": PASSWORD,
},
)
check(
result,
result.status_code,
"User" if result.status_code == 201 else "Error",
)
return result.status_code
with ThreadPoolExecutor(max_workers=10) as pool:
> statuses = list(pool.map(worker, range(10)))
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
student-tests/test_api.py:406:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
<home>/.local/share/uv/python/cpython-3.14.7-macos-aarch64-none/lib/python3.14/concurrent/futures/_base.py:645: in result_iterator
yield _result_or_cancel(fs.pop())
^^^^^^^^^^^^^^^^^^^^^^^^^^^
<home>/.local/share/uv/python/cpython-3.14.7-macos-aarch64-none/lib/python3.14/concurrent/futures/_base.py:312: in _result_or_cancel
return fut.result(timeout)
^^^^^^^^^^^^^^^^^^^
<home>/.local/share/uv/python/cpython-3.14.7-macos-aarch64-none/lib/python3.14/concurrent/futures/_base.py:454: in result
return self.__get_result()
^^^^^^^^^^^^^^^^^^^
<home>/.local/share/uv/python/cpython-3.14.7-macos-aarch64-none/lib/python3.14/concurrent/futures/_base.py:396: in __get_result
raise self._exception
<home>/.local/share/uv/python/cpython-3.14.7-macos-aarch64-none/lib/python3.14/concurrent/futures/thread.py:86: in run
result = ctx.run(self.task)
^^^^^^^^^^^^^^^^^^
<home>/.local/share/uv/python/cpython-3.14.7-macos-aarch64-none/lib/python3.14/concurrent/futures/thread.py:73: in run
return fn(*args, **kwargs)
^^^^^^^^^^^^^^^^^^^
student-tests/test_api.py:398: in worker
check(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
result = <Response [503 Service Unavailable]>, status = 503, schema = 'Error'
def check(result: httpx.Response, status: int, schema: str) -> dict:
assert result.status_code == status, result.text
assert result.headers["x-request-id"]
assert result.headers["x-instance-id"]
assert result.headers["content-type"].startswith("application/json")
payload = result.json()
spec = {"$ref": f"#/components/schemas/{schema}", **CONTRACT}
Draft202012Validator(spec, format_checker=FormatChecker()).validate(
payload
)
if schema == "Error":
assert payload["error"]["request_id"] == result.headers["x-request-id"]
assert (
payload["error"]["code"]
> == {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
500: "internal_error",
}[status]
)
E KeyError: 503
student-tests/conftest.py:32: KeyError
=========================== short test summary info ============================
FAILED student-tests/test_api.py::test_registration_race - KeyError: 503
1 failed, 107 passed in 377.89s (0:06:17)
+67
View File
@@ -0,0 +1,67 @@
{
"source_commit": "78670b9fa67202ddc26570daa245c75d1837991a",
"date": "2026-11-15T19:00:28.275924+00:00",
"complete": true,
"runs": [
{
"repeat": 1,
"seconds": 1.6275634999910835,
"exit_code": 0,
"output": ". [100%]\n1 passed in 1.17s\n"
},
{
"repeat": 2,
"seconds": 1.1972682919877116,
"exit_code": 0,
"output": ". [100%]\n1 passed in 0.83s\n"
},
{
"repeat": 3,
"seconds": 1.2752694170048926,
"exit_code": 0,
"output": ". [100%]\n1 passed in 0.90s\n"
},
{
"repeat": 4,
"seconds": 1.3356571669864934,
"exit_code": 0,
"output": ". [100%]\n1 passed in 0.97s\n"
},
{
"repeat": 5,
"seconds": 1.1046671249787323,
"exit_code": 0,
"output": ". [100%]\n1 passed in 0.74s\n"
},
{
"repeat": 6,
"seconds": 1.2911863749905024,
"exit_code": 0,
"output": ". [100%]\n1 passed in 0.93s\n"
},
{
"repeat": 7,
"seconds": 1.6777148330002092,
"exit_code": 0,
"output": ". [100%]\n1 passed in 1.32s\n"
},
{
"repeat": 8,
"seconds": 1.4123140000156127,
"exit_code": 0,
"output": ". [100%]\n1 passed in 1.03s\n"
},
{
"repeat": 9,
"seconds": 1.2036787920224015,
"exit_code": 0,
"output": ". [100%]\n1 passed in 0.83s\n"
},
{
"repeat": 10,
"seconds": 1.2103008750127628,
"exit_code": 0,
"output": ". [100%]\n1 passed in 0.84s\n"
}
]
}
+502
View File
@@ -0,0 +1,502 @@
{
"source_commit": "f5a7a74f679d936d851fa0e58f6cfb59dcd62c50",
"date": "2026-11-15T18:13:30.360880+00:00",
"complete": true,
"runtime": [
{
"role": "api",
"container": "c9c495521bf2",
"pid": 39030,
"started_at": "2026-11-15T18:03:15.404279669Z",
"ports": {},
"cpu_nano": 500000000,
"memory_limit": 805306368,
"instance": "e91b8ff7122d4842abb3aa0ff38e0352"
},
{
"role": "api",
"container": "2af84f3c87dd",
"pid": 39163,
"started_at": "2026-11-15T18:03:15.735686586Z",
"ports": {},
"cpu_nano": 500000000,
"memory_limit": 805306368,
"instance": "17cd27ba20064c5eb9580379e963f419"
},
{
"role": "cache",
"container": "e33ddf35f293",
"pid": 5356,
"started_at": "2026-11-15T17:39:31.281698344Z",
"ports": {},
"cpu_nano": 250000000,
"memory_limit": 134217728
},
{
"role": "lb",
"container": "6d7d02d323ed",
"pid": 39796,
"started_at": "2026-11-15T18:03:26.954206841Z",
"ports": {
"8080/tcp": [
{
"HostIp": "127.0.0.1",
"HostPort": "8084"
}
]
},
"cpu_nano": 500000000,
"memory_limit": 134217728
},
{
"role": "postgres",
"container": "a5ffac5a4228",
"pid": 5418,
"started_at": "2026-11-15T17:39:31.614022427Z",
"ports": {},
"cpu_nano": 1000000000,
"memory_limit": 536870912
},
{
"role": "reconciler",
"container": "c94b86137075",
"pid": 39092,
"started_at": "2026-11-15T18:03:15.578851294Z",
"ports": {},
"cpu_nano": 250000000,
"memory_limit": 268435456
},
{
"role": "s3",
"container": "acc08930aff2",
"pid": 38412,
"started_at": "2026-11-15T18:03:03.039434803Z",
"ports": {},
"cpu_nano": 1000000000,
"memory_limit": 1073741824
}
],
"upload_replica_stopped_downloaded_elsewhere": {
"stopped_container": "2af84f3c87dd",
"uploader": "17cd27ba20064c5eb9580379e963f419",
"downloader": "e91b8ff7122d4842abb3aa0ff38e0352",
"sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75"
},
"private_bucket_and_iam": {
"denied_head_is_not_missing": 503,
"anonymous_get": 403,
"list_other_bucket": "AccessDenied",
"create_bucket": "AccessDenied",
"write_outside_prefix": "AccessDenied",
"console_internal_network": "unreachable"
},
"bootstrap_repeat_preserved_original": true,
"aborted_upload_has_no_intent_or_bytes": true,
"pg_intent_failure_has_no_bytes": true,
"s3_unavailable": {
"status": 503,
"error": "unavailable"
},
"concurrent_uploads": {
"concurrency": 10,
"requests": 10,
"successes": 10,
"errors": 0,
"bytes_per_image": 6017095,
"pixels": 2890000,
"duration_seconds": 5.149,
"successful_rps": 1.942,
"latency_scope": "upload only; duration includes verified downloads and memory sampler",
"p50_ms": 2162.965,
"p95_ms": 4465.512,
"p99_ms": 4465.512,
"cpu_before": {
"c9c495521bf2e0eb21d94eebc8ac06ea3735ee282401f8bbf4918203b05e69ea": "usage_usec 148242470\nuser_usec 139413925\nsystem_usec 8828544\nnice_usec 0\nnr_periods 5268\nnr_throttled 2720\nthrottled_usec 566509749\nnr_bursts 0\nburst_usec 0",
"2af84f3c87dd51105775135adaa2864b852c68c3b3d929f566d714ee4bbf13a2": "usage_usec 7938759\nuser_usec 7311622\nsystem_usec 627137\nnice_usec 0\nnr_periods 338\nnr_throttled 144\nthrottled_usec 17342812\nnr_bursts 0\nburst_usec 0"
},
"cpu_after": {
"c9c495521bf2e0eb21d94eebc8ac06ea3735ee282401f8bbf4918203b05e69ea": "usage_usec 150694911\nuser_usec 141253264\nsystem_usec 9441647\nnice_usec 0\nnr_periods 5320\nnr_throttled 2767\nthrottled_usec 573793811\nnr_bursts 0\nburst_usec 0",
"2af84f3c87dd51105775135adaa2864b852c68c3b3d929f566d714ee4bbf13a2": "usage_usec 9567439\nuser_usec 8568377\nsystem_usec 999061\nnice_usec 0\nnr_periods 386\nnr_throttled 171\nthrottled_usec 20452342\nnr_bursts 0\nburst_usec 0"
},
"memory_samples": [
{
"at": 0.0,
"container": "c9c495521bf2",
"memory.current": 128004096,
"memory.peak": 215093248
},
{
"at": 0.931,
"container": "2af84f3c87dd",
"memory.current": 128983040,
"memory.peak": 152731648
},
{
"at": 2.318,
"container": "c9c495521bf2",
"memory.current": 163500032,
"memory.peak": 215093248
},
{
"at": 3.846,
"container": "2af84f3c87dd",
"memory.current": 126009344,
"memory.peak": 152731648
},
{
"at": 4.515,
"container": "c9c495521bf2",
"memory.current": 153980928,
"memory.peak": 215093248
},
{
"at": 4.862,
"container": "2af84f3c87dd",
"memory.current": 125583360,
"memory.peak": 152731648
}
],
"results": [
{
"id": "7df54468-dffb-48e1-b435-bb64e73b087c",
"latency_ms": 774.2156249878462,
"instance": "ba0474b668fd43b294ece08957bf0648"
},
{
"id": "e1ba3763-89f2-497f-a152-6008f4737e08",
"latency_ms": 1630.1402079989202,
"instance": "e91b8ff7122d4842abb3aa0ff38e0352"
},
{
"id": "69c854d8-ca53-46aa-9dbd-646b68bc42be",
"latency_ms": 3091.3296249927953,
"instance": "e91b8ff7122d4842abb3aa0ff38e0352"
},
{
"id": "03328959-bf30-4e57-a233-4084e599bbfc",
"latency_ms": 2098.3562500041444,
"instance": "e91b8ff7122d4842abb3aa0ff38e0352"
},
{
"id": "483eff54-3137-4764-bc89-3feccf7d00e6",
"latency_ms": 4303.714374982519,
"instance": "e91b8ff7122d4842abb3aa0ff38e0352"
},
{
"id": "f4eb43f0-65bf-462c-bfd2-9c8d88ff1d34",
"latency_ms": 1105.6364579999354,
"instance": "e91b8ff7122d4842abb3aa0ff38e0352"
},
{
"id": "90a80cf9-d955-4bcc-9f16-01587a3f2f66",
"latency_ms": 3825.5119579844177,
"instance": "e91b8ff7122d4842abb3aa0ff38e0352"
},
{
"id": "3e2a2c9c-4204-4883-b18a-5b1deeca70c3",
"latency_ms": 2162.9652910050936,
"instance": "ba0474b668fd43b294ece08957bf0648"
},
{
"id": "ea4b8e91-80fe-4741-8d0b-c77d2da6656f",
"latency_ms": 4465.512333001243,
"instance": "e91b8ff7122d4842abb3aa0ff38e0352"
},
{
"id": "031a9c2b-4c93-4dd4-935b-8104080a0a86",
"latency_ms": 1169.7680839861277,
"instance": "ba0474b668fd43b294ece08957bf0648"
}
],
"window_max_memory_current": 163500032,
"lifetime_memory_peak": 215093248
},
"reconciliation": {
"dry_run": {
"apply": false,
"grace_seconds": 300,
"objects_scanned": 20,
"rows_scanned": 20,
"head_requests": 8,
"bytes_read": 111817,
"fresh_protected": 13,
"ready_protected": 5,
"linked_protected": 0,
"actions": {
"delete_orphan": 1,
"recover_pending": 1,
"fail_pending_missing": 1,
"delete_failed_object": 1,
"mark_missing": 1
},
"applied": {},
"details": [
{
"action": "delete_orphan",
"identity": "objects/verification-f49e0d70d0f54f62bce62b4a3dccdbdc/orphan"
},
{
"action": "recover_pending",
"identity": "06e24ef9-2a84-43d1-bc08-facf33155e9f"
},
{
"action": "fail_pending_missing",
"identity": "44b0d154-ed76-4f79-a356-7feb85a3b14c"
},
{
"action": "delete_failed_object",
"identity": "54e914d0-5a4c-4dc9-982c-ef887467700c"
},
{
"action": "mark_missing",
"identity": "fa66fcd8-ca7e-41e4-8f25-25ff119c38e9"
}
],
"duration_seconds": 0.0604,
"complete": true
},
"apply": {
"apply": true,
"grace_seconds": 300,
"objects_scanned": 20,
"rows_scanned": 20,
"head_requests": 10,
"bytes_read": 111817,
"fresh_protected": 13,
"ready_protected": 5,
"linked_protected": 0,
"actions": {
"delete_orphan": 1,
"recover_pending": 1,
"fail_pending_missing": 1,
"delete_failed_object": 1,
"mark_missing": 1
},
"applied": {
"delete_orphan": 1,
"recover_pending": 1,
"fail_pending_missing": 1,
"delete_failed_object": 1,
"mark_missing": 1
},
"details": [
{
"action": "delete_orphan",
"identity": "objects/verification-f49e0d70d0f54f62bce62b4a3dccdbdc/orphan"
},
{
"action": "recover_pending",
"identity": "06e24ef9-2a84-43d1-bc08-facf33155e9f"
},
{
"action": "fail_pending_missing",
"identity": "44b0d154-ed76-4f79-a356-7feb85a3b14c"
},
{
"action": "delete_failed_object",
"identity": "54e914d0-5a4c-4dc9-982c-ef887467700c"
},
{
"action": "mark_missing",
"identity": "fa66fcd8-ca7e-41e4-8f25-25ff119c38e9"
}
],
"duration_seconds": 0.106004,
"complete": true
},
"repeat": {
"apply": true,
"grace_seconds": 300,
"objects_scanned": 18,
"rows_scanned": 20,
"head_requests": 6,
"bytes_read": 0,
"fresh_protected": 13,
"ready_protected": 6,
"linked_protected": 1,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.102749,
"complete": true
},
"s3_grace_wait_seconds": 331.301,
"fresh_and_ready_unlinked_protected": true,
"old_failed_unlinked_deleted_and_fresh_failed_protected": true,
"missing_used_id_and_link_preserved": true,
"dry_run_unchanged": true
},
"cost_research": {
"cells": [
{
"extra_objects": 0,
"repetition": 1,
"apply": false,
"grace_seconds": 300,
"objects_scanned": 18,
"rows_scanned": 20,
"head_requests": 6,
"bytes_read": 0,
"fresh_protected": 13,
"ready_protected": 6,
"linked_protected": 1,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.183485,
"complete": true
},
{
"extra_objects": 0,
"repetition": 2,
"apply": false,
"grace_seconds": 300,
"objects_scanned": 18,
"rows_scanned": 20,
"head_requests": 6,
"bytes_read": 0,
"fresh_protected": 13,
"ready_protected": 6,
"linked_protected": 1,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.043382,
"complete": true
},
{
"extra_objects": 0,
"repetition": 3,
"apply": false,
"grace_seconds": 300,
"objects_scanned": 18,
"rows_scanned": 20,
"head_requests": 6,
"bytes_read": 0,
"fresh_protected": 13,
"ready_protected": 6,
"linked_protected": 1,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.046774,
"complete": true
},
{
"extra_objects": 100,
"repetition": 1,
"apply": false,
"grace_seconds": 300,
"objects_scanned": 118,
"rows_scanned": 20,
"head_requests": 6,
"bytes_read": 0,
"fresh_protected": 112,
"ready_protected": 6,
"linked_protected": 1,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.078726,
"complete": true
},
{
"extra_objects": 100,
"repetition": 2,
"apply": false,
"grace_seconds": 300,
"objects_scanned": 118,
"rows_scanned": 20,
"head_requests": 6,
"bytes_read": 0,
"fresh_protected": 112,
"ready_protected": 6,
"linked_protected": 1,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.088476,
"complete": true
},
{
"extra_objects": 100,
"repetition": 3,
"apply": false,
"grace_seconds": 300,
"objects_scanned": 118,
"rows_scanned": 20,
"head_requests": 6,
"bytes_read": 0,
"fresh_protected": 112,
"ready_protected": 6,
"linked_protected": 1,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.206964,
"complete": true
},
{
"extra_objects": 1100,
"repetition": 1,
"apply": false,
"grace_seconds": 300,
"objects_scanned": 1118,
"rows_scanned": 20,
"head_requests": 6,
"bytes_read": 0,
"fresh_protected": 1112,
"ready_protected": 6,
"linked_protected": 1,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.197227,
"complete": true
},
{
"extra_objects": 1100,
"repetition": 2,
"apply": false,
"grace_seconds": 300,
"objects_scanned": 1118,
"rows_scanned": 20,
"head_requests": 10,
"bytes_read": 0,
"fresh_protected": 1108,
"ready_protected": 10,
"linked_protected": 1,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.145977,
"complete": true
},
{
"extra_objects": 1100,
"repetition": 3,
"apply": false,
"grace_seconds": 300,
"objects_scanned": 1118,
"rows_scanned": 20,
"head_requests": 16,
"bytes_read": 0,
"fresh_protected": 1102,
"ready_protected": 16,
"linked_protected": 1,
"actions": {},
"applied": {},
"details": [],
"duration_seconds": 0.199997,
"complete": true
}
],
"repeats": 3,
"method": "same running stand; 0/100/1100 fresh one-byte objects; dry-run; serial ascending dataset; no warmup",
"median_seconds": {
"0": 0.046774,
"100": 0.088476,
"1100": 0.197227
}
}
}
Binary file not shown.

After

Width:  |  Height:  |  Size: 80 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 83 KiB

+107
View File
@@ -0,0 +1,107 @@
// Fetch the immutable module ZIP in bounded HTTP ranges. The subsequent
// go mod download validates its h1 checksum through the Go checksum database.
package main
import (
"fmt"
"io"
"net/http"
"os"
"path/filepath"
"sync"
"time"
)
func main() {
const version = "v0.0.0-20251015172955-9e49d5e7a648"
const total int64 = 25342606
const chunk int64 = 512 * 1024
const source = "https://proxy.golang.org/github.com/minio/minio/@v/" + version + ".zip"
directory := "/go/pkg/mod/cache/download/github.com/minio/minio/@v"
if err := os.MkdirAll(directory, 0755); err != nil {
panic(err)
}
target := filepath.Join(directory, version+".zip")
if info, err := os.Stat(target); err == nil && info.Size() == total {
fmt.Println("Source ZIP cached; Go will validate checksum")
return
}
client := &http.Client{Timeout: 90 * time.Second}
jobs := make(chan int64)
errors := make(chan error, 64)
var group sync.WaitGroup
for worker := 0; worker < 8; worker++ {
group.Add(1)
go func() {
defer group.Done()
for start := range jobs {
end := min(start+chunk, total) - 1
part := fmt.Sprintf("%s.part-%d", target, start)
if info, err := os.Stat(part); err == nil && info.Size() == end-start+1 {
continue
}
var last error
for attempt := 0; attempt < 4; attempt++ {
req, _ := http.NewRequest("GET", source, nil)
req.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", start, end))
response, err := client.Do(req)
if err != nil {
last = fmt.Errorf("source range request failed")
continue
}
expected := fmt.Sprintf("bytes %d-%d/%d", start, end, total)
if response.StatusCode != 206 || response.Header.Get("Content-Range") != expected {
response.Body.Close()
last = fmt.Errorf("unexpected source range response: HTTP %d", response.StatusCode)
continue
}
data, err := io.ReadAll(io.LimitReader(response.Body, end-start+2))
response.Body.Close()
if err != nil || int64(len(data)) != end-start+1 {
last = fmt.Errorf("incomplete source range")
continue
}
if err := os.WriteFile(part, data, 0644); err != nil {
last = err
continue
}
last = nil
fmt.Printf("Source part %d verified\n", start/chunk+1)
break
}
if last != nil {
errors <- last
}
}
}()
}
for start := int64(0); start < total; start += chunk {
jobs <- start
}
close(jobs)
group.Wait()
close(errors)
for err := range errors {
panic(err)
}
out, err := os.Create(target + ".partial")
if err != nil {
panic(err)
}
for start := int64(0); start < total; start += chunk {
part, err := os.Open(fmt.Sprintf("%s.part-%d", target, start))
if err != nil {
panic(err)
}
if _, err := io.Copy(out, part); err != nil {
panic(err)
}
part.Close()
}
if err := out.Close(); err != nil {
panic(err)
}
if err := os.Rename(target+".partial", target); err != nil {
panic(err)
}
}
+36
View File
@@ -0,0 +1,36 @@
global
log stdout format raw local0
maxconn 512
stats socket /tmp/admin.sock mode 600 level admin
defaults
mode http
log global
option httplog
timeout connect 1s
timeout client 15s
timeout server 8s
timeout http-request 10s
timeout http-keep-alive 5s
retries 0
resolvers docker
nameserver dns 127.0.0.11:53
resolve_retries 3
timeout resolve 1s
timeout retry 1s
hold valid 1s
hold obsolete 1s
hold nx 1s
frontend public
bind :8080
default_backend messenger
backend messenger
balance roundrobin
option httpchk
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host api
http-check expect status 200
default-server check inter 1s fastinter 250ms fall 2 rise 1 resolvers docker init-addr libc,none resolve-prefer ipv4
server-template api 1-8 api:8080
+14
View File
@@ -0,0 +1,14 @@
#!/bin/sh
set -eu
root_user=$(cat /run/secrets/s3_root_user)
root_password=$(cat /run/secrets/s3_root_password)
api_key=$(cat /run/secrets/s3_access_key)
api_secret=$(cat /run/secrets/s3_secret_key)
# Credentials are passed only inside this isolated bootstrap container.
mc alias set local http://s3:9000 "$root_user" "$root_password" >/dev/null 2>&1
mc mb --ignore-existing local/messenger >/dev/null 2>&1
mc anonymous set none local/messenger >/dev/null 2>&1
mc admin user add local "$api_key" "$api_secret" >/dev/null 2>&1
mc admin policy create local messenger-api /policy.json >/dev/null 2>&1
mc admin policy attach local messenger-api --user "$api_key" >/dev/null 2>&1
printf '%s\n' 'Private bucket and scoped application policy ready'
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
set -eu
export MINIO_ROOT_USER="$(cat /run/secrets/s3_root_user)"
export MINIO_ROOT_PASSWORD="$(cat /run/secrets/s3_root_password)"
export MINIO_BROWSER_REDIRECT_URL=http://127.0.0.1:9001
exec minio server /data --address :9000 --console-address 127.0.0.1:9001
+15
View File
@@ -0,0 +1,15 @@
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:GetBucketLocation", "s3:ListBucket"],
"Resource": ["arn:aws:s3:::messenger"]
},
{
"Effect": "Allow",
"Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
"Resource": ["arn:aws:s3:::messenger/objects/*"]
}
]
}
+49
View File
@@ -0,0 +1,49 @@
FROM golang:1.24.8-bookworm@sha256:4ed690d6649d63c312b99a6120025ec79ce3b542968a37da53d6236c7c61a848 AS toolchain
ENV CGO_ENABLED=0 GOMAXPROCS=2 GOFLAGS=-p=2 GOTOOLCHAIN=local
FROM toolchain AS minio-build
WORKDIR /source
COPY infra/fetch-source.go /tmp/fetch-source.go
RUN --mount=type=cache,target=/go/pkg/mod,sharing=locked \
--mount=type=cache,target=/root/.cache/go-build,sharing=locked \
go run /tmp/fetch-source.go && \
for attempt in 1 2 3 4; do \
go mod download -json github.com/minio/minio@v0.0.0-20251015172955-9e49d5e7a648 && break; \
test "$attempt" -lt 4 || exit 1; sleep 1; \
done && \
cp -a /go/pkg/mod/github.com/minio/minio@v0.0.0-20251015172955-9e49d5e7a648/. /source/
RUN --mount=type=cache,target=/go/pkg/mod,sharing=locked \
--mount=type=cache,target=/root/.cache/go-build,sharing=locked \
for attempt in 1 2 3; do \
timeout 900s go build -trimpath -ldflags='-s -w -X github.com/minio/minio/cmd.Version=2025-10-15T17:29:55Z -X github.com/minio/minio/cmd.ReleaseTag=RELEASE.2025-10-15T17-29-55Z -X github.com/minio/minio/cmd.CommitID=9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a' -o /out/minio . && break; \
test "$attempt" -lt 3 || exit 1; sleep 1; \
done
FROM toolchain AS mc-build
WORKDIR /source
RUN git init . && git remote add origin https://github.com/minio/mc.git && \
git fetch --depth 1 origin 7394ce0dd2a80935aded936b09fa12cbb3cb8096 && git checkout --detach FETCH_HEAD
RUN --mount=type=cache,target=/go/pkg/mod,sharing=locked \
--mount=type=cache,target=/root/.cache/go-build,sharing=locked \
go build -trimpath -ldflags='-s -w' -o /out/mc .
FROM python:3.14.7-slim-trixie@sha256:51dafde81dbdb6ebde285137a295cf18a47ca95234fe388a343719cb97305b3d AS server
LABEL org.opencontainers.image.revision=9e49d5e7a648f00e26f2246f4dc28e6b07f8c84a org.opencontainers.image.version=RELEASE.2025-10-15T17-29-55Z
COPY --from=minio-build /out/minio /usr/local/bin/minio
COPY --from=minio-build /source/LICENSE /licenses/minio.LICENSE
COPY --chmod=755 infra/s3-entrypoint.sh /usr/local/bin/s3-entrypoint
RUN mkdir /data && chown 10001:10001 /data
USER 10001:10001
ENTRYPOINT ["/usr/local/bin/s3-entrypoint"]
EXPOSE 9000
HEALTHCHECK --interval=2s --timeout=2s --start-period=10s --retries=30 CMD ["python","-c","import urllib.request; urllib.request.urlopen('http://127.0.0.1:9000/minio/health/ready',timeout=1).read()"]
FROM python:3.14.7-slim-trixie@sha256:51dafde81dbdb6ebde285137a295cf18a47ca95234fe388a343719cb97305b3d AS bootstrap
LABEL org.opencontainers.image.revision=7394ce0dd2a80935aded936b09fa12cbb3cb8096 org.opencontainers.image.version=RELEASE.2025-08-13T08-35-41Z
COPY --from=mc-build /out/mc /usr/local/bin/mc
COPY --from=mc-build /source/LICENSE /licenses/mc.LICENSE
COPY --chmod=755 infra/s3-bootstrap.sh /usr/local/bin/s3-bootstrap
COPY infra/s3-policy.json /policy.json
USER 10001:10001
ENV MC_CONFIG_DIR=/tmp/mc
ENTRYPOINT ["/usr/local/bin/s3-bootstrap"]
+36
View File
@@ -0,0 +1,36 @@
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100),
password_hash text NOT NULL,
created_at timestamptz NOT NULL
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_at timestamptz NOT NULL
);
CREATE TABLE members (
chat_id uuid NOT NULL REFERENCES chats(id),
user_id uuid NOT NULL REFERENCES users(id),
position integer NOT NULL CHECK (position BETWEEN 0 AND 99),
PRIMARY KEY (chat_id, user_id),
UNIQUE (chat_id, position)
);
CREATE INDEX members_user_chat_idx ON members(user_id,chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id),
sender_id uuid NOT NULL,
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL,
FOREIGN KEY (chat_id, sender_id) REFERENCES members(chat_id,user_id)
);
CREATE INDEX messages_history_idx ON messages(chat_id,created_at,id);
CREATE TABLE sessions (
token_digest bytea PRIMARY KEY CHECK (octet_length(token_digest)=32),
user_id uuid NOT NULL REFERENCES users(id),
created_at timestamptz NOT NULL,
expires_at timestamptz NOT NULL CHECK (expires_at > created_at)
);
CREATE INDEX sessions_expiry_idx ON sessions(expires_at);
+10
View File
@@ -0,0 +1,10 @@
CREATE TABLE idempotency (
user_id uuid NOT NULL REFERENCES users(id),
chat_id uuid NOT NULL REFERENCES chats(id),
key text NOT NULL CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'),
body_hash bytea NOT NULL CHECK (octet_length(body_hash)=32),
message_id uuid NOT NULL REFERENCES messages(id),
expires_at timestamptz NOT NULL,
PRIMARY KEY(user_id, chat_id, key)
);
CREATE INDEX idempotency_expiry_idx ON idempotency(expires_at);
+32
View File
@@ -0,0 +1,32 @@
ALTER TABLE messages DROP CONSTRAINT messages_text_check;
ALTER TABLE messages ADD CHECK (char_length(text) <= 4000);
ALTER TABLE messages ADD UNIQUE(chat_id,id);
CREATE TABLE attachments (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id),
owner_id uuid NOT NULL,
filename text NOT NULL CHECK(char_length(filename) BETWEEN 1 AND 255),
content_type text NOT NULL CHECK(content_type IN ('image/png','image/jpeg')),
size_bytes bigint NOT NULL CHECK(size_bytes BETWEEN 1 AND 10485760),
sha256 text NOT NULL CHECK(sha256 ~ '^[a-f0-9]{64}$'),
object_key text NOT NULL UNIQUE,
state text NOT NULL CHECK(state IN ('pending','ready','failed')),
error_code text,
uploader_instance text NOT NULL,
expires_at timestamptz NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
updated_at timestamptz NOT NULL DEFAULT clock_timestamp(),
UNIQUE(chat_id,id),
FOREIGN KEY(chat_id,owner_id) REFERENCES members(chat_id,user_id)
);
CREATE INDEX attachments_state_created_idx ON attachments(state,created_at,id);
CREATE TABLE message_attachments (
message_id uuid NOT NULL,
chat_id uuid NOT NULL,
attachment_id uuid NOT NULL,
position integer NOT NULL CHECK(position BETWEEN 0 AND 9),
PRIMARY KEY(message_id,attachment_id),
UNIQUE(message_id,position),
FOREIGN KEY(chat_id,message_id) REFERENCES messages(chat_id,id),
FOREIGN KEY(chat_id,attachment_id) REFERENCES attachments(chat_id,id)
);
+37
View File
@@ -0,0 +1,37 @@
[project]
name = "mtusi-messenger-lab4"
version = "1.0.0"
requires-python = ">=3.14,<3.15"
dependencies = [
"fastapi==0.143.3",
"pydantic==2.14.1",
"uvicorn==0.54.0",
"psycopg[binary,pool]==3.3.6",
"argon2-cffi>=25,<26",
"redis==8.1.0",
"minio==7.2.20",
"pillow==13.0.0",
]
[dependency-groups]
dev = ["pytest>=8,<10", "httpx>=0.28,<1", "ruff>=0.14,<1", "openapi-spec-validator==0.7.2", "psutil>=7,<8", "matplotlib>=3.10,<4"]
[tool.ruff]
line-length = 79
target-version = "py314"
include = ["src/**/*.py", "student-tests/**/*.py", "research/**/*.py", "scripts/verify_*.py"]
[tool.ruff.lint]
select = ["E", "F", "I", "B", "UP"]
[tool.ruff.per-file-target-version]
"scripts/*.py" = "py39"
# SQL и генерируемые Markdown-таблицы в инструментах не разрываем.
[tool.ruff.lint.per-file-ignores]
"research/*.py" = ["E501"]
"scripts/*.py" = ["E501"]
[tool.pytest.ini_options]
testpaths = ["student-tests"]
addopts = "-ra"
+64
View File
@@ -0,0 +1,64 @@
"""Plot only measured storage evidence; no reconstructed timing samples."""
import argparse
import json
from pathlib import Path
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
def main():
parser = argparse.ArgumentParser()
parser.add_argument("input")
parser.add_argument("--cost-input")
parser.add_argument("--output", default="evidence/storage-research.png")
args = parser.parse_args()
data = json.loads(Path(args.input).read_text())
assert data["complete"]
series = data["cost_research"]
if args.cost_input:
series = json.loads(Path(args.cost_input).read_text())
assert series["complete"]
fig, axes = plt.subplots(1, 2, figsize=(11, 4), layout="constrained")
for cell in series["cells"]:
axes[0].scatter(
cell["objects_scanned"],
cell["duration_seconds"],
color="#176b87",
alpha=0.65,
)
axes[0].set(
xlabel="Objects scanned (including real attachments)",
ylabel="Dry-run duration, seconds",
title="Inventory cost: 3 repeats per dataset",
)
measured = data["concurrent_uploads"]
ids = sorted({s["container"] for s in measured["memory_samples"]})
for i, cid in enumerate(ids):
points = [
s for s in measured["memory_samples"] if s["container"] == cid
]
axes[1].plot(
[s["at"] for s in points],
[s["memory.current"] / 2**20 for s in points],
label=f"API {i + 1} cgroup current",
marker="o",
markersize=3,
)
axes[1].set(
xlabel="Time, seconds",
ylabel="Memory, MiB",
title="10 simultaneous uploads, verified downloads",
)
axes[1].legend(fontsize=8)
for ax in axes:
ax.grid(alpha=0.2)
fig.savefig(args.output, dpi=160)
print("Saved measured inventory and memory figure")
if __name__ == "__main__":
main()
+159
View File
@@ -0,0 +1,159 @@
"""Controlled inventory experiment on the teaching stand, with own fixtures."""
import argparse
import json
import statistics
from datetime import UTC, datetime
from pathlib import Path
from uuid import uuid4
import httpx
from scripts.stand import BASE, actor, auth, command, compose, ready, sql
from scripts.verify_storage import PNG, PREFIX, inside
def probe():
# Run the actual code with the reconciler service's .25 CPU /256 MiB.
code = (
PREFIX
+ """
import pathlib,resource
started=time.process_time()
result=reconcile(d,s,apply=False,grace=3600)
result['cpu_seconds']=time.process_time()-started
result['rss_peak_bytes']=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss*1024
result['cgroup_memory_peak_bytes']=int(pathlib.Path('/sys/fs/cgroup/memory.peak').read_text())
print(json.dumps(result)); s.close(); d.close()
"""
)
return json.loads(
command(
[
"docker",
"compose",
"run",
"--rm",
"--no-deps",
"-T",
"reconciler",
"python",
"-",
],
input=code,
)
)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--output", default="evidence/cost-repeat.json")
args = parser.parse_args()
output = Path(args.output)
assert not output.exists()
output.parent.mkdir(parents=True, exist_ok=True)
prefix = "objects/cost-" + uuid4().hex + "/"
result = {
"date": datetime.now(UTC).isoformat(),
"source_commit": command(["git", "rev-parse", "HEAD"]),
"complete": False,
"cells": [],
"warmups": [],
"method": "0/100/1100 extra fresh one-byte objects; one warmup then 3 repeats per dataset; real reconciler service .25 CPU/256MiB; grace3600; 8 PNG fixtures with deliberately aged PG metadata (2days); other runtime objects remain real",
"fixture_rows": 8,
"grace_seconds": 3600,
}
chat = None
ready()
compose("stop", "reconciler")
try:
with httpx.Client(
base_url=BASE, trust_env=False, timeout=20
) as client:
user, _, session = actor(client)
r = client.post(
"/api/v1/chats",
headers=auth(session),
json={
"title": "Controlled inventory",
"member_ids": [user["id"]],
},
)
assert r.status_code == 201
chat = r.json()["id"]
seed = f"""
from uuid import uuid4
data=bytes.fromhex({PNG.hex()!r})
for i in range(8):
identity=uuid4(); key={prefix!r}+'ready-'+str(i)
s.put(key=key,stream=io.BytesIO(data),size=len(data),content_type='image/png',sha256=hashlib.sha256(data).hexdigest())
with d.connection() as c:
c.execute("INSERT INTO attachments(id,chat_id,owner_id,filename,content_type,size_bytes,sha256,object_key,state,uploader_instance,expires_at,created_at) VALUES(%s,%s,%s,'fixture.png','image/png',%s,%s,%s,'ready','cost-fixture',clock_timestamp()-interval '1 day',clock_timestamp()-interval '2 days')",(identity,{chat!r},{user["id"]!r},len(data),hashlib.sha256(data).hexdigest(),key))
print('true')
"""
inside(seed)
for count in [0, 100, 1100]:
if count:
start = 0 if count == 100 else 100
inside(
f"\nfor i in range({start},{count}):\n s.put(key={prefix!r}+'extra-'+str(i),stream=io.BytesIO(b'x'),size=1,content_type='application/octet-stream',sha256=hashlib.sha256(b'x').hexdigest())\nprint('true')"
)
result["warmups"].append({"extra_objects": count, **probe()})
for repeat in range(3):
cell = {
"extra_objects": count,
"repetition": repeat + 1,
**probe(),
}
result["cells"].append(cell)
assert cell["complete"] and not cell["applied"]
assert cell["ready_protected"] >= 8
controls = {
(v["rows_scanned"], v["head_requests"], v["bytes_read"])
for v in result["cells"]
}
assert len(controls) == 1, (
"Age boundary changed work; choose a fresh stand"
)
for count in [0, 100, 1100]:
assert (
len(
{
v["objects_scanned"]
for v in result["cells"]
if v["extra_objects"] == count
}
)
== 1
)
result["stable_rows_head_bytes"] = list(next(iter(controls)))
result["median_seconds"] = {
str(n): statistics.median(
v["duration_seconds"]
for v in result["cells"]
if v["extra_objects"] == n
)
for n in [0, 100, 1100]
}
result["complete"] = True
finally:
if chat:
sql(
"DELETE FROM attachments WHERE chat_id='"
+ chat
+ "' AND uploader_instance='cost-fixture'"
)
inside(
f"\nfor o in s.objects():\n if o.object_name.startswith({prefix!r}): s.delete(key=o.object_name)\nprint('true')"
)
compose("up", "-d", "--no-build", "--no-recreate", "reconciler")
output.write_text(
json.dumps(result, ensure_ascii=False, indent=2) + "\n"
)
print(
"PASS: controlled inventory cost, 9 measurements and constant metadata/HEAD work"
)
if __name__ == "__main__":
main()
+51
View File
@@ -0,0 +1,51 @@
"""Создаёт только отсутствующие локальные файлы; секреты не печатает."""
import os
import secrets
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
def create(path, value):
try:
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644)
except FileExistsError:
return
with os.fdopen(fd, "w") as stream:
stream.write(value + "\n")
def main():
directory = ROOT / "secrets"
directory.mkdir(mode=0o700, exist_ok=True)
pg = directory / "postgres_password"
cache = directory / "cache_password"
create(pg, secrets.token_urlsafe(32))
create(cache, secrets.token_urlsafe(32))
create(
directory / "database_url",
"postgresql://messenger:"
+ pg.read_text().strip()
+ "@postgres:5432/messenger",
)
create(
directory / "cache_url",
"redis://:" + cache.read_text().strip() + "@cache:6379/0",
)
create(
directory / "valkey.conf",
"bind 0.0.0.0\nprotected-mode yes\nport 6379\nmaxmemory 64mb\n"
'maxmemory-policy allkeys-lru\nsave ""\nappendonly no\nrequirepass '
+ cache.read_text().strip(),
)
create(directory / "s3_root_user", secrets.token_hex(10))
create(directory / "s3_root_password", secrets.token_urlsafe(32))
create(directory / "s3_access_key", secrets.token_hex(10))
create(directory / "s3_secret_key", secrets.token_urlsafe(32))
create(ROOT / ".env", (ROOT / ".env.example").read_text().rstrip())
print("Local configuration ready; existing files preserved")
if __name__ == "__main__":
main()
+83
View File
@@ -0,0 +1,83 @@
"""Явные операторские действия только над API текущего Compose-проекта."""
import json
import os
import subprocess
import sys
import time
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
def command(*args):
return subprocess.check_output(args, cwd=ROOT, text=True).strip()
def containers():
ids = command("docker", "compose", "ps", "-q", "api").split()
return json.loads(command("docker", "inspect", *ids)) if ids else []
def alias(cid):
code = (
"import urllib.request; r=urllib.request.urlopen("
"'http://127.0.0.1:8080/health/live',timeout=2); "
"print(r.headers['X-Instance-Id'])"
)
return command("docker", "exec", cid, "python", "-c", code)
def wait_count(count):
deadline = time.monotonic() + 60
while time.monotonic() < deadline:
data = containers()
if len(data) == count and all(
c["State"].get("Health", {}).get("Status") == "healthy"
for c in data
):
# DNS и проверки HAProxy должны успеть увидеть новый адрес.
time.sleep(3)
return
time.sleep(0.5)
raise TimeoutError("Replica readiness")
def main():
action = sys.argv[1]
data = containers()
if action == "stop":
target = os.environ["TARGET_INSTANCE_ID"]
matches = [c for c in data if alias(c["Id"]) == target]
if len(matches) != 1 or len(data) < 2:
raise RuntimeError("Target must identify one running replica")
command("docker", "stop", "--time", "10", matches[0]["Id"])
print("Selected API stopped")
elif action == "rolling":
count = len(data)
if count < 2:
raise RuntimeError("Need at least two replicas")
# Сначала добавляется готовая реплика, затем удаляется одна старая.
for old in data:
command(
"docker",
"compose",
"up",
"-d",
"--no-deps",
"--no-recreate",
"--scale",
f"api={count + 1}",
"api",
)
wait_count(count + 1)
command("docker", "stop", "--time", "10", old["Id"])
command("docker", "rm", old["Id"])
wait_count(count)
print("Sequential replacement completed")
else:
raise ValueError("Unknown action")
if __name__ == "__main__":
main()
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
docker compose restart api postgres cache s3 lb
docker compose up -d --no-build --no-recreate --wait
+3
View File
@@ -0,0 +1,3 @@
#!/bin/sh
set -eu
exec python3 scripts/cluster.py rolling
+137
View File
@@ -0,0 +1,137 @@
import json
import os
import subprocess
import time
from pathlib import Path
from uuid import uuid4
import httpx
ROOT = Path(__file__).resolve().parents[1]
BASE = os.environ.get("BASE_URL", "http://127.0.0.1:8084")
def command(args, *, input=None):
result = subprocess.run(
args, cwd=ROOT, input=input, capture_output=True, text=True
)
if result.returncode:
raise RuntimeError(
"Command failed: "
+ args[0]
+ "; "
+ result.stderr.replace(str(ROOT), "<repository>")
)
return result.stdout.strip()
def compose(*args):
return command(["docker", "compose", *args])
def sql(query, *, database="messenger"):
return compose(
"exec",
"-T",
"postgres",
"psql",
"-U",
"messenger",
"-d",
database,
"-A",
"-t",
"-v",
"ON_ERROR_STOP=1",
"-c",
query,
)
def cache(command_name, *args):
script = (
'export REDISCLI_AUTH="$(cat /run/secrets/cache_password)"; '
'exec valkey-cli "$@"'
)
return compose(
"exec", "-T", "cache", "sh", "-c", script, "sh", command_name, *args
)
def ready(base=BASE, *, timeout=30):
end = time.monotonic() + timeout
with httpx.Client(base_url=base, trust_env=False, timeout=6) as client:
while time.monotonic() < end:
try:
if client.get("/health/ready").status_code == 200:
return
except httpx.HTTPError:
pass
time.sleep(0.2)
raise TimeoutError("API readiness")
def actor(client):
username = "verify_" + uuid4().hex[:20]
password = "Synthetic-" + uuid4().hex + ":🌍"
result = client.post(
"/api/v1/users",
json={
"username": username,
"display_name": "Synthetic",
"password": password,
},
)
assert result.status_code == 201
user = result.json()
session = client.post(
"/api/v1/auth/sessions", auth=httpx.BasicAuth(username, password)
)
assert session.status_code == 201
return user, password, session.json()
def auth(session):
return {"Authorization": "Bearer " + session["token"]}
def extra_api(*, ttl=3600, pool_size=1):
name = "mtusi-lab4-test-" + uuid4().hex[:10]
compose(
"run",
"-d",
"--no-deps",
"--name",
name,
"-e",
"SESSION_TTL_SECONDS=" + str(ttl),
"-e",
"DB_POOL_SIZE=" + str(pool_size),
"-p",
"127.0.0.1::8080",
"api",
)
try:
info = json.loads(command(["docker", "inspect", name]))[0]
base = (
"http://127.0.0.1:"
+ info["NetworkSettings"]["Ports"]["8080/tcp"][0]["HostPort"]
)
ready(base)
return name, base
except Exception:
command(["docker", "rm", "-f", name])
raise
def instances():
data = {}
for role in ["api", "postgres", "cache"]:
cid = compose("ps", "-q", role)
info = json.loads(command(["docker", "inspect", cid]))[0]
data[role] = {
"container": cid[:12],
"pid": info["State"]["Pid"],
"started_at": info["State"]["StartedAt"],
}
return data
+3
View File
@@ -0,0 +1,3 @@
#!/bin/sh
set -eu
exec python3 scripts/cluster.py stop
+215
View File
@@ -0,0 +1,215 @@
import argparse
import atexit
import json
import os
import socket
import subprocess
import tempfile
from datetime import UTC, datetime
from pathlib import Path
from uuid import uuid4
ROOT = Path(__file__).resolve().parents[1]
PROGRESS = {}
def save_incomplete():
receipt = PROGRESS.get("receipt")
if receipt and receipt.get("result") != "PASS":
target = PROGRESS["output"].with_name(
PROGRESS["output"].stem + "-failed.json"
)
if target.exists():
target = target.with_name(
target.stem + "-" + uuid4().hex[:8] + target.suffix
)
target.parent.mkdir(parents=True, exist_ok=True)
target.write_text(
json.dumps(
{**receipt, "result": "INCOMPLETE"},
ensure_ascii=False,
indent=2,
)
+ "\n"
)
atexit.register(save_incomplete)
def run(args, *, cwd, env, expected=0):
result = subprocess.run(
args, cwd=cwd, env=env, capture_output=True, text=True
)
def redact(text):
return (
text.replace(str(cwd), "<clean-clone>")
.replace(str(ROOT), "<repository>")
.replace(str(Path.home()), "<home>")
)
if result.returncode != expected:
if "receipt" in PROGRESS:
PROGRESS["receipt"]["failed_action"] = redact(" ".join(args))
raise RuntimeError(redact(result.stdout + result.stderr))
return redact(result.stdout.strip())
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--output", default="evidence/clean-clone.json")
args = parser.parse_args()
output = ROOT / args.output
if output.exists():
raise SystemExit("Choose new output path")
assert not subprocess.check_output(
["git", "status", "--porcelain"], cwd=ROOT
)
sha = subprocess.check_output(
["git", "rev-parse", "HEAD"], cwd=ROOT, text=True
).strip()
identity = uuid4().hex[:10]
project = "mtusi-lab4-clean-" + identity
with socket.socket() as reservation:
reservation.bind(("127.0.0.1", 0))
public_port = str(reservation.getsockname()[1])
env = {
**os.environ,
"COMPOSE_PROJECT_NAME": project,
"API_IMAGE": "mtusi-messenger:lab4-clean-" + identity,
"PUBLIC_PORT": public_port,
"VCS_REF": sha,
"NO_PROXY": "localhost,127.0.0.1",
"no_proxy": "localhost,127.0.0.1",
}
receipt = {
"date": datetime.now(UTC).isoformat(),
"source_commit": sha,
"fresh_secrets_environment_and_volumes": True,
"command": "python scripts/verify_clean.py",
"fixed_host_port_for_restart": int(public_port),
}
PROGRESS.update(receipt=receipt, output=output)
with tempfile.TemporaryDirectory(prefix="mtusi-lab4-clean-") as temporary:
clone = Path(temporary) / "lab4"
run(
[
"git",
"clone",
"--no-hardlinks",
"--branch",
"solution/bvt2301-maslov",
str(ROOT),
str(clone),
],
cwd=ROOT,
env=env,
)
for name in [".env", ".venv", "secrets"]:
assert not (clone / name).exists()
run(["uv", "sync", "--locked"], cwd=clone, env=env)
receipt["static_checks"] = run(
["make", "check", "validate", "lint", "PYTHON=.venv/bin/python"],
cwd=clone,
env=env,
)
run(["make", "bootstrap"], cwd=clone, env=env)
try:
run(
["docker", "compose", "up", "-d", "--build", "--wait"],
cwd=clone,
env=env,
)
env["BASE_URL"] = "http://127.0.0.1:" + public_port
receipt["smoke"] = run(
["make", "test", "BASE_URL=" + env["BASE_URL"]],
cwd=clone,
env=env,
)
receipt["http_tests"] = run(
[".venv/bin/pytest", "student-tests", "-q"], cwd=clone, env=env
)
run(
[
".venv/bin/python",
"-m",
"scripts.verify_cluster",
"--output",
"evidence/clean-cluster.json",
],
cwd=clone,
env=env,
)
run(
[
".venv/bin/python",
"-m",
"scripts.verify_storage",
"--output",
"evidence/clean-storage.json",
],
cwd=clone,
env=env,
)
receipt["storage"] = json.loads(
(clone / "evidence/clean-storage.json").read_text()
)
receipt["cluster"] = json.loads(
(clone / "evidence/clean-cluster.json").read_text()
)
import hashlib
expected = {
p.name: hashlib.sha256(p.read_bytes()).hexdigest()
for p in (clone / "src").glob("*.py")
}
ids = run(
["docker", "compose", "ps", "-q", "api"], cwd=clone, env=env
).split()
assert len(ids) == 2
code = (
"import hashlib,json,pathlib; print(json.dumps({p.name:"
"hashlib.sha256(p.read_bytes()).hexdigest() for p in pathlib.Path('/app/src').glob('*.py')}))"
)
for cid in ids:
actual = json.loads(
run(
["docker", "exec", cid, "python", "-c", code],
cwd=clone,
env=env,
)
)
assert actual == expected
info = json.loads(
run(["docker", "inspect", cid], cwd=clone, env=env)
)[0]
assert (
info["Config"]["Labels"][
"org.opencontainers.image.revision"
]
== sha
)
assert not info["HostConfig"]["PortBindings"]
receipt["both_replicas_runtime_hashes_and_revision_match"] = True
receipt["fsck"] = run(
["git", "fsck", "--full"], cwd=clone, env=env
)
receipt["checks_completed"] = True
finally:
assert project.startswith("mtusi-lab4-clean-")
run(
["docker", "compose", "down", "--volumes", "--remove-orphans"],
cwd=clone,
env=env,
)
receipt["result"] = "PASS"
output.parent.mkdir(parents=True, exist_ok=True)
output.write_text(json.dumps(receipt, ensure_ascii=False, indent=2) + "\n")
print(
"PASS: fresh clone, build, HTTP tests, failover, rolling, persistence and runtime hashes"
)
if __name__ == "__main__":
main()
+342
View File
@@ -0,0 +1,342 @@
"""Проверки реальных процессов, failover, rolling и общей идемпотентности."""
import argparse
import json
import os
import subprocess
import threading
import time
from concurrent.futures import ThreadPoolExecutor
from datetime import datetime, timezone
from pathlib import Path
from uuid import uuid4
import httpx
from scripts import cluster
from scripts.stand import BASE, ROOT, actor, auth, command, compose, ready, sql
def snapshot():
ids = compose("ps", "-q").split()
result = []
for c in json.loads(command(["docker", "inspect", *ids])):
role = c["Config"]["Labels"]["com.docker.compose.service"]
entry = {
"role": role,
"container": c["Id"][:12],
"pid": c["State"]["Pid"],
"started_at": c["State"]["StartedAt"],
"ports": c["HostConfig"]["PortBindings"],
"cpu_nano": c["HostConfig"]["NanoCpus"],
"memory_limit": c["HostConfig"]["Memory"],
}
if role == "api":
entry["instance"] = cluster.alias(c["Id"])
assert not entry["ports"]
result.append(entry)
return result
def exercise(client, session, chat, action, *, seconds=15):
path = f"/api/v1/chats/{chat['id']}/messages"
observations, confirmed, errors, reads = [], {}, 0, 0
started = time.monotonic()
finished = threading.Event()
action_result = {}
def operate():
time.sleep(0.5)
try:
action()
except BaseException as exc:
action_result["error"] = type(exc).__name__
finally:
action_result["finished"] = round(time.monotonic() - started, 3)
finished.set()
thread = threading.Thread(target=operate)
thread.start()
key = uuid4().hex
try:
while time.monotonic() - started < seconds or not finished.is_set():
h = {**auth(session), "Idempotency-Key": key}
try:
r = client.post(path, headers=h, json={"text": key})
if r.status_code != 201:
errors += 1
continue
m = r.json()
confirmed[m["id"]] = m
observations.append(
{
"at": round(time.monotonic() - started, 3),
"instance": r.headers["x-instance-id"],
}
)
key = uuid4().hex
read = client.get(
path, headers=auth(session), params={"limit": 100}
)
reads += read.status_code == 200
errors += read.status_code != 200
except httpx.HTTPError:
errors += 1
time.sleep(0.04)
finally:
thread.join(timeout=90)
assert not action_result.get("error"), action_result
found, cursor = [], None
while True:
r = client.get(
path,
headers=auth(session),
params={"limit": 100, **({"cursor": cursor} if cursor else {})},
)
assert r.status_code == 200
page = r.json()
found.extend(page["items"])
cursor = page["next_cursor"]
if not cursor:
break
by_id = {m["id"]: m for m in found}
assert all(by_id.get(k) == v for k, v in confirmed.items())
texts = [m["text"] for m in found]
assert len(texts) == len(set(texts))
recovery = next(
(
x["at"]
for x in observations
if x["at"] >= action_result["finished"]
),
None,
)
assert recovery is not None and (seconds > 20 or recovery <= 10)
elapsed = time.monotonic() - started
return {
"confirmed_writes": len(confirmed),
"successful_reads": reads,
"errors": errors,
"successful_rps": round((len(confirmed) + reads) / elapsed, 2),
"first_success_after_action_seconds": recovery,
"action": action_result,
"observations": observations,
"confirmed_preserved": True,
"duplicate_texts": False,
}
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--output", default="evidence/cluster-repeat.json")
args = parser.parse_args()
report = {
"date": datetime.now(timezone.utc).isoformat(),
"source_commit": command(["git", "rev-parse", "HEAD"]),
"complete": False,
}
output = Path(args.output)
output.parent.mkdir(parents=True, exist_ok=True)
try:
ready()
initial = snapshot()
apis = [c for c in initial if c["role"] == "api"]
assert len(apis) == 2 and len({c["pid"] for c in apis}) == 2
report["before"] = initial
with httpx.Client(base_url=BASE, trust_env=False, timeout=8) as client:
user, _, session = actor(client)
r = client.post(
"/api/v1/chats",
headers=auth(session),
json={
"title": "Cluster verification",
"member_ids": [user["id"]],
},
)
assert r.status_code == 201
chat = r.json()
path = f"/api/v1/chats/{chat['id']}/messages"
key = uuid4().hex
def repeat(_):
with httpx.Client(
base_url=BASE, trust_env=False, timeout=8
) as c:
r = c.post(
path,
headers={**auth(session), "Idempotency-Key": key},
json={"text": "Same concurrent request"},
)
assert r.status_code == 201
return r.json(), r.headers["x-instance-id"]
with ThreadPoolExecutor(max_workers=10) as pool:
repeated = list(pool.map(repeat, range(30)))
assert len({m[0]["id"] for m in repeated}) == 1
assert len({m[1] for m in repeated}) == 2
report["parallel_replay"] = {
"requests": 30,
"messages": 1,
"instances": sorted({m[1] for m in repeated}),
}
# Сбой второй записи транзакции не должен оставить сообщение.
fault_key = uuid4().hex
fault_text = "Atomic rollback " + fault_key
sql(
"CREATE FUNCTION student_idempo_fault() RETURNS trigger "
"LANGUAGE plpgsql AS $$ BEGIN IF NEW.key='"
+ fault_key
+ "' THEN RAISE EXCEPTION 'synthetic'; END IF; RETURN NEW; END $$; "
"CREATE TRIGGER student_idempo_fault BEFORE INSERT ON idempotency "
"FOR EACH ROW EXECUTE FUNCTION student_idempo_fault()"
)
try:
failed = client.post(
path,
headers={**auth(session), "Idempotency-Key": fault_key},
json={"text": fault_text},
)
assert failed.status_code == 500
assert (
sql(
"SELECT count(*) FROM messages WHERE text='"
+ fault_text
+ "'"
)
== "0"
)
finally:
sql(
"DROP TRIGGER student_idempo_fault ON idempotency; "
"DROP FUNCTION student_idempo_fault()"
)
retried = client.post(
path,
headers={**auth(session), "Idempotency-Key": fault_key},
json={"text": fault_text},
)
assert retried.status_code == 201
report["atomic_rollback_and_5xx_retry"] = True
sql(
"UPDATE idempotency SET expires_at=clock_timestamp()-interval '1 second' "
"WHERE key='" + fault_key + "'"
)
expired = client.post(
path,
headers={**auth(session), "Idempotency-Key": fault_key},
json={"text": "New retention window"},
)
assert expired.status_code == 201
assert expired.json()["id"] != retried.json()["id"]
report["expired_key_can_be_reused"] = True
# Отдельный чат каждой серии: проверки дубликатов не смешивают тексты.
report["failovers"] = []
for api in apis:
def stop(target=api["instance"]):
env = {**os.environ, "TARGET_INSTANCE_ID": target}
subprocess.run(
["scripts/stop-one.sh"],
cwd=ROOT,
env=env,
check=True,
capture_output=True,
text=True,
)
r = client.post(
"/api/v1/chats",
headers=auth(session),
json={"title": "Failover", "member_ids": [user["id"]]},
)
result = exercise(client, session, r.json(), stop)
assert api["instance"] not in [
o["instance"] for o in result["observations"][-5:]
]
assert (
command(
[
"docker",
"inspect",
"-f",
"{{.State.Running}}",
api["container"],
]
)
== "false"
)
result["stopped"] = api
report["failovers"].append(result)
compose("up", "-d", "--no-build", "--wait")
ready()
r = client.post(
"/api/v1/chats",
headers=auth(session),
json={"title": "Rolling", "member_ids": [user["id"]]},
)
before_roll = snapshot()
report["rolling"] = exercise(
client,
session,
r.json(),
lambda: command(["scripts/rolling-update.sh"]),
seconds=45,
)
after_roll = snapshot()
assert not (
{c["container"] for c in before_roll if c["role"] == "api"}
& {c["container"] for c in after_roll if c["role"] == "api"}
)
report["rolling"]["before"] = before_roll
report["rolling"]["after"] = after_roll
replay = repeat(0)[0]
assert replay == repeated[0][0]
report["replay_after_replacement"] = True
before = snapshot()
env = {
**os.environ,
"NO_PROXY": "localhost,127.0.0.1",
"no_proxy": "localhost,127.0.0.1",
}
for mode, hook in [
("failover", "scripts/stop-one.sh"),
("persistence", "scripts/restart.sh"),
]:
if mode == "persistence":
compose("up", "-d", "--no-build", "--wait")
ready()
before = snapshot()
run = subprocess.run(
[
".venv/bin/python",
"tests/resilience.py",
"--mode",
mode,
"--action-script",
hook,
"--base-url",
BASE,
],
cwd=ROOT,
env=env,
capture_output=True,
text=True,
)
assert run.returncode == 0, run.stdout + run.stderr
report["public_" + mode] = run.stdout.strip()
after = snapshot()
for role in ["postgres", "cache", "s3", "lb"]:
old = next(c for c in before if c["role"] == role)
new = next(c for c in after if c["role"] == role)
assert old["started_at"] != new["started_at"]
report["after_persistence"] = after
report["complete"] = True
finally:
output.write_text(
json.dumps(report, ensure_ascii=False, indent=2) + "\n"
)
print("PASS: process failover, rolling, replay and full persistence")
if __name__ == "__main__":
main()
+538
View File
@@ -0,0 +1,538 @@
"""Operator checks on the disposable teaching stand, never production."""
import argparse
import hashlib
import io
import json
import socket
import statistics
import threading
import time
from concurrent.futures import ThreadPoolExecutor
from datetime import datetime, timezone
from pathlib import Path
from uuid import uuid4
import httpx
from PIL import Image
from scripts import cluster
from scripts.stand import BASE, ROOT, actor, auth, command, compose, ready, sql
PNG = (ROOT / "tests/fixtures/sample.png").read_bytes()
PREFIX = """import hashlib,io,json,time,urllib.request,urllib.error
from src.object_store import ObjectStore,BUCKET
from src.database import Database
from src.settings import secret
from src.reconcile import reconcile
s=ObjectStore(); d=Database(url=secret('DATABASE_URL'),size=2); d.open()
"""
def inside(code):
containers = compose("ps", "-q", "api").split()
assert containers, "No running API in this project"
value = command(
["docker", "exec", "-i", containers[0], "python", "-"],
input=PREFIX + code + "\ns.close(); d.close()\n",
)
return json.loads(value)
def upload(client, session, chat, data=PNG, *, name=None):
return client.post(
f"/api/v1/chats/{chat['id']}/attachments",
headers={**auth(session), "Content-Type": "image/png"},
params={"filename": name or uuid4().hex + ".png"},
content=data,
)
def state(identity):
return sql("SELECT state FROM attachments WHERE id='" + identity + "'")
def key(identity):
return "objects/" + identity + "/original"
def run_reconcile(apply=False):
return inside(
"print(json.dumps(reconcile(d,s,apply=" + str(apply) + ",grace=300)))"
)
def age(identity):
sql(
"UPDATE attachments SET created_at=clock_timestamp()-interval '301 seconds', "
"expires_at=clock_timestamp()-interval '180 seconds' WHERE id='"
+ identity
+ "'"
)
def percentiles(values):
values = sorted(values)
return {
f"p{p}_ms": round(
values[min(len(values) - 1, int(p * len(values) / 100))], 3
)
for p in [50, 95, 99]
}
def concurrency(client, session, chat):
stream = io.BytesIO()
Image.effect_noise((1700, 1700), 100).convert("RGB").save(stream, "PNG")
image = stream.getvalue()
assert len(image) < 10 * 1024 * 1024
ids = compose("ps", "-q", "api").split()
samples, stop = [], threading.Event()
code = (
"import json,pathlib; p=pathlib.Path('/sys/fs/cgroup'); "
"print(json.dumps({k:int((p/k).read_text()) for k in ['memory.current','memory.peak']}))"
)
def sample():
while not stop.is_set():
for cid in ids:
samples.append(
{
"at": round(time.monotonic() - started, 3),
"container": cid[:12],
**json.loads(
command(
["docker", "exec", cid, "python", "-c", code]
)
),
}
)
stop.wait(0.3)
barrier = threading.Barrier(10)
def one(_):
with httpx.Client(base_url=BASE, trust_env=False, timeout=60) as c:
barrier.wait(timeout=30)
begin = time.monotonic()
r = upload(c, session, chat, image)
latency = (time.monotonic() - begin) * 1000
assert r.status_code == 201, (r.status_code, r.text)
a = r.json()
assert a["sha256"] == hashlib.sha256(image).hexdigest()
data = c.get(
f"/api/v1/attachments/{a['id']}/content", headers=auth(session)
)
assert data.status_code == 200 and data.content == image
return {
"id": a["id"],
"latency_ms": latency,
"instance": r.headers["x-instance-id"],
}
cpu_before = {
cid: command(["docker", "exec", cid, "cat", "/sys/fs/cgroup/cpu.stat"])
for cid in ids
}
started = time.monotonic()
thread = threading.Thread(target=sample)
thread.start()
try:
with ThreadPoolExecutor(max_workers=10) as pool:
results = list(pool.map(one, range(10)))
finally:
stop.set()
thread.join(timeout=30)
elapsed = time.monotonic() - started
assert samples
return {
"concurrency": 10,
"requests": 10,
"successes": len(results),
"errors": 0,
"bytes_per_image": len(image),
"pixels": 1700 * 1700,
"duration_seconds": round(elapsed, 3),
"successful_rps": round(10 / elapsed, 3),
"latency_scope": "upload only; duration includes verified downloads and memory sampler",
**percentiles([r["latency_ms"] for r in results]),
"cpu_before": cpu_before,
"cpu_after": {
cid: command(
["docker", "exec", cid, "cat", "/sys/fs/cgroup/cpu.stat"]
)
for cid in ids
},
"memory_samples": samples,
"results": results,
"window_max_memory_current": max(s["memory.current"] for s in samples),
"lifetime_memory_peak": max(s["memory.peak"] for s in samples),
}
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--output", default="evidence/storage-repeat.json")
parser.add_argument("--research", action="store_true")
args = parser.parse_args()
output = Path(args.output)
assert not output.exists(), "Choose a fresh evidence path"
output.parent.mkdir(parents=True, exist_ok=True)
result = {
"source_commit": command(["git", "rev-parse", "HEAD"]),
"date": datetime.now(timezone.utc).isoformat(),
"complete": False,
}
ready()
from scripts.verify_cluster import snapshot
result["runtime"] = snapshot()
compose("stop", "reconciler")
orphan = "objects/verification-" + uuid4().hex + "/orphan"
fresh = "objects/verification-" + uuid4().hex + "/fresh"
research_prefix = "objects/research-" + uuid4().hex + "/"
try:
# Its server LastModified must really age; no clock manipulation in S3.
inside(
f"s.put(key={orphan!r},stream=io.BytesIO(b'orphan'),size=6,content_type='application/octet-stream',sha256=hashlib.sha256(b'orphan').hexdigest()); print('true')"
)
orphan_started = time.monotonic()
with httpx.Client(
base_url=BASE, trust_env=False, timeout=30
) as client:
user, _, session = actor(client)
r = client.post(
"/api/v1/chats",
headers=auth(session),
json={
"title": "Storage verification",
"member_ids": [user["id"]],
},
)
assert r.status_code == 201
chat = r.json()
r = upload(client, session, chat)
assert r.status_code == 201
saved, uploader = r.json(), r.headers["x-instance-id"]
failed_old = upload(client, session, chat).json()
sql(
"UPDATE attachments SET state='failed',error_code='synthetic' WHERE id='"
+ failed_old["id"]
+ "'"
)
age(failed_old["id"])
grace_started = time.monotonic()
target = next(
c
for c in cluster.containers()
if cluster.alias(c["Id"]) == uploader
)
command(["docker", "stop", "--time", "10", target["Id"]])
try:
time.sleep(3)
download = client.get(
f"/api/v1/attachments/{saved['id']}/content",
headers=auth(session),
)
assert download.status_code == 200 and download.content == PNG
assert download.headers["x-instance-id"] != uploader
result["upload_replica_stopped_downloaded_elsewhere"] = {
"stopped_container": target["Id"][:12],
"uploader": uploader,
"downloader": download.headers["x-instance-id"],
"sha256": saved["sha256"],
}
finally:
compose(
"up",
"-d",
"--no-build",
"--no-recreate",
"--wait",
"api",
"lb",
)
ready()
private_code = f"""
from src.errors import DomainError
checks={{}}
try:
s.head(key='forbidden'); raise AssertionError('HEAD outside IAM prefix')
except DomainError as e:
assert e.status==503; checks['denied_head_is_not_missing']=e.status
try:
urllib.request.urlopen('http://s3:9000/messenger/{key(saved["id"])}',timeout=3)
raise AssertionError('public object')
except urllib.error.HTTPError as e: checks['anonymous_get']=e.code; assert e.code==403
for name,operation in [('list_other_bucket',lambda:list(s.client.list_objects('other-private'))),('create_bucket',lambda:s.client.make_bucket('forbidden-bucket')),('write_outside_prefix',lambda:s.client.put_object(BUCKET,'forbidden',io.BytesIO(b'x'),1))]:
try: operation(); raise AssertionError(name)
except Exception as e:
assert getattr(e,'code',None)=='AccessDenied',type(e).__name__; checks[name]='AccessDenied'
try:
urllib.request.urlopen('http://s3:9001/',timeout=2); raise AssertionError('console exposed')
except urllib.error.URLError: checks['console_internal_network']='unreachable'
print(json.dumps(checks))
"""
result["private_bucket_and_iam"] = inside(private_code)
compose("run", "--rm", "--no-deps", "s3-bootstrap")
assert (
client.get(
f"/api/v1/attachments/{saved['id']}/content",
headers=auth(session),
).content
== PNG
)
result["bootstrap_repeat_preserved_original"] = True
# A partial HTTP body must never create a durable intent or object.
before = int(sql("SELECT count(*) FROM attachments"))
objects_before_abort = inside("print(len(list(s.objects())))")
parsed = httpx.URL(BASE)
with socket.create_connection(
(parsed.host, parsed.port), timeout=3
) as raw:
request = (
(
f"POST /api/v1/chats/{chat['id']}/attachments?filename=partial.png HTTP/1.1\r\n"
f"Host: {parsed.host}\r\nAuthorization: Bearer {session['token']}\r\n"
"Content-Type: image/png\r\nContent-Length: 10000000\r\n\r\n"
).encode()
+ PNG
+ b"x" * (2 * 1024 * 1024)
)
raw.sendall(request)
time.sleep(1)
assert int(sql("SELECT count(*) FROM attachments")) == before
assert (
inside("print(len(list(s.objects())))") == objects_before_abort
)
result["aborted_upload_has_no_intent_or_bytes"] = True
# Failure before any S3 PUT.
name = uuid4().hex + ".png"
objects_before = inside("print(len(list(s.objects())))")
sql(
"CREATE FUNCTION student_upload_fault() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RAISE EXCEPTION 'synthetic'; END $$; CREATE TRIGGER student_upload_fault BEFORE INSERT ON attachments FOR EACH ROW EXECUTE FUNCTION student_upload_fault()"
)
try:
assert (
upload(client, session, chat, name=name).status_code == 500
)
assert (
int(
sql(
"SELECT count(*) FROM attachments WHERE filename='"
+ name
+ "'"
)
)
== 0
)
assert (
inside("print(len(list(s.objects())))") == objects_before
)
finally:
sql(
"DROP TRIGGER student_upload_fault ON attachments; DROP FUNCTION student_upload_fault()"
)
result["pg_intent_failure_has_no_bytes"] = True
# S3 PUT succeeded, then ready UPDATE fails: durable pending is recoverable.
name = uuid4().hex + ".png"
sql(
"CREATE FUNCTION student_ready_fault() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF NEW.state='ready' THEN RAISE EXCEPTION 'synthetic'; END IF; RETURN NEW; END $$; CREATE TRIGGER student_ready_fault BEFORE UPDATE ON attachments FOR EACH ROW EXECUTE FUNCTION student_ready_fault()"
)
try:
assert (
upload(client, session, chat, name=name).status_code == 500
)
finally:
sql(
"DROP TRIGGER student_ready_fault ON attachments; DROP FUNCTION student_ready_fault()"
)
pending = sql(
"SELECT id FROM attachments WHERE filename='" + name + "'"
)
assert state(pending) == "pending"
assert inside(
f"print(json.dumps(s.head(key={key(pending)!r}) is not None))"
)
age(pending)
# Stop S3; bypass LB health exclusion only from inside the selected API.
compose("stop", "s3")
name = uuid4().hex + ".png"
try:
direct = f"""
request=urllib.request.Request('http://127.0.0.1:8080/api/v1/chats/{chat["id"]}/attachments?filename={name}',data=bytes.fromhex({PNG.hex()!r}),headers={{'Authorization':{auth(session)["Authorization"]!r},'Content-Type':'image/png'}})
try: urllib.request.urlopen(request,timeout=15); raise AssertionError('S3 down accepted')
except urllib.error.HTTPError as e: print(json.dumps({{'status':e.code,'error':json.loads(e.read())['error']['code']}}))
"""
observed = inside(direct)
assert observed == {"status": 503, "error": "unavailable"}
missing_pending = sql(
"SELECT id FROM attachments WHERE filename='" + name + "'"
)
assert state(missing_pending) == "pending"
result["s3_unavailable"] = observed
finally:
compose(
"up", "-d", "--no-build", "--no-recreate", "--wait", "s3"
)
ready()
age(missing_pending)
# Used object missing: preserve metadata ID and the Message link.
used = upload(client, session, chat).json()
sent = client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers={**auth(session), "Idempotency-Key": uuid4().hex},
json={"text": "", "attachment_ids": [used["id"]]},
)
assert sent.status_code == 201
inside(f"s.delete(key={key(used['id'])!r}); print('true')")
age(used["id"])
age(saved["id"])
# Fresh cgroups make memory.peak specific to this experiment.
compose("restart", "api")
cluster.wait_count(2)
ready()
result["concurrent_uploads"] = concurrency(client, session, chat)
result["concurrent_uploads"][
"api_restarted_before_memory_measurement"
] = True
while time.monotonic() - grace_started < 302:
print(
"Waiting for genuine S3 LastModified grace: "
+ str(round(302 - (time.monotonic() - grace_started)))
+ "s",
flush=True,
)
time.sleep(
min(20, max(0, 302 - (time.monotonic() - grace_started)))
)
inside(
f"s.put(key={fresh!r},stream=io.BytesIO(b'fresh'),size=5,content_type='application/octet-stream',sha256=hashlib.sha256(b'fresh').hexdigest()); print('true')"
)
failed_fresh = upload(client, session, chat).json()
sql(
"UPDATE attachments SET state='failed',error_code='synthetic' WHERE id='"
+ failed_fresh["id"]
+ "'"
)
age(failed_fresh["id"])
before_states = [
state(i)
for i in [pending, missing_pending, used["id"], saved["id"]]
]
dry = run_reconcile()
assert [
state(i)
for i in [pending, missing_pending, used["id"], saved["id"]]
] == before_states
assert inside(
f"print(json.dumps(s.head(key={orphan!r}) is not None))"
)
for action in [
"recover_pending",
"fail_pending_missing",
"mark_missing",
"delete_orphan",
"delete_failed_object",
]:
assert dry["actions"].get(action, 0) >= 1, dry
applied = run_reconcile(True)
assert state(pending) == "ready"
assert (
state(missing_pending) == "failed"
and state(used["id"]) == "failed"
)
assert state(saved["id"]) == "ready"
assert (
int(
sql(
"SELECT count(*) FROM message_attachments WHERE attachment_id='"
+ used["id"]
+ "'"
)
)
== 1
)
assert (
client.get(
f"/api/v1/attachments/{used['id']}", headers=auth(session)
).status_code
== 409
)
assert (
client.get(
f"/api/v1/attachments/{pending}/content",
headers=auth(session),
).content
== PNG
)
assert inside(
f"print(json.dumps(s.head(key={orphan!r}) is None and s.head(key={fresh!r}) is not None and s.head(key={key(saved['id'])!r}) is not None))"
)
assert inside(
f"print(json.dumps(s.head(key={key(failed_old['id'])!r}) is None and s.head(key={key(failed_fresh['id'])!r}) is not None))"
)
repeat = run_reconcile(True)
assert not repeat["applied"]
assert repeat["linked_protected"] >= 1
result["reconciliation"] = {
"dry_run": dry,
"apply": applied,
"repeat": repeat,
"s3_grace_wait_seconds": round(
time.monotonic() - orphan_started, 3
),
"fresh_and_ready_unlinked_protected": True,
"old_failed_unlinked_deleted_and_fresh_failed_protected": True,
"missing_used_id_and_link_preserved": True,
"dry_run_unchanged": True,
}
if args.research:
cells = []
for count in [0, 100, 1100]:
if count:
start = 0 if count == 100 else 100
inside(
f"\nfor i in range({start},{count}):\n s.put(key={research_prefix!r}+str(i),stream=io.BytesIO(b'x'),size=1,content_type='application/octet-stream',sha256=hashlib.sha256(b'x').hexdigest())\nprint('true')"
)
for repetition in range(3):
measured = run_reconcile()
cells.append(
{
"extra_objects": count,
"repetition": repetition + 1,
**measured,
}
)
result["cost_research"] = {
"cells": cells,
"repeats": 3,
"method": "same running stand; 0/100/1100 fresh one-byte objects; dry-run; serial ascending dataset; no warmup",
"median_seconds": {
str(n): statistics.median(
c["duration_seconds"]
for c in cells
if c["extra_objects"] == n
)
for n in [0, 100, 1100]
},
}
result["complete"] = True
finally:
# Only keys created by this invocation; no broad bucket deletion.
try:
inside(
f"\nfor o in s.objects():\n if o.object_name.startswith({research_prefix!r}) or o.object_name in [{orphan!r},{fresh!r}]: s.delete(key=o.object_name)\nprint('true')"
)
finally:
compose("up", "-d", "--no-build", "--no-recreate", "reconciler")
output.write_text(
json.dumps(result, ensure_ascii=False, indent=2) + "\n"
)
print(
"PASS: private S3, failover, bounded concurrent uploads and two-store recovery"
)
if __name__ == "__main__":
main()
View File
+44
View File
@@ -0,0 +1,44 @@
import json
import logging
import os
import signal
import sys
def early_stop(signum, _frame):
print(
json.dumps({"event": "stopped_before_startup", "signal": signum}),
flush=True,
)
sys.exit(0)
signal.signal(signal.SIGTERM, early_stop)
signal.signal(signal.SIGINT, early_stop)
import uvicorn # noqa: E402
from src.logging_config import JsonFormatter # noqa: E402
def main() -> None:
host = os.environ.get("APP_HOST", "127.0.0.1")
port = int(os.environ.get("APP_PORT", "8080"))
if not 1 <= port <= 65535:
raise ValueError("APP_PORT must be between 1 and 65535")
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(JsonFormatter())
logging.basicConfig(level=logging.INFO, handlers=[handler], force=True)
uvicorn.run(
"src.api:app",
host=host,
port=port,
workers=1,
access_log=False,
timeout_graceful_shutdown=5,
log_config=None,
)
if __name__ == "__main__":
main()
+424
View File
@@ -0,0 +1,424 @@
import hashlib
import json
import logging
import tempfile
import time
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
from datetime import datetime
from functools import partial
from urllib.parse import quote
from uuid import UUID, uuid4
from anyio import Semaphore, fail_after, to_thread
from fastapi import FastAPI, Request
from fastapi.encoders import jsonable_encoder
from pydantic import ValidationError
from starlette.exceptions import HTTPException
from starlette.requests import ClientDisconnect
from starlette.responses import JSONResponse, Response, StreamingResponse
from src import images
from src.attachments import Attachments
from src.cache import UserCache
from src.cursor import parse_uuid
from src.database import Database
from src.domain import timestamp
from src.errors import DomainError, invalid
from src.object_store import ObjectStore
from src.password import Passwords
from src.repository import PostgresRepository
from src.schemas import CreateChat, CreateMessage, CreateUser, Input
from src.service import MessengerService
from src.settings import Settings
logger = logging.getLogger("messenger")
INSTANCE_ID = uuid4().hex
def response(data: object, *, status: int = 200) -> JSONResponse:
return JSONResponse(
jsonable_encoder(
data, custom_encoder={datetime: timestamp, UUID: str}
),
status_code=status,
)
async def body(request: Request, model: type[Input]) -> Input:
try:
data = await request.body()
return model.model_validate(
json.loads(
data.decode("utf-8"),
parse_constant=lambda _: (_ for _ in ()).throw(ValueError()),
)
)
except ValueError, ValidationError, UnicodeError, RecursionError:
raise invalid() from None
def pagination(request: Request) -> tuple[int, str | None]:
limits = request.query_params.getlist("limit")
cursors = request.query_params.getlist("cursor")
if len(limits) > 1 or len(cursors) > 1:
raise invalid()
raw = limits[0] if limits else "50"
if not raw.isascii() or not raw.isdecimal():
raise invalid()
raw = raw.lstrip("0") or "0"
if len(raw) > 3:
raise invalid()
limit = int(raw)
if not 1 <= limit <= 100:
raise invalid()
return limit, cursors[0] if cursors else None
def service(request: Request) -> MessengerService:
return request.app.state.service
async def run_io(function, **kwargs):
return await to_thread.run_sync(partial(function, **kwargs))
async def actor(request: Request):
return await run_io(
service(request).identify, value=request.headers.get("authorization")
)
@asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncIterator[None]:
settings = Settings.load()
database = Database(url=settings.database_url, size=settings.pool_size)
cache = UserCache(url=settings.cache_url)
store = ObjectStore()
try:
await run_io(database.open)
passwords = await run_io(Passwords)
app.state.database = database
app.state.store = store
app.state.upload_slots = Semaphore(2)
app.state.attachments = Attachments(
database=database, store=store, instance=INSTANCE_ID
)
app.state.service = MessengerService(
repository=PostgresRepository(database=database, cache=cache),
passwords=passwords,
session_ttl=settings.session_ttl,
)
app.state.ready = True
yield
finally:
app.state.ready = False
await run_io(store.close)
await run_io(cache.close)
await run_io(database.close)
app = FastAPI(
lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None
)
@app.middleware("http")
async def request_context(request: Request, call_next):
request_id = str(uuid4())
request.state.request_id = request_id
started = time.perf_counter()
try:
result = await call_next(request)
except Exception:
logger.error(
json.dumps({"event": "internal_error", "request_id": request_id})
)
result = response(
{
"error": {
"code": "internal_error",
"message": "Internal error",
"request_id": request_id,
}
},
status=500,
)
result.headers["X-Request-Id"] = request_id
result.headers["X-Instance-Id"] = INSTANCE_ID
route = request.scope.get("route")
logger.info(
json.dumps(
{
"event": "request",
"request_id": request_id,
"method": request.method,
"route": getattr(route, "path", "unmatched"),
"status": result.status_code,
"elapsed_ms": round((time.perf_counter() - started) * 1000, 3),
}
)
)
return result
@app.exception_handler(DomainError)
async def domain_error(request: Request, error: DomainError):
result = response(
{
"error": {
"code": error.code,
"message": error.message,
"request_id": request.state.request_id,
}
},
status=error.status,
)
result.headers.update(error.headers)
return result
@app.exception_handler(HTTPException)
async def http_error(request: Request, error: HTTPException):
code = "not_found" if error.status_code == 404 else "invalid_request"
return response(
{
"error": {
"code": code,
"message": "Resource not found"
if error.status_code == 404
else "Invalid request",
"request_id": request.state.request_id,
}
},
status=error.status_code,
)
@app.get("/health/live")
async def live():
return response({"status": "ok"})
@app.get("/health/ready")
async def ready():
if not getattr(app.state, "ready", False):
raise DomainError(503, "unavailable", "Not ready")
await run_io(app.state.database.ping)
await run_io(app.state.store.ping)
return response({"status": "ok"})
@app.post("/api/v1/users")
async def register(request: Request):
data = await body(request, CreateUser)
return response(
await run_io(service(request).register, **data.model_dump()),
status=201,
)
@app.get("/api/v1/users/me")
async def current(request: Request):
return response(await actor(request))
@app.post("/api/v1/chats")
async def create_chat(request: Request):
user = await actor(request)
data = await body(request, CreateChat)
return response(
await run_io(
service(request).create_chat, actor_id=user.id, **data.model_dump()
),
status=201,
)
@app.get("/api/v1/chats")
async def list_chats(request: Request):
user = await actor(request)
limit, cursor = pagination(request)
return response(
await run_io(
service(request).chats,
actor_id=user.id,
limit=limit,
cursor=cursor,
)
)
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(request: Request, chat_id: str):
user = await actor(request)
return response(
await run_io(
service(request).get_chat,
actor_id=user.id,
chat_id=parse_uuid(chat_id),
)
)
@app.post("/api/v1/chats/{chat_id}/messages")
async def send(request: Request, chat_id: str):
user = await actor(request)
cid = parse_uuid(chat_id)
await run_io(service(request).get_chat, actor_id=user.id, chat_id=cid)
data = await body(request, CreateMessage)
return response(
await run_io(
service(request).send,
actor_id=user.id,
chat_id=cid,
idempotency_key=request.headers.get("idempotency-key"),
**data.model_dump(),
),
status=201,
)
@app.get("/api/v1/chats/{chat_id}/messages")
async def history(request: Request, chat_id: str):
user = await actor(request)
cid = parse_uuid(chat_id)
chat = await run_io(
service(request).get_chat, actor_id=user.id, chat_id=cid
)
limit, cursor = pagination(request)
return response(
await run_io(
service(request).history,
actor_id=user.id,
chat=chat,
limit=limit,
cursor=cursor,
)
)
@app.post("/api/v1/auth/sessions")
async def login(request: Request):
return response(
await run_io(
service(request).login,
authorization=request.headers.get("authorization"),
),
status=201,
)
@app.delete("/api/v1/auth/sessions/current")
async def logout(request: Request):
await run_io(
service(request).logout,
authorization=request.headers.get("authorization"),
)
return Response(status_code=204)
@app.post("/api/v1/chats/{chat_id}/attachments")
async def upload(request: Request, chat_id: str):
user = await actor(request)
cid = parse_uuid(chat_id)
await run_io(service(request).get_chat, actor_id=user.id, chat_id=cid)
names = request.query_params.getlist("filename")
if len(names) != 1:
raise invalid()
name = images.filename(names[0])
declared = (
request.headers.get("content-type", "")
.partition(";")[0]
.strip()
.lower()
)
if declared not in {"image/png", "image/jpeg"}:
raise DomainError(
415, "unsupported_media_type", "PNG or JPEG required"
)
length = request.headers.get("content-length")
if length and (not length.isdecimal() or len(length) > 12):
raise invalid()
if length and int(length) > images.MAX_BYTES:
raise DomainError(413, "payload_too_large", "Byte limit exceeded")
try:
with fail_after(20):
async with app.state.upload_slots:
with tempfile.SpooledTemporaryFile(
max_size=1024 * 1024, mode="w+b"
) as stream:
size = 0
digest = hashlib.sha256()
async for chunk in request.stream():
size += len(chunk)
if size > images.MAX_BYTES:
raise DomainError(
413, "payload_too_large", "Byte limit exceeded"
)
digest.update(chunk)
stream.write(chunk)
await run_io(
images.verify, stream=stream, declared=declared
)
result = await run_io(
app.state.attachments.upload,
chat_id=cid,
owner_id=user.id,
filename=name,
content_type=declared,
size=size,
sha256=digest.hexdigest(),
stream=stream,
)
return response(result, status=201)
except ClientDisconnect:
raise invalid() from None
except TimeoutError:
raise DomainError(
503, "unavailable", "Upload deadline exceeded"
) from None
@app.get("/api/v1/attachments/{attachment_id}")
async def attachment_metadata(request: Request, attachment_id: str):
user = await actor(request)
return response(
await run_io(
app.state.attachments.metadata,
identity=parse_uuid(attachment_id),
actor_id=user.id,
)
)
@app.get("/api/v1/attachments/{attachment_id}/content")
async def attachment_content(request: Request, attachment_id: str):
user = await actor(request)
variants = request.query_params.getlist("variant")
if len(variants) > 1:
raise invalid()
row, upstream = await run_io(
app.state.attachments.content,
identity=parse_uuid(attachment_id),
actor_id=user.id,
variant=variants[0] if variants else "original",
)
def chunks():
try:
while data := upstream.read(65536):
yield data
finally:
upstream.close()
upstream.release_conn()
return StreamingResponse(
chunks(),
media_type=row["content_type"],
headers={
"Content-Length": str(row["size_bytes"]),
"Content-Disposition": "inline; filename*=UTF-8''"
+ quote(row["filename"], safe=""),
},
)
+116
View File
@@ -0,0 +1,116 @@
from uuid import uuid4
from src.errors import DomainError, not_found
def dto(row):
if row["state"] != "ready":
raise DomainError(409, "conflict", "Attachment is not ready")
return {
k: row[k]
for k in [
"id",
"chat_id",
"owner_id",
"filename",
"content_type",
"size_bytes",
"sha256",
"created_at",
"updated_at",
]
} | {
"status": "ready",
"variants": [],
"error_code": None,
}
class Attachments:
def __init__(self, *, database, store, instance):
self.database = database
self.store = store
self.instance = instance
def upload(
self,
*,
chat_id,
owner_id,
filename,
content_type,
size,
sha256,
stream,
):
identity = uuid4()
key = f"objects/{identity}/original"
# Durable intent precedes bytes; expired writers cannot confirm.
with self.database.connection() as conn:
conn.execute(
"INSERT INTO attachments(id,chat_id,owner_id,filename,"
"content_type,"
"size_bytes,sha256,object_key,state,uploader_instance,"
"expires_at) "
"VALUES(%s,%s,%s,%s,%s,%s,%s,%s,'pending',%s,"
"clock_timestamp()+interval '120 seconds')",
(
identity,
chat_id,
owner_id,
filename,
content_type,
size,
sha256,
key,
self.instance,
),
)
self.store.put(
key=key,
stream=stream,
size=size,
content_type=content_type,
sha256=sha256,
)
with self.database.connection() as conn:
row = conn.execute(
"UPDATE attachments SET state='ready',"
"updated_at=clock_timestamp() "
"WHERE id=%s AND state='pending' "
"AND expires_at>clock_timestamp() "
"RETURNING *",
(identity,),
).fetchone()
if row is None:
row = conn.execute(
"SELECT * FROM attachments WHERE id=%s", (identity,)
).fetchone()
if row["state"] != "ready":
raise DomainError(
503, "unavailable", "Upload reservation expired"
)
return dto(row)
def row(self, *, identity, actor_id):
with self.database.connection() as conn:
row = conn.execute(
"SELECT a.* FROM attachments a JOIN members m "
"ON m.chat_id=a.chat_id AND m.user_id=%s WHERE a.id=%s",
(actor_id, identity),
).fetchone()
if row is None:
raise not_found()
return row
def metadata(self, *, identity, actor_id):
return dto(self.row(identity=identity, actor_id=actor_id))
def content(self, *, identity, actor_id, variant):
row = self.row(identity=identity, actor_id=actor_id)
dto(row)
if variant != "original":
raise not_found()
if self.store.head(key=row["object_key"]) is None:
raise DomainError(503, "unavailable", "Original unavailable")
return row, self.store.get(key=row["object_key"])
+66
View File
@@ -0,0 +1,66 @@
import json
import threading
import time
from datetime import datetime
from uuid import UUID
import redis
from redis.backoff import NoBackoff
from redis.retry import Retry
from src.domain import User, timestamp
class UserCache:
def __init__(self, *, url: str):
self.client = redis.Redis.from_url(
url,
socket_connect_timeout=0.15,
socket_timeout=0.15,
max_connections=16,
retry=Retry(NoBackoff(), 0),
decode_responses=True,
)
self.disabled_until = 0.0
self.lock = threading.Lock()
def close(self):
self.client.close()
def _command(self, function, *args, **kwargs):
if time.monotonic() < self.disabled_until:
return None
try:
return function(*args, **kwargs)
except redis.RedisError, OSError:
with self.lock:
self.disabled_until = time.monotonic() + 5
return None
def get(self, *, user_id: UUID) -> User | None:
raw = self._command(self.client.get, "user:" + str(user_id))
if raw is None:
return None
try:
row = json.loads(raw)
if UUID(row["id"]) != user_id:
return None
return User(
user_id,
row["username"],
row["display_name"],
datetime.fromisoformat(row["created_at"]),
)
except ValueError, TypeError, KeyError:
return None
def put(self, *, user: User):
raw = json.dumps(
{
"id": str(user.id),
"username": user.username,
"display_name": user.display_name,
"created_at": timestamp(user.created_at),
}
)
self._command(self.client.set, "user:" + str(user.id), raw, ex=30)
+64
View File
@@ -0,0 +1,64 @@
import base64
import binascii
import json
import re
from datetime import datetime
from uuid import UUID
from src.domain import Key, timestamp
from src.errors import invalid
def parse_uuid(value: str) -> UUID:
if not isinstance(value, str) or not re.fullmatch(
r"[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}", value
):
raise invalid()
return UUID(value)
def encode_cursor(*, scope: str, key: Key) -> str:
payload = {
"v": 1,
"scope": scope,
"at": timestamp(key[0]),
"id": str(key[1]),
}
return (
base64.urlsafe_b64encode(
json.dumps(payload, separators=(",", ":")).encode()
)
.decode()
.rstrip("=")
)
def decode_cursor(*, value: str | None, scope: str) -> Key | None:
if value is None:
return None
try:
if (
not value
or len(value) > 2048
or not re.fullmatch(r"[A-Za-z0-9_-]+", value)
):
raise ValueError
data = json.loads(
base64.b64decode(
value + "=" * (-len(value) % 4), altchars=b"-_", validate=True
)
)
if (
not isinstance(data, dict)
or type(data.get("v")) is not int
or data["v"] != 1
or data.get("scope") != scope
or not isinstance(data.get("at"), str)
):
raise ValueError
at = datetime.fromisoformat(data["at"])
if at.tzinfo is None or timestamp(at) != data["at"]:
raise ValueError
return at, parse_uuid(data["id"])
except ValueError, TypeError, KeyError, binascii.Error, RecursionError:
raise invalid() from None
+69
View File
@@ -0,0 +1,69 @@
import time
from contextlib import contextmanager
import psycopg
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool, PoolTimeout
from src.errors import DomainError
class DeadlineConnection(psycopg.Connection):
"""Клиентский срок действует и при замороженном PostgreSQL."""
def wait(self, gen, interval=0.1, timeout=None):
deadline = getattr(self, "request_deadline", None)
remaining = (
max(0.001, deadline - time.monotonic()) if deadline else 3.0
)
bound = min(remaining, timeout) if timeout is not None else remaining
try:
return super().wait(gen, interval=interval, timeout=bound)
except psycopg.OperationalError:
self.close()
raise
class Database:
def __init__(self, *, url: str, size: int):
self.pool = ConnectionPool(
url,
connection_class=DeadlineConnection,
kwargs={
"autocommit": True,
"row_factory": dict_row,
"connect_timeout": 2,
"options": (
"-c statement_timeout=2500 -c lock_timeout=1000 "
"-c idle_in_transaction_session_timeout=6000"
),
},
min_size=1,
max_size=size,
timeout=1,
open=False,
)
def open(self):
self.pool.open(wait=True, timeout=10)
def close(self):
self.pool.close(timeout=2)
@contextmanager
def connection(self):
try:
with self.pool.connection(timeout=1) as conn:
conn.request_deadline = time.monotonic() + 4
try:
yield conn
finally:
conn.request_deadline = None
except psycopg.OperationalError, psycopg.InterfaceError, PoolTimeout:
raise DomainError(
503, "unavailable", "Database unavailable"
) from None
def ping(self):
with self.connection() as conn:
conn.execute("SELECT 1").fetchone()
+45
View File
@@ -0,0 +1,45 @@
from dataclasses import dataclass
from datetime import UTC, datetime
from uuid import UUID
def utcnow() -> datetime:
return datetime.now(UTC)
def timestamp(value: datetime) -> str:
return value.isoformat(timespec="microseconds").replace("+00:00", "Z")
@dataclass(frozen=True, slots=True)
class User:
id: UUID
username: str
display_name: str
created_at: datetime
@dataclass(frozen=True, slots=True)
class Chat:
id: UUID
title: str
member_ids: tuple[UUID, ...]
created_at: datetime
@dataclass(frozen=True, slots=True)
class Message:
id: UUID
chat_id: UUID
sender_id: UUID
text: str
created_at: datetime
attachment_ids: tuple[UUID, ...] = ()
type Record = User | Chat | Message
type Key = tuple[datetime, UUID]
def order_key(record: Record) -> Key:
return record.created_at, record.id
+16
View File
@@ -0,0 +1,16 @@
class DomainError(Exception):
def __init__(
self, status: int, code: str, message: str, headers=None
) -> None:
self.status = status
self.code = code
self.message = message
self.headers = headers or {}
def invalid() -> DomainError:
return DomainError(400, "invalid_request", "Invalid request")
def not_found() -> DomainError:
return DomainError(404, "not_found", "Resource not found")
+77
View File
@@ -0,0 +1,77 @@
import struct
import threading
import unicodedata
import zlib
from PIL import Image, UnidentifiedImageError
from src.errors import DomainError, invalid
MAX_BYTES = 10 * 1024 * 1024
MAX_PIXELS = 40_000_000
Image.MAX_IMAGE_PIXELS = MAX_PIXELS
DECODE_SLOT = threading.BoundedSemaphore(1)
def filename(value):
if (
not value
or not 1 <= len(value) <= 255
or not value.strip()
or any(
c in "/\\" or unicodedata.category(c) in {"Cc", "Cs"}
for c in value
)
):
raise invalid()
return value
def verify(stream, *, declared):
if declared not in {"image/png", "image/jpeg"}:
raise DomainError(
415, "unsupported_media_type", "PNG or JPEG required"
)
with DECODE_SLOT:
try:
stream.seek(0)
with Image.open(stream) as image:
actual = {"PNG": "image/png", "JPEG": "image/jpeg"}.get(
image.format
)
if actual != declared:
raise DomainError(
415, "unsupported_media_type", "Image type mismatch"
)
if image.width * image.height > MAX_PIXELS:
raise DomainError(
413, "payload_too_large", "Pixel limit exceeded"
)
image.verify()
# JPEG verify alone does not decode entropy data.
stream.seek(0)
with Image.open(stream) as image:
image.load()
except Image.DecompressionBombError:
raise DomainError(
413, "payload_too_large", "Pixel limit exceeded"
) from None
except (
UnidentifiedImageError,
OSError,
ValueError,
SyntaxError,
struct.error,
zlib.error,
EOFError,
):
raise DomainError(
415, "unsupported_media_type", "Invalid image"
) from None
except MemoryError:
raise DomainError(
503, "unavailable", "Image memory budget exceeded"
) from None
finally:
stream.seek(0)
return declared
+17
View File
@@ -0,0 +1,17 @@
import json
import logging
from datetime import UTC, datetime
class JsonFormatter(logging.Formatter):
def format(self, record: logging.LogRecord) -> str:
message = record.getMessage()
try:
event = json.loads(message)
if not isinstance(event, dict):
event = {"event": message}
except ValueError:
event = {"event": message}
event["timestamp"] = datetime.now(UTC).isoformat()
event["level"] = record.levelname.lower()
return json.dumps(event, ensure_ascii=False)
+51
View File
@@ -0,0 +1,51 @@
import hashlib
import json
from pathlib import Path
import psycopg
from src.settings import secret
def main():
with psycopg.connect(
secret("DATABASE_URL"), autocommit=True, connect_timeout=3
) as conn:
conn.execute("SELECT pg_advisory_lock(2301002)")
try:
conn.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations "
"(name text PRIMARY KEY, checksum text NOT NULL, "
"applied_at timestamptz NOT NULL DEFAULT now())"
)
for path in sorted(Path("migrations").glob("*.sql")):
content = path.read_bytes()
checksum = hashlib.sha256(content).hexdigest()
row = conn.execute(
"SELECT checksum FROM schema_migrations WHERE name=%s",
(path.name,),
).fetchone()
if row:
if row[0] != checksum:
raise RuntimeError(
"Applied migration checksum mismatch"
)
continue
with conn.transaction():
conn.execute(content.decode())
conn.execute(
"INSERT INTO schema_migrations(name,checksum) "
"VALUES(%s,%s)",
(path.name, checksum),
)
print(
json.dumps(
{"event": "migration_applied", "name": path.name}
)
)
finally:
conn.execute("SELECT pg_advisory_unlock(2301002)")
if __name__ == "__main__":
main()
+84
View File
@@ -0,0 +1,84 @@
from contextlib import contextmanager
import urllib3
from minio import Minio
from minio.error import S3Error
from src.errors import DomainError
from src.settings import secret
BUCKET = "messenger"
class ObjectStore:
def __init__(self):
self.http = urllib3.PoolManager(
maxsize=32,
block=True,
timeout=urllib3.Timeout(connect=1, read=3),
retries=urllib3.Retry(total=0),
)
self.client = Minio(
"s3:9000",
access_key=secret("S3_ACCESS_KEY"),
secret_key=secret("S3_SECRET_KEY"),
secure=False,
region="us-east-1",
http_client=self.http,
)
@contextmanager
def operation(self):
try:
yield
except S3Error, urllib3.exceptions.HTTPError, OSError:
raise DomainError(
503, "unavailable", "Object store unavailable"
) from None
def ping(self):
with self.operation():
if not self.client.bucket_exists(BUCKET):
raise DomainError(
503, "unavailable", "Object store unavailable"
)
def put(self, *, key, stream, size, content_type, sha256):
stream.seek(0)
with self.operation():
self.client.put_object(
BUCKET,
key,
stream,
length=size,
content_type=content_type,
metadata={"sha256": sha256},
part_size=10 * 1024 * 1024,
num_parallel_uploads=1,
)
def head(self, *, key):
with self.operation():
try:
return self.client.stat_object(BUCKET, key)
except S3Error as exc:
if exc.code in {"NoSuchKey", "NoSuchObject"}:
return None
raise
def get(self, *, key):
with self.operation():
return self.client.get_object(BUCKET, key)
def delete(self, *, key):
with self.operation():
self.client.remove_object(BUCKET, key)
def objects(self):
with self.operation():
yield from self.client.list_objects(
BUCKET, prefix="objects/", recursive=True
)
def close(self):
self.http.clear()
+36
View File
@@ -0,0 +1,36 @@
import threading
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
from argon2.low_level import Type
from src.errors import DomainError
class Passwords:
def __init__(self):
self.hasher = PasswordHasher(
time_cost=3, memory_cost=65536, parallelism=4, type=Type.ID
)
self.slots = threading.BoundedSemaphore(2)
self.dummy = self.hasher.hash("Synthetic-dummy-password-not-for-login")
def _run(self, function, *args):
if not self.slots.acquire(timeout=5):
raise DomainError(503, "unavailable", "Authentication busy")
try:
return function(*args)
finally:
self.slots.release()
def hash(self, *, password: str) -> str:
return self._run(self.hasher.hash, password)
def verify(self, *, password: str, encoded: str | None) -> bool:
try:
return (
self._run(self.hasher.verify, encoded or self.dummy, password)
and encoded is not None
)
except VerificationError, InvalidHashError:
return False
+200
View File
@@ -0,0 +1,200 @@
"""Сверка двух stores: dry-run по умолчанию, grace не менее пяти минут."""
import argparse
import hashlib
import json
import time
from datetime import timedelta
from src.database import Database
from src.object_store import ObjectStore
from src.settings import integer, secret
def verified(store, row, counters):
counters["head_requests"] += 1
info = store.head(key=row["object_key"])
if info is None:
return "missing"
if info.size != row["size_bytes"]:
return "mismatch"
result = store.get(key=row["object_key"])
digest = hashlib.sha256()
size = 0
try:
while data := result.read(65536):
digest.update(data)
size += len(data)
counters["bytes_read"] += len(data)
if size > 10 * 1024 * 1024:
return "mismatch"
finally:
result.close()
result.release_conn()
return "valid" if digest.hexdigest() == row["sha256"] else "mismatch"
def reconcile(database, store, *, apply, grace):
started = time.monotonic()
result = {
"apply": apply,
"grace_seconds": grace,
"objects_scanned": 0,
"rows_scanned": 0,
"head_requests": 0,
"bytes_read": 0,
"fresh_protected": 0,
"ready_protected": 0,
"linked_protected": 0,
"actions": {},
"applied": {},
"details": [],
}
with database.connection() as conn:
now = conn.execute("SELECT clock_timestamp() AS at").fetchone()["at"]
rows = conn.execute("SELECT * FROM attachments ORDER BY id").fetchall()
cutoff = now - timedelta(seconds=grace)
objects = {o.object_name: o for o in store.objects()}
result["objects_scanned"] = len(objects)
result["rows_scanned"] = len(rows)
keys = {r["object_key"] for r in rows}
def record(action, identity, *, changed=False):
result["actions"][action] = result["actions"].get(action, 0) + 1
if changed:
result["applied"][action] = result["applied"].get(action, 0) + 1
if len(result["details"]) < 20:
result["details"].append(
{"action": action, "identity": str(identity)}
)
for key, obj in objects.items():
if obj.last_modified > cutoff:
result["fresh_protected"] += 1
continue
if key in keys:
continue
changed = False
if apply:
with database.connection() as conn, conn.transaction():
# Fresh intents are checked again immediately before deletion.
exists = conn.execute(
"SELECT 1 FROM attachments WHERE object_key=%s", (key,)
).fetchone()
if exists:
continue
current = store.head(key=key)
result["head_requests"] += 1
if current is not None and current.last_modified > cutoff:
result["fresh_protected"] += 1
continue
store.delete(key=key)
changed = True
record("delete_orphan", key, changed=changed)
for snapshot in rows:
if snapshot["created_at"] > cutoff:
continue
with database.connection() as conn, conn.transaction():
row = conn.execute(
"SELECT * FROM attachments WHERE id=%s FOR UPDATE",
(snapshot["id"],),
).fetchone()
if row is None or row["created_at"] > cutoff:
continue
action = None
if row["state"] == "pending":
state = verified(store, row, result)
action = (
"recover_pending"
if state == "valid"
else "fail_pending_" + state
)
if apply:
conn.execute(
"UPDATE attachments SET state=%s,error_code=%s,"
"updated_at=clock_timestamp() WHERE id=%s",
(
"ready" if state == "valid" else "failed",
None if state == "valid" else "upload_" + state,
row["id"],
),
)
elif row["state"] == "ready":
result["head_requests"] += 1
info = store.head(key=row["object_key"])
if info is not None:
# A ready attachment stays even if it has no Message link.
result["ready_protected"] += 1
continue
action = "mark_missing"
if apply:
conn.execute(
"UPDATE attachments SET state='failed',"
"error_code='original_missing',"
"updated_at=clock_timestamp() WHERE id=%s",
(row["id"],),
)
else:
linked = conn.execute(
"SELECT 1 FROM message_attachments "
"WHERE attachment_id=%s LIMIT 1",
(row["id"],),
).fetchone()
if linked:
result["linked_protected"] += 1
continue
obj = objects.get(row["object_key"])
if obj is None or obj.last_modified > cutoff:
continue
action = "delete_failed_object"
if apply:
# A timed-out uploader may finish PUT after LIST.
# Recheck freshness before removing its object.
current = store.head(key=row["object_key"])
result["head_requests"] += 1
if current is not None and current.last_modified > cutoff:
result["fresh_protected"] += 1
continue
store.delete(key=row["object_key"])
if action:
record(action, row["id"], changed=apply)
result["duration_seconds"] = round(time.monotonic() - started, 6)
result["complete"] = True
return result
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--apply", action="store_true")
parser.add_argument("--loop", action="store_true")
args = parser.parse_args()
grace = integer("RECONCILE_GRACE_SECONDS", 300, 300, 604800)
database = Database(url=secret("DATABASE_URL"), size=2)
store = ObjectStore()
try:
database.open()
while True:
try:
result = reconcile(
database, store, apply=args.apply, grace=grace
)
print(json.dumps(result, ensure_ascii=False), flush=True)
except Exception as exc:
print(
json.dumps(
{"complete": False, "error": type(exc).__name__}
),
flush=True,
)
if not args.loop:
raise SystemExit(1) from None
if not args.loop:
break
time.sleep(60)
finally:
store.close()
database.close()
if __name__ == "__main__":
main()
+296
View File
@@ -0,0 +1,296 @@
import hashlib
import json
from uuid import UUID
from psycopg.errors import ForeignKeyViolation, UniqueViolation
from src.cache import UserCache
from src.database import Database
from src.domain import Chat, Key, Message, User
from src.errors import DomainError, invalid, not_found
MESSAGE_COLUMNS = (
"m.*, ARRAY(SELECT attachment_id FROM message_attachments ma "
"WHERE ma.message_id=m.id ORDER BY ma.position) attachment_ids"
)
USER_COLUMNS = "id, username, display_name, created_at"
def user_dto(row) -> User:
return User(
row["id"], row["username"], row["display_name"], row["created_at"]
)
def chat_dto(row) -> Chat:
return Chat(
row["id"], row["title"], tuple(row["member_ids"]), row["created_at"]
)
def message_dto(row) -> Message:
return Message(
row["id"],
row["chat_id"],
row["sender_id"],
row["text"],
row["created_at"],
tuple(row.get("attachment_ids", ())),
)
class PostgresRepository:
def __init__(self, *, database: Database, cache: UserCache):
self.database = database
self.cache = cache
def add_user(self, *, user: User, password_hash: str) -> User:
try:
with self.database.connection() as conn:
conn.execute(
"INSERT INTO users(id,username,display_name,"
"password_hash,created_at) VALUES(%s,%s,%s,%s,%s)",
(
user.id,
user.username,
user.display_name,
password_hash,
user.created_at,
),
)
except UniqueViolation:
raise DomainError(
409, "conflict", "Username already exists"
) from None
return user
def get_user(self, *, user_id: UUID) -> User | None:
cached = self.cache.get(user_id=user_id)
if cached is not None:
return cached
with self.database.connection() as conn:
row = conn.execute(
"SELECT " + USER_COLUMNS + " FROM users WHERE id=%s",
(user_id,),
).fetchone()
if row is None:
return None
user = user_dto(row)
self.cache.put(user=user)
return user
def credentials(self, *, username: str):
with self.database.connection() as conn:
row = conn.execute(
"SELECT "
+ USER_COLUMNS
+ ", password_hash FROM users WHERE username=%s",
(username,),
).fetchone()
if row is None:
return None, None
return user_dto(row), row["password_hash"]
def username_exists(self, *, username: str) -> bool:
with self.database.connection() as conn:
return (
conn.execute(
"SELECT 1 FROM users WHERE username=%s", (username,)
).fetchone()
is not None
)
def add_session(
self, *, digest: bytes, user_id: UUID, created_at, expires_at
):
with self.database.connection() as conn:
conn.execute(
"INSERT INTO sessions(token_digest,user_id,created_at,"
"expires_at) VALUES(%s,%s,%s,%s)",
(digest, user_id, created_at, expires_at),
)
def session_user(self, *, digest: bytes) -> UUID | None:
with self.database.connection() as conn:
row = conn.execute(
"SELECT user_id FROM sessions WHERE token_digest=%s "
"AND expires_at>clock_timestamp()",
(digest,),
).fetchone()
return row["user_id"] if row else None
def delete_session(self, *, digest: bytes):
with self.database.connection() as conn:
conn.execute(
"DELETE FROM sessions WHERE token_digest=%s", (digest,)
)
def add_chat(self, *, chat: Chat, actor_id: UUID) -> Chat:
members = chat.member_ids
if actor_id not in members or len(set(members)) != len(members):
raise invalid()
try:
with self.database.connection() as conn, conn.transaction():
conn.execute(
"INSERT INTO chats(id,title,created_at) VALUES(%s,%s,%s)",
(chat.id, chat.title, chat.created_at),
)
with conn.cursor() as cursor:
cursor.executemany(
"INSERT INTO members(chat_id,user_id,position) "
"VALUES(%s,%s,%s)",
[
(chat.id, user_id, position)
for position, user_id in enumerate(members)
],
)
except ForeignKeyViolation:
raise invalid() from None
return chat
def get_chat(self, *, chat_id: UUID, actor_id: UUID) -> Chat:
with self.database.connection() as conn:
row = conn.execute(
"SELECT c.id,c.title,c.created_at,"
"array_agg(m.user_id ORDER BY m.position) member_ids "
"FROM chats c JOIN members m ON m.chat_id=c.id "
"WHERE c.id=%s AND EXISTS(SELECT 1 FROM members own "
"WHERE own.chat_id=c.id AND own.user_id=%s) GROUP BY c.id",
(chat_id, actor_id),
).fetchone()
if row is None:
raise not_found()
return chat_dto(row)
def add_message(
self, *, message: Message, idempotency_key: str
) -> Message:
# Область включает пользователя, метод и нормализованный путь чата.
scope = f"{message.sender_id}:POST:{message.chat_id}:{idempotency_key}"
lock = int.from_bytes(
hashlib.sha256(scope.encode()).digest()[:8], "big", signed=True
)
fingerprint = hashlib.sha256(
json.dumps(
{
"text": message.text,
"attachment_ids": [str(x) for x in message.attachment_ids],
},
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
).encode()
).digest()
try:
with self.database.connection() as conn, conn.transaction():
conn.execute("SELECT pg_advisory_xact_lock(%s)", (lock,))
prior = conn.execute(
"SELECT i.body_hash,i.message_id,"
"i.expires_at>clock_timestamp() active "
"FROM idempotency i WHERE user_id=%s AND chat_id=%s "
"AND key=%s FOR UPDATE",
(message.sender_id, message.chat_id, idempotency_key),
).fetchone()
if prior and prior["active"]:
if bytes(prior["body_hash"]) != fingerprint:
raise DomainError(409, "conflict", "Key already used")
row = conn.execute(
"SELECT "
+ MESSAGE_COLUMNS
+ " FROM messages m WHERE m.id=%s",
(prior["message_id"],),
).fetchone()
return message_dto(row)
if message.attachment_ids:
rows = conn.execute(
"SELECT id,state FROM attachments WHERE chat_id=%s "
"AND id=ANY(%s) FOR SHARE",
(message.chat_id, list(message.attachment_ids)),
).fetchall()
if len(rows) != len(message.attachment_ids):
raise not_found()
if any(row["state"] != "ready" for row in rows):
raise DomainError(
409, "conflict", "Attachment is not ready"
)
conn.execute(
"INSERT INTO messages(id,chat_id,sender_id,"
"text,created_at) "
"VALUES(%s,%s,%s,%s,%s)",
(
message.id,
message.chat_id,
message.sender_id,
message.text,
message.created_at,
),
)
if message.attachment_ids:
with conn.cursor() as cursor:
cursor.executemany(
"INSERT INTO message_attachments("
"message_id,chat_id,"
"attachment_id,position) "
"VALUES(%s,%s,%s,%s)",
[
(message.id, message.chat_id, aid, i)
for i, aid in enumerate(message.attachment_ids)
],
)
conn.execute(
"INSERT INTO idempotency(user_id,chat_id,key,body_hash,"
"message_id,expires_at) VALUES(%s,%s,%s,%s,%s,"
"clock_timestamp()+interval '24 hours') "
"ON CONFLICT(user_id,chat_id,key) DO UPDATE SET "
"body_hash=excluded.body_hash,message_id=excluded.message_id,"
"expires_at=excluded.expires_at",
(
message.sender_id,
message.chat_id,
idempotency_key,
fingerprint,
message.id,
),
)
except ForeignKeyViolation:
raise not_found() from None
return message
def list_chats(
self, *, actor_id: UUID, after: Key | None, limit: int
) -> list[Chat]:
condition = "AND (c.created_at,c.id)>(%s,%s)" if after else ""
parameters = (
[actor_id, *after, limit + 1] if after else [actor_id, limit + 1]
)
with self.database.connection() as conn:
rows = conn.execute(
"SELECT c.id,c.title,c.created_at,ARRAY(SELECT user_id "
"FROM members WHERE chat_id=c.id "
"ORDER BY position) member_ids "
"FROM chats c JOIN members own ON own.chat_id=c.id "
"WHERE own.user_id=%s "
+ condition
+ " ORDER BY c.created_at,c.id LIMIT %s",
parameters,
).fetchall()
return [chat_dto(row) for row in rows]
def list_messages(
self, *, chat_id: UUID, actor_id: UUID, after: Key | None, limit: int
) -> list[Message]:
condition = "AND (m.created_at,m.id)>(%s,%s)" if after else ""
parameters = (
[chat_id, *after, limit + 1] if after else [chat_id, limit + 1]
)
with self.database.connection() as conn:
rows = conn.execute(
"SELECT "
+ MESSAGE_COLUMNS
+ " FROM messages m WHERE m.chat_id=%s "
+ condition
+ " ORDER BY m.created_at,m.id LIMIT %s",
parameters,
).fetchall()
return [message_dto(row) for row in rows]
+65
View File
@@ -0,0 +1,65 @@
import re
from typing import Annotated
from uuid import UUID
from pydantic import (
BaseModel,
BeforeValidator,
ConfigDict,
Field,
StrictStr,
ValidationInfo,
field_validator,
model_validator,
)
from src.cursor import parse_uuid
UuidIn = Annotated[UUID, BeforeValidator(parse_uuid)]
class Input(BaseModel):
model_config = ConfigDict(extra="forbid")
@field_validator("*", mode="after")
@classmethod
def nonblank(cls, value: object, info: ValidationInfo) -> object:
if isinstance(value, str) and (
(not value.strip() and info.field_name != "text")
or any(0xD800 <= ord(c) <= 0xDFFF for c in value)
):
raise ValueError("Invalid text")
return value
class CreateUser(Input):
username: StrictStr
display_name: StrictStr = Field(min_length=1, max_length=100)
password: StrictStr = Field(min_length=12, max_length=128)
@field_validator("username")
@classmethod
def username_format(cls, value: str) -> str:
if not re.fullmatch(r"[a-z0-9_]{3,32}", value):
raise ValueError("Invalid username")
return value
class CreateChat(Input):
title: StrictStr = Field(min_length=1, max_length=100)
member_ids: list[UuidIn] = Field(min_length=1, max_length=100, strict=True)
class CreateMessage(Input):
text: StrictStr = Field(max_length=4000)
attachment_ids: list[UuidIn] = Field(
default_factory=list, max_length=10, strict=True
)
@model_validator(mode="after")
def content(self):
if len(set(self.attachment_ids)) != len(self.attachment_ids):
raise ValueError("Duplicate attachment")
if not self.text.strip() and not self.attachment_ids:
raise ValueError("Empty message")
return self
+192
View File
@@ -0,0 +1,192 @@
import base64
import hashlib
import re
import secrets
import threading
from datetime import timedelta
from uuid import UUID, uuid4
from src.cursor import decode_cursor, encode_cursor
from src.domain import Chat, Message, Record, User, order_key, utcnow
from src.errors import DomainError, invalid, not_found
from src.password import Passwords
from src.repository import PostgresRepository
def page(*, rows: list[Record], limit: int, scope: str) -> dict:
items = rows[:limit]
cursor = (
encode_cursor(scope=scope, key=order_key(items[-1]))
if len(rows) > limit
else None
)
return {"items": items, "next_cursor": cursor}
def unauthorized(*, basic=False):
challenge = (
'Basic realm="messenger", charset="UTF-8"'
if basic
else 'Bearer realm="messenger"'
)
return DomainError(
401,
"unauthorized",
"Authentication required",
{"WWW-Authenticate": challenge},
)
def bearer(value):
if not value:
raise unauthorized()
scheme, _, token = value.partition(" ")
if scheme.lower() != "bearer" or not re.fullmatch(
r"[A-Za-z0-9_-]{32,256}", token
):
raise unauthorized()
return token
def token_digest(value):
return hashlib.sha256(value.encode()).digest()
class MessengerService:
def __init__(
self,
*,
repository: PostgresRepository,
passwords: Passwords,
session_ttl: int,
) -> None:
self.repository = repository
self.passwords = passwords
self.session_ttl = session_ttl
self.registration_locks = [threading.Lock() for _ in range(64)]
def identify(self, *, value: str | None) -> User:
token = bearer(value)
user_id = self.repository.session_user(digest=token_digest(token))
user = self.repository.get_user(user_id=user_id) if user_id else None
if user is None:
raise unauthorized()
return user
def register(
self, *, username: str, display_name: str, password: str
) -> User:
# Bound lock memory and avoid running Argon2 for every local duplicate.
# Different replicas still race safely through PostgreSQL UNIQUE.
stripe = hashlib.sha256(username.encode()).digest()[0] % 64
lock = self.registration_locks[stripe]
if not lock.acquire(timeout=8):
raise DomainError(503, "unavailable", "Registration busy")
try:
if self.repository.username_exists(username=username):
raise DomainError(409, "conflict", "Username already exists")
encoded = self.passwords.hash(password=password)
return self.repository.add_user(
user=User(uuid4(), username, display_name, utcnow()),
password_hash=encoded,
)
finally:
lock.release()
def login(self, *, authorization: str | None):
try:
scheme, _, encoded = (authorization or "").partition(" ")
if scheme.lower() != "basic":
raise ValueError
plain = base64.b64decode(encoded, validate=True).decode("utf-8")
username, separator, password = plain.partition(":")
if (
not separator
or not re.fullmatch(r"[a-z0-9_]{3,32}", username)
or not 12 <= len(password) <= 128
or not password.strip()
):
raise ValueError
except ValueError, UnicodeError:
raise unauthorized(basic=True) from None
user, password_hash = self.repository.credentials(username=username)
if not self.passwords.verify(password=password, encoded=password_hash):
raise unauthorized(basic=True)
now = utcnow()
expires = now + timedelta(seconds=self.session_ttl)
token = secrets.token_urlsafe(32)
self.repository.add_session(
digest=token_digest(token),
user_id=user.id,
created_at=now,
expires_at=expires,
)
return {
"token": token,
"token_type": "Bearer",
"expires_at": expires,
"user": user,
}
def logout(self, *, authorization: str | None):
self.identify(value=authorization)
self.repository.delete_session(
digest=token_digest(bearer(authorization))
)
def create_chat(
self, *, actor_id: UUID, title: str, member_ids: list[UUID]
) -> Chat:
return self.repository.add_chat(
chat=Chat(uuid4(), title, tuple(member_ids), utcnow()),
actor_id=actor_id,
)
def get_chat(self, *, actor_id: UUID, chat_id: UUID) -> Chat:
return self.repository.get_chat(actor_id=actor_id, chat_id=chat_id)
def send(
self,
*,
actor_id: UUID,
chat_id: UUID,
text: str,
idempotency_key: str | None,
attachment_ids: list[UUID],
) -> Message:
if not idempotency_key or not re.fullmatch(
r"[A-Za-z0-9._:-]{1,128}", idempotency_key
):
raise invalid()
return self.repository.add_message(
message=Message(
uuid4(),
chat_id,
actor_id,
text,
utcnow(),
tuple(attachment_ids),
),
idempotency_key=idempotency_key,
)
def chats(self, *, actor_id: UUID, limit: int, cursor: str | None) -> dict:
scope = f"chats:{actor_id}"
after = decode_cursor(value=cursor, scope=scope)
rows = self.repository.list_chats(
actor_id=actor_id, after=after, limit=limit
)
return page(rows=rows, limit=limit, scope=scope)
def history(
self, *, actor_id: UUID, chat: Chat, limit: int, cursor: str | None
) -> dict:
if actor_id not in chat.member_ids:
raise not_found()
chat_id = chat.id
scope = f"messages:{chat_id}"
after = decode_cursor(value=cursor, scope=scope)
rows = self.repository.list_messages(
actor_id=actor_id, chat_id=chat_id, after=after, limit=limit
)
return page(rows=rows, limit=limit, scope=scope)
+37
View File
@@ -0,0 +1,37 @@
import os
from dataclasses import dataclass, field
from pathlib import Path
def secret(name: str) -> str:
file = os.environ.get(name + "_FILE")
if file:
return Path(file).read_text().strip()
value = os.environ.get(name)
if not value:
raise ValueError("Missing required secret setting: " + name)
return value
def integer(name: str, default: int, low: int, high: int) -> int:
value = int(os.environ.get(name, str(default)))
if not low <= value <= high:
raise ValueError("Invalid setting: " + name)
return value
@dataclass(frozen=True)
class Settings:
database_url: str = field(repr=False)
cache_url: str = field(repr=False)
session_ttl: int = 3600
pool_size: int = 10
@classmethod
def load(cls):
return cls(
secret("DATABASE_URL"),
secret("CACHE_URL"),
integer("SESSION_TTL_SECONDS", 3600, 1, 86400),
integer("DB_POOL_SIZE", 10, 1, 32),
)
+119
View File
@@ -0,0 +1,119 @@
import json
import os
from pathlib import Path
from uuid import uuid4
import httpx
import pytest
from jsonschema import Draft202012Validator, FormatChecker
CONTRACT = json.loads(
(Path(__file__).parents[1] / "contracts/openapi.json").read_text()
)
BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8084")
PASSWORD = "Synthetic-Password-🌍-123"
TOKENS = {}
def check(result: httpx.Response, status: int, schema: str) -> dict:
assert result.status_code == status, result.text
assert result.headers["x-request-id"]
assert result.headers["x-instance-id"]
assert result.headers["content-type"].startswith("application/json")
payload = result.json()
spec = {"$ref": f"#/components/schemas/{schema}", **CONTRACT}
Draft202012Validator(spec, format_checker=FormatChecker()).validate(
payload
)
if schema == "Error":
assert payload["error"]["request_id"] == result.headers["x-request-id"]
assert (
payload["error"]["code"]
== {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
413: "payload_too_large",
415: "unsupported_media_type",
429: "rate_limited",
500: "internal_error",
503: "unavailable",
}[status]
)
return payload
def register(client: httpx.Client, **overrides) -> dict:
data = {
"username": "u_" + uuid4().hex[:24],
"display_name": "Алиса 🌍",
"password": PASSWORD,
}
data.update(overrides)
user = check(client.post("/api/v1/users", json=data), 201, "User")
session = check(
client.post(
"/api/v1/auth/sessions",
auth=httpx.BasicAuth(data["username"], data["password"]),
),
201,
"Session",
)
TOKENS[user["id"]] = session["token"]
return user
@pytest.fixture
def client():
with httpx.Client(
base_url=BASE_URL, timeout=15, trust_env=False
) as client:
yield client
@pytest.fixture
def actors(client):
return register(client), register(client), register(client)
@pytest.fixture
def chat(client, actors):
alice, bob, _ = actors
return check(
client.post(
"/api/v1/chats",
headers=headers(alice),
json={"title": "Учёба 🌍", "member_ids": [alice["id"], bob["id"]]},
),
201,
"Chat",
)
def headers(actor: dict) -> dict:
return {
"Authorization": "Bearer " + TOKENS[actor["id"]],
"Idempotency-Key": uuid4().hex,
}
def history(client, actor, chat_id, limit=7):
found, cursor = [], None
while True:
params = {"limit": limit}
if cursor:
params["cursor"] = cursor
page = check(
client.get(
f"/api/v1/chats/{chat_id}/messages",
headers=headers(actor),
params=params,
),
200,
"MessagePage",
)
found.extend(page["items"])
cursor = page["next_cursor"]
if cursor is None:
return found
+412
View File
@@ -0,0 +1,412 @@
import base64
import json
import threading
from concurrent.futures import ThreadPoolExecutor
from uuid import UUID, uuid4
import httpx
import pytest
from conftest import BASE_URL, PASSWORD, check, headers, history, register
@pytest.mark.parametrize("path", ["/health/live", "/health/ready"])
def test_health(client, path):
assert check(client.get(path), 200, "Health") == {"status": "ok"}
@pytest.mark.parametrize(
"value", [None, "not-a-uuid", str(uuid4()), uuid4().hex]
)
def test_identification(client, value):
check(
client.get(
"/api/v1/users/me", headers={"X-User-Id": value} if value else {}
),
401,
"Error",
)
def test_identity(client, actors):
assert (
check(
client.get("/api/v1/users/me", headers=headers(actors[0])),
200,
"User",
)
== actors[0]
)
@pytest.mark.parametrize(
"data",
[
{},
[],
None,
{"username": "ABC", "display_name": "A"},
{"username": "abc\n", "display_name": "A"},
{"username": 123, "display_name": "A"},
{"username": "abc", "display_name": " "},
{"username": "abc", "display_name": "x" * 101},
{"username": "abc", "display_name": "A", "extra": True},
{"username": "abc", "display_name": "\ud800"},
],
)
def test_invalid_user(client, data):
if isinstance(data, dict):
data = {"password": PASSWORD, **data}
check(client.post("/api/v1/users", content=json.dumps(data)), 400, "Error")
@pytest.mark.parametrize(
"raw", [b"{", b"NaN", b'{"username":"abc", "display_name":NaN}', b"\xff"]
)
def test_malformed_json(client, raw):
check(client.post("/api/v1/users", content=raw), 400, "Error")
def test_auth_before_json(client):
check(client.post("/api/v1/chats", content=b"{"), 401, "Error")
def test_duplicate_username(client, actors):
check(
client.post(
"/api/v1/users",
json={
"username": actors[0]["username"],
"display_name": "B",
"password": PASSWORD,
},
),
409,
"Error",
)
def test_unicode_codepoints(client, actors, chat):
user = register(client, display_name="🌍" * 100)
assert user["display_name"] == "🌍" * 100
text = "🌍" * 4000
result = check(
client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers=headers(actors[0]),
json={"text": text},
),
201,
"Message",
)
assert result["text"] == text
assert result["sender_id"] == actors[0]["id"]
@pytest.mark.parametrize(
"method,suffix,body",
[
("GET", "", None),
("GET", "/messages", None),
("POST", "/messages", {"text": "hello"}),
],
)
def test_acl(client, actors, chat, method, suffix, body):
outsider = headers(actors[2])
actual = check(
client.request(
method,
f"/api/v1/chats/{chat['id']}{suffix}",
headers=outsider,
json=body,
),
404,
"Error",
)
missing = check(
client.request(
method,
f"/api/v1/chats/{uuid4()}{suffix}",
headers=outsider,
json=body,
),
404,
"Error",
)
assert actual["error"]["message"] == missing["error"]["message"]
@pytest.mark.parametrize("value", ["", " \t\n", 42, True, None, "a" * 4001])
def test_bad_message(client, actors, chat, value):
check(
client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers=headers(actors[0]),
json={"text": value},
),
400,
"Error",
)
def test_sender_not_client_controlled(client, actors, chat):
check(
client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers=headers(actors[0]),
json={"text": "Hi", "sender_id": actors[1]["id"]},
),
400,
"Error",
)
@pytest.mark.parametrize(
"case",
[
"duplicate",
"unknown",
"no_caller",
"empty",
"wrong_type",
"bad_uuid",
"too_many",
"blank_title",
],
)
def test_invalid_chat(client, actors, case):
a, b, _ = actors
members = {
"duplicate": [a["id"], a["id"]],
"unknown": [a["id"], str(uuid4())],
"no_caller": [b["id"]],
"empty": [],
"wrong_type": a["id"],
"bad_uuid": ["broken"],
"too_many": [str(uuid4()) for _ in range(101)],
"blank_title": [a["id"]],
}[case]
check(
client.post(
"/api/v1/chats",
headers=headers(a),
json={
"title": " " if case == "blank_title" else "Title",
"member_ids": members,
},
),
400,
"Error",
)
@pytest.mark.parametrize(
"limit", ["0", "101", "-1", "1.5", "true", "1e1", "", "12"]
)
def test_bad_limit(client, actors, chat, limit):
check(
client.get(
f"/api/v1/chats/{chat['id']}/messages",
headers=headers(actors[0]),
params={"limit": limit},
),
400,
"Error",
)
@pytest.mark.parametrize(
"cursor", ["", "broken", "W10", "e30", "*", "x" * 2049]
)
def test_bad_cursor(client, actors, chat, cursor):
check(
client.get(
f"/api/v1/chats/{chat['id']}/messages",
headers=headers(actors[0]),
params={"cursor": cursor},
),
400,
"Error",
)
def test_pagination(client, actors, chat):
a, b, outsider = actors
sent = []
path = f"/api/v1/chats/{chat['id']}/messages"
for i in range(23):
sent.append(
check(
client.post(
path,
headers=headers(a if i % 2 else b),
json={"text": f"Msg {i}"},
),
201,
"Message",
)
)
got = history(client, a, chat["id"])
assert got == sorted(
sent, key=lambda m: (m["created_at"], UUID(m["id"]).int)
)
first = check(
client.get(path, headers=headers(a), params={"limit": 1}),
200,
"MessagePage",
)
second = check(
client.get(
path,
headers=headers(b),
params={"limit": 22, "cursor": first["next_cursor"]},
),
200,
"MessagePage",
)
assert second["items"] == got[1:]
assert second["next_cursor"] is None
chats = check(
client.get("/api/v1/chats", headers=headers(outsider)), 200, "ChatPage"
)
assert chats["items"] == []
other = check(
client.post(
"/api/v1/chats",
headers=headers(a),
json={"title": "Other", "member_ids": [a["id"]]},
),
201,
"Chat",
)
check(
client.get(
f"/api/v1/chats/{other['id']}/messages",
headers=headers(a),
params={"cursor": first["next_cursor"]},
),
400,
"Error",
)
# Валидный base64/JSON с неверным типом ключа тоже даёт 400.
data = json.loads(
base64.urlsafe_b64decode(
first["next_cursor"] + "=" * (-len(first["next_cursor"]) % 4)
)
)
data["at"] = 17
forged = (
base64.urlsafe_b64encode(json.dumps(data).encode())
.decode()
.rstrip("=")
)
check(
client.get(path, headers=headers(a), params={"cursor": forged}),
400,
"Error",
)
def test_chat_pagination_scope(client, actors):
a, b, _ = actors
created = []
for i in range(4):
created.append(
check(
client.post(
"/api/v1/chats",
headers=headers(a),
json={"title": str(i), "member_ids": [a["id"], b["id"]]},
),
201,
"Chat",
)
)
page = check(
client.get("/api/v1/chats", headers=headers(a), params={"limit": 2}),
200,
"ChatPage",
)
assert page["items"] == created[:2]
last = check(
client.get(
"/api/v1/chats",
headers=headers(a),
params={"limit": 2, "cursor": page["next_cursor"]},
),
200,
"ChatPage",
)
assert last["items"] == created[2:]
assert last["next_cursor"] is None
check(
client.get(
"/api/v1/chats",
headers=headers(b),
params={"cursor": page["next_cursor"]},
),
400,
"Error",
)
def test_concurrent_messages(client, actors, chat):
barrier = threading.Barrier(10)
a = actors[0]
path = f"/api/v1/chats/{chat['id']}/messages"
def worker(i):
with httpx.Client(
base_url=BASE_URL, timeout=15, trust_env=False
) as conn:
barrier.wait(timeout=15)
return [
check(
conn.post(
path, headers=headers(a), json={"text": f"{i}:{j}"}
),
201,
"Message",
)["id"]
for j in range(10)
]
with ThreadPoolExecutor(max_workers=10) as pool:
ids = [item for batch in pool.map(worker, range(10)) for item in batch]
rows = history(client, a, chat["id"])
assert len(rows) == len(ids) == len(set(ids)) == 100
assert set(ids) == {row["id"] for row in rows}
assert len({row["text"] for row in rows}) == 100
def test_registration_race(client):
username = "race_" + uuid4().hex[:20]
barrier = threading.Barrier(10)
def worker(_):
with httpx.Client(
base_url=BASE_URL, timeout=15, trust_env=False
) as conn:
barrier.wait(timeout=15)
result = conn.post(
"/api/v1/users",
json={
"username": username,
"display_name": "Test",
"password": PASSWORD,
},
)
check(
result,
result.status_code,
"User" if result.status_code == 201 else "Error",
)
return result.status_code
with ThreadPoolExecutor(max_workers=10) as pool:
statuses = list(pool.map(worker, range(10)))
assert statuses.count(201) == 1
assert statuses.count(409) == 9
def test_unknown_path(client):
check(client.get("/does-not-exist"), 404, "Error")
+192
View File
@@ -0,0 +1,192 @@
import hashlib
import io
from pathlib import Path
from uuid import uuid4
import pytest
from conftest import check, headers
from PIL import Image
PNG = (Path(__file__).parents[1] / "tests/fixtures/sample.png").read_bytes()
def upload(
client, actor, chat, *, data=PNG, filename="Фото 🌍.png", mime="image/png"
):
return client.post(
f"/api/v1/chats/{chat['id']}/attachments",
headers={**headers(actor), "Content-Type": mime},
params={"filename": filename},
content=data,
)
def test_attachment_roundtrip_acl_and_message(client, actors, chat):
attachment = check(upload(client, actors[0], chat), 201, "Attachment")
assert attachment["status"] == "ready" and attachment["variants"] == []
assert attachment["sha256"] == hashlib.sha256(PNG).hexdigest()
assert attachment["size_bytes"] == len(PNG)
path = f"/api/v1/attachments/{attachment['id']}"
assert (
check(client.get(path, headers=headers(actors[1])), 200, "Attachment")
== attachment
)
downloaded = client.get(path + "/content", headers=headers(actors[1]))
assert downloaded.status_code == 200 and downloaded.content == PNG
assert downloaded.headers["Content-Type"] == "image/png"
assert not downloaded.history
for suffix in ["", "/content"]:
check(
client.get(path + suffix, headers=headers(actors[2])), 404, "Error"
)
check(client.get(path + suffix), 401, "Error")
check(
client.get(
path + "/content",
headers=headers(actors[1]),
params={"variant": "thumbnail"},
),
404,
"Error",
)
sent = check(
client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers=headers(actors[1]),
json={"text": "", "attachment_ids": [attachment["id"]]},
),
201,
"Message",
)
assert sent["attachment_ids"] == [attachment["id"]]
assert sent["sender_id"] == actors[1]["id"]
@pytest.mark.parametrize(
"name",
[
"../x.png",
"x/y.png",
"x\\y.png",
"x\x00.png",
"x\x7f.png",
"x\n.png",
"a" * 256,
"",
],
)
def test_filename_guard(client, actors, chat, name):
check(upload(client, actors[0], chat, filename=name), 400, "Error")
@pytest.mark.parametrize(
"data,mime,status",
[
(b"not an image", "image/png", 415),
(PNG, "image/jpeg", 415),
(PNG, "application/octet-stream", 415),
(PNG[:25], "image/png", 415),
(b"", "image/png", 415),
(b"x" * (10 * 1024 * 1024 + 1), "image/png", 413),
],
)
def test_image_guards(client, actors, chat, data, mime, status):
r = upload(client, actors[0], chat, data=data, mime=mime)
check(r, status, "Error")
def test_jpeg_original_unchanged(client, actors, chat):
stream = io.BytesIO()
Image.new("RGB", (320, 200), (30, 60, 90)).save(stream, format="JPEG")
jpeg = stream.getvalue()
attachment = check(
upload(
client,
actors[0],
chat,
data=jpeg,
filename="camera.jpg",
mime="image/jpeg",
),
201,
"Attachment",
)
r = client.get(
f"/api/v1/attachments/{attachment['id']}/content",
headers=headers(actors[1]),
)
assert r.content == jpeg
def test_cross_chat_link_and_unknown(client, actors, chat):
a = check(upload(client, actors[0], chat), 201, "Attachment")
other = check(
client.post(
"/api/v1/chats",
headers=headers(actors[0]),
json={"title": "Other", "member_ids": [actors[0]["id"]]},
),
201,
"Chat",
)
for identity in [a["id"], str(uuid4())]:
check(
client.post(
f"/api/v1/chats/{other['id']}/messages",
headers=headers(actors[0]),
json={"text": "", "attachment_ids": [identity]},
),
404,
"Error",
)
check(
client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers=headers(actors[0]),
json={"text": "", "attachment_ids": [a["id"], a["id"]]},
),
400,
"Error",
)
def test_default_attachments_are_semantically_equal(client, actors, chat):
h = headers(actors[0])
path = f"/api/v1/chats/{chat['id']}/messages"
first = check(
client.post(path, headers=h, json={"text": "Semantic default"}),
201,
"Message",
)
second = check(
client.post(
path,
headers=h,
json={"attachment_ids": [], "text": "Semantic default"},
),
201,
"Message",
)
assert first == second and first["attachment_ids"] == []
def test_pixel_limit_before_decode(client, actors, chat):
# Compressible synthetic image stays below10MiB but exceeds40M pixels.
stream = io.BytesIO()
Image.new("1", (8000, 5001)).save(stream, format="PNG")
assert len(stream.getvalue()) < 10 * 1024 * 1024
r = upload(client, actors[0], chat, data=stream.getvalue())
assert r.status_code == 413
def test_chunked_body_limit_without_content_length(client, actors, chat):
r = client.post(
f"/api/v1/chats/{chat['id']}/attachments",
headers={**headers(actors[0]), "Content-Type": "image/png"},
params={"filename": "chunked.png"},
content=iter([b"x" * (10 * 1024 * 1024 + 1)]),
)
assert r.request.headers.get("content-length") is None
assert r.status_code == 413
assert r.json()["error"]["code"] == "payload_too_large"
assert r.json()["error"]["request_id"] == r.headers["x-request-id"]
+26
View File
@@ -0,0 +1,26 @@
import json
from uuid import uuid4
import pytest
from conftest import check, headers
@pytest.mark.parametrize("encoding", ["utf-16", "utf-32"])
def test_only_utf8_json(client, encoding):
payload = {"username": "u_" + uuid4().hex[:20], "display_name": "UTF"}
payload["password"] = "Synthetic-encoding-test-123"
result = client.post(
"/api/v1/users",
content=json.dumps(payload).encode(encoding),
headers={"Content-Type": "application/json"},
)
check(result, 400, "Error")
def test_leading_zero_limit(client, actors, chat):
result = client.get(
"/api/v1/chats/" + chat["id"] + "/messages",
headers=headers(actors[0]),
params={"limit": "0001"},
)
check(result, 200, "MessagePage")
+23
View File
@@ -0,0 +1,23 @@
from conftest import check, headers
def test_history_acl_precedes_query_validation(client, actors, chat):
path = f"/api/v1/chats/{chat['id']}/messages"
check(
client.get(
path,
headers=headers(actors[2]),
params={"limit": 0, "cursor": "broken"},
),
404,
"Error",
)
check(
client.get(
path,
headers=headers(actors[0]),
params={"limit": 0, "cursor": "broken"},
),
400,
"Error",
)
+75
View File
@@ -0,0 +1,75 @@
from concurrent.futures import ThreadPoolExecutor
from uuid import uuid4
import httpx
import pytest
from conftest import BASE_URL, check, headers, history
@pytest.mark.parametrize("key", [None, "", "a b", "x" * 129, "a/b"])
def test_key_required_and_valid(client, actors, chat, key):
h = headers(actors[0])
h.pop("Idempotency-Key")
if key is not None:
h["Idempotency-Key"] = key
check(
client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers=h,
json={"text": "Key"},
),
400,
"Error",
)
def test_parallel_replay_across_instances(client, actors, chat):
h = headers(actors[0])
path = f"/api/v1/chats/{chat['id']}/messages"
def send(_):
with httpx.Client(base_url=BASE_URL, trust_env=False, timeout=15) as c:
r = c.post(path, headers=h, json={"text": "Один результат 🌍"})
return check(r, 201, "Message"), r.headers["x-instance-id"]
with ThreadPoolExecutor(max_workers=10) as pool:
results = list(pool.map(send, range(30)))
assert len({r[0]["id"] for r in results}) == 1
assert len({r[1] for r in results}) >= 2
assert history(client, actors[0], chat["id"]) == [results[0][0]]
check(
client.post(path, headers=h, json={"text": "Другой текст"}),
409,
"Error",
)
# Другой пользователь может независимо использовать тот же ключ.
other = headers(actors[1])
other["Idempotency-Key"] = h["Idempotency-Key"]
second = check(
client.post(path, headers=other, json={"text": "Боб"}), 201, "Message"
)
assert second["id"] != results[0][0]["id"]
def test_replay_rechecks_acl(client, actors, chat):
h = headers(actors[0])
path = f"/api/v1/chats/{chat['id']}/messages"
check(
client.post(path, headers=h, json={"text": "Existing"}), 201, "Message"
)
outsider = headers(actors[2])
outsider["Idempotency-Key"] = h["Idempotency-Key"]
check(
client.post(path, headers=outsider, json={"text": "Existing"}),
404,
"Error",
)
check(
client.post(
path,
headers={"Idempotency-Key": uuid4().hex},
json={"text": "Existing"},
),
401,
"Error",
)
+114
View File
@@ -0,0 +1,114 @@
from uuid import uuid4
import httpx
import pytest
from conftest import PASSWORD, TOKENS, check, headers, register
@pytest.mark.parametrize(
"password", ["", "x" * 11, "x" * 129, " " * 12, 42, True, None]
)
def test_password_validation(client, password):
check(
client.post(
"/api/v1/users",
json={
"username": "pwd_" + uuid4().hex[:20],
"display_name": "Test",
"password": password,
},
),
400,
"Error",
)
def test_full_utf8_password(client):
password = "🌍" * 127 + ":"
user = register(client, password=password)
assert (
check(
client.get("/api/v1/users/me", headers=headers(user)), 200, "User"
)
== user
)
@pytest.mark.parametrize(
"authorization", [None, "Basic broken", "Bearer unknown", "Basic /w=="]
)
def test_bad_basic(client, authorization):
result = client.post(
"/api/v1/auth/sessions",
headers={"Authorization": authorization} if authorization else {},
)
check(result, 401, "Error")
assert (
result.headers["www-authenticate"]
== 'Basic realm="messenger", charset="UTF-8"'
)
def test_wrong_password_and_unknown_user(client):
user = register(client)
for username in [user["username"], "missing_" + uuid4().hex[:20]]:
result = client.post(
"/api/v1/auth/sessions",
auth=httpx.BasicAuth(username, PASSWORD + "wrong"),
)
data = check(result, 401, "Error")
assert data["error"]["message"] == "Authentication required"
def test_logout_is_not_revived_by_cache(client):
user = register(client)
auth = headers(user)
check(client.get("/api/v1/users/me", headers=auth), 200, "User")
result = client.delete("/api/v1/auth/sessions/current", headers=auth)
assert result.status_code == 204 and result.content == b""
assert result.headers["x-request-id"]
check(client.get("/api/v1/users/me", headers=auth), 401, "Error")
check(
client.delete("/api/v1/auth/sessions/current", headers=auth),
401,
"Error",
)
def test_only_current_session_revoked(client):
user = register(client)
another = check(
client.post(
"/api/v1/auth/sessions",
auth=httpx.BasicAuth(user["username"], PASSWORD),
),
201,
"Session",
)
assert another["token"] != TOKENS[user["id"]]
assert len(another["token"]) >= 32
assert (
client.delete(
"/api/v1/auth/sessions/current", headers=headers(user)
).status_code
== 204
)
result = client.get(
"/api/v1/users/me",
headers={"Authorization": "Bearer " + another["token"]},
)
assert check(result, 200, "User") == user
def test_bearer_source_and_ignored_user_header(client, actors):
alice, bob, _ = actors
auth = {**headers(alice), "X-User-Id": bob["id"]}
assert (
check(client.get("/api/v1/users/me", headers=auth), 200, "User")["id"]
== alice["id"]
)
result = client.get(
"/api/v1/users/me", auth=httpx.BasicAuth(alice["username"], PASSWORD)
)
check(result, 401, "Error")
assert result.headers["www-authenticate"] == 'Bearer realm="messenger"'
Generated
+1095
View File
File diff suppressed because it is too large Load Diff