Author SHA1 Message Date
gytall 2d40313318 fixed makefile and add new evidence 2026-11-12 23:02:32 +03:00
gytall 2639c08944 final vers 2026-11-12 22:50:05 +03:00
gytall 9899ee4676 formatted project by python-black 2026-11-10 09:52:42 +03:00
gytall 7cd02da51d pure version of lab5 2026-11-10 07:44:19 +03:00
gytall 2b9fb3f375 included rabbitmq as broker 2026-11-10 07:01:17 +03:00
gytall 0a70358829 prepared skeleton for lab5 2026-11-07 16:10:32 +03:00
156 changed files with 12794 additions and 377 deletions
+1
View File
@@ -18,3 +18,4 @@ __pycache__
node_modules
evidence
.DS_Store
docs
+86 -12
View File
@@ -1,25 +1,99 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
# Скопируйте в .env для локального окружения; .env не коммитится.
# Настройки приложения, Compose и очереди.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
APP_ENV=development
LOG_LEVEL=INFO
MAX_MESSAGES=100000
# Лимит одновременных запросов НА ОДНУ реплику
MAX_IN_FLIGHT=16
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
SESSION_STORE=redis
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_DB=0
REDIS_MAX_CONNECTIONS=20
REDIS_POOL_TIMEOUT_SECONDS=1
REDIS_CONNECT_TIMEOUT_SECONDS=1
REDIS_SOCKET_TIMEOUT_SECONDS=0.5
DB_HOST=postgres
DB_PORT=5432
DB_NAME=messenger
DB_USER=messenger
# Пул на одну реплику: суммарно API_REPLICAS * (POOL_SIZE + MAX_OVERFLOW)
# соединений должно помещаться в max_connections PostgreSQL.
DB_POOL_SIZE=5
DB_MAX_OVERFLOW=10
DB_POOL_TIMEOUT_SECONDS=3
DB_CONNECT_TIMEOUT_SECONDS=3
DB_STATEMENT_TIMEOUT_MS=5000
# --- Балансировка и идемпотентность ---
API_REPLICAS=2
API_IMAGE=messenger:local
API_BUILD_REVISION=development
IDEMPOTENCY_TTL_SECONDS=86400
S3_ENDPOINT=http://s3:9000
SHUTDOWN_DRAIN_SECONDS=1
GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS=5
READINESS_TIMEOUT_SECONDS=2
# Порт единственной публичной точки входа (nginx)
LB_HOST_PORT=18081
# Используются только тестовым стендом (compose.test.yaml)
DB_HOST_PORT=25432
REDIS_HOST_PORT=26379
# --- MinIO, ограниченный upload и очистка журнала ---
S3_ENDPOINT=http://minio:9000
S3_REGION=us-east-1
S3_BUCKET=messenger-attachments
S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
BROKER_URL_FILE=/run/secrets/broker_url
S3_CONNECT_TIMEOUT_SECONDS=2
S3_READ_TIMEOUT_SECONDS=10
S3_UPLOAD_TIMEOUT_SECONDS=30
S3_DOWNLOAD_TIMEOUT_SECONDS=60
S3_IMAGE_TIMEOUT_SECONDS=10
S3_MAX_UPLOAD_BYTES=10485760
S3_MAX_IMAGE_PIXELS=40000000
S3_CHUNK_BYTES=65536
S3_MAX_CONCURRENT_UPLOADS=2
S3_CLEANUP_GRACE_SECONDS=86400
S3_CLEANUP_INTERVAL_SECONDS=300
# Пути секретов внутри контейнеров; должны совпадать с secrets mounts.
POSTGRES_PASSWORD_FILE=/run/secrets/db_password
MINIO_ROOT_USER_FILE=/run/secrets/minio_root_user
MINIO_ROOT_PASSWORD_FILE=/run/secrets/minio_root_password
MINIO_BROWSER=off
# Отдельный RabbitMQ broker и ограниченный worker.
WORKER_CONCURRENCY=2
JOB_MAX_ATTEMPTS=5
JOB_TIMEOUT_SECONDS=60
STAGING_RETENTION_SECONDS=86400
BROKER_HOST=broker
BROKER_PORT=5672
BROKER_PASSWORD_FILE=/run/secrets/broker_password
BROKER_QUEUE=attachment-jobs
BROKER_USER=messenger
BROKER_VHOST=/
JOB_LEASE_SECONDS=90
JOB_RETRY_SECONDS=5
PUBLISHER_POLL_SECONDS=1
# Качество вариантов и лимиты одного процесса обработки
IMAGE_JPEG_QUALITY=85
IMAGE_WEBP_QUALITY=80
IMAGE_WEBP_METHOD=4
IMAGE_MEMORY_MIB=768
IMAGE_CPU_SECONDS=20
# Retry cap and retained failed sources for explicit replay
JOB_RETRY_MAX_SECONDS=120
FAILED_STAGING_RETENTION_SECONDS=604800
+6
View File
@@ -28,5 +28,11 @@ coverage/
.DS_Store
.idea/
.vscode/
venv/
.pytest_cache/
.ruff_cache/
# Keep small, sanitized evidence summaries in evidence/ under version control.
# Inspect git diff --cached: ignore rules are not a secret scanner.
# Private working documentation
/docs/
+29
View File
@@ -0,0 +1,29 @@
FROM python:3.12.15-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1 \
PIP_DISABLE_PIP_VERSION_CHECK=1
WORKDIR /app
RUN useradd --system --uid 10001 --no-create-home appuser
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY alembic.ini ./
COPY migrations ./migrations
COPY app ./app
ARG API_BUILD_REVISION
LABEL org.opencontainers.image.revision=$API_BUILD_REVISION
USER appuser
EXPOSE 8080
HEALTHCHECK --interval=3s --timeout=3s --start-period=10s --retries=2 \
CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/ready', timeout=2.5)"]
CMD ["python", "-m", "app"]
+110 -11
View File
@@ -1,13 +1,79 @@
PYTHON ?= python3
BASE_URL ?= http://localhost:8080
-include .env
PYTHON ?= $(if $(wildcard .venv/bin/python),.venv/bin/python,$(if $(wildcard venv/bin/python),venv/bin/python,python3))
PYTEST_ARGS ?=
BASE_URL ?= http://localhost:$(or $(LB_HOST_PORT),8080)
CA_FILE ?=
SERVICE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
COMPOSE = docker compose --env-file .env
.PHONY: help check validate test load test-persistence test-failover
TEST_PROJECT ?= messenger-test
TEST_LB_PORT ?= 28080
TEST_DB_PORT ?= $(DB_HOST_PORT)
TEST_REDIS_PORT ?= $(REDIS_HOST_PORT)
TEST_BASE_URL = http://localhost:$(TEST_LB_PORT)
TEST_ENV = COMPOSE_PROJECT_NAME=$(TEST_PROJECT) COMPOSE_FILE=compose.yaml:compose.test.yaml \
LB_HOST_PORT=$(TEST_LB_PORT) DB_HOST_PORT=$(TEST_DB_PORT) REDIS_HOST_PORT=$(TEST_REDIS_PORT)
TEST_COMPOSE = $(TEST_ENV) $(COMPOSE)
TEST_DB_PASSWORD = $(if $(wildcard secrets/db_password),$(file <secrets/db_password),$(DB_PASSWORD))
TEST_DATABASE_URL ?= postgresql+asyncpg://$(DB_USER):$(TEST_DB_PASSWORD)@localhost:$(TEST_DB_PORT)/$(DB_NAME)_test
TEST_REDIS_HOST ?= localhost
TEST_REDIS_PASSWORD ?= $(if $(wildcard secrets/redis_password),$(file <secrets/redis_password),$(REDIS_PASSWORD))
TEST_REDIS_DB ?= 15
export TEST_DATABASE_URL TEST_REDIS_HOST TEST_REDIS_PORT TEST_REDIS_PASSWORD TEST_REDIS_DB
.PHONY: help init up down restart ps logs migrate migration worker-stop worker-start \
cleanup-dry-run cleanup-apply check validate test test-unit test-pipeline \
test-nginx test-storage test-outbox test-jobs test-persistence test-failover \
test-suite test-stand-up test-stand-destroy
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "Запуск: init | up | down | restart | ps | logs SERVICE=worker"
@echo "Обслуживание: migrate | migration m='описание' | worker-stop | worker-start"
@echo "Очистка объектов: cleanup-dry-run | cleanup-apply"
@echo "Проверки: check | validate | test | test-pipeline | test-unit PYTEST_ARGS=..."
@echo "Сервисы: test-nginx | test-storage | test-outbox | test-jobs"
@echo "Отказы API (по запросу): test-persistence | test-failover"
@echo "Автономный прогон с удалением тестового стенда: test-suite"
init:
$(PYTHON) scripts/init_local.py
up:
$(COMPOSE) up -d --build --wait --wait-timeout 120
down:
$(COMPOSE) down
restart:
scripts/restart.sh
ps:
$(COMPOSE) ps $(SERVICE)
logs:
$(COMPOSE) logs -f $(SERVICE)
migrate:
$(COMPOSE) run --rm --build migrate
migration:
DB_HOST=localhost DB_PORT=$(TEST_DB_PORT) $(PYTHON) -m alembic revision --autogenerate -m "$(m)"
worker-stop:
$(COMPOSE) stop worker
worker-start:
$(COMPOSE) start worker
cleanup-dry-run:
$(COMPOSE) run --rm --no-deps cleanup python -m app.core.cleanup --once
cleanup-apply:
$(COMPOSE) run --rm --no-deps cleanup python -m app.core.cleanup --once --apply
check:
$(PYTHON) scripts/check_contract.py
@@ -16,15 +82,48 @@ validate:
$(PYTHON) scripts/validate_openapi.py
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
$(PYTHON) tests/smoke.py --base-url "$(TEST_BASE_URL)" $(TLS_ARGS)
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
# Все сохранённые регрессионные тесты запускаются явно; PYTEST_ARGS выбирает подмножество.
test-unit:
$(TEST_ENV) $(PYTHON) -m pytest -q $(PYTEST_ARGS)
test-pipeline:
$(TEST_ENV) $(PYTHON) -m pytest -q student-tests/test_attachments.py student-tests/test_jobs.py student-tests/test_image_pipeline.py $(PYTEST_ARGS)
test-nginx:
$(PYTHON) scripts/check_nginx.py
test-storage:
$(PYTHON) -m scripts.check_s3 --base-url "$(BASE_URL)" $(TLS_ARGS)
test-outbox:
$(PYTHON) -m scripts.check_outbox_recovery --base-url "$(BASE_URL)" $(TLS_ARGS)
test-jobs:
$(PYTHON) -m scripts.check_jobs --base-url "$(BASE_URL)" $(TLS_ARGS)
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(or $(ACTION_SCRIPT),scripts/restart.sh)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(or $(ACTION_SCRIPT),scripts/stop-one.sh)" --base-url "$(BASE_URL)" $(TLS_ARGS)
# Отдельные PostgreSQL/Redis нужны для локальных тестов; тестовая БД создаётся явно.
test-stand-up:
$(TEST_COMPOSE) up -d --build --wait --wait-timeout 120
$(TEST_COMPOSE) exec -T postgres sh -c 'psql -U "$$POSTGRES_USER" -d postgres -tAc "SELECT 1 FROM pg_database WHERE datname = '\''$${POSTGRES_DB}_test'\''" | grep -q 1 || createdb -U "$$POSTGRES_USER" "$${POSTGRES_DB}_test"'
test-stand-destroy:
$(TEST_COMPOSE) down --volumes --remove-orphans
# Проверки текущего pipeline; полный регрессионный набор и отказы API — отдельные цели.
test-suite:
@set -eu; trap '$(TEST_COMPOSE) down --volumes --remove-orphans' EXIT; \
$(MAKE) check validate; \
$(MAKE) test-stand-up; \
$(TEST_ENV) $(MAKE) test-pipeline; \
$(TEST_ENV) $(MAKE) test BASE_URL="$(TEST_BASE_URL)"; \
$(TEST_ENV) $(MAKE) test-storage BASE_URL="$(TEST_BASE_URL)"; \
$(TEST_ENV) $(MAKE) test-outbox BASE_URL="$(TEST_BASE_URL)"; \
$(TEST_ENV) $(MAKE) test-jobs BASE_URL="$(TEST_BASE_URL)";
+74 -16
View File
@@ -1,37 +1,95 @@
# Отчёт — лабораторная 5
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Григорян Илья Мурадович, БПИ2303.
- Целевая оценка: **4**. Все пункты уровней **3 и 4** реализованы и проверены.
- Commit/PR: TODO после публикации.
- Использованные источники, библиотеки и помощь ИИ: Python 3.12, FastAPI, SQLAlchemy, Pillow, aio-pika; [RabbitMQ](https://www.rabbitmq.com/docs/reliability), [Pillow](https://pillow.readthedocs.io/en/stable/); помощь Codex при реализации и проверках.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Python 3.12, pip и Docker Compose. Версии зависимостей закреплены в requirements.txt;
основные образы — PostgreSQL 16.10, Redis 7.4.2, RabbitMQ 4.4.0 и nginx 1.28.0.
```sh
python3 -m venv .venv
.venv/bin/python -m pip install -r requirements.txt -r requirements-dev.txt
make init
make up
make test
make down
```
`make init` создаёт отсутствующие .env и secrets/, миграции и bootstrap выполняются
при запуске. Все настройки берутся из .env; образец — .env.example.
HTTP: http://localhost:18081. Внутренние хранилища и брокер наружу не открыты.
`make down` сохраняет данные; `docker compose down --volumes` намеренно удаляет их.
При обновлении схемы сначала остановить старые процессы, сохранив volumes.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
API → приватный MinIO staging + PostgreSQL job/outbox → RabbitMQ → worker →
конечные объекты MinIO + PostgreSQL metadata. Redis хранит сессии.
Сохранены аутентификация, чаты, сообщения, пагинация и идемпотентность предыдущих работ.
Загрузка возвращает **202 queued** после устойчивого приёма. Состояния:
queued / processing / ready / failed; скачивание до ready возвращает 409.
RabbitMQ использует устойчивую очередь, сохранение сообщений на диск и подтверждения.
Publisher отмечает публикацию после подтверждения брокера; worker подтверждает доставку
после фиксации результата. Outbox восстанавливает разрыв COMMIT → publish.
Фиксированные ключи объектов, блокировка job и lease защищают от повторов и устаревшего worker.
Original не перекодируется. Варианты: JPEG thumbnail ≤256×256, центральный JPEG crop
128×128 и WebP ≤1280×1280. JPEG quality=85, WebP quality=80/method=4; EXIF orientation
учитывается, EXIF/ICC/XMP удаляются. Для JPEG alpha заменяется белой подложкой,
WebP сохраняет прозрачность. Лимиты: 10 MiB, 40 млн пикселей, timeout 60 секунд,
768 MiB и 20 секунд CPU на дочерний процесс; concurrency=2, prefetch=1, lease=90 секунд.
Повторы ограничены пятью попытками. Задержка со случайным разбросом:
c=min(120, 5×2^(n−1)), delay∈[c/2,c]. Постоянные ошибки завершаются сразу.
Реестр failed и аудит находятся в PostgreSQL; явный replay проверяет исходник,
выделяет новый бюджет и не запускает уже готовую job. Staging активных jobs сохраняется;
ready очищается через сутки, failed — через семь суток.
Операторские команды:
```sh
docker compose run --rm --no-deps worker python -m app.core.job_admin list-failed
docker compose run --rm --no-deps worker python -m app.core.job_admin replay JOB_ID --request-id REQUEST_UUID --actor operator --reason dependency_restored
```
JOB_ID и REQUEST_UUID заменить UUID. Повтор команды с тем же request-id безопасен.
## Доказательства критериев
`make test-suite` поднимает отдельный стенд, проверяет pipeline и удаляет контейнеры,
сети и volumes при завершении, включая ошибку. Полная сохранённая регрессия запускается
отдельно через `make test-unit`; отдельные сервисы — `test-nginx` и `test-storage`.
Проверки pipeline: 42 теста. Полная сохранённая регрессия: 201 тест.
Публичные smoke/persistence/failover прошли. Для отдельных pytest-прогонов нужен
`make test-stand-up`; после проверки — `make test-stand-destroy`.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke | make test | 202 → ready, неизменный original, JPEG thumbnail | evidence/verification.json |
| Устойчивый приём и сохранение возможностей lab4 | DOCKER_TESTS=1 make test-unit; make test-persistence | Данные и сессия сохранены, загрузка асинхронная | evidence/verification.json |
| Отдельные broker/worker, поздний ack | make test-jobs | Сообщения сохранены, очередь подтверждена | evidence/jobs.json |
| Состояния, ограниченные повторы, идемпотентность | make test-pipeline; make test-jobs | failed после бюджета, дубли не создают новые объекты | evidence/verification.json |
| Остановка worker и рестарт API/брокера | make test-jobs | То же вложение стало ready, сообщение пережило рестарт | evidence/jobs.json |
| Crop/WebP и ограничения worker | make test-pipeline; make test-jobs | Форматы/размеры, metadata и лимиты проверены | evidence/verification.json |
| Разрыв COMMIT → publish | make test-outbox | SIGKILL publisher, затем ready без нового upload | evidence/verification.json |
| Backoff/jitter, failed registry, replay | make test-jobs | Постоянные/временные ошибки различаются, replay безопасен | evidence/jobs.json |
| Crash после PUT до ack, lease и cleanup | make test-jobs; make test-pipeline | Тот же результат, prefetch=1; активный staging сохранён | evidence/jobs.json; evidence/verification.json |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Crash после PUT до COMMIT | Повтор той же job | ready на второй попытке, те же четыре объекта и SHA-256 | После lease/retry; потерь нет |
| Crash после COMMIT до ack | Готовый дубль без обработки | Metadata и Last-Modified не изменились | После доставки; потерь нет |
| Временная / постоянная ошибка | Ограниченный retry / немедленный failed | Пять / одна попытка; явный replay завершился ready | В пределах бюджета; потерь нет |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Один Docker-хост, без репликации хранилищ и защиты от потери диска. Очередь не имеет
admission control; pipeline фиксирован на версии 1. Доставка как минимум один раз,
с идемпотентным результатом.
+38
View File
@@ -0,0 +1,38 @@
[alembic]
script_location = migrations
prepend_sys_path = .
path_separator = os
[loggers]
keys = root,sqlalchemy,alembic
[handlers]
keys = console
[formatters]
keys = generic
[logger_root]
level = WARNING
handlers = console
qualname =
[logger_sqlalchemy]
level = WARNING
handlers =
qualname = sqlalchemy.engine
[logger_alembic]
level = INFO
handlers =
qualname = alembic
[handler_console]
class = StreamHandler
args = (sys.stderr,)
level = NOTSET
formatter = generic
[formatter_generic]
format = %(levelname)-5.5s [%(name)s] %(message)s
datefmt = %H:%M:%S
View File
+4
View File
@@ -0,0 +1,4 @@
from app.main import main
if __name__ == "__main__":
main()
View File
+40
View File
@@ -0,0 +1,40 @@
"""Остановка фоновых процессов и безопасные сообщения об отказах."""
import asyncio
import logging
import signal
from aio_pika.exceptions import AMQPException, ChannelInvalidStateError
from sqlalchemy.exc import InterfaceError, OperationalError
from sqlalchemy.exc import TimeoutError as PoolTimeoutError
TRANSIENT_JOB_ERRORS = (
AMQPException,
ChannelInvalidStateError,
InterfaceError,
OperationalError,
PoolTimeoutError,
OSError,
)
logger = logging.getLogger(__name__)
def shutdown_event() -> asyncio.Event:
stop = asyncio.Event()
loop = asyncio.get_running_loop()
for signum in (signal.SIGTERM, signal.SIGINT):
loop.add_signal_handler(signum, stop.set)
return stop
async def wait_or_stop(stop: asyncio.Event, seconds: float) -> None:
try:
async with asyncio.timeout(seconds):
await stop.wait()
except TimeoutError:
pass
def log_background_error(operation: str, error: Exception) -> None:
# SDK/DB exceptions могут содержать параметры и credentials; выводим только тип.
logger.warning("%s: %s", operation, type(error).__name__)
+66
View File
@@ -0,0 +1,66 @@
"""Периодическая компенсация незавершённых загрузок; отдельный Compose-сервис."""
import argparse
import asyncio
from dataclasses import asdict
import json
from app.core.config import Settings
from app.core.jobs import JobSettings
from app.core.database import create_db_engine, create_session_factory
from app.core.s3 import S3Settings
from app.domain.attachments import reconcile_attachments
from app.domain.attachment_jobs import cleanup_staging
from app.errors.handlers import RECOVERABLE_STORAGE_ERRORS, log_recoverable_error
from app.storage.s3 import create_s3_storage
async def cleanup_once(factory, storage, apply: bool, jobs: JobSettings) -> bool:
completed = True
try:
async with factory() as session:
result = await reconcile_attachments(session, storage, dry_run=not apply)
staging = await cleanup_staging(session, storage, jobs, apply=apply)
print(
json.dumps({**asdict(result), "terminal_staging": staging}), flush=True
)
except RECOVERABLE_STORAGE_ERRORS as error:
log_recoverable_error("Reconciliation", error)
completed = False
return completed
async def run(once: bool, apply: bool) -> None:
settings = Settings() # type: ignore
s3_settings = S3Settings()
jobs = JobSettings()
engine = create_db_engine(settings)
factory = create_session_factory(engine)
storage = create_s3_storage(s3_settings)
try:
while True:
completed = await cleanup_once(factory, storage, apply, jobs)
if once:
if not completed:
raise SystemExit(1)
break
await asyncio.sleep(s3_settings.cleanup_interval_seconds)
finally:
await storage.aclose()
await engine.dispose()
def main() -> None:
parser = argparse.ArgumentParser(description="Сверка журнала загрузок MinIO/БД")
parser.add_argument("--once", action="store_true")
parser.add_argument(
"--apply",
action="store_true",
help="удалять безопасные кандидаты; по умолчанию dry-run",
)
args = parser.parse_args()
asyncio.run(run(args.once, args.apply))
if __name__ == "__main__":
main()
+129
View File
@@ -0,0 +1,129 @@
from enum import StrEnum
from pathlib import Path
from typing import Literal, Self
from pydantic import Field, SecretStr, model_validator
from pydantic_settings import (
BaseSettings,
PydanticBaseSettingsSource,
SettingsConfigDict,
)
from sqlalchemy import URL
from app.core.s3 import S3Settings
ASYNC_DRIVER = "postgresql+asyncpg"
SECRETS_DIR = next(
(
path
for path in (
Path("/run/secrets"),
Path(__file__).resolve().parents[2] / "secrets",
)
if (path / "db_password").is_file()
),
None,
)
class LogLevel(StrEnum):
DEBUG = "DEBUG"
INFO = "INFO"
WARNING = "WARNING"
ERROR = "ERROR"
CRITICAL = "CRITICAL"
class Settings(BaseSettings):
s3_enabled: bool = True
s3: S3Settings = Field(default_factory=S3Settings)
app_host: str
app_port: int = Field(ge=1, le=65535)
app_env: str
log_level: LogLevel = LogLevel.INFO
max_messages: int = Field(ge=1)
max_in_flight: int = Field(ge=1)
session_ttl_seconds: int = Field(default=3600, ge=1)
session_store: Literal["redis"] = "redis"
redis_host: str = "localhost"
redis_port: int = Field(default=6379, ge=1, le=65535)
redis_db: int = Field(default=0, ge=0)
redis_password: SecretStr | None = None
redis_max_connections: int = Field(default=20, ge=1)
redis_pool_timeout_seconds: float = Field(default=1.0, gt=0)
redis_connect_timeout_seconds: float = Field(default=1.0, gt=0)
redis_socket_timeout_seconds: float = Field(default=0.5, gt=0)
database_url: SecretStr | None = None
db_host: str | None = None
db_port: int = Field(default=5432, ge=1, le=65535)
db_name: str | None = None
db_user: str | None = None
db_password: SecretStr | None = None
db_pool_size: int = Field(default=5, ge=1)
db_max_overflow: int = Field(default=5, ge=0)
db_pool_timeout_seconds: float = Field(default=3.0, gt=0)
db_connect_timeout_seconds: int = Field(default=3, ge=1)
db_statement_timeout_ms: int = Field(default=5000, ge=1)
instance_id: str | None = None
idempotency_ttl_seconds: int = Field(default=86400, ge=1)
shutdown_drain_seconds: float = Field(default=1, ge=0)
graceful_shutdown_timeout_seconds: int = Field(default=5, ge=1)
readiness_timeout_seconds: float = Field(default=2, gt=0, lt=2.5)
model_config = SettingsConfigDict(
env_file=".env",
env_file_encoding="utf-8",
case_sensitive=False,
extra="ignore",
secrets_dir=SECRETS_DIR,
)
@classmethod
def settings_customise_sources(
cls,
settings_cls: type[BaseSettings],
init_settings: PydanticBaseSettingsSource,
env_settings: PydanticBaseSettingsSource,
dotenv_settings: PydanticBaseSettingsSource,
file_secret_settings: PydanticBaseSettingsSource,
) -> tuple[PydanticBaseSettingsSource, ...]:
"""Явные параметры и файлы имеют приоритет над окружением."""
return init_settings, file_secret_settings, env_settings, dotenv_settings
@model_validator(mode="after")
def _require_database_source(self) -> Self:
if self.shutdown_drain_seconds + self.graceful_shutdown_timeout_seconds >= 8:
raise ValueError(
"Drain и graceful shutdown должны суммарно занимать менее 8 секунд"
)
if self.database_url is not None:
if not self.database_url.get_secret_value().startswith(ASYNC_DRIVER):
raise ValueError(f"DATABASE_URL должен начинаться с {ASYNC_DRIVER}://")
return self
if not (self.db_host and self.db_name and self.db_user and self.db_password):
raise ValueError(
"Нужны DATABASE_URL либо DB_HOST, DB_NAME, DB_USER и секрет db_password"
)
return self
def get_database_url(self) -> str:
if self.database_url is not None:
return self.database_url.get_secret_value()
assert self.db_password is not None
url = URL.create(
ASYNC_DRIVER,
username=self.db_user,
password=self.db_password.get_secret_value(),
host=self.db_host,
port=self.db_port,
database=self.db_name,
)
return url.render_as_string(hide_password=False)
+28
View File
@@ -0,0 +1,28 @@
from sqlalchemy.ext.asyncio import (
AsyncEngine,
AsyncSession,
async_sessionmaker,
create_async_engine,
)
from app.core.config import Settings
def create_db_engine(settings: Settings) -> AsyncEngine:
return create_async_engine(
settings.get_database_url(),
pool_size=settings.db_pool_size,
max_overflow=settings.db_max_overflow,
pool_timeout=settings.db_pool_timeout_seconds,
pool_pre_ping=True,
connect_args={
"timeout": settings.db_connect_timeout_seconds,
"server_settings": {
"statement_timeout": str(settings.db_statement_timeout_ms)
},
},
)
def create_session_factory(engine: AsyncEngine) -> async_sessionmaker[AsyncSession]:
return async_sessionmaker(bind=engine, expire_on_commit=False, autoflush=False)
+16
View File
@@ -0,0 +1,16 @@
"""Качество вариантов и пределы отдельного процесса обработки."""
from pydantic import Field
from pydantic_settings import BaseSettings, SettingsConfigDict
class ImageSettings(BaseSettings):
model_config = SettingsConfigDict(
env_prefix="IMAGE_", env_file=".env", extra="ignore"
)
jpeg_quality: int = Field(default=85, ge=1, le=95)
webp_quality: int = Field(default=80, ge=1, le=100)
webp_method: int = Field(default=4, ge=0, le=6)
memory_mib: int = Field(default=768, ge=256, le=1024)
cpu_seconds: int = Field(default=20, ge=1, le=120)
+24
View File
@@ -0,0 +1,24 @@
"""Одноразовый Linux-процесс декодирования с пределами памяти и CPU"""
from pathlib import Path
import resource
import sys
from app.domain.image_validation import decode_image
from app.errors.exceptions import IMAGE_WORKER_ERRORS, image_worker_error_code
def main() -> int:
resource.setrlimit(resource.RLIMIT_AS, (512 * 1024 * 1024, 512 * 1024 * 1024))
resource.setrlimit(resource.RLIMIT_CPU, (10, 10))
path, content_type, maximum = sys.argv[1:]
status = 0
try:
decode_image(Path(path), content_type, int(maximum))
except IMAGE_WORKER_ERRORS as error:
status = image_worker_error_code(error)
return status
if __name__ == "__main__":
raise SystemExit(main())
+40
View File
@@ -0,0 +1,40 @@
"""Идентификатор API-реплики и заголовок X-Instance-Id."""
import os
from uuid import uuid4
from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
from starlette.requests import Request
from starlette.responses import Response
INSTANCE_ID_HEADER = "X-Instance-Id"
def resolve_instance_id(configured: str | None) -> str:
"""Выбирает INSTANCE_ID, HOSTNAME или UUID при старте приложения."""
if configured and configured.strip():
return configured.strip()
hostname = os.getenv("HOSTNAME", "").strip()
if hostname:
return hostname
return str(uuid4())
class InstanceIdMiddleware(BaseHTTPMiddleware):
"""Добавляет сохранённый идентификатор реплики в ответ."""
def __init__(self, app, instance_id: str) -> None:
super().__init__(app)
self.instance_id = instance_id
async def dispatch(
self,
request: Request,
call_next: RequestResponseEndpoint,
) -> Response:
response = await call_next(request)
response.headers[INSTANCE_ID_HEADER] = self.instance_id
return response
+82
View File
@@ -0,0 +1,82 @@
"""Операторский интерфейс failed registry. Доступ требует credentials стенда."""
import argparse
import asyncio
import json
from uuid import UUID
from app.core.background import log_background_error
from app.core.config import Settings
from app.core.database import create_db_engine, create_session_factory
from app.core.jobs import JobSettings
from app.domain.job_admin import (
REPLAY_REASONS,
history,
list_failed,
replay_failed_job,
show_job,
)
from app.errors.exceptions import JobOperationError
from app.storage.s3 import create_s3_storage
async def execute(args):
settings = Settings()
engine = create_db_engine(settings)
storage = None
try:
factory = create_session_factory(engine)
async with factory() as session:
if args.command == "list-failed":
result = await list_failed(session, args.limit)
elif args.command == "show":
result = await show_job(session, args.job_id)
elif args.command == "history":
result = await history(session, args.job_id)
else:
storage = create_s3_storage(settings.s3)
result = await replay_failed_job(
session,
storage,
JobSettings(),
args.job_id,
request_id=args.request_id,
actor=args.actor,
reason=args.reason,
)
print(json.dumps(result, default=str), flush=True)
finally:
if storage is not None:
await storage.aclose()
await engine.dispose()
def main():
parser = argparse.ArgumentParser(
description="Реестр failed и явный replay с аудитом"
)
commands = parser.add_subparsers(dest="command", required=True)
listing = commands.add_parser("list-failed")
listing.add_argument(
"--limit", type=int, choices=range(1, 501), default=50, metavar="1..500"
)
for name in ("show", "history", "replay"):
command = commands.add_parser(name)
command.add_argument("job_id", type=UUID)
if name == "replay":
command.add_argument("--request-id", type=UUID, required=True)
command.add_argument("--actor", required=True)
command.add_argument("--reason", choices=REPLAY_REASONS, required=True)
args = parser.parse_args()
try:
asyncio.run(execute(args))
except JobOperationError as error:
print(json.dumps({"error_code": error.code}), flush=True)
raise SystemExit(2) from None
except Exception as error:
log_background_error("Job administration failed", error)
raise SystemExit(1) from None
if __name__ == "__main__":
main()
+170
View File
@@ -0,0 +1,170 @@
"""Отдельные consumers с ограниченной конкуренцией; API не выполняет resize."""
import argparse
import asyncio
from dataclasses import dataclass
import json
import logging
import os
import signal
from uuid import UUID, uuid4
from PIL import features
from pydantic import ValidationError
from app.core.background import (
TRANSIENT_JOB_ERRORS,
log_background_error,
shutdown_event,
wait_or_stop,
)
from app.core.config import Settings
from app.core.database import create_db_engine, create_session_factory
from app.core.jobs import JobSettings
from app.domain.attachment_jobs import process_attachment_job
from app.errors.exceptions import ProcessingError
from app.schemas.job import JobMessage
from app.storage.broker import JobBroker
from app.storage.s3 import create_s3_storage
@dataclass(frozen=True)
class Faults:
"""Только явные CLI-флаги; обычный worker не включает инъекции сбоев."""
crash_after_object: UUID | None = None
crash_before_ack: UUID | None = None
fail_transient: UUID | None = None
fail_permanent: UUID | None = None
object_name: str = "optimized"
def kill(self, attachment_id: UUID, phase: str) -> None:
print(
json.dumps({"fault": phase, "attachment_id": str(attachment_id)}),
flush=True,
)
os.kill(os.getpid(), signal.SIGKILL)
def after_object(self, attachment_id: UUID, name: str) -> None:
if attachment_id == self.crash_after_object and name == self.object_name:
self.kill(attachment_id, "after_object:" + name)
def before_ack(self, attachment_id: UUID) -> None:
if attachment_id == self.crash_before_ack:
self.kill(attachment_id, "before_ack")
def before_processing(self, attachment_id: UUID) -> None:
if attachment_id == self.fail_transient:
raise TimeoutError("injected transient failure")
if attachment_id == self.fail_permanent:
raise ProcessingError("injected_permanent")
async def consume_connected(
factory,
storage,
broker: JobBroker,
settings: JobSettings,
stop: asyncio.Event,
faults: Faults,
) -> None:
consumer = uuid4().hex
while not stop.is_set():
try:
await broker.ensure_ready()
delivery = await broker.receive(consumer)
if delivery is None:
continue
try:
message = JobMessage.model_validate_json(delivery.payload)
except ValidationError:
await broker.reject_invalid(delivery.id)
continue
try:
async with factory() as session:
acknowledge = await process_attachment_job(
session,
storage,
message,
settings,
after_object=faults.after_object,
before_processing=faults.before_processing,
)
except ProcessingError:
await broker.reject_invalid(delivery.id)
else:
if acknowledge:
faults.before_ack(message.attachment_id)
await broker.acknowledge_job(delivery.id)
else:
await broker.defer_job(delivery.id)
except TRANSIENT_JOB_ERRORS as error:
log_background_error("Worker delivery deferred", error)
await broker.aclose()
await wait_or_stop(stop, settings.publisher_poll_seconds)
async def consume(factory, storage, settings, stop, faults) -> None:
broker = JobBroker(settings)
try:
await consume_connected(factory, storage, broker, settings, stop, faults)
finally:
await broker.aclose()
async def run_worker(faults: Faults) -> None:
settings = Settings()
jobs = JobSettings()
logging.basicConfig(level=settings.log_level)
if not features.check("webp"):
logging.error("Pillow requires WebP support for the image worker")
raise RuntimeError("WebP codec is unavailable")
stop = shutdown_event()
engine = create_db_engine(settings)
storage = None
try:
storage = create_s3_storage(settings.s3)
factory = create_session_factory(engine)
async with asyncio.TaskGroup() as group:
tasks = [
group.create_task(consume(factory, storage, jobs, stop, faults))
for _ in range(jobs.worker_concurrency)
]
await stop.wait()
# Отмена убивает resize-процесс, дожидается SDK и не отправляет ack.
for task in tasks:
task.cancel()
finally:
if storage is not None:
await storage.aclose()
await engine.dispose()
def main() -> None:
parser = argparse.ArgumentParser(
description="Image worker с явными fault-injection hooks"
)
modes = parser.add_mutually_exclusive_group()
for flag in (
"crash-after-object",
"crash-before-ack",
"fail-transient",
"fail-permanent",
):
modes.add_argument("--" + flag, type=UUID, metavar="ATTACHMENT_ID")
parser.add_argument(
"--object-name",
choices=("original", "thumbnail", "crop", "optimized"),
default="optimized",
)
args = parser.parse_args()
faults = Faults(**vars(args))
try:
asyncio.run(run_worker(faults))
except Exception as error:
log_background_error("Worker stopped", error)
raise SystemExit(1) from None
if __name__ == "__main__":
main()
+37
View File
@@ -0,0 +1,37 @@
"""Настройки очереди из .env; credentials брокера читаются отдельно из файла."""
from pathlib import Path
from typing import Self
from pydantic import Field, model_validator
from pydantic_settings import BaseSettings, SettingsConfigDict
class JobSettings(BaseSettings):
model_config = SettingsConfigDict(env_file=".env", extra="ignore")
broker_host: str = "broker"
broker_port: int = Field(default=5672, ge=1, le=65535)
broker_password_file: Path = Path("/run/secrets/broker_password")
broker_queue: str = "attachment-jobs"
broker_user: str = "messenger"
broker_vhost: str = "/"
worker_concurrency: int = Field(default=2, ge=1, le=4)
job_max_attempts: int = Field(default=5, ge=1, le=100)
job_timeout_seconds: int = Field(default=60, ge=10, le=300)
job_lease_seconds: int = Field(default=90, ge=20, le=600)
job_retry_seconds: int = Field(default=5, ge=1, le=300)
job_retry_max_seconds: int = Field(default=120, ge=1, le=3600)
failed_staging_retention_seconds: int = Field(default=604800, ge=300)
publisher_poll_seconds: float = Field(default=1, gt=0, le=10)
staging_retention_seconds: int = Field(default=86400, ge=300)
@model_validator(mode="after")
def validate_lease(self) -> Self:
if self.job_lease_seconds < self.job_timeout_seconds + 30:
raise ValueError(
"Lease должен превышать timeout задания минимум на 30 секунд"
)
if self.job_retry_max_seconds < self.job_retry_seconds:
raise ValueError("Retry maximum must be at least the base delay")
return self
+50
View File
@@ -0,0 +1,50 @@
"""Готовность реплики и мягкое завершение сервера."""
import asyncio
from types import FrameType
import uvicorn
class Lifecycle:
"""Хранит состояние завершения реплики."""
def __init__(self) -> None:
self._draining = False
@property
def draining(self) -> bool:
return self._draining
def start_draining(self) -> None:
"""Отключает приём новых бизнес-запросов."""
self._draining = True
class GracefulServer(uvicorn.Server):
"""Оставляет время для исключения завершающейся реплики."""
def __init__(
self, config: uvicorn.Config, lifecycle: Lifecycle, drain_seconds: float
) -> None:
super().__init__(config)
self.lifecycle = lifecycle
self.drain_seconds = drain_seconds
self._drain_task: asyncio.Task[None] | None = None
def handle_exit(self, sig: int, frame: FrameType | None) -> None:
"""Первый сигнал запускает drain, повторный ускоряет остановку."""
if self._drain_task is not None:
if not self._drain_task.done():
self._drain_task.cancel()
super().handle_exit(sig, frame)
return
self.lifecycle.start_draining()
self._drain_task = asyncio.get_running_loop().create_task(
self._finish_draining(sig, frame)
)
async def _finish_draining(self, sig: int, frame: FrameType | None) -> None:
"""Передаёт остановку Uvicorn после drain-периода."""
await asyncio.sleep(self.drain_seconds)
super().handle_exit(sig, frame)
+88
View File
@@ -0,0 +1,88 @@
"""Доставка намерений из PostgreSQL; crash hook включается только явно через CLI."""
import argparse
import asyncio
import json
import logging
import os
import signal
from uuid import UUID
from app.core.background import (
TRANSIENT_JOB_ERRORS,
log_background_error,
shutdown_event,
wait_or_stop,
)
from app.core.config import Settings
from app.core.database import create_db_engine, create_session_factory
from app.core.jobs import JobSettings
from app.domain.attachment_jobs import publish_next_job, recover_expired_jobs
from app.storage.broker import JobBroker
def crash_before_publish(attachment_id: UUID) -> None:
"""Реальный SIGKILL после чтения принятой job, до publisher confirm и отметки publish."""
print(
json.dumps({"fault": "before_publish", "attachment_id": str(attachment_id)}),
flush=True,
)
os.kill(os.getpid(), signal.SIGKILL)
async def run_publisher(crash_attachment_id: UUID | None = None) -> None:
settings = Settings()
jobs = JobSettings()
logging.basicConfig(level=settings.log_level)
stop = shutdown_event()
engine = create_db_engine(settings)
broker = None
try:
broker = JobBroker(jobs)
factory = create_session_factory(engine)
while not stop.is_set():
published = False
try:
await broker.ensure_ready()
async with factory() as session:
await recover_expired_jobs(session, jobs)
published = await publish_next_job(
session,
broker,
attachment_id=crash_attachment_id,
before_publish=(
crash_before_publish
if crash_attachment_id is not None
else None
),
)
except TRANSIENT_JOB_ERRORS as error:
log_background_error("Publisher deferred", error)
if not published:
await wait_or_stop(stop, jobs.publisher_poll_seconds)
finally:
if broker is not None:
await broker.aclose()
await engine.dispose()
def main() -> None:
parser = argparse.ArgumentParser(
description="Публикация устойчивых jobs в RabbitMQ"
)
parser.add_argument(
"--crash-before-publish",
type=UUID,
metavar="ATTACHMENT_ID",
help="аварийно завершить этот процесс перед публикацией только указанного вложения",
)
args = parser.parse_args()
try:
asyncio.run(run_publisher(args.crash_before_publish))
except Exception as error:
log_background_error("Publisher stopped", error)
raise SystemExit(1) from None
if __name__ == "__main__":
main()
+24
View File
@@ -0,0 +1,24 @@
from redis.asyncio import BlockingConnectionPool, Redis
from redis.asyncio.retry import Retry
from redis.backoff import NoBackoff
from app.core.config import Settings
def create_redis_client(settings: Settings) -> Redis:
password = (
settings.redis_password.get_secret_value() if settings.redis_password else None
)
pool = BlockingConnectionPool(
host=settings.redis_host,
port=settings.redis_port,
db=settings.redis_db,
password=password,
max_connections=settings.redis_max_connections,
timeout=settings.redis_pool_timeout_seconds,
socket_connect_timeout=settings.redis_connect_timeout_seconds,
socket_timeout=settings.redis_socket_timeout_seconds,
retry=Retry(NoBackoff(), retries=1),
decode_responses=True,
)
return Redis.from_pool(pool)
+42
View File
@@ -0,0 +1,42 @@
from collections.abc import AsyncIterator
from fastapi import Request
from app.errors.exceptions import rate_limited, unavailable
class RequestCapacity:
def __init__(self, max_in_flight: int) -> None:
self._max_in_flight = max_in_flight
self._in_flight = 0
@property
def in_flight(self) -> int:
return self._in_flight
def try_acquire(self) -> bool:
if self._in_flight >= self._max_in_flight:
return False
self._in_flight += 1
return True
def release(self) -> None:
self._in_flight -= 1
def create_request_capacity(max_in_flight: int) -> RequestCapacity:
return RequestCapacity(max_in_flight)
async def acquire_request_slot(request: Request) -> AsyncIterator[None]:
if request.app.state.lifecycle.draining:
raise unavailable("Реплика завершает работу")
capacity: RequestCapacity = request.app.state.request_capacity
if not capacity.try_acquire():
raise rate_limited()
try:
yield
finally:
capacity.release()
+22
View File
@@ -0,0 +1,22 @@
from uuid import uuid4
from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
from starlette.requests import Request
from starlette.responses import Response
REQUEST_ID_HEADER = "X-Request-Id"
class RequestIdMiddleware(BaseHTTPMiddleware):
async def dispatch(
self,
request: Request,
call_next: RequestResponseEndpoint,
) -> Response:
request_id = str(uuid4())
request.state.request_id = request_id
response = await call_next(request)
response.headers[REQUEST_ID_HEADER] = request_id
return response
+47
View File
@@ -0,0 +1,47 @@
"""Конфигурация MinIO; значения credentials читаются только из файлов."""
from pathlib import Path
from urllib.parse import urlsplit
from pydantic import Field, model_validator
from pydantic_settings import BaseSettings, SettingsConfigDict
class S3Settings(BaseSettings):
endpoint: str = "http://minio:9000"
region: str = "us-east-1"
bucket: str = "messenger-attachments"
access_key_id_file: Path = Path("/run/secrets/s3_access_key_id")
secret_access_key_file: Path = Path("/run/secrets/s3_secret_access_key")
connect_timeout_seconds: float = Field(default=2, gt=0, le=5)
read_timeout_seconds: float = Field(default=10, gt=0, le=15)
upload_timeout_seconds: float = Field(default=30, gt=0, le=60)
download_timeout_seconds: float = Field(default=60, gt=0, le=120)
image_timeout_seconds: float = Field(default=10, gt=0, le=15)
max_upload_bytes: int = Field(default=10_485_760, ge=1, le=10_485_760)
max_image_pixels: int = Field(default=40_000_000, ge=1, le=40_000_000)
chunk_bytes: int = Field(default=65_536, ge=1024, le=262_144)
max_concurrent_uploads: int = Field(default=2, ge=1, le=2)
cleanup_grace_seconds: int = Field(default=86_400, ge=300)
cleanup_interval_seconds: int = Field(default=300, ge=1)
model_config = SettingsConfigDict(
env_prefix="S3_", env_file=".env", extra="ignore", frozen=True
)
@model_validator(mode="after")
def validate_endpoint(self):
url = urlsplit(self.endpoint)
if (
url.scheme not in {"http", "https"}
or not url.hostname
or url.username
or url.password
or url.path not in {"", "/"}
or url.query
or url.fragment
):
raise ValueError(
"S3_ENDPOINT должен быть http(s) адресом без credentials/пути"
)
return self
+63
View File
@@ -0,0 +1,63 @@
"""Хеширование паролей (Argon2id) и выпуск непрозрачных токенов сессий."""
import asyncio
import hashlib
import os
import secrets
from concurrent.futures import ThreadPoolExecutor
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
TOKEN_BYTES = 32
_hasher = PasswordHasher()
_executor = ThreadPoolExecutor(
max_workers=max(1, min(2, (os.cpu_count() or 1) // _hasher.parallelism)),
thread_name_prefix="argon2",
)
def _hash_password_sync(password: str) -> str:
"""Блокирующий расчёт Argon2id-хеша со случайной солью в формате PHC."""
return _hasher.hash(password)
def _verify_password_sync(password: str, password_hash: str) -> bool:
"""Блокирующая проверка пароля по PHC-строке; False при несовпадении или повреждённом хеше."""
try:
return _hasher.verify(password_hash, password)
except (VerificationError, InvalidHashError):
return False
_DUMMY_HASH = _hash_password_sync(secrets.token_urlsafe(TOKEN_BYTES))
async def hash_password(password: str) -> str:
"""Хеширует пароль в пуле потоков, не блокируя event loop."""
loop = asyncio.get_running_loop()
return await loop.run_in_executor(_executor, _hash_password_sync, password)
async def verify_password(password: str, password_hash: str) -> bool:
"""Проверяет пароль в пуле потоков, не блокируя event loop."""
loop = asyncio.get_running_loop()
return await loop.run_in_executor(
_executor, _verify_password_sync, password, password_hash
)
async def dummy_verify_password(password: str) -> None:
"""Проверка против фиктивного хеша: время ответа не выдаёт отсутствие пользователя."""
await verify_password(password, _DUMMY_HASH)
def generate_token() -> str:
"""Непрозрачный токен сессии: 32 случайных байта в base64url."""
return secrets.token_urlsafe(TOKEN_BYTES)
def hash_token(token: str) -> str:
"""SHA-256 токена в hex: детерминированный ключ для хранилища сессий."""
return hashlib.sha256(token.encode()).hexdigest()
+32
View File
@@ -0,0 +1,32 @@
"""Один pipeline изображений в Linux-процессе с лимитами памяти и CPU."""
from pathlib import Path
import resource
import sys
from app.core.image_processing import ImageSettings
from app.domain.image_pipeline import create_variants
from app.errors.exceptions import IMAGE_WORKER_ERRORS, pipeline_worker_error_code
def main() -> int:
settings = ImageSettings()
memory = settings.memory_mib * 1024 * 1024
resource.setrlimit(resource.RLIMIT_AS, (memory, memory))
resource.setrlimit(
resource.RLIMIT_CPU, (settings.cpu_seconds, settings.cpu_seconds)
)
source, directory, metadata, content_type, maximum = sys.argv[1:]
code = 0
try:
result = create_variants(
Path(source), Path(directory), content_type, int(maximum), settings
)
Path(metadata).write_text(result.model_dump_json())
except IMAGE_WORKER_ERRORS as error:
code = pipeline_worker_error_code(error)
return code
if __name__ == "__main__":
raise SystemExit(main())
+1
View File
@@ -0,0 +1 @@
"""Бизнес-логика: проверки доступа, транзакции и ошибки API."""
+265
View File
@@ -0,0 +1,265 @@
"""Приём, durable публикация, попытки и фиксация результата обработки."""
import asyncio
from collections.abc import Callable
from dataclasses import dataclass
from pathlib import Path
from tempfile import TemporaryDirectory
from uuid import UUID, uuid4
from minio.error import MinioException
from sqlalchemy.ext.asyncio import AsyncSession
from urllib3.exceptions import HTTPError as StorageHTTPError
from app.core.jobs import JobSettings
from app.domain.job_retry import classify_failure, retry_delay
from app.domain.job_files import fetch_original, render_variants
from app.errors.exceptions import ProcessingError
from app.schemas.attachment import VARIANT_FILENAMES
from app.schemas.job import JobMessage
from app.storage import jobs, outbox
from app.storage.broker import JobBroker
from app.storage.jobs import JobWork
from app.storage.s3 import MinioStorage
@dataclass(frozen=True)
class Claim:
work: JobWork | None = None
acknowledge: bool = False
async def enqueue_attachment_job(
session: AsyncSession, attachment_id: UUID, staging_key: str
) -> UUID:
"""Включить намерение обработки в транзакцию queued metadata; без commit."""
return await jobs.create_job(session, attachment_id, staging_key)
async def publish_next_job(
session: AsyncSession,
broker: JobBroker,
*,
attachment_id: UUID | None = None,
before_publish: Callable[[UUID], None] | None = None,
) -> bool:
"""Отметка publish следует за durable publisher confirm; crash допускает тот же job-дубль."""
job = await outbox.next_unpublished_job(session, attachment_id=attachment_id)
published = job is not None
if job is not None:
if before_publish is not None:
before_publish(job.attachment_id)
await broker.publish_job(
JobMessage(
job_id=job.id,
attachment_id=job.attachment_id,
pipeline_version=job.pipeline_version,
attempt=job.attempt + 1,
created_at=job.created_at,
)
)
outbox.mark_published(job)
await session.commit()
return published
async def claim_job(
session: AsyncSession, message: JobMessage, settings: JobSettings
) -> Claim:
"""Дубликат не захватывает живую аренду и не откатывает terminal-состояние."""
row = await jobs.lock_job(session, message.job_id)
result = Claim()
if row is None:
raise ProcessingError("unknown_job")
job, attachment = row
if (
message.attachment_id != attachment.id
or message.pipeline_version != job.pipeline_version
):
raise ProcessingError("invalid_job")
now = await jobs.database_time(session)
if job.attempt_limit is None:
job.attempt_limit = settings.job_max_attempts
if attachment.status in {"ready", "failed"}:
result = Claim(acknowledge=True)
elif message.attempt <= job.attempt and attachment.status == "queued":
# Предыдущая попытка уже устойчиво заменена новой в PostgreSQL.
result = Claim(acknowledge=True)
elif message.attempt < job.attempt:
result = Claim(acknowledge=True)
elif message.attempt > job.attempt + 1:
raise ProcessingError("invalid_attempt")
elif attachment.status == "queued" and job.next_attempt_at <= now:
if (
job.attempt >= (job.attempt_limit or settings.job_max_attempts)
or job.staging_key is None
):
jobs.record_failure(
job, attachment, now, "retry_exhausted", terminal=True, retry_seconds=0
)
result = Claim(acknowledge=True)
else:
result = Claim(
work=jobs.start_job(
job, attachment, uuid4(), now, settings.job_lease_seconds
)
)
await session.commit()
return result
async def save_failure(
session: AsyncSession,
work: JobWork,
settings: JobSettings,
code: str,
*,
permanent: bool,
) -> None:
# Неоднозначный COMMIT проверяется повторным чтением: ready сохраняется.
await session.rollback()
row = await jobs.lock_job(session, work.job_id)
if row is not None:
job, attachment = row
if attachment.status == "processing" and job.lease_token == work.lease_token:
exhausted = job.attempt >= (job.attempt_limit or settings.job_max_attempts)
jobs.record_failure(
job,
attachment,
await jobs.database_time(session),
"retry_exhausted" if exhausted and not permanent else code,
terminal=permanent or exhausted,
retry_seconds=retry_delay(
settings, job.attempt - job.cycle_start_attempt
),
)
job.last_error_code = code
job.last_error_permanent = permanent
await session.commit()
async def build_result(
session: AsyncSession,
storage: MinioStorage,
work: JobWork,
after_object: Callable[[UUID, str], None] | None = None,
) -> bool:
"""Фиксированные ключи и блокировка job защищают PUT от устаревшей попытки."""
with TemporaryDirectory(prefix="messenger-job-") as directory:
source = Path(directory) / "original"
await fetch_original(storage, work, source)
result = await render_variants(storage, work, source, Path(directory))
row = await jobs.lock_job(session, work.job_id)
if row is None:
await session.rollback()
return True
job, attachment = row
now = await jobs.database_time(session)
if attachment.status != "processing" or job.lease_token != work.lease_token:
await session.rollback()
return True
if job.lease_until is None or job.lease_until <= now:
await session.rollback()
return False
# Блокировка остаётся до завершения PUT/COMMIT; reaper использует SKIP LOCKED.
# При отмене S3 adapter дожидается SDK-потока до освобождения блокировки.
await storage.put_file(
work.original_key,
source,
size_bytes=work.size_bytes,
content_type=work.content_type,
sha256=work.sha256,
)
if after_object is not None:
after_object(work.attachment_id, "original")
for variant in result.variants:
await storage.put_file(
work.variant_key(variant.name),
Path(directory) / VARIANT_FILENAMES[variant.name],
size_bytes=variant.size_bytes,
content_type=variant.content_type,
sha256=variant.sha256,
)
if after_object is not None:
after_object(work.attachment_id, variant.name)
jobs.complete_job(
job,
attachment,
work,
[variant.model_dump() for variant in result.variants],
await jobs.database_time(session),
)
await session.commit()
return True
async def process_attachment_job(
session: AsyncSession,
storage: MinioStorage,
message: JobMessage,
settings: JobSettings,
*,
after_object: Callable[[UUID, str], None] | None = None,
before_processing: Callable[[UUID], None] | None = None,
) -> bool:
claim = await claim_job(session, message, settings)
acknowledge = claim.acknowledge
if claim.work is not None:
work = claim.work
try:
async with asyncio.timeout(settings.job_timeout_seconds):
if before_processing is not None:
before_processing(work.attachment_id)
acknowledge = await build_result(session, storage, work, after_object)
except (
ProcessingError,
MinioException,
StorageHTTPError,
OSError,
TimeoutError,
) as error:
code, permanent = classify_failure(error)
await save_failure(session, work, settings, code, permanent=permanent)
acknowledge = True
# Ошибка БД/неизвестная ошибка или отмена не подтверждают доставку.
return acknowledge
async def recover_expired_jobs(session: AsyncSession, settings: JobSettings) -> int:
rows = await jobs.expired_jobs(session)
now = await jobs.database_time(session)
for job, attachment in rows:
if job.attempt_limit is None:
job.attempt_limit = settings.job_max_attempts
exhausted = job.attempt >= (job.attempt_limit or settings.job_max_attempts)
jobs.record_failure(
job,
attachment,
now,
"retry_exhausted" if exhausted else "worker_timeout",
terminal=exhausted,
retry_seconds=retry_delay(settings, job.attempt - job.cycle_start_attempt),
)
job.last_error_code = "worker_timeout"
job.last_error_permanent = False
await session.commit()
return len(rows)
async def cleanup_staging(
session: AsyncSession, storage: MinioStorage, settings: JobSettings, *, apply: bool
) -> int:
rows = await jobs.terminal_staging(
session,
settings.staging_retention_seconds,
settings.failed_staging_retention_seconds,
)
if apply:
for job, attachment in rows:
if job.staging_key != attachment.object_key:
await storage.delete_object(job.staging_key)
jobs.clear_staging(job)
await session.commit()
else:
await session.rollback()
return len(rows)
+340
View File
@@ -0,0 +1,340 @@
"""Авторизация, приём оригинала и согласованность PostgreSQL/MinIO."""
from collections.abc import AsyncIterator, Iterator
from contextlib import contextmanager, suppress
from dataclasses import dataclass
import hashlib
from pathlib import Path
from tempfile import TemporaryDirectory
from uuid import UUID, uuid4
from anyio import CancelScope
from sqlalchemy.ext.asyncio import AsyncSession
from app.core.request_capacity import RequestCapacity
from app.domain.chats import ensure_chat_member
from app.domain.attachment_jobs import enqueue_attachment_job
from app.domain.images import validate_filename, validate_image
from app.errors.exceptions import (
conflict,
invalid_request,
not_found,
payload_too_large,
rate_limited,
unavailable,
unsupported_media_type,
)
from app.errors.handlers import (
RECOVERABLE_STORAGE_ERRORS,
log_recoverable_error,
operation_timeout,
)
from app.schemas.attachment import Attachment, VARIANT_FILENAMES
from app.schemas.user import User
from app.storage import attachments as repository
from app.storage.s3 import MinioStorage
@dataclass(frozen=True)
class CleanupResult:
examined: int
candidates: int
deleted: int
@dataclass(frozen=True)
class OriginalFile:
path: Path
size_bytes: int
sha256: str
def require_storage(storage: MinioStorage | None) -> MinioStorage:
if storage is None:
raise unavailable("Объектное хранилище не настроено")
return storage
def validate_declared_size(value: str | None, maximum: int) -> None:
if value is not None:
if not value.isascii() or not value.isdecimal() or len(value) > 20:
raise invalid_request("Некорректный Content-Length")
if int(value) > maximum:
raise payload_too_large()
@contextmanager
def upload_slot(capacity: RequestCapacity) -> Iterator[None]:
if not capacity.try_acquire():
raise rate_limited()
try:
yield
finally:
capacity.release()
async def receive_attachment(
session: AsyncSession,
storage: MinioStorage | None,
user: User,
chat_id: UUID,
*,
capacity: RequestCapacity,
filename: str,
content_type: str,
declared_length: str | None,
chunks: AsyncIterator[bytes],
) -> Attachment:
storage = require_storage(storage)
validate_declared_size(declared_length, storage.settings.max_upload_bytes)
timeout_error = invalid_request("Истекло время загрузки")
with upload_slot(capacity):
async with operation_timeout(
storage.settings.upload_timeout_seconds, timeout_error
):
result = await upload_attachment(
session,
storage,
user,
chat_id,
filename=filename,
content_type=content_type,
chunks=chunks,
)
return result
async def read_original(
chunks: AsyncIterator[bytes],
path: Path,
maximum: int,
chunk_bytes: int,
) -> OriginalFile:
checksum = hashlib.sha256()
size = 0
with path.open("wb") as target:
async for chunk in chunks:
size += len(chunk)
if size > maximum:
raise payload_too_large()
checksum.update(chunk)
view = memoryview(chunk)
for offset in range(0, len(view), chunk_bytes):
target.write(view[offset : offset + chunk_bytes])
if size == 0:
raise unsupported_media_type("Пустой файл")
return OriginalFile(path, size, checksum.hexdigest())
async def compensate_upload(
session: AsyncSession, storage: MinioStorage, id: UUID
) -> None:
"""Неоднозначный COMMIT сначала проверяется в БД: готовый объект не удаляется."""
await session.rollback()
intent = await repository.lock_upload(session, id)
if intent is not None:
if await repository.get_by_key(session, intent.object_key) is None:
await storage.delete_object(intent.object_key)
await repository.finish_upload(session, id)
await session.commit()
async def recover_upload(
session: AsyncSession, storage: MinioStorage, id: UUID
) -> None:
"""Локальное восстановление после ошибки; журнал остаётся при отказе компенсации."""
try:
await compensate_upload(session, storage, id)
except RECOVERABLE_STORAGE_ERRORS as error:
log_recoverable_error("Upload compensation", error)
# Ошибка повторного rollback не должна скрыть исходную ошибку или отмену.
with suppress(*RECOVERABLE_STORAGE_ERRORS):
await session.rollback()
async def stage_attachment(
session: AsyncSession,
storage: MinioStorage,
user: User,
chat_id: UUID,
*,
original: OriginalFile,
filename: str,
content_type: str,
) -> Attachment:
"""Сохранить исходник в staging и атомарно принять metadata/job."""
id = uuid4()
key = f"staging/{uuid4().hex}"
# Журнал устойчив до PUT, включая аварию процесса и неоднозначный COMMIT.
await repository.reserve_upload(session, id, key)
await session.commit()
try:
if await repository.lock_upload(session, id) is None:
raise unavailable("Загрузка отменена до записи оригинала")
await storage.put_file(
key,
original.path,
size_bytes=original.size_bytes,
content_type=content_type,
sha256=original.sha256,
)
record = await repository.create_attachment(
session,
id=id,
chat_id=chat_id,
owner_id=user.id,
object_key=f"originals/{id.hex}/v1",
status="queued",
filename=filename,
content_type=content_type,
size_bytes=original.size_bytes,
sha256=original.sha256,
)
await enqueue_attachment_job(session, id, key)
await repository.finish_upload(session, id)
# Снимок queued строится до COMMIT, даже если worker очень быстрый.
result = Attachment.model_validate(record)
await session.commit()
except BaseException:
# Отмена тоже требует дождаться SDK и компенсировать незавершённый PUT.
with CancelScope(shield=True):
await recover_upload(session, storage, id)
raise
return result
async def upload_attachment(
session: AsyncSession,
storage: MinioStorage,
user: User,
chat_id: UUID,
*,
filename: str,
content_type: str,
chunks: AsyncIterator[bytes],
) -> Attachment:
await ensure_chat_member(session, user, chat_id)
validate_filename(filename)
if content_type not in {"image/png", "image/jpeg"}:
raise unsupported_media_type("Принимаются только image/png и image/jpeg")
# Не держим соединение PostgreSQL во время чтения медленного клиента.
await session.rollback()
settings = storage.settings
with TemporaryDirectory(prefix="messenger-upload-") as directory:
original = await read_original(
chunks,
Path(directory) / "original",
settings.max_upload_bytes,
settings.chunk_bytes,
)
await validate_image(original.path, content_type, settings)
result = await stage_attachment(
session,
storage,
user,
chat_id,
original=original,
filename=filename,
content_type=content_type,
)
return result
async def get_attachment(
session: AsyncSession, user: User, attachment_id: UUID
) -> Attachment:
record = await repository.get_attachment(session, attachment_id)
if record is None:
raise not_found()
await ensure_chat_member(session, user, record.chat_id)
return Attachment.model_validate(record)
@dataclass(frozen=True)
class DownloadInfo:
filename: str
content_type: str
size_bytes: int
async def download_attachment(
session: AsyncSession,
storage: MinioStorage | None,
user: User,
attachment_id: UUID,
*,
variant: str = "original",
) -> tuple[DownloadInfo, AsyncIterator[bytes]]:
result = await get_attachment(session, user, attachment_id)
if result.status != "ready":
raise conflict("Вложение пока недоступно для скачивания")
storage = require_storage(storage)
record = await repository.get_attachment(session, attachment_id)
if record is None:
raise not_found()
if variant == "original":
key = record.object_key
info = DownloadInfo(result.filename, result.content_type, result.size_bytes)
else:
selected = next(
(item for item in result.variants if item.name == variant), None
)
keys = {
"thumbnail": record.thumbnail_key,
"crop": record.crop_key,
"optimized": record.optimized_key,
}
key = keys.get(variant)
if selected is None or key is None:
raise not_found()
info = DownloadInfo(
VARIANT_FILENAMES[variant], selected.content_type, selected.size_bytes
)
await session.rollback()
stored = await storage.stat_object(key)
if stored.size_bytes != info.size_bytes or stored.content_type != info.content_type:
raise unavailable("Файл временно недоступен")
stream = await storage.open_object(key)
return info, stream
async def validate_message_attachments(
session: AsyncSession,
user: User,
chat_id: UUID,
attachment_ids: list[UUID],
) -> None:
await ensure_chat_member(session, user, chat_id)
records = await repository.get_for_chat(session, chat_id, attachment_ids)
if len(records) != len(attachment_ids):
raise not_found()
if any(record.status == "failed" for record in records):
raise conflict("Обработка вложения завершилась ошибкой")
async def reconcile_attachments(
session: AsyncSession,
storage: MinioStorage,
*,
batch_size: int = 20,
dry_run: bool = True,
) -> CleanupResult:
if not 1 <= batch_size <= 100:
raise invalid_request("batch_size должен быть от 1 до 100")
intents = await repository.stale_uploads(
session, storage.settings.cleanup_grace_seconds, batch_size
)
candidates = deleted = 0
for intent in intents:
if await repository.get_by_key(session, intent.object_key) is None:
candidates += 1
if not dry_run:
await storage.delete_object(intent.object_key)
deleted += 1
if not dry_run:
await repository.finish_upload(session, intent.id)
if dry_run:
await session.rollback()
else:
await session.commit()
return CleanupResult(len(intents), candidates, deleted)
+84
View File
@@ -0,0 +1,84 @@
import re
from datetime import UTC, datetime, timedelta
from redis.asyncio import Redis
from sqlalchemy.ext.asyncio import AsyncSession
from app.core import security
from app.domain.users import to_user_schema
from app.errors.exceptions import unauthorized_basic, unauthorized_bearer
from app.schemas.session import AuthSession
from app.schemas.user import (
PASSWORD_MAX_LENGTH,
PASSWORD_MIN_LENGTH,
USERNAME_PATTERN,
User,
)
from app.storage import sessions as sessions_storage
from app.storage import users as users_storage
USERNAME_RE = re.compile(USERNAME_PATTERN)
async def create_session(
session: AsyncSession,
redis: Redis,
username: str,
password: str,
ttl_seconds: int,
) -> AuthSession:
"""Проверяет учётные данные и выдаёт новый Bearer-токен."""
if (
USERNAME_RE.fullmatch(username) is None
or not PASSWORD_MIN_LENGTH <= len(password) <= PASSWORD_MAX_LENGTH
or not password.strip()
):
raise unauthorized_basic()
user = await users_storage.get_user_by_username(session, username)
await session.commit()
if user is None:
await security.dummy_verify_password(password)
raise unauthorized_basic()
if not await security.verify_password(password, user.password_hash):
raise unauthorized_basic()
token = security.generate_token()
expires_at = datetime.now(UTC) + timedelta(seconds=ttl_seconds)
await sessions_storage.create_session(
redis,
token_hash=security.hash_token(token),
user_id=user.id,
expires_at=expires_at,
)
auth_session = AuthSession(
token=token, expires_at=expires_at, user=to_user_schema(user)
)
return auth_session
async def authenticate_token(session: AsyncSession, redis: Redis, token: str) -> User:
"""Возвращает владельца действующей сессии или бросает 401."""
user_id = await sessions_storage.get_session_user_id(
redis, security.hash_token(token)
)
if user_id is None:
raise unauthorized_bearer()
user = await users_storage.get_user_by_id(session, user_id)
if user is None:
raise unauthorized_bearer()
current_user = to_user_schema(user)
return current_user
async def revoke_session(redis: Redis, token: str) -> None:
"""Отзывает текущую сессию; повторный отзыв даёт 401."""
is_deleted = await sessions_storage.delete_session(
redis, security.hash_token(token)
)
if not is_deleted:
raise unauthorized_bearer()
+104
View File
@@ -0,0 +1,104 @@
from uuid import UUID
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession
from app.domain.pagination import (
KIND_CHATS,
build_next_cursor,
decode_cursor,
split_page,
)
from app.errors.exceptions import invalid_request, not_found
from app.models.chat import Chat as ChatModel
from app.schemas.chat import Chat, ChatPage, CreateChat
from app.schemas.user import User
from app.storage import chats as chats_storage
from app.storage import users as users_storage
from app.storage.types import Position
UNKNOWN_MEMBER_MESSAGE = "member_ids содержит неизвестного пользователя"
def to_chat_schema(chat: ChatModel) -> Chat:
"""Преобразует ORM-модель чата с загруженными участниками в схему."""
chat_schema = Chat(
id=chat.id,
title=chat.title,
member_ids=[member.user_id for member in chat.members],
created_at=chat.created_at,
)
return chat_schema
def validate_new_chat(creator: User, new_chat: CreateChat) -> None:
"""Проверяет состав участников без обращения к базе."""
member_ids = new_chat.member_ids
if creator.id not in member_ids:
raise invalid_request("Создатель чата должен входить в member_ids")
if len(set(member_ids)) != len(member_ids):
raise invalid_request("member_ids содержит дубликаты")
async def create_chat(
session: AsyncSession, creator: User, new_chat: CreateChat
) -> Chat:
"""Создаёт чат с участниками атомарно; неверный состав даёт 400."""
validate_new_chat(creator, new_chat)
existing_ids = await users_storage.get_existing_user_ids(
session, new_chat.member_ids
)
if existing_ids != set(new_chat.member_ids):
raise invalid_request(UNKNOWN_MEMBER_MESSAGE)
try:
chat = await chats_storage.create_chat(
session, title=new_chat.title, member_ids=new_chat.member_ids
)
await session.commit()
except IntegrityError:
await session.rollback()
raise invalid_request(UNKNOWN_MEMBER_MESSAGE) from None
created_chat = to_chat_schema(chat)
return created_chat
async def get_chat(session: AsyncSession, user: User, chat_id: UUID) -> Chat:
"""Возвращает чат участнику; чужой и несуществующий чат дают 404."""
chat = await chats_storage.get_chat_for_member(session, chat_id, user.id)
if chat is None:
raise not_found()
found_chat = to_chat_schema(chat)
return found_chat
async def ensure_chat_member(session: AsyncSession, user: User, chat_id: UUID) -> None:
"""Бросает 404, если пользователь не состоит в чате или чата нет."""
if not await chats_storage.is_chat_member(session, chat_id, user.id):
raise not_found()
async def list_chats(
session: AsyncSession,
user: User,
cursor: str | None,
limit: int,
) -> ChatPage:
"""Возвращает страницу чатов пользователя по (created_at, id)."""
after: Position | None = None
if cursor is not None:
after = decode_cursor(cursor, KIND_CHATS, user.id)
rows = await chats_storage.list_chats_for_user(session, user.id, after, limit + 1)
page_rows, has_next = split_page(rows, limit)
items = [to_chat_schema(chat) for chat in page_rows]
page = ChatPage(
items=items,
next_cursor=build_next_cursor(KIND_CHATS, user.id, items, has_next),
)
return page
+36
View File
@@ -0,0 +1,36 @@
"""Условия готовности реплики и ограниченная проверка зависимостей."""
import asyncio
from redis.asyncio import Redis
from sqlalchemy.ext.asyncio import AsyncEngine
from app.core.lifecycle import Lifecycle
from app.errors.exceptions import unavailable
from app.errors.handlers import operation_timeout
from app.schemas.base import Health
from app.storage.health import check_database, check_redis
from app.storage.s3 import MinioStorage
def liveness() -> Health:
return Health(status="ok")
async def readiness(
engine: AsyncEngine,
redis: Redis,
storage: MinioStorage | None,
lifecycle: Lifecycle,
timeout_seconds: float,
) -> Health:
if lifecycle.draining:
raise unavailable()
checks = [check_database(engine), check_redis(redis)]
if storage is not None:
checks.append(storage.check_available())
async with operation_timeout(timeout_seconds, unavailable()):
dependencies = await asyncio.gather(*checks, return_exceptions=True)
if not all(result is True for result in dependencies):
raise unavailable()
return Health(status="ok")
+78
View File
@@ -0,0 +1,78 @@
"""Атомарная отправка сообщения с защитой от повторов."""
import hashlib
import json
import re
from uuid import UUID
from sqlalchemy.ext.asyncio import AsyncSession
from app.domain.chats import ensure_chat_member
from app.domain.attachments import validate_message_attachments
from app.errors.exceptions import conflict, invalid_request, unavailable
from app.schemas.message import CreateMessage, Message
from app.schemas.user import User
from app.storage import idempotency as key_storage
from app.storage import messages as message_storage
from app.storage import attachments as attachment_storage
IDEMPOTENCY_KEY_PATTERN = re.compile(r"[A-Za-z0-9._:-]{1,128}")
def validate_idempotency_key(key: str | None) -> str:
"""Проверяет обязательный ASCII-ключ запроса."""
if key is None or IDEMPOTENCY_KEY_PATTERN.fullmatch(key) is None:
raise invalid_request("Требуется корректный Idempotency-Key")
return key
def request_fingerprint(new_message: CreateMessage) -> str:
"""Хеширует нормализованное содержимое запроса."""
body = new_message.model_dump(mode="json")
# Сохраняет прежние отпечатки текстовых запросов и равенство absent / [].
if not body["attachment_ids"]:
body.pop("attachment_ids")
canonical = json.dumps(body, sort_keys=True, ensure_ascii=False)
return hashlib.sha256(canonical.encode()).hexdigest()
async def send_message_idempotent(
session: AsyncSession,
sender: User,
chat_id: UUID,
new_message: CreateMessage,
idempotency_key: str,
max_messages: int,
ttl_seconds: int,
) -> Message:
"""Создаёт сообщение или возвращает результат прежнего запроса."""
await ensure_chat_member(session, sender, chat_id)
scope = (sender.id, "POST", f"/api/v1/chats/{chat_id}/messages", idempotency_key)
fingerprint = request_fingerprint(new_message)
await key_storage.lock_key(session, scope)
previous = await key_storage.get_active_key(session, scope, ttl_seconds)
if previous is not None:
if previous.request_hash != fingerprint:
raise conflict("Idempotency-Key уже использован для другого сообщения")
message = await message_storage.get_message(session, previous.message_id)
else:
await validate_message_attachments(
session, sender, chat_id, new_message.attachment_ids
)
if not await message_storage.reserve_message_slot(session, max_messages):
raise unavailable("Достигнут лимит количества сообщений")
message = await message_storage.create_message(
session, chat_id=chat_id, sender_id=sender.id, text=new_message.text
)
await attachment_storage.bind_attachments(
session, message.id, new_message.attachment_ids
)
await key_storage.save_result(session, scope, fingerprint, message.id)
links = await attachment_storage.message_attachment_ids(session, [message.id])
result = Message.model_validate(message).model_copy(
update={"attachment_ids": links[message.id]}
)
await session.commit()
return result
+105
View File
@@ -0,0 +1,105 @@
"""Thumbnail, crop и WebP; один ограниченный процесс, последовательная обработка."""
import hashlib
from pathlib import Path
from PIL import Image, ImageOps
from app.core.image_processing import ImageSettings
from app.domain.image_validation import decode_image
from app.schemas.attachment import PipelineResult, Variant
def fitted_size(size: tuple[int, int], maximum: int) -> tuple[int, int]:
"""Вписать без увеличения, округляя вниз, минимум один пиксель."""
longest = max(size)
result = size
if longest > maximum:
result = (
max(1, size[0] * maximum // longest),
max(1, size[1] * maximum // longest),
)
return result
def describe_variant(
name: str, content_type: str, path: Path, size: tuple[int, int]
) -> Variant:
checksum = hashlib.sha256()
with path.open("rb") as source:
for chunk in iter(lambda: source.read(65536), b""):
checksum.update(chunk)
return Variant(
name=name,
content_type=content_type,
size_bytes=path.stat().st_size,
width=size[0],
height=size[1],
sha256=checksum.hexdigest(),
)
def save_jpeg(image: Image.Image, destination: Path, quality: int) -> None:
"""Белая подложка и новый image без EXIF/ICC/XMP/текстовых метаданных."""
with Image.new("RGB", image.size, "white") as clean:
with image.getchannel("A") as alpha:
clean.paste(image, mask=alpha)
clean.save(destination, format="JPEG", quality=quality, exif=b"")
def create_thumbnail(image: Image.Image, destination: Path, quality: int) -> Variant:
size = fitted_size(image.size, 256)
with image.resize(size, Image.Resampling.LANCZOS) as resized:
save_jpeg(resized, destination, quality)
return describe_variant("thumbnail", "image/jpeg", destination, size)
def create_crop(image: Image.Image, destination: Path, quality: int) -> Variant:
"""Центрированный JPEG 128×128; маленький исходник допускает увеличение."""
with ImageOps.fit(
image, (128, 128), method=Image.Resampling.LANCZOS, centering=(0.5, 0.5)
) as crop:
save_jpeg(crop, destination, quality)
return describe_variant("crop", "image/jpeg", destination, (128, 128))
def create_optimized(
image: Image.Image, destination: Path, settings: ImageSettings
) -> Variant:
"""WebP ≤1280×1280 без увеличения; alpha сохраняется, метаданные удаляются."""
size = fitted_size(image.size, 1280)
with image.resize(size, Image.Resampling.LANCZOS) as resized:
with Image.new("RGBA", size) as clean:
clean.paste(resized)
clean.save(
destination,
format="WEBP",
lossless=False,
quality=settings.webp_quality,
method=settings.webp_method,
exif=b"",
icc_profile=b"",
xmp=b"",
)
return describe_variant("optimized", "image/webp", destination, size)
def create_variants(
source: Path,
directory: Path,
content_type: str,
max_pixels: int,
settings: ImageSettings,
) -> PipelineResult:
decode_image(source, content_type, max_pixels)
with Image.open(source, formats=["PNG", "JPEG"]) as image:
ImageOps.exif_transpose(image, in_place=True)
with image.convert("RGBA") as pixels:
variants = [
create_thumbnail(
pixels, directory / "thumbnail.jpg", settings.jpeg_quality
),
create_crop(pixels, directory / "crop.jpg", settings.jpeg_quality),
create_optimized(pixels, directory / "optimized.webp", settings),
]
return PipelineResult(variants=variants)
+23
View File
@@ -0,0 +1,23 @@
"""Синхронная проверка изображения; вызывается только из ограниченного процесса."""
from pathlib import Path
import warnings
from PIL import Image
from app.errors.exceptions import payload_too_large, unsupported_media_type
def decode_image(path: Path, content_type: str, max_pixels: int) -> None:
Image.MAX_IMAGE_PIXELS = max_pixels
warnings.simplefilter("error", Image.DecompressionBombWarning)
with Image.open(path, formats=["PNG", "JPEG"]) as image:
if image.width * image.height > max_pixels:
raise payload_too_large("Превышен лимит пикселей изображения")
image_format = image.format
if image_format is None or Image.MIME.get(image_format) != content_type:
raise unsupported_media_type("Содержимое не соответствует Content-Type")
image.verify()
# Для JPEG одной verify() недостаточно: декодировать весь оригинал.
with Image.open(path, formats=["PNG", "JPEG"]) as image:
image.load()
+48
View File
@@ -0,0 +1,48 @@
"""Проверка имени и запуск ограниченного декодера."""
import asyncio
from pathlib import Path
import sys
import unicodedata
from anyio import CancelScope
from app.core.s3 import S3Settings
from app.errors.exceptions import (
image_validation_error,
invalid_request,
payload_too_large,
)
from app.errors.handlers import operation_timeout
def validate_filename(filename: str) -> None:
if not 1 <= len(filename) <= 255 or any(
char in "/\\" or unicodedata.category(char) in {"Cc", "Cf", "Cs"}
for char in filename
):
raise invalid_request("Недопустимое имя файла")
async def validate_image(path: Path, content_type: str, settings: S3Settings) -> None:
process = await asyncio.create_subprocess_exec(
sys.executable,
"-m",
"app.core.image_worker",
str(path),
content_type,
str(settings.max_image_pixels),
stdout=asyncio.subprocess.DEVNULL,
stderr=asyncio.subprocess.DEVNULL,
)
error = payload_too_large("Превышен бюджет проверки изображения")
try:
async with operation_timeout(settings.image_timeout_seconds, error):
code = await process.wait()
finally:
if process.returncode is None:
process.kill()
with CancelScope(shield=True):
await process.wait()
if code != 0:
raise image_validation_error(code)
+161
View File
@@ -0,0 +1,161 @@
"""Replay только failed с проверенным исходником и ограниченным новым бюджетом."""
import asyncio
import re
from pathlib import Path
from tempfile import TemporaryDirectory
from uuid import uuid4
from minio.error import S3Error
from app.domain.job_files import fetch_original
from app.errors.exceptions import JobOperationError, ProcessingError
from app.storage import job_admin, jobs
from app.storage.jobs import JobWork
REPLAY_REASONS = ("dependency_restored", "configuration_fixed", "manual_review")
def snapshot(job, attachment):
return dict(
job_id=str(job.id),
attachment_id=str(attachment.id),
status=attachment.status,
attempt=job.attempt,
attempt_limit=job.attempt_limit,
cycle_start_attempt=job.cycle_start_attempt,
error_code=attachment.error_code,
last_error_code=job.last_error_code,
last_error_permanent=job.last_error_permanent,
staging_retained=job.staging_key is not None,
next_attempt_at=job.next_attempt_at,
lease_until=job.lease_until,
finished_at=job.finished_at,
)
async def list_failed(session, limit):
return [
snapshot(job, attachment)
for job, attachment in await job_admin.failed_jobs(session, limit)
]
async def show_job(session, job_id):
row = await jobs.lock_job(session, job_id)
if row is None:
raise JobOperationError("unknown_job")
result = snapshot(*row)
await session.rollback()
return result
async def history(session, job_id):
return [
dict(
request_id=str(row.id),
actor=row.actor,
reason=row.reason,
previous_attempt=row.previous_attempt,
attempt_limit=row.attempt_limit,
previous_error_code=row.previous_error_code,
created_at=row.created_at,
)
for row in await job_admin.replay_history(session, job_id)
]
def same_request(record, job_id, actor, reason):
if record.job_id != job_id or record.actor != actor or record.reason != reason:
raise JobOperationError("request_conflict")
return {
"request_id": str(record.id),
"job_id": str(job_id),
"already_applied": True,
}
def validate_replay_request(actor: str, reason: str) -> None:
"""Проверить данные оператора для записи аудита."""
if (
re.fullmatch(r"[A-Za-z0-9._-]{1,64}", actor) is None
or reason not in REPLAY_REASONS
):
raise JobOperationError("invalid_audit_fields")
def validate_replay_job(job, attachment) -> None:
"""Разрешить новый replay только для failed с сохранённым исходником."""
if attachment.status != "failed":
raise JobOperationError("job_not_failed")
if job.staging_key is None:
raise JobOperationError("source_expired")
async def verify_replay_source(storage, settings, job, attachment) -> None:
"""Проверить размер и SHA-256 исходника в S3 под блокировкой job."""
work = JobWork(
job.id,
attachment.id,
uuid4(),
job.pipeline_version,
job.staging_key,
attachment.content_type,
attachment.size_bytes,
attachment.sha256,
)
try:
async with asyncio.timeout(settings.job_timeout_seconds):
with TemporaryDirectory(prefix="replay-source-") as directory:
await fetch_original(storage, work, Path(directory) / "original")
except ProcessingError as error:
raise JobOperationError(error.code) from None
except S3Error as error:
if error.code in {"NoSuchKey", "NoSuchObject"}:
raise JobOperationError("source_missing") from None
raise
async def replay_failed_job(
session, storage, settings, job_id, *, request_id, actor, reason
):
"""Организовать replay; блокировка, rollback и commit остаются здесь."""
validate_replay_request(actor, reason)
row = await jobs.lock_job(session, job_id)
if row is None:
raise JobOperationError("unknown_job")
record = await job_admin.replay_record(session, request_id)
if record is not None:
result = same_request(record, job_id, actor, reason)
await session.rollback()
return result
job, attachment = row
validate_replay_job(job, attachment)
# Блокировка сохраняется во время проверки S3, аудита и изменения job.
await verify_replay_source(storage, settings, job, attachment)
limit = job.attempt + settings.job_max_attempts
inserted = await job_admin.insert_replay(
session,
id=request_id,
job_id=job_id,
actor=actor,
reason=reason,
previous_attempt=job.attempt,
attempt_limit=limit,
previous_error_code=job.last_error_code,
)
if not inserted:
result = same_request(
await job_admin.replay_record(session, request_id), job_id, actor, reason
)
await session.rollback()
return result
job_admin.reset_failed(job, attachment, await jobs.database_time(session), limit)
await session.commit()
return {
"request_id": str(request_id),
"job_id": str(job_id),
"already_applied": False,
"status": "queued",
"attempt_limit": limit,
}
+72
View File
@@ -0,0 +1,72 @@
"""Получение исходника и запуск изолированного процесса обработки вариантов."""
import asyncio
import errno
import hashlib
from pathlib import Path
import sys
from anyio import CancelScope
from app.errors.exceptions import ProcessingError
from app.schemas.attachment import PipelineResult
from app.storage.jobs import JobWork
from app.storage.s3 import MinioStorage
async def fetch_original(
storage: MinioStorage, work: JobWork, destination: Path
) -> None:
if work.size_bytes > storage.settings.max_upload_bytes:
raise ProcessingError("image_limits")
checksum = hashlib.sha256()
size = 0
stream = await storage.open_object(work.staging_key)
try:
with destination.open("wb") as target:
async for chunk in stream:
size += len(chunk)
if size > work.size_bytes:
raise ProcessingError("source_mismatch")
target.write(chunk)
checksum.update(chunk)
finally:
await stream.aclose()
if size != work.size_bytes or checksum.hexdigest() != work.sha256:
raise ProcessingError("source_mismatch")
async def render_variants(
storage: MinioStorage, work: JobWork, source: Path, directory: Path
) -> PipelineResult:
metadata = directory / "variants.json"
process = await asyncio.create_subprocess_exec(
sys.executable,
"-m",
"app.core.thumbnail_worker",
str(source),
str(directory),
str(metadata),
work.content_type,
str(storage.settings.max_image_pixels),
stdout=asyncio.subprocess.DEVNULL,
stderr=asyncio.subprocess.DEVNULL,
)
try:
code = await process.wait()
finally:
if process.returncode is None:
process.kill()
with CancelScope(shield=True):
await process.wait()
if code == 2:
raise ProcessingError("invalid_image")
if code == 3 or code < 0:
raise ProcessingError("image_limits")
if code == 4:
raise OSError(errno.EIO, "Pipeline filesystem unavailable")
if code == 5:
raise ProcessingError("processing_configuration")
if code != 0:
raise RuntimeError("Image pipeline subprocess failed")
return PipelineResult.model_validate_json(metadata.read_text())
+51
View File
@@ -0,0 +1,51 @@
"""Ограниченный exponential backoff: jitter сохраняется вместе с новой попыткой."""
import errno
import random
from minio.error import S3Error
from app.core.jobs import JobSettings
from app.errors.exceptions import ProcessingError
def retry_delay(settings: JobSettings, cycle_attempt: int) -> float:
ceiling = min(
settings.job_retry_max_seconds,
settings.job_retry_seconds * 2 ** min(30, max(0, cycle_attempt - 1)),
)
return random.uniform(ceiling / 2, ceiling)
def classify_failure(error: Exception) -> tuple[str, bool]:
if isinstance(error, ProcessingError):
return error.code, True
if isinstance(error, S3Error):
if error.code in {"NoSuchKey", "NoSuchObject"}:
return "source_missing", True
if error.code in {
"AccessDenied",
"InvalidAccessKeyId",
"SignatureDoesNotMatch",
"NoSuchBucket",
}:
return "storage_configuration", True
if error.code in {
"InternalError",
"SlowDown",
"ServiceUnavailable",
"RequestTimeout",
"Throttling",
}:
return "storage_unavailable", False
return "storage_rejected", True
if isinstance(error, TimeoutError):
return "processing_timeout", False
if isinstance(error, OSError) and error.errno in {
errno.EACCES,
errno.EPERM,
errno.EROFS,
errno.ENOENT,
}:
return "processing_configuration", True
return "processing_unavailable", False
+48
View File
@@ -0,0 +1,48 @@
from uuid import UUID
from sqlalchemy.ext.asyncio import AsyncSession
from app.domain.chats import ensure_chat_member
from app.domain.pagination import (
KIND_MESSAGES,
build_next_cursor,
decode_cursor,
split_page,
)
from app.schemas.message import Message, MessagePage
from app.schemas.user import User
from app.storage import messages as messages_storage
from app.storage import attachments as attachments_storage
from app.storage.types import Position
async def list_messages(
session: AsyncSession,
user: User,
chat_id: UUID,
cursor: str | None,
limit: int,
) -> MessagePage:
"""Возвращает страницу истории чата по (created_at, id)."""
after: Position | None = None
if cursor is not None:
after = decode_cursor(cursor, KIND_MESSAGES, chat_id)
await ensure_chat_member(session, user, chat_id)
rows = await messages_storage.list_messages(session, chat_id, after, limit + 1)
page_rows, has_next = split_page(rows, limit)
links = await attachments_storage.message_attachment_ids(
session, [message.id for message in page_rows]
)
items = [
Message.model_validate(message).model_copy(
update={"attachment_ids": links[message.id]},
)
for message in page_rows
]
page = MessagePage(
items=items,
next_cursor=build_next_cursor(KIND_MESSAGES, chat_id, items, has_next),
)
return page
+83
View File
@@ -0,0 +1,83 @@
import base64
import json
from collections.abc import Sequence
from datetime import datetime
from typing import Protocol, TypeVar
from uuid import UUID
from app.errors.exceptions import invalid_request
from app.storage.types import Position
KIND_CHATS = "chats"
KIND_MESSAGES = "messages"
T = TypeVar("T")
class Positioned(Protocol):
"""Объект с позицией в порядке (created_at, id)."""
@property
def id(self) -> UUID: ...
@property
def created_at(self) -> datetime: ...
def encode_cursor(
kind: str,
resource_id: UUID,
created_at: datetime,
item_id: UUID,
) -> str:
"""Кодирует позицию и ресурс, к которому она привязана, в непрозрачный cursor."""
payload = {
"kind": kind,
"resource_id": str(resource_id),
"created_at": created_at.isoformat(),
"item_id": str(item_id),
}
raw = json.dumps(payload).encode()
return base64.urlsafe_b64encode(raw).decode()
def decode_cursor(cursor: str, kind: str, resource_id: UUID) -> Position:
"""Возвращает позицию из cursor; битый или чужой cursor даёт 400."""
try:
payload = json.loads(base64.urlsafe_b64decode(cursor))
cursor_kind = payload["kind"]
cursor_resource_id = UUID(payload["resource_id"])
created_at = datetime.fromisoformat(payload["created_at"])
item_id = UUID(payload["item_id"])
except (ValueError, KeyError, TypeError, AttributeError):
raise invalid_request("Некорректный cursor") from None
if (
cursor_kind != kind
or cursor_resource_id != resource_id
or created_at.tzinfo is None
):
raise invalid_request("Некорректный cursor")
return created_at, item_id
def split_page(rows: list[T], limit: int) -> tuple[list[T], bool]:
"""Отделяет страницу от лишней строки limit + 1, по которой видно продолжение."""
has_next = len(rows) > limit
items = rows[:limit]
return items, has_next
def build_next_cursor(
kind: str,
resource_id: UUID,
items: Sequence[Positioned],
has_next: bool,
) -> str | None:
"""Возвращает cursor на последний элемент страницы или None, если она последняя."""
if not has_next:
return None
last_item = items[-1]
return encode_cursor(kind, resource_id, last_item.created_at, last_item.id)
+41
View File
@@ -0,0 +1,41 @@
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession
from app.core import security
from app.errors.exceptions import conflict
from app.models.user import User as UserModel
from app.schemas.user import CreateUser, User
from app.storage import users as users_storage
USERNAME_TAKEN_MESSAGE = "Имя пользователя уже занято"
def to_user_schema(user: UserModel) -> User:
"""Преобразует ORM-модель в публичную схему без password_hash."""
user_schema = User.model_validate(user)
return user_schema
async def register_user(session: AsyncSession, new_user: CreateUser) -> User:
"""Регистрирует пользователя; занятый username даёт 409."""
existing_user = await users_storage.get_user_by_username(session, new_user.username)
await session.commit()
if existing_user is not None:
raise conflict(USERNAME_TAKEN_MESSAGE)
password_hash = await security.hash_password(new_user.password)
try:
user = await users_storage.create_user(
session,
username=new_user.username,
display_name=new_user.display_name,
password_hash=password_hash,
)
await session.commit()
except IntegrityError:
await session.rollback()
raise conflict(USERNAME_TAKEN_MESSAGE) from None
created_user = to_user_schema(user)
return created_user
View File
+74
View File
@@ -0,0 +1,74 @@
"""HTTP-параметры и упаковка ответов; сценарии находятся в domain."""
from typing import Annotated
from urllib.parse import quote
from uuid import UUID
from fastapi import APIRouter, Query, Request
from fastapi.responses import StreamingResponse
from starlette.background import BackgroundTask
from app.domain import attachments
from app.endpoints.dependencies import CurrentUser, DbSession, S3Storage, UploadCapacity
from app.schemas.attachment import Attachment
router = APIRouter(prefix="/api/v1", tags=["attachments"])
@router.post("/chats/{chat_id}/attachments", status_code=202)
async def upload(
request: Request,
chat_id: UUID,
user: CurrentUser,
session: DbSession,
storage: S3Storage,
capacity: UploadCapacity,
filename: Annotated[str, Query(min_length=1, max_length=255)],
) -> Attachment:
return await attachments.receive_attachment(
session,
storage,
user,
chat_id,
capacity=capacity,
filename=filename,
content_type=request.headers.get("content-type", "").lower(),
declared_length=request.headers.get("content-length"),
chunks=request.stream(),
)
@router.get("/attachments/{attachment_id}")
async def metadata(
attachment_id: UUID, user: CurrentUser, session: DbSession
) -> Attachment:
return await attachments.get_attachment(session, user, attachment_id)
@router.get("/attachments/{attachment_id}/content")
async def content(
attachment_id: UUID,
user: CurrentUser,
session: DbSession,
storage: S3Storage,
variant: Annotated[str, Query()] = "original",
) -> StreamingResponse:
record, stream = await attachments.download_attachment(
session,
storage,
user,
attachment_id,
variant=variant,
)
return StreamingResponse(
stream,
media_type=record.content_type,
headers={
"Content-Length": str(record.size_bytes),
"Content-Disposition": "attachment; filename*=UTF-8''"
+ quote(record.filename, safe=""),
"X-Content-Type-Options": "nosniff",
"Cache-Control": "private, no-store",
},
background=BackgroundTask(stream.aclose),
)
+32
View File
@@ -0,0 +1,32 @@
from fastapi import APIRouter, Response
from app.domain.auth import create_session, revoke_session
from app.endpoints.dependencies import (
AppSettings,
BasicCredentials,
BearerToken,
DbSession,
RedisClient,
)
from app.schemas.session import AuthSession
router = APIRouter(prefix="/api/v1/auth", tags=["auth"])
@router.post("/sessions", status_code=201)
async def login(
credentials: BasicCredentials,
session: DbSession,
redis: RedisClient,
settings: AppSettings,
) -> AuthSession:
username, password = credentials
return await create_session(
session, redis, username, password, settings.session_ttl_seconds
)
@router.delete("/sessions/current", status_code=204)
async def logout(token: BearerToken, redis: RedisClient) -> Response:
await revoke_session(redis, token)
return Response(status_code=204)
+32
View File
@@ -0,0 +1,32 @@
from typing import Annotated
from uuid import UUID
from fastapi import APIRouter, Query
from app.domain.chats import create_chat, get_chat, list_chats
from app.endpoints.dependencies import CurrentUser, DbSession
from app.schemas.chat import Chat, ChatPage, CreateChat
router = APIRouter(prefix="/api/v1/chats", tags=["chats"])
@router.post("", status_code=201)
async def create_new_chat(
new_chat: CreateChat, creator: CurrentUser, session: DbSession
) -> Chat:
return await create_chat(session, creator, new_chat)
@router.get("")
async def list_user_chats(
user: CurrentUser,
session: DbSession,
limit: Annotated[int, Query(ge=1, le=100)] = 50,
cursor: Annotated[str | None, Query(min_length=1)] = None,
) -> ChatPage:
return await list_chats(session, user, cursor, limit)
@router.get("/{chat_id}")
async def get_chat_by_id(chat_id: UUID, user: CurrentUser, session: DbSession) -> Chat:
return await get_chat(session, user, chat_id)
+112
View File
@@ -0,0 +1,112 @@
import base64
import binascii
from collections.abc import AsyncIterator
from typing import Annotated
from fastapi import Depends, Request, Security
from fastapi.openapi.models import HTTPBase, HTTPBearer
from fastapi.security.base import SecurityBase
from redis.asyncio import Redis
from sqlalchemy.ext.asyncio import AsyncSession
from app.core.config import Settings
from app.core.request_capacity import RequestCapacity
from app.domain.auth import authenticate_token
from app.errors.exceptions import unauthorized_basic, unauthorized_bearer
from app.schemas.user import User
from app.storage.s3 import MinioStorage
async def get_settings(request: Request) -> Settings:
settings: Settings = request.app.state.settings
return settings
async def get_db(request: Request) -> AsyncIterator[AsyncSession]:
"""Одна AsyncSession на HTTP-запрос; незакоммиченная транзакция откатывается."""
session_factory = request.app.state.session_factory
async with session_factory() as session:
yield session
async def get_redis(request: Request) -> Redis:
redis: Redis = request.app.state.redis
return redis
def get_s3(request: Request) -> MinioStorage | None:
return request.app.state.s3
def get_upload_capacity(request: Request) -> RequestCapacity:
return request.app.state.upload_capacity
class AuthorizationHeader(SecurityBase):
"""Отдаёт сырой заголовок Authorization и описывает схему для OpenAPI."""
def __init__(self, model: HTTPBase, scheme_name: str) -> None:
self.model = model
self.scheme_name = scheme_name
async def __call__(self, request: Request) -> str | None:
return request.headers.get("Authorization")
basic_auth = AuthorizationHeader(HTTPBase(scheme="basic"), "BasicAuth")
bearer_auth = AuthorizationHeader(HTTPBearer(), "BearerAuth")
def _split_authorization(authorization: str | None) -> tuple[str, str] | None:
if authorization is None:
return None
scheme, _, value = authorization.partition(" ")
if not value.strip():
return None
return scheme.lower(), value.strip()
async def get_bearer_token(
authorization: Annotated[str | None, Security(bearer_auth)],
) -> str:
parts = _split_authorization(authorization)
if parts is None or parts[0] != "bearer":
raise unauthorized_bearer()
return parts[1]
async def get_basic_credentials(
authorization: Annotated[str | None, Security(basic_auth)],
) -> tuple[str, str]:
"""(username, password) из `Authorization: Basic`; пароль может содержать ':'."""
parts = _split_authorization(authorization)
if parts is None or parts[0] != "basic":
raise unauthorized_basic()
try:
decoded = base64.b64decode(parts[1], validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError, ValueError):
raise unauthorized_basic() from None
username, separator, password = decoded.partition(":")
if not separator or not username:
raise unauthorized_basic()
return username, password
DbSession = Annotated[AsyncSession, Depends(get_db)]
RedisClient = Annotated[Redis, Depends(get_redis)]
AppSettings = Annotated[Settings, Depends(get_settings)]
S3Storage = Annotated[MinioStorage | None, Depends(get_s3)]
UploadCapacity = Annotated[RequestCapacity, Depends(get_upload_capacity)]
BearerToken = Annotated[str, Depends(get_bearer_token)]
BasicCredentials = Annotated[tuple[str, str], Depends(get_basic_credentials)]
async def get_current_user(
token: BearerToken, session: DbSession, redis: RedisClient
) -> User:
return await authenticate_token(session, redis, token)
CurrentUser = Annotated[User, Depends(get_current_user)]
+23
View File
@@ -0,0 +1,23 @@
from fastapi import APIRouter, Request
from app.domain import health
from app.schemas.base import Health
router = APIRouter(prefix="/health", tags=["health"])
@router.get("/live")
async def liveness() -> Health:
return health.liveness()
@router.get("/ready")
async def readiness(request: Request) -> Health:
state = request.app.state
return await health.readiness(
state.engine,
state.redis,
state.s3,
state.lifecycle,
state.settings.readiness_timeout_seconds,
)
+42
View File
@@ -0,0 +1,42 @@
from typing import Annotated
from uuid import UUID
from fastapi import APIRouter, Header, Query
from app.domain.idempotency import send_message_idempotent, validate_idempotency_key
from app.domain.messages import list_messages
from app.endpoints.dependencies import AppSettings, CurrentUser, DbSession
from app.schemas.message import CreateMessage, Message, MessagePage
router = APIRouter(prefix="/api/v1/chats", tags=["messages"])
@router.post("/{chat_id}/messages", status_code=201)
async def send_new_message(
chat_id: UUID,
new_message: CreateMessage,
sender: CurrentUser,
session: DbSession,
settings: AppSettings,
idempotency_key: Annotated[str | None, Header(alias="Idempotency-Key")] = None,
) -> Message:
return await send_message_idempotent(
session,
sender,
chat_id,
new_message,
validate_idempotency_key(idempotency_key),
settings.max_messages,
settings.idempotency_ttl_seconds,
)
@router.get("/{chat_id}/messages")
async def get_history_messages(
chat_id: UUID,
user: CurrentUser,
session: DbSession,
limit: Annotated[int, Query(ge=1, le=100)] = 50,
cursor: Annotated[str | None, Query(min_length=1)] = None,
) -> MessagePage:
return await list_messages(session, user, chat_id, cursor, limit)
+17
View File
@@ -0,0 +1,17 @@
from fastapi import APIRouter
from app.domain.users import register_user
from app.endpoints.dependencies import CurrentUser, DbSession
from app.schemas.user import CreateUser, User
router = APIRouter(prefix="/api/v1/users", tags=["users"])
@router.post("", status_code=201)
async def create_user(new_user: CreateUser, session: DbSession) -> User:
return await register_user(session, new_user)
@router.get("/me")
async def get_me(user: CurrentUser) -> User:
return user
View File
+145
View File
@@ -0,0 +1,145 @@
import errno
from collections.abc import Mapping
from PIL import Image, UnidentifiedImageError
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
class ApiError(Exception):
def __init__(
self,
status_code: int,
code: str,
message: str,
headers: Mapping[str, str] | None = None,
) -> None:
super().__init__(message)
self.status_code = status_code
self.code = code
self.message = message
self.headers = headers
def invalid_request(message: str = "Неверный запрос") -> ApiError:
"""Создаёт ошибку некорректного или недопустимого запроса."""
return ApiError(400, "invalid_request", message)
def unauthorized(
message: str = "Нет действительной аутентификации",
www_authenticate: str | None = None,
) -> ApiError:
"""Создаёт ошибку отсутствующей или недействительной аутентификации."""
headers = {"WWW-Authenticate": www_authenticate} if www_authenticate else None
return ApiError(401, "unauthorized", message, headers)
def unauthorized_basic(message: str = "Неверные учётные данные") -> ApiError:
"""401 для POST /auth/sessions (одинаковый для неверного username и пароля)."""
return unauthorized(message, BASIC_CHALLENGE)
def unauthorized_bearer(message: str = "Нет действительной сессии") -> ApiError:
"""401 для бизнес-endpoint: нет, истёк, отозван или неизвестен токен."""
return unauthorized(message, BEARER_CHALLENGE)
def not_found(message: str = "Объект не найден") -> ApiError:
"""Создаёт ошибку, указывающую на отсутствие запрошенного ресурса."""
return ApiError(404, "not_found", message)
def conflict(message: str = "Конфликт") -> ApiError:
"""Создаёт ошибку конфликта с текущим состоянием ресурса."""
return ApiError(409, "conflict", message)
def payload_too_large(message: str = "Слишком большое тело запроса") -> ApiError:
"""Создаёт ошибку, указывающую на превышение допустимого размера запроса."""
return ApiError(413, "payload_too_large", message)
def unsupported_media_type(
message: str = "Требуется Content-Type: application/json",
) -> ApiError:
"""Создаёт ошибку неподдерживаемого формата или типа содержимого запроса."""
return ApiError(415, "unsupported_media_type", message)
def rate_limited(retry_after: int = 1) -> ApiError:
"""Создаёт ошибку превышения допустимой частоты запросов."""
return ApiError(
429,
"rate_limited",
"Слишком много запросов",
{"Retry-After": str(max(1, retry_after))},
)
def unavailable(message: str = "Сервис временно недоступен") -> ApiError:
"""Создаёт ошибку временной недоступности сервиса."""
return ApiError(503, "unavailable", message)
def internal_error() -> ApiError:
"""Создаёт ошибку внутренней ошибки сервера."""
return ApiError(500, "internal_error", "Внутренняя ошибка сервера")
IMAGE_WORKER_ERRORS = (
ApiError,
Image.DecompressionBombError,
Image.DecompressionBombWarning,
MemoryError,
UnidentifiedImageError,
OSError,
ValueError,
SyntaxError,
)
def image_worker_error_code(error: Exception) -> int:
code = 2
resource_error = isinstance(
error,
(Image.DecompressionBombError, Image.DecompressionBombWarning, MemoryError),
)
declared_limit = isinstance(error, ApiError) and error.status_code == 413
if resource_error or declared_limit:
code = 3
return code
def image_validation_error(code: int) -> ApiError:
error = unsupported_media_type("Повреждённое изображение или несовпадение MIME")
if code == 3 or code < 0:
error = payload_too_large("Превышен лимит пикселей или ресурсов изображения")
return error
class ProcessingError(Exception):
"""Постоянная ошибка pipeline с безопасным машинным кодом."""
def __init__(self, code: str) -> None:
super().__init__(code)
self.code = code
class JobOperationError(Exception):
"""Безопасный код отказа операторской команды."""
def __init__(self, code: str):
self.code = code
super().__init__(code)
def pipeline_worker_error_code(error: Exception) -> int:
"""Отделить ошибки файловой системы от ошибки декодирования изображения."""
if isinstance(error, OSError) and error.errno is not None:
if error.errno in {errno.EACCES, errno.EPERM, errno.EROFS, errno.ENOENT}:
return 5
return 4
return image_worker_error_code(error)
+238
View File
@@ -0,0 +1,238 @@
import asyncio
import logging
from contextlib import asynccontextmanager
from collections.abc import Mapping
from uuid import uuid4
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from minio.error import MinioException
from redis.exceptions import ConnectionError as RedisConnectionError
from redis.exceptions import TimeoutError as RedisTimeoutError
from sqlalchemy.exc import DBAPIError, InterfaceError, OperationalError, SQLAlchemyError
from sqlalchemy.exc import TimeoutError as PoolTimeoutError
from starlette.exceptions import HTTPException as StarletteHTTPException
from starlette.requests import ClientDisconnect
from urllib3.exceptions import HTTPError as StorageHTTPError
from app.core.instance import INSTANCE_ID_HEADER
from app.core.request_id import REQUEST_ID_HEADER
from app.errors.exceptions import (
ApiError,
internal_error,
invalid_request,
not_found,
unavailable,
)
logger = logging.getLogger(__name__)
TRANSIENT_SQLSTATE_CLASSES = ("08", "40", "53", "57")
TRANSIENT_SQLSTATES = frozenset({"55P03"})
RECOVERABLE_STORAGE_ERRORS = (
ApiError,
SQLAlchemyError,
MinioException,
StorageHTTPError,
OSError,
TimeoutError,
)
@asynccontextmanager
async def operation_timeout(seconds: float, error: ApiError):
"""Единое преобразование таймаутов; владелец операции задаёт ожидаемую ошибку."""
try:
async with asyncio.timeout(seconds):
yield
except TimeoutError:
raise error from None
async def client_disconnect_handler(request: Request, exc: Exception) -> JSONResponse:
return await api_error_handler(
request, invalid_request("Загрузка прервана клиентом")
)
def log_recoverable_error(operation: str, error: Exception) -> None:
"""Согласованный безопасный лог восстановления без содержимого SDK-ошибки."""
logger.warning("%s deferred: %s", operation, type(error).__name__)
def _get_request_id(request: Request) -> str:
request_id = getattr(request.state, "request_id", None)
if request_id is None:
request_id = str(uuid4())
request.state.request_id = request_id
return request_id
def _build_response(
request: Request,
status_code: int,
code: str,
message: str,
headers: Mapping[str, str] | None = None,
) -> JSONResponse:
request_id = _get_request_id(request)
response_headers = {
**(headers or {}),
REQUEST_ID_HEADER: request_id,
}
instance_id = getattr(request.app.state, "instance_id", None)
if instance_id is not None:
response_headers[INSTANCE_ID_HEADER] = instance_id
body = {
"error": {
"code": code,
"message": message,
"request_id": request_id,
}
}
return JSONResponse(
status_code=status_code,
content=body,
headers=response_headers,
)
async def api_error_handler(
request: Request,
exc: Exception,
) -> JSONResponse:
assert isinstance(exc, ApiError)
return _build_response(
request,
exc.status_code,
exc.code,
exc.message,
exc.headers,
)
async def routing_error_handler(
request: Request,
exc: Exception,
) -> JSONResponse:
assert isinstance(exc, StarletteHTTPException)
error = invalid_request()
if exc.status_code == 404:
error = not_found()
return _build_response(
request,
exc.status_code,
error.code,
error.message,
exc.headers,
)
async def validation_error_handler(
request: Request,
exc: Exception,
) -> JSONResponse:
assert isinstance(exc, RequestValidationError)
fields = sorted({".".join(map(str, error["loc"])) for error in exc.errors()})
message = "Неверный запрос"
if fields:
message = f"{message}: {', '.join(fields)}"
return _build_response(
request,
400,
"invalid_request",
message,
)
async def dependency_unavailable_handler(
request: Request,
exc: Exception,
) -> JSONResponse:
"""PostgreSQL/Redis/S3 недоступны либо исчерпан пул: 503 без внутренних деталей."""
request_id = _get_request_id(request)
logger.error(
"Dependency unavailable request_id=%s: %s",
request_id,
type(exc).__name__,
)
error = unavailable()
return _build_response(
request,
error.status_code,
error.code,
error.message,
{"Retry-After": "1"},
)
def _is_transient_database_error(exc: DBAPIError) -> bool:
sqlstate = getattr(exc.orig, "sqlstate", None) or ""
return (
sqlstate.startswith(TRANSIENT_SQLSTATE_CLASSES)
or sqlstate in TRANSIENT_SQLSTATES
)
async def database_error_handler(
request: Request,
exc: Exception,
) -> JSONResponse:
"""Временные ошибки PostgreSQL (таймаут запроса, блокировки, нехватка ресурсов) — 503."""
assert isinstance(exc, DBAPIError)
handler = unhandled_error_handler
if _is_transient_database_error(exc):
handler = dependency_unavailable_handler
return await handler(request, exc)
async def unhandled_error_handler(
request: Request,
exc: Exception,
) -> JSONResponse:
request_id = _get_request_id(request)
logger.error(
"Unhandled error request_id=%s",
request_id,
exc_info=exc,
)
error = internal_error()
return _build_response(
request,
error.status_code,
error.code,
error.message,
)
def register_exception_handlers(app: FastAPI) -> None:
app.add_exception_handler(ApiError, api_error_handler)
app.add_exception_handler(ClientDisconnect, client_disconnect_handler)
app.add_exception_handler(MinioException, dependency_unavailable_handler)
app.add_exception_handler(StorageHTTPError, dependency_unavailable_handler)
app.add_exception_handler(StarletteHTTPException, routing_error_handler)
app.add_exception_handler(RequestValidationError, validation_error_handler)
app.add_exception_handler(OperationalError, dependency_unavailable_handler)
app.add_exception_handler(InterfaceError, dependency_unavailable_handler)
app.add_exception_handler(PoolTimeoutError, dependency_unavailable_handler)
app.add_exception_handler(DBAPIError, database_error_handler)
app.add_exception_handler(RedisConnectionError, dependency_unavailable_handler)
app.add_exception_handler(RedisTimeoutError, dependency_unavailable_handler)
app.add_exception_handler(OSError, dependency_unavailable_handler)
app.add_exception_handler(Exception, unhandled_error_handler)
+94
View File
@@ -0,0 +1,94 @@
import logging
from collections.abc import AsyncGenerator
from contextlib import asynccontextmanager
import uvicorn
from fastapi import Depends, FastAPI
from app.core.config import Settings
from app.core.database import create_db_engine, create_session_factory
from app.core.instance import InstanceIdMiddleware, resolve_instance_id
from app.core.lifecycle import GracefulServer, Lifecycle
from app.core.redis import create_redis_client
from app.core.request_capacity import acquire_request_slot, create_request_capacity
from app.core.request_id import RequestIdMiddleware
from app.endpoints.auth import router as auth_router
from app.endpoints.attachments import router as attachments_router
from app.endpoints.chats import router as chats_router
from app.endpoints.health import router as health_router
from app.endpoints.messages import router as messages_router
from app.endpoints.users import router as users_router
from app.errors.handlers import register_exception_handlers
from app.storage.s3 import create_s3_storage
def configure_logging(settings: Settings) -> None:
logging.basicConfig(
level=settings.log_level,
format="%(asctime)s %(levelname)s %(name)s %(message)s",
)
def create_app(settings: Settings | None = None) -> FastAPI:
settings = settings or Settings() # type: ignore
configure_logging(settings)
engine = create_db_engine(settings)
redis = create_redis_client(settings)
s3 = create_s3_storage(settings.s3) if settings.s3_enabled else None
@asynccontextmanager
async def lifespan(_: FastAPI) -> AsyncGenerator[None]:
yield
if s3 is not None:
await s3.aclose()
await redis.aclose()
await engine.dispose()
application = FastAPI(title="Messenger", version="1.5.0", lifespan=lifespan)
application.state.settings = settings
application.state.engine = engine
application.state.session_factory = create_session_factory(engine)
application.state.redis = redis
application.state.s3 = s3
application.state.upload_capacity = create_request_capacity(
settings.s3.max_concurrent_uploads
)
application.state.request_capacity = create_request_capacity(settings.max_in_flight)
application.state.instance_id = resolve_instance_id(settings.instance_id)
application.state.lifecycle = Lifecycle()
application.add_middleware(RequestIdMiddleware)
application.add_middleware(
InstanceIdMiddleware, instance_id=application.state.instance_id
)
register_exception_handlers(application)
limited = [Depends(acquire_request_slot)]
application.include_router(health_router)
application.include_router(users_router, dependencies=limited)
application.include_router(auth_router, dependencies=limited)
application.include_router(chats_router, dependencies=limited)
application.include_router(messages_router, dependencies=limited)
application.include_router(attachments_router, dependencies=limited)
return application
def main() -> None:
settings = Settings() # type: ignore
application = create_app(settings)
config = uvicorn.Config(
application,
host=settings.app_host,
port=settings.app_port,
log_level=settings.log_level.lower(),
timeout_graceful_shutdown=settings.graceful_shutdown_timeout_seconds,
)
GracefulServer(
config, application.state.lifecycle, settings.shutdown_drain_seconds
).run()
if __name__ == "__main__":
main()
+25
View File
@@ -0,0 +1,25 @@
from app.models.job_replay import JobReplay
from app.models.base import Base
from app.models.job import AttachmentJob
from app.models.attachment import Attachment, MessageAttachment, UploadIntent
from app.models.chat import Chat
from app.models.chat_member import ChatMember
from app.models.counter import Counter
from app.models.idempotency_key import IdempotencyKey
from app.models.message import Message
from app.models.user import User
__all__ = [
"JobReplay",
"AttachmentJob",
"Base",
"Attachment",
"MessageAttachment",
"UploadIntent",
"Chat",
"ChatMember",
"Counter",
"IdempotencyKey",
"Message",
"User",
]
+71
View File
@@ -0,0 +1,71 @@
"""Метаданные оригиналов и журнал операций до записи в S3."""
import uuid
from datetime import datetime
from sqlalchemy import CheckConstraint, ForeignKey, Index, String, func, text
from sqlalchemy.dialects.postgresql import JSONB
from sqlalchemy.orm import Mapped, mapped_column
from app.models.base import Base
class Attachment(Base):
__tablename__ = "attachments"
__table_args__ = (
CheckConstraint("size_bytes BETWEEN 1 AND 10485760", name="size_bytes"),
CheckConstraint(
"content_type IN ('image/png', 'image/jpeg')", name="content_type"
),
CheckConstraint("sha256 ~ '^[a-f0-9]{64}$'", name="sha256"),
CheckConstraint(
"status IN ('queued', 'processing', 'ready', 'failed')", name="status"
),
CheckConstraint(
"(status = 'failed' AND error_code IS NOT NULL) OR (status <> 'failed' AND error_code IS NULL)",
name="error_code",
),
Index("ix_attachments_chat_id", "chat_id"),
)
id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
chat_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("chats.id"))
owner_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"))
object_key: Mapped[str] = mapped_column(String(128), unique=True)
filename: Mapped[str] = mapped_column(String(255))
content_type: Mapped[str] = mapped_column(String(32))
size_bytes: Mapped[int]
sha256: Mapped[str] = mapped_column(String(64))
status: Mapped[str] = mapped_column(String(16), server_default="queued")
error_code: Mapped[str | None] = mapped_column(String(64))
thumbnail_key: Mapped[str | None] = mapped_column(String(128))
crop_key: Mapped[str | None] = mapped_column(String(128))
optimized_key: Mapped[str | None] = mapped_column(String(128))
variants: Mapped[list[dict]] = mapped_column(
JSONB, default=list, server_default=text("'[]'::jsonb")
)
created_at: Mapped[datetime] = mapped_column(server_default=func.clock_timestamp())
updated_at: Mapped[datetime] = mapped_column(server_default=func.clock_timestamp())
class MessageAttachment(Base):
__tablename__ = "message_attachments"
message_id: Mapped[uuid.UUID] = mapped_column(
ForeignKey("messages.id", ondelete="CASCADE"), primary_key=True
)
attachment_id: Mapped[uuid.UUID] = mapped_column(
ForeignKey("attachments.id"), primary_key=True
)
position: Mapped[int]
class UploadIntent(Base):
"""Фиксируется до PUT; удаляется атомарно с принятием queued metadata/job."""
__tablename__ = "upload_intents"
__table_args__ = (Index("ix_upload_intents_created_at", "created_at"),)
id: Mapped[uuid.UUID] = mapped_column(primary_key=True)
object_key: Mapped[str] = mapped_column(String(128), unique=True)
created_at: Mapped[datetime] = mapped_column(server_default=func.clock_timestamp())
+27
View File
@@ -0,0 +1,27 @@
import uuid
from datetime import datetime
from typing import Any, ClassVar
from sqlalchemy import DateTime, MetaData
from sqlalchemy.dialects.postgresql import UUID as PG_UUID
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.types import TypeEngine
NAMING_CONVENTION = {
"ix": "ix_%(column_0_label)s",
"uq": "uq_%(table_name)s_%(column_0_name)s",
"ck": "ck_%(table_name)s_%(constraint_name)s",
"fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
"pk": "pk_%(table_name)s",
}
class Base(DeclarativeBase):
"""Базовый класс ORM-моделей."""
metadata = MetaData(naming_convention=NAMING_CONVENTION)
type_annotation_map: ClassVar[dict[Any, TypeEngine[Any]]] = {
uuid.UUID: PG_UUID(as_uuid=True),
datetime: DateTime(timezone=True),
}
+32
View File
@@ -0,0 +1,32 @@
import uuid
from datetime import datetime
from typing import TYPE_CHECKING
from sqlalchemy import String, func
from sqlalchemy.orm import Mapped, mapped_column, relationship
from app.models.base import Base
if TYPE_CHECKING:
from app.models.chat_member import ChatMember
from app.models.message import Message
class Chat(Base):
"""Чат с фиксированным составом участников."""
__tablename__ = "chats"
id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
title: Mapped[str] = mapped_column(String(100))
created_at: Mapped[datetime] = mapped_column(server_default=func.now())
members: Mapped[list["ChatMember"]] = relationship(
back_populates="chat",
cascade="all, delete-orphan",
passive_deletes=True,
lazy="selectin",
)
messages: Mapped[list["Message"]] = relationship(
back_populates="chat", lazy="raise"
)
+26
View File
@@ -0,0 +1,26 @@
import uuid
from typing import TYPE_CHECKING
from sqlalchemy import ForeignKey, Index
from sqlalchemy.orm import Mapped, mapped_column, relationship
from app.models.base import Base
if TYPE_CHECKING:
from app.models.chat import Chat
from app.models.user import User
class ChatMember(Base):
"""Членство пользователя в чате."""
__tablename__ = "chat_members"
__table_args__ = (Index("ix_chat_members_user_id_chat_id", "user_id", "chat_id"),)
chat_id: Mapped[uuid.UUID] = mapped_column(
ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True
)
user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"), primary_key=True)
chat: Mapped["Chat"] = relationship(back_populates="members", lazy="raise")
user: Mapped["User"] = relationship(back_populates="memberships", lazy="raise")
+13
View File
@@ -0,0 +1,13 @@
from sqlalchemy import BigInteger, String
from sqlalchemy.orm import Mapped, mapped_column
from app.models.base import Base
class Counter(Base):
"""Именованный счётчик с атомарным обновлением."""
__tablename__ = "counters"
name: Mapped[str] = mapped_column(String(64), primary_key=True)
value: Mapped[int] = mapped_column(BigInteger)
+24
View File
@@ -0,0 +1,24 @@
"""Сохранённый результат отправки сообщения."""
import uuid
from datetime import datetime
from sqlalchemy import ForeignKey, Index, String, func
from sqlalchemy.orm import Mapped, mapped_column
from app.models.base import Base
class IdempotencyKey(Base):
"""Ключ запроса и связанное сообщение."""
__tablename__ = "idempotency_keys"
__table_args__ = (Index("ix_idempotency_keys_created_at", "created_at"),)
user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"), primary_key=True)
method: Mapped[str] = mapped_column(String(8), primary_key=True)
path: Mapped[str] = mapped_column(String(255), primary_key=True)
key: Mapped[str] = mapped_column(String(128), primary_key=True)
request_hash: Mapped[str] = mapped_column(String(64))
message_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("messages.id"))
created_at: Mapped[datetime] = mapped_column(server_default=func.clock_timestamp())
+40
View File
@@ -0,0 +1,40 @@
"""Устойчивая работа и намерение публикации; один pipeline на вложение."""
from datetime import datetime
from uuid import UUID, uuid4
from sqlalchemy import CheckConstraint, ForeignKey, Index, String, func
from sqlalchemy.orm import Mapped, mapped_column
from app.models.base import Base
class AttachmentJob(Base):
__tablename__ = "attachment_jobs"
__table_args__ = (
CheckConstraint("pipeline_version = 1", name="pipeline_version"),
CheckConstraint("attempt >= 0 AND published_attempt >= 0", name="attempt"),
Index("ix_attachment_jobs_due", "next_attempt_at"),
Index("ix_attachment_jobs_lease", "lease_until"),
)
id: Mapped[UUID] = mapped_column(primary_key=True, default=uuid4)
attachment_id: Mapped[UUID] = mapped_column(
ForeignKey("attachments.id"),
unique=True,
)
staging_key: Mapped[str | None] = mapped_column(String(128))
pipeline_version: Mapped[int] = mapped_column(server_default="1")
attempt: Mapped[int] = mapped_column(server_default="0")
cycle_start_attempt: Mapped[int] = mapped_column(server_default="0")
attempt_limit: Mapped[int | None]
last_error_permanent: Mapped[bool | None]
published_attempt: Mapped[int] = mapped_column(server_default="0")
next_attempt_at: Mapped[datetime] = mapped_column(
server_default=func.clock_timestamp()
)
lease_token: Mapped[UUID | None]
lease_until: Mapped[datetime | None]
last_error_code: Mapped[str | None] = mapped_column(String(64))
finished_at: Mapped[datetime | None]
created_at: Mapped[datetime] = mapped_column(server_default=func.clock_timestamp())
+22
View File
@@ -0,0 +1,22 @@
"""Аудит явного повторного запуска failed; request id обеспечивает идемпотентность."""
from datetime import datetime
from uuid import UUID
from sqlalchemy import ForeignKey, String, func
from sqlalchemy.orm import Mapped, mapped_column
from app.models.base import Base
class JobReplay(Base):
__tablename__ = "job_replays"
id: Mapped[UUID] = mapped_column(primary_key=True)
job_id: Mapped[UUID] = mapped_column(ForeignKey("attachment_jobs.id"), index=True)
actor: Mapped[str] = mapped_column(String(64))
reason: Mapped[str] = mapped_column(String(32))
previous_attempt: Mapped[int]
attempt_limit: Mapped[int]
previous_error_code: Mapped[str | None] = mapped_column(String(64))
created_at: Mapped[datetime] = mapped_column(server_default=func.clock_timestamp())
+30
View File
@@ -0,0 +1,30 @@
import uuid
from datetime import datetime
from typing import TYPE_CHECKING
from sqlalchemy import ForeignKey, Index, Text, func
from sqlalchemy.orm import Mapped, mapped_column, relationship
from app.models.base import Base
if TYPE_CHECKING:
from app.models.chat import Chat
from app.models.user import User
class Message(Base):
"""Сообщение в чате."""
__tablename__ = "messages"
__table_args__ = (
Index("ix_messages_chat_id_created_at_id", "chat_id", "created_at", "id"),
)
id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
chat_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("chats.id"))
sender_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"))
text: Mapped[str] = mapped_column(Text)
created_at: Mapped[datetime] = mapped_column(server_default=func.clock_timestamp())
chat: Mapped["Chat"] = relationship(back_populates="messages", lazy="raise")
sender: Mapped["User"] = relationship(back_populates="messages", lazy="raise")
+31
View File
@@ -0,0 +1,31 @@
import uuid
from datetime import datetime
from typing import TYPE_CHECKING
from sqlalchemy import String, func
from sqlalchemy.orm import Mapped, mapped_column, relationship
from app.models.base import Base
if TYPE_CHECKING:
from app.models.chat_member import ChatMember
from app.models.message import Message
class User(Base):
"""Пользователь и его учётные данные."""
__tablename__ = "users"
id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
username: Mapped[str] = mapped_column(String(32), unique=True)
display_name: Mapped[str] = mapped_column(String(100))
password_hash: Mapped[str] = mapped_column(String(255))
created_at: Mapped[datetime] = mapped_column(server_default=func.now())
memberships: Mapped[list["ChatMember"]] = relationship(
back_populates="user", lazy="raise"
)
messages: Mapped[list["Message"]] = relationship(
back_populates="sender", lazy="raise"
)
+6
View File
@@ -0,0 +1,6 @@
from app.schemas.chat import Chat
from app.schemas.message import Message
from app.schemas.session import AuthSession
from app.schemas.user import User
__all__ = ["AuthSession", "Chat", "Message", "User"]
+53
View File
@@ -0,0 +1,53 @@
"""Публичные состояния и варианты; внутренние ключи S3 не сериализуются."""
from datetime import datetime
from typing import Literal
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_validator
from app.schemas.base import Base
class Variant(BaseModel):
model_config = ConfigDict(extra="forbid", from_attributes=True)
name: Literal["thumbnail", "crop", "optimized"]
content_type: Literal["image/jpeg", "image/png", "image/webp"]
size_bytes: int = Field(ge=1)
width: int = Field(ge=1)
height: int = Field(ge=1)
sha256: str = Field(pattern=r"^[a-f0-9]{64}$")
class Attachment(Base):
chat_id: UUID
owner_id: UUID
filename: str = Field(min_length=1, max_length=255)
content_type: Literal["image/png", "image/jpeg"]
size_bytes: int = Field(ge=1, le=10_485_760)
sha256: str = Field(pattern=r"^[a-f0-9]{64}$")
status: Literal["queued", "processing", "ready", "failed"]
variants: list[Variant] = Field(default_factory=list)
error_code: str | None = None
created_at: datetime
updated_at: datetime
VARIANT_FILENAMES = {
"thumbnail": "thumbnail.jpg",
"crop": "crop.jpg",
"optimized": "optimized.webp",
}
class PipelineResult(BaseModel):
model_config = ConfigDict(extra="forbid")
variants: list[Variant] = Field(min_length=3, max_length=3)
@field_validator("variants")
@classmethod
def require_all_variants(cls, variants: list[Variant]) -> list[Variant]:
if {item.name for item in variants} != set(VARIANT_FILENAMES):
raise ValueError("Нужны thumbnail, crop и optimized без повторов")
return variants
+35
View File
@@ -0,0 +1,35 @@
from typing import Literal
from uuid import UUID
from pydantic import BaseModel, ConfigDict, field_validator
class Base(BaseModel):
model_config = ConfigDict(extra="forbid", from_attributes=True)
id: UUID
class Health(BaseModel):
model_config = ConfigDict(extra="forbid")
status: Literal["ok"]
class BaseCreate(BaseModel):
model_config = ConfigDict(extra="forbid")
@field_validator("*", mode="before")
@classmethod
def reject_invalid_strings(cls, value: object) -> object:
"""Отклоняет строки из одних пробелов и строки с NUL, который не хранит PostgreSQL."""
if isinstance(value, str):
if not value.strip():
raise ValueError("Строка не может состоять только из пробелов")
if "\x00" in value:
raise ValueError("Строка не может содержать символ NUL")
return value
class BasePage(BaseModel):
model_config = ConfigDict(extra="forbid")
+22
View File
@@ -0,0 +1,22 @@
from datetime import datetime
from uuid import UUID
from pydantic import Field
from app.schemas.base import Base, BaseCreate, BasePage
class Chat(Base):
title: str = Field(min_length=1, max_length=100)
member_ids: list[UUID] = Field(min_length=1, max_length=100)
created_at: datetime
class CreateChat(BaseCreate):
title: str = Field(min_length=1, max_length=100)
member_ids: list[UUID] = Field(min_length=1, max_length=100)
class ChatPage(BasePage):
items: list[Chat]
next_cursor: str | None
+22
View File
@@ -0,0 +1,22 @@
"""Сообщение брокера: только идентификаторы и служебные поля контракта v1."""
from typing import Literal
from uuid import UUID
from pydantic import AwareDatetime, BaseModel, ConfigDict, Field
class JobMessage(BaseModel):
model_config = ConfigDict(extra="forbid")
schema_version: Literal[1] = 1
type: Literal["attachment.process.v1"] = "attachment.process.v1"
job_id: UUID
attachment_id: UUID
pipeline_version: int = Field(default=1, ge=1)
attempt: int = Field(ge=1)
created_at: AwareDatetime
traceparent: str | None = Field(
default=None, pattern=r"^00-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$"
)
tracestate: str | None = Field(default=None, max_length=512)
+41
View File
@@ -0,0 +1,41 @@
from datetime import datetime
from typing import Self
from uuid import UUID
from pydantic import Field, field_validator, model_validator
from app.schemas.base import Base, BaseCreate, BasePage
class Message(Base):
chat_id: UUID
sender_id: UUID
text: str = Field(max_length=4000)
attachment_ids: list[UUID] = Field(default_factory=list, max_length=10)
created_at: datetime
class CreateMessage(BaseCreate):
text: str = Field(max_length=4000)
attachment_ids: list[UUID] = Field(default_factory=list, max_length=10)
@field_validator("*", mode="before")
@classmethod
def reject_invalid_strings(cls, value: object) -> object:
if isinstance(value, str):
if "\x00" in value or (value != "" and not value.strip()):
raise ValueError("Некорректная строка сообщения")
return value
@model_validator(mode="after")
def require_content(self) -> Self:
if not self.text and not self.attachment_ids:
raise ValueError("Нужен текст или вложение")
if len(self.attachment_ids) != len(set(self.attachment_ids)):
raise ValueError("attachment_ids содержит дубликаты")
return self
class MessagePage(BasePage):
items: list[Message]
next_cursor: str | None
+17
View File
@@ -0,0 +1,17 @@
from datetime import datetime
from typing import Literal
from pydantic import BaseModel, ConfigDict, Field
from app.schemas.user import User
class AuthSession(BaseModel):
"""Ответ POST /auth/sessions (в OpenAPI — Session)."""
model_config = ConfigDict(extra="forbid")
token: str = Field(min_length=32)
token_type: Literal["Bearer"] = "Bearer"
expires_at: datetime
user: User
+25
View File
@@ -0,0 +1,25 @@
from datetime import datetime
from pydantic import Field
from app.schemas.base import Base, BaseCreate
USERNAME_PATTERN = r"^[a-z0-9_]{3,32}$"
PASSWORD_MIN_LENGTH = 12
PASSWORD_MAX_LENGTH = 128
class User(Base):
"""Публичное представление пользователя. Пароль/хеш сюда не попадают никогда."""
username: str = Field(pattern=USERNAME_PATTERN)
display_name: str = Field(min_length=1, max_length=100)
created_at: datetime
class CreateUser(BaseCreate):
username: str = Field(pattern=USERNAME_PATTERN)
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(
min_length=PASSWORD_MIN_LENGTH, max_length=PASSWORD_MAX_LENGTH, repr=False
)
+1
View File
@@ -0,0 +1 @@
"""Доступ к данным PostgreSQL и Redis."""
+99
View File
@@ -0,0 +1,99 @@
"""SQL-запросы метаданных и журнала; commit выполняется в domain."""
from datetime import timedelta
from uuid import UUID
from sqlalchemy import delete, func, select
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.attachment import Attachment, MessageAttachment, UploadIntent
async def create_attachment(session: AsyncSession, **values) -> Attachment:
record = Attachment(**values)
session.add(record)
await session.flush()
return record
async def get_attachment(
session: AsyncSession, attachment_id: UUID
) -> Attachment | None:
return await session.get(Attachment, attachment_id)
async def get_by_key(session: AsyncSession, key: str) -> Attachment | None:
return await session.scalar(select(Attachment).where(Attachment.object_key == key))
async def get_for_chat(
session: AsyncSession, chat_id: UUID, attachment_ids: list[UUID]
) -> list[Attachment]:
records = []
if attachment_ids:
records = list(
await session.scalars(
select(Attachment).where(
Attachment.id.in_(attachment_ids),
Attachment.chat_id == chat_id,
)
)
)
return records
async def bind_attachments(
session: AsyncSession, message_id: UUID, attachment_ids: list[UUID]
) -> None:
session.add_all(
MessageAttachment(message_id=message_id, attachment_id=id, position=position)
for position, id in enumerate(attachment_ids)
)
await session.flush()
async def message_attachment_ids(
session: AsyncSession, message_ids: list[UUID]
) -> dict[UUID, list[UUID]]:
result: dict[UUID, list[UUID]] = {id: [] for id in message_ids}
if not message_ids:
return result
rows = await session.execute(
select(MessageAttachment)
.where(MessageAttachment.message_id.in_(message_ids))
.order_by(MessageAttachment.position)
)
for link in rows.scalars():
result[link.message_id].append(link.attachment_id)
return result
async def reserve_upload(session: AsyncSession, id: UUID, key: str) -> None:
session.add(UploadIntent(id=id, object_key=key))
await session.flush()
async def lock_upload(session: AsyncSession, id: UUID) -> UploadIntent | None:
return await session.scalar(
select(UploadIntent).where(UploadIntent.id == id).with_for_update()
)
async def finish_upload(session: AsyncSession, id: UUID) -> None:
await session.execute(delete(UploadIntent).where(UploadIntent.id == id))
async def stale_uploads(
session: AsyncSession, grace_seconds: int, limit: int
) -> list[UploadIntent]:
result = await session.scalars(
select(UploadIntent)
.where(
UploadIntent.created_at
< func.clock_timestamp() - timedelta(seconds=grace_seconds),
)
.order_by(UploadIntent.created_at)
.limit(limit)
.with_for_update(skip_locked=True)
)
return list(result)
+94
View File
@@ -0,0 +1,94 @@
"""RabbitMQ: durable queue, persistent messages, publisher confirms и manual ack."""
import asyncio
import logging
from dataclasses import dataclass
import aio_pika
from aio_pika.abc import AbstractIncomingMessage
from app.core.jobs import JobSettings
from app.schemas.job import JobMessage
@dataclass(frozen=True)
class Delivery:
id: AbstractIncomingMessage
payload: bytes
class JobBroker:
"""Один consumer/канал на экземпляр; publisher использует отдельный экземпляр."""
def __init__(self, settings: JobSettings) -> None:
self.settings = settings
self.connection = self.channel = self.queue = self.iterator = None
# Transport exceptions могут содержать URL с credentials.
logging.getLogger("aio_pika").setLevel(logging.CRITICAL)
logging.getLogger("aiormq").setLevel(logging.CRITICAL)
async def ensure_ready(self) -> None:
if (
self.connection is None
or self.connection.is_closed
or self.channel is None
or self.channel.is_closed
):
await self.aclose()
self.connection = await aio_pika.connect(
host=self.settings.broker_host,
port=self.settings.broker_port,
login=self.settings.broker_user,
password=self.settings.broker_password_file.read_text().strip(),
virtualhost=self.settings.broker_vhost,
timeout=5,
heartbeat=30,
)
self.channel = await self.connection.channel(
publisher_confirms=True, on_return_raises=True
)
await self.channel.set_qos(prefetch_count=1)
self.queue = await self.channel.declare_queue(
self.settings.broker_queue, durable=True
)
async def publish_job(self, message: JobMessage) -> None:
await self.ensure_ready()
await self.channel.default_exchange.publish(
aio_pika.Message(
body=message.model_dump_json(exclude_none=True).encode(),
content_type="application/json",
delivery_mode=aio_pika.DeliveryMode.PERSISTENT,
message_id=f"{message.job_id}:{message.attempt}",
),
routing_key=self.settings.broker_queue,
mandatory=True,
timeout=10,
)
async def receive(self, consumer: str) -> Delivery:
await self.ensure_ready()
if self.iterator is None:
self.iterator = self.queue.iterator(no_ack=False, consumer_tag=consumer)
await self.iterator.__aenter__()
message = await self.iterator.__anext__()
return Delivery(message, message.body)
async def acknowledge_job(self, delivery_id: AbstractIncomingMessage) -> None:
await delivery_id.ack()
async def defer_job(self, delivery_id: AbstractIncomingMessage) -> None:
# Живая чужая lease: не удерживать единственный prefetch slot навсегда.
await asyncio.sleep(self.settings.publisher_poll_seconds)
await delivery_id.nack(requeue=True)
async def reject_invalid(self, delivery_id: AbstractIncomingMessage) -> None:
# Failed jobs находятся в PostgreSQL; неизвестные payload не копируются в DLQ.
logging.getLogger(__name__).warning("Rejected invalid job envelope")
await delivery_id.reject(requeue=False)
async def aclose(self) -> None:
connection = self.connection
self.connection = self.channel = self.queue = self.iterator = None
if connection is not None and not connection.is_closed:
await connection.close()
+71
View File
@@ -0,0 +1,71 @@
from collections.abc import Sequence
from uuid import UUID
from sqlalchemy import exists, select, tuple_
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.chat import Chat
from app.models.chat_member import ChatMember
from app.storage.types import Position
async def create_chat(
session: AsyncSession,
*,
title: str,
member_ids: Sequence[UUID],
) -> Chat:
"""Добавляет чат вместе с участниками."""
chat = Chat(
title=title,
members=[ChatMember(user_id=user_id) for user_id in member_ids],
)
session.add(chat)
await session.flush()
return chat
async def get_chat_for_member(
session: AsyncSession,
chat_id: UUID,
user_id: UUID,
) -> Chat | None:
"""Возвращает чат, если пользователь в нём состоит, иначе None."""
stmt = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(Chat.id == chat_id, ChatMember.user_id == user_id)
)
result = await session.execute(stmt)
chat = result.scalar_one_or_none()
return chat
async def is_chat_member(session: AsyncSession, chat_id: UUID, user_id: UUID) -> bool:
"""Возвращает True, если пользователь состоит в чате; одна проверка по PK."""
stmt = select(
exists().where(ChatMember.chat_id == chat_id, ChatMember.user_id == user_id)
)
result = await session.execute(stmt)
is_member = bool(result.scalar_one())
return is_member
async def list_chats_for_user(
session: AsyncSession,
user_id: UUID,
after: Position | None,
limit: int,
) -> list[Chat]:
"""Возвращает чаты пользователя по (created_at, id) строго после позиции after."""
stmt = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(ChatMember.user_id == user_id)
)
if after is not None:
stmt = stmt.where(tuple_(Chat.created_at, Chat.id) > tuple_(*after))
stmt = stmt.order_by(Chat.created_at, Chat.id).limit(limit)
result = await session.execute(stmt)
chats = list(result.scalars().all())
return chats
+15
View File
@@ -0,0 +1,15 @@
"""Простые проверки соединения с общими хранилищами."""
from redis.asyncio import Redis
from sqlalchemy import text
from sqlalchemy.ext.asyncio import AsyncEngine
async def check_database(engine: AsyncEngine) -> bool:
async with engine.connect() as connection:
await connection.execute(text("SELECT 1"))
return True
async def check_redis(client: Redis) -> bool:
return bool(await client.ping())
+70
View File
@@ -0,0 +1,70 @@
"""Хранение и блокировка ключей в PostgreSQL."""
from datetime import timedelta
import hashlib
import json
from uuid import UUID
from sqlalchemy import BigInteger, func, literal, select, tuple_
from sqlalchemy.dialects.postgresql import insert
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.idempotency_key import IdempotencyKey
Scope = tuple[UUID, str, str, str]
async def lock_key(session: AsyncSession, scope: Scope) -> None:
"""Сериализует один ключ до конца транзакции."""
raw = json.dumps([str(scope[0]), *scope[1:]]).encode()
lock_id = int.from_bytes(hashlib.sha256(raw).digest()[:8], signed=True)
await session.execute(
select(func.pg_advisory_xact_lock(literal(lock_id, type_=BigInteger)))
)
async def get_active_key(
session: AsyncSession, scope: Scope, ttl_seconds: int
) -> IdempotencyKey | None:
"""Читает результат, пока срок ключа не истёк."""
stmt = select(IdempotencyKey).where(
tuple_(
IdempotencyKey.user_id,
IdempotencyKey.method,
IdempotencyKey.path,
IdempotencyKey.key,
)
== tuple_(*scope),
IdempotencyKey.created_at
> func.clock_timestamp() - timedelta(seconds=ttl_seconds),
)
return await session.scalar(stmt)
async def save_result(
session: AsyncSession, scope: Scope, request_hash: str, message_id: UUID
) -> None:
"""Сохраняет новый результат или заменяет истёкший."""
stmt = insert(IdempotencyKey).values(
user_id=scope[0],
method=scope[1],
path=scope[2],
key=scope[3],
request_hash=request_hash,
message_id=message_id,
)
await session.execute(
stmt.on_conflict_do_update(
index_elements=[
IdempotencyKey.user_id,
IdempotencyKey.method,
IdempotencyKey.path,
IdempotencyKey.key,
],
set_={
"request_hash": request_hash,
"message_id": message_id,
"created_at": func.clock_timestamp(),
},
)
)
+59
View File
@@ -0,0 +1,59 @@
"""Операторские выборки и журнал replay; транзакция принадлежит domain."""
from sqlalchemy import select
from sqlalchemy.dialects.postgresql import insert
from app.models.attachment import Attachment
from app.models.job import AttachmentJob
from app.models.job_replay import JobReplay
async def failed_jobs(session, limit: int):
result = await session.execute(
select(AttachmentJob, Attachment)
.join(Attachment, Attachment.id == AttachmentJob.attachment_id)
.where(Attachment.status == "failed")
.order_by(AttachmentJob.finished_at.desc(), AttachmentJob.id)
.limit(limit)
)
return result.all()
async def replay_record(session, request_id):
return await session.get(JobReplay, request_id)
async def insert_replay(session, **values) -> bool:
result = await session.scalar(
insert(JobReplay)
.values(**values)
.on_conflict_do_nothing(index_elements=[JobReplay.id])
.returning(JobReplay.id)
)
return result is not None
async def replay_history(session, job_id):
return (
await session.scalars(
select(JobReplay)
.where(JobReplay.job_id == job_id)
.order_by(JobReplay.created_at)
.limit(100)
)
).all()
def reset_failed(job, attachment, now, attempt_limit):
job.cycle_start_attempt = job.attempt
job.attempt_limit = attempt_limit
job.published_attempt = job.attempt
job.next_attempt_at = now
job.lease_token = None
job.lease_until = None
job.finished_at = None
job.last_error_code = None
job.last_error_permanent = None
attachment.status = "queued"
attachment.error_code = None
attachment.updated_at = now
+160
View File
@@ -0,0 +1,160 @@
"""SQL и изменения jobs/attachments; commit остаётся в domain."""
from dataclasses import dataclass
from datetime import datetime, timedelta
from uuid import UUID
from sqlalchemy import and_, or_, func, select
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.attachment import Attachment
from app.models.job import AttachmentJob
from app.schemas.attachment import VARIANT_FILENAMES
@dataclass(frozen=True)
class JobWork:
job_id: UUID
attachment_id: UUID
lease_token: UUID
pipeline_version: int
staging_key: str
content_type: str
size_bytes: int
sha256: str
@property
def original_key(self) -> str:
return f"originals/{self.attachment_id.hex}/v{self.pipeline_version}"
def variant_key(self, name: str) -> str:
filename = VARIANT_FILENAMES[name]
return f"variants/{self.attachment_id.hex}/v{self.pipeline_version}/{filename}"
async def create_job(
session: AsyncSession, attachment_id: UUID, staging_key: str
) -> UUID:
job = AttachmentJob(attachment_id=attachment_id, staging_key=staging_key)
session.add(job)
await session.flush()
return job.id
async def lock_job(session: AsyncSession, job_id: UUID):
result = await session.execute(
select(AttachmentJob, Attachment)
.join(Attachment, Attachment.id == AttachmentJob.attachment_id)
.where(AttachmentJob.id == job_id)
.with_for_update(of=AttachmentJob)
.execution_options(populate_existing=True)
)
return result.one_or_none()
async def database_time(session: AsyncSession) -> datetime:
return await session.scalar(select(func.clock_timestamp()))
async def expired_jobs(session: AsyncSession, limit: int = 20):
result = await session.execute(
select(AttachmentJob, Attachment)
.join(Attachment, Attachment.id == AttachmentJob.attachment_id)
.where(
Attachment.status == "processing",
AttachmentJob.lease_until < func.clock_timestamp(),
)
.order_by(AttachmentJob.lease_until)
.limit(limit)
.with_for_update(of=AttachmentJob, skip_locked=True)
)
return result.all()
def start_job(
job, attachment, token: UUID, now: datetime, lease_seconds: int
) -> JobWork:
job.attempt += 1
job.lease_token = token
job.lease_until = now + timedelta(seconds=lease_seconds)
attachment.status = "processing"
attachment.updated_at = now
return JobWork(
job.id,
attachment.id,
token,
job.pipeline_version,
job.staging_key,
attachment.content_type,
attachment.size_bytes,
attachment.sha256,
)
def record_failure(
job,
attachment,
now: datetime,
error_code: str,
*,
terminal: bool,
retry_seconds: float,
) -> None:
job.lease_token = None
job.lease_until = None
job.last_error_code = error_code
job.next_attempt_at = now + timedelta(seconds=retry_seconds)
job.finished_at = now if terminal else None
attachment.status = "failed" if terminal else "queued"
attachment.error_code = error_code if terminal else None
attachment.updated_at = now
def complete_job(
job, attachment, work: JobWork, variants: list[dict], now: datetime
) -> None:
attachment.object_key = work.original_key
attachment.thumbnail_key = work.variant_key("thumbnail")
attachment.crop_key = work.variant_key("crop")
attachment.optimized_key = work.variant_key("optimized")
attachment.variants = variants
attachment.status = "ready"
attachment.error_code = None
attachment.updated_at = now
job.lease_token = None
job.lease_until = None
job.last_error_code = None
job.last_error_permanent = None
job.finished_at = now
async def terminal_staging(
session: AsyncSession, retention: int, failed_retention: int, limit: int = 20
):
result = await session.execute(
select(AttachmentJob, Attachment)
.join(Attachment, Attachment.id == AttachmentJob.attachment_id)
.where(
AttachmentJob.staging_key.is_not(None),
or_(
and_(
Attachment.status == "ready",
AttachmentJob.finished_at
< func.clock_timestamp() - timedelta(seconds=retention),
),
and_(
Attachment.status == "failed",
AttachmentJob.finished_at
< func.clock_timestamp() - timedelta(seconds=failed_retention),
),
),
)
.order_by(AttachmentJob.finished_at)
.limit(limit)
.with_for_update(of=AttachmentJob, skip_locked=True)
)
return result.all()
def clear_staging(job) -> None:
job.staging_key = None
+62
View File
@@ -0,0 +1,62 @@
from uuid import UUID
from sqlalchemy import select, tuple_
from sqlalchemy.dialects.postgresql import insert
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.counter import Counter
from app.models.message import Message
from app.storage.types import Position
MESSAGES_COUNTER = "messages"
async def get_message(session: AsyncSession, message_id: UUID) -> Message | None:
return await session.get(Message, message_id)
async def create_message(
session: AsyncSession,
*,
chat_id: UUID,
sender_id: UUID,
text: str,
) -> Message:
"""Добавляет сообщение; id и created_at назначает сервер."""
message = Message(chat_id=chat_id, sender_id=sender_id, text=text)
session.add(message)
await session.flush()
return message
async def list_messages(
session: AsyncSession,
chat_id: UUID,
after: Position | None,
limit: int,
) -> list[Message]:
"""Возвращает сообщения чата по (created_at, id) строго после позиции after."""
stmt = select(Message).where(Message.chat_id == chat_id)
if after is not None:
stmt = stmt.where(tuple_(Message.created_at, Message.id) > tuple_(*after))
stmt = stmt.order_by(Message.created_at, Message.id).limit(limit)
result = await session.execute(stmt)
messages = list(result.scalars().all())
return messages
async def reserve_message_slot(session: AsyncSession, max_messages: int) -> bool:
"""Атомарно увеличивает счётчик сообщений, если лимит не исчерпан."""
stmt = (
insert(Counter)
.values(name=MESSAGES_COUNTER, value=1)
.on_conflict_do_update(
index_elements=[Counter.name],
set_={"value": Counter.value + 1},
where=Counter.value < max_messages,
)
.returning(Counter.value)
)
result = await session.execute(stmt)
is_reserved = result.scalar_one_or_none() is not None
return is_reserved
+33
View File
@@ -0,0 +1,33 @@
"""Jobs одновременно хранят намерение публикации очередной попытки."""
from uuid import UUID
from sqlalchemy import func, select
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.attachment import Attachment
from app.models.job import AttachmentJob
async def next_unpublished_job(
session: AsyncSession, *, attachment_id: UUID | None = None
) -> AttachmentJob | None:
statement = (
select(AttachmentJob)
.join(Attachment, Attachment.id == AttachmentJob.attachment_id)
.where(
Attachment.status == "queued",
AttachmentJob.next_attempt_at <= func.clock_timestamp(),
AttachmentJob.published_attempt <= AttachmentJob.attempt,
)
.order_by(AttachmentJob.next_attempt_at, AttachmentJob.id)
.limit(1)
.with_for_update(of=AttachmentJob, skip_locked=True)
)
if attachment_id is not None:
statement = statement.where(AttachmentJob.attachment_id == attachment_id)
return await session.scalar(statement)
def mark_published(job: AttachmentJob) -> None:
job.published_attempt = job.attempt + 1
+180
View File
@@ -0,0 +1,180 @@
"""MinIO SDK выполняется в потоках; ресурсы живут до конца операции."""
import asyncio
from collections.abc import Callable
from contextlib import suppress
from dataclasses import dataclass
from datetime import datetime
from pathlib import Path
from typing import TypeVar
import time
from urllib.parse import urlsplit
from anyio import CancelScope
from minio import Minio
import urllib3
from app.core.s3 import S3Settings
T = TypeVar("T")
async def run_sync(
operation: Callable[..., T], *args, discard_result=None, **kwargs
) -> T:
"""При отмене дождаться потока: иначе PUT может догнать компенсацию удаления."""
task = asyncio.create_task(asyncio.to_thread(operation, *args, **kwargs))
try:
result = await asyncio.shield(task)
except asyncio.CancelledError:
with CancelScope(shield=True):
await settle_cancelled_call(task, discard_result)
raise
return result
async def settle_cancelled_call(
task: asyncio.Task, discard_result: Callable | None
) -> None:
"""wait не переносит исключение SDK; повторная отмена не прерывает компенсацию."""
while not task.done():
with suppress(asyncio.CancelledError):
await asyncio.wait([task])
completed = not task.cancelled() and task.exception() is None
if completed and discard_result is not None:
discard_result(task.result())
@dataclass(frozen=True)
class ObjectInfo:
"""Поля S3 сохраняют необязательность SDK; согласованность проверяет domain."""
key: str
size_bytes: int | None
content_type: str | None
last_modified: datetime | None
def close_response(response) -> None:
response.close()
response.release_conn()
class ObjectStream:
"""Закрывается даже если StreamingResponse не успел начать итерацию."""
def __init__(self, storage, response):
self.storage = storage
self.response = response
self.deadline = time.monotonic() + storage.settings.download_timeout_seconds
self.closed = False
def __aiter__(self):
return self
async def __anext__(self):
if self.closed:
raise StopAsyncIteration
try:
remaining = self.deadline - time.monotonic()
if remaining <= 0:
raise TimeoutError
async with asyncio.timeout(remaining):
chunk = await self.storage._call(
lambda: self.response.read(self.storage.settings.chunk_bytes)
)
if not chunk:
await self.aclose()
raise StopAsyncIteration
except BaseException:
await self.aclose()
raise
return chunk
async def aclose(self):
if not self.closed:
self.closed = True
close_response(self.response)
class MinioStorage:
def __init__(self, settings: S3Settings) -> None:
self.settings = settings
# Клиент создаётся в event loop один раз, не конкурентно в worker threads.
url = urlsplit(settings.endpoint)
self._http = urllib3.PoolManager(
timeout=urllib3.Timeout(
connect=settings.connect_timeout_seconds,
read=settings.read_timeout_seconds,
),
retries=urllib3.Retry(total=0),
maxsize=32,
)
self._health_http = urllib3.PoolManager(
timeout=urllib3.Timeout(connect=0.25, read=0.5),
retries=urllib3.Retry(total=0),
)
self._client = Minio(
url.netloc,
secure=url.scheme == "https",
region=settings.region,
access_key=settings.access_key_id_file.read_text().strip(),
secret_key=settings.secret_access_key_file.read_text().strip(),
http_client=self._http,
)
async def _call(self, operation: Callable, *, discard_result=None):
return await run_sync(operation, discard_result=discard_result)
async def put_file(
self, key: str, path: Path, *, size_bytes: int, content_type: str, sha256: str
) -> None:
def put():
with path.open("rb") as source:
# Один PUT: размер части равен максимальному разрешённому файлу.
self._client.put_object(
self.settings.bucket,
key,
source,
size_bytes,
content_type=content_type,
metadata={"sha256": sha256},
part_size=10_485_760,
num_parallel_uploads=1,
)
await self._call(put)
async def open_object(self, key: str) -> ObjectStream:
response = await self._call(
lambda: self._client.get_object(self.settings.bucket, key),
discard_result=close_response,
)
return ObjectStream(self, response)
async def stat_object(self, key: str) -> ObjectInfo:
def stat():
info = self._client.stat_object(self.settings.bucket, key)
return ObjectInfo(key, info.size, info.content_type, info.last_modified)
return await self._call(stat)
async def delete_object(self, key: str) -> None:
await self._call(lambda: self._client.remove_object(self.settings.bucket, key))
async def check_available(self) -> bool:
status = await self._call(
lambda: self._health_http.request(
"GET",
self.settings.endpoint.rstrip("/") + "/minio/health/ready",
).status
)
return status == 200
async def aclose(self) -> None:
self._http.clear()
self._health_http.clear()
def create_s3_storage(settings: S3Settings) -> MinioStorage:
return MinioStorage(settings)
+38
View File
@@ -0,0 +1,38 @@
from datetime import datetime
from uuid import UUID
from redis.asyncio import Redis
SESSION_KEY_PREFIX = "session:"
def session_key(token_hash: str) -> str:
"""Возвращает ключ Redis для хеша токена."""
return f"{SESSION_KEY_PREFIX}{token_hash}"
async def create_session(
redis: Redis,
*,
token_hash: str,
user_id: UUID,
expires_at: datetime,
) -> None:
"""Добавляет сессию с абсолютным временем истечения."""
await redis.set(session_key(token_hash), str(user_id), pxat=expires_at)
async def get_session_user_id(redis: Redis, token_hash: str) -> UUID | None:
"""Возвращает id владельца действующей сессии или None."""
raw_user_id = await redis.get(session_key(token_hash))
if isinstance(raw_user_id, bytes):
raw_user_id = raw_user_id.decode()
user_id = UUID(raw_user_id) if raw_user_id else None
return user_id
async def delete_session(redis: Redis, token_hash: str) -> bool:
"""Удаляет сессию; возвращает True, если она существовала."""
deleted_count = await redis.delete(session_key(token_hash))
is_deleted = deleted_count > 0
return is_deleted
+6
View File
@@ -0,0 +1,6 @@
"""Общие типы слоя хранения."""
from datetime import datetime
from uuid import UUID
Position = tuple[datetime, UUID]
+47
View File
@@ -0,0 +1,47 @@
from collections.abc import Collection
from uuid import UUID
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.user import User
async def create_user(
session: AsyncSession,
*,
username: str,
display_name: str,
password_hash: str,
) -> User:
"""Добавляет пользователя; занятый username даёт IntegrityError при flush."""
user = User(
username=username, display_name=display_name, password_hash=password_hash
)
session.add(user)
await session.flush()
return user
async def get_user_by_id(session: AsyncSession, user_id: UUID) -> User | None:
"""Возвращает пользователя по id или None."""
user = await session.get(User, user_id)
return user
async def get_user_by_username(session: AsyncSession, username: str) -> User | None:
"""Возвращает пользователя по username или None."""
stmt = select(User).where(User.username == username)
result = await session.execute(stmt)
user = result.scalar_one_or_none()
return user
async def get_existing_user_ids(
session: AsyncSession, user_ids: Collection[UUID]
) -> set[UUID]:
"""Возвращает те из user_ids, что существуют, одним запросом."""
stmt = select(User.id).where(User.id.in_(user_ids))
result = await session.execute(stmt)
existing_ids = set(result.scalars().all())
return existing_ids
+10
View File
@@ -0,0 +1,10 @@
# Override для отдельного тестового стенда (make test-stand-up):
# публикует PostgreSQL и Redis на 127.0.0.1, чтобы pytest из student-tests/
# мог подключаться к ним напрямую. В основном стенде эти порты закрыты.
services:
postgres:
ports:
- "127.0.0.1:${DB_HOST_PORT:?Set DB_HOST_PORT in .env}:5432"
redis:
ports:
- "127.0.0.1:${REDIS_HOST_PORT:?Set REDIS_HOST_PORT in .env}:6379"
+416
View File
@@ -0,0 +1,416 @@
name: messenger
x-api-image: &api-image
build:
context: .
args:
API_BUILD_REVISION: ${API_BUILD_REVISION:?Set API_BUILD_REVISION in .env}
image: ${API_IMAGE:?Set API_IMAGE in .env}
x-base-env: &base-env
APP_HOST: ${APP_HOST:?Set APP_HOST in .env}
APP_PORT: ${APP_PORT:?Set APP_PORT in .env}
APP_ENV: ${APP_ENV:?Set APP_ENV in .env}
LOG_LEVEL: ${LOG_LEVEL:?Set LOG_LEVEL in .env}
MAX_MESSAGES: ${MAX_MESSAGES:?Set MAX_MESSAGES in .env}
MAX_IN_FLIGHT: ${MAX_IN_FLIGHT:?Set MAX_IN_FLIGHT in .env}
DB_HOST: ${DB_HOST:?Set DB_HOST in .env}
DB_PORT: ${DB_PORT:?Set DB_PORT in .env}
DB_NAME: ${DB_NAME:?Set DB_NAME in .env}
DB_USER: ${DB_USER:?Set DB_USER in .env}
DB_POOL_SIZE: ${DB_POOL_SIZE:?Set DB_POOL_SIZE in .env}
DB_MAX_OVERFLOW: ${DB_MAX_OVERFLOW:?Set DB_MAX_OVERFLOW in .env}
DB_POOL_TIMEOUT_SECONDS: ${DB_POOL_TIMEOUT_SECONDS:?Set DB_POOL_TIMEOUT_SECONDS in .env}
DB_CONNECT_TIMEOUT_SECONDS: ${DB_CONNECT_TIMEOUT_SECONDS:?Set DB_CONNECT_TIMEOUT_SECONDS in .env}
DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:?Set DB_STATEMENT_TIMEOUT_MS in .env}
SHUTDOWN_DRAIN_SECONDS: ${SHUTDOWN_DRAIN_SECONDS:?Set SHUTDOWN_DRAIN_SECONDS in .env}
GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS: ${GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS:?Set GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS in .env}
READINESS_TIMEOUT_SECONDS: ${READINESS_TIMEOUT_SECONDS:?Set READINESS_TIMEOUT_SECONDS in .env}
x-s3-env: &s3-env
S3_ENDPOINT: ${S3_ENDPOINT:?Set S3_ENDPOINT in .env}
S3_REGION: ${S3_REGION:?Set S3_REGION in .env}
S3_BUCKET: ${S3_BUCKET:?Set S3_BUCKET in .env}
S3_ACCESS_KEY_ID_FILE: ${S3_ACCESS_KEY_ID_FILE:?Set S3_ACCESS_KEY_ID_FILE in .env}
S3_SECRET_ACCESS_KEY_FILE: ${S3_SECRET_ACCESS_KEY_FILE:?Set S3_SECRET_ACCESS_KEY_FILE in .env}
S3_CONNECT_TIMEOUT_SECONDS: ${S3_CONNECT_TIMEOUT_SECONDS:?Set S3_CONNECT_TIMEOUT_SECONDS in .env}
S3_READ_TIMEOUT_SECONDS: ${S3_READ_TIMEOUT_SECONDS:?Set S3_READ_TIMEOUT_SECONDS in .env}
S3_UPLOAD_TIMEOUT_SECONDS: ${S3_UPLOAD_TIMEOUT_SECONDS:?Set S3_UPLOAD_TIMEOUT_SECONDS in .env}
S3_DOWNLOAD_TIMEOUT_SECONDS: ${S3_DOWNLOAD_TIMEOUT_SECONDS:?Set S3_DOWNLOAD_TIMEOUT_SECONDS in .env}
S3_IMAGE_TIMEOUT_SECONDS: ${S3_IMAGE_TIMEOUT_SECONDS:?Set S3_IMAGE_TIMEOUT_SECONDS in .env}
S3_MAX_UPLOAD_BYTES: ${S3_MAX_UPLOAD_BYTES:?Set S3_MAX_UPLOAD_BYTES in .env}
S3_MAX_IMAGE_PIXELS: ${S3_MAX_IMAGE_PIXELS:?Set S3_MAX_IMAGE_PIXELS in .env}
S3_CHUNK_BYTES: ${S3_CHUNK_BYTES:?Set S3_CHUNK_BYTES in .env}
S3_MAX_CONCURRENT_UPLOADS: ${S3_MAX_CONCURRENT_UPLOADS:?Set S3_MAX_CONCURRENT_UPLOADS in .env}
S3_CLEANUP_GRACE_SECONDS: ${S3_CLEANUP_GRACE_SECONDS:?Set S3_CLEANUP_GRACE_SECONDS in .env}
S3_CLEANUP_INTERVAL_SECONDS: ${S3_CLEANUP_INTERVAL_SECONDS:?Set S3_CLEANUP_INTERVAL_SECONDS in .env}
x-jobs-env: &jobs-env
BROKER_HOST: ${BROKER_HOST:?Set BROKER_HOST in .env}
BROKER_PORT: ${BROKER_PORT:?Set BROKER_PORT in .env}
BROKER_PASSWORD_FILE: ${BROKER_PASSWORD_FILE:?Set BROKER_PASSWORD_FILE in .env}
BROKER_QUEUE: ${BROKER_QUEUE:?Set BROKER_QUEUE in .env}
BROKER_USER: ${BROKER_USER:?Set BROKER_USER in .env}
BROKER_VHOST: ${BROKER_VHOST:?Set BROKER_VHOST in .env}
WORKER_CONCURRENCY: ${WORKER_CONCURRENCY:?Set WORKER_CONCURRENCY in .env}
JOB_MAX_ATTEMPTS: ${JOB_MAX_ATTEMPTS:?Set JOB_MAX_ATTEMPTS in .env}
JOB_TIMEOUT_SECONDS: ${JOB_TIMEOUT_SECONDS:?Set JOB_TIMEOUT_SECONDS in .env}
JOB_LEASE_SECONDS: ${JOB_LEASE_SECONDS:?Set JOB_LEASE_SECONDS in .env}
JOB_RETRY_MAX_SECONDS: ${JOB_RETRY_MAX_SECONDS:?Set JOB_RETRY_MAX_SECONDS in .env}
JOB_RETRY_SECONDS: ${JOB_RETRY_SECONDS:?Set JOB_RETRY_SECONDS in .env}
PUBLISHER_POLL_SECONDS: ${PUBLISHER_POLL_SECONDS:?Set PUBLISHER_POLL_SECONDS in .env}
FAILED_STAGING_RETENTION_SECONDS: ${FAILED_STAGING_RETENTION_SECONDS:?Set FAILED_STAGING_RETENTION_SECONDS in .env}
STAGING_RETENTION_SECONDS: ${STAGING_RETENTION_SECONDS:?Set STAGING_RETENTION_SECONDS in .env}
IMAGE_JPEG_QUALITY: ${IMAGE_JPEG_QUALITY:?Set IMAGE_JPEG_QUALITY in .env}
IMAGE_WEBP_QUALITY: ${IMAGE_WEBP_QUALITY:?Set IMAGE_WEBP_QUALITY in .env}
IMAGE_WEBP_METHOD: ${IMAGE_WEBP_METHOD:?Set IMAGE_WEBP_METHOD in .env}
IMAGE_MEMORY_MIB: ${IMAGE_MEMORY_MIB:?Set IMAGE_MEMORY_MIB in .env}
IMAGE_CPU_SECONDS: ${IMAGE_CPU_SECONDS:?Set IMAGE_CPU_SECONDS in .env}
services:
minio:
build:
context: .
dockerfile: infra/minio/Dockerfile
target: server
image: messenger-minio:local
command: ["server", "/data", "--console-address", "127.0.0.1:9001"]
restart: unless-stopped
environment:
MINIO_ROOT_USER_FILE: ${MINIO_ROOT_USER_FILE:?Set MINIO_ROOT_USER_FILE in .env}
MINIO_ROOT_PASSWORD_FILE: ${MINIO_ROOT_PASSWORD_FILE:?Set MINIO_ROOT_PASSWORD_FILE in .env}
MINIO_BROWSER: ${MINIO_BROWSER:?Set MINIO_BROWSER in .env}
secrets:
- source: minio_root_user
target: ${MINIO_ROOT_USER_FILE:?Set MINIO_ROOT_USER_FILE in .env}
- source: minio_root_password
target: ${MINIO_ROOT_PASSWORD_FILE:?Set MINIO_ROOT_PASSWORD_FILE in .env}
volumes:
- miniodata:/data
networks: [objects]
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:9000/minio/health/ready', timeout=2)"]
interval: 3s
timeout: 3s
retries: 10
deploy:
resources:
limits:
cpus: "1.0"
memory: 512M
minio-bootstrap:
build:
context: .
dockerfile: infra/minio/Dockerfile
target: bootstrap
image: messenger-minio-bootstrap:local
environment:
S3_ENDPOINT: ${S3_ENDPOINT:?Set S3_ENDPOINT in .env}
S3_BUCKET: ${S3_BUCKET:?Set S3_BUCKET in .env}
S3_ACCESS_KEY_ID_FILE: ${S3_ACCESS_KEY_ID_FILE:?Set S3_ACCESS_KEY_ID_FILE in .env}
S3_SECRET_ACCESS_KEY_FILE: ${S3_SECRET_ACCESS_KEY_FILE:?Set S3_SECRET_ACCESS_KEY_FILE in .env}
MINIO_ROOT_USER_FILE: ${MINIO_ROOT_USER_FILE:?Set MINIO_ROOT_USER_FILE in .env}
MINIO_ROOT_PASSWORD_FILE: ${MINIO_ROOT_PASSWORD_FILE:?Set MINIO_ROOT_PASSWORD_FILE in .env}
secrets:
- source: minio_root_user
target: ${MINIO_ROOT_USER_FILE:?Set MINIO_ROOT_USER_FILE in .env}
- source: minio_root_password
target: ${MINIO_ROOT_PASSWORD_FILE:?Set MINIO_ROOT_PASSWORD_FILE in .env}
- source: s3_access_key_id
target: ${S3_ACCESS_KEY_ID_FILE:?Set S3_ACCESS_KEY_ID_FILE in .env}
- source: s3_secret_access_key
target: ${S3_SECRET_ACCESS_KEY_FILE:?Set S3_SECRET_ACCESS_KEY_FILE in .env}
networks: [objects]
restart: "no"
depends_on:
minio:
condition: service_healthy
deploy:
resources:
limits:
cpus: "0.25"
memory: 128M
postgres:
image: postgres:16.10-bookworm
restart: unless-stopped
environment:
POSTGRES_USER: ${DB_USER:?Set DB_USER in .env}
POSTGRES_DB: ${DB_NAME:?Set DB_NAME in .env}
POSTGRES_PASSWORD_FILE: ${POSTGRES_PASSWORD_FILE:?Set POSTGRES_PASSWORD_FILE in .env}
secrets:
- source: db_password
target: ${POSTGRES_PASSWORD_FILE:?Set POSTGRES_PASSWORD_FILE in .env}
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
interval: 3s
timeout: 3s
retries: 10
deploy:
resources:
limits:
cpus: "1.0"
memory: 512M
redis:
image: redis:7.4.2-bookworm
restart: unless-stopped
entrypoint: ["/bin/sh", "/usr/local/bin/start-redis.sh"]
secrets:
- redis_password
volumes:
- ./infra/redis/redis.conf:/usr/local/etc/redis/redis.conf:ro
- ./infra/redis/start-redis.sh:/usr/local/bin/start-redis.sh:ro
- redisdata:/data
healthcheck:
test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/redis_password)\" redis-cli ping"]
interval: 3s
timeout: 3s
retries: 10
deploy:
resources:
limits:
cpus: "0.5"
memory: 512M
broker:
image: rabbitmq:4.4.0
hostname: broker
restart: unless-stopped
entrypoint: ["/bin/sh", "/usr/local/bin/start-broker.sh"]
environment:
BROKER_PORT: ${BROKER_PORT:?Set BROKER_PORT in .env}
BROKER_USER: ${BROKER_USER:?Set BROKER_USER in .env}
BROKER_VHOST: ${BROKER_VHOST:?Set BROKER_VHOST in .env}
BROKER_PASSWORD_FILE: ${BROKER_PASSWORD_FILE:?Set BROKER_PASSWORD_FILE in .env}
secrets:
- source: broker_password
target: ${BROKER_PASSWORD_FILE:?Set BROKER_PASSWORD_FILE in .env}
volumes:
- ./infra/broker/start-broker.sh:/usr/local/bin/start-broker.sh:ro
- rabbitmqdata:/var/lib/rabbitmq
healthcheck:
test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
interval: 5s
timeout: 5s
retries: 20
start_period: 20s
deploy:
resources:
limits:
cpus: "1.0"
memory: 768M
publisher:
<<: *api-image
init: true
command: ["python", "-m", "app.core.outbox_publisher"]
restart: unless-stopped
environment:
<<: [*base-env, *jobs-env]
secrets:
- db_password
- source: broker_password
target: ${BROKER_PASSWORD_FILE:?Set BROKER_PASSWORD_FILE in .env}
depends_on:
postgres:
condition: service_healthy
broker:
condition: service_healthy
migrate:
condition: service_completed_successfully
healthcheck:
disable: true
stop_grace_period: 15s
deploy:
resources:
limits:
cpus: "0.5"
memory: 256M
worker:
<<: *api-image
init: true
command: ["python", "-m", "app.core.job_worker"]
restart: unless-stopped
environment:
<<: [*base-env, *s3-env, *jobs-env]
secrets:
- db_password
- source: broker_password
target: ${BROKER_PASSWORD_FILE:?Set BROKER_PASSWORD_FILE in .env}
- source: s3_access_key_id
target: ${S3_ACCESS_KEY_ID_FILE:?Set S3_ACCESS_KEY_ID_FILE in .env}
- source: s3_secret_access_key
target: ${S3_SECRET_ACCESS_KEY_FILE:?Set S3_SECRET_ACCESS_KEY_FILE in .env}
networks: [default, objects]
tmpfs:
- /tmp:rw,noexec,nosuid,size=128m,mode=1777
depends_on:
postgres:
condition: service_healthy
broker:
condition: service_healthy
minio:
condition: service_healthy
minio-bootstrap:
condition: service_completed_successfully
migrate:
condition: service_completed_successfully
healthcheck:
disable: true
stop_signal: SIGTERM
stop_grace_period: 20s
deploy:
resources:
limits:
cpus: "2.0"
memory: 2048M
migrate:
<<: *api-image
command: ["alembic", "upgrade", "head"]
environment: *base-env
secrets:
- db_password
depends_on:
postgres:
condition: service_healthy
restart: "no"
healthcheck:
disable: true
deploy:
resources:
limits:
cpus: "0.5"
memory: 256M
api:
<<: *api-image
restart: unless-stopped
environment:
<<: [*base-env, *s3-env]
REDIS_HOST: ${REDIS_HOST:?Set REDIS_HOST in .env}
REDIS_PORT: ${REDIS_PORT:?Set REDIS_PORT in .env}
REDIS_DB: ${REDIS_DB:?Set REDIS_DB in .env}
REDIS_MAX_CONNECTIONS: ${REDIS_MAX_CONNECTIONS:?Set REDIS_MAX_CONNECTIONS in .env}
REDIS_POOL_TIMEOUT_SECONDS: ${REDIS_POOL_TIMEOUT_SECONDS:?Set REDIS_POOL_TIMEOUT_SECONDS in .env}
REDIS_CONNECT_TIMEOUT_SECONDS: ${REDIS_CONNECT_TIMEOUT_SECONDS:?Set REDIS_CONNECT_TIMEOUT_SECONDS in .env}
REDIS_SOCKET_TIMEOUT_SECONDS: ${REDIS_SOCKET_TIMEOUT_SECONDS:?Set REDIS_SOCKET_TIMEOUT_SECONDS in .env}
SESSION_STORE: ${SESSION_STORE:?Set SESSION_STORE in .env}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:?Set SESSION_TTL_SECONDS in .env}
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:?Set IDEMPOTENCY_TTL_SECONDS in .env}
secrets:
- db_password
- redis_password
- source: s3_access_key_id
target: ${S3_ACCESS_KEY_ID_FILE:?Set S3_ACCESS_KEY_ID_FILE in .env}
- source: s3_secret_access_key
target: ${S3_SECRET_ACCESS_KEY_FILE:?Set S3_SECRET_ACCESS_KEY_FILE in .env}
networks: [default, objects]
tmpfs:
- /tmp:rw,noexec,nosuid,size=64m,mode=1777
deploy:
replicas: ${API_REPLICAS:?Set API_REPLICAS in .env}
resources:
limits:
cpus: "1.0"
memory: 1536M
healthcheck:
test: ["CMD", "python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/ready', timeout=2.5)"]
interval: 3s
timeout: 3s
start_period: 10s
retries: 2
stop_signal: SIGTERM
stop_grace_period: 8s
depends_on:
minio:
condition: service_healthy
minio-bootstrap:
condition: service_completed_successfully
postgres:
condition: service_healthy
redis:
condition: service_healthy
migrate:
condition: service_completed_successfully
cleanup:
<<: *api-image
command: ["python", "-m", "app.core.cleanup", "--apply"]
restart: unless-stopped
environment:
<<: [*base-env, *s3-env]
FAILED_STAGING_RETENTION_SECONDS: ${FAILED_STAGING_RETENTION_SECONDS:?Set FAILED_STAGING_RETENTION_SECONDS in .env}
STAGING_RETENTION_SECONDS: ${STAGING_RETENTION_SECONDS:?Set STAGING_RETENTION_SECONDS in .env}
secrets:
- db_password
- source: s3_access_key_id
target: ${S3_ACCESS_KEY_ID_FILE:?Set S3_ACCESS_KEY_ID_FILE in .env}
- source: s3_secret_access_key
target: ${S3_SECRET_ACCESS_KEY_FILE:?Set S3_SECRET_ACCESS_KEY_FILE in .env}
networks: [default, objects]
healthcheck:
disable: true
depends_on:
migrate:
condition: service_completed_successfully
minio-bootstrap:
condition: service_completed_successfully
deploy:
resources:
limits:
cpus: "0.25"
memory: 256M
nginx:
image: nginx:1.28.0-alpine
restart: unless-stopped
volumes:
- ./infra/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
ports:
- "127.0.0.1:${LB_HOST_PORT:?Set LB_HOST_PORT in .env}:8080"
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/lb-health"]
interval: 5s
timeout: 3s
retries: 5
depends_on:
api:
condition: service_healthy
deploy:
resources:
limits:
cpus: "0.5"
memory: 128M
volumes:
pgdata:
redisdata:
miniodata:
rabbitmqdata:
networks:
default:
objects:
internal: true
secrets:
broker_password:
file: ./secrets/broker_password
db_password:
file: ./secrets/db_password
redis_password:
file: ./secrets/redis_password
minio_root_user:
file: ./secrets/minio_root_user
minio_root_password:
file: ./secrets/minio_root_password
s3_access_key_id:
file: ./secrets/s3_access_key_id
s3_secret_access_key:
file: ./secrets/s3_secret_access_key
+378
View File
@@ -0,0 +1,378 @@
{
"status": "passed",
"results": [
{
"scenario": "worker_stopped_restart_all",
"attachment_id": "f5cc75ba-d2c7-43ff-8cf4-123b723118b8",
"queue_before": {
"name": "attachment-jobs",
"messages_unacknowledged": 0,
"consumers": 0,
"durable": true,
"messages_ready": 1
},
"queue_after": {
"name": "attachment-jobs",
"messages_unacknowledged": 0,
"consumers": 0,
"durable": true,
"messages_ready": 1
},
"after": {
"job_id": "9adcea8e-9046-4736-9763-c24bb6daf417",
"status": "ready",
"attempt": 1,
"published_attempt": 1,
"limit": 5,
"updated_at": "2026-11-10 04:36:45.543612+00:00",
"next_attempt_at": "2026-11-10 04:35:56.727228+00:00",
"last_error_code": null,
"permanent": null,
"objects": [
{
"name": "crop.jpg",
"size": 2462,
"sha256": "fae35500205a78065cf7d589f121cc909b017e2a4cde882177e24f5608fb4c1f",
"last_modified": "2026-11-10 04:36:45.525000+00:00"
},
{
"name": "optimized.webp",
"size": 2462,
"sha256": "1090d84ed8411226010ae498b08e1b9e6d81c8eee02ee77143a0dc327b894beb",
"last_modified": "2026-11-10 04:36:45.533000+00:00"
},
{
"name": "thumbnail.jpg",
"size": 5813,
"sha256": "b8e59b0cad429b1c49c27c4a1c79e52bfc23e2fab7c7238d18d5addd4df4b546",
"last_modified": "2026-11-10 04:36:45.521000+00:00"
},
{
"name": "v1",
"size": 111817,
"sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75",
"last_modified": "2026-11-10 04:36:45.508000+00:00"
}
]
}
},
{
"scenario": "crash-after-object",
"attachment_id": "1927c264-c721-4de1-8914-32d9beab48e5",
"exit_code": 137,
"before": {
"job_id": "bda1d00d-41c7-4d28-b2e5-07759be55985",
"status": "processing",
"attempt": 1,
"published_attempt": 1,
"limit": 5,
"updated_at": "2026-11-10 04:36:50.666631+00:00",
"next_attempt_at": "2026-11-10 04:36:48.673346+00:00",
"last_error_code": null,
"permanent": null,
"objects": [
{
"name": "crop.jpg",
"size": 2462,
"sha256": "fae35500205a78065cf7d589f121cc909b017e2a4cde882177e24f5608fb4c1f",
"last_modified": "2026-11-10 04:36:51.443000+00:00"
},
{
"name": "optimized.webp",
"size": 2462,
"sha256": "1090d84ed8411226010ae498b08e1b9e6d81c8eee02ee77143a0dc327b894beb",
"last_modified": "2026-11-10 04:36:51.448000+00:00"
},
{
"name": "thumbnail.jpg",
"size": 5813,
"sha256": "b8e59b0cad429b1c49c27c4a1c79e52bfc23e2fab7c7238d18d5addd4df4b546",
"last_modified": "2026-11-10 04:36:51.434000+00:00"
},
{
"name": "v1",
"size": 111817,
"sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75",
"last_modified": "2026-11-10 04:36:51.420000+00:00"
}
]
},
"after": {
"job_id": "bda1d00d-41c7-4d28-b2e5-07759be55985",
"status": "ready",
"attempt": 2,
"published_attempt": 2,
"limit": 5,
"updated_at": "2026-11-10 04:38:26.694238+00:00",
"next_attempt_at": "2026-11-10 04:38:25.019759+00:00",
"last_error_code": null,
"permanent": null,
"objects": [
{
"name": "crop.jpg",
"size": 2462,
"sha256": "fae35500205a78065cf7d589f121cc909b017e2a4cde882177e24f5608fb4c1f",
"last_modified": "2026-11-10 04:38:26.675000+00:00"
},
{
"name": "optimized.webp",
"size": 2462,
"sha256": "1090d84ed8411226010ae498b08e1b9e6d81c8eee02ee77143a0dc327b894beb",
"last_modified": "2026-11-10 04:38:26.686000+00:00"
},
{
"name": "thumbnail.jpg",
"size": 5813,
"sha256": "b8e59b0cad429b1c49c27c4a1c79e52bfc23e2fab7c7238d18d5addd4df4b546",
"last_modified": "2026-11-10 04:38:26.666000+00:00"
},
{
"name": "v1",
"size": 111817,
"sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75",
"last_modified": "2026-11-10 04:38:26.656000+00:00"
}
]
}
},
{
"scenario": "crash-before-ack",
"attachment_id": "e02d817d-9615-4058-ae5c-63ab895aa6f5",
"exit_code": 137,
"before": {
"job_id": "9bfea78c-ce05-4a00-bf76-a2213ed3a8df",
"status": "ready",
"attempt": 1,
"published_attempt": 1,
"limit": 5,
"updated_at": "2026-11-10 04:38:32.063984+00:00",
"next_attempt_at": "2026-11-10 04:38:29.436074+00:00",
"last_error_code": null,
"permanent": null,
"objects": [
{
"name": "crop.jpg",
"size": 2462,
"sha256": "fae35500205a78065cf7d589f121cc909b017e2a4cde882177e24f5608fb4c1f",
"last_modified": "2026-11-10 04:38:32.054000+00:00"
},
{
"name": "optimized.webp",
"size": 2462,
"sha256": "1090d84ed8411226010ae498b08e1b9e6d81c8eee02ee77143a0dc327b894beb",
"last_modified": "2026-11-10 04:38:32.059000+00:00"
},
{
"name": "thumbnail.jpg",
"size": 5813,
"sha256": "b8e59b0cad429b1c49c27c4a1c79e52bfc23e2fab7c7238d18d5addd4df4b546",
"last_modified": "2026-11-10 04:38:32.048000+00:00"
},
{
"name": "v1",
"size": 111817,
"sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75",
"last_modified": "2026-11-10 04:38:32.032000+00:00"
}
]
},
"after": {
"job_id": "9bfea78c-ce05-4a00-bf76-a2213ed3a8df",
"status": "ready",
"attempt": 1,
"published_attempt": 1,
"limit": 5,
"updated_at": "2026-11-10 04:38:32.063984+00:00",
"next_attempt_at": "2026-11-10 04:38:29.436074+00:00",
"last_error_code": null,
"permanent": null,
"objects": [
{
"name": "crop.jpg",
"size": 2462,
"sha256": "fae35500205a78065cf7d589f121cc909b017e2a4cde882177e24f5608fb4c1f",
"last_modified": "2026-11-10 04:38:32.054000+00:00"
},
{
"name": "optimized.webp",
"size": 2462,
"sha256": "1090d84ed8411226010ae498b08e1b9e6d81c8eee02ee77143a0dc327b894beb",
"last_modified": "2026-11-10 04:38:32.059000+00:00"
},
{
"name": "thumbnail.jpg",
"size": 5813,
"sha256": "b8e59b0cad429b1c49c27c4a1c79e52bfc23e2fab7c7238d18d5addd4df4b546",
"last_modified": "2026-11-10 04:38:32.048000+00:00"
},
{
"name": "v1",
"size": 111817,
"sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75",
"last_modified": "2026-11-10 04:38:32.032000+00:00"
}
]
}
},
{
"scenario": "fail-transient",
"attachment_id": "a9c15ce8-cacf-43c0-8373-8e3ff5fa23aa",
"samples": [
{
"job_id": "ffa9abca-645a-4ee2-ab2a-7bd06a7e0a59",
"status": "queued",
"attempt": 1,
"published_attempt": 1,
"limit": 5,
"updated_at": "2026-11-10 04:38:46.283315+00:00",
"next_attempt_at": "2026-11-10 04:38:50.994899+00:00",
"last_error_code": "processing_timeout",
"permanent": false,
"objects": []
},
{
"job_id": "ffa9abca-645a-4ee2-ab2a-7bd06a7e0a59",
"status": "queued",
"attempt": 2,
"published_attempt": 2,
"limit": 5,
"updated_at": "2026-11-10 04:38:51.039278+00:00",
"next_attempt_at": "2026-11-10 04:38:59.940067+00:00",
"last_error_code": "processing_timeout",
"permanent": false,
"objects": []
},
{
"job_id": "ffa9abca-645a-4ee2-ab2a-7bd06a7e0a59",
"status": "queued",
"attempt": 3,
"published_attempt": 3,
"limit": 5,
"updated_at": "2026-11-10 04:39:00.122276+00:00",
"next_attempt_at": "2026-11-10 04:39:19.754304+00:00",
"last_error_code": "processing_timeout",
"permanent": false,
"objects": []
},
{
"job_id": "ffa9abca-645a-4ee2-ab2a-7bd06a7e0a59",
"status": "queued",
"attempt": 4,
"published_attempt": 4,
"limit": 5,
"updated_at": "2026-11-10 04:39:20.250087+00:00",
"next_attempt_at": "2026-11-10 04:39:56.121121+00:00",
"last_error_code": "processing_timeout",
"permanent": false,
"objects": []
},
{
"job_id": "ffa9abca-645a-4ee2-ab2a-7bd06a7e0a59",
"status": "failed",
"attempt": 5,
"published_attempt": 5,
"limit": 5,
"updated_at": "2026-11-10 04:39:56.526646+00:00",
"next_attempt_at": "2026-11-10 04:41:15.809038+00:00",
"last_error_code": "processing_timeout",
"permanent": false,
"objects": []
}
],
"after": {
"job_id": "ffa9abca-645a-4ee2-ab2a-7bd06a7e0a59",
"status": "ready",
"attempt": 6,
"published_attempt": 6,
"limit": 10,
"updated_at": "2026-11-10 04:40:09.651133+00:00",
"next_attempt_at": "2026-11-10 04:40:03.031585+00:00",
"last_error_code": null,
"permanent": null,
"objects": [
{
"name": "crop.jpg",
"size": 2462,
"sha256": "fae35500205a78065cf7d589f121cc909b017e2a4cde882177e24f5608fb4c1f",
"last_modified": "2026-11-10 04:40:09.642000+00:00"
},
{
"name": "optimized.webp",
"size": 2462,
"sha256": "1090d84ed8411226010ae498b08e1b9e6d81c8eee02ee77143a0dc327b894beb",
"last_modified": "2026-11-10 04:40:09.647000+00:00"
},
{
"name": "thumbnail.jpg",
"size": 5813,
"sha256": "b8e59b0cad429b1c49c27c4a1c79e52bfc23e2fab7c7238d18d5addd4df4b546",
"last_modified": "2026-11-10 04:40:09.637000+00:00"
},
{
"name": "v1",
"size": 111817,
"sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75",
"last_modified": "2026-11-10 04:40:09.624000+00:00"
}
]
},
"replay_idempotent": true
},
{
"scenario": "fail-permanent",
"attachment_id": "d8a6e312-e468-4e4b-a7ee-1d84751d5843",
"samples": [
{
"job_id": "0da2ef52-65a8-4a74-8d43-015666e2975c",
"status": "failed",
"attempt": 1,
"published_attempt": 1,
"limit": 5,
"updated_at": "2026-11-10 04:40:24.826416+00:00",
"next_attempt_at": "2026-11-10 04:40:29.630307+00:00",
"last_error_code": "injected_permanent",
"permanent": true,
"objects": []
}
],
"after": {
"job_id": "0da2ef52-65a8-4a74-8d43-015666e2975c",
"status": "ready",
"attempt": 2,
"published_attempt": 2,
"limit": 6,
"updated_at": "2026-11-10 04:40:40.004814+00:00",
"next_attempt_at": "2026-11-10 04:40:30.084006+00:00",
"last_error_code": null,
"permanent": null,
"objects": [
{
"name": "crop.jpg",
"size": 2462,
"sha256": "fae35500205a78065cf7d589f121cc909b017e2a4cde882177e24f5608fb4c1f",
"last_modified": "2026-11-10 04:40:39.988000+00:00"
},
{
"name": "optimized.webp",
"size": 2462,
"sha256": "1090d84ed8411226010ae498b08e1b9e6d81c8eee02ee77143a0dc327b894beb",
"last_modified": "2026-11-10 04:40:39.996000+00:00"
},
{
"name": "thumbnail.jpg",
"size": 5813,
"sha256": "b8e59b0cad429b1c49c27c4a1c79e52bfc23e2fab7c7238d18d5addd4df4b546",
"last_modified": "2026-11-10 04:40:39.982000+00:00"
},
{
"name": "v1",
"size": 111817,
"sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75",
"last_modified": "2026-11-10 04:40:39.968000+00:00"
}
]
},
"replay_idempotent": true
}
]
}
+2
View File
@@ -0,0 +1,2 @@
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+2
View File
@@ -0,0 +1,2 @@
python3 tests/smoke.py --base-url "http://localhost:28080"
PASS: lab5 public API scenario; infrastructure and grading evidence remain separate.
+308
View File
@@ -0,0 +1,308 @@
{
"date": "2026-11-10",
"status": "passed",
"project": "mtusi-lab5-verification",
"base_url": "http://localhost:28080",
"checks": [
{
"name": "pytest_regression",
"exit_code": 0,
"stdout": "199 passed in 82.29s (0:01:22)",
"scope": "Dedicated *_test database and Redis DB15; Docker restart tests enabled"
},
{
"name": "pytest_timeout_retention",
"exit_code": 0,
"stdout": "2 passed, 5 deselected in 1.91s",
"scope": "Dedicated *_test database and Redis DB15; Docker restart tests enabled"
},
{
"name": "compose_configuration",
"command": [
"docker",
"compose",
"--env-file",
".env",
"config",
"--quiet"
],
"exit_code": 0,
"stdout": ""
},
{
"name": "contract",
"command": [
"/home/gytall/.pyenv/versions/3.12.14/bin/python3",
"scripts/check_contract.py"
],
"exit_code": 0,
"stdout": "PASS: offline skeleton structure, local refs and Python syntax; application NOT tested."
},
{
"name": "openapi",
"command": [
"/home/gytall/.pyenv/versions/3.12.14/bin/python3",
"scripts/validate_openapi.py"
],
"exit_code": 0,
"stdout": "PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested."
},
{
"name": "public_smoke",
"command": [
"/home/gytall/.pyenv/versions/3.12.14/bin/python3",
"tests/smoke.py",
"--base-url",
"http://localhost:28080"
],
"exit_code": 0,
"stdout": "PASS: lab5 public API scenario; infrastructure and grading evidence remain separate."
},
{
"name": "message_idempotency",
"command": [
"/home/gytall/.pyenv/versions/3.12.14/bin/python3",
"-m",
"scripts.check_idempotency",
"--base-url",
"http://localhost:28080"
],
"exit_code": 0,
"stdout": "PASS: 24 concurrent replays, 2 replicas, one message"
},
{
"name": "outbox_crash",
"command": [
"/home/gytall/.pyenv/versions/3.12.14/bin/python3",
"-m",
"scripts.check_outbox_recovery",
"--base-url",
"http://localhost:28080"
],
"exit_code": 0,
"stdout": "{\"scenario\": \"commit_before_publish\", \"attachment_id\": \"0fff1dce-c479-40d8-8627-f28cc85cb6cf\", \"message_id\": \"e79bfb7e-c2af-4011-a87a-52528d7a7840\", \"publisher_exit_code\": 137, \"status_after_crash\": \"queued\", \"status_after_restart\": \"ready\", \"variants\": [\"thumbnail\", \"crop\", \"optimized\"], \"reuploaded\": false}"
},
{
"name": "public_persistence",
"command": [
"/home/gytall/.pyenv/versions/3.12.14/bin/python3",
"tests/resilience.py",
"--mode",
"persistence",
"--action-script",
"scripts/restart.sh",
"--base-url",
"http://localhost:28080"
],
"exit_code": 0,
"stdout": "Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.\nPASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence."
},
{
"name": "public_failover",
"command": [
"/home/gytall/.pyenv/versions/3.12.14/bin/python3",
"tests/resilience.py",
"--mode",
"failover",
"--action-script",
"scripts/stop-one.sh",
"--base-url",
"http://localhost:28080"
],
"exit_code": 0,
"stdout": "Executing explicit failover hook; hook output suppressed to avoid leaking secrets.\n{\"observed_instances_before\": 2, \"successful_writes\": 104, \"failed_attempts\": 5, \"first_recovery_seconds\": 1.907}\nPASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence."
},
{
"name": "rabbitmq_prefetch",
"command": [
"docker",
"compose",
"--env-file",
".env",
"exec",
"-T",
"broker",
"rabbitmqctl",
"list_channels",
"--formatter=json",
"consumer_count",
"prefetch_count",
"messages_unacknowledged"
],
"exit_code": 0,
"stdout": "[\n{\"consumer_count\":1,\"messages_unacknowledged\":0,\"prefetch_count\":1}\n,{\"consumer_count\":0,\"messages_unacknowledged\":0,\"prefetch_count\":1}\n,{\"consumer_count\":1,\"messages_unacknowledged\":0,\"prefetch_count\":1}\n]"
},
{
"name": "rabbitmq_durability_ack",
"command": [
"docker",
"compose",
"--env-file",
".env",
"exec",
"-T",
"broker",
"rabbitmqctl",
"list_queues",
"--formatter=json",
"name",
"durable",
"messages_ready",
"messages_unacknowledged",
"consumers"
],
"exit_code": 0,
"stdout": "[\n{\"name\":\"attachment-jobs\",\"messages_unacknowledged\":0,\"consumers\":2,\"durable\":true,\"messages_ready\":0}\n]"
},
{
"name": "worker_fault_retry_replay",
"exit_code": 0,
"evidence": "jobs.json",
"scenarios": [
"worker_stopped_restart_all",
"crash-after-object",
"crash-before-ack",
"fail-transient",
"fail-permanent"
]
},
{
"name": "whitespace",
"command": [
"git",
"diff",
"--check"
],
"exit_code": 0,
"stdout": ""
},
{
"name": "public_contract_tests_unchanged",
"exit_code": 0
},
{
"name": "final_services",
"command": [
"docker",
"compose",
"--env-file",
".env",
"ps",
"--format",
"{{.Service}} {{.State}} {{.Health}}"
],
"exit_code": 0,
"stdout": "api running healthy\napi running healthy\nbroker running healthy\ncleanup running \nminio running healthy\nnginx running healthy\npostgres running healthy\npublisher running \nredis running healthy\nworker running"
}
],
"git_base_commit": "0a703588290e26d0f148b45d0e6bee2e8eefce7d",
"uncommitted_changes": true,
"environment": {
"test_runner_python": "3.12.14",
"runtime_python": "3.12.15",
"broker": "RabbitMQ 4.4.0",
"sessions": "Redis 7.4.2",
"worker_memory_bytes": 2147483648,
"worker_cpu_limit": 2.0,
"worker_init": true
},
"profile": {
"data": "Synthetic users/chats only; tests/fixtures/sample.png for fault scenarios; no credentials in evidence",
"worker_concurrency": 2,
"prefetch_per_consumer": 1,
"max_attempts_per_cycle": 5,
"timeout_seconds": 60,
"lease_seconds": 90,
"retry_base_seconds": 5,
"retry_cap_seconds": 120,
"image_memory_mib": 768,
"image_cpu_seconds": 20,
"isolated_limit_tests": "256 MiB / 1 CPU second in child process; timeout cancellation checked separately"
},
"criteria": {
"3.1_lab4_and_durable_202": [
"pytest_regression",
"public_smoke",
"public_persistence",
"worker_fault_retry_replay"
],
"3.2_durable_broker_worker_late_ack": [
"rabbitmq_durability_ack",
"rabbitmq_prefetch",
"worker_fault_retry_replay"
],
"3.3_states_original_thumbnail": [
"public_smoke",
"pytest_regression",
"worker_fault_retry_replay"
],
"3.4_bounded_retry_idempotency": [
"pytest_regression",
"worker_fault_retry_replay"
],
"3.5_stopped_worker_api_broker_restart": [
"worker_fault_retry_replay",
"public_persistence"
],
"4.1_crop_webp_and_worker_limits": [
"pytest_regression",
"worker_fault_retry_replay"
],
"4.2_commit_publish_recovery": [
"outbox_crash"
],
"4.3_backoff_jitter_classification_registry_replay": [
"pytest_regression",
"pytest_timeout_retention",
"worker_fault_retry_replay"
],
"4.4_crash_after_put_lease_prefetch_cleanup": [
"worker_fault_retry_replay",
"rabbitmq_prefetch",
"pytest_regression",
"pytest_timeout_retention"
]
},
"limitations": [
"Single Docker host, no disk-loss or cluster failover claim",
"Grade 5 experiments not performed",
"No production-scale performance/security claim"
],
"post_test_cleanup": {
"date": "2026-11-10",
"project_removed": "mtusi-lab5-verification",
"test_volumes_removed": 4,
"conserver_removed": true,
"old_lab3_image_removed": true,
"old_empty_networks_removed": true,
"current_lab5_images_retained": true
},
"maintenance_checks": {
"status": "passed",
"command": "make test-suite",
"project": "messenger-test",
"pipeline_tests": 42,
"checks": [
"contract",
"OpenAPI",
"Compose startup",
"public smoke",
"MinIO private access/bootstrap",
"outbox recovery",
"worker_stopped_restart_all",
"crash-after-object",
"crash-before-ack",
"fail-transient",
"fail-permanent"
],
"standalone_nginx": "passed",
"test_resources_removed": true,
"obsolete_image_tags_removed": [
"mtusi-messenger-minio-bootstrap:lab5",
"mtusi-messenger-minio:lab5",
"mtusi-messenger:lab5"
],
"regression_tests_preserved": true,
"note": "Earlier recorded commands retain their original names as historical evidence; operational scripts and resource names are now neutral."
}
}
+13 -4
View File
@@ -1,7 +1,16 @@
# Инфраструктура студента
# Инфраструктура
Здесь разместите конфигурации выбранных сервисов; основную топологию — в корневом compose.yaml/stack.yaml. `compose.example.yaml` — только worksheet ролей и намеренно не запускается. `contracts/infrastructure.json` задаёт минимальные роли, не готовые образы/пароли.
compose.yaml запускает две API-реплики за nginx, PostgreSQL, Redis сессий,
RabbitMQ, приватный MinIO, publisher, worker и cleanup. Все environment-настройки
берутся из .env; credentials передаются файлами secrets. Миграции и bootstrap
завершаются до старта зависимых сервисов.
В REPORT.md сопоставьте роль → service name → версия/digest → health/readiness → volume → сеть/порт → способ передачи credentials. Приведите bootstrap (schema, bucket, broker topology, а с lab6 provisioning) и безопасное повторение этих команд.
Publisher читает outbox PostgreSQL и ждёт подтверждения RabbitMQ. Worker фиксирует
результат в MinIO/PostgreSQL до ack; prefetch=1 на consumer. init:true обеспечивает
корректные сигналы. Broker и хранилища не публикуют внешние порты.
Приложение строится из исходников. Не используйте заранее существующий образ преподавательского сервера вместо своей реализации. Restart hook перезапускает все соответствующие stores с volumes; failover hook останавливает только заданную API-реплику.
make up/down управляют основным проектом messenger и сохраняют volumes.
make test-suite использует отдельный messenger-test и удаляет его вместе с
volumes и сетями при завершении. compose.test.yaml открывает тестовые PostgreSQL
и Redis только на localhost. Полная регрессия доступна через make test-unit,
отдельные проверки — make test-nginx, test-storage, test-outbox и test-jobs.
+8
View File
@@ -0,0 +1,8 @@
#!/bin/sh
set -eu
# Secret читается внутри контейнера, не попадает в compose config/аргументы.
export RABBITMQ_DEFAULT_PASS="$(cat "${BROKER_PASSWORD_FILE:?}")"
export RABBITMQ_DEFAULT_USER="${BROKER_USER:?}"
export RABBITMQ_DEFAULT_VHOST="${BROKER_VHOST:?}"
export RABBITMQ_NODE_PORT="${BROKER_PORT:?}"
exec /usr/local/bin/docker-entrypoint.sh rabbitmq-server
+22
View File
@@ -0,0 +1,22 @@
FROM golang:1.24.8-bookworm AS compiler
ENV CGO_ENABLED=0 GOTOOLCHAIN=local GOBIN=/out GOMAXPROCS=4
RUN --mount=type=cache,target=/go/pkg/mod --mount=type=cache,target=/root/.cache/go-build \
go install -p 4 -ldflags='-s -w -X github.com/minio/minio/cmd.Version=RELEASE.2025-10-15T17-29-55Z -X github.com/minio/minio/cmd.ReleaseTag=RELEASE.2025-10-15T17-29-55Z' github.com/minio/minio@RELEASE.2025-10-15T17-29-55Z
RUN --mount=type=cache,target=/go/pkg/mod --mount=type=cache,target=/root/.cache/go-build \
go install -p 4 -ldflags='-s -w' github.com/minio/mc@RELEASE.2025-08-13T08-35-41Z
FROM python:3.12.15-slim-bookworm AS runtime
RUN useradd --system --uid 10001 --no-create-home minio && mkdir /data && chown minio /data
USER minio
FROM runtime AS server
COPY --from=compiler /out/minio /usr/local/bin/minio
LABEL org.opencontainers.image.source="https://github.com/minio/minio" \
org.opencontainers.image.version="RELEASE.2025-10-15T17-29-55Z"
VOLUME ["/data"]
ENTRYPOINT ["/usr/local/bin/minio"]
FROM runtime AS bootstrap
COPY --from=compiler /out/mc /usr/local/bin/mc
COPY infra/minio/bootstrap.py /bootstrap.py
ENTRYPOINT ["python", "/bootstrap.py"]
+120
View File
@@ -0,0 +1,120 @@
"""Идемпотентный private bucket и отдельная ограниченная учётная запись API."""
import json
import os
from pathlib import Path
import subprocess
from tempfile import TemporaryDirectory
import time
from urllib.request import urlopen
def secret(name):
value = Path(os.environ[name.upper() + "_FILE"]).read_text().strip()
if not value:
raise ValueError("Пустой файл секрета")
return value
def main():
endpoint = os.environ["S3_ENDPOINT"]
bucket = os.environ["S3_BUCKET"]
root_user, root_password = secret("minio_root_user"), secret("minio_root_password")
access, password = secret("s3_access_key_id"), secret("s3_secret_access_key")
if access == root_user:
raise ValueError("API не должен использовать root credentials")
deadline = time.monotonic() + 60
while True:
try:
with urlopen(endpoint + "/minio/health/ready", timeout=2) as response:
if response.status == 200:
break
except OSError:
pass
if time.monotonic() >= deadline:
raise RuntimeError("MinIO не готов за 60 секунд")
time.sleep(1)
with TemporaryDirectory(prefix="minio-bootstrap-") as directory:
config = Path(directory)
# Credentials не передаются mc alias set через аргументы или окружение.
config_file = config / "config.json"
config_file.write_text(
json.dumps(
{
"version": "10",
"aliases": {
"storage": {
"url": endpoint,
"accessKey": root_user,
"secretKey": root_password,
"api": "S3v4",
"path": "auto",
}
},
}
)
)
config_file.chmod(0o600)
def mc(*args):
result = subprocess.run(
["mc", "--config-dir", directory, *args],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
timeout=30,
)
if result.returncode:
raise RuntimeError(
"Ошибка bootstrap MinIO; значения credentials скрыты"
)
mc("mb", "--ignore-existing", "storage/" + bucket)
mc("anonymous", "set", "none", "storage/" + bucket)
policy = {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:GetBucketLocation", "s3:ListBucket"],
"Resource": [f"arn:aws:s3:::{bucket}"],
},
{
"Effect": "Allow",
"Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
"Resource": [
f"arn:aws:s3:::{bucket}/{prefix}/*"
for prefix in ("originals", "staging", "variants")
],
},
],
}
policy_file = config / "policy.json"
policy_file.write_text(json.dumps(policy))
mc(
"admin",
"policy",
"create",
"storage",
"messenger-attachments",
str(policy_file),
)
# mc не поддерживает stdin для user add: вывод и ошибки команды скрыты.
mc("admin", "user", "add", "storage", access, password)
mc(
"admin",
"policy",
"attach",
"storage",
"messenger-attachments",
"--user",
access,
)
print("MinIO private bucket and API policy configured", flush=True)
if __name__ == "__main__":
try:
main()
except Exception as error:
print("MinIO bootstrap failed: " + type(error).__name__, flush=True)
raise SystemExit(1) from None
+140
View File
@@ -0,0 +1,140 @@
# Единая точка входа: round-robin между API-репликами, без sticky sessions.
# Директивы рассчитаны на закреплённый nginx:1.28.0-alpine.
worker_processes 2;
events {
worker_connections 1024;
}
http {
# В логе используем request_id ответа API, для собственных ошибок — id nginx.
map $upstream_http_x_request_id $response_request_id {
"" $request_id;
default $upstream_http_x_request_id;
}
log_format requests escape=json
'{"time":"$time_iso8601","request_id":"$response_request_id",'
'"method":"$request_method","uri":"$uri","status":$status,'
'"bytes":$body_bytes_sent,"request_time":$request_time,'
'"upstream":"$upstream_addr","upstream_status":"$upstream_status",'
'"upstream_time":"$upstream_response_time",'
'"instance_id":"$upstream_http_x_instance_id",'
'"limit_status":"$limit_req_status"}';
access_log /dev/stdout requests;
error_log /dev/stderr warn;
server_tokens off;
# DNS Docker возвращает адреса всех реплик сервиса api.
resolver 127.0.0.11 valid=5s ipv6=off;
resolver_timeout 1s;
# Общий для worker-процессов лимит на IP, который видит nginx.
# Клиентский X-Forwarded-For не используется в качестве ключа лимита.
limit_req_zone $binary_remote_addr zone=per_client:10m rate=50r/s;
gzip on;
gzip_vary on;
gzip_min_length 1024;
gzip_comp_level 3;
gzip_types application/json;
upstream api_backend {
zone api_backend 64k;
server api:8080 resolve max_fails=1 fail_timeout=5s;
# Кэш свободных соединений на worker, а не лимит запросов к API.
keepalive 16;
keepalive_timeout 4s;
}
server {
listen 8080;
client_header_timeout 10s;
client_body_timeout 10s;
# Размер ограничивает API при чтении, включая chunked-передачу.
client_max_body_size 0;
client_body_buffer_size 64k;
send_timeout 10s;
keepalive_timeout 30s;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_connect_timeout 500ms;
proxy_send_timeout 10s;
proxy_read_timeout 10s;
# Пассивное обнаружение отказов; Docker healthcheck сам не управляет LB.
# non_idempotent не включён: уже отправленные POST не повторяем.
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_next_upstream_tries 2;
# Окно перехода на другой backend, не общий deadline ответа.
proxy_next_upstream_timeout 2s;
# JSON и заголовки ошибок API передаются без подмены.
proxy_intercept_errors off;
error_page 429 = @rate_limited;
error_page 502 503 504 = @unavailable;
# Проверка самого LB для healthcheck в compose; не проксируется в API.
location = /lb-health {
access_log off;
default_type text/plain;
return 200 "ok\n";
}
# Проверки готовности/жизни не расходуют бюджет бизнес-запросов.
location /health/ {
proxy_pass http://api_backend;
}
location / {
limit_req zone=per_client burst=100 nodelay;
limit_req_status 429;
limit_req_log_level warn;
proxy_pass http://api_backend;
}
location ~ ^/api/v1/chats/[^/]+/attachments$ {
limit_req zone=per_client burst=100 nodelay;
limit_req_status 429;
proxy_request_buffering off;
proxy_buffering off;
proxy_read_timeout 65s;
proxy_send_timeout 15s;
# Ошибка одного upload не должна скрыть работающую реплику для чатов.
proxy_next_upstream off;
proxy_pass http://api_backend;
}
location ~ ^/api/v1/attachments/[^/]+/content$ {
limit_req zone=per_client burst=100 nodelay;
limit_req_status 429;
proxy_buffering off;
proxy_read_timeout 65s;
proxy_pass http://api_backend;
}
# Это ответы балансировщика: X-Instance-Id реплики у них отсутствует.
location @rate_limited {
default_type application/json;
add_header X-Request-Id $request_id always;
add_header Retry-After 1 always;
return 429 '{"error":{"code":"rate_limited","message":"Request rate exceeded","request_id":"$request_id"}}';
}
location @unavailable {
default_type application/json;
add_header X-Request-Id $request_id always;
add_header Retry-After 1 always;
return 503 '{"error":{"code":"unavailable","message":"API temporarily unavailable","request_id":"$request_id"}}';
}
}
}

Some files were not shown because too many files have changed in this diff Show More