feat: усилить reconciler для lab4

This commit is contained in:
2026-11-05 23:30:24 +03:00
parent a3bbdeef42
commit 1ad44408ba
11 changed files with 276 additions and 54 deletions
+44 -15
View File
@@ -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)`.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
+11
View File
@@ -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)
+56 -11
View File
@@ -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,
+1 -1
View File
@@ -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
+1 -1
View File
@@ -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}
+19 -17
View File
@@ -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-проверками,
присутствовали во всех точках одинаково и не влияют на вывод о масштабе.
+22 -5
View File
@@ -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
+2
View File
@@ -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(),
+9
View File
@@ -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']
+2
View File
@@ -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))
+109 -4
View File
@@ -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)