109 lines
4.3 KiB
Python
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())
|