forked from mtusi2026/mtusi2026lab5
237 lines
9.3 KiB
Python
237 lines
9.3 KiB
Python
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,
|
||
)
|