39 changed files with 4011 additions and 26 deletions
+16 -9
View File
@@ -1,20 +1,27 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
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
# PostgreSQL credentials and database configuration
POSTGRES_USER=postgres
POSTGRES_PASSWORD=postgres
POSTGRES_DB=messenger
DATABASE_URL=postgresql://postgres:postgres@postgres:5432/messenger
# Redis session store configuration
SESSION_STORE=redis
CACHE_URL=redis://redis:6379/0
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
S3_ENDPOINT=http://s3:9000
# MinIO configuration
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
S3_ACCESS_KEY_ID=minioadmin
S3_SECRET_ACCESS_KEY=minioadmin
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
+1
View File
@@ -25,6 +25,7 @@ bin/
obj/
coverage/
*.log
!evidence/*.log
.DS_Store
.idea/
.vscode/
+27
View File
@@ -0,0 +1,27 @@
FROM python:3.12-slim
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
APP_HOST=0.0.0.0 \
APP_PORT=8080
RUN groupadd -g 10001 appuser && \
useradd -u 10001 -g appuser -s /sbin/nologin -M appuser
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app/ ./app/
RUN chown -R appuser:appuser /app
USER appuser
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready')" || exit 1
CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080", "--timeout-graceful-shutdown", "10"]
+16 -1
View File
@@ -4,10 +4,12 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence test-failover
.PHONY: help check validate test load test-persistence test-failover test-student up down restart
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "test-student: run student tests (pytest); test-persistence: test stack restart with data preservation"
@echo "test-failover: test replica failure handling; up: build and start stack; down: stop stack"
check:
$(PYTHON) scripts/check_contract.py
@@ -28,3 +30,16 @@ test-persistence:
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)
test-student:
BASE_URL="$(BASE_URL)" .venv/bin/pytest tests_student/ -v
up:
docker compose up -d --build
down:
docker compose down
restart:
docker compose restart
+154 -16
View File
@@ -1,37 +1,175 @@
# Отчёт — лабораторная 4
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Герейханов Ильяс, БВТ2301
- Целевая оценка: 4
- Commit/PR: ветка `solution/bvt2301-Gereykhanov`. PR: `ЛР 4 — БВТ2301 — Герейханов — на 4`
- Использованные источники, библиотеки и помощь ИИ: Python 3.12, FastAPI, Uvicorn, PostgreSQL 16, Redis 7, Nginx 1.27, MinIO, boto3, Pillow, asyncpg, argon2-cffi, Pydantic, Pytest, Docker Compose; документация AWS S3 API, RFC 7231, OpenAPI 3.1.0. ИИ использовался для подготовки скриптов, отладки конфигурации nginx и расширения тестов pytest.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
1. **Версии runtime и образов:**
- Локальный runtime: Linux, Docker 29.9.1, Docker Compose v5.6.0
- Load Balancer: `nginx:1.27-alpine`
- API контейнеры: `python:3.12-slim`
- PostgreSQL: `postgres:16-alpine`
- Redis: `redis:7-alpine`
- S3-совместимое хранилище: `cleanstart/minio:0.20260330.001845`
2. **Подготовка окружения и запуск стека:**
```sh
git checkout solution/bvt2301-Gereykhanov
cp .env.example .env
# Сборка и запуск всех сервисов
make up
```
3. **Ожидание готовности и запуск проверок:**
```sh
# Проверка структуры и синтаксиса
make check
# Валидация схемы OpenAPI
make validate PYTHON=.venv/bin/python
# Проверка smoke теста
make test
# Проверка сценария сохранности данных и сессий при рестарте
make test-persistence ACTION_SCRIPT=scripts/restart.sh
# Проверка отказоустойчивости при отключении одной API-реплики
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
# Восстановление остановленной реплики после теста
docker compose up -d
# Запуск собственных тестов
make test-student
# Запуск нагрузочного теста
python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load.json
```
4. **Остановка и очистка:**
```sh
# Остановка с сохранением данных volumes
docker compose down
# Остановка с удалением volumes
docker compose down -v
```
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
- **Топология процессов и распределение ролей:**
- **Клиент** отправляет все HTTP-запросы в единую точку входа **Nginx Load Balancer** на порт `8080`.
- **Nginx** осуществляет Round-Robin балансировку между двумя независимыми репликами API (`api-1` и `api-2`).
- Реплики API работают в stateless-режиме, не имеют открытых портов на хост и доступны только через балансировщик.
- Каждая реплика API обращается к общему **PostgreSQL**, **Redis** и **MinIO S3**.
- Отдельный одноразовый контейнер **migration** применяет `init.sql` перед стартом API-реплик.
- **Хранилища данных и источник истины:**
- **PostgreSQL:** источник истины для реляционных данных пользователей, чатов, сообщений и метаданных вложений в таблице `attachments` (`id`, `chat_id`, `owner_id`, `filename`, `content_type`, `size_bytes`, `sha256`, `s3_key`, `status`, `error_code`, `created_at`, `updated_at`).
- **MinIO S3:** хранилище бинарного контента в приватном бакете `messenger-attachments`. Ключи объектов формируются по схеме `chats/{chat_id}/{attachment_id}/{filename}`.
- **Redis:** сессионный кэш Bearer-токенов с TTL 3600 с и сохранением на volume `redis_data` через `--appendonly yes`.
- **Что перенесено из лабы 3:**
- Балансировщик Nginx с Round-robin 50/50 и `proxy_next_upstream` для быстрого переключения при сбое.
- Сквозные заголовки `X-Request-Id` и `X-Instance-Id` в ответах API.
- Единое хранилище сессий в Redis.
- Идемпотентность отправки сообщений по заголовку `Idempotency-Key` с сохранением `request_hash` в БД.
- Keyset-пагинация сообщений по индексу.
- **Интеграция S3 и изоляция сети:**
- MinIO включен во внутреннюю Docker-сеть с постоянным volume `minio_data`.
- Порты MinIO не проброшены на хост наружу, консоль закрыта от общей сети.
- При старте API выполняется автоматический идемпотентный bootstrap: проверка и создание бакета `messenger-attachments` через `boto3`.
- **Загрузка, валидация и защита от атак:**
- Эндпоинт `POST /api/v1/chats/{chat_id}/attachments?filename=...` принимает сырое бинарное тело (PNG/JPEG) до 10 MiB.
- **Проверка MIME по содержимому:** проверяются магические сигнатуры байтов. Невалидные форматы отклоняются с кодом `415`.
- **Защита от decompression bomb:** через библиотеку `Pillow` считываются размеры изображения из заголовков IHDR/SOF без декомпрессии растра в память. Превышение лимита 40 млн пикселей возвращает `413 payload_too_large`.
- **Валидация имени файла (`filename`):** длина 1–255 символов; отклоняются path-traversal последовательности, NUL-байт (`\0`) и управляющие символы с кодом `400 invalid_request`.
- **Компенсация сиротских объектов и прямой download:**
- Файл сначала сохраняется в S3 через `boto3.put_object`, после чего выполняется запись метаданных в базу. При ошибке в БД блок `except` вызывает `s3_client.delete_object`, удаляя объект из S3.
- Скачивание через `GET /api/v1/attachments/{id}/content` возвращает байты напрямую из S3 без 302/307 редиректов. Запрос от постороннего возвращает строго `404 not_found`.
- **Связывание с сообщениями и настройки Nginx:**
- В таблицу `messages` добавлено поле `attachment_ids UUID[]`.
- Разрешена отправка сообщения с пустым текстом `text=""`, если прикреплены файлы.
- В `infra/nginx.conf` задана директива `client_max_body_size 15M;` для пропуска 10 MiB загрузок.
- Все параметры согласованы с `.env.example`: `S3_ENDPOINT`, `S3_BUCKET`, `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS`.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Проверка синтаксиса и контракта | `make check` | `PASS: offline skeleton structure, local refs and Python syntax` | [`evidence/check_contract.log`](evidence/check_contract.log) |
| Полная OpenAPI 3.1 валидация | `make validate PYTHON=.venv/bin/python` | `PASS: full OpenAPI 3.1 and JSON Schema validation` | [`evidence/validate_openapi.log`](evidence/validate_openapi.log) |
| Публичный smoke тест | `make test` | `PASS: lab4 public API scenario` | [`evidence/smoke_test.log`](evidence/smoke_test.log) |
| Чередование реплик | `for i in {1..10}; do curl -sI http://localhost:8080/health/live \| grep -i x-instance-id; done` | 50 на 50 ответы `api-1` и `api-2` | [`evidence/round_robin.log`](evidence/round_robin.log) |
| Сохранение данных и сессий при рестарте | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | Стек перезапущен, токен, сообщения и вложения в S3 сохранены | [`evidence/persistence_test.log`](evidence/persistence_test.log) |
| Отказ API-реплики под нагрузкой | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | Восстановление записи за **0.778 с**, 105 успешных запросов, 0 сбоев | [`evidence/failover_test.log`](evidence/failover_test.log) |
| Защита от decompression bomb (>40M px) | `make test-student` | Запрос с 50M px изображением отклонен с `413 payload_too_large` | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Проверка MIME по магическим байтам | `make test-student` | Поддельные и поврежденные изображения отклоняются с `415` | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Компенсация сирот S3 при отказе БД | `make test-student` | При сбое PostgreSQL объект удаляется из S3, в хранилище нет сирот | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Закрытый бакет и лимит RAM (10 загрузок) | `make test-student` | Порт 9000 закрыт снаружи, 10 параллельных загрузок успешны, RAM стабильна | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Собственные тесты | `make test-student` | **34 теста проходят**: валидация вложений, компенсация S3, курсор, идемпотентность | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Статусы и изоляция контейнеров | `docker compose ps` | Все 6 сервисов healthy, API и MinIO не открывают порты на хост | [`evidence/docker_services.log`](evidence/docker_services.log) |
| Нагрузочный тест | `make load` | **309.4 RPS**, p50 = 7.9 ms, p95 = 40.8 ms, p99 = 63.0 ms, 0 ошибок | [`evidence/load.json`](evidence/load.json) |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
- **Профиль нагрузки:** скрипт `tests/load.py`, закрытый цикл параллельных POST-запросов отправки сообщений с уникальными `Idempotency-Key`.
- **Параметры:** длительность 30 секунд, 4 параллельных потока.
- **Результаты нагрузки (`evidence/load.json`):**
```json
{
"lab": 4,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.015,
"concurrency": 4,
"successful_requests": 9286,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 309.375,
"successful_latency_ms": {
"p50": 7.928,
"p95": 40.768,
"p99": 62.963
}
}
```
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Остановка одной реплики API (`scripts/stop-one.sh`) | Nginx переключает трафик на живую реплику, продолжение записи $\le 10$ с, нет дубликатов | 105 успешных записей во время остановки, 0 ошибок, переключение за 0.778 с | 0.778 сек, потерь данных нет |
| Рестарт всего стека (`scripts/restart.sh`) при активной сессии| Сохранение подтверждённых данных в Postgres, токенов сессий в Redis и файлов в MinIO | Контейнеры перезапущены, токен валиден, история сообщений и файлы сохранены | Восстановление около 5 сек, потеря подтверждённых данных: 0 |
| Загрузка декомпрессионной бомбы (изображение 10000x5000) | Отклонение запроса с кодом 413 `payload_too_large` без исчерпания RAM | Запрос отклонен мгновенно по метаданным IHDR без распаковки растра | Мгновенно (< 2 мс) |
| Загрузка файла размером более 10 MiB | Отклонение запроса с кодом 413 `payload_too_large` | Запрос отклонен до сохранения в S3 | Мгновенно |
| Попытка загрузки файла с поддельным расширением | Отклонение с кодом 415 `unsupported_media_type` | Проверка сигнатуры байтов выявляет подмену и возвращает 415 | Мгновенно |
| Попытка доступа к метаданным или контенту посторонним пользователем | Защита приватности: возврат строго 404 Not Found без утечки факта существования файла | Посторонний получает 404 на `GET /attachments/{id}` и `/content` | Мгновенно |
| Попытка передачи опасного имени файла | Отклонение запроса с кодом 400 `invalid_request` | Валидатор отклоняет некорректное имя до обращения к хранилищу | Мгновенно |
| Сбой сохранения метаданных в БД после успешного `PUT` в S3 | Автоматическое удаление объекта из S3 | В S3 не остается мусорных файлов | Мгновенно |
| Конкурентная загрузка ≥10 файлов с контролем RAM | Все файлы сохраняются в S3, память API стабильна | 10 параллельных загрузок вернули 201 ready, утечек памяти нет | Мгновенно (< 1 с) |
| Попытка прямого обращения к MinIO на порт 9000 с хоста | Соединение отклоняется (Connection Refused), консоль закрыта | Порты MinIO не проброшены наружу, прямой доступ невозможен | Мгновенно |
## Ограничения и следующие шаги
## Ограничения
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- **Какие отказы выдерживаются и какие нет:**
1. *Выдерживаются:*
- Внезапная остановка любой одной API-реплики под нагрузкой: балансировщик Nginx переключает входящие запросы на оставшуюся реплику.
- Полный рестарт стека: все подтверждённые данные, активные токены и файлы в S3 сохраняются благодаря volumes.
- Конкурентная отправка сообщений с одинаковым `Idempotency-Key` в разные реплики.
- Попытки атак декомпрессионными бомбами и внедрения вредоносных имен файлов.
- Сбои транзакций после записи в S3: механизм компенсации удаляет сиротские объекты.
2. *Не выдерживаются:*
- Одновременное падение обеих API-реплик (HTTP 502 Bad Gateway).
- Падение единственного экземпляра PostgreSQL, Redis или MinIO.
- Удаление через `docker compose down -v`.
- **Учебные упрощения:**
1. Nginx, PostgreSQL, Redis и MinIO запущены в единственном экземпляре без распределенной репликации.
2. Скачивание контента реализовано через проксирование байтов API-репликой.
+1
View File
@@ -0,0 +1 @@
"""Messenger application package."""
+27
View File
@@ -0,0 +1,27 @@
from __future__ import annotations
import secrets
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError
_hasher = PasswordHasher()
def hash_password(password: str) -> str:
"""Хэширует пароль с использованием Argon2id."""
return _hasher.hash(password)
def verify_password(hash_str: str, password: str) -> bool:
"""Проверяет пароль на соответствие хэшу Argon2id."""
try:
return _hasher.verify(hash_str, password)
except VerifyMismatchError:
return False
except Exception:
return False
def generate_session_token() -> str:
"""Генерирует криптографически стойкий непрозрачный токен сессии (256 бит энтропии)."""
return secrets.token_urlsafe(32)
+44
View File
@@ -0,0 +1,44 @@
from __future__ import annotations
import os
import socket
from pathlib import Path
def _get_val(env_name: str, file_env_name: str | None = None, default: str = "") -> str:
if file_env_name and file_env_name in os.environ:
file_path = Path(os.environ[file_env_name])
if file_path.is_file():
return file_path.read_text(encoding="utf-8").strip()
return os.getenv(env_name, default)
APP_HOST: str = os.getenv("APP_HOST", "0.0.0.0")
APP_PORT: int = int(os.getenv("APP_PORT", "8080"))
APP_ENV: str = os.getenv("APP_ENV", "lab")
LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
SESSION_TTL_SECONDS: int = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
SESSION_STORE: str = os.getenv("SESSION_STORE", "redis").lower()
INSTANCE_ID: str = os.getenv("INSTANCE_ID") or socket.gethostname() or "api-1"
IDEMPOTENCY_TTL_SECONDS: int = int(os.getenv("IDEMPOTENCY_TTL_SECONDS", "86400"))
DATABASE_URL: str = _get_val(
"DATABASE_URL",
"DATABASE_URL_FILE",
"postgresql://postgres:postgres@postgres:5432/messenger",
)
CACHE_URL: str = _get_val(
"CACHE_URL",
"CACHE_URL_FILE",
"redis://redis:6379/0",
)
S3_ENDPOINT: str = os.getenv("S3_ENDPOINT", "http://minio:9000")
S3_REGION: str = os.getenv("S3_REGION", "us-east-1")
S3_BUCKET: str = os.getenv("S3_BUCKET", "messenger-attachments")
S3_ACCESS_KEY_ID: str = _get_val("S3_ACCESS_KEY_ID", "S3_ACCESS_KEY_ID_FILE", "minioadmin")
S3_SECRET_ACCESS_KEY: str = _get_val("S3_SECRET_ACCESS_KEY", "S3_SECRET_ACCESS_KEY_FILE", "minioadmin")
MAX_UPLOAD_BYTES: int = int(os.getenv("MAX_UPLOAD_BYTES", "10485760"))
MAX_IMAGE_PIXELS: int = int(os.getenv("MAX_IMAGE_PIXELS", "40000000"))
+30
View File
@@ -0,0 +1,30 @@
from __future__ import annotations
from fastapi import Depends, Header, Request
from app.errors import UnauthorizedError
from app.schemas import UserResponse
from app.storage import storage
async def get_current_token(
authorization: str | None = Header(default=None, alias="Authorization"),
) -> str:
if not authorization or not authorization.strip():
raise UnauthorizedError("Отсутствует заголовок Authorization")
parts = authorization.strip().split(maxsplit=1)
if len(parts) != 2 or parts[0].lower() != "bearer":
raise UnauthorizedError("Неверная схема авторизации (ожидается Bearer)")
token = parts[1].strip()
if not token:
raise UnauthorizedError("Пустой Bearer токен")
return token
async def get_current_user(token: str = Depends(get_current_token)) -> UserResponse:
user = await storage.get_session_user(token)
if not user:
raise UnauthorizedError("Недействительная или истекшая сессия")
return user
+260
View File
@@ -0,0 +1,260 @@
import asyncio
import logging
import uuid
import asyncpg
import botocore.exceptions
from fastapi import FastAPI, Request, status
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
import redis.exceptions
from starlette.exceptions import HTTPException as StarletteHTTPException
from app.config import INSTANCE_ID
from app.schemas import ErrorCode, ErrorDetail, ErrorResponse
class StorageError(Exception):
pass
class UnavailableError(StorageError):
pass
class InvalidRequestError(StorageError):
pass
class NotFoundError(StorageError):
pass
class ConflictError(StorageError):
pass
class PayloadTooLargeError(StorageError):
pass
class UnsupportedMediaTypeError(StorageError):
pass
class UnauthorizedError(StorageError):
pass
logger = logging.getLogger("app.errors")
def get_request_id(request: Request) -> str:
req_id = getattr(request.state, "request_id", None)
if not req_id:
req_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
return req_id
def make_error_response(
status_code: int,
code: ErrorCode,
message: str,
request_id: str,
headers: dict[str, str] | None = None,
) -> JSONResponse:
payload = ErrorResponse(
error=ErrorDetail(code=code, message=message, request_id=request_id)
).model_dump()
resp_headers = {
"X-Request-Id": request_id,
"X-Instance-Id": INSTANCE_ID,
"Content-Type": "application/json",
}
if headers:
resp_headers.update(headers)
return JSONResponse(
status_code=status_code,
content=payload,
headers=resp_headers,
)
def register_error_handlers(app: FastAPI) -> None:
@app.exception_handler(InvalidRequestError)
async def invalid_request_handler(
request: Request, exc: InvalidRequestError
) -> JSONResponse:
req_id = get_request_id(request)
return make_error_response(
status.HTTP_400_BAD_REQUEST, ErrorCode.INVALID_REQUEST, str(exc), req_id
)
@app.exception_handler(UnauthorizedError)
async def unauthorized_handler(
request: Request, exc: UnauthorizedError
) -> JSONResponse:
req_id = get_request_id(request)
scheme = (
'Basic realm="messenger", charset="UTF-8"'
if request.url.path == "/api/v1/auth/sessions"
else 'Bearer realm="messenger"'
)
return make_error_response(
status.HTTP_401_UNAUTHORIZED,
ErrorCode.UNAUTHORIZED,
str(exc),
req_id,
headers={"WWW-Authenticate": scheme},
)
@app.exception_handler(NotFoundError)
async def not_found_handler(request: Request, exc: NotFoundError) -> JSONResponse:
req_id = get_request_id(request)
return make_error_response(
status.HTTP_404_NOT_FOUND, ErrorCode.NOT_FOUND, str(exc), req_id
)
@app.exception_handler(ConflictError)
async def conflict_handler(request: Request, exc: ConflictError) -> JSONResponse:
req_id = get_request_id(request)
return make_error_response(
status.HTTP_409_CONFLICT, ErrorCode.CONFLICT, str(exc), req_id
)
@app.exception_handler(PayloadTooLargeError)
async def payload_too_large_handler(
request: Request, exc: PayloadTooLargeError
) -> JSONResponse:
req_id = get_request_id(request)
return make_error_response(
status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
ErrorCode.PAYLOAD_TOO_LARGE,
str(exc),
req_id,
)
@app.exception_handler(UnsupportedMediaTypeError)
async def unsupported_media_type_handler(
request: Request, exc: UnsupportedMediaTypeError
) -> JSONResponse:
req_id = get_request_id(request)
return make_error_response(
status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
ErrorCode.UNSUPPORTED_MEDIA_TYPE,
str(exc),
req_id,
)
@app.exception_handler(RequestValidationError)
async def validation_error_handler(
request: Request, exc: RequestValidationError
) -> JSONResponse:
req_id = get_request_id(request)
errors = exc.errors()
messages = []
for err in errors:
loc = ".".join(str(x) for x in err.get("loc", []) if x != "body")
msg = err.get("msg", "invalid")
messages.append(f"{loc}: {msg}" if loc else msg)
detail_msg = "; ".join(messages) or "Некорректное тело запроса или параметры"
return make_error_response(
status.HTTP_400_BAD_REQUEST, ErrorCode.INVALID_REQUEST, detail_msg, req_id
)
@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(
request: Request, exc: StarletteHTTPException
) -> JSONResponse:
req_id = get_request_id(request)
code = ErrorCode.INTERNAL_ERROR
extra_headers: dict[str, str] = {}
if exc.status_code == 400:
code = ErrorCode.INVALID_REQUEST
elif exc.status_code == 401:
code = ErrorCode.UNAUTHORIZED
scheme = (
'Basic realm="messenger", charset="UTF-8"'
if request.url.path == "/api/v1/auth/sessions"
else 'Bearer realm="messenger"'
)
extra_headers["WWW-Authenticate"] = scheme
elif exc.status_code == 404:
code = ErrorCode.NOT_FOUND
elif exc.status_code == 409:
code = ErrorCode.CONFLICT
elif exc.status_code == 413:
code = ErrorCode.PAYLOAD_TOO_LARGE
elif exc.status_code == 415:
code = ErrorCode.UNSUPPORTED_MEDIA_TYPE
elif exc.status_code == 429:
code = ErrorCode.RATE_LIMITED
elif exc.status_code == 503:
code = ErrorCode.UNAVAILABLE
msg = exc.detail if isinstance(exc.detail, str) else "HTTP ошибка"
return make_error_response(
exc.status_code, code, msg, req_id, headers=extra_headers
)
async def dependency_unavailable_handler(
request: Request, exc: Exception
) -> JSONResponse:
req_id = get_request_id(request)
logger.warning(
"Upstream storage dependency unavailable for request %s: %s",
req_id,
exc,
)
return make_error_response(
status.HTTP_503_SERVICE_UNAVAILABLE,
ErrorCode.UNAVAILABLE,
"Зависимость недоступна",
req_id,
)
for exc_cls in (
UnavailableError,
asyncpg.PostgresError,
asyncpg.InterfaceError,
redis.exceptions.RedisError,
botocore.exceptions.BotoCoreError,
botocore.exceptions.ClientError,
TimeoutError,
asyncio.TimeoutError,
ConnectionError,
OSError,
):
app.add_exception_handler(exc_cls, dependency_unavailable_handler)
@app.exception_handler(Exception)
async def unhandled_exception_handler(
request: Request, exc: Exception
) -> JSONResponse:
req_id = get_request_id(request)
if isinstance(
exc,
(
UnavailableError,
asyncpg.PostgresError,
asyncpg.InterfaceError,
redis.exceptions.RedisError,
botocore.exceptions.BotoCoreError,
botocore.exceptions.ClientError,
TimeoutError,
asyncio.TimeoutError,
ConnectionError,
OSError,
),
):
return await dependency_unavailable_handler(request, exc)
logger.error(
"Unhandled exception for request %s: %s", req_id, exc, exc_info=True
)
return make_error_response(
status.HTTP_500_INTERNAL_SERVER_ERROR,
ErrorCode.INTERNAL_ERROR,
"Внутренняя ошибка сервера",
req_id,
)
+61
View File
@@ -0,0 +1,61 @@
from __future__ import annotations
import logging
from contextlib import asynccontextmanager
import uvicorn
from fastapi import FastAPI
from app.config import APP_HOST, APP_PORT, LOG_LEVEL
from app.errors import register_error_handlers
from app.middleware import RequestIdAndLoggingMiddleware
from app.routes.attachments import router as attachments_router
from app.routes.auth import router as auth_router
from app.routes.chats import router as chats_router
from app.routes.health import router as health_router
from app.routes.messages import router as messages_router
from app.routes.users import router as users_router
from app.storage import storage
logger = logging.getLogger("app.lifecycle")
@asynccontextmanager
async def lifespan(app: FastAPI):
logger.info(
"Starting messenger server on %s:%d (env: %s)", APP_HOST, APP_PORT, LOG_LEVEL
)
await storage.connect()
yield
logger.info("Graceful shutdown: closing connections...")
await storage.disconnect()
app = FastAPI(
title="highload-messenger",
version="1.4.0",
docs_url="/docs",
redoc_url=None,
lifespan=lifespan,
)
app.add_middleware(RequestIdAndLoggingMiddleware)
register_error_handlers(app)
app.include_router(health_router)
app.include_router(auth_router)
app.include_router(users_router)
app.include_router(chats_router)
app.include_router(messages_router)
app.include_router(attachments_router)
if __name__ == "__main__":
uvicorn.run(
"app.main:app",
host=APP_HOST,
port=APP_PORT,
log_level=LOG_LEVEL.lower(),
timeout_graceful_shutdown=10,
)
+93
View File
@@ -0,0 +1,93 @@
from __future__ import annotations
import logging
import sys
import time
import uuid
from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
from starlette.requests import Request
from starlette.responses import Response
from app.config import INSTANCE_ID
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
stream=sys.stdout,
)
logger = logging.getLogger("app.access")
class RequestIdAndLoggingMiddleware(BaseHTTPMiddleware):
async def dispatch(
self, request: Request, call_next: RequestResponseEndpoint
) -> Response:
# Получаем X-Request-Id или генерируем новый
request_id = request.headers.get("X-Request-Id")
if not request_id or not request_id.strip():
request_id = str(uuid.uuid4())
request.state.request_id = request_id
start_time = time.monotonic()
if request.method in ("POST", "PUT", "PATCH") and request.url.path != "/api/v1/auth/sessions":
is_attachment_upload = (
request.method == "POST"
and "/attachments" in request.url.path
and request.url.path.startswith("/api/v1/chats/")
)
ct = request.headers.get("content-type")
ct_clean = ct.split(";")[0].strip().lower() if ct else ""
if is_attachment_upload:
if not ct or ct_clean not in ("image/png", "image/jpeg"):
from fastapi import status
from app.errors import make_error_response
from app.schemas import ErrorCode
return make_error_response(
status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
ErrorCode.UNSUPPORTED_MEDIA_TYPE,
f"Неподдерживаемый тип содержимого '{ct}'. Ожидается image/png или image/jpeg",
request_id,
)
elif ct and ct_clean != "application/json":
from fastapi import status
from app.errors import make_error_response
from app.schemas import ErrorCode
return make_error_response(
status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
ErrorCode.UNSUPPORTED_MEDIA_TYPE,
f"Неподдерживаемый тип содержимого '{ct}'. Ожидается application/json",
request_id,
)
try:
response = await call_next(request)
except Exception:
# Исключение перехватится exception_handler
duration_ms = (time.monotonic() - start_time) * 1000
logger.error(
"%s %s -> 500 error | duration=%.2fms | request_id=%s",
request.method,
request.url.path,
duration_ms,
request_id,
)
raise
duration_ms = (time.monotonic() - start_time) * 1000
response.headers["X-Request-Id"] = request_id
response.headers["X-Instance-Id"] = INSTANCE_ID
# лог без логирования тела запросов и текстов сообщений
logger.info(
"%s %s -> %d | duration=%.2fms | request_id=%s",
request.method,
request.url.path,
response.status_code,
duration_ms,
request_id,
)
return response
View File
+85
View File
@@ -0,0 +1,85 @@
from uuid import UUID
from fastapi import APIRouter, Depends, Query, Request, Response, status
from app.dependencies import get_current_user
from app.errors import InvalidRequestError
from app.schemas import AttachmentResponse, UserResponse
from app.storage import storage
router = APIRouter(tags=["attachments"])
def validate_uuid(value: str, field_name: str = "id") -> str:
try:
UUID(value)
return value
except ValueError as exc:
raise InvalidRequestError(f"Поле '{field_name}' не является валидным UUID") from exc
@router.post(
"/api/v1/chats/{chat_id}/attachments",
response_model=AttachmentResponse,
status_code=status.HTTP_201_CREATED,
)
async def upload_attachment(
chat_id: str,
request: Request,
filename: str = Query(..., min_length=1, max_length=255),
current_user: UserResponse = Depends(get_current_user),
) -> AttachmentResponse:
"""Загрузка бинарного вложения в чат."""
valid_chat_id = validate_uuid(chat_id, "chat_id")
content_type = request.headers.get("content-type") or ""
data = await request.body()
return await storage.upload_attachment(
caller_id=current_user.id,
chat_id=valid_chat_id,
filename=filename,
content_type=content_type,
data=data,
)
@router.get(
"/api/v1/attachments/{attachment_id}",
response_model=AttachmentResponse,
status_code=status.HTTP_200_OK,
)
async def get_attachment_metadata(
attachment_id: str,
current_user: UserResponse = Depends(get_current_user),
) -> AttachmentResponse:
"""Получение метаданных вложения."""
valid_att_id = validate_uuid(attachment_id, "attachment_id")
return await storage.get_attachment(
caller_id=current_user.id,
attachment_id=valid_att_id,
)
@router.get(
"/api/v1/attachments/{attachment_id}/content",
status_code=status.HTTP_200_OK,
)
async def download_attachment_content(
attachment_id: str,
variant: str | None = Query(default=None),
current_user: UserResponse = Depends(get_current_user),
) -> Response:
"""Скачивание бинарного содержимого вложения."""
valid_att_id = validate_uuid(attachment_id, "attachment_id")
data, content_type = await storage.get_attachment_content(
caller_id=current_user.id,
attachment_id=valid_att_id,
variant=variant,
)
return Response(
content=data,
media_type=content_type,
headers={
"Content-Length": str(len(data)),
},
)
+63
View File
@@ -0,0 +1,63 @@
from __future__ import annotations
import base64
from fastapi import APIRouter, Depends, Header, Request, Response, status
from app.dependencies import get_current_token
from app.errors import InvalidRequestError, UnauthorizedError
from app.schemas import SessionResponse
from app.storage import storage
router = APIRouter(prefix="/api/v1/auth/sessions", tags=["auth"])
@router.post("", response_model=SessionResponse, status_code=status.HTTP_201_CREATED)
async def create_session(
request: Request,
authorization: str | None = Header(default=None, alias="Authorization"),
) -> SessionResponse:
"""Аутентификация пользователя через Basic Auth и создание новой сессии."""
body = await request.body()
if body and body.strip():
raise InvalidRequestError("Тело запроса для создания сессии должно быть пустым")
if not authorization or not authorization.strip():
raise UnauthorizedError("Отсутствует заголовок Authorization")
parts = authorization.strip().split(maxsplit=1)
if len(parts) != 2 or parts[0].lower() != "basic":
raise UnauthorizedError("Неверная схема авторизации (ожидается Basic)")
try:
raw_bytes = base64.b64decode(parts[1].strip())
raw_str = raw_bytes.decode("utf-8")
if ":" not in raw_str:
raise UnauthorizedError("Некорректный формат Basic credentials")
username, password = raw_str.split(":", 1)
except Exception:
raise UnauthorizedError("Некорректный заголовок Basic авторизации")
user = await storage.authenticate_user(username, password)
if not user:
raise UnauthorizedError("Неверное имя пользователя или пароль")
session = await storage.create_session(user)
return session
@router.delete("/current", status_code=status.HTTP_204_NO_CONTENT)
async def delete_current_session(
request: Request,
token: str = Depends(get_current_token),
) -> Response:
"""Отзыв текущей сессии."""
body = await request.body()
if body and body.strip():
raise InvalidRequestError("Тело запроса для отзыва сессии должно быть пустым")
user = await storage.get_session_user(token)
if not user:
raise UnauthorizedError("Недействительная или уже отозванная сессия")
await storage.delete_session(token)
return Response(status_code=status.HTTP_204_NO_CONTENT)
+64
View File
@@ -0,0 +1,64 @@
from __future__ import annotations
from uuid import UUID
from fastapi import APIRouter, Depends, Query, status
from app.dependencies import get_current_user
from app.schemas import (
ChatPageResponse,
ChatResponse,
CreateChatRequest,
UserResponse,
)
from app.storage import InvalidRequestError, storage
router = APIRouter(prefix="/api/v1/chats", tags=["chats"])
def validate_uuid(value: str, field_name: str = "id") -> str:
try:
UUID(value)
return value
except ValueError as exc:
raise InvalidRequestError(f"Поле '{field_name}' не является валидным UUID") from exc
@router.post("", response_model=ChatResponse, status_code=status.HTTP_201_CREATED)
async def create_chat(
body: CreateChatRequest,
current_user: UserResponse = Depends(get_current_user),
) -> ChatResponse:
"""Создание нового чата."""
chat = await storage.create_chat(
caller_id=current_user.id,
title=body.title,
member_ids=body.member_ids,
)
return chat
@router.get("", response_model=ChatPageResponse, status_code=status.HTTP_200_OK)
async def list_chats(
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None),
current_user: UserResponse = Depends(get_current_user),
) -> ChatPageResponse:
"""Список чатов, в которых состоит текущий пользователь."""
items, next_cursor = await storage.list_chats(
caller_id=current_user.id,
limit=limit,
cursor=cursor,
)
return ChatPageResponse(items=items, next_cursor=next_cursor)
@router.get("/{chat_id}", response_model=ChatResponse, status_code=status.HTTP_200_OK)
async def get_chat(
chat_id: str,
current_user: UserResponse = Depends(get_current_user),
) -> ChatResponse:
"""Получение информации о чате по ID."""
valid_id = validate_uuid(chat_id, "chat_id")
chat = await storage.get_chat(caller_id=current_user.id, chat_id=valid_id)
return chat
+31
View File
@@ -0,0 +1,31 @@
from __future__ import annotations
from fastapi import APIRouter, status
from starlette.exceptions import HTTPException as StarletteHTTPException
from app.schemas import HealthResponse
from app.storage import storage
router = APIRouter(tags=["health"])
@router.get(
"/health/live", response_model=HealthResponse, status_code=status.HTTP_200_OK
)
async def health_live() -> HealthResponse:
"""Проверка жизни процесса (Liveness)."""
return HealthResponse(status="ok")
@router.get(
"/health/ready", response_model=HealthResponse, status_code=status.HTTP_200_OK
)
async def health_ready() -> HealthResponse:
"""Проверка готовности сервиса и его зависимостей (Readiness)."""
is_ready = await storage.check_health()
if not is_ready:
raise StarletteHTTPException(
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
detail="Сервис или его хранилища недоступны",
)
return HealthResponse(status="ok")
+74
View File
@@ -0,0 +1,74 @@
import re
from uuid import UUID
from fastapi import APIRouter, Depends, Header, Query, status
from app.dependencies import get_current_user
from app.schemas import (
CreateMessageRequest,
MessagePageResponse,
MessageResponse,
UserResponse,
)
from app.storage import InvalidRequestError, storage
router = APIRouter(prefix="/api/v1/chats", tags=["messages"])
IDEMPOTENCY_KEY_REGEX = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
def validate_uuid(value: str, field_name: str = "id") -> str:
try:
UUID(value)
return value
except ValueError as exc:
raise InvalidRequestError(f"Поле '{field_name}' не является валидным UUID") from exc
@router.post(
"/{chat_id}/messages",
response_model=MessageResponse,
status_code=status.HTTP_201_CREATED,
)
async def create_message(
chat_id: str,
body: CreateMessageRequest,
idempotency_key: str | None = Header(default=None, alias="Idempotency-Key"),
current_user: UserResponse = Depends(get_current_user),
) -> MessageResponse:
"""Отправка сообщения в чат."""
if not idempotency_key or not IDEMPOTENCY_KEY_REGEX.match(idempotency_key):
raise InvalidRequestError(
"Заголовок 'Idempotency-Key' обязателен и должен соответствовать шаблону ^[A-Za-z0-9._:-]{1,128}$"
)
valid_id = validate_uuid(chat_id, "chat_id")
msg = await storage.send_message(
caller_id=current_user.id,
chat_id=valid_id,
text=body.text,
idempotency_key=idempotency_key,
attachment_ids=body.attachment_ids,
)
return msg
@router.get(
"/{chat_id}/messages",
response_model=MessagePageResponse,
status_code=status.HTTP_200_OK,
)
async def list_messages(
chat_id: str,
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None),
current_user: UserResponse = Depends(get_current_user),
) -> MessagePageResponse:
"""Получение истории сообщений чата с keyset-пагинацией."""
valid_id = validate_uuid(chat_id, "chat_id")
items, next_cursor = await storage.list_messages(
caller_id=current_user.id,
chat_id=valid_id,
limit=limit,
cursor=cursor,
)
return MessagePageResponse(items=items, next_cursor=next_cursor)
+28
View File
@@ -0,0 +1,28 @@
from __future__ import annotations
from fastapi import APIRouter, Depends, status
from app.dependencies import get_current_user
from app.schemas import CreateUserRequest, UserResponse
from app.storage import storage
router = APIRouter(prefix="/api/v1/users", tags=["users"])
@router.post("", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
async def create_user(body: CreateUserRequest) -> UserResponse:
"""Регистрация нового пользователя."""
user = await storage.create_user(
username=body.username,
display_name=body.display_name,
password=body.password,
)
return user
@router.get("/me", response_model=UserResponse, status_code=status.HTTP_200_OK)
async def get_me(
current_user: UserResponse = Depends(get_current_user),
) -> UserResponse:
"""Получение профиля текущего пользователя."""
return current_user
+207
View File
@@ -0,0 +1,207 @@
from __future__ import annotations
import datetime as dt
import re
from enum import Enum
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
def now_utc_iso() -> str:
"""Возвращает текущее время в формате RFC 3339 UTC с суффиксом Z."""
return dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
class ErrorCode(str, Enum):
INVALID_REQUEST = "invalid_request"
UNAUTHORIZED = "unauthorized"
NOT_FOUND = "not_found"
CONFLICT = "conflict"
PAYLOAD_TOO_LARGE = "payload_too_large"
UNSUPPORTED_MEDIA_TYPE = "unsupported_media_type"
RATE_LIMITED = "rate_limited"
UNAVAILABLE = "unavailable"
INTERNAL_ERROR = "internal_error"
class ErrorDetail(BaseModel):
model_config = ConfigDict(extra="forbid")
code: ErrorCode
message: str = Field(min_length=1)
request_id: str = Field(min_length=1)
class ErrorResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
error: ErrorDetail
class HealthResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
status: str = Field(default="ok")
class CreateUserRequest(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True)
username: str = Field(min_length=3, max_length=32)
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
@field_validator("username")
@classmethod
def validate_username(cls, v: str) -> str:
if not re.match(r"^[a-z0-9_]{3,32}\Z", v):
raise ValueError("Имя пользователя должно соответствовать шаблону ^[a-z0-9_]{3,32}$")
return v
@field_validator("display_name")
@classmethod
def validate_display_name(cls, v: str) -> str:
if not v.strip():
raise ValueError("Отображаемое имя не может состоять только из пробелов")
return v
@field_validator("password")
@classmethod
def validate_password(cls, v: str) -> str:
if not v.strip():
raise ValueError("Пароль не может состоять только из пробелов")
return v
class UserResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
id: str
username: str
display_name: str
created_at: str
class SessionResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
token: str = Field(min_length=32)
token_type: str = Field(default="Bearer")
expires_at: str
user: UserResponse
class CreateChatRequest(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True)
title: str = Field(min_length=1, max_length=100)
member_ids: list[str] = Field(min_length=1, max_length=100)
@field_validator("title")
@classmethod
def validate_title(cls, v: str) -> str:
if not v.strip():
raise ValueError("Название не может состоять только из пробелов")
return v
@field_validator("member_ids")
@classmethod
def validate_member_ids(cls, v: list[str]) -> list[str]:
if len(v) != len(set(v)):
raise ValueError("Идентификаторы участников должны быть уникальными")
for member_id in v:
try:
UUID(member_id)
except ValueError:
raise ValueError(f"Идентификатор участника '{member_id}' не является валидным UUID")
return v
class ChatResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
id: str
title: str
member_ids: list[str]
created_at: str
class ChatPageResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
items: list[ChatResponse]
next_cursor: str | None = None
class VariantResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
name: str
content_type: str
size_bytes: int
width: int
height: int
sha256: str
class AttachmentResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
id: str
chat_id: str
owner_id: str
filename: str
content_type: str
size_bytes: int
sha256: str
status: str = "ready"
variants: list[VariantResponse] = Field(default_factory=list)
error_code: str | None = None
created_at: str
updated_at: str
class CreateMessageRequest(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True)
text: str = Field(default="", max_length=4000)
attachment_ids: list[str] = Field(default_factory=list, max_length=10)
@field_validator("attachment_ids")
@classmethod
def validate_attachment_ids(cls, v: list[str]) -> list[str]:
if len(v) != len(set(v)):
raise ValueError("attachment_ids must contain unique items")
for item in v:
try:
UUID(item)
except ValueError:
raise ValueError(f"Идентификатор вложения '{item}' не является валидным UUID")
return v
@model_validator(mode="after")
def check_text_or_attachment(self) -> CreateMessageRequest:
has_text = bool(self.text and self.text.strip())
has_attachments = bool(self.attachment_ids)
if not has_text and not has_attachments:
raise ValueError("Сообщение должно содержать непустой текст или хотя бы одно вложение")
return self
class MessageResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
id: str
chat_id: str
sender_id: str
text: str
created_at: str
attachment_ids: list[str] = Field(default_factory=list)
class MessagePageResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
items: list[MessageResponse]
next_cursor: str | None = None
+949
View File
@@ -0,0 +1,949 @@
import asyncio
import base64
from contextlib import asynccontextmanager
import datetime as dt
import hashlib
import json
import logging
import uuid
from typing import Any
import asyncpg
import redis.asyncio as redis
import io
import boto3
import botocore.exceptions
from PIL import Image
from app.auth import generate_session_token, hash_password, verify_password
from app.config import (
CACHE_URL,
DATABASE_URL,
SESSION_TTL_SECONDS,
S3_ENDPOINT,
S3_REGION,
S3_BUCKET,
S3_ACCESS_KEY_ID,
S3_SECRET_ACCESS_KEY,
MAX_UPLOAD_BYTES,
MAX_IMAGE_PIXELS,
)
from app.errors import (
ConflictError,
InvalidRequestError,
NotFoundError,
PayloadTooLargeError,
UnauthorizedError,
UnsupportedMediaTypeError,
)
from app.schemas import (
AttachmentResponse,
ChatResponse,
MessageResponse,
SessionResponse,
UserResponse,
VariantResponse,
now_utc_iso,
)
logger = logging.getLogger("app.storage")
def encode_cursor(data: dict) -> str:
raw = json.dumps(data, separators=(",", ":")).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("utf-8").rstrip("=")
def decode_cursor(cursor_str: str) -> dict:
if not isinstance(cursor_str, str) or not cursor_str.strip():
raise InvalidRequestError("Некорректный курсор")
try:
padded = cursor_str + "=" * (-len(cursor_str) % 4)
raw = base64.urlsafe_b64decode(padded.encode("utf-8"))
data = json.loads(raw.decode("utf-8"))
if not isinstance(data, dict):
raise InvalidRequestError("Некорректный курсор")
return data
except InvalidRequestError:
raise
except Exception as exc:
raise InvalidRequestError("Некорректный курсор") from exc
def _format_dt(d: dt.datetime) -> str:
if d.tzinfo is None:
d = d.replace(tzinfo=dt.timezone.utc)
return d.astimezone(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def _to_text(val: Any) -> str:
if isinstance(val, (bytes, bytearray, memoryview)):
return bytes(val).decode("utf-8")
return str(val)
class PostgresStorage:
def __init__(self) -> None:
self.pg_pool: asyncpg.Pool | None = None
self.redis_client: redis.Redis | None = None
self.s3_client: Any = None
@asynccontextmanager
async def acquire_conn(self, timeout: float = 2.0):
if self.pg_pool is None:
raise asyncpg.InterfaceError("Пул подключений к PostgreSQL не инициализирован")
async with asyncio.timeout(3.0):
async with self.pg_pool.acquire(timeout=timeout) as conn:
yield conn
async def connect(self) -> None:
logger.info("Подключение к PostgreSQL: %s", DATABASE_URL.split("@")[-1])
self.pg_pool = await asyncpg.create_pool(
DATABASE_URL,
min_size=2,
max_size=20,
command_timeout=3.0,
timeout=2.0,
)
logger.info("Подключение к Redis: %s", CACHE_URL.split("@")[-1])
self.redis_client = redis.from_url(
CACHE_URL,
decode_responses=True,
socket_connect_timeout=2.0,
socket_timeout=2.0,
)
logger.info("Подключение к S3 (MinIO): %s, bucket: %s", S3_ENDPOINT, S3_BUCKET)
self.s3_client = boto3.client(
"s3",
endpoint_url=S3_ENDPOINT,
aws_access_key_id=S3_ACCESS_KEY_ID,
aws_secret_access_key=S3_SECRET_ACCESS_KEY,
region_name=S3_REGION,
)
await self._ensure_bucket()
async def _ensure_bucket(self) -> None:
def _init():
try:
self.s3_client.head_bucket(Bucket=S3_BUCKET)
except Exception:
try:
self.s3_client.create_bucket(Bucket=S3_BUCKET)
logger.info("Создан приватный бакет S3: %s", S3_BUCKET)
except Exception as e:
logger.warning("Не удалось создать бакет S3 %s: %s", S3_BUCKET, e)
await asyncio.to_thread(_init)
async def disconnect(self) -> None:
if self.pg_pool:
await self.pg_pool.close()
self.pg_pool = None
if self.redis_client:
await self.redis_client.close()
self.redis_client = None
self.s3_client = None
async def check_health(self) -> bool:
if not self.pg_pool or not self.redis_client or not self.s3_client:
return False
try:
async with asyncio.timeout(2.5):
async with self.acquire_conn(timeout=1.5) as conn:
await conn.fetchval("SELECT 1")
await self.redis_client.ping()
await asyncio.to_thread(self.s3_client.head_bucket, Bucket=S3_BUCKET)
return True
except Exception as exc:
logger.warning("Ошибка проверки health: %s", exc)
return False
# ------------------ Пользователи и аутентификация ------------------
async def create_user(
self, username: str, display_name: str, password: str
) -> UserResponse:
user_id = uuid.uuid4()
now = dt.datetime.now(dt.timezone.utc)
pwd_hash = await asyncio.to_thread(hash_password, password)
try:
async with self.acquire_conn() as conn:
await conn.execute(
"""
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ($1, $2, $3, $4, $5)
""",
user_id,
username,
display_name,
pwd_hash,
now,
)
except asyncpg.UniqueViolationError:
raise ConflictError("Имя пользователя уже занято")
return UserResponse(
id=str(user_id),
username=username,
display_name=display_name,
created_at=_format_dt(now),
)
async def authenticate_user(
self, username: str, password: str
) -> UserResponse | None:
async with self.acquire_conn() as conn:
row = await conn.fetchrow(
"""
SELECT id, username, display_name, password_hash, created_at
FROM users
WHERE username = $1
""",
username,
)
if not row:
return None
is_valid = await asyncio.to_thread(verify_password, row["password_hash"], password)
if not is_valid:
return None
return UserResponse(
id=str(row["id"]),
username=row["username"],
display_name=_to_text(row["display_name"]),
created_at=_format_dt(row["created_at"]),
)
async def get_user_by_id(self, user_id: str) -> UserResponse | None:
try:
uid = uuid.UUID(user_id)
except ValueError:
return None
async with self.acquire_conn() as conn:
row = await conn.fetchrow(
"""
SELECT id, username, display_name, created_at
FROM users
WHERE id = $1
""",
uid,
)
if not row:
return None
return UserResponse(
id=str(row["id"]),
username=row["username"],
display_name=_to_text(row["display_name"]),
created_at=_format_dt(row["created_at"]),
)
# ------------------ Сессии (Redis) ------------------
async def create_session(self, user: UserResponse) -> SessionResponse:
assert self.redis_client is not None
token = generate_session_token()
now = dt.datetime.now(dt.timezone.utc)
expires_at = now + dt.timedelta(seconds=SESSION_TTL_SECONDS)
expires_at_str = _format_dt(expires_at)
session_data = json.dumps(
{
"user_id": user.id,
"expires_at": expires_at_str,
}
)
key = f"session:{token}"
await self.redis_client.set(key, session_data, ex=SESSION_TTL_SECONDS)
return SessionResponse(
token=token,
token_type="Bearer",
expires_at=expires_at_str,
user=user,
)
async def get_session_user(self, token: str) -> UserResponse | None:
if not token or not self.redis_client:
return None
key = f"session:{token}"
raw = await self.redis_client.get(key)
if not raw:
return None
try:
data = json.loads(raw)
user_id = data.get("user_id")
except Exception:
return None
if not user_id:
return None
return await self.get_user_by_id(user_id)
async def delete_session(self, token: str) -> bool:
if not token or not self.redis_client:
return False
key = f"session:{token}"
res = await self.redis_client.delete(key)
return res > 0
# ------------------ Чаты ------------------
async def create_chat(
self, caller_id: str, title: str, member_ids: list[str]
) -> ChatResponse:
if caller_id not in member_ids:
raise InvalidRequestError("Создатель чата должен быть в списке участников")
chat_id = uuid.uuid4()
now = dt.datetime.now(dt.timezone.utc)
member_uuids = [uuid.UUID(m) for m in member_ids]
async with self.acquire_conn() as conn:
# Проверяем существование всех участников
found = await conn.fetch(
"SELECT id FROM users WHERE id = ANY($1::uuid[])", member_uuids
)
if len(found) != len(member_uuids):
raise InvalidRequestError(
"Один или несколько участников чата не найдены"
)
async with conn.transaction():
await conn.execute(
"INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)",
chat_id,
title,
now,
)
member_records = [(chat_id, m) for m in member_uuids]
await conn.executemany(
"INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)",
member_records,
)
return ChatResponse(
id=str(chat_id),
title=title,
member_ids=member_ids,
created_at=_format_dt(now),
)
async def get_chat(self, caller_id: str, chat_id: str) -> ChatResponse:
try:
cid = uuid.UUID(chat_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Чат не найден")
async with self.acquire_conn() as conn:
# Проверяем членство вызывающего
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
cid,
c_caller,
)
if not is_member:
raise NotFoundError("Чат не найден")
chat_row = await conn.fetchrow(
"SELECT id, title, created_at FROM chats WHERE id = $1", cid
)
if not chat_row:
raise NotFoundError("Чат не найден")
members_rows = await conn.fetch(
"SELECT user_id FROM chat_members WHERE chat_id = $1", cid
)
member_ids = [str(r["user_id"]) for r in members_rows]
return ChatResponse(
id=str(chat_row["id"]),
title=_to_text(chat_row["title"]),
member_ids=member_ids,
created_at=_format_dt(chat_row["created_at"]),
)
async def list_chats(
self, caller_id: str, limit: int = 50, cursor: str | None = None
) -> tuple[list[ChatResponse], str | None]:
try:
c_caller = uuid.UUID(caller_id)
except ValueError:
return [], None
c_created: dt.datetime | None = None
c_id: uuid.UUID | None = None
if cursor is not None:
c_data = decode_cursor(cursor)
if c_data.get("type") != "chats":
raise InvalidRequestError("Недействительный тип курсора")
c_created_str = c_data.get("created_at")
c_id_str = c_data.get("id")
if (
not isinstance(c_created_str, str)
or not isinstance(c_id_str, str)
or not c_created_str.strip()
or not c_id_str.strip()
):
raise InvalidRequestError("Поврежденный курсор")
try:
c_created = dt.datetime.fromisoformat(
c_created_str.replace("Z", "+00:00")
)
c_id = uuid.UUID(c_id_str)
except Exception:
raise InvalidRequestError("Некорректные параметры курсора")
async with self.acquire_conn() as conn:
query = """
SELECT c.id, c.title, c.created_at, array_agg(cm.user_id::text) as member_ids
FROM chats c
JOIN chat_members my_m ON c.id = my_m.chat_id AND my_m.user_id = $1
JOIN chat_members cm ON c.id = cm.chat_id
WHERE ($2::timestamptz IS NULL OR (c.created_at, c.id) > ($2::timestamptz, $3::uuid))
GROUP BY c.id, c.title, c.created_at
ORDER BY c.created_at ASC, c.id ASC
LIMIT $4
"""
rows = await conn.fetch(query, c_caller, c_created, c_id, limit + 1)
has_next = len(rows) > limit
items_rows = rows[:limit]
items = [
ChatResponse(
id=str(r["id"]),
title=_to_text(r["title"]),
member_ids=list(r["member_ids"]),
created_at=_format_dt(r["created_at"]),
)
for r in items_rows
]
next_cursor = None
if has_next and items:
last = items[-1]
next_cursor = encode_cursor(
{
"type": "chats",
"created_at": last.created_at,
"id": last.id,
}
)
return items, next_cursor
# ------------------ Сообщения ------------------
@staticmethod
def compute_request_hash(text: str, attachment_ids: list[str] | None = None) -> str:
norm_attachments = [str(x) for x in (attachment_ids or [])]
canonical = json.dumps(
{"attachment_ids": norm_attachments, "text": text},
sort_keys=True,
ensure_ascii=False,
)
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
async def send_message(
self,
caller_id: str,
chat_id: str,
text: str,
idempotency_key: str,
attachment_ids: list[str] | None = None,
) -> MessageResponse:
try:
cid = uuid.UUID(chat_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Чат не найден")
norm_attachments = [str(x) for x in (attachment_ids or [])]
req_hash = self.compute_request_hash(text, norm_attachments)
async with self.acquire_conn() as conn:
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
cid,
c_caller,
)
if not is_member:
raise NotFoundError("Чат не найден")
# Валидация прикрепляемых вложений
att_uuids: list[uuid.UUID] = []
if norm_attachments:
for att_str in norm_attachments:
try:
att_uuids.append(uuid.UUID(att_str))
except ValueError:
raise NotFoundError("Вложение не найдено")
rows = await conn.fetch(
"SELECT id, chat_id, status FROM attachments WHERE id = ANY($1::uuid[])",
att_uuids,
)
if len(rows) != len(att_uuids):
raise NotFoundError("Одно или несколько вложений не найдены")
for r in rows:
if r["chat_id"] != cid:
raise NotFoundError("Вложение принадлежит другому чату")
if r["status"] != "ready":
raise ConflictError("Вложение еще не готово или повреждено")
# 1. Проверяем, обрабатывался ли уже этот idempotency_key
existing = await conn.fetchrow(
"""
SELECT ik.message_id, ik.request_hash, m.text, m.attachment_ids, m.created_at AS msg_created_at
FROM idempotency_keys ik
JOIN messages m ON m.id = ik.message_id
WHERE ik.user_id = $1 AND ik.chat_id = $2 AND ik.idempotency_key = $3
""",
c_caller,
cid,
idempotency_key,
)
if existing:
if existing["request_hash"] == req_hash:
raw_text = existing["text"]
msg_text = (
raw_text.decode("utf-8")
if isinstance(raw_text, (bytes, bytearray))
else str(raw_text)
)
res_attachments = [
str(a) for a in (existing["attachment_ids"] or [])
]
return MessageResponse(
id=str(existing["message_id"]),
chat_id=chat_id,
sender_id=caller_id,
text=msg_text,
attachment_ids=res_attachments,
created_at=_format_dt(existing["msg_created_at"]),
)
else:
raise ConflictError("Ключ идемпотентности уже использован с другим телом запроса")
msg_id = uuid.uuid4()
now = dt.datetime.now(dt.timezone.utc)
text_bytes = text.encode("utf-8")
try:
async with conn.transaction():
await conn.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text, attachment_ids, created_at)
VALUES ($1, $2, $3, $4, $5, $6)
""",
msg_id,
cid,
c_caller,
text_bytes,
att_uuids,
now,
)
await conn.execute(
"""
INSERT INTO idempotency_keys (user_id, chat_id, idempotency_key, message_id, request_hash, created_at)
VALUES ($1, $2, $3, $4, $5, $6)
""",
c_caller,
cid,
idempotency_key,
msg_id,
req_hash,
now,
)
except asyncpg.UniqueViolationError:
winner = await conn.fetchrow(
"""
SELECT ik.message_id, ik.request_hash, m.text, m.attachment_ids, m.created_at AS msg_created_at
FROM idempotency_keys ik
JOIN messages m ON m.id = ik.message_id
WHERE ik.user_id = $1 AND ik.chat_id = $2 AND ik.idempotency_key = $3
""",
c_caller,
cid,
idempotency_key,
)
if winner:
if winner["request_hash"] == req_hash:
raw_text = winner["text"]
msg_text = (
raw_text.decode("utf-8")
if isinstance(raw_text, (bytes, bytearray))
else str(raw_text)
)
res_attachments = [
str(a) for a in (winner["attachment_ids"] or [])
]
return MessageResponse(
id=str(winner["message_id"]),
chat_id=chat_id,
sender_id=caller_id,
text=msg_text,
attachment_ids=res_attachments,
created_at=_format_dt(winner["msg_created_at"]),
)
else:
raise ConflictError("Ключ идемпотентности уже использован с другим телом запроса")
raise
return MessageResponse(
id=str(msg_id),
chat_id=chat_id,
sender_id=caller_id,
text=text,
attachment_ids=norm_attachments,
created_at=_format_dt(now),
)
async def list_messages(
self, caller_id: str, chat_id: str, limit: int = 50, cursor: str | None = None
) -> tuple[list[MessageResponse], str | None]:
try:
cid = uuid.UUID(chat_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Чат не найден")
async with self.acquire_conn() as conn:
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
cid,
c_caller,
)
if not is_member:
raise NotFoundError("Чат не найден")
c_created: dt.datetime | None = None
c_id: uuid.UUID | None = None
if cursor is not None:
c_data = decode_cursor(cursor)
if c_data.get("type") != "messages" or c_data.get("chat_id") != chat_id:
raise InvalidRequestError(
"Курсор принадлежит другому чату или недействителен"
)
c_created_str = c_data.get("created_at")
c_id_str = c_data.get("id")
if (
not isinstance(c_created_str, str)
or not isinstance(c_id_str, str)
or not c_created_str.strip()
or not c_id_str.strip()
):
raise InvalidRequestError("Поврежденный курсор")
try:
c_created = dt.datetime.fromisoformat(
c_created_str.replace("Z", "+00:00")
)
c_id = uuid.UUID(c_id_str)
except Exception:
raise InvalidRequestError("Некорректные параметры курсора")
query = """
SELECT id, chat_id, sender_id, text, attachment_ids, created_at
FROM messages
WHERE chat_id = $1
AND ($2::timestamptz IS NULL OR (created_at, id) > ($2::timestamptz, $3::uuid))
ORDER BY created_at ASC, id ASC
LIMIT $4
"""
rows = await conn.fetch(query, cid, c_created, c_id, limit + 1)
has_next = len(rows) > limit
items_rows = rows[:limit]
def _to_text(val: Any) -> str:
if isinstance(val, (bytes, bytearray, memoryview)):
return bytes(val).decode("utf-8")
return str(val)
items = [
MessageResponse(
id=str(r["id"]),
chat_id=str(r["chat_id"]),
sender_id=str(r["sender_id"]),
text=_to_text(r["text"]),
attachment_ids=[str(a) for a in (r["attachment_ids"] or [])],
created_at=_format_dt(r["created_at"]),
)
for r in items_rows
]
next_cursor = None
if has_next and items:
last = items[-1]
next_cursor = encode_cursor(
{
"type": "messages",
"chat_id": chat_id,
"created_at": last.created_at,
"id": last.id,
}
)
return items, next_cursor
# ------------------ Вложения (Attachments) ------------------
async def upload_attachment(
self,
caller_id: str,
chat_id: str,
filename: str,
content_type: str,
data: bytes,
) -> AttachmentResponse:
try:
cid = uuid.UUID(chat_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Чат не найден")
# 1. Валидация filename
if not filename or len(filename) > 255:
raise InvalidRequestError("Некорректная длина имени файла (1-255 символов)")
if any(c in filename for c in ("/", "\\", "\0")) or any(
ord(c) < 32 for c in filename
):
raise InvalidRequestError("Имя файла содержит недопустимые символы")
# 2. Проверка прав (ACL)
async with self.acquire_conn() as conn:
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
cid,
c_caller,
)
if not is_member:
raise NotFoundError("Чат не найден")
# 3. Валидация Content-Type
ct_clean = content_type.split(";")[0].strip().lower()
if ct_clean not in ("image/png", "image/jpeg"):
raise UnsupportedMediaTypeError(
"Поддерживаются только форматы image/png и image/jpeg"
)
# 4. Валидация размера данных
size_bytes = len(data)
if size_bytes > MAX_UPLOAD_BYTES:
raise PayloadTooLargeError(
f"Размер файла {size_bytes} байт превышает допустимый лимит {MAX_UPLOAD_BYTES} байт"
)
# 5. Проверка магических байтов (сигнатуры MIME)
if ct_clean == "image/png":
if not data.startswith(b"\x89PNG\r\n\x1a\n"):
raise UnsupportedMediaTypeError("Содержимое файла не соответствует формату PNG")
elif ct_clean == "image/jpeg":
if not (data.startswith(b"\xff\xd8\xff")):
raise UnsupportedMediaTypeError("Содержимое файла не соответствует формату JPEG")
# 6. Проверка разрешения (лимит 40 млн пикселей) и целостности растра
def _check_dimensions():
try:
with Image.open(io.BytesIO(data)) as img:
w, h = img.size
if w * h > MAX_IMAGE_PIXELS:
return False
# Проверяем целостность растровых данных и фильтров строк:
img.load()
return True
except Exception:
raise UnsupportedMediaTypeError("Поврежденное изображение")
try:
within_limits = await asyncio.to_thread(_check_dimensions)
if not within_limits:
raise PayloadTooLargeError(
f"Разрешение изображения превышает лимит {MAX_IMAGE_PIXELS} пикселей"
)
except (UnsupportedMediaTypeError, PayloadTooLargeError):
raise
except Exception as e:
logger.warning("upload_attachment check_dimensions unexpected: %s (%s)", type(e), e)
raise UnsupportedMediaTypeError("Поврежденное изображение") from e
# 7. Генерация идентификаторов
att_id = uuid.uuid4()
s3_key = f"chats/{chat_id}/{att_id}/{filename}"
sha256_hash = hashlib.sha256(data).hexdigest()
now = dt.datetime.now(dt.timezone.utc)
# 8. Загрузка файла в S3
def _put_to_s3():
self.s3_client.put_object(
Bucket=S3_BUCKET,
Key=s3_key,
Body=data,
ContentType=ct_clean,
)
await asyncio.to_thread(_put_to_s3)
# 9. Сохранение метаданных в PostgreSQL (с компенсацией удаления из S3 при ошибке)
try:
async with self.acquire_conn() as conn:
await conn.execute(
"""
INSERT INTO attachments (
id, chat_id, owner_id, filename, content_type,
size_bytes, sha256, s3_key, status, error_code,
created_at, updated_at
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'ready', NULL, $9, $9)
""",
att_id,
cid,
c_caller,
filename,
ct_clean,
size_bytes,
sha256_hash,
s3_key,
now,
)
except Exception as db_err:
logger.error("Ошибка записи метаданных в БД, компенсация S3: %s", db_err)
try:
await asyncio.to_thread(
self.s3_client.delete_object, Bucket=S3_BUCKET, Key=s3_key
)
except Exception as del_err:
logger.error("Ошибка удаления S3 объекта при компенсации: %s", del_err)
raise
return AttachmentResponse(
id=str(att_id),
chat_id=str(cid),
owner_id=str(c_caller),
filename=filename,
content_type=ct_clean,
size_bytes=size_bytes,
sha256=sha256_hash,
status="ready",
variants=[],
error_code=None,
created_at=_format_dt(now),
updated_at=_format_dt(now),
)
async def get_attachment(
self, caller_id: str, attachment_id: str
) -> AttachmentResponse:
try:
aid = uuid.UUID(attachment_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Вложение не найдено")
async with self.acquire_conn() as conn:
row = await conn.fetchrow(
"""
SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type,
a.size_bytes, a.sha256, a.status, a.error_code, a.created_at, a.updated_at
FROM attachments a
WHERE a.id = $1
""",
aid,
)
if not row:
raise NotFoundError("Вложение не найдено")
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
row["chat_id"],
c_caller,
)
if not is_member:
raise NotFoundError("Вложение не найдено")
return AttachmentResponse(
id=str(row["id"]),
chat_id=str(row["chat_id"]),
owner_id=str(row["owner_id"]),
filename=row["filename"],
content_type=row["content_type"],
size_bytes=row["size_bytes"],
sha256=row["sha256"],
status=row["status"],
variants=[],
error_code=row["error_code"],
created_at=_format_dt(row["created_at"]),
updated_at=_format_dt(row["updated_at"]),
)
async def get_attachment_content(
self, caller_id: str, attachment_id: str, variant: str | None = None
) -> tuple[bytes, str]:
try:
aid = uuid.UUID(attachment_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Вложение не найдено")
if variant not in (None, "", "original"):
raise NotFoundError("Вариант не найден")
async with self.acquire_conn() as conn:
row = await conn.fetchrow(
"""
SELECT a.chat_id, a.content_type, a.s3_key, a.status
FROM attachments a
WHERE a.id = $1
""",
aid,
)
if not row:
raise NotFoundError("Вложение не найдено")
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
row["chat_id"],
c_caller,
)
if not is_member:
raise NotFoundError("Вложение не найдено")
if row["status"] != "ready":
raise ConflictError("Вложение повреждено или еще не готово")
s3_key = row["s3_key"]
content_type = row["content_type"]
def _get_from_s3():
resp = self.s3_client.get_object(Bucket=S3_BUCKET, Key=s3_key)
return resp["Body"].read()
try:
data = await asyncio.to_thread(_get_from_s3)
except Exception as e:
logger.error("Ошибка чтения объекта из S3 %s: %s", s3_key, e)
raise NotFoundError("Файл не найден в хранилище") from e
return data, content_type
# Глобальный экземпляр хранилища
storage = PostgresStorage()
+194
View File
@@ -0,0 +1,194 @@
services:
load_balancer:
image: nginx:1.27-alpine
ports:
- "8080:8080"
volumes:
- ./infra/nginx.conf:/etc/nginx/nginx.conf:ro
depends_on:
api-1:
condition: service_healthy
api-2:
condition: service_healthy
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/health/live"]
interval: 2s
timeout: 2s
retries: 5
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.25'
memory: 128M
migration:
image: postgres:16-alpine
restart: "no"
environment:
PGPASSWORD: postgres
command: >
sh -c "until pg_isready -h postgres -U postgres -d messenger; do sleep 1; done;
psql -h postgres -U postgres -d messenger -f /docker-entrypoint-initdb.d/init.sql"
volumes:
- ./infra/init.sql:/docker-entrypoint-initdb.d/init.sql:ro
depends_on:
postgres:
condition: service_healthy
deploy:
resources:
limits:
cpus: '0.25'
memory: 128M
api-1:
build:
context: .
dockerfile: Dockerfile
image: highload-messenger:lab4
stop_grace_period: 15s
environment:
APP_HOST: "0.0.0.0"
APP_PORT: "8080"
APP_ENV: "lab"
INSTANCE_ID: "api-1"
SESSION_TTL_SECONDS: "3600"
DATABASE_URL: "postgresql://postgres:postgres@postgres:5432/messenger"
SESSION_STORE: "redis"
CACHE_URL: "redis://redis:6379/0"
IDEMPOTENCY_TTL_SECONDS: "86400"
S3_ENDPOINT: "http://minio:9000"
S3_REGION: "us-east-1"
S3_BUCKET: "messenger-attachments"
S3_ACCESS_KEY_ID: "minioadmin"
S3_SECRET_ACCESS_KEY: "minioadmin"
MAX_UPLOAD_BYTES: "10485760"
MAX_IMAGE_PIXELS: "40000000"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
minio:
condition: service_healthy
migration:
condition: service_completed_successfully
healthcheck:
test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready')"]
interval: 2s
timeout: 2s
retries: 5
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.50'
memory: 512M
api-2:
build:
context: .
dockerfile: Dockerfile
image: highload-messenger:lab4
stop_grace_period: 15s
environment:
APP_HOST: "0.0.0.0"
APP_PORT: "8080"
APP_ENV: "lab"
INSTANCE_ID: "api-2"
SESSION_TTL_SECONDS: "3600"
DATABASE_URL: "postgresql://postgres:postgres@postgres:5432/messenger"
SESSION_STORE: "redis"
CACHE_URL: "redis://redis:6379/0"
IDEMPOTENCY_TTL_SECONDS: "86400"
S3_ENDPOINT: "http://minio:9000"
S3_REGION: "us-east-1"
S3_BUCKET: "messenger-attachments"
S3_ACCESS_KEY_ID: "minioadmin"
S3_SECRET_ACCESS_KEY: "minioadmin"
MAX_UPLOAD_BYTES: "10485760"
MAX_IMAGE_PIXELS: "40000000"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
minio:
condition: service_healthy
migration:
condition: service_completed_successfully
healthcheck:
test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready')"]
interval: 2s
timeout: 2s
retries: 5
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.50'
memory: 512M
postgres:
image: postgres:16-alpine
environment:
POSTGRES_USER: postgres
POSTGRES_PASSWORD: postgres
POSTGRES_DB: messenger
volumes:
- pg_data:/var/lib/postgresql/data
- ./infra/init.sql:/docker-entrypoint-initdb.d/init.sql:ro
healthcheck:
test: ["CMD-SHELL", "pg_isready -U postgres -d messenger"]
interval: 2s
timeout: 2s
retries: 5
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.50'
memory: 512M
redis:
image: redis:7-alpine
command: ["redis-server", "--appendonly", "yes"]
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 2s
timeout: 2s
retries: 5
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.25'
memory: 256M
minio:
image: cleanstart/minio:0.20260330.001845
user: "0:0"
command: server /data --address ":9000" --console-address ":9001"
environment:
MINIO_ROOT_USER: minioadmin
MINIO_ROOT_PASSWORD: minioadmin
volumes:
- minio_data:/data
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:9000/minio/health/live"]
interval: 2s
timeout: 2s
retries: 5
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.50'
memory: 512M
volumes:
pg_data:
redis_data:
minio_data:
+2
View File
@@ -0,0 +1,2 @@
.venv/bin/python scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+7
View File
@@ -0,0 +1,7 @@
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab4-api-1-1 highload-messenger:lab4 "python -m uvicorn a…" api-1 6 minutes ago Up About a minute (healthy) 8080/tcp
mtusi2026lab4-api-2-1 highload-messenger:lab4 "python -m uvicorn a…" api-2 6 minutes ago Up 2 minutes (healthy) 8080/tcp
mtusi2026lab4-load_balancer-1 nginx:1.27-alpine "/docker-entrypoint.…" load_balancer 10 minutes ago Up 2 minutes (healthy) 80/tcp, 0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp
mtusi2026lab4-minio-1 cleanstart/minio:latest "/usr/bin/minio serv…" minio 10 minutes ago Up 2 minutes (healthy)
mtusi2026lab4-postgres-1 postgres:16-alpine "docker-entrypoint.s…" postgres 10 minutes ago Up 2 minutes (healthy) 5432/tcp
mtusi2026lab4-redis-1 redis:7-alpine "docker-entrypoint.s…" redis 10 minutes ago Up 2 minutes (healthy) 6379/tcp
+4
View File
@@ -0,0 +1,4 @@
python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080"
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 123, "failed_attempts": 0, "first_recovery_seconds": 0.768}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 4,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.015,
"concurrency": 4,
"successful_requests": 9286,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 309.375,
"successful_latency_ms": {
"p50": 7.928,
"p95": 40.768,
"p99": 62.963
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+3
View File
@@ -0,0 +1,3 @@
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
+10
View File
@@ -0,0 +1,10 @@
x-instance-id: api-2
x-instance-id: api-1
x-instance-id: api-2
x-instance-id: api-1
x-instance-id: api-2
x-instance-id: api-1
x-instance-id: api-2
x-instance-id: api-1
x-instance-id: api-2
x-instance-id: api-1
+2
View File
@@ -0,0 +1,2 @@
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.
+45
View File
@@ -0,0 +1,45 @@
============================= test session starts ==============================
platform linux -- Python 3.12.15, pytest-9.1.1, pluggy-1.7.0 -- /home/ilyas/projects/labs_highload/mtusi2026lab4/.venv/bin/python3.12
cachedir: .pytest_cache
rootdir: /home/ilyas/projects/labs_highload/mtusi2026lab4
configfile: pytest.ini
plugins: anyio-4.16.0, asyncio-1.4.0
asyncio: mode=Mode.AUTO, debug=False, asyncio_default_fixture_loop_scope=None, asyncio_default_test_loop_scope=function
collecting ... collected 34 items
tests_student/tests.py::test_invalid_json_and_extra_fields PASSED [ 2%]
tests_student/tests.py::test_outsider_chat_access_is_404 PASSED [ 5%]
tests_student/tests.py::test_empty_and_whitespace_message PASSED [ 8%]
tests_student/tests.py::test_duplicate_username_conflict PASSED [ 11%]
tests_student/tests.py::test_wrong_password_and_bad_basic_auth PASSED [ 14%]
tests_student/tests.py::test_logout_and_revocation PASSED [ 17%]
tests_student/tests.py::test_multi_page_cursor_pagination PASSED [ 20%]
tests_student/tests.py::test_concurrency_race_condition PASSED [ 23%]
tests_student/tests.py::test_password_whitespace_rejected PASSED [ 26%]
tests_student/tests.py::test_auth_sessions_with_body_rejected PASSED [ 29%]
tests_student/tests.py::test_unsupported_media_type_415 PASSED [ 32%]
tests_student/tests.py::test_nul_byte_in_strings_handled PASSED [ 35%]
tests_student/tests.py::test_basic_auth_invalid_base64_returns_401 PASSED [ 38%]
tests_student/tests.py::test_cross_chat_cursor_rejected_400 PASSED [ 41%]
tests_student/tests.py::test_utf8_password_support PASSED [ 44%]
tests_student/tests.py::test_health_readiness_and_liveness PASSED [ 47%]
tests_student/tests.py::test_instance_id_header_present PASSED [ 50%]
tests_student/tests.py::test_idempotency_key_validation PASSED [ 52%]
tests_student/tests.py::test_idempotency_replay_and_conflict PASSED [ 55%]
tests_student/tests.py::test_idempotency_acl_check_on_replay PASSED [ 58%]
tests_student/tests.py::test_invalid_cursor_date_returns_400 PASSED [ 61%]
tests_student/tests.py::test_strict_types_and_json_parsing PASSED [ 64%]
tests_student/tests.py::test_chat_creation_with_unknown_participant_is_400 PASSED [ 67%]
tests_student/tests.py::test_password_with_colons_and_utf8 PASSED [ 70%]
tests_student/tests.py::test_keyset_pagination_returns_next_cursor PASSED [ 73%]
tests_student/tests.py::test_attachment_upload_and_download_flow PASSED [ 76%]
tests_student/tests.py::test_attachment_unsupported_media_type_and_magic_bytes PASSED [ 79%]
tests_student/tests.py::test_attachment_filename_validation PASSED [ 82%]
tests_student/tests.py::test_attachment_payload_too_large_and_pixel_bomb PASSED [ 85%]
tests_student/tests.py::test_attachment_acl_and_isolation PASSED [ 88%]
tests_student/tests.py::test_message_linking_attachments PASSED [ 91%]
tests_student/tests.py::test_attachment_orphan_compensation PASSED [ 94%]
tests_student/tests.py::test_private_bucket_outside_api PASSED [ 97%]
tests_student/tests.py::test_concurrent_uploads_memory_limit PASSED [100%]
============================= 34 passed in 37.86s ==============================
+2
View File
@@ -0,0 +1,2 @@
.venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
+68
View File
@@ -0,0 +1,68 @@
CREATE TABLE IF NOT EXISTS users (
id UUID PRIMARY KEY,
username VARCHAR(32) NOT NULL UNIQUE,
display_name VARCHAR(100) NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_users_username ON users (username);
CREATE TABLE IF NOT EXISTS chats (
id UUID PRIMARY KEY,
title VARCHAR(100) NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_chats_cursor ON chats (created_at ASC, id ASC);
CREATE TABLE IF NOT EXISTS chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX IF NOT EXISTS idx_chat_members_user_id ON chat_members (user_id);
CREATE TABLE IF NOT EXISTS messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
text BYTEA NOT NULL,
attachment_ids UUID[] NOT NULL DEFAULT '{}',
created_at TIMESTAMPTZ NOT NULL
);
ALTER TABLE messages ADD COLUMN IF NOT EXISTS attachment_ids UUID[] NOT NULL DEFAULT '{}';
CREATE INDEX IF NOT EXISTS idx_messages_cursor ON messages (chat_id, created_at ASC, id ASC);
CREATE TABLE IF NOT EXISTS attachments (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
owner_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
filename VARCHAR(255) NOT NULL,
content_type VARCHAR(50) NOT NULL,
size_bytes BIGINT NOT NULL,
sha256 VARCHAR(64) NOT NULL,
s3_key VARCHAR(512) NOT NULL,
status VARCHAR(20) NOT NULL DEFAULT 'ready',
error_code VARCHAR(100),
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_attachments_chat_id ON attachments (chat_id, created_at ASC);
CREATE INDEX IF NOT EXISTS idx_attachments_owner_id ON attachments (owner_id);
CREATE TABLE IF NOT EXISTS idempotency_keys (
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
idempotency_key VARCHAR(128) NOT NULL,
message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
request_hash VARCHAR(64) NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
PRIMARY KEY (user_id, chat_id, idempotency_key)
);
CREATE INDEX IF NOT EXISTS idx_idempotency_created_at ON idempotency_keys (created_at);
+72
View File
@@ -0,0 +1,72 @@
events {
worker_connections 1024;
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" upstream: $upstream_addr '
'upstream_status: $upstream_status '
'rt=$request_time uct="$upstream_connect_time" uht="$upstream_header_time" urt="$upstream_response_time"';
access_log /var/log/nginx/access.log main;
error_log /var/log/nginx/error.log warn;
sendfile on;
keepalive_timeout 65;
client_max_body_size 15M;
# DNS-сервер Docker для динамического обновления IP-адресов контейнеров
resolver 127.0.0.11 valid=2s ipv6=off;
upstream api_backend {
zone api_backend 64k;
server api-1:8080 resolve max_fails=1 fail_timeout=2s;
server api-2:8080 resolve max_fails=1 fail_timeout=2s;
}
server {
listen 8080;
server_name _;
# Быстрый таймаут обнаружения недоступной реплики
proxy_connect_timeout 1s;
proxy_read_timeout 5s;
proxy_send_timeout 5s;
# Базовая политика переключения: безопасно для идемпотентных запросов
# Неидемпотентные POST не повторяем
proxy_next_upstream error timeout http_502 http_503;
proxy_next_upstream_tries 2;
proxy_next_upstream_timeout 5s;
location ~ ^/api/v1/chats/[^/]+/messages$ {
proxy_pass http://api_backend;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Request-Id $http_x_request_id;
proxy_next_upstream error timeout http_502 http_503 non_idempotent;
proxy_next_upstream_tries 2;
proxy_next_upstream_timeout 5s;
}
location / {
proxy_pass http://api_backend;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Request-Id $http_x_request_id;
}
}
}
+4
View File
@@ -0,0 +1,4 @@
[pytest]
pythonpath = .
asyncio_mode = auto
python_files = test_*.py *_test.py tests.py test.py
+11
View File
@@ -0,0 +1,11 @@
fastapi==0.141.1
uvicorn[standard]==0.52.4
pydantic==2.13.5
asyncpg==0.30.0
redis==5.2.1
argon2-cffi==23.1.0
pytest==9.1.1
pytest-asyncio==1.4.0
httpx==0.28.1
boto3==1.43.123
pillow==13.0.0
+8
View File
@@ -0,0 +1,8 @@
#!/bin/sh
set -eu
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
# Перезапуск всех сервисов API и хранилищ с сохранением volumes
docker compose -f "$PROJECT_DIR/compose.yaml" restart
+13
View File
@@ -0,0 +1,13 @@
#!/bin/sh
set -eu
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
if docker compose -f "$PROJECT_DIR/compose.yaml" stop "$TARGET_INSTANCE_ID" 2>/dev/null; then
exit 0
fi
docker stop "$TARGET_INSTANCE_ID" >/dev/null
+19
View File
@@ -0,0 +1,19 @@
from __future__ import annotations
import os
import pytest
from httpx import ASGITransport, AsyncClient
@pytest.fixture
async def client():
base_url = os.getenv("BASE_URL", "http://localhost:8080")
if base_url.startswith("http://testserver"):
from app.main import app
transport = ASGITransport(app=app)
async with AsyncClient(transport=transport, base_url="http://testserver") as ac:
yield ac
else:
async with AsyncClient(base_url=base_url) as ac:
yield ac
File diff suppressed because it is too large Load Diff