Files
mtusi2026lab4-fork/scripts/s3_faults.py
T
2026-11-04 21:27:54 +03:00

109 lines
4.3 KiB
Python

"""Исполняется внутри API-контейнера: реальные S3/БД и управляемые отказы."""
import asyncio
import base64
from datetime import datetime, timedelta, timezone
import json
import sys
from uuid import UUID
from minio.error import S3Error
from sqlalchemy import select
from sqlalchemy.exc import OperationalError
from app.core.config import Settings
from app.core.database import create_db_engine, create_session_factory
from app.domain import attachments as domain
from app.errors.exceptions import unavailable
from app.models.attachment import UploadIntent
from app.schemas.user import User
from app.storage import attachments as repository
from app.storage.s3 import create_s3_storage
async def object_exists(storage, key):
exists = True
try:
await storage.stat_object(key)
except S3Error as error:
if error.code not in {'NoSuchKey', 'NoSuchObject'}:
raise
exists = False
return exists
async def main():
payload = json.load(sys.stdin)
settings = Settings()
engine = create_db_engine(settings)
factory = create_session_factory(engine)
storage = create_s3_storage(settings.s3)
user = User.model_validate(payload['user'])
chat_id = UUID(payload['chat_id'])
original = base64.b64decode(payload['image'])
keys = []
create_record = repository.create_attachment
put_file, delete_object = storage.put_file, storage.delete_object
async def capture_put(key, path, **metadata):
keys.append(key)
await put_file(key, path, **metadata)
async def fail_metadata(*args, **kwargs):
raise OperationalError('injected metadata failure after real S3 PUT', {}, None)
async def fail_delete(*args):
raise unavailable('injected compensation failure')
async def chunks():
yield original
async def attempt():
raised = False
async with factory() as session:
try:
await domain.upload_attachment(session, storage, user, chat_id,
filename='fault.png', content_type='image/png', chunks=chunks())
except OperationalError:
raised = True
assert raised, 'injected database failure was not raised'
storage.put_file = capture_put
repository.create_attachment = fail_metadata
try:
await attempt()
assert not await object_exists(storage, keys[-1]), 'compensation left original'
async with factory() as session:
intent = await session.scalar(select(UploadIntent).where(UploadIntent.object_key == keys[-1]))
assert intent is None, 'compensated upload left intent'
storage.delete_object = fail_delete
await attempt()
key = keys[-1]
assert await object_exists(storage, key), 'fault did not leave real S3 object'
storage.delete_object = delete_object
async with factory() as session:
result = await domain.reconcile_attachments(session, storage, dry_run=False)
assert result.deleted == 0, 'fresh object deleted before grace period'
intent = await session.scalar(select(UploadIntent).where(UploadIntent.object_key == key))
assert intent is not None, 'durable intent missing'
intent.created_at = datetime.now(timezone.utc) - timedelta(days=2)
await session.commit()
dry_run = await domain.reconcile_attachments(session, storage)
assert dry_run.candidates == 1 and dry_run.deleted == 0
assert await object_exists(storage, key), 'dry-run removed original'
applied = await domain.reconcile_attachments(session, storage, dry_run=False)
assert applied.deleted == 1 and not await object_exists(storage, key)
repeated = await domain.reconcile_attachments(session, storage, dry_run=False)
assert repeated.examined == repeated.deleted == 0
print(json.dumps({'compensation': True, 'durable_intent': True, 'grace_period': True,
'dry_run': True, 'cleanup': True, 'idempotent_cleanup': True}))
finally:
repository.create_attachment = create_record
storage.put_file, storage.delete_object = put_file, delete_object
await storage.aclose()
await engine.dispose()
if __name__ == '__main__':
asyncio.run(main())