188 lines
8.6 KiB
Python
188 lines
8.6 KiB
Python
"""Конфигурация из переменных окружения.
|
||
|
||
Секреты (строки подключения с паролями) читаются из файлов *_FILE,
|
||
которые Compose монтирует как secrets в /run/secrets/. Для локального
|
||
запуска без Docker допускаются и прямые переменные DATABASE_URL / CACHE_URL.
|
||
"""
|
||
import os
|
||
from dataclasses import dataclass
|
||
from typing import Optional
|
||
|
||
|
||
def _read_secret(name: str) -> Optional[str]:
|
||
path = os.environ.get(name + "_FILE")
|
||
if path:
|
||
with open(path, "r", encoding="utf-8") as handle:
|
||
value = handle.read().strip()
|
||
return value or None
|
||
value = os.environ.get(name, "").strip()
|
||
return value or None
|
||
|
||
|
||
def _int(name: str, default: int) -> int:
|
||
raw = os.environ.get(name)
|
||
if raw is None or raw.strip() == "":
|
||
return default
|
||
return int(raw)
|
||
|
||
|
||
def _float(name: str, default: float) -> float:
|
||
raw = os.environ.get(name)
|
||
if raw is None or raw.strip() == "":
|
||
return default
|
||
return float(raw)
|
||
|
||
|
||
def _bool(name: str, default: bool) -> bool:
|
||
raw = os.environ.get(name)
|
||
if raw is None or raw.strip() == "":
|
||
return default
|
||
return raw.strip().lower() in {"1", "true", "yes", "on"}
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class Settings:
|
||
app_env: str
|
||
app_version: str
|
||
instance_id: str
|
||
database_url: str
|
||
cache_url: Optional[str]
|
||
session_store: str
|
||
session_ttl_seconds: int
|
||
session_cache_ttl_seconds: int
|
||
db_pool_min: int
|
||
db_pool_max: int
|
||
db_pool_timeout: float
|
||
db_connect_timeout: int
|
||
db_statement_timeout_ms: int
|
||
cache_timeout_seconds: float
|
||
cache_retry_after_seconds: float
|
||
migrate_wait_seconds: int
|
||
run_migrations_on_start: bool
|
||
idempotency_ttl_seconds: int
|
||
idempotency_cleanup_interval_seconds: int
|
||
ready_db_timeout_seconds: float
|
||
drain_seconds: float
|
||
graceful_timeout_seconds: int
|
||
keep_alive_seconds: int
|
||
password_hash_concurrency: int
|
||
# lab4: S3 и вложения
|
||
s3_endpoint: Optional[str]
|
||
s3_region: str
|
||
s3_bucket: str
|
||
s3_access_key_id: Optional[str]
|
||
s3_secret_access_key: Optional[str]
|
||
s3_connect_timeout_seconds: float
|
||
s3_read_timeout_seconds: float
|
||
s3_max_attempts: int
|
||
s3_download_deadline_seconds: float
|
||
s3_upload_deadline_seconds: float
|
||
s3_circuit_open_seconds: float
|
||
max_upload_bytes: int
|
||
max_image_pixels: int
|
||
max_concurrent_uploads: int
|
||
upload_queue_timeout_seconds: float
|
||
upload_read_timeout_seconds: float
|
||
image_decode_concurrency: int
|
||
attachment_gc_interval_seconds: int
|
||
attachment_gc_grace_seconds: int
|
||
orphan_sweep_interval_seconds: int
|
||
fault_injection: str
|
||
|
||
|
||
# Жёсткие пределы контракта lab4; конфигурация может их только ужесточить.
|
||
CONTRACT_MAX_UPLOAD_BYTES = 10 * 1024 * 1024
|
||
CONTRACT_MAX_IMAGE_PIXELS = 40_000_000
|
||
# Grace period сборщика должен быть заметно больше самой долгой загрузки
|
||
# (чтение тела + S3 PUT с повтором), см. REPORT.md.
|
||
MIN_GC_GRACE_SECONDS = 300
|
||
|
||
|
||
def load_settings() -> Settings:
|
||
database_url = _read_secret("DATABASE_URL")
|
||
if not database_url:
|
||
raise RuntimeError("DATABASE_URL or DATABASE_URL_FILE must be set")
|
||
|
||
ttl = _int("SESSION_TTL_SECONDS", 3600)
|
||
if ttl < 1:
|
||
raise RuntimeError("SESSION_TTL_SECONDS must be positive")
|
||
|
||
session_store = os.environ.get("SESSION_STORE", "postgres").strip().lower()
|
||
# Источник истины для сессий в этой реализации всегда PostgreSQL;
|
||
# Redis (CACHE_URL) — только кэш проверок токена.
|
||
if session_store != "postgres":
|
||
raise RuntimeError("only SESSION_STORE=postgres is supported")
|
||
|
||
idem_ttl = _int("IDEMPOTENCY_TTL_SECONDS", 86400)
|
||
if idem_ttl < 86400:
|
||
# Контракт: повтор в течение 24 часов возвращает тот же результат.
|
||
raise RuntimeError("IDEMPOTENCY_TTL_SECONDS must be >= 86400")
|
||
|
||
# X-Instance-Id: по умолчанию hostname контейнера (= короткий ID контейнера
|
||
# Docker), стабилен в пределах жизни процесса. INSTANCE_ID — для запуска без Docker.
|
||
from .runtime import INSTANCE_ID as instance_id
|
||
|
||
max_upload = _int("MAX_UPLOAD_BYTES", CONTRACT_MAX_UPLOAD_BYTES)
|
||
max_pixels = _int("MAX_IMAGE_PIXELS", CONTRACT_MAX_IMAGE_PIXELS)
|
||
if not 1 <= max_upload <= CONTRACT_MAX_UPLOAD_BYTES:
|
||
raise RuntimeError("MAX_UPLOAD_BYTES must be within 1..10485760")
|
||
if not 1 <= max_pixels <= CONTRACT_MAX_IMAGE_PIXELS:
|
||
raise RuntimeError("MAX_IMAGE_PIXELS must be within 1..40000000")
|
||
gc_grace = _int("ATTACHMENT_GC_GRACE_SECONDS", 900)
|
||
# Меньше минимума — только для явных тестов сверки (ALLOW_SHORT_GC_GRACE=true).
|
||
if gc_grace < MIN_GC_GRACE_SECONDS and not _bool("ALLOW_SHORT_GC_GRACE", False):
|
||
raise RuntimeError("ATTACHMENT_GC_GRACE_SECONDS must be >= %d" % MIN_GC_GRACE_SECONDS)
|
||
|
||
return Settings(
|
||
app_env=os.environ.get("APP_ENV", "lab"),
|
||
app_version=os.environ.get("APP_VERSION", "lab4"),
|
||
instance_id=instance_id,
|
||
database_url=database_url,
|
||
cache_url=_read_secret("CACHE_URL"),
|
||
session_store=session_store,
|
||
session_ttl_seconds=ttl,
|
||
session_cache_ttl_seconds=_int("SESSION_CACHE_TTL_SECONDS", 60),
|
||
db_pool_min=_int("DB_POOL_MIN", 1),
|
||
db_pool_max=_int("DB_POOL_MAX", 10),
|
||
db_pool_timeout=_float("DB_POOL_TIMEOUT_SECONDS", 3.0),
|
||
db_connect_timeout=_int("DB_CONNECT_TIMEOUT_SECONDS", 3),
|
||
db_statement_timeout_ms=_int("DB_STATEMENT_TIMEOUT_MS", 5000),
|
||
cache_timeout_seconds=_float("CACHE_TIMEOUT_SECONDS", 0.25),
|
||
cache_retry_after_seconds=_float("CACHE_RETRY_AFTER_SECONDS", 5.0),
|
||
migrate_wait_seconds=_int("MIGRATE_WAIT_SECONDS", 60),
|
||
# lab3: миграции выполняет отдельный one-shot сервис `migrate`,
|
||
# реплики API их не запускают (нет гонки N реплик за схему).
|
||
run_migrations_on_start=_bool("RUN_MIGRATIONS_ON_START", False),
|
||
idempotency_ttl_seconds=idem_ttl,
|
||
idempotency_cleanup_interval_seconds=_int("IDEMPOTENCY_CLEANUP_INTERVAL_SECONDS", 300),
|
||
ready_db_timeout_seconds=_float("READY_DB_TIMEOUT_SECONDS", 1.0),
|
||
drain_seconds=_float("DRAIN_SECONDS", 3.0),
|
||
graceful_timeout_seconds=_int("GRACEFUL_TIMEOUT_SECONDS", 10),
|
||
keep_alive_seconds=_int("KEEP_ALIVE_SECONDS", 30),
|
||
password_hash_concurrency=_int("PASSWORD_HASH_CONCURRENCY", 4),
|
||
s3_endpoint=os.environ.get("S3_ENDPOINT", "").strip() or None,
|
||
s3_region=os.environ.get("S3_REGION", "us-east-1").strip() or "us-east-1",
|
||
s3_bucket=os.environ.get("S3_BUCKET", "messenger-attachments").strip(),
|
||
s3_access_key_id=_read_secret("S3_ACCESS_KEY_ID"),
|
||
s3_secret_access_key=_read_secret("S3_SECRET_ACCESS_KEY"),
|
||
s3_connect_timeout_seconds=_float("S3_CONNECT_TIMEOUT_SECONDS", 2.0),
|
||
s3_read_timeout_seconds=_float("S3_READ_TIMEOUT_SECONDS", 10.0),
|
||
s3_max_attempts=_int("S3_MAX_ATTEMPTS", 2),
|
||
# Полный бюджет вызова S3 из запроса (DNS + connect + повторы). Скачивание
|
||
# обязано уложиться в timeout server HAProxy (10 с), загрузка — 10 с (PUT 10 MiB локально ~0.1 с).
|
||
s3_download_deadline_seconds=_float("S3_DOWNLOAD_DEADLINE_SECONDS", 5.0),
|
||
s3_upload_deadline_seconds=_float("S3_UPLOAD_DEADLINE_SECONDS", 10.0),
|
||
s3_circuit_open_seconds=_float("S3_CIRCUIT_OPEN_SECONDS", 5.0),
|
||
max_upload_bytes=max_upload,
|
||
max_image_pixels=max_pixels,
|
||
max_concurrent_uploads=max(1, _int("MAX_CONCURRENT_UPLOADS", 4)),
|
||
upload_queue_timeout_seconds=_float("UPLOAD_QUEUE_TIMEOUT_SECONDS", 5.0),
|
||
upload_read_timeout_seconds=_float("UPLOAD_READ_TIMEOUT_SECONDS", 60.0),
|
||
image_decode_concurrency=max(1, _int("IMAGE_DECODE_CONCURRENCY", 2)),
|
||
attachment_gc_interval_seconds=_int("ATTACHMENT_GC_INTERVAL_SECONDS", 300),
|
||
attachment_gc_grace_seconds=gc_grace,
|
||
orphan_sweep_interval_seconds=_int("ORPHAN_SWEEP_INTERVAL_SECONDS", 3600),
|
||
# Только для тестового экземпляра api-faults (профиль faults), см. REPORT.md.
|
||
fault_injection=os.environ.get("FAULT_INJECTION", "").strip().lower(),
|
||
)
|