114 lines
3.9 KiB
Python
114 lines
3.9 KiB
Python
import asyncio
|
|
from collections.abc import AsyncIterator, Awaitable, Callable, Sequence
|
|
from datetime import UTC, datetime, timedelta
|
|
from typing import Any
|
|
|
|
from dishka import Provider, Scope, provide
|
|
|
|
from messenger.attachments.application.errors import ObjectMissingError
|
|
from messenger.attachments.application.ports import ObjectContent, ObjectStorage, StoredObject
|
|
from messenger.shared.application.errors import Unavailable
|
|
|
|
|
|
class NullLogger:
|
|
__slots__ = ()
|
|
|
|
def info(self, event: str, /, **fields: Any) -> None: ...
|
|
|
|
def warning(self, event: str, /, **fields: Any) -> None: ...
|
|
|
|
def error(self, event: str, /, **fields: Any) -> None: ...
|
|
|
|
|
|
class FrozenClock:
|
|
__slots__ = ("_current",)
|
|
|
|
def __init__(self, start: datetime) -> None:
|
|
self._current = start
|
|
|
|
def now(self) -> datetime:
|
|
self._current += timedelta(microseconds=1)
|
|
return self._current
|
|
|
|
|
|
async def pieces(data: bytes, size: int = 65_536, delay: float = 0.0) -> AsyncIterator[bytes]:
|
|
for start in range(0, len(data), size):
|
|
await asyncio.sleep(delay)
|
|
yield data[start : start + size]
|
|
|
|
|
|
class MemoryObjectStorage:
|
|
__slots__ = ("after_page", "after_put", "delay", "failing", "modified", "objects")
|
|
|
|
def __init__(self) -> None:
|
|
self.objects: dict[str, tuple[bytes, str]] = {}
|
|
self.modified: dict[str, datetime] = {}
|
|
self.failing = False
|
|
self.delay = 0.0
|
|
self.after_put: Callable[[str], Awaitable[None]] | None = None
|
|
self.after_page: Callable[[], Awaitable[None]] | None = None
|
|
|
|
async def put(self, key: str, data: bytes, content_type: str) -> None:
|
|
if self.failing:
|
|
raise Unavailable("S3 недоступно")
|
|
self.objects[key] = (bytes(data), content_type)
|
|
self.modified[key] = datetime.now(UTC)
|
|
if self.after_put is not None:
|
|
await self.after_put(key)
|
|
|
|
async def listing(self, prefix: str, page_size: int) -> AsyncIterator[Sequence[StoredObject]]:
|
|
if self.failing:
|
|
raise Unavailable("S3 недоступно")
|
|
keys = sorted(key for key in self.objects if key.startswith(prefix))
|
|
for start in range(0, len(keys), page_size):
|
|
yield [self._stored(key) for key in keys[start : start + page_size]]
|
|
if self.after_page is not None:
|
|
await self.after_page()
|
|
|
|
async def stat(self, key: str) -> StoredObject | None:
|
|
return self._stored(key) if key in self.objects else None
|
|
|
|
def _stored(self, key: str) -> StoredObject:
|
|
return StoredObject(key, len(self.objects[key][0]), self.modified[key])
|
|
|
|
async def open(self, key: str) -> ObjectContent:
|
|
if self.failing:
|
|
raise Unavailable("S3 недоступно")
|
|
if key not in self.objects:
|
|
raise ObjectMissingError(key)
|
|
data = self.objects[key][0]
|
|
return ObjectContent(size=len(data), chunks=pieces(data, delay=self.delay))
|
|
|
|
async def read(self, key: str) -> bytes:
|
|
content = await self.open(key)
|
|
return b"".join([chunk async for chunk in content.chunks])
|
|
|
|
async def copy(self, source: str, target: str) -> None:
|
|
if self.failing:
|
|
raise Unavailable("S3 недоступно")
|
|
if source not in self.objects:
|
|
raise ObjectMissingError(source)
|
|
self.objects[target] = self.objects[source]
|
|
|
|
async def delete(self, key: str) -> None:
|
|
if self.failing:
|
|
raise Unavailable("S3 недоступно")
|
|
self.objects.pop(key, None)
|
|
self.modified.pop(key, None)
|
|
|
|
|
|
class MemoryStorageProvider(Provider):
|
|
@provide(scope=Scope.APP)
|
|
def storage(self) -> ObjectStorage:
|
|
return MemoryObjectStorage()
|
|
|
|
|
|
class RecordingPublisher:
|
|
__slots__ = ("events",)
|
|
|
|
def __init__(self) -> None:
|
|
self.events: list[Any] = []
|
|
|
|
async def publish(self, events: Sequence[Any]) -> None:
|
|
self.events.extend(events)
|