import asyncio from collections.abc import AsyncIterator from contextlib import asynccontextmanager from typing import ClassVar, Protocol from sqlalchemy import Text, make_url, select from sqlalchemy.exc import DBAPIError, IntegrityError, InterfaceError, OperationalError from sqlalchemy.exc import TimeoutError as PoolTimeout from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine from sqlalchemy.orm import DeclarativeBase from messenger.shared.application.errors import Unavailable from messenger.shared.domain.events import DomainEvent FAILURES = (OSError, InterfaceError, OperationalError, PoolTimeout, TimeoutError) PING_TIMEOUT_SECONDS = 0.4 type DatabaseSession = AsyncSession class EventSource(Protocol): def collect_events(self) -> list[DomainEvent]: ... class Base(DeclarativeBase): type_annotation_map: ClassVar = {str: Text} def unavailable(error: BaseException) -> bool: if isinstance(error, IntegrityError): return False if isinstance(error, FAILURES): return True if isinstance(error, DBAPIError) and error.connection_invalidated: return True state = getattr(error.orig if isinstance(error, DBAPIError) else error, "sqlstate", None) return isinstance(state, str) and (state.startswith(("08", "53", "57")) or state == "55P03") class Database: __slots__ = ("_engine", "_sessions") def __init__( self, dsn: str, *, max_size: int, connect_timeout: float, acquire_timeout: float, command_timeout: float, ) -> None: self._engine = create_async_engine( make_url(dsn).set(drivername="postgresql+asyncpg"), pool_size=max_size, max_overflow=0, pool_timeout=acquire_timeout, pool_recycle=60, pool_pre_ping=True, hide_parameters=True, connect_args={ "timeout": connect_timeout, "command_timeout": command_timeout, "server_settings": { "statement_timeout": str(int(command_timeout * 1000)), "lock_timeout": str(int(command_timeout * 1000)), "idle_in_transaction_session_timeout": "10000", }, }, ) self._sessions = async_sessionmaker(self._engine, expire_on_commit=False) async def open(self) -> None: pass async def close(self) -> None: await self._engine.dispose() @asynccontextmanager async def session(self) -> AsyncIterator[DatabaseSession]: try: async with self._sessions() as session: yield session except Exception as error: if not unavailable(error): raise raise Unavailable("PostgreSQL недоступен") from error async def ping(self) -> None: try: async with asyncio.timeout(PING_TIMEOUT_SECONDS): async with self.session() as session: await session.execute(select(1)) except TimeoutError as error: raise Unavailable("PostgreSQL недоступен") from error class PostgresUnitOfWork: __slots__ = ("_committed", "_database", "_events", "_session", "seen") def __init__(self, database: Database) -> None: self._database = database self._session: DatabaseSession | None = None self._committed = False self._events: list[DomainEvent] = [] self.seen: list[EventSource] = [] @property def session(self) -> DatabaseSession: if self._session is None: raise RuntimeError("репозиторий используется вне транзакции") return self._session @asynccontextmanager async def transaction(self) -> AsyncIterator[None]: async with self._database.session() as session: self._session = session self._committed = False mark = len(self._events) try: yield finally: if not self._committed: del self._events[mark:] self.seen.clear() self._session = None async def commit(self) -> None: await self.session.commit() self._committed = True for source in self.seen: self._events.extend(source.collect_events()) def record(self, event: DomainEvent) -> None: self._events.append(event) def collect_new_events(self) -> list[DomainEvent]: events, self._events = self._events, [] return events