Files
mtusi2026lab5/src/infrastructure/dependencies/database.py
T

237 lines
9.3 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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,
)