feat: конф нгинкс, тесты, ключ идмпт etc

This commit is contained in:
Enterxx2
2026-10-20 10:41:56 +03:00
parent aa971fbd27
commit b53e5d1077
63 changed files with 5013 additions and 153 deletions
@@ -1,20 +1,26 @@
import re
import time
import uuid
from fastapi import Request, Response
from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
from application.api.utils import REQUEST_ID_HEADER, error_response
from config import LOGGER
from application.api.utils import INSTANCE_ID_HEADER, REQUEST_ID_HEADER, error_response
from config import INSTANCE_ID, LOGGER
from domain.errors import AppError
HEALTH_PATH_PREFIX = "/health/"
INCOMING_REQUEST_ID = re.compile(r"^[0-9a-f]{32}$")
class RequestContextMiddleware(BaseHTTPMiddleware):
"""
X-Request-Id в каждом ответе, журнал запросов и защита от необработанных ошибок.
X-Request-Id и X-Instance-Id в каждом ответе, журнал запросов и защита
от необработанных ошибок.
X-Request-Id берётся у балансировщика (nginx выставляет $request_id),
поэтому одна строка access-лога LB и журнал реплики связаны одним ID.
В лог попадают метод, путь, статус и длительность — без тел запросов,
query-параметров и текста сообщений.
"""
@@ -22,7 +28,7 @@ class RequestContextMiddleware(BaseHTTPMiddleware):
async def dispatch(
self, request: Request, call_next: RequestResponseEndpoint
) -> Response:
request_id = uuid.uuid4().hex
request_id = self._request_id(request)
request.state.request_id = request_id
started = time.perf_counter()
try:
@@ -34,9 +40,19 @@ class RequestContextMiddleware(BaseHTTPMiddleware):
request_id, error.status_code, error.code, error.message
)
response.headers[REQUEST_ID_HEADER] = request_id
response.headers[INSTANCE_ID_HEADER] = INSTANCE_ID
if getattr(request.app.state, "is_draining", False):
response.headers["Connection"] = "close"
self._log_request(request, response, request_id, started)
return response
@staticmethod
def _request_id(request: Request) -> str:
incoming = request.headers.get(REQUEST_ID_HEADER, "")
if INCOMING_REQUEST_ID.fullmatch(incoming):
return incoming
return uuid.uuid4().hex
@staticmethod
def _log_request(
request: Request, response: Response, request_id: str, started: float
@@ -1,10 +1,12 @@
from typing import Annotated
from uuid import UUID
from fastapi import APIRouter, Body, Depends, Query, status
from fastapi import APIRouter, Body, Depends, Header, Query, status
from application.api.dependencies import get_current_user
from domain import (
IDEMPOTENCY_KEY_MAX_LENGTH,
IDEMPOTENCY_KEY_PATTERN,
CreateMessageSchema,
MessagePageSchema,
MessageSchema,
@@ -26,10 +28,23 @@ messages_router = APIRouter(
async def send_message(
chat_id: UUID,
body: Annotated[CreateMessageSchema, Body(...)],
idempotency_key: Annotated[
str,
Header(
alias="Idempotency-Key",
min_length=1,
max_length=IDEMPOTENCY_KEY_MAX_LENGTH,
pattern=IDEMPOTENCY_KEY_PATTERN,
),
],
current_user: UserSchema = Depends(get_current_user),
service: MessageService = Depends(ServiceCreator.get_message_service),
) -> MessageSchema:
return await service.send_message(current_user, chat_id, body)
"""
Idempotency-Key обязателен: повтор того же тела возвращает тот же 201
и то же сообщение, другое тело с тем же ключом — 409. Нет/неверный ключ — 400.
"""
return await service.send_message(current_user, chat_id, body, idempotency_key)
@messages_router.get(
+12 -2
View File
@@ -1,3 +1,13 @@
from .errors import REQUEST_ID_HEADER, error_response, get_request_id
from .errors import (
INSTANCE_ID_HEADER,
REQUEST_ID_HEADER,
error_response,
get_request_id,
)
__all__ = ["REQUEST_ID_HEADER", "error_response", "get_request_id"]
__all__ = [
"REQUEST_ID_HEADER",
"INSTANCE_ID_HEADER",
"error_response",
"get_request_id",
]
+1
View File
@@ -6,6 +6,7 @@ from fastapi.responses import JSONResponse
from domain.errors import ErrorBodySchema, ErrorCode, ErrorSchema
REQUEST_ID_HEADER = "X-Request-Id"
INSTANCE_ID_HEADER = "X-Instance-Id"
def get_request_id(request: Request) -> str:
+12
View File
@@ -2,7 +2,9 @@ from .log_config import LOGGER
from .settings import (
APP_ENV,
APP_HOST,
APP_KEEPALIVE_TIMEOUT_SEC,
APP_PORT,
APP_REVISION,
DB_COMMAND_TIMEOUT_SEC,
DB_CONNECT_TIMEOUT_SEC,
DB_HOST,
@@ -13,10 +15,14 @@ from .settings import (
DB_PORT,
DB_STARTUP_TIMEOUT_SEC,
DB_USER,
IDEMPOTENCY_TTL_SECONDS,
INSTANCE_ID,
INSTANCE_ID_FILE,
LOG_LEVEL,
PASSWORD_HASH_WORKERS,
SESSION_CACHE_TTL_SECONDS,
SESSION_TTL_SECONDS,
SHUTDOWN_DRAIN_SEC,
SHUTDOWN_TIMEOUT_SEC,
VALKEY_HOST,
VALKEY_PASS,
@@ -31,8 +37,11 @@ __all__ = [
"APP_HOST",
"APP_PORT",
"APP_ENV",
"APP_REVISION",
"APP_KEEPALIVE_TIMEOUT_SEC",
"LOG_LEVEL",
"SHUTDOWN_TIMEOUT_SEC",
"SHUTDOWN_DRAIN_SEC",
"DB_USER",
"DB_PASS",
"DB_NAME",
@@ -52,4 +61,7 @@ __all__ = [
"SESSION_TTL_SECONDS",
"SESSION_CACHE_TTL_SECONDS",
"PASSWORD_HASH_WORKERS",
"IDEMPOTENCY_TTL_SECONDS",
"INSTANCE_ID",
"INSTANCE_ID_FILE",
]
+10
View File
@@ -1,4 +1,6 @@
import os
import secrets
import tempfile
from pathlib import Path
from envparse import Env
@@ -12,9 +14,13 @@ if ENV_FILE.is_file():
APP_HOST = env.str("APP_HOST")
APP_PORT = env.int("APP_PORT")
APP_ENV = env.str("APP_ENV")
APP_REVISION = env.str("APP_REVISION", default="dev")
# Больше keepalive_timeout балансировщика: idle-соединение закрывает LB, а не API
APP_KEEPALIVE_TIMEOUT_SEC = env.int("APP_KEEPALIVE_TIMEOUT_SEC")
LOG_LEVEL = env.str("LOG_LEVEL")
SHUTDOWN_TIMEOUT_SEC = env.int("SHUTDOWN_TIMEOUT_SEC")
SHUTDOWN_DRAIN_SEC = env.float("SHUTDOWN_DRAIN_SEC")
DB_USER = env.str("DB_USER")
DB_PASS = env.str("DB_PASS")
@@ -37,3 +43,7 @@ VALKEY_RETRY_AFTER_SEC = env.float("VALKEY_RETRY_AFTER_SEC")
SESSION_TTL_SECONDS = env.int("SESSION_TTL_SECONDS")
SESSION_CACHE_TTL_SECONDS = env.int("SESSION_CACHE_TTL_SECONDS")
PASSWORD_HASH_WORKERS = env.int("PASSWORD_HASH_WORKERS")
IDEMPOTENCY_TTL_SECONDS = env.int("IDEMPOTENCY_TTL_SECONDS")
INSTANCE_ID = secrets.token_hex(6)
INSTANCE_ID_FILE = Path(tempfile.gettempdir()) / "instance-id"
+11 -1
View File
@@ -1,7 +1,14 @@
from .auth import ActiveSessionSchema, BasicCredentialsSchema, SessionSchema
from .chats import ChatPageSchema, ChatSchema, CreateChatSchema
from .health import HealthSchema
from .messages import CreateMessageSchema, MessagePageSchema, MessageSchema
from .messages import (
IDEMPOTENCY_KEY_MAX_LENGTH,
IDEMPOTENCY_KEY_PATTERN,
CreateMessageSchema,
IdempotencyKeySchema,
MessagePageSchema,
MessageSchema,
)
from .pagination import PageCursorSchema, PageKey
from .users import CreateUserSchema, UserCredentialsSchema, UserSchema
@@ -16,6 +23,9 @@ __all__ = [
"ChatSchema",
"ChatPageSchema",
"CreateMessageSchema",
"IdempotencyKeySchema",
"IDEMPOTENCY_KEY_PATTERN",
"IDEMPOTENCY_KEY_MAX_LENGTH",
"MessageSchema",
"MessagePageSchema",
"HealthSchema",
+11 -1
View File
@@ -1,7 +1,17 @@
from .schemas import CreateMessageSchema, MessagePageSchema, MessageSchema
from .schemas import (
IDEMPOTENCY_KEY_MAX_LENGTH,
IDEMPOTENCY_KEY_PATTERN,
CreateMessageSchema,
IdempotencyKeySchema,
MessagePageSchema,
MessageSchema,
)
__all__ = [
"IDEMPOTENCY_KEY_PATTERN",
"IDEMPOTENCY_KEY_MAX_LENGTH",
"CreateMessageSchema",
"IdempotencyKeySchema",
"MessageSchema",
"MessagePageSchema",
]
+18
View File
@@ -7,6 +7,9 @@ from domain.utils import NotBlankStr, UtcDateTime
MessageText = Annotated[NotBlankStr, Field(min_length=1, max_length=4000)]
IDEMPOTENCY_KEY_PATTERN = r"^[A-Za-z0-9._:-]{1,128}$"
IDEMPOTENCY_KEY_MAX_LENGTH = 128
class CreateMessageSchema(BaseModel):
"""Запрос отправки сообщения: отправитель берётся из текущей сессии"""
@@ -33,3 +36,18 @@ class MessagePageSchema(BaseModel):
items: list[MessageSchema]
next_cursor: str | None
class IdempotencyKeySchema(BaseModel):
"""
Ключ повторной отправки сообщения.
request_hash — SHA-256 канонического тела: повтор с тем же ключом и тем же
телом возвращает исходное сообщение, с другим телом — конфликт.
"""
model_config = ConfigDict(frozen=True)
key: str
request_hash: bytes
ttl_seconds: int
+63 -8
View File
@@ -1,3 +1,5 @@
import asyncio
import socket
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
@@ -10,11 +12,16 @@ from application.api.middlewares import RequestContextMiddleware
from config import (
APP_ENV,
APP_HOST,
APP_KEEPALIVE_TIMEOUT_SEC,
APP_PORT,
APP_REVISION,
DB_STARTUP_TIMEOUT_SEC,
INSTANCE_ID,
INSTANCE_ID_FILE,
LOGGER,
PASSWORD_HASH_WORKERS,
SESSION_TTL_SECONDS,
SHUTDOWN_DRAIN_SEC,
SHUTDOWN_TIMEOUT_SEC,
)
from infrastructure import PasswordHasher, cache_manager, database_pool_manager
@@ -22,29 +29,35 @@ from infrastructure import PasswordHasher, cache_manager, database_pool_manager
@asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncIterator[None]:
"""
uvicorn открывает порт только после startup: реплика без БД или со старой
схемой не принимает соединений, и LB отправляет запросы другим репликам.
"""
await database_pool_manager.create_pool(DB_STARTUP_TIMEOUT_SEC)
await database_pool_manager.apply_migrations()
await database_pool_manager.check_migrations()
cache_manager.create_client()
password_hasher = PasswordHasher(PASSWORD_HASH_WORKERS)
app.state.database = database_pool_manager
app.state.cache = cache_manager
app.state.password_hasher = password_hasher
INSTANCE_ID_FILE.write_text(INSTANCE_ID)
app.state.is_ready = True
LOGGER.info(
f"Application started, env={APP_ENV}, session ttl={SESSION_TTL_SECONDS} s"
f"Application started, env={APP_ENV}, revision={APP_REVISION}, "
f"instance={INSTANCE_ID}, session ttl={SESSION_TTL_SECONDS} s"
)
yield
app.state.is_ready = False
await cache_manager.close()
await database_pool_manager.close()
password_hasher.close()
LOGGER.info("Application stopped, connections closed")
LOGGER.info(f"Application stopped, instance={INSTANCE_ID}, connections closed")
app = FastAPI(
title="mtuci-labs-messanger",
description="мессенджер-конкурент-максу",
version="1.2.0",
version="1.3.0",
lifespan=lifespan,
)
@@ -55,17 +68,59 @@ app.include_router(health_endpoints)
app.include_router(api_endpoints)
def main(host: str, port: int, shutdown_timeout: int) -> None:
"""Функция для запуска api"""
uvicorn.run(
class DrainingServer(uvicorn.Server):
"""
SIGTERM: сначала drain, затем штатный graceful shutdown uvicorn.
"""
def __init__(self, config: uvicorn.Config, drain_seconds: float) -> None:
super().__init__(config)
self._drain_seconds = drain_seconds
async def shutdown(self, sockets: list[socket.socket] | None = None) -> None:
for server in getattr(self, "servers", []):
server.close()
app.state.is_ready = False
app.state.is_draining = True
LOGGER.info(
f"SIGTERM: drain {self._drain_seconds} с, instance={INSTANCE_ID}: "
"порт закрыт, keep-alive соединения закрываются после ответа"
)
await asyncio.sleep(self._drain_seconds)
await super().shutdown(sockets)
def main(
host: str,
port: int,
shutdown_timeout: int,
keepalive_timeout: int,
drain_seconds: float,
) -> None:
"""
Функция для запуска api.
SIGTERM: drain_seconds без приёма новых соединений, затем uvicorn ждёт
текущих запросов не дольше shutdown_timeout, и lifespan закрывает пулы.
Сумма меньше stop_grace_period контейнера (10 с).
"""
config = uvicorn.Config(
app,
host=host,
port=port,
timeout_graceful_shutdown=shutdown_timeout,
timeout_keep_alive=keepalive_timeout,
access_log=False,
server_header=False,
)
DrainingServer(config, drain_seconds).run()
if __name__ == "__main__":
main(host=APP_HOST, port=APP_PORT, shutdown_timeout=SHUTDOWN_TIMEOUT_SEC)
main(
host=APP_HOST,
port=APP_PORT,
shutdown_timeout=SHUTDOWN_TIMEOUT_SEC,
keepalive_timeout=APP_KEEPALIVE_TIMEOUT_SEC,
drain_seconds=SHUTDOWN_DRAIN_SEC,
)
+33 -3
View File
@@ -106,8 +106,10 @@ class DatabasePoolManager:
"""
Применение миграций NNNN_name.sql по порядку версий.
Вызывается однократно отдельным процессом (src/migrate.py, сервис migrate)
до запуска API-реплик, а не каждой репликой при старте.
Каждая миграция и запись о ней в schema_migrations — одна транзакция.
Advisory lock не даёт двум процессам API применять миграции одновременно;
Advisory lock — страховка от двух одновременных запусков migrate;
уже применённые версии пропускаются, поэтому повторный запуск безопасен.
"""
async with self.acquire() as conn:
@@ -133,8 +135,7 @@ class DatabasePoolManager:
"SELECT version FROM schema_migrations;"
)
}
for path in sorted(directory.glob("*.sql")):
version = int(path.name.split("_", 1)[0])
for version, path in self._migration_files(directory):
if version in applied:
continue
async with conn.transaction():
@@ -155,6 +156,35 @@ class DatabasePoolManager:
)
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]:
"""
@@ -1,6 +1,10 @@
from fastapi import Depends
from config import SESSION_CACHE_TTL_SECONDS, SESSION_TTL_SECONDS
from config import (
IDEMPOTENCY_TTL_SECONDS,
SESSION_CACHE_TTL_SECONDS,
SESSION_TTL_SECONDS,
)
from infrastructure.dependencies.cache import CacheManager, get_cache
from infrastructure.dependencies.database import DatabasePoolManager, get_database
from infrastructure.repositories import (
@@ -90,4 +94,6 @@ class ServiceCreator:
chat_repository: ChatRepository = Depends(_get_chat_repository),
message_repository: MessageRepository = Depends(_get_message_repository),
) -> MessageService:
return MessageService(chat_repository, message_repository)
return MessageService(
chat_repository, message_repository, IDEMPOTENCY_TTL_SECONDS
)
@@ -2,7 +2,8 @@ from uuid import UUID
import asyncpg
from domain import MessageSchema, PageKey
from domain import IdempotencyKeySchema, MessageSchema, PageKey
from domain.errors import ConflictError
from infrastructure.utils import Pool, repository_logs, transaction
from interfaces import MessageRepository
@@ -15,11 +16,22 @@ class PostgresMessageRepository(MessageRepository):
self._pool = pool
@repository_logs
async def create(self, chat_id: UUID, sender_id: UUID, text: str) -> MessageSchema:
async def create(
self,
chat_id: UUID,
sender_id: UUID,
text: str,
idempotency: IdempotencyKeySchema,
) -> tuple[MessageSchema, bool]:
"""
Блокировка чата и вставка — одна транзакция; lock снимается на COMMIT.
Блокировка чата, проверка ключа, вставка сообщения и ключа — одна
транзакция; lock снимается на COMMIT.
Запись в один чат сериализуется, записи в разные чаты не мешают друг другу.
Ключ идемпотентности привязан к чату, поэтому та же блокировка
сериализует и одновременные повторы с одним ключом с разных реплик:
второй ждёт COMMIT первого и находит его ключ
created_at строго больше последнего в чате, даже если часы ушли назад:
порядок коммитов совпадает с порядком (created_at, id), и читатель
с cursor не пропустит сообщение. MAX берётся из индекса
@@ -28,6 +40,22 @@ class PostgresMessageRepository(MessageRepository):
lock_query = """
SELECT pg_advisory_xact_lock($1, hashtext($2::uuid::text));
"""
find_key_query = """
SELECT
idem.request_hash,
message.id,
message.chat_id,
message.sender_id,
message.text,
message.created_at
FROM message_idempotency_keys idem
JOIN messages message ON message.id = idem.message_id
WHERE
idem.sender_id = $1
AND idem.chat_id = $2
AND idem.idempotency_key = $3
AND idem.expires_at > clock_timestamp();
"""
insert_query = """
INSERT INTO messages
(
@@ -45,11 +73,56 @@ class PostgresMessageRepository(MessageRepository):
WHERE chat_id = $1
RETURNING id, chat_id, sender_id, text, created_at;
"""
save_key_query = """
INSERT INTO message_idempotency_keys
(
sender_id,
chat_id,
idempotency_key,
request_hash,
message_id,
expires_at
)
VALUES
(
$1,
$2,
$3,
$4,
$5,
clock_timestamp() + make_interval(secs => $6::integer)
)
ON CONFLICT (sender_id, chat_id, idempotency_key) DO UPDATE
SET
request_hash = EXCLUDED.request_hash,
message_id = EXCLUDED.message_id,
created_at = EXCLUDED.created_at,
expires_at = EXCLUDED.expires_at;
"""
async with transaction(self._pool) as conn:
await conn.execute(lock_query, CHAT_LOCK_NAMESPACE, chat_id)
stored = await conn.fetchrow(
find_key_query, sender_id, chat_id, idempotency.key
)
if stored is not None:
if stored["request_hash"] != idempotency.request_hash:
raise ConflictError(
"Idempotency-Key уже использован с другим телом запроса"
)
return self._row_to_message(stored), False
row = await conn.fetchrow(insert_query, chat_id, sender_id, text)
assert row is not None
return self._row_to_message(row)
assert row is not None
await conn.execute(
save_key_query,
sender_id,
chat_id,
idempotency.key,
idempotency.request_hash,
row["id"],
idempotency.ttl_seconds,
)
return self._row_to_message(row), True
@repository_logs
async def list_for_chat(
@@ -1,7 +1,14 @@
import hashlib
from uuid import UUID
from config import LOGGER
from domain import CreateMessageSchema, MessagePageSchema, MessageSchema, UserSchema
from domain import (
CreateMessageSchema,
IdempotencyKeySchema,
MessagePageSchema,
MessageSchema,
UserSchema,
)
from domain.errors import NotFoundError
from infrastructure.utils import build_page, decode_cursor
from interfaces import ChatRepository, MessageRepository
@@ -9,21 +16,47 @@ from interfaces import ChatRepository, MessageRepository
class MessageService:
def __init__(
self, chat_repository: ChatRepository, message_repository: MessageRepository
self,
chat_repository: ChatRepository,
message_repository: MessageRepository,
idempotency_ttl_seconds: int,
) -> None:
self._chats = chat_repository
self._messages = message_repository
self._idempotency_ttl = idempotency_ttl_seconds
async def send_message(
self, current_user: UserSchema, chat_id: UUID, data: CreateMessageSchema
self,
current_user: UserSchema,
chat_id: UUID,
data: CreateMessageSchema,
idempotency_key: str,
) -> MessageSchema:
"""Отправитель берётся из текущей идентификации; текст в логи не пишется"""
"""
Отправитель берётся из текущей идентификации; текст в логи не пишется.
Повтор с тем же Idempotency-Key заново проверяет доступ к чату
и возвращает исходное сообщение.
"""
await self._ensure_member(current_user, chat_id)
message = await self._messages.create(chat_id, current_user.id, data.text)
LOGGER.info(
f"Сообщение {message.id} отправлено в чат {chat_id} "
f"пользователем {current_user.id}"
idempotency = IdempotencyKeySchema(
key=idempotency_key,
request_hash=self._request_hash(data),
ttl_seconds=self._idempotency_ttl,
)
message, created = await self._messages.create(
chat_id, current_user.id, data.text, idempotency
)
if created:
LOGGER.info(
f"Сообщение {message.id} отправлено в чат {chat_id} "
f"пользователем {current_user.id}"
)
else:
LOGGER.info(
f"Повтор по Idempotency-Key: возвращено сообщение {message.id} "
f"чата {chat_id}"
)
return message
async def list_messages(
@@ -40,3 +73,11 @@ class MessageService:
"""Посторонний получает 404: существование чужого чата не раскрывается"""
if await self._chats.get_for_member(chat_id, current_user.id) is None:
raise NotFoundError()
@staticmethod
def _request_hash(data: CreateMessageSchema) -> bytes:
"""
SHA-256 канонического тела. Порядок полей задаёт схема, а не клиент,
поэтому JSON с другим порядком ключей считается тем же запросом.
"""
return hashlib.sha256(data.model_dump_json().encode()).digest()
+12 -2
View File
@@ -1,18 +1,28 @@
from abc import ABC, abstractmethod
from uuid import UUID
from domain import MessageSchema, PageKey
from domain import IdempotencyKeySchema, MessageSchema, PageKey
class MessageRepository(ABC):
"""Слой абстракции хранилища сообщений"""
@abstractmethod
async def create(self, chat_id: UUID, sender_id: UUID, text: str) -> MessageSchema:
async def create(
self,
chat_id: UUID,
sender_id: UUID,
text: str,
idempotency: IdempotencyKeySchema,
) -> tuple[MessageSchema, bool]:
"""
Добавление сообщения в конец истории чата. id и created_at назначает
хранилище; created_at строго возрастает внутри чата, поэтому сообщение
не может появиться перед уже выданным cursor.
Сообщение и запись ключа идемпотентности сохраняются атомарно.
Одновременные запросы с одним ключом через любые реплики создают
ровно одно сообщение; повтор возвращает его же.
"""
pass
+24
View File
@@ -0,0 +1,24 @@
"""
Однократное применение миграций до запуска API-реплик.
Запускается сервисом migrate (compose) и завершается; реплики стартуют
после его успешного завершения и только проверяют версию схемы.
"""
import asyncio
from config import DB_STARTUP_TIMEOUT_SEC, LOGGER
from infrastructure import database_pool_manager
async def main() -> None:
await database_pool_manager.create_pool(DB_STARTUP_TIMEOUT_SEC)
try:
await database_pool_manager.apply_migrations()
finally:
await database_pool_manager.close()
LOGGER.info("Миграции применены, migrate завершается")
if __name__ == "__main__":
asyncio.run(main())