Files
mtusi2026lab5/src/messenger/shared/infrastructure/postgres.py
T

140 lines
4.6 KiB
Python

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