Document pipeline evidence and load profile (U5)

This commit is contained in:
Самохвалов Андрей Ремович
2026-10-02 14:59:32 +03:00
parent ab88c5ba1b
commit 3386e46c39
8 changed files with 357 additions and 21 deletions
+64 -20
View File
@@ -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 проверены отдельно.
+40
View File
@@ -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"
}
@@ -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.
+17
View File
@@ -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."
}
+3 -1
View File
@@ -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.
+107
View File
@@ -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()
+59
View File
@@ -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()
+45
View File
@@ -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)