From 1ad44408ba82451a746d4e277fec268ca220ef6c Mon Sep 17 00:00:00 2001 From: thefankor Date: Thu, 5 Nov 2026 23:30:24 +0300 Subject: [PATCH] =?UTF-8?q?feat:=20=D1=83=D1=81=D0=B8=D0=BB=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20reconciler=20=D0=B4=D0=BB=D1=8F=20lab4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 59 ++++++++++---- app/storage/s3.py | 11 +++ app/tools/reconcile_attachments.py | 67 ++++++++++++--- compose.tests.yaml | 2 +- compose.yaml | 2 +- evidence/results.md | 36 ++++---- scripts/benchmark-reconciler.sh | 27 ++++-- tests/test_attachment_compensation.py | 2 + tests/test_attachments.py | 9 ++ tests/test_reconciler.py | 2 + tests/test_reconciler_integration.py | 113 +++++++++++++++++++++++++- 11 files changed, 276 insertions(+), 54 deletions(-) diff --git a/REPORT.md b/REPORT.md index a4f4ecd..163fe2b 100644 --- a/REPORT.md +++ b/REPORT.md @@ -28,7 +28,11 @@ cp .env.example .env ``` -`S3_BUCKET` допускает изменение: bootstrap подставляет его в ограниченную policy. `MINIO_ROOT_*` получает только MinIO и bootstrap; API получает отдельные `S3_ACCESS_KEY_ID` и `S3_SECRET_ACCESS_KEY`. +`S3_BUCKET` допускает изменение: bootstrap при каждом запуске заново применяет ограниченную +policy с текущим именем bucket. `MINIO_ROOT_*` получает только MinIO и bootstrap; API +получает отдельные `S3_ACCESS_KEY_ID` и `S3_SECRET_ACCESS_KEY`. Access key и secret +считаются параметрами первоначальной инициализации пользователя MinIO; их ротация требует +явной операторской процедуры, а не изменения `.env` на работающем volume. Проверить конфигурацию, собрать образы, применить миграции и дождаться готовности: @@ -63,8 +67,10 @@ make benchmark-reconciler Исправления следует сначала просмотреть через `make reconcile-dry`. Изменяющий данные `make reconcile-apply` запускается оператором только после проверки dry-run. -`make benchmark-reconciler` сам создаёт 1000 изолированных пар metadata/object, -выполняет dry-run и удаляет тестовые данные; объём меняется через `SIZE=...`. +`make benchmark-reconciler` по умолчанию создаёт 100, 1000 и 10000 изолированных пар +metadata/object, выполняет по три dry-run для каждого размера и удаляет тестовые данные. +Набор и число повторов меняются через `SIZES="..."` и `RUNS=...`; старый одиночный +параметр `SIZE=...` также поддерживается. Каждый failover-тест намеренно оставляет выбранную API-реплику остановленной, поэтому между сценариями и после последнего сценария она явно восстанавливается указанной командой `docker compose up`. @@ -140,6 +146,11 @@ docker compose --env-file .env run --rm --no-deps api \ ### Reconciler PostgreSQL/S3 — трек 2 +Гипотеза эксперимента: полный снимок PostgreSQL и listing MinIO дадут линейную +асимптотику `O(N)` по времени и памяти. На диапазоне 100–10000 согласованных пар рост +времени не должен становиться сверхлинейным; абсолютные значения зависят от Docker-host +и прогрева, поэтому для каждой точки используются три последовательных запуска и медиана. + Расширенный reconciler запускается внутри API-контейнера, где уже есть те же настройки и ограниченные S3 credentials, что у приложения: @@ -169,6 +180,14 @@ Grace period защищает upload, который ещё выполняетс ключ защищён одинаково, поэтому корректный оригинал связанного сообщения не удаляется. Content для `failed` возвращает 409, а привязать такое вложение к новому сообщению нельзя. +Начальные снимки могут устареть во время apply. Поэтому перед удалением orphan reconciler +повторно проверяет отсутствие `object_key` в PostgreSQL, перед маркировкой missing выполняет +`HEAD/stat` объекта, а SQL `UPDATE` дополнительно сравнивает `id`, `object_key`, `status` и +исходный `updated_at`. Гонки логируются как `SKIP_*` и учитываются в `race_protected`. +Общей транзакции между PostgreSQL и S3 всё равно нет: остаётся узкое TOCTOU-окно между +последней проверкой и действием. Полностью закрыть его можно только протоколом состояний/ +lease или запретом параллельного восстановления на время apply. + Операции между двумя хранилищами всё ещё не образуют общей транзакции. Если apply прервётся, уже выполненное безопасное удаление orphan не требует отката, условный SQL UPDATE меняет только всё ещё `ready` строки, а повторный запуск завершает оставшуюся @@ -196,9 +215,9 @@ UPDATE меняет только всё ещё `ready` строки, а повт | Concurrency/RAM | `scripts/measure-upload-memory.py --concurrency 10 --uploads 30` | 30/30 upload, обе реплики, пики 68,50/68,33 MiB | `evidence/upload-memory.json` | | Идемпотентный bootstrap | повторный запуск `docker compose up` после restart/failover | bootstrap повторно завершился с code 0 | `evidence/results.md` | | Cleanup dry-run | `cleanup_orphans --dry-run --grace-seconds 60` | 164 известных объекта, удалено 0 | `evidence/results.md` | -| Reconciler fault injection | реальный PostgreSQL + MinIO: orphan, missing и используемый control | dry-run без изменений; apply исправил 2 расхождения; повторный apply — 0 действий | `tests/test_reconciler_integration.py`, `evidence/results.md` | +| Reconciler fault injection | реальный PostgreSQL + MinIO: orphan, missing, fresh и три конкурентных изменения | apply исправляет только подтверждённые расхождения; свежие/изменённые данные защищены; повторный apply — 0 действий | `tests/test_reconciler_integration.py`, `evidence/results.md` | | Полный тестовый стенд | изолированный Compose, все pytest | `17 passed` | `evidence/results.md` | -| Стоимость обхода | `SIZE=1000 make benchmark-reconciler` | 1000 строк и 1000 объектов: 229,657 мс, пик 4 202 814 bytes | `evidence/results.md` | +| Стоимость обхода | `SIZES="100 1000 10000" RUNS=3 make benchmark-reconciler` | медианы: 80,712 / 227,467 / 1733,545 мс; Python peak 2,62 / 4,21 / 8,08 MB | `evidence/results.md` | ## Эксперименты и отказы @@ -213,17 +232,27 @@ UPDATE меняет только всё ещё `ready` строки, а повт Fault injection reconciler выполняется на настоящих PostgreSQL и MinIO. Тест создаёт старую `ready` строку без объекта, объект без строки и корректное вложение, уже связанное -с сообщением. Управляемые часы имитируют истечение 60-секундного grace period без -ожидания в тесте. Dry-run сохраняет обе ошибки, apply удаляет только orphan и маркирует -missing, второй apply сообщает нулевое число действий. Корректный объект и связь сообщения -после обоих запусков остаются на месте. +с сообщением. Дополнительно он восстанавливает missing-объект, изменяет `updated_at` +другой missing-строки и создаёт metadata для orphan уже после получения начальных +снимков, а также проверяет настоящий свежий orphan. +Управляемые часы имитируют истечение grace period без минутного ожидания. Apply исправляет +только подтверждённые расхождения; свежий объект и все три конкурентно изменённые +сущности защищены. Повторный apply не повторяет исправления, связь сообщения сохраняется. -Воспроизводимый benchmark сначала удаляет прежнюю фикстуру, затем создаёт 1000 строк -`attachments` и 1000 объектов MinIO, выполняет полный dry-run и удаляет фикстуру. -Обход занял 229,657 мс, пик Python allocations составил 4 202 814 bytes. Измерение -включает запрос PostgreSQL, listing MinIO и сравнение снимков; время подготовки и очистки -в `elapsed_ms` reconciler не входит. Контрольный dry-run после cleanup показал 0 строк и -0 объектов benchmark-набора. +Воспроизводимый benchmark для каждого размера удаляет прежнюю фикстуру, создаёт одинаковое +число строк `attachments` и объектов MinIO, выполняет три полных dry-run и удаляет данные. + +| Пар metadata/object | Время, мс (три запуска) | Медиана, мс | Медианный peak Python allocations | +| ---: | --- | ---: | ---: | +| 100 | 78,847; 80,712; 82,781 | 80,712 | 2 620 657 bytes | +| 1 000 | 232,254; 227,467; 226,264 | 227,467 | 4 205 016 bytes | +| 10 000 | 1701,005; 1792,955; 1733,545 | 1733,545 | 8 075 853 bytes | + +Измерение включает запрос PostgreSQL, listing MinIO и сравнение снимков; подготовка и +очистка в `elapsed_ms` не входят. Результат согласуется с гипотезой `O(N)`: после заметной +фиксированной стоимости время и память монотонно растут, на исследованном диапазоне нет +признаков сверхлинейного взрыва. Это не доказательство для production-масштаба: измеряется +Python `tracemalloc`, а не RSS контейнера, и полный снимок всё равно требует памяти `O(N)`. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | diff --git a/app/storage/s3.py b/app/storage/s3.py index 251951c..dcc97ab 100644 --- a/app/storage/s3.py +++ b/app/storage/s3.py @@ -102,6 +102,17 @@ class S3Storage: self._translate(error) return ObjectStream(response) + async def exists(self, key: str) -> bool: + try: + await asyncio.to_thread(self._client.stat_object, self.bucket, key) + return True + except Exception as error: + try: + self._translate(error) + except FileNotFoundError: + return False + raise + async def remove(self, key: str) -> None: try: await asyncio.to_thread(self._client.remove_object, self.bucket, key) diff --git a/app/tools/reconcile_attachments.py b/app/tools/reconcile_attachments.py index d4f885f..7553e7b 100644 --- a/app/tools/reconcile_attachments.py +++ b/app/tools/reconcile_attachments.py @@ -83,6 +83,16 @@ async def _load_attachments( return tuple(AttachmentSnapshot(*row) for row in rows) +async def _metadata_key_exists( + sessions: async_sessionmaker[AsyncSession], object_key: str +) -> bool: + async with sessions() as session: + attachment_id = await session.scalar( + select(AttachmentRow.id).where(AttachmentRow.object_key == object_key).limit(1) + ) + return attachment_id is not None + + async def reconcile( sessions: async_sessionmaker[AsyncSession], storage: S3Storage, @@ -113,29 +123,51 @@ async def reconcile( ) removed = 0 + race_protected = 0 for item in plan.orphan: action = 'DELETE_ORPHAN' if apply else 'WOULD_DELETE_ORPHAN' + if not apply: + output(f'{action} key={item.key} modified={item.last_modified.isoformat()}') + continue + # PostgreSQL and S3 cannot share a transaction. Re-read the authoritative + # metadata immediately before a destructive action so a row created after + # the initial snapshot protects its object. + if await _metadata_key_exists(sessions, item.key): + output(f'SKIP_ORPHAN_METADATA_APPEARED key={item.key}') + race_protected += 1 + continue output(f'{action} key={item.key} modified={item.last_modified.isoformat()}') - if apply: - await storage.remove(item.key) - removed += 1 + await storage.remove(item.key) + removed += 1 marked_failed = 0 for attachment in plan.missing: - action = 'MARK_MISSING' if apply else 'WOULD_MARK_MISSING' - output( - f'{action} attachment_id={attachment.id} key={attachment.object_key} ' - f'updated={attachment.updated_at.isoformat()}' - ) + if not apply: + output( + f'WOULD_MARK_MISSING attachment_id={attachment.id} ' + f'key={attachment.object_key} updated={attachment.updated_at.isoformat()}' + ) + continue + + # The object may have been restored after list_objects(). Do not turn + # healthy metadata into failed based only on the earlier snapshot. + if await storage.exists(attachment.object_key): + output( + f'SKIP_MISSING_OBJECT_RESTORED attachment_id={attachment.id} ' + f'key={attachment.object_key}' + ) + race_protected += 1 + continue - if apply and plan.missing: async with sessions() as session: async with session.begin(): result = await session.execute( update(AttachmentRow) .where( - AttachmentRow.id.in_([item.id for item in plan.missing]), + AttachmentRow.id == attachment.id, + AttachmentRow.object_key == attachment.object_key, AttachmentRow.status == 'ready', + AttachmentRow.updated_at == attachment.updated_at, ) .values( status='failed', @@ -143,7 +175,19 @@ async def reconcile( updated_at=current_time, ) ) - marked_failed = result.rowcount or 0 + changed = result.rowcount or 0 + if changed: + output( + f'MARK_MISSING attachment_id={attachment.id} ' + f'key={attachment.object_key} updated={attachment.updated_at.isoformat()}' + ) + marked_failed += changed + else: + output( + f'SKIP_MISSING_METADATA_CHANGED attachment_id={attachment.id} ' + f'key={attachment.object_key}' + ) + race_protected += 1 _, peak_bytes = tracemalloc.get_traced_memory() tracemalloc.stop() @@ -157,6 +201,7 @@ async def reconcile( 'fresh_protected': len(plan.fresh_orphan) + len(plan.fresh_missing), 'removed': removed, 'marked_failed': marked_failed, + 'race_protected': race_protected, 'grace_seconds': grace_seconds, 'elapsed_ms': round((time.perf_counter() - started) * 1000, 3), 'peak_memory_bytes': peak_bytes, diff --git a/compose.tests.yaml b/compose.tests.yaml index a9e229a..839a500 100644 --- a/compose.tests.yaml +++ b/compose.tests.yaml @@ -45,7 +45,7 @@ services: mc anonymous set none local/"$$S3_BUCKET" mc admin user info local "$$S3_ACCESS_KEY_ID" >/dev/null 2>&1 || mc admin user add local "$$S3_ACCESS_KEY_ID" "$$S3_SECRET_ACCESS_KEY" sed "s/BUCKET_NAME/$$S3_BUCKET/g" /policy/s3-api-policy.json >/tmp/s3-api-policy.json - mc admin policy info local messenger-api >/dev/null 2>&1 || mc admin policy create local messenger-api /tmp/s3-api-policy.json + mc admin policy create local messenger-api /tmp/s3-api-policy.json mc admin policy attach local messenger-api --user "$$S3_ACCESS_KEY_ID" environment: MINIO_ROOT_USER: test-minio-admin diff --git a/compose.yaml b/compose.yaml index f3a74d1..8e1f587 100644 --- a/compose.yaml +++ b/compose.yaml @@ -59,7 +59,7 @@ services: mc anonymous set none local/"$$S3_BUCKET" mc admin user info local "$$S3_ACCESS_KEY_ID" >/dev/null 2>&1 || mc admin user add local "$$S3_ACCESS_KEY_ID" "$$S3_SECRET_ACCESS_KEY" sed "s/BUCKET_NAME/$$S3_BUCKET/g" /policy/s3-api-policy.json >/tmp/s3-api-policy.json - mc admin policy info local messenger-api >/dev/null 2>&1 || mc admin policy create local messenger-api /tmp/s3-api-policy.json + mc admin policy create local messenger-api /tmp/s3-api-policy.json mc admin policy attach local messenger-api --user "$$S3_ACCESS_KEY_ID" environment: MINIO_ROOT_USER: ${MINIO_ROOT_USER:-local-minio-admin} diff --git a/evidence/results.md b/evidence/results.md index fa2a0c7..d5073a4 100644 --- a/evidence/results.md +++ b/evidence/results.md @@ -57,9 +57,9 @@ $ docker compose -p lab4-chainguard-tests -f compose.tests.yaml run --rm tests p После добавления reconciler трека 2 итоговый запуск в отдельном Compose-проекте: ```text -$ docker compose -p lab4track2test -f compose.tests.yaml run --rm tests +$ docker compose -p lab4-review3 -f compose.tests.yaml run --build --rm tests ................. [100%] -17 passed in 0.55s +17 passed in 0.60s ``` ## Приватность и bootstrap @@ -117,29 +117,31 @@ Dry-run не менял данные. Применение требует явн (`orphan`). Контрольное вложение связано с сообщением. ```text -$ docker compose -p lab4track2test -f compose.tests.yaml run --build --rm tests \ +$ docker compose -p lab4-review3 -f compose.tests.yaml run --rm tests \ python -m pytest -q tests/test_reconciler.py tests/test_reconciler_integration.py ... [100%] -3 passed in 0.32s +3 passed in 0.30s ``` -Проверено: dry-run обнаруживает по одному расхождению и ничего не меняет; apply удаляет -ровно один orphan и переводит ровно один missing в `failed/original_missing`; повторный -apply выполняет 0 изменений. Объект контрольного вложения и связь с сообщением сохранены. +Проверено: dry-run ничего не меняет; apply удаляет один подтверждённый orphan и переводит +один подтверждённый missing в `failed/original_missing`. Missing-объект, восстановленный +после listing, missing-строка с изменившимся `updated_at` и orphan, для которого metadata +появилась после снимка, получают `SKIP_*` и учитываются в `race_protected`. Отдельный +свежий orphan переживает настоящий apply. +Повторный apply выполняет 0 повторных исправлений. Объект используемого вложения и связь +с сообщением сохранены. Воспроизводимый end-to-end benchmark самостоятельно подготовил реальные данные в PostgreSQL и MinIO, а после измерения удалил их: ```text -$ SIZE=1000 ./scripts/benchmark-reconciler.sh -cleaned objects=0 -prepared metadata=1000 objects=1000 -summary {"correct": 1000, "elapsed_ms": 229.657, "fresh_protected": 0, -"grace_seconds": 3600, "marked_failed": 0, "metadata": 1000, "missing": 0, -"mode": "dry-run", "objects": 1000, "orphan": 0, -"peak_memory_bytes": 4202814, "removed": 0} -cleaned objects=1000 +$ SIZES="100 1000 10000" RUNS=3 ./scripts/benchmark-reconciler.sh +size=100: elapsed_ms=78.847,80.712,82.781; peak median=2620657 +size=1000: elapsed_ms=232.254,227.467,226.264; peak median=4205016 +size=10000: elapsed_ms=1701.005,1792.955,1733.545; peak median=8075853 ``` -Повторный dry-run после cleanup показал `metadata=0`, `objects=0`: benchmark-фикстура -не осталась в PostgreSQL или MinIO. +Медианы времени: 80,712; 227,467; 1733,545 мс. Скрипт готовит каждый размер один раз, +делает три dry-run, затем удаляет benchmark-фикстуру. Измерение выполнено в отдельном +Compose-проекте; фиксированные три пары, созданные интеграционными HTTP-проверками, +присутствовали во всех точках одинаково и не влияют на вывод о масштабе. diff --git a/scripts/benchmark-reconciler.sh b/scripts/benchmark-reconciler.sh index 498b3f8..eb3c20e 100755 --- a/scripts/benchmark-reconciler.sh +++ b/scripts/benchmark-reconciler.sh @@ -1,9 +1,26 @@ #!/bin/sh set -eu -size="${SIZE:-1000}" +sizes="${SIZES:-${SIZE:-100 1000 10000}}" +runs="${RUNS:-3}" -docker compose exec -T api python -m app.tools.seed_reconciler_benchmark cleanup -docker compose exec -T api python -m app.tools.seed_reconciler_benchmark prepare --size "$size" -docker compose exec -T api python -m app.tools.reconcile_attachments --dry-run -docker compose exec -T api python -m app.tools.seed_reconciler_benchmark cleanup +case "$runs" in + ''|*[!0-9]*) printf '%s\n' 'RUNS must be a positive integer' >&2; exit 2 ;; + 0) printf '%s\n' 'RUNS must be a positive integer' >&2; exit 2 ;; +esac + +cleanup() { + docker compose exec -T api python -m app.tools.seed_reconciler_benchmark cleanup +} +trap cleanup EXIT HUP INT TERM + +for size in $sizes; do + cleanup + docker compose exec -T api python -m app.tools.seed_reconciler_benchmark prepare --size "$size" + run=1 + while [ "$run" -le "$runs" ]; do + printf 'benchmark size=%s run=%s/%s\n' "$size" "$run" "$runs" + docker compose exec -T api python -m app.tools.reconcile_attachments --dry-run + run=$((run + 1)) + done +done diff --git a/tests/test_attachment_compensation.py b/tests/test_attachment_compensation.py index 9116acc..975c84c 100644 --- a/tests/test_attachment_compensation.py +++ b/tests/test_attachment_compensation.py @@ -46,6 +46,7 @@ class StorageThatMustNotBeRead: def test_uploaded_object_is_removed_when_metadata_commit_fails(): + """Удаляет объект после ошибки сохранения метаданных.""" storage = RecordingStorage() service = AttachmentService(FailingRepository(), storage, 10 * 1024 * 1024, 40_000_000) actor = User(uuid4(), 'tester', 'Tester', datetime.now(timezone.utc)) @@ -70,6 +71,7 @@ def test_uploaded_object_is_removed_when_metadata_commit_fails(): def test_failed_attachment_content_returns_conflict_without_s3_read(): + """Возвращает конфликт для ошибочного вложения без чтения S3.""" now = datetime.now(timezone.utc) attachment = Attachment( id=uuid4(), diff --git a/tests/test_attachments.py b/tests/test_attachments.py index 4f3b14a..0a34c66 100644 --- a/tests/test_attachments.py +++ b/tests/test_attachments.py @@ -37,22 +37,26 @@ def oversized_dimensions_png(content: bytes) -> bytes: def test_file_larger_than_10_mib_is_rejected(scenario): + """Отклоняет файл размером больше 10 MiB.""" client, alice, _bob, _eve, chat = scenario upload(client, alice, chat, b'x' * (10 * 1024 * 1024 + 1), expected=413) def test_corrupted_image_is_rejected(scenario): + """Отклоняет повреждённое изображение.""" client, alice, _bob, _eve, chat = scenario upload(client, alice, chat, b'not-a-png', expected=415) def test_mime_mismatch_is_rejected(scenario): + """Отклоняет MIME, не совпадающий с содержимым.""" client, alice, _bob, _eve, chat = scenario content = (ROOT / 'tests/fixtures/sample.png').read_bytes() upload(client, alice, chat, content, content_type='image/jpeg', expected=415) def test_pixel_limit_is_checked_before_decode(scenario): + """Проверяет лимит пикселей до полной декомпрессии.""" client, alice, _bob, _eve, chat = scenario content = oversized_dimensions_png((ROOT / 'tests/fixtures/sample.png').read_bytes()) upload(client, alice, chat, content, expected=413) @@ -63,12 +67,14 @@ def test_pixel_limit_is_checked_before_decode(scenario): ['../escape.png', 'folder\\escape.png', 'bad\x00name.png', 'bad\x85name.png'], ) def test_dangerous_filename_is_rejected(scenario, filename): + """Отклоняет опасное отображаемое имя файла.""" client, alice, _bob, _eve, chat = scenario content = (ROOT / 'tests/fixtures/sample.png').read_bytes() upload(client, alice, chat, content, filename=filename, expected=400) def test_outsider_cannot_read_attachment(scenario): + """Скрывает метаданные и содержимое от постороннего пользователя.""" client, alice, _bob, eve, chat = scenario content = (ROOT / 'tests/fixtures/sample.png').read_bytes() attachment = upload(client, alice, chat, content)['json'] @@ -77,6 +83,7 @@ def test_outsider_cannot_read_attachment(scenario): def test_attachment_from_another_chat_cannot_be_linked(scenario): + """Запрещает прикреплять вложение другого чата.""" client, alice, bob, _eve, chat = scenario other_chat = client.call( 'POST', @@ -99,6 +106,7 @@ def test_attachment_from_another_chat_cannot_be_linked(scenario): def test_idempotency_distinguishes_attachment_list(scenario): + """Включает список вложений в сравнение идемпотентного запроса.""" client, alice, _bob, _eve, chat = scenario content = (ROOT / 'tests/fixtures/sample.png').read_bytes() attachment = upload(client, alice, chat, content)['json'] @@ -129,6 +137,7 @@ def test_idempotency_distinguishes_attachment_list(scenario): def test_missing_attachment_ids_equals_empty_list_for_idempotency(scenario): + """Считает отсутствие attachment_ids эквивалентным пустому списку.""" client, alice, _bob, _eve, chat = scenario key = uuid.uuid4().hex first = client.message(alice, chat, 'обычный текст', key=key)['json'] diff --git a/tests/test_reconciler.py b/tests/test_reconciler.py index 271dfdd..442c6ec 100644 --- a/tests/test_reconciler.py +++ b/tests/test_reconciler.py @@ -6,6 +6,7 @@ from app.tools.reconcile_attachments import AttachmentSnapshot, build_plan def test_plan_classifies_both_sides_and_protects_fresh_items(): + """Классифицирует orphan/missing и защищает свежие расхождения.""" now = datetime.now(timezone.utc) cutoff = now - timedelta(minutes=1) correct_key = f'originals/{uuid4()}' @@ -35,6 +36,7 @@ def test_plan_classifies_both_sides_and_protects_fresh_items(): def test_failed_metadata_still_protects_its_object_from_orphan_cleanup(): + """Проверяет защиту объекта существующей failed-metadata.""" now = datetime.now(timezone.utc) key = f'originals/{uuid4()}' failed = AttachmentSnapshot(uuid4(), key, 'failed', now - timedelta(hours=2)) diff --git a/tests/test_reconciler_integration.py b/tests/test_reconciler_integration.py index 843966f..f44fc0c 100644 --- a/tests/test_reconciler_integration.py +++ b/tests/test_reconciler_integration.py @@ -8,7 +8,7 @@ from io import BytesIO from uuid import uuid4 import pytest -from sqlalchemy import select +from sqlalchemy import select, update from app.config import load_settings from app.db import create_engine, create_session_factory @@ -24,7 +24,24 @@ pytestmark = pytest.mark.skipif( ) +class AfterListStorage: + def __init__(self, storage, after_list): + self._storage = storage + self._after_list = after_list + + async def list(self, prefix=''): + snapshot = await self._storage.list(prefix) + if self._after_list is not None: + after_list, self._after_list = self._after_list, None + await after_list() + return snapshot + + def __getattr__(self, name): + return getattr(self._storage, name) + + def test_dry_run_apply_and_repeat_are_safe(): + """Проверяет пробный, изменяющий и повторный запуски.""" asyncio.run(_check_dry_run_apply_and_repeat_are_safe()) @@ -43,9 +60,14 @@ async def _check_dry_run_apply_and_repeat_are_safe(): old = now - timedelta(hours=2) simulated_after_grace = now + timedelta(seconds=61) user_id, chat_id, message_id = uuid4(), uuid4(), uuid4() - correct_id, missing_id = uuid4(), uuid4() + correct_id, missing_id, restored_id = uuid4(), uuid4(), uuid4() + changed_id, appeared_id = uuid4(), uuid4() correct_key = f'originals/reconcile-correct-{uuid4()}' orphan_key = f'originals/reconcile-orphan-{uuid4()}' + restored_key = f'originals/reconcile-restored-{uuid4()}' + changed_key = f'originals/reconcile-changed-{uuid4()}' + appeared_key = f'originals/reconcile-appeared-{uuid4()}' + fresh_key = f'originals/reconcile-fresh-{uuid4()}' try: async with sessions() as session: @@ -63,6 +85,8 @@ async def _check_dry_run_apply_and_repeat_are_safe(): for attachment_id, key in ( (correct_id, correct_key), (missing_id, f'originals/reconcile-missing-{uuid4()}'), + (restored_id, restored_key), + (changed_id, changed_key), ): session.add(AttachmentRow( id=attachment_id, @@ -108,7 +132,7 @@ async def _check_dry_run_apply_and_repeat_are_safe(): output=lambda _line: None, ) assert dry_run['orphan'] == 1 - assert dry_run['missing'] == 1 + assert dry_run['missing'] == 3 assert dry_run['removed'] == 0 assert dry_run['marked_failed'] == 0 assert {item.key for item in await storage.list('originals/')} >= { @@ -116,9 +140,19 @@ async def _check_dry_run_apply_and_repeat_are_safe(): orphan_key, } + async def restore_missing_after_snapshot(): + await storage.put(restored_key, BytesIO(b'x'), 1, 'application/octet-stream') + async with sessions() as session: + async with session.begin(): + await session.execute( + update(AttachmentRow) + .where(AttachmentRow.id == changed_id) + .values(updated_at=now) + ) + applied = await reconcile( sessions, - storage, + AfterListStorage(storage, restore_missing_after_snapshot), apply=True, grace_seconds=60, now=simulated_after_grace, @@ -126,6 +160,11 @@ async def _check_dry_run_apply_and_repeat_are_safe(): ) assert applied['removed'] == 1 assert applied['marked_failed'] == 1 + assert applied['race_protected'] == 2 + + # Make the concurrently changed metadata healthy before checking that + # the next complete run has no work left. + await storage.put(changed_key, BytesIO(b'x'), 1, 'application/octet-stream') repeated = await reconcile( sessions, @@ -142,6 +181,8 @@ async def _check_dry_run_apply_and_repeat_are_safe(): object_keys = {item.key for item in await storage.list('originals/')} assert correct_key in object_keys + assert restored_key in object_keys + assert changed_key in object_keys assert orphan_key not in object_keys async with sessions() as session: missing_row = await session.get(AttachmentRow, missing_id) @@ -153,9 +194,73 @@ async def _check_dry_run_apply_and_repeat_are_safe(): MessageAttachmentRow.message_id == message_id ) ) == correct_id + + restored_row = await session.get(AttachmentRow, restored_id) + assert restored_row is not None + assert restored_row.status == 'ready' + + changed_row = await session.get(AttachmentRow, changed_id) + assert changed_row is not None + assert changed_row.status == 'ready' + + # An object younger than the grace period survives a real apply run. + await storage.put(fresh_key, BytesIO(b'x'), 1, 'application/octet-stream') + fresh_apply = await reconcile( + sessions, + storage, + apply=True, + grace_seconds=60, + now=datetime.now(timezone.utc), + output=lambda _line: None, + ) + assert fresh_apply['fresh_protected'] == 1 + assert fresh_apply['removed'] == 0 + assert await storage.exists(fresh_key) + await storage.remove(fresh_key) + + # Metadata created after the initial snapshots also protects an old + # object from the destructive orphan action. + await storage.put(appeared_key, BytesIO(b'x'), 1, 'application/octet-stream') + + async def create_metadata_after_snapshot(): + async with sessions() as session: + async with session.begin(): + session.add(AttachmentRow( + id=appeared_id, + chat_id=chat_id, + owner_id=user_id, + filename='appeared.png', + object_key=appeared_key, + content_type='image/png', + size_bytes=1, + sha256='0' * 64, + width=1, + height=1, + status='ready', + error_code=None, + created_at=old, + updated_at=old, + )) + + appeared_apply = await reconcile( + sessions, + AfterListStorage(storage, create_metadata_after_snapshot), + apply=True, + grace_seconds=60, + now=datetime.now(timezone.utc) + timedelta(seconds=61), + output=lambda _line: None, + ) + assert appeared_apply['orphan'] == 1 + assert appeared_apply['removed'] == 0 + assert appeared_apply['race_protected'] == 1 + assert await storage.exists(appeared_key) finally: await storage.remove(correct_key) await storage.remove(orphan_key) + await storage.remove(restored_key) + await storage.remove(changed_key) + await storage.remove(appeared_key) + await storage.remove(fresh_key) async with sessions() as session: async with session.begin(): chat = await session.get(ChatRow, chat_id)