diff --git a/REPORT.md b/REPORT.md index e98f75e9..9cf8f801 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,81 @@ # Отчёт — лабораторная 5 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Самохвалов Андрей Ремович, БПИ-2302. +- Целевая оценка: 5, трек 2 «Доказанная идемпотентность pipeline». Уровни 3 и 4 тоже проверены. +- Ветка: `solution/bpi2302-samohvalov`. Локальные `docs/plans/` и `LAB_NOTES.md` не входят в коммиты. +- Источники: `README.md`, `COURSE.md`, `contracts/README.md`, `contracts/attachment-states.md`, `contracts/jobs.schema.json`, `contracts/openapi.json`, публичные тесты и собственная lab4. Python 3.12.12, FastAPI 0.118.3, Pillow 11.3.0, psycopg 3.2.12, MinIO SDK 7.2.20, pika 1.4.4. Помощь ИИ: Codex; факты ниже проверены на синтетических данных. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker Compose и Python 3.9+. Наружу опубликован только HAProxy на `127.0.0.1:${APP_PORT:-8080}`; паролей в Git нет. -## Архитектура и решения +```sh +cp .env.example .env +python3 scripts/setup-local-secrets.py +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --scale api=2 +docker compose --env-file .env up -d --wait --scale api=2 api lb worker publisher +make check +make test +``` -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Скрипт создаёт только отсутствующие секреты с правами 0600. `migrate`, `s3-volume-init`, `s3-bootstrap`, `broker-init` — одноразовые роли: `Exited (0)` для них штатен. Миграции применяются под PostgreSQL advisory lock. Остановить стенд без потери учебных данных: `docker compose --env-file .env down`. Только для намеренного удаления синтетических данных: `docker compose --env-file .env down -v`. + +Образы: PostgreSQL 17.6, RabbitMQ 4.1.8-management, HAProxy 3.0.11, Python 3.12.12, MinIO `RELEASE.2025-10-15T17-29-55Z` и MinIO Client `2025.7.21-debian-12-r3` (S3-образы закреплены digest). Проверено в Colima/arm64: 2 CPU, 2 GiB RAM. На этом хосте Docker build не разрешал DNS `files.pythonhosted.org`; сборка применяла только локальный ignored `compose.local.yaml` с временным адресом CDN через `COMPOSE_FILE=compose.yaml:compose.local.yaml`. При обычном DNS/PyPI он не нужен. + +## Архитектура и границы надёжности + +Клиент → HAProxy → две API-реплики. PostgreSQL — источник истины для пользователей, сообщений, вложений, jobs, outbox и версий. MinIO хранит байты в закрытом bucket. RabbitMQ переносит только ID и служебные поля `jobs.schema.json`, без изображения, credentials, клиентского пути или произвольного URL. + +| Роль | Health, volume, пределы | Доступ | +| --- | --- | --- | +| `lb` | проверка API backends, без данных | единственный host port | +| `api ×2` | `/health/ready`, 0,5 CPU/256 MiB каждая | DB URL и ограниченные S3 credentials | +| `postgres` | `pg_isready`, `postgres_data` | локальный secret | +| `s3` | `/minio/health/ready`, `s3_data`, 0,5 CPU/384 MiB | root только внутри S3/bootstrap | +| `broker` | `rabbitmq-diagnostics ping`, `broker_data` | AMQP URL через secret, без host port | +| `publisher` | отдельный процесс с publisher confirms | DB и AMQP, без S3 | +| `worker` | отдельный процесс, 0,5 CPU/768 MiB, prefetch=1 | DB, AMQP, объектные S3 права | +| `staging-cleanup` | периодический процесс | DB и отдельные S3 maintenance credentials | + +API потоково принимает до 10 MiB PNG/JPEG, сверяет MIME с содержимым и ограничивает изображение 40 млн пикселей. Имя файла используется только для отображения. Перед S3 PUT создаётся временный upload marker; полный staging-object затем сверяется по размеру и SHA-256. Одна транзакция записывает attachment, job и outbox, и лишь после COMMIT API отвечает `202 queued`. Поэтому остановленный broker/worker не теряет принятую загрузку; другие сообщения и ссылка на queued-вложение того же чата работают. Пока нет `ready`, скачивание отвечает 409. + +Publisher арендует outbox, публикует persistent сообщение в durable quorum queue и отмечает outbox только после broker confirm. Потеря DB-подтверждения может создать вторую доставку. Worker захватывает job под lease, читает доверенные метаданные из PostgreSQL, сверяет исходные байты и пишет объекты с детерминированными ключами. Статус `ready` фиксируется лишь после всех четырёх внутренних эффектов: `original`, `thumbnail`, `crop`, `optimized`. Публичная metadata показывает три производных варианта; доступ к каждому проходит проверку членства в чате через API. + +Original остаётся побайтно неизменным. Thumbnail — JPEG quality=85, `optimize=True`, вписан в 256×256 без увеличения и с округлением вниз: 320×200 → 256×160. Crop — центральный JPEG 128×128; маленький исходник может увеличиваться. Optimized — WebP quality=82, method=4, вписан в 1280×1280 без увеличения. EXIF orientation применяется к производным, alpha кладётся на белый фон, EXIF и прочие метаданные в производные не передаются. Уменьшение размера в байтах каждого файла не обещается. + +Worker имеет 60-секундный deadline/lease, одно текущее сообщение и контейнерный предел памяти. Временная ошибка повторяется до 5 попыток с экспоненциальной базой 1–30 с и jitter до 50%; `invalid_image` постоянна, `storage_unavailable` и `worker_timeout` повторяются. Исчерпанная job остаётся `failed` с безопасным `error_code` в БД: это реестр вместо отдельной DLQ-очереди. Операторский replay требует явной команды и пишет audit, а `ready` job повторно не исполняется: + +```sh +docker compose --env-file .env exec -T worker python -m src.replay JOB_UUID --operator local-operator --reason 'verified repair' +``` + +Вторую версию исследователь запускает через `python -m src.reprocess ATTACHMENT_UUID` в worker-контейнере. Команда принимает только `ready` с проверенным оригиналом. Версия 1 читает staging, следующие версии — неизменный конечный original. Уникальность `(attachment_id, pipeline_version, name)` и lease token защищают текущий результат от старой доставки. После COMMIT worker удаляет staging по возможности; `staging-cleanup` повторяет удаление после сбоя. Orphan без job удаляется только после 3600 с и перепроверки upload marker/БД; queued/processing источник сохраняется. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| Критерий README | Команда/сценарий | Наблюдение | Evidence | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Общий стенд и quorum | `docker compose up -d --build --scale api=2`; restart broker; `rabbitmqctl list_queues` | Все роли поднялись; durable quorum queue сохранилась после restart | `evidence/broker-restart.txt`, `compose.yaml` | +| Публичный API | `make test BASE_URL=http://127.0.0.1:8085` после финальной сборки | PASS; original побайтно верен, thumbnail 256×160 | `tests/smoke.py` | +| Durable handoff | `student-tests/test_upload_handoff.py`: broker/worker down → 202/409 → restart API/broker | PASS; сообщение с вложением создано, та же job стала ready | собственный тест | +| Окно publish→confirm | `student-tests/test_publish_confirm_gap.py` | После первой broker confirm outbox остался pending; повтор дал 2 копии в очереди, но один логический ready-результат | `evidence/pipeline-faults-2026-10-02.md` | +| Варианты, доступ и лимиты | `student-tests/test_image_pipeline.py` в worker; `test_variants_api.py` через LB | 5/5 unit; все 3 варианта совпали с metadata/hash, original точен, чужой пользователь 404 | собственные тесты | +| Retry, lease, replay, версия, crash | `student-tests/test_pipeline_faults.py` на существующих и пустых томах | В обеих сериях 6/6 PASS, включая смерть процесса до/после S3 и после result COMMIT | `evidence/pipeline-faults-2026-10-02.md` | +| Очистка staging | `student-tests/test_staging_cleanup.py` в maintenance-контейнере | Старый orphan удалён, active upload сохранён, expired marker/object удалены | собственный тест U2 | +| Persistence/failover | `make test-persistence ACTION_SCRIPT=scripts/restart.sh`; `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | PASS; сохранены токен/данные после остановки API/LB/publisher/worker/cleanup/broker/PG/S3; 133 успешные записи, 0 ошибок, восстановление 1,327 с | hooks, `tests/resilience.py` | +| Нагрузка | `tests/load.py` 30 с/4 клиента; `scripts/measure-image-pipeline.py` 20+20 файлов/4 клиента | 22 419 сообщений без ошибок, 747,002 RPS; 40/40 изображений ready за 14,150 с | `evidence/load-2026-10-02.json`, `evidence/image-load-2026-10-02.json`, `evidence/image-resource-samples-2026-10-02.txt` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +## Эксперимент трека 5 и замеры -## Эксперименты и отказы +Гипотеза: подтверждённая job и её эффект останутся логически единичными при дублировании, перестановке версий и смерти worker до/после S3 и COMMIT. `evidence/pipeline-faults-2026-10-02.md` описывает две обезличенные серии: одна на существующих томах, другая в отдельном изначально пустом PostgreSQL/S3 проекте (до теста 0 jobs/replays). В каждой серии 6/6 PASS; у каждой готовой версии ровно четыре внутренние записи, current version и SHA-256 оригинала верны. Тест publish→confirm намеренно создал две копии в RabbitMQ. Это идемпотентность эффекта, не exactly-once доставка. -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Текстовая closed-loop нагрузка 30,012 с, concurrency=4: 22 419 успешных POST, 0 ошибок, 747,002 успешных RPS, latency p50/p95/p99=4,109/11,019/36,533 мс. Closed-loop не измеряет предельную пропускную способность image pipeline и имеет coordinated omission/накладные расходы клиента. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +Изображения: 20 PNG 320×200 по 111 817 байт и 20 PNG 800×600 с псевдослучайными пикселями по 1 441 103 байт; concurrency=4, 40/40 ready, 0 ошибок, 14,150 с (~2,827 ready/s). Для маленьких upload p50/p95/p99=20,276/29,796/30,022 мс, от начала upload до ready=1273,778/1285,587/1287,102 мс. Для больших upload=29,097/54,469/57,979 мс, до ready=1585,251/2256,920/2571,138 мс. `os.urandom` сохраняет размер/разрешение профиля, но не конкретный hash между запусками. Poll каждые 0,3 с увеличивает наблюдаемое время ready; p95/p99 основаны на 20 результатах каждого размера. Выборочные Docker stats во время серии: API 85–86 MiB на реплику, worker 49–61 MiB, S3 182–184 MiB; это снимки, не пик памяти. -## Ограничения и следующие шаги +После failover вторая API-реплика восстановлена командой `docker compose up -d --wait --scale api=2 api lb`. Основные тома сохраняют синтетические записи; отдельные пустые тома эксперимента удалены только в проекте `mtusi2026lab5fresh`. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +## Ограничения + +Единственные PostgreSQL, MinIO, RabbitMQ и Docker-host остаются точками отказа; quorum queue на одном узле не означает кластерную доступность. При недоступности зависимости worker повторяет работу или достигает `failed`, а не выдаёт ложный `ready`. Serial worker/prefetch=1 и 60-секундный deadline подходят для учебных лимитов 10 MiB/40 млн пикселей; на другом оборудовании нужны новые замеры. Локальный HTTP используется только с синтетическими данными; удалённой демонстрации нужен TLS. Публичный smoke подтверждает обязательный минимум; отказные сценарии и трек 5 проверены отдельно. diff --git a/evidence/image-load-2026-10-02.json b/evidence/image-load-2026-10-02.json new file mode 100644 index 00000000..d2cf2eab --- /dev/null +++ b/evidence/image-load-2026-10-02.json @@ -0,0 +1,40 @@ +{ + "accepted_ready": 40, + "concurrency": 4, + "elapsed_seconds": 14.15, + "failed": 0, + "failure_types": [], + "lab": 5, + "per_size": 20, + "profiles": { + "noise_800x600": { + "ready_ms": { + "p50": 1585.251, + "p95": 2256.92, + "p99": 2571.138 + }, + "size_bytes": 1441103, + "successful": 20, + "upload_ms": { + "p50": 29.097, + "p95": 54.469, + "p99": 57.979 + } + }, + "small_320x200": { + "ready_ms": { + "p50": 1273.778, + "p95": 1285.587, + "p99": 1287.102 + }, + "size_bytes": 111817, + "successful": 20, + "upload_ms": { + "p50": 20.276, + "p95": 29.796, + "p99": 30.022 + } + } + }, + "workload": "synthetic PNG upload and poll until ready" +} diff --git a/evidence/image-resource-samples-2026-10-02.txt b/evidence/image-resource-samples-2026-10-02.txt new file mode 100644 index 00000000..16973431 --- /dev/null +++ b/evidence/image-resource-samples-2026-10-02.txt @@ -0,0 +1,22 @@ +Lab5 synthetic image run, 2026-10-02, Colima/arm64, 2 CPU / 2 GiB VM. +Command: python3 scripts/measure-image-pipeline.py --base-url http://127.0.0.1:8085 --concurrency 4 --per-size 20 --output evidence/image-load-2026-10-02.json +40 uploads, 20 PNG files per size profile, no failures, elapsed 14.150 s. +Docker stats sampled with --no-stream during that run (CPU is an interval sample, +memory is current usage; these are not CPU/RSS peaks): + +sample 1: +api-1 13.74% 86.09 MiB / 256 MiB +api-2 13.98% 85.24 MiB / 256 MiB +worker 8.38% 60.82 MiB / 768 MiB +postgres 3.26% 70.89 MiB / 1.914 GiB +s3 5.32% 182.10 MiB / 384 MiB + +sample 2: +api-1 14.78% 86.06 MiB / 256 MiB +api-2 0.87% 85.19 MiB / 256 MiB +worker 0.22% 48.93 MiB / 768 MiB +postgres 0.24% 71.05 MiB / 1.914 GiB +s3 0.36% 183.60 MiB / 384 MiB + +The first sample was collected while load was active. The second may include +idle time near the end of the run. No broker/publisher stats were sampled. diff --git a/evidence/load-2026-10-02.json b/evidence/load-2026-10-02.json new file mode 100644 index 00000000..5209e34f --- /dev/null +++ b/evidence/load-2026-10-02.json @@ -0,0 +1,17 @@ +{ + "lab": 5, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.012, + "concurrency": 4, + "successful_requests": 22419, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 747.002, + "successful_latency_ms": { + "p50": 4.109, + "p95": 11.019, + "p99": 36.533 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/pipeline-faults-2026-10-02.md b/evidence/pipeline-faults-2026-10-02.md index 26743bf5..bbf741e7 100644 --- a/evidence/pipeline-faults-2026-10-02.md +++ b/evidence/pipeline-faults-2026-10-02.md @@ -33,4 +33,6 @@ Both runs returned the same anonymized raw summary (one JSON line per run): For each ready version, the test found exactly the four expected variant names (`original`, `thumbnail`, `crop`, `optimized`), a matching original SHA-256, and the expected current `pipeline_version`. Replaying an already ready job returned `duplicate_or_stale`. After a second version became ready, an older delivery left its checksums and current version unchanged; version 1 rows remained available as history. The failed-job replay wrote one audit row and used a new attempt without deleting prior outbox history. The transient retry test exhausted a two-attempt budget, recorded `failed`, then succeeded only after replay reset that budget. -The controlled process death checks durable boundaries, not the probability of such a crash under load. The local stand has one MinIO and one PostgreSQL instance, so this result does not prove service availability during their outage or exactly-once delivery. The broker outage/confirm boundary is tested separately; this matrix checks the worker effect boundary against real S3 and PostgreSQL. +`student-tests/test_publish_confirm_gap.py` separately stopped the normal publisher and worker, accepted a queued upload, published a persistent broker copy with confirm, intentionally left its outbox row unconfirmed, expired that claim, and ran normal `publish_batch` again. Before starting worker, RabbitMQ reported two queued copies and PostgreSQL reported confirmed outbox. After worker resumed, the attachment reached ready with one public three-variant set. This demonstrates the expected duplicate from publish-before-confirm and safe handling of it. `student-tests/test_upload_handoff.py` also passed with broker and worker down at upload time, then API/broker restart and the original accepted job reaching ready. + +The controlled process death checks durable boundaries, not the probability of such a crash under load. The local stand has one MinIO and one PostgreSQL instance, so this result does not prove service availability during their outage or exactly-once delivery. diff --git a/scripts/measure-image-pipeline.py b/scripts/measure-image-pipeline.py new file mode 100644 index 00000000..55b6e6cc --- /dev/null +++ b/scripts/measure-image-pipeline.py @@ -0,0 +1,107 @@ +#!/usr/bin/env python3 +"""Small synthetic image workload; reports upload and time-to-ready separately.""" + +import argparse +import hashlib +import json +import math +import os +import struct +import sys +import time +import uuid +import zlib +from concurrent.futures import ThreadPoolExecutor, as_completed +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) +from client import Client, Failure # noqa: E402 + + +def png_noise(width, height): + raw = b"".join(b"\0" + os.urandom(width * 3) for _ in range(height)) + + def chunk(kind, data): + return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data)) + + return (b"\x89PNG\r\n\x1a\n" + + chunk(b"IHDR", struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)) + + chunk(b"IDAT", zlib.compress(raw, 1)) + chunk(b"IEND", b"")) + + +def percentile(values, percentile_value): + values = sorted(values) + return round(values[max(0, math.ceil(len(values) * percentile_value) - 1)], 3) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--base-url", default="http://127.0.0.1:8080") + parser.add_argument("--concurrency", type=int, default=4) + parser.add_argument("--per-size", type=int, default=4) + parser.add_argument("--output", required=True) + args = parser.parse_args() + if not 1 <= args.concurrency <= 16 or not 1 <= args.per_size <= 100: + parser.error("invalid workload size") + + setup = Client(args.base_url) + alice, _bob, _eve, chat = setup.bootstrap() + images = { + "small_320x200": (ROOT / "tests/fixtures/sample.png").read_bytes(), + "noise_800x600": png_noise(800, 600), + } + items = [(name, data) for name, data in images.items() for _ in range(args.per_size)] + + def work(item): + name, data = item + client = Client(args.base_url, timeout=20) + start = time.monotonic() + response = client.call( + "POST", f"/api/v1/chats/{chat['id']}/attachments?filename={name}.png", + 202, actor=alice, raw=data, headers={"Content-Type": "image/png"}, schema="Attachment", + ) + accepted = time.monotonic() + attachment = response["json"] + if attachment["sha256"] != hashlib.sha256(data).hexdigest(): + raise Failure("accepted checksum mismatch") + client.wait_ready(alice, attachment, wait_seconds=180) + ready = time.monotonic() + return {"profile": name, "size_bytes": len(data), + "upload_ms": round((accepted - start) * 1000, 3), + "ready_ms": round((ready - start) * 1000, 3)} + + started = time.monotonic() + completed, failures = [], [] + with ThreadPoolExecutor(max_workers=args.concurrency) as executor: + for future in as_completed([executor.submit(work, item) for item in items]): + try: + completed.append(future.result()) + except (Failure, OSError, ValueError) as exc: + failures.append(type(exc).__name__) + elapsed = time.monotonic() - started + result = { + "lab": 5, "workload": "synthetic PNG upload and poll until ready", + "concurrency": args.concurrency, "per_size": args.per_size, + "elapsed_seconds": round(elapsed, 3), "accepted_ready": len(completed), + "failed": len(failures), "failure_types": sorted(set(failures)), + "profiles": {}, + } + for name, data in images.items(): + rows = [item for item in completed if item["profile"] == name] + result["profiles"][name] = { + "size_bytes": len(data), "successful": len(rows), + "upload_ms": {f"p{p}": percentile([r["upload_ms"] for r in rows], p / 100) + for p in (50, 95, 99)} if rows else {}, + "ready_ms": {f"p{p}": percentile([r["ready_ms"] for r in rows], p / 100) + for p in (50, 95, 99)} if rows else {}, + } + Path(args.output).write_text(json.dumps(result, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print(json.dumps(result, indent=2, sort_keys=True)) + if failures or len(completed) != len(items): + raise SystemExit(1) + + +if __name__ == "__main__": + main() diff --git a/student-tests/publish_gap_inner.py b/student-tests/publish_gap_inner.py new file mode 100644 index 00000000..e1e05596 --- /dev/null +++ b/student-tests/publish_gap_inner.py @@ -0,0 +1,59 @@ +"""Run in a one-shot publisher container to inject publish-before-confirm gap.""" + +import json +import os +from pathlib import Path +from uuid import UUID, uuid4 + +import pika + +from src.db import pool +from src.publisher import QUEUE, job_payload, publish_batch + + +attachment_id = UUID(os.environ["FAULT_ATTACHMENT_ID"]) +url = Path(os.environ["BROKER_URL_FILE"]).read_text(encoding="utf-8").strip() +broker = pika.BlockingConnection(pika.URLParameters(url)) +try: + channel = broker.channel() + channel.queue_declare(queue=QUEUE, passive=True) + channel.confirm_delivery() + token = uuid4() + with pool().connection() as conn: + row = conn.execute( + "SELECT o.id,o.job_id,o.attempt,j.attachment_id,j.pipeline_version,j.created_at " + "FROM attachment_outbox o JOIN attachment_jobs j ON j.id=o.job_id " + "WHERE j.attachment_id=%s AND j.pipeline_version=1 AND o.attempt=1", + (attachment_id,), + ).fetchone() + assert row is not None + claimed = conn.execute( + "UPDATE attachment_outbox SET claim_token=%s," + "claim_expires_at=clock_timestamp()+interval '30 seconds' " + "WHERE id=%s AND claim_token IS NULL AND published_at IS NULL RETURNING id", + (token, row["id"]), + ).fetchone() + assert claimed is not None + body = json.dumps(job_payload(row), separators=(",", ":")).encode() + channel.basic_publish( + exchange="", routing_key=QUEUE, mandatory=True, body=body, + properties=pika.BasicProperties(content_type="application/json", delivery_mode=2), + ) + # Simulate process death after broker confirm, before PostgreSQL confirm. + with pool().connection() as conn: + conn.execute( + "UPDATE attachment_outbox SET claim_expires_at=clock_timestamp()-interval '1 second' " + "WHERE id=%s AND claim_token=%s AND published_at IS NULL", + (row["id"], token), + ) + published = publish_batch(channel) + with pool().connection() as conn: + outbox = conn.execute( + "SELECT published_at IS NOT NULL AS confirmed FROM attachment_outbox " + "WHERE id=%s", (row["id"],), + ).fetchone() + count = channel.queue_declare(queue=QUEUE, passive=True).method.message_count + assert published >= 1 and outbox["confirmed"] and count >= 2 + print(json.dumps({"confirmed_after_republish": True, "queued_copies_before_worker": count})) +finally: + broker.close() diff --git a/student-tests/test_publish_confirm_gap.py b/student-tests/test_publish_confirm_gap.py new file mode 100644 index 00000000..be5b1b65 --- /dev/null +++ b/student-tests/test_publish_confirm_gap.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python3 +"""Show that broker confirm without outbox confirmation safely republishes.""" + +import subprocess +import sys +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) +from client import Client, arguments, check, run # noqa: E402 + + +def compose(*args, input_data=None): + return subprocess.run( + ["docker", "compose", "--env-file", ".env", *args], cwd=ROOT, + input=input_data, check=True, + ) + + +def main(): + args = arguments("Lab5 publish/confirm gap") + client = Client(args.base_url, args.ca_file) + compose("stop", "worker", "publisher") + attachment = None + try: + alice, bob, _eve, chat = client.bootstrap() + attachment, _original = client.attachment(alice, chat) + check(attachment["status"] == "queued", "upload was not queued") + source = (ROOT / "student-tests/publish_gap_inner.py").read_bytes() + compose( + "run", "--rm", "--no-deps", "-T", + "-e", f"FAULT_ATTACHMENT_ID={attachment['id']}", "publisher", "python", "-", + input_data=source, + ) + finally: + compose("up", "-d", "publisher", "worker") + ready = client.wait_ready(bob, attachment) + check(ready["status"] == "ready", "republished job did not finish") + check(len(ready["variants"]) == 3, "duplicate delivery changed variant set") + print("PASS: confirmed broker copy republished after lost DB confirm; worker reached ready once") + + +if __name__ == "__main__": + run(main)