diff --git a/.dockerignore b/.dockerignore index 8e5d3661..93056db6 100644 --- a/.dockerignore +++ b/.dockerignore @@ -33,3 +33,5 @@ Makefile compose.yaml .work* + +student-unit diff --git a/Makefile b/Makefile index 788ce574..6e04c7dd 100644 --- a/Makefile +++ b/Makefile @@ -39,9 +39,15 @@ up: bootstrap down: docker compose down lint: - $(UV) run --locked ruff format --check 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) + $(UV) run --locked ruff format --check src student-tests student-unit scripts/bootstrap.py scripts/stand.py scripts/cluster.py $(wildcard scripts/verify_*.py) + $(UV) run --locked ruff check src student-tests student-unit 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_pipeline --output evidence/pipeline-repeat.json + +.PHONY: unit reconcile +unit: + PYTHONPATH=. $(UV) run --locked pytest student-unit -q +reconcile: + docker compose run --rm --no-deps reconciler python -m src.reconcile diff --git a/REPORT.md b/REPORT.md index e98f75e9..0d440c08 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,234 @@ -# Отчёт — лабораторная 5 +# Лабораторная 5 — Маслов, БВТ2301 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +Цель: **5, трек 2 — идемпотентность versioned pipeline**. Собственная ЛР4 +перенесена в независимую историю текущего teacher skeleton; обязательные +contracts/tests/check/validate сохранены. API принимает исходник, а отдельный +worker публикует original/thumbnail/crop/optimized. Исследование проверяет +дубли, reorder и реальные SIGKILL, а не моделирует их ответами mock. -## Запуск из чистого clone +Результаты полного fault-injection и clean clone будут внесены после запуска. +Промежуточный public smoke уже PASS; итоговые evidence ниже обновляются +только фактическими командами. Первый запуск HTTP suite ошибочно обращался +к порту предыдущей лабы; `http-initial-environment.json` честно отмечает +INVALID_ENVIRONMENT, это не проверка корректности API. -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +## Воспроизведение -## Архитектура и решения +Нужны Git, Docker Desktop с Compose v2, uv0.13.7. Версии Python3.14.7, +PostgreSQL18.3, Valkey8.1.3, HAProxy3.2.1, Pillow13.0.0 закреплены; +MinIO/mc собираются из точных upstream commits в infra/s3.Dockerfile, +Go module checksum проверяется GoSumDB. Сборка требует доступа к registries, +Go module proxy и PyPI; наличие сети нельзя заменить уже установленной БД. -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +```sh +uv sync --locked +make bootstrap +VCS_REF=$(git rev-parse HEAD) docker compose up -d --build --wait +make check validate PYTHON=.venv/bin/python +make lint unit +NO_PROXY=localhost,127.0.0.1 no_proxy=localhost,127.0.0.1 make test PYTHON=.venv/bin/python +BASE_URL=http://127.0.0.1:8085 make test-student +``` -## Доказательства критериев +URL: http://127.0.0.1:8085. API не имеет persistent volume/host port. +Bootstrap создаёт только отсутствующие secrets и .env; не печатает значения, +не перезаписывает существующие. `secrets/`0700, файлы0644 нужны UID10001 +через readonly Docker secrets mounts; сам каталог недоступен другим users. +`docker compose down` сохраняет volumes. Удаление volumes — отдельное +осознанное действие над своим синтетическим стендом. -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +Для автоматических отказов включается только явный test override: + +```sh +export COMPOSE_FILE=compose.yaml:compose.test.yaml +export NO_PROXY=localhost,127.0.0.1 no_proxy=localhost,127.0.0.1 +VCS_REF=$(git rev-parse HEAD) docker compose up -d --build --wait +uv run --locked python -m scripts.verify_cleanup seed --seed evidence/gc-seed-repeat.json +uv run --locked python -m scripts.verify_pipeline --output evidence/pipeline-repeat.json --repeats 2 +uv run --locked python -m scripts.verify_cleanup verify --seed evidence/gc-seed-repeat.json --output evidence/gc-repeat.json +uv run --locked python -m scripts.verify_cluster --output evidence/cluster-repeat.json +``` + +Проверки, меняющие состояние контейнеров, выполняются последовательно. +Seed и результат — разные файлы; нельзя использовать seed с уже удалённым +orphan. Verify ожидает настоящий возраст S3 не менее302s; часы/LastModified +не подменяются. Для нового полного чистого повторения: + +```sh +# Перед стартом весь проверяемый source должен быть закоммичен и git clean. +uv run --locked python scripts/verify_clean.py --output evidence/clean-clone-repeat.json +``` + +Этот verifier создаёт отдельные secrets/env/volumes/image/project, собирает, +запускает static/unit/public smoke/HTTP, cluster, всю fault matrix и cleanup, +сверяет source hashes и OCI revision обоих API, worker, relay, reconciler и +тестового controller; после удаляет только временный проект и его volumes. + +## Границы устойчивости + +1. API проверяет фактические bytes≤10MiB, MIME PNG/JPEG, декодирование, + filename и ≤40M pixels до полной распаковки. Временный spool≤1MiB в RAM, + затем bounded tmpfs; upload slots2/API, decode slot1/API, срок запроса20s. +2. Устойчивый upload reservation120s COMMIT предшествует PUT в приватный + `objects/staging//original`. После PUT одна PG transaction проверяет + reservation с FOR UPDATE, создаёт Attachment queued + logical Job + Outbox, + удаляет reservation и COMMIT. Только затем202 с захваченным queued-снимком. + Быстрый worker не превращает upload-ответ в ready. Сам upload не имеет + Idempotency-Key: потерянный HTTP-ответ нельзя безопасно повторять вслепую. +3. API зависит от PG и S3 для ready, cache используется как необязательный + read-through user cache. Broker не критичен для синхронного приёма: + работа остаётся в outbox. Relay имеет PG+broker secrets, не S3/root keys. +4. Relay читает due outbox FOR UPDATE SKIP LOCKED, XADD и WAITAOF1/0/2000 + **на одной выделенной connection**. Подтверждён fsync локального AOF; + только затем published_at/COMMIT в PG. Crash в этом окне даёт дубль. +5. Отдельный Valkey Streams broker с persistent volume, AOF appendfsync always, + noeviction. Disposable cache — другой сервис/volume/policy. Нет Pub/Sub. +6. Worker consumer group, COUNT=1 на каждый из2 слотов; XAUTOCLAIM возвращает + зависшие PEL entries. PG атомарно переводит queued→processing, увеличивает + attempt/fence, сохраняет owner/lease. Duplicate active оставляется pending; + ready duplicate делает HEAD всех4вариантов/size/SHA metadata и ACK без resize. +7. Child получает ID/fence, trusted source берётся из PG, не из произвольного + URL или filename. До обработки проверяется исходный size/SHA. Все4 PUT идут + в `objects//v/`. Original побайтно неизменён. +8. В одной PG transaction worker проверяет state/version/fence/live lease, + публикует metadata всех вариантов, unique effect_publication и ready. + Старый child может дописать свой version-prefix, но не подтвердить новый + результат. Стабильный алгоритм нельзя менять под тем же pipeline_version. +9. ACK только после устойчивой ready, failed/obsolete или решения queued retry. + Watchdog relay восстанавливает expired leases; pending outbox сохраняет retry. + Потерянные wakeups queued jobs переиздаются через15s без создания logical job. + +## Состояния и варианты + +GET показывает queued/processing/ready/failed. Queued/processing можно связать +с Message; failed —409. Все metadata/content проходят Bearer+membership, +чужой/неизвестный UUID —404, content до ready —409. У ready все3 производных +варианта и error_code=null; size/content_type/SHA описывают original. +Прямого redirect/public S3 URL нет. Atomic Message+Idempotency-Key сохранены. + +EXIF orientation применяется; RGBA компонуется на белом. Thumbnail JPEG +вписан≤256×256 без увеличения, floor/min1;320×200→256×160. Crop — центральный +JPEG128×128 с допустимым увеличением маленького исходника. JPEGquality85, +subsampling0,LANCZOS. Optimized — WebP≤1280×1280 без увеличения, quality82(v1) +или76(v2), method4. EXIF/info удаляются из производных; metadata original +сохраняются в исходных bytes. Маленький WebP не обязательно меньше original. + +Job соответствует contracts/jobs.schema.json: schema_version1, +type attachment.process.v1, UUID job/attachment, version, attempt>=1, RFC3339 +created_at; возможен W3C carrier. Bytes/credentials/paths/URL запрещены. +Broker redelivery не меняет job_id; finite replay сохраняет job_id и увеличивает +cycle; новая pipeline version получает новый job_id. Idempotency effect key — +(attachment_id,pipeline_version,variant), PK в PG и детерминированный S3 key. + +## Ограничение ресурсов и повторы + +| Роль | CPU | RAM | Ограничение работы | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| API каждая из2 |0.5|768MiB|2uploads,1decode,128MiB tmpfs| +| Worker |2|1536MiB|2child,COUNT1/slot,child RLIMIT_AS768MiB| +| Relay |0.25|192MiB|один bounded publish/transaction| +| Broker |0.5|256MiB|192MiB maxmemory,noeviction,AOF volume| +| PostgreSQL |1|512MiB|pool10/API,4/worker-slot| +| S3 |1|1024MiB|persistent volume,private bucket| +| Reconciler |0.25|256MiB|inventory проход/60s| -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Normal timeout20s / lease23s; test override12s/15s даёт время контроллеру +завершить v2 в другой slot пока v1 удерживается после PUT. Child действительно +killable: parent убивает процесс по timeout, а не лишь отменяет future/thread. +Весь container ограничен cgroup; лимит40M pixels не обещает, что всякий такой +файл уложится в память и срок — memory_limit/timeout приводят к safe failed/retry. -## Эксперименты и отказы +Максимум5attempts; временные ошибки/смерть worker/timeout → persisted next_at +с jitter uniform0.25…min(30,2^attempt)s. Постоянные decode/checksum/memory ошибки +сразу failed; временные после5→retry_exhausted. Публичные error_code безопасны, +без stack/SQL/key. Реестр failed и audited replay доступны только оператору: -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +```sh +docker compose exec worker python -m src.operator failed +docker compose exec worker python -m src.operator replay --job-id UUID --operator maslov --reason 'Synthetic recovery demonstration' +docker compose exec worker python -m src.operator version --job-id UUID --version 2 --operator maslov --reason 'Upgrade pipeline' +docker compose run --rm --no-deps reconciler python -m src.reconcile +docker compose run --rm --no-deps reconciler python -m src.reconcile --apply +``` -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +Ready replay отвергается. Failed replay проверяет наличие source, оставляет +audit и новый finite cycle. После source_expired нельзя обещать обработку +отсутствующих bytes. New-version поддерживает реализованный переход1→2. -## Ограничения и следующие шаги +## Retention -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Staging удаляется после безопасного COMMIT ready; сбой удаления не отменяет +результат, последующий GC уберёт остаток. Failed/unconfirmed source и orphan +живут минимум retention86400s, конфигурационный hard minimum300s. Cleanup +по умолчанию dry-run; --apply явный. Active queued/processing source и prefix, +действующий reservation и current published variants защищены. Перед delete +повторяются PG lock/recheck и HEAD реального возраста. Expired reservation +удаляется под lock; API не сможет поздно подтвердить удалённый source. +Старые версии после успешной новой могут удаляться; metadata/audit сохраняются. +Failed без source остаётся failed/source_expired и replay отвергается. +Текущий original не удаляется лишь из-за отсутствия Message links. + +## Исследование: гипотеза и инварианты + +Гипотеза: durable intent/outbox + PG version/fence/lease CAS + immutable +version keys сохраняют подтверждённую работу и не допускают publication старой +версии поверх новой при at-least-once delivery. + +Проверяемые инварианты: каждый202 имеет durable Job; все принятые matrix jobs +доходят до ready или наблюдаемого failed; финальный ready имеет ровно4 variant +rows/keys и1effect_publication на версию; original SHA равен загрузке; +old version не меняет hashes текущей; конечный retry/replay наблюдаемы; +cleanup не удаляет current/active/fresh. До handoff crash не получает202. + +`scripts/verify_pipeline.py --repeats2` использует отдельный test controller +с PG/S3/broker secrets (API не получает broker secrets), single-use hooks в PG +с durable hit_at, реальные container SIGKILL и повторный запуск. Hooks по +умолчанию выключены, публичного endpoint для них нет. Проверяются: +source-before-handoff, COMMIT-before-publish, confirmed broker SIGKILL/volume, +relay XADD-before-PG-marker, worker before_effect/after_effect/after_commit +каждый дважды; transient, timeout, permanent/replay,5attempt exhaustion/replay, +duplicates/reorder, held stalev1 послеv2 и старые notifications; malformed +notification, private IAM/anonymous denial и другая API после uploader stop. + +Raw evidence сохраняет IDs, attempts, fences, events,4keys/checksums и +publications. Worker child_finished даёт elapsed/CPU/peakRSS; это длительность +child, не полный queue lag. Исследование про корректность, не максимальный RPS. + +## Вопросы защиты + +**Publisher confirm и consumer ACK?** Первый подтверждает durable приём брокером +(здесь локальный AOF fsync через WAITAOF), второй — устойчивое завершение или +сохранённое решение о повторе у consumer. Между PG/Valkey/S3 нет общей transaction. + +**Что уже сохранено к202?** Полный проверенный original в private persistent +S3 staging плюс attachment/job/outbox в одной подтверждённой PG transaction. +Смерть API/worker не удаляет намерение. Перед202 тяжёлого resize нет. + +**Почему дубли нормальны?** Producer/consumer могут потерять ответ после +успешного действия. Отправитель повторяет, поскольку не знает исход. Logical +job_id и effect tuple/version/fence позволяют повторить доставку безопасно. +Ровно одна publication в PG не означает exactly-once delivery в broker. + +**Как отличить зависший worker от долгого?** Совершенно точно нельзя: lease — +выбранный бюджет. Parent timeout убивает child; watchdog восстанавливает работу +после lease, новый fence делает старое завершение недействительным. Ограничение +slots/COUNT сдерживает конкуренцию. Возможен лишний PUT, но не старый COMMIT. + +## Источники, помощь, ограничения + +Использованы текущие teacher contracts, собственная ЛР4, pinned dependencies, +[Valkey WAITAOF](https://valkey.io/commands/waitaof/), +[Valkey XAUTOCLAIM](https://valkey.io/commands/xautoclaim/), +[Pillow ImageOps](https://pillow.readthedocs.io/en/stable/reference/ImageOps.html). +При проектировании, реализации, тестах и отчёте использована помощь ИИ. +Код/данные/история других студентов не использовались; результаты — реальные +локальные запуски, а remote CI отдельно не считается прошедшим. + +Один host/LB/PG/S3/broker — SPOF, AOF/fsync/volume не заменяет backup и защиту +от потери диска. HTTP допустим для локальных синтетических данных; удалённый +доступ требует TLS. Строгого production exactly-once нет. HEAD metadata не +заменяет полный periodic checksum audit. Удалённые bytes не восстановить по SHA. +Весь inventory GC хранится в RAM, outbox/events/audit требуют retention при +долгой эксплуатации. Нет global admission quota: при долгой недоступности +worker/broker PG outbox может расти; исследование перегрузки — другой трек. +Short synthetic fixtures и повторы ограничивают обобщение на большие файлы. diff --git a/compose.test.yaml b/compose.test.yaml index 094c4c70..850a9ff8 100644 --- a/compose.test.yaml +++ b/compose.test.yaml @@ -11,3 +11,20 @@ services: PIPELINE_FAULTS: "1" JOB_TIMEOUT_SECONDS: "12" JOB_LEASE_SECONDS: "15" + controller: + image: ${API_IMAGE:-mtusi-messenger:lab5} + pull_policy: never + command: [python, -c, "import time; time.sleep(86400)"] + environment: + DATABASE_URL_FILE: /run/secrets/database_url + BROKER_URL_FILE: /run/secrets/broker_url + S3_ACCESS_KEY_FILE: /run/secrets/s3_access_key + S3_SECRET_KEY_FILE: /run/secrets/s3_secret_key + secrets: [database_url, broker_url, s3_access_key, s3_secret_key] + cpus: 0.5 + mem_limit: 192m + memswap_limit: 192m + read_only: true + healthcheck: {disable: true} + cap_drop: [ALL] + security_opt: [no-new-privileges:true] diff --git a/evidence/http-first.json b/evidence/http-first.json new file mode 100644 index 00000000..f89baa75 --- /dev/null +++ b/evidence/http-first.json @@ -0,0 +1,12 @@ +{ + "source_commit": "bb4e8a2", + "runtime_revision": "bb4e8a2", + "public_smoke": "PASS", + "http_tests": 112, + "passed": 112, + "failed": 0, + "seconds": 404.42, + "unit_tests": 19, + "unit_result": "PASS", + "output": "........................................................................ [ 64%]\n........................................ [100%]\n112 passed in 404.42s (0:06:44)\n" +} diff --git a/pyproject.toml b/pyproject.toml index cd0d6b96..ea928755 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -19,7 +19,7 @@ dev = ["pytest>=8,<10", "httpx>=0.28,<1", "ruff>=0.14,<1", "openapi-spec-validat [tool.ruff] line-length = 79 target-version = "py314" -include = ["src/**/*.py", "student-tests/**/*.py", "research/**/*.py", "scripts/verify_*.py"] +include = ["src/**/*.py", "student-tests/**/*.py", "student-unit/**/*.py", "research/**/*.py", "scripts/**/*.py"] [tool.ruff.lint] select = ["E", "F", "I", "B", "UP"] diff --git a/scripts/verify_clean.py b/scripts/verify_clean.py index 6a56626e..deb961b2 100644 --- a/scripts/verify_clean.py +++ b/scripts/verify_clean.py @@ -80,6 +80,7 @@ def main(): "API_IMAGE": "mtusi-messenger:lab5-clean-" + identity, "PUBLIC_PORT": public_port, "VCS_REF": sha, + "COMPOSE_FILE": "compose.yaml:compose.test.yaml", "NO_PROXY": "localhost,127.0.0.1", "no_proxy": "localhost,127.0.0.1", } @@ -114,6 +115,7 @@ def main(): cwd=clone, env=env, ) + receipt["unit_tests"] = run(["make", "unit"], cwd=clone, env=env) run(["make", "bootstrap"], cwd=clone, env=env) try: run( @@ -141,19 +143,39 @@ def main(): cwd=clone, env=env, ) - run( + for command_args in [ [ ".venv/bin/python", "-m", - "scripts.verify_storage", - "--output", - "evidence/clean-storage.json", + "scripts.verify_cleanup", + "seed", + "--seed", + "evidence/clean-gc-seed.json", ], - cwd=clone, - env=env, + [ + ".venv/bin/python", + "-m", + "scripts.verify_pipeline", + "--output", + "evidence/clean-pipeline.json", + ], + [ + ".venv/bin/python", + "-m", + "scripts.verify_cleanup", + "verify", + "--seed", + "evidence/clean-gc-seed.json", + "--output", + "evidence/clean-cleanup.json", + ], + ]: + run(command_args, cwd=clone, env=env) + receipt["pipeline"] = json.loads( + (clone / "evidence/clean-pipeline.json").read_text() ) - receipt["storage"] = json.loads( - (clone / "evidence/clean-storage.json").read_text() + receipt["cleanup"] = json.loads( + (clone / "evidence/clean-cleanup.json").read_text() ) receipt["cluster"] = json.loads( (clone / "evidence/clean-cluster.json").read_text() @@ -172,6 +194,21 @@ def main(): "import hashlib,json,pathlib; print(json.dumps({p.name:" "hashlib.sha256(p.read_bytes()).hexdigest() for p in pathlib.Path('/app/src').glob('*.py')}))" ) + ids += run( + [ + "docker", + "compose", + "ps", + "-q", + "worker", + "relay", + "reconciler", + "controller", + ], + cwd=clone, + env=env, + ).split() + assert len(ids) == 6 for cid in ids: actual = json.loads( run( @@ -191,7 +228,9 @@ def main(): == sha ) assert not info["HostConfig"]["PortBindings"] - receipt["both_replicas_runtime_hashes_and_revision_match"] = True + receipt[ + "api_worker_relay_reconciler_runtime_hashes_and_revision_match" + ] = True receipt["fsck"] = run( ["git", "fsck", "--full"], cwd=clone, env=env ) diff --git a/scripts/verify_cleanup.py b/scripts/verify_cleanup.py new file mode 100644 index 00000000..e4e622c0 --- /dev/null +++ b/scripts/verify_cleanup.py @@ -0,0 +1,223 @@ +"""Real S3 retention test: seed is separate from verification output.""" + +import argparse +import json +import time +from datetime import datetime, timezone +from pathlib import Path +from uuid import uuid4 + +import httpx + +from scripts.stand import BASE, ROOT, actor, auth, command, compose, ready +from scripts.verify_pipeline import inside, operator, wait + + +def seed(path): + if path.exists(): + raise ValueError("Choose a new seed file") + ready() + compose("stop", "--timeout", "1", "reconciler") + raw = (ROOT / "tests/fixtures/sample.png").read_bytes() + with httpx.Client(base_url=BASE, trust_env=False, timeout=20) as c: + user, _, session = actor(c) + headers = auth(session) + result = c.post( + "/api/v1/chats", + headers=headers, + json={ + "title": "Cleanup synthetic seed", + "member_ids": [user["id"]], + }, + ) + assert result.status_code == 201 + chat = result.json()["id"] + r = c.post( + f"/api/v1/chats/{chat}/attachments", + headers={**headers, "Content-Type": "image/png"}, + params={"filename": "retained.png"}, + content=raw, + ) + assert r.status_code == 202 + attachment = r.json()["id"] + wait( + lambda: ( + c.get( + "/api/v1/attachments/" + attachment, headers=headers + ).json()["status"] + == "ready" + ) + ) + job = inside( + f"with db.connection() as c: r=c.execute('SELECT id FROM jobs WHERE attachment_id=%s',({attachment!r},)).fetchone()\nprint(json.dumps(str(r['id'])))" + ) + data = { + "seed_id": uuid4().hex, + "source_commit": command(["git", "rev-parse", "HEAD"]), + "date": datetime.now(timezone.utc).isoformat(), + "ready_attachment": attachment, + "ready_job": job, + "chat": chat, + "owner": user["id"], + } + # Real old v1 objects will become obsolete after v2 is ready. + second = operator(job, version=2) + wait( + lambda: inside( + f"with db.connection() as c: r=c.execute('SELECT state FROM jobs WHERE id=%s',({second!r},)).fetchone()\nprint(json.dumps(r['state']=='ready'))" + ) + ) + data["version2_job"] = second + data["orphan"] = f"objects/cleanup-{data['seed_id']}/old-orphan" + data["failed_id"] = str(uuid4()) + data["active_id"] = str(uuid4()) + data["reservation_id"] = str(uuid4()) + data["expired_reservation_id"] = str(uuid4()) + data["failed_source"] = f"objects/staging/{data['failed_id']}/original" + data["active_source"] = f"objects/staging/{data['active_id']}/original" + data["reservation_key"] = ( + f"objects/staging/{data['reservation_id']}/original" + ) + data["expired_reservation_key"] = ( + f"objects/staging/{data['expired_reservation_id']}/original" + ) + inside(f"""from pathlib import Path +raw=Path('/app/src/__init__.py').read_bytes() or b'fixture' +keys={json.dumps([data[k] for k in ["orphan", "failed_source", "active_source", "reservation_key", "expired_reservation_key"]])} +for key in keys: store.put(key=key,stream=io.BytesIO(raw),size=len(raw),content_type='image/png',sha256=hashlib.sha256(raw).hexdigest()) +with db.connection() as c, c.transaction(): + for identity,state in [({data["failed_id"]!r},'failed'),({data["active_id"]!r},'processing')]: + key='objects/staging/'+identity+'/original' + c.execute(\"INSERT INTO attachments(id,chat_id,owner_id,filename,content_type,size_bytes,sha256,object_key,state,error_code,uploader_instance,expires_at) VALUES(%s,%s,%s,'synthetic.png','image/png',%s,%s,%s,%s,%s,'cleanup-fixture',clock_timestamp())\",(identity,{chat!r},{user["id"]!r},len(raw),hashlib.sha256(raw).hexdigest(),key,state,'invalid_image' if state=='failed' else None)) + c.execute(\"INSERT INTO jobs(id,attachment_id,pipeline_version,source_key,state,attempt,lease_until,updated_at,error_code) VALUES(%s,%s,1,%s,%s,1,clock_timestamp()+interval '1 hour',clock_timestamp()-interval '2 days',%s)\",(uuid4(),identity,key,state,'invalid_image' if state=='failed' else None)) + c.execute(\"INSERT INTO upload_reservations(id,object_key,expires_at) VALUES(%s,%s,clock_timestamp()+interval '1 hour'),(%s,%s,clock_timestamp()-interval '1 second')\",({data["reservation_id"]!r},{data["reservation_key"]!r},{data["expired_reservation_id"]!r},{data["expired_reservation_key"]!r})) +print('true')""") + data["seeded_unix"] = time.time() + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n") + print( + "PASS: retention seed created; real S3 age must reach300s", flush=True + ) + + +def verify(seed_path, output): + if output.exists(): + raise ValueError("Choose a new output path") + data = json.loads(seed_path.read_text()) + report = { + "source_commit": command(["git", "rev-parse", "HEAD"]), + "seed": seed_path.name, + "complete": False, + } + try: + compose("stop", "--timeout", "1", "reconciler") + + def age(): + return inside( + f"h=store.head(key={data['orphan']!r})\nassert h is not None\nwith db.connection() as c: now=c.execute('SELECT clock_timestamp() now').fetchone()['now']\nprint(json.dumps((now-h.last_modified).total_seconds()))" + ) + + while age() < 302: + time.sleep(min(5, 303 - age())) + report["real_s3_age_seconds"] = age() + fresh = f"objects/cleanup-{data['seed_id']}/fresh-orphan" + inside( + f"b=b'fresh'\nstore.put(key={fresh!r},stream=io.BytesIO(b),size=len(b),content_type='image/png',sha256=hashlib.sha256(b).hexdigest())\nprint('true')" + ) + oldkeys = [ + data["orphan"], + data["failed_source"], + data["expired_reservation_key"], + ] + [ + f"objects/{data['ready_attachment']}/v1/{v}" + for v in ["original", "thumbnail", "crop", "optimized"] + ] + protected = [data["active_source"], data["reservation_key"], fresh] + [ + f"objects/{data['ready_attachment']}/v2/{v}" + for v in ["original", "thumbnail", "crop", "optimized"] + ] + before = inside( + f"print(json.dumps({{k:store.head(key=k) is not None for k in {oldkeys + protected!r}}}))" + ) + assert all(before.values()) + dry = inside( + "print(json.dumps(reconcile(db,store,apply=False,grace=300)))" + ) + candidates = {a["key"] for a in dry["actions"]} + assert set(oldkeys) <= candidates and not set(protected) & candidates + afterdry = inside( + f"print(json.dumps({{k:store.head(key=k) is not None for k in {oldkeys + protected!r}}}))" + ) + assert afterdry == before + applied = inside( + "print(json.dumps(reconcile(db,store,apply=True,grace=300)))" + ) + repeat = inside( + "print(json.dumps(reconcile(db,store,apply=True,grace=300)))" + ) + assert not repeat["actions"] + after = inside( + f"print(json.dumps({{k:store.head(key=k) is not None for k in {oldkeys + protected!r}}}))" + ) + assert all(not after[k] for k in oldkeys) and all( + after[k] for k in protected + ) + failed = inside( + f"with db.connection() as c: j=c.execute('SELECT id,error_code FROM jobs WHERE attachment_id=%s',({data['failed_id']!r},)).fetchone()\nprint(json.dumps(j,default=str))" + ) + assert failed["error_code"] == "source_expired" + try: + operator(failed["id"]) + except RuntimeError: + replay_refused = True + else: + raise AssertionError("Expired source replay must fail") + # Expired reservation was removed, so a delayed API cannot commit its handoff. + fenced = inside( + f"with db.connection() as c: r=c.execute('SELECT count(*) n FROM upload_reservations WHERE id=%s AND expires_at>clock_timestamp()',({data['expired_reservation_id']!r},)).fetchone()\nprint(json.dumps(r['n']==0))" + ) + assert fenced + report.update( + dry_run=dry, + apply=applied, + repeat=repeat, + before=before, + after=after, + dry_run_unchanged=True, + active_current_and_fresh_protected=True, + expired_source_replay_refused=replay_refused, + expired_writer_fenced=fenced, + complete=True, + ) + finally: + # Remove only this fixture's artificial active reservation/job; never real jobs. + inside( + f"with db.connection() as c, c.transaction():\n c.execute(\"UPDATE jobs SET state='failed',error_code='fixture_complete',lease_until=NULL WHERE attachment_id=%s\",({data['active_id']!r},))\n c.execute(\"UPDATE attachments SET state='failed',error_code='fixture_complete' WHERE id=%s\",({data['active_id']!r},))\n c.execute('DELETE FROM upload_reservations WHERE id=%s',({data['reservation_id']!r},))\nprint('true')" + ) + compose("up", "-d", "--no-deps", "--no-recreate", "reconciler") + output.parent.mkdir(parents=True, exist_ok=True) + output.write_text( + json.dumps(report, ensure_ascii=False, indent=2) + "\n" + ) + print( + "PASS: real retention, dry-run/apply/repeat, current/active/fresh protection", + flush=True, + ) + + +def main(): + p = argparse.ArgumentParser() + p.add_argument("action", choices=["seed", "verify"]) + p.add_argument("--seed", required=True, type=Path) + p.add_argument("--output", type=Path) + a = p.parse_args() + if a.action == "seed": + seed(a.seed) + else: + if a.output is None: + p.error("output required") + verify(a.seed, a.output) + + +if __name__ == "__main__": + main() diff --git a/scripts/verify_pipeline.py b/scripts/verify_pipeline.py index 1d4fd6f8..78281d38 100644 --- a/scripts/verify_pipeline.py +++ b/scripts/verify_pipeline.py @@ -30,7 +30,7 @@ db,store,queue=database(),ObjectStore(),broker() def inside(code): - cid = compose("ps", "-q", "api").split()[0] + cid = compose("ps", "-q", "controller").split()[0] return json.loads( command( ["docker", "exec", "-i", cid, "python", "-"], input=PREFIX + code @@ -123,8 +123,19 @@ def main(): try: ready() # Check instrumentation is really enabled and production default is off. - assert inside( - "import os\nprint(json.dumps(os.getenv('PIPELINE_FAULTS')=='1'))" + cid = compose("ps", "-q", "api").split()[0] + assert ( + command( + [ + "docker", + "exec", + cid, + "python", + "-c", + "import os;print(os.getenv('PIPELINE_FAULTS'))", + ] + ) + == "1" ) stop("reconciler") with httpx.Client( @@ -503,6 +514,71 @@ def main(): save( "malformed_notification_rejected", {"durable_diagnostic": True} ) + # Private bucket, bounded IAM, and download after uploader process dies. + a, j = upload() + confirm(a, j) + key = f"objects/{a['id']}/v1/original" + security = inside(f"""from minio.error import S3Error +from urllib.error import HTTPError +try: urllib.request.urlopen('http://s3:9000/'+BUCKET+'/' + {key!r},timeout=3) +except HTTPError as e: anonymous=e.code +else: raise AssertionError('Anonymous access allowed') +denials={{}} +for name,fn in [('create_bucket',lambda:store.client.make_bucket('forbidden-'+uuid4().hex)),('write_outside_prefix',lambda:store.client.put_object(BUCKET,'outside-'+uuid4().hex,io.BytesIO(b'x'),1)),('list_other_bucket',lambda:list(store.client.list_objects('forbidden-'+uuid4().hex)))]: + try: fn() + except S3Error as e: denials[name]=e.code + else: raise AssertionError('IAM allowed forbidden action') +print(json.dumps({{'anonymous':anonymous,'iam':denials}}))""") + assert security["anonymous"] == 403 and set( + security["iam"].values() + ) == {"AccessDenied"} + selected = None + for cid in compose("ps", "-q", "api").split(): + alias = command( + [ + "docker", + "exec", + cid, + "python", + "-c", + "import urllib.request;print(urllib.request.urlopen('http://127.0.0.1:8080/health/live').headers['X-Instance-Id'])", + ] + ) + uploader = inside( + f"with db.connection() as c: r=c.execute('SELECT uploader_instance FROM attachments WHERE id=%s',({a['id']!r},)).fetchone()\nprint(json.dumps(r['uploader_instance']))" + ) + if alias == uploader: + selected = cid + assert selected + command(["docker", "stop", "--time", "1", selected]) + ready() + wait( + lambda: ( + client.get( + f"/api/v1/attachments/{a['id']}/content", headers=h + ).status_code + == 200 + ) + ) + downloaded = client.get( + f"/api/v1/attachments/{a['id']}/content", headers=h + ) + assert ( + downloaded.content == raw + and downloaded.headers["X-Instance-Id"] != uploader + ) + start("api") + ready() + save( + "private_iam_and_other_api_download", + { + "security": security, + "attachment": a["id"], + "uploader": uploader, + "downloader": downloaded.headers["X-Instance-Id"], + "sha256": hashlib.sha256(raw).hexdigest(), + }, + ) report["worker_metrics"] = inside( "with db.connection() as c: r=c.execute(\"SELECT job_id,detail FROM pipeline_events WHERE event='child_finished' ORDER BY id\").fetchall()\nprint(json.dumps(r,default=str))" ) diff --git a/student-unit/test_job_envelope.py b/student-unit/test_job_envelope.py new file mode 100644 index 00000000..6f3444e9 --- /dev/null +++ b/student-unit/test_job_envelope.py @@ -0,0 +1,68 @@ +import copy +from datetime import UTC, datetime +from uuid import uuid4 + +import pytest +from jsonschema import Draft202012Validator, FormatChecker + +from src.pipeline import validate_job + + +def example(): + return dict( + schema_version=1, + job_id=str(uuid4()), + type="attachment.process.v1", + attachment_id=str(uuid4()), + pipeline_version=1, + attempt=1, + created_at=datetime.now(UTC).isoformat(), + ) + + +def test_schema_and_runtime_agree_on_valid_job(): + import json + from pathlib import Path + + schema = json.loads(Path("contracts/jobs.schema.json").read_text()) + for version in [1, 2]: + data = example() + data["pipeline_version"] = version + data.update( + traceparent="00-" + "a" * 32 + "-" + "b" * 16 + "-01", + tracestate="vendor=opaque", + ) + Draft202012Validator(schema, format_checker=FormatChecker()).validate( + data + ) + assert validate_job(data) == data + + +@pytest.mark.parametrize( + "field,value", + [ + ("schema_version", True), + ("schema_version", 2), + ("type", "other"), + ("job_id", 123), + ("job_id", "broken"), + ("attachment_id", None), + ("pipeline_version", 0), + ("pipeline_version", True), + ("attempt", 0), + ("attempt", 1.0), + ("created_at", "2026-01-01"), + ("created_at", "2026-01-01T12:00:00"), + ("created_at", None), + ("traceparent", "not-w3c"), + ("tracestate", "x" * 513), + ("url", "http://invalid.example"), + ("bytes", "secret-contents"), + ("filename", "../../bad"), + ], +) +def test_invalid_notification_is_rejected(field, value): + data = copy.deepcopy(example()) + data[field] = value + with pytest.raises((ValueError, TypeError)): + validate_job(data)