import asyncio import time from collections.abc import AsyncIterator from contextlib import asynccontextmanager from pathlib import Path import asyncpg from starlette.requests import HTTPConnection from config import ( DB_COMMAND_TIMEOUT_SEC, DB_CONNECT_TIMEOUT_SEC, DB_HOST, DB_NAME, DB_PASS, DB_POOL_MAX_SIZE, DB_POOL_MIN_SIZE, DB_PORT, DB_USER, LOGGER, ) from infrastructure.utils import DATABASE_UNAVAILABLE_ERRORS MIGRATIONS_DIR = Path(__file__).resolve().parents[3] / "migrations" MIGRATIONS_LOCK_NAMESPACE = 1 STARTUP_RETRY_INTERVAL_SEC = 1 BROKEN_CONNECTION_ERRORS: tuple[type[Exception], ...] = ( asyncpg.PostgresConnectionError, asyncpg.InterfaceError, asyncpg.exceptions.OperatorInterventionError, ) MIGRATIONS_TIMEOUT_SEC = 300 class DatabasePoolManager: """Класс для управления пулом соединений и версионируемыми миграциями.""" def __init__( self, user: str, password: str, db: str, host: str, port: int, min_size: int, max_size: int, connect_timeout: float, command_timeout: float, ) -> None: self._user = user self._password = password self._host = host self._port = port self._database = db self.min_size = min_size self.max_size = max_size self.connect_timeout = connect_timeout self.command_timeout = command_timeout self.pool: asyncpg.Pool | None = None async def create_pool(self, startup_timeout: float) -> asyncpg.Pool: """ Создание ограниченного пула соединений. """ LOGGER.info("Установка соединения с базой данных psql") deadline = time.monotonic() + startup_timeout while self.pool is None: try: self.pool = await asyncpg.create_pool( user=self._user, password=self._password, host=self._host, port=self._port, database=self._database, min_size=self.min_size, max_size=self.max_size, timeout=self.connect_timeout, command_timeout=self.command_timeout, server_settings={ "application_name": "messenger-api", "statement_timeout": str(int(self.command_timeout * 1000)), }, ) except (*DATABASE_UNAVAILABLE_ERRORS, asyncpg.PostgresError) as error: if time.monotonic() >= deadline: LOGGER.error( "Не удалось подключиться к psql за " f"{startup_timeout} с: {type(error).__name__}" ) raise LOGGER.warning( f"PostgreSQL ещё недоступен: {type(error).__name__}, повтор" ) await asyncio.sleep(STARTUP_RETRY_INTERVAL_SEC) LOGGER.info( f"Соединение с базой данных psql установлено. DB_NAME: " f"{self._database}, pool: {self.min_size}..{self.max_size}" ) return self.pool async def apply_migrations(self, directory: Path = MIGRATIONS_DIR) -> None: """ Применение миграций NNNN_name.sql по порядку версий. Вызывается однократно отдельным процессом (src/migrate.py, сервис migrate) до запуска API-реплик, а не каждой репликой при старте. Каждая миграция и запись о ней в schema_migrations — одна транзакция. Advisory lock — страховка от двух одновременных запусков migrate; уже применённые версии пропускаются, поэтому повторный запуск безопасен. """ async with self.acquire() as conn: await conn.execute("SET statement_timeout = 0;") await conn.execute( "SELECT pg_advisory_lock($1, 0);", MIGRATIONS_LOCK_NAMESPACE, timeout=MIGRATIONS_TIMEOUT_SEC, ) try: await conn.execute( """ CREATE TABLE IF NOT EXISTS schema_migrations ( version integer PRIMARY KEY, name text NOT NULL, applied_at timestamptz NOT NULL DEFAULT clock_timestamp() ); """ ) applied = { record["version"] for record in await conn.fetch( "SELECT version FROM schema_migrations;" ) } for version, path in self._migration_files(directory): if version in applied: continue async with conn.transaction(): await conn.execute( path.read_text(encoding="utf-8"), timeout=MIGRATIONS_TIMEOUT_SEC, ) await conn.execute( "INSERT INTO schema_migrations (version, name) " "VALUES ($1, $2);", version, path.stem, ) LOGGER.info(f"Применена миграция {path.name}") finally: await conn.execute( "SELECT pg_advisory_unlock($1, 0);", MIGRATIONS_LOCK_NAMESPACE ) LOGGER.info("Схема БД в актуальной версии") async def check_migrations(self, directory: Path = MIGRATIONS_DIR) -> None: """ Схема БД не старше кода: все миграции из образа уже применены. API миграции не применяет. Если migrate ещё не отработал, реплика не стартует и не начинает слушать порт, балансировщик её не использует """ expected = {version for version, _ in self._migration_files(directory)} async with self.acquire() as conn: try: records = await conn.fetch("SELECT version FROM schema_migrations;") except asyncpg.UndefinedTableError: records = [] applied = {record["version"] for record in records} missing = sorted(expected - applied) if missing: raise RuntimeError( f"В БД не применены миграции {missing}: сначала запустите migrate" ) LOGGER.info(f"Схема БД совместима: версия {max(applied, default=0)}") @staticmethod def _migration_files(directory: Path) -> list[tuple[int, Path]]: """Файлы NNNN_name.sql по возрастанию версии""" return sorted( (int(path.name.split("_", 1)[0]), path) for path in directory.glob("*.sql") ) @asynccontextmanager async def acquire(self) -> AsyncIterator[asyncpg.Connection]: """ Получение соединения из пула с ограниченным ожиданием свободного. После рестарта PostgreSQL все соединения пула мертвы. На первой же ошибке соединения пул помечает их на переподключение, чтобы 503 получил один запрос, а не каждый из max_size следующих. """ assert self.pool is not None try: async with self.pool.acquire(timeout=self.connect_timeout) as connection: yield connection except BROKEN_CONNECTION_ERRORS: await self.pool.expire_connections() raise async def check(self) -> bool: """PostgreSQL отвечает на запрос — для readiness""" try: async with self.acquire() as conn: await conn.fetchval("SELECT 1;", timeout=self.connect_timeout) except DATABASE_UNAVAILABLE_ERRORS: return False return True async def close(self) -> None: if self.pool: await self.pool.close() self.pool = None def get_database(connection: HTTPConnection) -> DatabasePoolManager: """Получение менеджера пула соединений, созданного в lifespan.""" database: DatabasePoolManager = connection.app.state.database return database database_pool_manager = DatabasePoolManager( user=DB_USER, password=DB_PASS, db=DB_NAME, host=DB_HOST, port=DB_PORT, min_size=DB_POOL_MIN_SIZE, max_size=DB_POOL_MAX_SIZE, connect_timeout=DB_CONNECT_TIMEOUT_SEC, command_timeout=DB_COMMAND_TIMEOUT_SEC, )