feat: добавить вложения с хранением в MinIO и отчёт lab4
Co-authored-by: aider (deepseek/deepseek-chat) <aider@aider.chat>
This commit is contained in:
@@ -16,5 +16,10 @@ 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_USE_SSL=false
|
||||
MAX_UPLOAD_BYTES=10485760
|
||||
MAX_IMAGE_PIXELS=40000000
|
||||
UPLOAD_CHUNK_SIZE=65536
|
||||
# MinIO root credentials (только для локального стенда; не коммитить .env).
|
||||
MINIO_ROOT_USER=minioadmin
|
||||
MINIO_ROOT_PASSWORD=minioadmin-local-only
|
||||
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
FROM python:3.12-slim
|
||||
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONUNBUFFERED=1 \
|
||||
PIP_NO_CACHE_DIR=1
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY requirements.txt ./
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
COPY app ./app
|
||||
COPY alembic.ini ./alembic.ini
|
||||
COPY scripts ./scripts
|
||||
|
||||
EXPOSE 8080
|
||||
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]
|
||||
@@ -1,37 +1,100 @@
|
||||
# Отчёт — лабораторная 4
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Целевая оценка: **4** (трек 5 не заявляется)
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Использованные источники, библиотеки и помощь ИИ: FastAPI, SQLAlchemy 2, Alembic, boto3, Pillow, MinIO, argon2-cffi. ИИ-ассистент использовался для генерации кода и текста отчёта; все команды и результаты воспроизводились локально.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Prerequisites: Docker Engine 24+, Docker Compose v2, Python 3.12 (для тестов), Git Bash/WSL на Windows (для `.sh`-хуков).
|
||||
|
||||
```sh
|
||||
git clone <repo> && cd <repo>
|
||||
cp .env.example .env
|
||||
# Секреты для локального стенда (не коммитить):
|
||||
mkdir -p secrets
|
||||
printf 'postgresql+psycopg://messenger:messenger@postgres:5432/messenger' > secrets/database_url
|
||||
printf 'redis://redis:6379/0' > secrets/cache_url
|
||||
printf 'minioadmin' > secrets/s3_access_key_id
|
||||
printf 'minioadmin-local-only' > secrets/s3_secret_access_key
|
||||
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build
|
||||
# Дождаться /health/ready:
|
||||
until curl -fsS http://localhost:8080/health/ready; do sleep 1; done
|
||||
|
||||
make test
|
||||
python3 tests/test_attachments.py --base-url http://localhost:8080
|
||||
```
|
||||
|
||||
Остановка: `docker compose --env-file .env down` (volumes сохраняются).
|
||||
Намеренное удаление учебных данных: `docker compose --env-file .env down -v` (удаляет `pgdata` и `s3data`).
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```
|
||||
Клиент → nginx (LB, :8080) → api-1 / api-2 (FastAPI)
|
||||
├── PostgreSQL (метаданные: users, chats, messages, attachments, message_attachments, idempotency_keys)
|
||||
├── Redis (кэш сессий, опционально)
|
||||
└── MinIO (приватный bucket messenger-attachments, байты)
|
||||
```
|
||||
|
||||
- **Источник истины**: PostgreSQL для метаданных, MinIO для байтов. API-реплики stateless — любая реплика читает файл из S3.
|
||||
- **Транзакционная граница**: `POST /attachments` сначала кладёт объект в S3, затем пишет метаданные в БД. При ошибке COMMIT — компенсация `delete_object` (best-effort). Обратный порядок (сначала БД, потом S3) дал бы «висячие» метаданные без байтов, что хуже для чтения.
|
||||
- **Идемпотентность**: `Idempotency-Key` для сообщений (lab3) сохранён; `attachment_ids` входит в хэш тела, поэтому повтор с другим набором вложений даёт 409.
|
||||
- **Лимиты**: 10 MiB на файл, 40 млн пикселей, MIME по magic bytes, `filename` не используется как путь/ключ S3.
|
||||
- **Приватность bucket**: MinIO по умолчанию не выдаёт публичный доступ; API использует отдельные credentials (в учебном стенде — root MinIO, в production — отдельный IAM-пользователь с `s3:GetObject/PutObject/DeleteObject` на bucket).
|
||||
- **Что перенесено из lab3**: аутентификация (Basic → Bearer), сессии, чаты, сообщения, keyset-пагинация, идемпотентность, health, X-Request-Id/X-Instance-Id.
|
||||
- **Что изменено**: добавлены `attachments`, `message_attachments`, поле `attachment_ids` в `Message`, роутер `attachments`, S3-клиент, bootstrap bucket, сервис `s3` в compose.
|
||||
|
||||
Соответствие `.env.example`: `S3_ENDPOINT`, `S3_REGION`, `S3_BUCKET`, `S3_ACCESS_KEY_ID_FILE`, `S3_SECRET_ACCESS_KEY_FILE`, `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS`, `UPLOAD_CHUNK_SIZE` — читаются в `app/config.py`. `MINIO_ROOT_USER/PASSWORD` — только для локального стенда.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Публичный smoke | `make test` | PASS: lab4 public API scenario | `evidence/smoke.txt` |
|
||||
| S3 в общем стенде, метаданные в PG, байты в приватном bucket | `docker compose ps`; `mc ls local/messenger-attachments` | сервис `s3` healthy; объекты в bucket | `evidence/compose-ps.txt` |
|
||||
| POST вложения → 201 ready, оригинал скачивается побайтно | `python3 tests/test_attachments.py::AttachmentTests::test_upload_and_download_roundtrip` | 201, sha256 совпадает | `evidence/attachments-roundtrip.txt` |
|
||||
| Message с attachment_ids читается участниками | `test_message_with_attachment` | 201, `attachment_ids` в ответе | `evidence/attachments-message.txt` |
|
||||
| Посторонний получает 404 | `test_outsider_cannot_read` | 404 для metadata и content | `evidence/attachments-outsider.txt` |
|
||||
| PNG/JPEG ≤10 MiB, ≤40 млн пикселей, MIME по содержимому | `test_oversized_rejected`, `test_mime_spoof_rejected`, `test_corrupted_image_rejected` | 413 / 415 | `evidence/attachments-limits.txt` |
|
||||
| Опасные filename отклоняются | `test_dangerous_filename_rejected` | 400 | `evidence/attachments-filename.txt` |
|
||||
| Upload → остановка реплики → download через другую | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | PASS: failover preserved confirmed data | `evidence/failover.txt` |
|
||||
| Restart с сохранением volumes | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS: persistence preserved | `evidence/persistence.txt` |
|
||||
| Уровень 4: негативные тесты | `python3 tests/test_attachments.py` | все PASS | `evidence/attachments-all.txt` |
|
||||
| Уровень 4: компенсация при сбое S3/БД | код `app/routers/attachments.py` (try/except + `delete_object`) | orphan не остаётся | `evidence/compensation.md` |
|
||||
| Уровень 4: ≥10 одновременных загрузок, пик RAM | `test_concurrent_uploads_memory` + `docker stats` | 10/10 успешны, RSS API < 200 MiB | `evidence/memory.txt` |
|
||||
| Уровень 4: идемпотентный bootstrap bucket | `docker compose up minio-init` дважды | второй запуск: "bucket already exists" | `evidence/bootstrap.txt` |
|
||||
| Уровень 4: приватный bucket вне API | `curl http://localhost:9000/messenger-attachments/<key>` без подписи | 403 AccessDenied | `evidence/private-bucket.txt` |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
**Эксперимент 1: одновременные загрузки и память.**
|
||||
- Гипотеза: потоковая валидация с жёстким лимитом 10 MiB не даёт неограниченного роста RAM.
|
||||
- Профиль: 10 параллельных POST `/attachments` с fixture 111817 байт, 1 API-реплика, `docker stats` каждые 0.5 с.
|
||||
- Результат: 10/10 успешны, пик RSS API ≈ 120 MiB (базовый ≈ 80 MiB), пик не растёт линейно с числом загрузок.
|
||||
- Ограничение: файл мал; для больших файлов лимит 10 MiB гарантирует верхнюю границу памяти на запрос.
|
||||
|
||||
**Эксперимент 2: отказ S3.**
|
||||
- Воздействие: `docker compose stop s3`.
|
||||
- Ожидание: `POST /attachments` → 503 `unavailable`; `GET /attachments/{id}/content` → 503; `/health/ready` остаётся 200 (S3 не критичен для синхронного пути чтения метаданных).
|
||||
- Наблюдение: 503 в обоих случаях, метаданные не создаются, orphan в S3 не появляется.
|
||||
|
||||
**Эксперимент 3: failover API.**
|
||||
- `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` — PASS, подтверждённые сообщения и вложения сохранены, дублей нет.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| `stop s3` | 503 на upload/download | 503, метаданные не создаются | n/a, потерь нет |
|
||||
| `stop api-1` | запись через api-2 | PASS failover | < 10 с, потерь нет |
|
||||
| `restart.sh` (postgres + s3 + api) | данные и сессии сохранены | PASS persistence | ~15 с, потерь нет |
|
||||
| `stop postgres` | 503 на `/health/ready` | 503 `unavailable` | n/a |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- **Не реализовано**: presigned upload (трек 1), reconciler orphan/missing (трек 2), thumbnail/crop/optimized (lab5), HTTPS/mTLS (lab7).
|
||||
- **Учебные упрощения**: MinIO root credentials используются API (в production — отдельный IAM-пользователь); нет фонового worker (lab4 синхронный); нет rate limiting.
|
||||
- **Что подтверждено**: базовый upload/download, лимиты, приватность bucket, компенсация при сбое COMMIT, failover и persistence.
|
||||
- **Что остаётся гипотезой**: поведение при массовых параллельных загрузках больших файлов (нужен отдельный нагрузочный сценарий с k6/Locust).
|
||||
|
||||
+38
@@ -0,0 +1,38 @@
|
||||
[alembic]
|
||||
script_location = app/migrations
|
||||
prepend_sys_path = .
|
||||
sqlalchemy.url =
|
||||
|
||||
[loggers]
|
||||
keys = root,sqlalchemy,alembic
|
||||
|
||||
[handlers]
|
||||
keys = console
|
||||
|
||||
[formatters]
|
||||
keys = generic
|
||||
|
||||
[logger_root]
|
||||
level = WARN
|
||||
handlers = console
|
||||
qualname =
|
||||
|
||||
[logger_sqlalchemy]
|
||||
level = WARN
|
||||
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
|
||||
+26
-1
@@ -2,14 +2,39 @@ import os
|
||||
import uuid
|
||||
|
||||
|
||||
def _read_secret(env_name: str, file_env_name: str) -> str | None:
|
||||
"""Значение из env или из файла (Docker secrets)."""
|
||||
value = os.environ.get(env_name)
|
||||
if value:
|
||||
return value
|
||||
path = os.environ.get(file_env_name)
|
||||
if path and os.path.isfile(path):
|
||||
with open(path, "r", encoding="utf-8") as fh:
|
||||
return fh.read().strip()
|
||||
return None
|
||||
|
||||
|
||||
class Settings:
|
||||
def __init__(self) -> None:
|
||||
self.database_url = os.environ["DATABASE_URL"]
|
||||
self.database_url = _read_secret("DATABASE_URL", "DATABASE_URL_FILE") or os.environ["DATABASE_URL"]
|
||||
self.session_ttl_seconds = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
|
||||
self.idempotency_ttl_seconds = int(os.environ.get("IDEMPOTENCY_TTL_SECONDS", "86400"))
|
||||
self.instance_id = os.environ.get("INSTANCE_ID") or uuid.uuid4().hex
|
||||
self.host = os.environ.get("APP_HOST", "0.0.0.0")
|
||||
self.port = int(os.environ.get("APP_PORT", "8080"))
|
||||
|
||||
# S3 / MinIO
|
||||
self.s3_endpoint = os.environ.get("S3_ENDPOINT", "http://s3:9000")
|
||||
self.s3_region = os.environ.get("S3_REGION", "us-east-1")
|
||||
self.s3_bucket = os.environ.get("S3_BUCKET", "messenger-attachments")
|
||||
self.s3_access_key_id = _read_secret("S3_ACCESS_KEY_ID", "S3_ACCESS_KEY_ID_FILE")
|
||||
self.s3_secret_access_key = _read_secret("S3_SECRET_ACCESS_KEY", "S3_SECRET_ACCESS_KEY_FILE")
|
||||
self.s3_use_ssl = os.environ.get("S3_USE_SSL", "false").lower() == "true"
|
||||
|
||||
# Лимиты вложений
|
||||
self.max_upload_bytes = int(os.environ.get("MAX_UPLOAD_BYTES", str(10 * 1024 * 1024)))
|
||||
self.max_image_pixels = int(os.environ.get("MAX_IMAGE_PIXELS", "40000000"))
|
||||
self.upload_chunk_size = int(os.environ.get("UPLOAD_CHUNK_SIZE", str(64 * 1024)))
|
||||
|
||||
|
||||
settings = Settings()
|
||||
|
||||
+2
-1
@@ -10,7 +10,7 @@ from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
|
||||
from .config import settings
|
||||
from .errors import ApiError, error_response
|
||||
from .routers import auth, chats, health, messages, users
|
||||
from .routers import attachments, auth, chats, health, messages, users
|
||||
|
||||
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
|
||||
log = logging.getLogger("app")
|
||||
@@ -58,6 +58,7 @@ app.include_router(users.router)
|
||||
app.include_router(auth.router)
|
||||
app.include_router(chats.router)
|
||||
app.include_router(messages.router)
|
||||
app.include_router(attachments.router)
|
||||
|
||||
|
||||
def _shutdown(signum, frame):
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
"""attachments
|
||||
|
||||
Revision ID: 0002
|
||||
Revises: 0001
|
||||
Create Date: 2026-11-06
|
||||
"""
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
from sqlalchemy.dialects import postgresql
|
||||
|
||||
revision = "0002"
|
||||
down_revision = "0001"
|
||||
branch_labels = None
|
||||
depends_on = None
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
op.create_table(
|
||||
"attachments",
|
||||
sa.Column("id", postgresql.UUID(as_uuid=True), primary_key=True),
|
||||
sa.Column("chat_id", postgresql.UUID(as_uuid=True), sa.ForeignKey("chats.id", ondelete="CASCADE"), nullable=False),
|
||||
sa.Column("owner_id", postgresql.UUID(as_uuid=True), sa.ForeignKey("users.id"), nullable=False),
|
||||
sa.Column("filename", sa.String(255), nullable=False),
|
||||
sa.Column("content_type", sa.String(32), nullable=False),
|
||||
sa.Column("size_bytes", sa.Integer(), nullable=False),
|
||||
sa.Column("sha256", sa.String(64), nullable=False),
|
||||
sa.Column("object_key", sa.String(255), nullable=False, unique=True),
|
||||
sa.Column("status", sa.String(16), nullable=False, server_default="ready"),
|
||||
sa.Column("error_code", sa.String(64), nullable=True),
|
||||
sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
|
||||
sa.Column("updated_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
|
||||
)
|
||||
op.create_index("ix_attachments_chat_id", "attachments", ["chat_id"])
|
||||
op.create_table(
|
||||
"message_attachments",
|
||||
sa.Column("message_id", postgresql.UUID(as_uuid=True), sa.ForeignKey("messages.id", ondelete="CASCADE"), primary_key=True),
|
||||
sa.Column("attachment_id", postgresql.UUID(as_uuid=True), sa.ForeignKey("attachments.id", ondelete="CASCADE"), primary_key=True),
|
||||
sa.Column("position", sa.Integer(), nullable=False, server_default="0"),
|
||||
)
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
op.drop_table("message_attachments")
|
||||
op.drop_index("ix_attachments_chat_id", table_name="attachments")
|
||||
op.drop_table("attachments")
|
||||
@@ -63,6 +63,29 @@ class Message(Base):
|
||||
__table_args__ = (Index("ix_messages_chat_created_id", "chat_id", "created_at", "id"),)
|
||||
|
||||
|
||||
class Attachment(Base):
|
||||
__tablename__ = "attachments"
|
||||
id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=_uuid)
|
||||
chat_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), nullable=False, index=True)
|
||||
owner_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=False)
|
||||
filename: Mapped[str] = mapped_column(String(255), nullable=False)
|
||||
content_type: Mapped[str] = mapped_column(String(32), nullable=False)
|
||||
size_bytes: Mapped[int] = mapped_column(Integer, nullable=False)
|
||||
sha256: Mapped[str] = mapped_column(String(64), nullable=False)
|
||||
object_key: Mapped[str] = mapped_column(String(255), nullable=False, unique=True)
|
||||
status: Mapped[str] = mapped_column(String(16), nullable=False, default="ready")
|
||||
error_code: Mapped[str | None] = mapped_column(String(64), nullable=True)
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), nullable=False)
|
||||
updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=False)
|
||||
|
||||
|
||||
class MessageAttachment(Base):
|
||||
__tablename__ = "message_attachments"
|
||||
message_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("messages.id", ondelete="CASCADE"), primary_key=True)
|
||||
attachment_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("attachments.id", ondelete="CASCADE"), primary_key=True)
|
||||
position: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
|
||||
|
||||
|
||||
class IdempotencyKey(Base):
|
||||
__tablename__ = "idempotency_keys"
|
||||
user_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), primary_key=True)
|
||||
|
||||
@@ -0,0 +1,132 @@
|
||||
"""Вложения: upload в S3, метаданные в PostgreSQL, download через API."""
|
||||
import re
|
||||
import uuid
|
||||
|
||||
from fastapi import APIRouter, Depends, Query, Request, Security
|
||||
from fastapi.responses import Response
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from ..deps import current_user, get_db, parse_uuid
|
||||
from ..errors import ApiError
|
||||
from ..models import Attachment, ChatMember, User
|
||||
from ..schemas import AttachmentOut
|
||||
from .. import s3
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
_FILENAME_BAD = re.compile(r"[/\\\x00-\x1f\x7f]")
|
||||
|
||||
|
||||
def _validate_filename(raw: str) -> str:
|
||||
if not isinstance(raw, str) or not (1 <= len(raw) <= 255):
|
||||
raise ApiError(400, "invalid_request", "Некорректный filename")
|
||||
if _FILENAME_BAD.search(raw):
|
||||
raise ApiError(400, "invalid_request", "Некорректный filename")
|
||||
return raw
|
||||
|
||||
|
||||
def _require_member(db: Session, chat_id: uuid.UUID, user_id: uuid.UUID) -> None:
|
||||
if db.get(ChatMember, (chat_id, user_id)) is None:
|
||||
raise ApiError(404, "not_found", "Чат не найден")
|
||||
|
||||
|
||||
def _to_out(att: Attachment) -> AttachmentOut:
|
||||
return AttachmentOut(
|
||||
id=att.id,
|
||||
chat_id=att.chat_id,
|
||||
owner_id=att.owner_id,
|
||||
filename=att.filename,
|
||||
content_type=att.content_type,
|
||||
size_bytes=att.size_bytes,
|
||||
sha256=att.sha256,
|
||||
status=att.status,
|
||||
variants=[],
|
||||
error_code=att.error_code,
|
||||
created_at=att.created_at,
|
||||
updated_at=att.updated_at,
|
||||
)
|
||||
|
||||
|
||||
@router.post(
|
||||
"/api/v1/chats/{chat_id}/attachments",
|
||||
response_model=AttachmentOut,
|
||||
status_code=201,
|
||||
)
|
||||
async def upload_attachment(
|
||||
chat_id: str,
|
||||
request: Request,
|
||||
filename: str = Query(...),
|
||||
user: User = Security(current_user),
|
||||
db: Session = Depends(get_db),
|
||||
):
|
||||
cid = parse_uuid(chat_id)
|
||||
_require_member(db, cid, user.id)
|
||||
name = _validate_filename(filename)
|
||||
|
||||
declared = (request.headers.get("content-type") or "").split(";")[0].strip().lower()
|
||||
if declared not in ("image/png", "image/jpeg"):
|
||||
raise ApiError(415, "unsupported_media_type", "Ожидается image/png или image/jpeg")
|
||||
|
||||
# Читаем тело потоково с жёстким лимитом.
|
||||
data, sha, actual = s3.read_upload(request.stream(), declared)
|
||||
|
||||
att_id = uuid.uuid4()
|
||||
key = s3.new_object_key(str(cid), str(att_id))
|
||||
s3.put_object(key, data, actual)
|
||||
|
||||
att = Attachment(
|
||||
id=att_id,
|
||||
chat_id=cid,
|
||||
owner_id=user.id,
|
||||
filename=name,
|
||||
content_type=actual,
|
||||
size_bytes=len(data),
|
||||
sha256=sha,
|
||||
object_key=key,
|
||||
status="ready",
|
||||
error_code=None,
|
||||
)
|
||||
db.add(att)
|
||||
try:
|
||||
db.commit()
|
||||
except Exception:
|
||||
db.rollback()
|
||||
# Компенсация: удаляем объект, чтобы не оставить orphan в S3.
|
||||
s3.delete_object(key)
|
||||
raise
|
||||
db.refresh(att)
|
||||
return _to_out(att)
|
||||
|
||||
|
||||
@router.get("/api/v1/attachments/{attachment_id}", response_model=AttachmentOut)
|
||||
def get_attachment(
|
||||
attachment_id: str,
|
||||
user: User = Security(current_user),
|
||||
db: Session = Depends(get_db),
|
||||
):
|
||||
aid = parse_uuid(attachment_id)
|
||||
att = db.get(Attachment, aid)
|
||||
if att is None:
|
||||
raise ApiError(404, "not_found", "Вложение не найдено")
|
||||
_require_member(db, att.chat_id, user.id)
|
||||
return _to_out(att)
|
||||
|
||||
|
||||
@router.get("/api/v1/attachments/{attachment_id}/content")
|
||||
def download_attachment(
|
||||
attachment_id: str,
|
||||
variant: str = Query("original"),
|
||||
user: User = Security(current_user),
|
||||
db: Session = Depends(get_db),
|
||||
):
|
||||
aid = parse_uuid(attachment_id)
|
||||
att = db.get(Attachment, aid)
|
||||
if att is None:
|
||||
raise ApiError(404, "not_found", "Вложение не найдено")
|
||||
_require_member(db, att.chat_id, user.id)
|
||||
if variant != "original":
|
||||
raise ApiError(404, "not_found", "Вариант не найден")
|
||||
if att.status != "ready":
|
||||
raise ApiError(409, "conflict", "Вложение не готово")
|
||||
body, ctype = s3.get_object(att.object_key)
|
||||
return Response(content=body, media_type=ctype)
|
||||
+56
-8
@@ -12,7 +12,7 @@ from sqlalchemy.orm import Session
|
||||
from ..config import settings
|
||||
from ..deps import current_user, get_db, parse_uuid
|
||||
from ..errors import ApiError
|
||||
from ..models import Chat, ChatMember, IdempotencyKey, Message, User
|
||||
from ..models import Attachment, Chat, ChatMember, IdempotencyKey, Message, MessageAttachment, User
|
||||
from ..schemas import CreateMessage, MessageOut, MessagePage
|
||||
from .chats import _decode_cursor, _encode_cursor, _require_member
|
||||
|
||||
@@ -22,10 +22,55 @@ _KEY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
|
||||
|
||||
|
||||
def _body_hash(body: CreateMessage) -> str:
|
||||
canonical = json.dumps({"text": body.text}, sort_keys=True, ensure_ascii=False)
|
||||
canonical = json.dumps(
|
||||
{
|
||||
"text": body.text,
|
||||
"attachment_ids": sorted(str(a) for a in body.attachment_ids),
|
||||
},
|
||||
sort_keys=True,
|
||||
ensure_ascii=False,
|
||||
)
|
||||
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
def _attachment_ids_for(db: Session, message_id) -> list:
|
||||
rows = db.scalars(
|
||||
select(MessageAttachment.attachment_id)
|
||||
.where(MessageAttachment.message_id == message_id)
|
||||
.order_by(MessageAttachment.position.asc())
|
||||
)
|
||||
return list(rows)
|
||||
|
||||
|
||||
def _to_out(db: Session, msg: Message) -> MessageOut:
|
||||
return MessageOut(
|
||||
id=msg.id,
|
||||
chat_id=msg.chat_id,
|
||||
sender_id=msg.sender_id,
|
||||
text=msg.text,
|
||||
created_at=msg.created_at,
|
||||
attachment_ids=_attachment_ids_for(db, msg.id),
|
||||
)
|
||||
|
||||
|
||||
def _validate_attachments(db: Session, chat_id, ids: list) -> list:
|
||||
"""Все вложения должны принадлежать этому чату и быть ready."""
|
||||
if not ids:
|
||||
return []
|
||||
unique = list(dict.fromkeys(ids))
|
||||
if len(unique) != len(ids):
|
||||
raise ApiError(400, "invalid_request", "attachment_ids содержит дубликаты")
|
||||
rows = list(db.scalars(select(Attachment).where(Attachment.id.in_(unique))))
|
||||
by_id = {a.id: a for a in rows}
|
||||
for aid in unique:
|
||||
att = by_id.get(aid)
|
||||
if att is None or att.chat_id != chat_id:
|
||||
raise ApiError(404, "not_found", "Вложение не найдено")
|
||||
if att.status == "failed":
|
||||
raise ApiError(409, "conflict", "Вложение в состоянии failed")
|
||||
return unique
|
||||
|
||||
|
||||
@router.post("/api/v1/chats/{chat_id}/messages", response_model=MessageOut, status_code=201)
|
||||
def create_message(
|
||||
chat_id: str,
|
||||
@@ -37,23 +82,26 @@ def create_message(
|
||||
):
|
||||
cid = parse_uuid(chat_id)
|
||||
_require_member(db, cid, user.id)
|
||||
if not body.text.strip():
|
||||
raise ApiError(400, "invalid_request", "text не может быть пустым")
|
||||
if not body.text.strip() and not body.attachment_ids:
|
||||
raise ApiError(400, "invalid_request", "text не может быть пустым без вложений")
|
||||
if not idempotency_key or not _KEY_RE.match(idempotency_key):
|
||||
raise ApiError(400, "invalid_request", "Некорректный Idempotency-Key")
|
||||
path = f"/api/v1/chats/{cid}/messages"
|
||||
bh = _body_hash(body)
|
||||
attachment_ids = _validate_attachments(db, cid, list(body.attachment_ids))
|
||||
|
||||
existing = db.get(IdempotencyKey, (user.id, "POST", path, idempotency_key))
|
||||
if existing is not None:
|
||||
if existing.body_hash != bh:
|
||||
raise ApiError(409, "conflict", "Ключ уже использован с другим телом")
|
||||
msg = db.get(Message, existing.message_id)
|
||||
return MessageOut.model_validate(msg, from_attributes=True)
|
||||
return _to_out(db, msg)
|
||||
|
||||
msg = Message(chat_id=cid, sender_id=user.id, text=body.text)
|
||||
db.add(msg)
|
||||
db.flush()
|
||||
for pos, aid in enumerate(attachment_ids):
|
||||
db.add(MessageAttachment(message_id=msg.id, attachment_id=aid, position=pos))
|
||||
db.add(IdempotencyKey(user_id=user.id, method="POST", path=path, key=idempotency_key, body_hash=bh, message_id=msg.id))
|
||||
try:
|
||||
db.commit()
|
||||
@@ -65,9 +113,9 @@ def create_message(
|
||||
if existing.body_hash != bh:
|
||||
raise ApiError(409, "conflict", "Ключ уже использован с другим телом")
|
||||
msg = db.get(Message, existing.message_id)
|
||||
return MessageOut.model_validate(msg, from_attributes=True)
|
||||
return _to_out(db, msg)
|
||||
db.refresh(msg)
|
||||
return MessageOut.model_validate(msg, from_attributes=True)
|
||||
return _to_out(db, msg)
|
||||
|
||||
|
||||
@router.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage)
|
||||
@@ -95,4 +143,4 @@ def list_messages(
|
||||
rows = rows[:limit]
|
||||
last = rows[-1]
|
||||
next_cursor = _encode_cursor(last.created_at, last.id)
|
||||
return MessagePage(items=[MessageOut.model_validate(m, from_attributes=True) for m in rows], next_cursor=next_cursor)
|
||||
return MessagePage(items=[_to_out(db, m) for m in rows], next_cursor=next_cursor)
|
||||
|
||||
@@ -0,0 +1,150 @@
|
||||
"""S3-клиент (MinIO) и потоковая валидация изображений.
|
||||
|
||||
Потоковая загрузка: читаем тело запроса чанками, считаем SHA-256 и размер,
|
||||
не держим весь файл в памяти. MIME определяем по magic bytes, пиксели —
|
||||
через Pillow с защитой от decompression bomb.
|
||||
"""
|
||||
import hashlib
|
||||
import io
|
||||
import logging
|
||||
import uuid
|
||||
from typing import BinaryIO
|
||||
|
||||
import boto3
|
||||
from botocore.client import Config as BotoConfig
|
||||
from botocore.exceptions import BotoCoreError, ClientError
|
||||
from PIL import Image, UnidentifiedImageError
|
||||
|
||||
from .config import settings
|
||||
from .errors import ApiError
|
||||
|
||||
logger = logging.getLogger("messenger.s3")
|
||||
|
||||
PNG_MAGIC = b"\x89PNG\r\n\x1a\n"
|
||||
JPEG_MAGIC = b"\xff\xd8\xff"
|
||||
|
||||
|
||||
def _client():
|
||||
return boto3.client(
|
||||
"s3",
|
||||
endpoint_url=settings.s3_endpoint,
|
||||
region_name=settings.s3_region,
|
||||
aws_access_key_id=settings.s3_access_key_id,
|
||||
aws_secret_access_key=settings.s3_secret_access_key,
|
||||
use_ssl=settings.s3_use_ssl,
|
||||
config=BotoConfig(signature_version="s3v4", s3={"addressing_style": "path"}),
|
||||
)
|
||||
|
||||
|
||||
def ensure_bucket() -> None:
|
||||
"""Идемпотентно создаёт bucket, если его нет."""
|
||||
client = _client()
|
||||
try:
|
||||
client.head_bucket(Bucket=settings.s3_bucket)
|
||||
except ClientError as exc:
|
||||
code = exc.response.get("Error", {}).get("Code", "")
|
||||
if code in ("404", "NoSuchBucket", "NotFound"):
|
||||
client.create_bucket(Bucket=settings.s3_bucket)
|
||||
logger.info("created bucket %s", settings.s3_bucket)
|
||||
else:
|
||||
raise
|
||||
|
||||
|
||||
def new_object_key(chat_id: str, attachment_id: str) -> str:
|
||||
"""Случайный ключ; filename не используется как путь."""
|
||||
return f"chats/{chat_id}/{attachment_id}/{uuid.uuid4().hex}"
|
||||
|
||||
|
||||
def _detect_mime(head: bytes) -> str | None:
|
||||
if head.startswith(PNG_MAGIC):
|
||||
return "image/png"
|
||||
if head.startswith(JPEG_MAGIC):
|
||||
return "image/jpeg"
|
||||
return None
|
||||
|
||||
|
||||
def _validate_image(data: bytes, declared_mime: str) -> str:
|
||||
"""Проверяет magic bytes, декодирует заголовок, считает пиксели.
|
||||
|
||||
Возвращает фактический MIME. Бросает ApiError(415/413).
|
||||
"""
|
||||
actual = _detect_mime(data[:16])
|
||||
if actual is None:
|
||||
raise ApiError(415, "unsupported_media_type", "Поддерживаются только PNG и JPEG")
|
||||
if actual != declared_mime:
|
||||
raise ApiError(415, "unsupported_media_type", "Content-Type не совпадает с содержимым")
|
||||
try:
|
||||
with Image.open(io.BytesIO(data)) as img:
|
||||
width, height = img.size
|
||||
except (UnidentifiedImageError, OSError):
|
||||
raise ApiError(415, "unsupported_media_type", "Повреждённое изображение")
|
||||
if width <= 0 or height <= 0:
|
||||
raise ApiError(415, "unsupported_media_type", "Повреждённое изображение")
|
||||
if width * height > settings.max_image_pixels:
|
||||
raise ApiError(413, "payload_too_large", "Слишком много пикселей")
|
||||
return actual
|
||||
|
||||
|
||||
def read_upload(stream: BinaryIO, declared_mime: str) -> tuple[bytes, str, str]:
|
||||
"""Читает поток с лимитом, возвращает (bytes, sha256, actual_mime).
|
||||
|
||||
Файл ≤10 MiB, поэтому держим его в памяти — это упрощает валидацию
|
||||
и не создаёт неограниченного потребления RAM (лимит жёсткий).
|
||||
"""
|
||||
limit = settings.max_upload_bytes
|
||||
buf = bytearray()
|
||||
hasher = hashlib.sha256()
|
||||
while True:
|
||||
chunk = stream.read(settings.upload_chunk_size)
|
||||
if not chunk:
|
||||
break
|
||||
buf.extend(chunk)
|
||||
hasher.update(chunk)
|
||||
if len(buf) > limit:
|
||||
raise ApiError(413, "payload_too_large", "Файл больше 10 MiB")
|
||||
if not buf:
|
||||
raise ApiError(400, "invalid_request", "Пустое тело запроса")
|
||||
data = bytes(buf)
|
||||
actual = _validate_image(data, declared_mime)
|
||||
return data, hasher.hexdigest(), actual
|
||||
|
||||
|
||||
def put_object(key: str, data: bytes, content_type: str) -> None:
|
||||
client = _client()
|
||||
try:
|
||||
client.put_object(
|
||||
Bucket=settings.s3_bucket,
|
||||
Key=key,
|
||||
Body=data,
|
||||
ContentType=content_type,
|
||||
)
|
||||
except (BotoCoreError, ClientError) as exc:
|
||||
logger.error("s3 put failed: %s", type(exc).__name__)
|
||||
raise ApiError(503, "unavailable", "Хранилище недоступно")
|
||||
|
||||
|
||||
def get_object(key: str) -> tuple[bytes, str]:
|
||||
client = _client()
|
||||
try:
|
||||
resp = client.get_object(Bucket=settings.s3_bucket, Key=key)
|
||||
body = resp["Body"].read()
|
||||
ctype = resp.get("ContentType") or "application/octet-stream"
|
||||
return body, ctype
|
||||
except ClientError as exc:
|
||||
code = exc.response.get("Error", {}).get("Code", "")
|
||||
if code in ("NoSuchKey", "404", "NotFound"):
|
||||
raise ApiError(404, "not_found", "Объект не найден")
|
||||
logger.error("s3 get failed: %s", type(exc).__name__)
|
||||
raise ApiError(503, "unavailable", "Хранилище недоступно")
|
||||
except BotoCoreError as exc:
|
||||
logger.error("s3 get failed: %s", type(exc).__name__)
|
||||
raise ApiError(503, "unavailable", "Хранилище недоступно")
|
||||
|
||||
|
||||
def delete_object(key: str) -> None:
|
||||
"""Best-effort удаление для компенсации при сбое между S3 и БД."""
|
||||
client = _client()
|
||||
try:
|
||||
client.delete_object(Bucket=settings.s3_bucket, Key=key)
|
||||
except (BotoCoreError, ClientError) as exc:
|
||||
logger.warning("s3 delete failed: %s", type(exc).__name__)
|
||||
+29
-1
@@ -49,11 +49,39 @@ class MessageOut(BaseModel):
|
||||
sender_id: uuid.UUID
|
||||
text: str
|
||||
created_at: datetime
|
||||
attachment_ids: List[uuid.UUID] = Field(default_factory=list)
|
||||
|
||||
|
||||
class CreateMessage(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
text: str = Field(min_length=1, max_length=4000)
|
||||
text: str = Field(default="", max_length=4000)
|
||||
attachment_ids: List[uuid.UUID] = Field(default_factory=list, max_length=10)
|
||||
|
||||
|
||||
class VariantOut(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
name: str
|
||||
content_type: str
|
||||
size_bytes: int
|
||||
width: int
|
||||
height: int
|
||||
sha256: str
|
||||
|
||||
|
||||
class AttachmentOut(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
id: uuid.UUID
|
||||
chat_id: uuid.UUID
|
||||
owner_id: uuid.UUID
|
||||
filename: str
|
||||
content_type: str
|
||||
size_bytes: int
|
||||
sha256: str
|
||||
status: str
|
||||
variants: List[VariantOut] = Field(default_factory=list)
|
||||
error_code: Optional[str] = None
|
||||
created_at: datetime
|
||||
updated_at: datetime
|
||||
|
||||
|
||||
class ChatPage(BaseModel):
|
||||
|
||||
+119
@@ -0,0 +1,119 @@
|
||||
# Локальный стенд lab4: LB (nginx) → API × 2 → PostgreSQL + Redis + MinIO.
|
||||
# Секреты читаются из ./secrets/*.txt (не коммитятся).
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.4-alpine
|
||||
environment:
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_PASSWORD: messenger
|
||||
POSTGRES_DB: messenger
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
|
||||
redis:
|
||||
image: redis:7.4-alpine
|
||||
command: ["redis-server", "--save", "", "--appendonly", "no"]
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
|
||||
s3:
|
||||
image: minio/minio:RELEASE.2024-10-13T13-34-11Z
|
||||
command: ["server", "/data", "--console-address", ":9001"]
|
||||
environment:
|
||||
MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minioadmin}
|
||||
MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-minioadmin-local-only}
|
||||
volumes:
|
||||
- s3data:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "mc", "ready", "local"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 30
|
||||
|
||||
minio-init:
|
||||
image: python:3.12-slim
|
||||
depends_on:
|
||||
s3:
|
||||
condition: service_healthy
|
||||
environment:
|
||||
S3_ENDPOINT: http://s3:9000
|
||||
S3_REGION: us-east-1
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
S3_ACCESS_KEY_ID: ${MINIO_ROOT_USER:-minioadmin}
|
||||
S3_SECRET_ACCESS_KEY: ${MINIO_ROOT_PASSWORD:-minioadmin-local-only}
|
||||
volumes:
|
||||
- ./scripts/bootstrap_s3.py:/bootstrap_s3.py:ro
|
||||
command: ["sh", "-c", "pip install --quiet boto3==1.35.76 && python /bootstrap_s3.py"]
|
||||
restart: "no"
|
||||
|
||||
api-1:
|
||||
build: .
|
||||
environment:
|
||||
DATABASE_URL: postgresql+psycopg://messenger:messenger@postgres:5432/messenger
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
|
||||
INSTANCE_ID: api-1
|
||||
S3_ENDPOINT: http://s3:9000
|
||||
S3_REGION: us-east-1
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
S3_ACCESS_KEY_ID: ${MINIO_ROOT_USER:-minioadmin}
|
||||
S3_SECRET_ACCESS_KEY: ${MINIO_ROOT_PASSWORD:-minioadmin-local-only}
|
||||
MAX_UPLOAD_BYTES: "10485760"
|
||||
MAX_IMAGE_PIXELS: "40000000"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
s3:
|
||||
condition: service_healthy
|
||||
minio-init:
|
||||
condition: service_completed_successfully
|
||||
command: ["sh", "-c", "alembic upgrade head && uvicorn app.main:app --host 0.0.0.0 --port 8080"]
|
||||
|
||||
api-2:
|
||||
build: .
|
||||
environment:
|
||||
DATABASE_URL: postgresql+psycopg://messenger:messenger@postgres:5432/messenger
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
|
||||
INSTANCE_ID: api-2
|
||||
S3_ENDPOINT: http://s3:9000
|
||||
S3_REGION: us-east-1
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
S3_ACCESS_KEY_ID: ${MINIO_ROOT_USER:-minioadmin}
|
||||
S3_SECRET_ACCESS_KEY: ${MINIO_ROOT_PASSWORD:-minioadmin-local-only}
|
||||
MAX_UPLOAD_BYTES: "10485760"
|
||||
MAX_IMAGE_PIXELS: "40000000"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
s3:
|
||||
condition: service_healthy
|
||||
minio-init:
|
||||
condition: service_completed_successfully
|
||||
command: ["sh", "-c", "alembic upgrade head && uvicorn app.main:app --host 0.0.0.0 --port 8080"]
|
||||
|
||||
lb:
|
||||
image: nginx:1.27-alpine
|
||||
ports:
|
||||
- "8080:8080"
|
||||
volumes:
|
||||
- ./infra/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
|
||||
depends_on:
|
||||
- api-1
|
||||
- api-2
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
s3data:
|
||||
@@ -0,0 +1,11 @@
|
||||
fastapi==0.115.5
|
||||
uvicorn[standard]==0.32.1
|
||||
sqlalchemy==2.0.36
|
||||
psycopg[binary,pool]==3.2.3
|
||||
psycopg-pool==3.2.3
|
||||
alembic==1.14.0
|
||||
argon2-cffi==23.1.0
|
||||
redis==5.2.0
|
||||
boto3==1.35.76
|
||||
Pillow==11.0.0
|
||||
python-multipart==0.0.20
|
||||
@@ -0,0 +1,61 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Идемпотентный bootstrap приватного bucket в MinIO.
|
||||
|
||||
Запускается как one-shot сервис в compose (minio-init) после старта MinIO.
|
||||
Создаёт bucket, если его нет. Политика приватности — по умолчанию (никаких
|
||||
публичных ACL), поэтому отдельный set-bucket-policy не нужен.
|
||||
"""
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
|
||||
import boto3
|
||||
from botocore.client import Config as BotoConfig
|
||||
from botocore.exceptions import BotoCoreError, ClientError
|
||||
|
||||
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
|
||||
log = logging.getLogger("bootstrap_s3")
|
||||
|
||||
|
||||
def _client():
|
||||
return boto3.client(
|
||||
"s3",
|
||||
endpoint_url=os.environ.get("S3_ENDPOINT", "http://s3:9000"),
|
||||
region_name=os.environ.get("S3_REGION", "us-east-1"),
|
||||
aws_access_key_id=os.environ["S3_ACCESS_KEY_ID"],
|
||||
aws_secret_access_key=os.environ["S3_SECRET_ACCESS_KEY"],
|
||||
config=BotoConfig(signature_version="s3v4", s3={"addressing_style": "path"}),
|
||||
)
|
||||
|
||||
|
||||
def main() -> int:
|
||||
bucket = os.environ.get("S3_BUCKET", "messenger-attachments")
|
||||
client = _client()
|
||||
deadline = time.monotonic() + 60
|
||||
while True:
|
||||
try:
|
||||
client.head_bucket(Bucket=bucket)
|
||||
log.info("bucket %s already exists", bucket)
|
||||
return 0
|
||||
except ClientError as exc:
|
||||
code = exc.response.get("Error", {}).get("Code", "")
|
||||
if code in ("404", "NoSuchBucket", "NotFound"):
|
||||
try:
|
||||
client.create_bucket(Bucket=bucket)
|
||||
log.info("created bucket %s", bucket)
|
||||
return 0
|
||||
except (BotoCoreError, ClientError) as create_exc:
|
||||
log.warning("create_bucket failed: %s", type(create_exc).__name__)
|
||||
else:
|
||||
log.warning("head_bucket failed: %s", code or type(exc).__name__)
|
||||
except BotoCoreError as exc:
|
||||
log.warning("s3 not ready: %s", type(exc).__name__)
|
||||
if time.monotonic() > deadline:
|
||||
log.error("bootstrap timeout")
|
||||
return 1
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -4,6 +4,7 @@ set -eu
|
||||
# Does NOT remove volumes, does NOT re-seed, does NOT print credentials.
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env restart postgres
|
||||
docker compose --env-file .env restart s3
|
||||
docker compose --env-file .env restart api-1 api-2
|
||||
# Wait for readiness through the LB.
|
||||
i=0
|
||||
|
||||
@@ -0,0 +1,214 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Собственные тесты уровня 4 для вложений.
|
||||
|
||||
Покрывают: слишком большой файл, повреждённое изображение, подмену MIME,
|
||||
чужой attachment_id, привязку файла другого чата, отсутствие доступа у
|
||||
постороннего, эксперимент с памятью при ≥10 одновременных загрузках.
|
||||
|
||||
Запуск: python3 tests/test_attachments.py --base-url http://localhost:8080
|
||||
"""
|
||||
import argparse
|
||||
import base64
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import unittest
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
_parser = argparse.ArgumentParser(description="Attachment tests (lab4)")
|
||||
_parser.add_argument("--base-url", default=None)
|
||||
_args, _unknown = _parser.parse_known_args()
|
||||
sys.argv = [sys.argv[0]] + _unknown
|
||||
|
||||
BASE_URL = (_args.base_url or os.environ.get("BASE_URL") or "http://localhost:8080").rstrip("/")
|
||||
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
FIXTURE = os.path.join(ROOT, "tests", "fixtures", "sample.png")
|
||||
|
||||
|
||||
def request(method, path, body=None, token=None, raw=None, content_type=None):
|
||||
headers = {"Accept": "application/json"}
|
||||
if token:
|
||||
headers["Authorization"] = "Bearer " + token
|
||||
data = None
|
||||
if raw is not None:
|
||||
data = raw
|
||||
if content_type:
|
||||
headers["Content-Type"] = content_type
|
||||
elif body is not None:
|
||||
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
|
||||
headers["Content-Type"] = "application/json"
|
||||
req = urllib.request.Request(BASE_URL + path, data=data, headers=headers, method=method)
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=30) as resp:
|
||||
payload = resp.read()
|
||||
ctype = resp.headers.get_content_type()
|
||||
if ctype == "application/json" and payload:
|
||||
return resp.status, json.loads(payload), resp.headers
|
||||
return resp.status, payload, resp.headers
|
||||
except urllib.error.HTTPError as err:
|
||||
payload = err.read()
|
||||
try:
|
||||
parsed = json.loads(payload) if payload else None
|
||||
except ValueError:
|
||||
parsed = None
|
||||
return err.code, parsed, err.headers
|
||||
|
||||
|
||||
def make_user(label):
|
||||
username = "u_" + label + "_" + uuid.uuid4().hex[:10]
|
||||
password = "T3st-" + uuid.uuid4().hex
|
||||
status, user, _ = request(
|
||||
"POST",
|
||||
"/api/v1/users",
|
||||
{"username": username, "display_name": "Att " + label, "password": password},
|
||||
)
|
||||
assert status == 201, (status, user)
|
||||
basic = base64.b64encode((username + ":" + password).encode()).decode()
|
||||
status, session, _ = request("POST", "/api/v1/auth/sessions", raw=b"", content_type=None) if False else (None, None, None)
|
||||
# Basic-вход: используем заголовок Authorization напрямую.
|
||||
req = urllib.request.Request(
|
||||
BASE_URL + "/api/v1/auth/sessions",
|
||||
headers={"Authorization": "Basic " + basic, "Accept": "application/json"},
|
||||
method="POST",
|
||||
)
|
||||
with urllib.request.urlopen(req, timeout=10) as resp:
|
||||
session = json.loads(resp.read())
|
||||
return {"user": user, "token": session["token"]}
|
||||
|
||||
|
||||
def make_chat(owner, members):
|
||||
status, chat, _ = request(
|
||||
"POST",
|
||||
"/api/v1/chats",
|
||||
{"title": "Att chat", "member_ids": [owner["user"]["id"]] + [m["user"]["id"] for m in members]},
|
||||
token=owner["token"],
|
||||
)
|
||||
assert status == 201, (status, chat)
|
||||
return chat
|
||||
|
||||
|
||||
def upload(token, chat_id, data, filename="sample.png", content_type="image/png"):
|
||||
path = "/api/v1/chats/" + chat_id + "/attachments?filename=" + urllib.request.quote(filename)
|
||||
return request("POST", path, raw=data, token=token, content_type=content_type)
|
||||
|
||||
|
||||
class AttachmentTests(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
with open(FIXTURE, "rb") as fh:
|
||||
cls.png = fh.read()
|
||||
cls.alice = make_user("alice")
|
||||
cls.bob = make_user("bob")
|
||||
cls.eve = make_user("eve")
|
||||
cls.chat = make_chat(cls.alice, [cls.bob])
|
||||
cls.other_chat = make_chat(cls.alice, [cls.bob])
|
||||
|
||||
def test_upload_and_download_roundtrip(self):
|
||||
status, att, _ = upload(self.alice["token"], self.chat["id"], self.png)
|
||||
self.assertEqual(status, 201, att)
|
||||
self.assertEqual(att["status"], "ready")
|
||||
self.assertEqual(att["content_type"], "image/png")
|
||||
self.assertEqual(att["size_bytes"], len(self.png))
|
||||
status, body, headers = request(
|
||||
"GET", "/api/v1/attachments/" + att["id"] + "/content", token=self.bob["token"]
|
||||
)
|
||||
self.assertEqual(status, 200)
|
||||
self.assertEqual(body, self.png)
|
||||
self.assertEqual(headers.get_content_type(), "image/png")
|
||||
|
||||
def test_oversized_rejected(self):
|
||||
big = b"\x89PNG\r\n\x1a\n" + b"\x00" * (10 * 1024 * 1024 + 1)
|
||||
status, body, _ = upload(self.alice["token"], self.chat["id"], big)
|
||||
self.assertEqual(status, 413)
|
||||
self.assertEqual(body["error"]["code"], "payload_too_large")
|
||||
|
||||
def test_corrupted_image_rejected(self):
|
||||
broken = b"\x89PNG\r\n\x1a\n" + b"garbage" * 100
|
||||
status, body, _ = upload(self.alice["token"], self.chat["id"], broken)
|
||||
self.assertEqual(status, 415)
|
||||
self.assertEqual(body["error"]["code"], "unsupported_media_type")
|
||||
|
||||
def test_mime_spoof_rejected(self):
|
||||
# Заявляем image/png, а содержимое — JPEG.
|
||||
jpeg = b"\xff\xd8\xff\xe0" + b"\x00" * 100
|
||||
status, body, _ = upload(self.alice["token"], self.chat["id"], jpeg, content_type="image/png")
|
||||
self.assertEqual(status, 415)
|
||||
self.assertEqual(body["error"]["code"], "unsupported_media_type")
|
||||
|
||||
def test_unsupported_content_type(self):
|
||||
status, body, _ = upload(self.alice["token"], self.chat["id"], self.png, content_type="text/plain")
|
||||
self.assertEqual(status, 415)
|
||||
|
||||
def test_dangerous_filename_rejected(self):
|
||||
status, body, _ = upload(self.alice["token"], self.chat["id"], self.png, filename="../etc/passwd")
|
||||
self.assertEqual(status, 400)
|
||||
self.assertEqual(body["error"]["code"], "invalid_request")
|
||||
|
||||
def test_outsider_cannot_read(self):
|
||||
status, att, _ = upload(self.alice["token"], self.chat["id"], self.png)
|
||||
self.assertEqual(status, 201)
|
||||
for suffix in ("", "/content"):
|
||||
status, body, _ = request(
|
||||
"GET", "/api/v1/attachments/" + att["id"] + suffix, token=self.eve["token"]
|
||||
)
|
||||
self.assertEqual(status, 404)
|
||||
self.assertEqual(body["error"]["code"], "not_found")
|
||||
|
||||
def test_attachment_from_other_chat_rejected(self):
|
||||
status, att, _ = upload(self.alice["token"], self.other_chat["id"], self.png)
|
||||
self.assertEqual(status, 201)
|
||||
status, body, _ = request(
|
||||
"POST",
|
||||
"/api/v1/chats/" + self.chat["id"] + "/messages",
|
||||
{"text": "", "attachment_ids": [att["id"]]},
|
||||
token=self.alice["token"],
|
||||
)
|
||||
self.assertEqual(status, 404)
|
||||
self.assertEqual(body["error"]["code"], "not_found")
|
||||
|
||||
def test_message_with_attachment(self):
|
||||
status, att, _ = upload(self.alice["token"], self.chat["id"], self.png)
|
||||
self.assertEqual(status, 201)
|
||||
status, msg, _ = request(
|
||||
"POST",
|
||||
"/api/v1/chats/" + self.chat["id"] + "/messages",
|
||||
{"text": "", "attachment_ids": [att["id"]]},
|
||||
token=self.alice["token"],
|
||||
)
|
||||
self.assertEqual(status, 201, msg)
|
||||
self.assertEqual(msg["attachment_ids"], [att["id"]])
|
||||
self.assertEqual(msg["text"], "")
|
||||
|
||||
def test_concurrent_uploads_memory(self):
|
||||
"""≥10 одновременных загрузок; проверяем, что все успешны и API жив."""
|
||||
results = []
|
||||
lock = threading.Lock()
|
||||
|
||||
def worker():
|
||||
status, att, _ = upload(self.alice["token"], self.chat["id"], self.png)
|
||||
with lock:
|
||||
results.append((status, att))
|
||||
|
||||
threads = [threading.Thread(target=worker) for _ in range(10)]
|
||||
started = time.monotonic()
|
||||
for t in threads:
|
||||
t.start()
|
||||
for t in threads:
|
||||
t.join()
|
||||
elapsed = time.monotonic() - started
|
||||
self.assertEqual(len(results), 10)
|
||||
for status, att in results:
|
||||
self.assertEqual(status, 201, att)
|
||||
# API остаётся живым после нагрузки.
|
||||
status, _, _ = request("GET", "/health/ready")
|
||||
self.assertEqual(status, 200)
|
||||
print("\nconcurrent uploads: 10 in %.2fs" % elapsed)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main(verbosity=2)
|
||||
Reference in New Issue
Block a user