ЛР4 - Будилов БВТ2304 - на 4 #31

Closed
Budilov_bvt2304 wants to merge 1 commits from Budilov_bvt2304/mtusi2026lab4:solution/BVT2304-Budilov_Yaroslav into main
20 changed files with 1314 additions and 11 deletions
+23
View File
@@ -0,0 +1,23 @@
FROM python:3.12-slim
RUN apt-get update && apt-get install -y --no-install-recommends \
gcc \
libpq-dev \
curl \
libmagic1 \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app/ ./app/
COPY alembic.ini .
COPY alembic/ ./alembic/
# Создаём непривилегированного пользователя для read-only контейнера
RUN useradd -m appuser && chown -R appuser:appuser /app
USER appuser
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]
+42 -11
View File
@@ -1,26 +1,50 @@
# Отчёт — лабораторная 4
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Автор, группа: Будилов Ярослав БВТ2304
- Целевая оценка 4; выбранный трек 5
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
**Prerequisites:** Docker, Docker Compose v2, Python 3.9+.
**Шаги:**
1. Клонировать репозиторий и создать `.env`:
```sh
cp .env.example .env
2. Запустить стенд с масштабированием:
docker compose up -d --build --scale api=2
3. Применить миграции БД:
docker compose run --rm api alembic upgrade head
4. Дождаться готовности всех сервисов:
docker compose ps
5. Запустить стенд с масштабированием:
python3 tests/smoke.py --base-url http://localhost:8080
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Топология: Клиент → Nginx (LB) → API (2+ реплики) → PostgreSQL (метаданные) + SeaweedFS S3 (байты).
Выбор S3: Использован chrislusf/seaweedfs:3.80 как легковесный, S3-совместимый сервер. Порт 8333 не опубликован наружу, доступен только внутри сети default.
Инициализация Bucket: Сервис s3-init (на базе amazon/aws-cli) идемпотентно создаёт приватный bucket messenger-attachments при старте. API использует credentials с ограниченными правами (только Read/List/Write в свой bucket).
Модель данных: Таблица attachments хранит метаданные (s3_key, original_filename, content_type, size_bytes, sha256, width, height). Связь с сообщением осуществляется через таблицу message_attachments.
Загрузка файлов:
Принимает сырые байты через POST /api/v1/chats/{chat_id}/attachments?filename=....
Проверяет размер (≤ 10 MiB) до декодирования.
Определяет MIME-тип по содержимому через python-magic (защита от подмены расширения).
Валидирует размеры изображения (≤ 40 млн пикселей) через Pillow.
Генерирует уникальный s3_key (attachments/{uuid}.ext), загружает в S3 и сохраняет метаданные в PostgreSQL.
Скачивание файлов: GET /api/v1/attachments/{id}/content проверяет принадлежность пользователя к чату перед проксированием байтов из S3.
Отказоустойчивость: Поскольку байты хранятся в общем S3, а метаданные в общей БД, любая API-реплика может обслужить запрос на скачивание после падения реплики, которая выполняла загрузку.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke | python3 tests/smoke.py --base-url http://localhost:8080 | PASS: lab4 public API scenario... | evidence/smoke_pass.txt |
| S3 в общем стенде, приватный bucket | docker compose ps + проверка конфига | Сервис s3 работает, порт не опубликован. s3-init создал bucket и завершил работу с кодом 0. | evidence/infra.txt |
| Метаданные в PostgreSQL, не байты на диске API | Конфиг compose.yaml + docker exec | У сервиса api установлен read_only: true и tmpfs на /tmp. Файлы не сохраняются на диске реплики. | evidence/infra.txt |
| Валидация: размер, MIME, повреждённый файл | Smoke-тест (встроенные проверки) | Загрузка файлов >10MB или с подменным MIME возвращает 413 или 415, а не 500. | evidence/smoke_pass.txt |
| Failover: upload → stop API → download | ./scripts/stop-one.sh | Файл, загруженный через реплику А, успешно скачивается через реплику Б после остановки А. | evidence/failover_demo.txt |
| Persistence: restart с volumes | docker compose down && docker compose up -d | После перезапуска метаданные и байты в S3 сохраняются, скачивание работает. | evidence/persistence.txt |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
@@ -30,8 +54,15 @@ TODO: гипотеза, hardware/лимиты, версии, объём данн
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Остановка API-реплики после upload | Другая реплика успешно скачивает файл по attachment_id | 200 OK с корректными байтами и совпадающим SHA-256. | ~5 сек (время переключения Nginx). Потери: 0. |
| Перезапуск всего стенда (down/up) | Сохранение метаданных в БД и байтов в S3 volume | Файлы доступны, smoke проходит полностью. | Потери: 0. |
| Попытка скачать чужое вложение |
Доступ запрещён | 404 Not Found, так как пользователь не состоит в чате. | Потери: 0. |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Выдерживаемые отказы: Падение до 50% API-реплик. Файлы остаются доступными, так как S3 и PostgreSQL являются общими ресурсами.
Не выдерживаемые отказы (SPOF): Падение SeaweedFS или PostgreSQL делает невозможным как загрузку, так и скачивание. Репликация S3/БД не реализована в рамках учебной задачи.
Ограничение RAM при загрузке (Уровень 4): Текущая реализация использует await request.body() с последующей проверкой размера (≤ 10 MiB) до декодирования. Это предотвращает DoS-атаки большими файлами на уровне приложения, но пиковое потребление RAM на один запрос составляет ~10 MiB. Для полноценного streaming (без буферизации всего файла в память) требовалась бы интеграция с ограничением client_max_body_size на уровне Nginx и потоковая валидация сигнатуры по чанкам, что выходит за рамки текущего API-контракта и возможностей стандартных библиотек валидации изображений (Pillow).
Согласованность хранилищ и Orphan-объекты (Уровень 4): В случае успеха записи в S3 и падения приложения до COMMIT в PostgreSQL, в S3 может остаться "orphan" (бесхозный) объект. Для компенсации этого сценария предусмотрен документированный механизм: фоновый reconciler-скрипт, который раз в 24 часа сканирует bucket messenger-attachments, сверяет s3_key с таблицей attachments и безопасно удаляет объекты, созданные ранее grace_period (например, 2 часа), не имеющие соответствующей записи в БД. Свежие или активно используемые вложения не удаляются.
Следующий шаг (Трек 5): Реализация presigned URL для прямой загрузки клиентом в S3, чтобы полностью разгрузить API от передачи бинарных данных и снять ограничение по RAM.
+41
View File
@@ -0,0 +1,41 @@
[alembic]
script_location = alembic
prepend_sys_path = .
version_path_separator = os
sqlalchemy.url = driver://user:pass@localhost/dbname
[post_write_hooks]
[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
+55
View File
@@ -0,0 +1,55 @@
import asyncio
import os
import sys
from logging.config import fileConfig
from sqlalchemy import pool
from sqlalchemy.engine import Connection
from sqlalchemy.ext.asyncio import async_engine_from_config
from alembic import context
# Добавляем корень проекта в sys.path, чтобы импортировать app
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from app.database import Base, DATABASE_URL
from app.models import User, UserSession, Chat, ChatMember, Message, IdempotencyKey, Attachment, MessageAttachment
config = context.config
if config.config_file_name is not None:
fileConfig(config.config_file_name)
target_metadata = Base.metadata
def run_migrations_offline() -> None:
context.configure(
url=DATABASE_URL,
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
)
with context.begin_transaction():
context.run_migrations()
def do_run_migrations(connection: Connection) -> None:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
async def run_async_migrations() -> None:
connectable = async_engine_from_config(
{"sqlalchemy.url": DATABASE_URL},
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
async with connectable.connect() as connection:
await connection.run_sync(do_run_migrations)
await connectable.dispose()
def run_migrations_online() -> None:
asyncio.run(run_async_migrations())
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
+26
View File
@@ -0,0 +1,26 @@
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
# revision identifiers, used by Alembic.
revision: str = ${repr(up_revision)}
down_revision: Union[str, None] = ${repr(down_revision)}
branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
def upgrade() -> None:
${upgrades if upgrades else "pass"}
def downgrade() -> None:
${downgrades if downgrades else "pass"}
@@ -0,0 +1,116 @@
"""initial schema with attachments
Revision ID: ef1db79b13b5
Revises:
Create Date: 2026-10-29 22:42:22.791042
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision: str = 'ef1db79b13b5'
down_revision: Union[str, None] = None
branch_labels: Union[str, Sequence[str], None] = None
depends_on: Union[str, Sequence[str], None] = None
def upgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('chats',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('title', sa.String(length=100), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
sa.PrimaryKeyConstraint('id')
)
op.create_table('users',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('username', sa.String(length=32), nullable=False),
sa.Column('display_name', sa.String(length=100), nullable=False),
sa.Column('password_hash', sa.String(length=255), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True)
op.create_table('attachments',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('owner_id', sa.UUID(), nullable=False),
sa.Column('chat_id', sa.UUID(), nullable=False),
sa.Column('s3_key', sa.String(length=512), nullable=False),
sa.Column('original_filename', sa.String(length=255), nullable=False),
sa.Column('content_type', sa.String(length=100), nullable=False),
sa.Column('size_bytes', sa.BigInteger(), nullable=False),
sa.Column('width', sa.BigInteger(), nullable=True),
sa.Column('height', sa.BigInteger(), nullable=True),
sa.Column('sha256', sa.String(length=64), nullable=False),
sa.Column('status', sa.String(length=20), nullable=False),
sa.Column('error_code', sa.String(length=50), nullable=True),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['owner_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('id'),
sa.UniqueConstraint('s3_key')
)
op.create_table('chat_members',
sa.Column('chat_id', sa.UUID(), nullable=False),
sa.Column('user_id', sa.UUID(), nullable=False),
sa.Column('joined_at', sa.DateTime(timezone=True), nullable=True),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('chat_id', 'user_id')
)
op.create_table('idempotency_keys',
sa.Column('key', sa.String(length=255), nullable=False),
sa.Column('chat_id', sa.UUID(), nullable=False),
sa.Column('response_data', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('key')
)
op.create_table('messages',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('chat_id', sa.UUID(), nullable=False),
sa.Column('sender_id', sa.UUID(), nullable=False),
sa.Column('text', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['sender_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_messages_chat_id'), 'messages', ['chat_id'], unique=False)
op.create_index(op.f('ix_messages_created_at'), 'messages', ['created_at'], unique=False)
op.create_table('sessions',
sa.Column('token', sa.String(length=255), nullable=False),
sa.Column('user_id', sa.UUID(), nullable=False),
sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('token')
)
op.create_table('message_attachments',
sa.Column('message_id', sa.UUID(), nullable=False),
sa.Column('attachment_id', sa.UUID(), nullable=False),
sa.ForeignKeyConstraint(['attachment_id'], ['attachments.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['message_id'], ['messages.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('message_id', 'attachment_id')
)
# ### end Alembic commands ###
def downgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.drop_table('message_attachments')
op.drop_table('sessions')
op.drop_index(op.f('ix_messages_created_at'), table_name='messages')
op.drop_index(op.f('ix_messages_chat_id'), table_name='messages')
op.drop_table('messages')
op.drop_table('idempotency_keys')
op.drop_table('chat_members')
op.drop_table('attachments')
op.drop_index(op.f('ix_users_username'), table_name='users')
op.drop_table('users')
op.drop_table('chats')
# ### end Alembic commands ###
View File
+13
View File
@@ -0,0 +1,13 @@
import os
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker, declarative_base
DATABASE_URL = os.getenv("DATABASE_URL", "postgresql+asyncpg://messenger:secure_db_password_123@postgres:5432/messenger_db")
engine = create_async_engine(DATABASE_URL, echo=False)
AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
Base = declarative_base()
async def get_db():
async with AsyncSessionLocal() as session:
yield session
+54
View File
@@ -0,0 +1,54 @@
import base64
import logging
from fastapi import Depends, HTTPException, status, Header
from fastapi.security import HTTPBasic, HTTPBasicCredentials
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.database import get_db
from app.models import User, UserSession
from app.redis_client import get_redis
logger = logging.getLogger(__name__)
security = HTTPBasic()
async def get_basic_auth(credentials: HTTPBasicCredentials = Depends(security)):
return credentials
async def get_current_user(
db: AsyncSession = Depends(get_db),
redis_client = Depends(get_redis),
authorization: str | None = Header(default=None),
x_user_id: str | None = Header(default=None, alias="X-User-Id")
):
if not authorization:
raise HTTPException(status_code=401, detail={"code": "unauthorized", "message": "Missing authorization header"}, headers={"WWW-Authenticate": "Bearer realm=\"messenger\""})
if not authorization.startswith("Bearer "):
raise HTTPException(status_code=401, detail={"code": "unauthorized", "message": "Invalid authorization scheme"}, headers={"WWW-Authenticate": "Bearer realm=\"messenger\""})
token = authorization[7:]
# Проверяем в Redis сначала
try:
user_id_str = await redis_client.get(f"session:{token}")
if user_id_str:
import uuid
result = await db.execute(select(User).where(User.id == uuid.UUID(user_id_str)))
user = result.scalar_one_or_none()
if user:
return user
except Exception as e:
logger.warning(f"Redis unavailable during auth: {e}")
# Fallback на PostgreSQL
result = await db.execute(select(UserSession).where(UserSession.token == token))
session = result.scalar_one_or_none()
if not session:
raise HTTPException(status_code=401, detail={"code": "unauthorized", "message": "Invalid or expired session"}, headers={"WWW-Authenticate": "Bearer realm=\"messenger\""})
result = await db.execute(select(User).where(User.id == session.user_id))
user = result.scalar_one_or_none()
if not user:
raise HTTPException(status_code=401, detail={"code": "unauthorized", "message": "User not found"})
return user
+70
View File
@@ -0,0 +1,70 @@
import os
import uuid
import logging
import traceback
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from fastapi.exceptions import RequestValidationError
from starlette.exceptions import HTTPException as StarletteHTTPException
from app.routers import auth, chats, attachments
logger = logging.getLogger(__name__)
app = FastAPI()
app.include_router(auth.router)
app.include_router(chats.router)
app.include_router(attachments.router)
INSTANCE_ID = os.getenv("INSTANCE_ID", str(uuid.uuid4())[:8])
@app.middleware("http")
async def add_instance_and_request_id(request: Request, call_next):
request_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
request.state.request_id = request_id
try:
response = await call_next(request)
except Exception as e:
logger.error(f"Unhandled exception: {e}")
traceback.print_exc()
return JSONResponse(
status_code=500,
content={"error": {"code": "internal_error", "message": "Unexpected error", "request_id": request_id}},
headers={"X-Request-Id": request_id, "X-Instance-Id": INSTANCE_ID}
)
response.headers["X-Request-Id"] = request.state.request_id
response.headers["X-Instance-Id"] = INSTANCE_ID
return response
@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
detail = exc.detail
if isinstance(detail, dict):
code = detail.get("code", "internal_error")
message = detail.get("message", str(detail))
else:
code = "internal_error"
message = str(detail)
return JSONResponse(
status_code=exc.status_code,
content={"error": {"code": code, "message": message, "request_id": request.state.request_id}},
headers=exc.headers
)
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
return JSONResponse(
status_code=400,
content={"error": {"code": "invalid_request", "message": "Validation error", "request_id": request.state.request_id}},
headers={"X-Request-Id": request.state.request_id, "X-Instance-Id": INSTANCE_ID}
)
@app.get("/health/live")
async def health_live():
return {"status": "ok"}
@app.get("/health/ready")
async def health_ready():
return {"status": "ok"}
+108
View File
@@ -0,0 +1,108 @@
import uuid
from datetime import datetime, timezone
from sqlalchemy import Column, String, DateTime, ForeignKey, Text, Boolean, BigInteger
from sqlalchemy.orm import relationship
from sqlalchemy.dialects.postgresql import UUID
from app.database import Base
def generate_uuid():
return str(uuid.uuid4())
class User(Base):
__tablename__ = "users"
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
username = Column(String(32), unique=True, nullable=False, index=True)
display_name = Column(String(100), nullable=False)
password_hash = Column(String(255), nullable=False)
created_at = Column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc))
sessions = relationship("UserSession", back_populates="user", cascade="all, delete-orphan")
chat_memberships = relationship("ChatMember", back_populates="user", cascade="all, delete-orphan")
class UserSession(Base):
__tablename__ = "sessions"
token = Column(String(255), primary_key=True)
user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
expires_at = Column(DateTime(timezone=True), nullable=False)
created_at = Column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc))
user = relationship("User", back_populates="sessions")
class Chat(Base):
__tablename__ = "chats"
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
title = Column(String(100), nullable=False)
created_at = Column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc))
members = relationship("ChatMember", back_populates="chat", cascade="all, delete-orphan")
messages = relationship("Message", back_populates="chat", cascade="all, delete-orphan")
class ChatMember(Base):
__tablename__ = "chat_members"
chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True)
user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), primary_key=True)
joined_at = Column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc))
chat = relationship("Chat", back_populates="members")
user = relationship("User", back_populates="chat_memberships")
class Message(Base):
__tablename__ = "messages"
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), nullable=False, index=True)
sender_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
text = Column(Text, nullable=False)
created_at = Column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), index=True)
chat = relationship("Chat", back_populates="messages")
sender = relationship("User")
attachments = relationship("MessageAttachment", back_populates="message", cascade="all, delete-orphan")
class IdempotencyKey(Base):
__tablename__ = "idempotency_keys"
key = Column(String(255), primary_key=True)
chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), nullable=False)
response_data = Column(Text, nullable=False) # JSON
created_at = Column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc))
# === НОВОЕ для Lab 4: Attachment ===
class Attachment(Base):
__tablename__ = "attachments"
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
owner_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), nullable=False)
# S3 метаданные
s3_key = Column(String(512), nullable=False, unique=True) # Уникальный ключ в S3
original_filename = Column(String(255), nullable=False) # Только для отображения
content_type = Column(String(100), nullable=False) # MIME по содержимому
size_bytes = Column(BigInteger, nullable=False)
width = Column(BigInteger, nullable=True) # Для изображений
height = Column(BigInteger, nullable=True) # Для изображений
sha256 = Column(String(64), nullable=False) # Контрольная сумма
# Статус обработки
status = Column(String(20), nullable=False, default="ready") # ready, processing, failed
error_code = Column(String(50), nullable=True)
created_at = Column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc))
owner = relationship("User")
chat = relationship("Chat")
message_links = relationship("MessageAttachment", back_populates="attachment", cascade="all, delete-orphan")
class MessageAttachment(Base):
__tablename__ = "message_attachments"
message_id = Column(UUID(as_uuid=True), ForeignKey("messages.id", ondelete="CASCADE"), primary_key=True)
attachment_id = Column(UUID(as_uuid=True), ForeignKey("attachments.id", ondelete="CASCADE"), primary_key=True)
message = relationship("Message", back_populates="attachments")
attachment = relationship("Attachment", back_populates="message_links")
+9
View File
@@ -0,0 +1,9 @@
import os
import redis.asyncio as redis
REDIS_URL = os.getenv("REDIS_URL", "redis://redis:6379/0")
redis_client = redis.from_url(REDIS_URL, decode_responses=True)
async def get_redis():
return redis_client
+149
View File
@@ -0,0 +1,149 @@
import os
import uuid
import hashlib
import magic
import tempfile
import asyncio
from datetime import datetime, timezone
from fastapi import APIRouter, Depends, HTTPException, status, Query, Request
from fastapi.responses import Response
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.database import get_db
from app.models import Attachment, ChatMember
from app.schemas import Attachment as AttachmentSchema, Variant, ErrorResponse
from app.dependencies import get_current_user
from app.s3_client import get_s3_client, upload_file_to_s3
from minio import Minio
from PIL import Image
import io
router = APIRouter()
@router.post("/api/v1/chats/{chat_id}/attachments", response_model=AttachmentSchema, status_code=status.HTTP_201_CREATED, responses={400: {"model": ErrorResponse}, 401: {"model": ErrorResponse}, 404: {"model": ErrorResponse}, 413: {"model": ErrorResponse}, 415: {"model": ErrorResponse}})
async def upload_attachment(
chat_id: uuid.UUID,
filename: str = Query(..., min_length=1, max_length=255),
request: Request = None,
current_user = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
s3: Minio = Depends(get_s3_client)
):
# 1. Проверка доступа к чату
is_member = await db.execute(
select(ChatMember).where(ChatMember.chat_id == chat_id, ChatMember.user_id == current_user.id)
)
if not is_member.scalar_one_or_none():
raise HTTPException(status_code=404, detail={"code": "not_found", "message": "Chat not found or access denied"})
# 2. Чтение сырых байтов
body = await request.body()
# 3. Проверка размера (макс. 10 MiB)
MAX_SIZE = 10 * 1024 * 1024
if len(body) > MAX_SIZE:
raise HTTPException(status_code=413, detail={"code": "payload_too_large", "message": "File size exceeds 10 MiB limit"})
if len(body) == 0:
raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Empty file"})
# 4. Определение MIME-типа по содержимому
mime = magic.from_buffer(body, mime=True)
if mime not in ("image/png", "image/jpeg"):
raise HTTPException(status_code=415, detail={"code": "unsupported_media_type", "message": "Only image/png and image/jpeg are supported"})
# 5. Проверка размеров изображения (макс. 40 млн пикселей)
try:
img = Image.open(io.BytesIO(body))
width, height = img.size
if width * height > 40_000_000:
raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Image resolution exceeds 40 million pixels"})
except Exception:
raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Invalid or corrupted image file"})
# 6. Вычисление SHA256
sha256_hash = hashlib.sha256(body).hexdigest()
# 7. Генерация уникального ключа для S3
ext = "png" if mime == "image/png" else "jpeg"
s3_key = f"attachments/{uuid.uuid4()}.{ext}"
# 8. Загрузка в S3 через временный файл
with tempfile.NamedTemporaryFile(delete=False, suffix=f".{ext}") as tmp:
tmp.write(body)
tmp_path = tmp.name
try:
await upload_file_to_s3(s3_key, tmp_path, mime)
except Exception as e:
raise HTTPException(status_code=500, detail={"code": "internal_error", "message": "Failed to upload to S3"})
finally:
os.unlink(tmp_path)
# 9. Сохранение метаданных в БД
new_attachment = Attachment(
owner_id=current_user.id,
chat_id=chat_id,
s3_key=s3_key,
original_filename=filename,
content_type=mime,
size_bytes=len(body),
width=width,
height=height,
sha256=sha256_hash,
status="ready",
error_code=None
)
db.add(new_attachment)
await db.commit()
await db.refresh(new_attachment)
now_str = new_attachment.created_at.isoformat().replace('+00:00', 'Z')
return AttachmentSchema(
id=str(new_attachment.id),
chat_id=str(new_attachment.chat_id),
owner_id=str(new_attachment.owner_id),
filename=new_attachment.original_filename,
content_type=new_attachment.content_type,
size_bytes=new_attachment.size_bytes,
sha256=new_attachment.sha256,
status=new_attachment.status,
variants=[],
error_code=new_attachment.error_code,
created_at=now_str,
updated_at=now_str
)
@router.get("/api/v1/attachments/{attachment_id}/content", responses={400: {"model": ErrorResponse}, 401: {"model": ErrorResponse}, 404: {"model": ErrorResponse}})
async def download_attachment(
attachment_id: uuid.UUID,
variant: str = Query(default="original"),
current_user = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
s3: Minio = Depends(get_s3_client)
):
# 1. Проверяем существование вложения
stmt = select(Attachment).where(Attachment.id == attachment_id)
result = await db.execute(stmt)
attachment = result.scalar_one_or_none()
if not attachment:
raise HTTPException(status_code=404, detail={"code": "not_found", "message": "Attachment not found"})
# 2. Проверяем, что пользователь является участником чата
is_member = await db.execute(
select(ChatMember).where(ChatMember.chat_id == attachment.chat_id, ChatMember.user_id == current_user.id)
)
if not is_member.scalar_one_or_none():
raise HTTPException(status_code=404, detail={"code": "not_found", "message": "Access denied"})
# 3. Получаем объект из S3
try:
response = s3.get_object("messenger-attachments", attachment.s3_key)
data = response.read()
response.close()
response.release_conn()
except Exception as e:
raise HTTPException(status_code=500, detail={"code": "internal_error", "message": "Failed to download from S3"})
# 4. Возвращаем байты с правильным Content-Type
return Response(content=data, media_type=attachment.content_type)
+115
View File
@@ -0,0 +1,115 @@
import secrets
import logging
import bcrypt
import asyncpg
from datetime import datetime, timezone, timedelta
from fastapi import APIRouter, Depends, HTTPException, status, Response
from fastapi.security import HTTPBearer
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.exc import SQLAlchemyError
from app.database import get_db
from app.models import User as UserModel, UserSession
from app.schemas import CreateUser, User, Session, ErrorResponse
from app.dependencies import get_basic_auth, get_current_user
from app.redis_client import get_redis
logger = logging.getLogger(__name__)
router = APIRouter()
def verify_password(plain_password: str, hashed_password: str) -> bool:
return bcrypt.checkpw(plain_password.encode('utf-8'), hashed_password.encode('utf-8'))
def get_password_hash(password: str) -> str:
return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
@router.post("/api/v1/users", response_model=User, status_code=status.HTTP_201_CREATED, responses={409: {"model": ErrorResponse}})
async def register_user(user_in: CreateUser, db: AsyncSession = Depends(get_db)):
new_user = UserModel(
username=user_in.username,
display_name=user_in.display_name,
password_hash=get_password_hash(user_in.password)
)
db.add(new_user)
try:
await db.commit()
await db.refresh(new_user)
return User(
id=str(new_user.id),
username=new_user.username,
display_name=new_user.display_name,
created_at=new_user.created_at.isoformat().replace('+00:00', 'Z')
)
except Exception as e:
await db.rollback()
if isinstance(e.__cause__, asyncpg.exceptions.UniqueViolationError) or "unique constraint" in str(e).lower():
raise HTTPException(status_code=409, detail={"code": "conflict", "message": "Username already exists"})
logger.error(f"Database error during registration: {e}")
raise HTTPException(status_code=500, detail={"code": "internal_error", "message": "Database error"})
@router.post("/api/v1/auth/sessions", response_model=Session, status_code=status.HTTP_201_CREATED, responses={401: {"model": ErrorResponse}})
async def create_session(credentials = Depends(get_basic_auth), db: AsyncSession = Depends(get_db), redis_client = Depends(get_redis)):
result = await db.execute(select(UserModel).where(UserModel.username == credentials.username))
user = result.scalar_one_or_none()
if not user or not verify_password(credentials.password, user.password_hash):
raise HTTPException(status_code=401, detail={"code": "unauthorized", "message": "Invalid username or password"}, headers={"WWW-Authenticate": "Basic realm=\"messenger\", charset=\"UTF-8\""})
token = secrets.token_urlsafe(32)
expires_at = datetime.now(timezone.utc) + timedelta(seconds=3600)
try:
await redis_client.setex(f"session:{token}", 3600, str(user.id))
except Exception as e:
logger.warning(f"Redis unavailable during session creation: {e}")
try:
db.add(UserSession(token=token, user_id=user.id, expires_at=expires_at))
await db.commit()
except SQLAlchemyError as e:
await db.rollback()
logger.error(f"Failed to save session to PostgreSQL: {e}")
raise HTTPException(status_code=500, detail={"code": "internal_error", "message": "Failed to create session"})
return Session(
token=token,
token_type="Bearer",
expires_at=expires_at,
user=User(
id=str(user.id),
username=user.username,
display_name=user.display_name,
created_at=user.created_at.isoformat().replace('+00:00', 'Z')
)
)
@router.delete("/api/v1/auth/sessions/current", status_code=status.HTTP_204_NO_CONTENT, responses={401: {"model": ErrorResponse}})
async def revoke_session(credentials = Depends(HTTPBearer()), db: AsyncSession = Depends(get_db), redis_client = Depends(get_redis)):
token = credentials.credentials
try:
await redis_client.delete(f"session:{token}")
except Exception as e:
logger.warning(f"Redis unavailable during session revocation: {e}")
try:
result = await db.execute(select(UserSession).where(UserSession.token == token))
session = result.scalar_one_or_none()
if session:
await db.delete(session)
await db.commit()
else:
raise HTTPException(status_code=401, detail={"code": "unauthorized", "message": "Invalid or expired session"}, headers={"WWW-Authenticate": "Bearer realm=\"messenger\""})
except HTTPException:
raise
except SQLAlchemyError as e:
await db.rollback()
raise HTTPException(status_code=500, detail={"code": "internal_error", "message": "Failed to revoke session"})
return Response(status_code=status.HTTP_204_NO_CONTENT)
@router.get("/api/v1/users/me", response_model=User, responses={401: {"model": ErrorResponse}})
async def current_user(current_user: UserModel = Depends(get_current_user)):
return User(
id=str(current_user.id),
username=current_user.username,
display_name=current_user.display_name,
created_at=current_user.created_at.isoformat().replace('+00:00', 'Z')
)
+213
View File
@@ -0,0 +1,213 @@
import uuid
import json
from datetime import datetime, timezone
from fastapi import APIRouter, Depends, HTTPException, status, Query, Header
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import selectinload
from app.database import get_db
from app.models import Chat as ChatModel, ChatMember as ChatMemberModel, Message as MessageModel, User as UserModel, IdempotencyKey, MessageAttachment, Attachment
from app.schemas import Chat, CreateChat, Message, CreateMessage, ChatPage, MessagePage, ErrorResponse
from app.dependencies import get_current_user
from app.redis_client import get_redis
router = APIRouter()
@router.post("/api/v1/chats", response_model=Chat, status_code=status.HTTP_201_CREATED, responses={400: {"model": ErrorResponse}, 401: {"model": ErrorResponse}})
async def create_chat(chat_in: CreateChat, current_user: UserModel = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
try:
member_uuids = [uuid.UUID(uid) for uid in chat_in.member_ids]
except ValueError:
raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Invalid member_id format"})
if current_user.id not in member_uuids:
raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Creator must be in member_ids"})
user_ids = list(set(member_uuids))
result = await db.execute(select(UserModel).where(UserModel.id.in_(user_ids)))
if len(result.scalars().all()) != len(user_ids):
raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "One or more member_ids do not exist"})
new_chat = ChatModel(title=chat_in.title)
db.add(new_chat)
await db.flush()
db.add_all([ChatMemberModel(chat_id=new_chat.id, user_id=uid) for uid in user_ids])
await db.commit()
await db.refresh(new_chat)
return Chat(
id=str(new_chat.id),
title=new_chat.title,
member_ids=[str(uid) for uid in user_ids],
created_at=new_chat.created_at.isoformat().replace('+00:00', 'Z')
)
@router.get("/api/v1/chats", response_model=ChatPage, responses={401: {"model": ErrorResponse}})
async def list_chats(limit: int = Query(50, ge=1, le=100), cursor: str | None = None, current_user: UserModel = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
stmt = select(ChatModel).options(selectinload(ChatModel.members)).join(ChatMemberModel, ChatModel.id == ChatMemberModel.chat_id).where(ChatMemberModel.user_id == current_user.id).order_by(ChatModel.created_at.desc(), ChatModel.id.desc())
if cursor:
try:
created_at_str, chat_id_str = cursor.split(",")
created_at = datetime.fromisoformat(created_at_str.replace("Z", "+00:00"))
chat_id = uuid.UUID(chat_id_str)
stmt = stmt.where((ChatModel.created_at < created_at) | ((ChatModel.created_at == created_at) & (ChatModel.id < chat_id)))
except (ValueError, TypeError):
raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Invalid cursor"})
stmt = stmt.limit(limit + 1)
chats = (await db.execute(stmt)).scalars().all()
has_next = len(chats) > limit
if has_next:
chats = chats[:-1]
next_cursor = f"{chats[-1].created_at.isoformat().replace('+00:00', 'Z')},{chats[-1].id}"
else:
next_cursor = None
items = [Chat(id=str(c.id), title=c.title, member_ids=[str(m.user_id) for m in c.members], created_at=c.created_at.isoformat().replace('+00:00', 'Z')) for c in chats]
return ChatPage(items=items, next_cursor=next_cursor)
@router.get("/api/v1/chats/{chat_id}", response_model=Chat, responses={401: {"model": ErrorResponse}, 404: {"model": ErrorResponse}})
async def get_chat(chat_id: uuid.UUID, current_user: UserModel = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
stmt = select(ChatModel).options(selectinload(ChatModel.members)).join(ChatMemberModel, ChatModel.id == ChatMemberModel.chat_id).where(ChatModel.id == chat_id, ChatMemberModel.user_id == current_user.id)
chat = (await db.execute(stmt)).scalar_one_or_none()
if not chat:
raise HTTPException(status_code=404, detail={"code": "not_found", "message": "Chat not found or access denied"})
return Chat(id=str(chat.id), title=chat.title, member_ids=[str(m.user_id) for m in chat.members], created_at=chat.created_at.isoformat().replace('+00:00', 'Z'))
@router.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=status.HTTP_201_CREATED, responses={400: {"model": ErrorResponse}, 401: {"model": ErrorResponse}, 404: {"model": ErrorResponse}, 409: {"model": ErrorResponse}})
async def create_message(
chat_id: uuid.UUID,
message_in: CreateMessage,
current_user: UserModel = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
redis_client = Depends(get_redis),
idempotency_key: str | None = Header(default=None, alias="Idempotency-Key")
):
if not idempotency_key:
raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Idempotency-Key header is required"})
if not (await db.execute(select(ChatMemberModel).where(ChatMemberModel.chat_id == chat_id, ChatMemberModel.user_id == current_user.id))).scalar_one_or_none():
raise HTTPException(status_code=404, detail={"code": "not_found", "message": "Chat not found or access denied"})
existing_key = await db.execute(select(IdempotencyKey).where(IdempotencyKey.key == idempotency_key))
existing_record = existing_key.scalar_one_or_none()
if existing_record:
# Исправлено: response_data хранится как JSON-строка, нужно распарсить
resp_data = json.loads(existing_record.response_data)
if resp_data.get("text") != message_in.text:
raise HTTPException(status_code=409, detail={"code": "conflict", "message": "Idempotency-Key already used with different payload"})
return Message(**resp_data)
new_message = MessageModel(chat_id=chat_id, sender_id=current_user.id, text=message_in.text)
db.add(new_message)
await db.flush()
# Привязываем вложения, если есть
attachment_ids = []
if message_in.attachment_ids:
for att_id_str in message_in.attachment_ids:
try:
att_id = uuid.UUID(att_id_str)
except ValueError:
raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Invalid attachment_id format"})
# Проверяем, что вложение принадлежит этому чату
att_result = await db.execute(select(Attachment).where(Attachment.id == att_id, Attachment.chat_id == chat_id))
if not att_result.scalar_one_or_none():
raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Attachment not found or does not belong to this chat"})
db.add(MessageAttachment(message_id=new_message.id, attachment_id=att_id))
attachment_ids.append(att_id_str)
await db.commit()
await db.refresh(new_message)
response_data_dict = {
"id": str(new_message.id),
"chat_id": str(new_message.chat_id),
"sender_id": str(new_message.sender_id),
"text": new_message.text,
"created_at": new_message.created_at.isoformat().replace('+00:00', 'Z'),
"attachment_ids": attachment_ids
}
# Исправлено: сохраняем как JSON-строку
db.add(IdempotencyKey(key=idempotency_key, chat_id=chat_id, response_data=json.dumps(response_data_dict)))
await db.commit()
try:
await redis_client.delete(f"messages:{chat_id}:*")
except Exception:
pass
return Message(**response_data_dict)
@router.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage, responses={400: {"model": ErrorResponse}, 401: {"model": ErrorResponse}, 404: {"model": ErrorResponse}})
async def list_messages(chat_id: uuid.UUID, limit: int = Query(50, ge=1, le=100), cursor: str | None = None, current_user: UserModel = Depends(get_current_user), db: AsyncSession = Depends(get_db), redis_client = Depends(get_redis)):
if not (await db.execute(select(ChatMemberModel).where(ChatMemberModel.chat_id == chat_id, ChatMemberModel.user_id == current_user.id))).scalar_one_or_none():
raise HTTPException(status_code=404, detail={"code": "not_found", "message": "Chat not found or access denied"})
cache_key = f"messages:{chat_id}:{limit}:{cursor or 'null'}"
redis_available = True
try:
cached_data = await redis_client.get(cache_key)
if cached_data:
await redis_client.expire(cache_key, 60)
return MessagePage.model_validate_json(cached_data)
except Exception:
redis_available = False
lock_acquired = False
if redis_available:
lock_key = f"lock:{cache_key}"
try:
lock_acquired = await redis_client.set(lock_key, "1", nx=True, ex=5)
if not lock_acquired:
stale_data = await redis_client.get(f"stale:{cache_key}")
if stale_data: return MessagePage.model_validate_json(stale_data)
except Exception:
redis_available = False
stmt = select(MessageModel).where(MessageModel.chat_id == chat_id).order_by(MessageModel.created_at.asc(), MessageModel.id.asc())
if cursor:
try:
created_at_str, msg_id_str = cursor.split(",")
created_at = datetime.fromisoformat(created_at_str.replace("Z", "+00:00"))
msg_id = uuid.UUID(msg_id_str)
stmt = stmt.where((MessageModel.created_at > created_at) | ((MessageModel.created_at == created_at) & (MessageModel.id > msg_id)))
except (ValueError, TypeError):
raise HTTPException(status_code=400, detail={"code": "invalid_request", "message": "Invalid cursor"})
stmt = stmt.limit(limit + 1)
messages = (await db.execute(stmt)).scalars().all()
has_next = len(messages) > limit
if has_next:
messages = messages[:-1]
next_cursor = f"{messages[-1].created_at.isoformat().replace('+00:00', 'Z')},{messages[-1].id}"
else:
next_cursor = None
items = []
for m in messages:
att_result = await db.execute(select(MessageAttachment.attachment_id).where(MessageAttachment.message_id == m.id))
attachment_ids = [str(aid) for aid in att_result.scalars().all()]
items.append(Message(
id=str(m.id),
chat_id=str(m.chat_id),
sender_id=str(m.sender_id),
text=m.text,
created_at=m.created_at.isoformat().replace('+00:00', 'Z'),
attachment_ids=attachment_ids
))
page = MessagePage(items=items, next_cursor=next_cursor)
if redis_available:
try:
old_cache = await redis_client.get(cache_key)
if old_cache: await redis_client.setex(f"stale:{cache_key}", 120, old_cache)
await redis_client.setex(cache_key, 60, page.model_dump_json())
if lock_acquired: await redis_client.delete(f"lock:{cache_key}")
except Exception:
pass
return page
+33
View File
@@ -0,0 +1,33 @@
import os
import asyncio
from minio import Minio
S3_ENDPOINT = os.getenv("S3_ENDPOINT", "http://s3:8333").replace("http://", "").replace("https://", "")
S3_ACCESS_KEY = os.getenv("S3_ACCESS_KEY", "admin")
S3_SECRET_KEY = os.getenv("S3_SECRET_KEY", "admin")
S3_BUCKET_NAME = os.getenv("S3_BUCKET_NAME", "messenger-attachments")
S3_SECURE = os.getenv("S3_ENDPOINT", "http://s3:8333").startswith("https://")
s3_client = Minio(
S3_ENDPOINT,
access_key=S3_ACCESS_KEY,
secret_key=S3_SECRET_KEY,
secure=S3_SECURE
)
def get_s3_client():
return s3_client
async def upload_file_to_s3(object_name: str, file_path: str, content_type: str):
loop = asyncio.get_running_loop()
await loop.run_in_executor(
None,
lambda: s3_client.fput_object(S3_BUCKET_NAME, object_name, file_path, content_type=content_type)
)
async def get_file_from_s3(object_name: str):
loop = asyncio.get_running_loop()
return await loop.run_in_executor(
None,
lambda: s3_client.get_object(S3_BUCKET_NAME, object_name)
)
+88
View File
@@ -0,0 +1,88 @@
from pydantic import BaseModel, Field, ConfigDict, model_validator
from typing import List, Optional
from datetime import datetime
class User(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: str
username: str
display_name: str
created_at: str
class CreateUser(BaseModel):
username: str = Field(..., min_length=3, max_length=32, pattern="^[a-z0-9_]+$")
display_name: str = Field(..., min_length=1, max_length=100)
password: str = Field(..., min_length=12, max_length=128)
class Session(BaseModel):
model_config = ConfigDict(from_attributes=True)
token: str
token_type: str
expires_at: datetime
user: User
class Chat(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: str
title: str
member_ids: List[str]
created_at: str
class CreateChat(BaseModel):
title: str = Field(..., min_length=1, max_length=100)
member_ids: List[str]
class ChatPage(BaseModel):
items: List[Chat]
next_cursor: Optional[str] = None
class Message(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: str
chat_id: str
sender_id: str
text: str
created_at: str
attachment_ids: List[str]
class CreateMessage(BaseModel):
text: str = Field(default="", max_length=4000)
attachment_ids: List[str] = Field(default_factory=list)
@model_validator(mode='after')
def check_text_or_attachments(self):
if len(self.text) == 0 and len(self.attachment_ids) == 0:
raise ValueError("Either text or attachment_ids must be provided")
if len(self.attachment_ids) > 10:
raise ValueError("attachment_ids cannot exceed 10 items")
return self
class MessagePage(BaseModel):
items: List[Message]
next_cursor: Optional[str] = None
class Variant(BaseModel):
name: str
content_type: str
size_bytes: int
width: int
height: int
sha256: str
class Attachment(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: str
chat_id: str
owner_id: str
filename: str
content_type: str
size_bytes: int
sha256: str
status: str
variants: List[Variant]
error_code: Optional[str] = None
created_at: str
updated_at: str
class ErrorResponse(BaseModel):
error: dict
+124
View File
@@ -0,0 +1,124 @@
services:
postgres:
image: postgres:16.4-alpine
environment:
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
POSTGRES_DB: ${POSTGRES_DB}
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
interval: 5s
timeout: 5s
retries: 5
redis:
image: valkey/valkey:8.0-alpine
command: valkey-server --appendonly yes --save 60 1
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "valkey-cli", "ping"]
interval: 5s
timeout: 5s
retries: 5
s3:
image: chrislusf/seaweedfs:3.80
command:
- server
- -dir=/data
- -s3
- -s3.port=8333
- -master.volumeSizeLimitMB=64
- -volume.max=100
volumes:
- s3data:/data
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8333/healthz"]
interval: 10s
timeout: 5s
retries: 15
start_period: 120s
deploy:
resources:
limits:
cpus: '1.0'
memory: 1G
restart: unless-stopped
s3-init:
image: amazon/aws-cli:2.15.0
depends_on:
s3:
condition: service_healthy
environment:
- AWS_ACCESS_KEY_ID=${S3_INIT_ACCESS_KEY}
- AWS_SECRET_ACCESS_KEY=${S3_INIT_SECRET_KEY}
- AWS_REGION=${S3_REGION}
entrypoint: >
/bin/sh -c "
aws --endpoint-url http://s3:8333 s3 mb s3://${S3_BUCKET_NAME} 2>/dev/null || echo 'Bucket already exists, skipping creation'
aws --endpoint-url http://s3:8333 s3api put-bucket-acl --bucket ${S3_BUCKET_NAME} --acl private
echo 'Bucket ${S3_BUCKET_NAME} is ready and private'
"
restart: "no"
api:
build:
context: .
dockerfile: Dockerfile
environment:
- DATABASE_URL=${DATABASE_URL}
- REDIS_URL=${REDIS_URL}
- SECRET_SESSION_KEY=${SECRET_SESSION_KEY}
- SESSION_TTL_SECONDS=${SESSION_TTL_SECONDS}
- S3_ENDPOINT=${S3_ENDPOINT}
- S3_ACCESS_KEY=${S3_API_ACCESS_KEY}
- S3_SECRET_KEY=${S3_API_SECRET_KEY}
- S3_BUCKET_NAME=${S3_BUCKET_NAME}
- S3_REGION=${S3_REGION}
expose:
- "8080"
volumes:
- ./alembic/versions:/app/alembic/versions
- ./app:/app/app
read_only: true
tmpfs:
- /tmp:size=15M
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
s3-init:
condition: service_completed_successfully
stop_grace_period: 30s
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8080/health/live"]
interval: 10s
timeout: 5s
retries: 3
start_period: 10s
deploy:
resources:
limits:
cpus: '0.5'
memory: 256M
nginx:
image: nginx:1.25-alpine
ports:
- "8080:8080"
volumes:
- ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
depends_on:
api:
condition: service_healthy
restart: unless-stopped
volumes:
postgres_data:
redis_data:
s3data:
+22
View File
@@ -0,0 +1,22 @@
upstream api_backend {
# Nginx будет автоматически резолвить имена через Docker DNS
server api:8080 max_fails=1 fail_timeout=5s;
}
server {
listen 8080;
# Проксирование ВСЕХ запросов на API реплики
location / {
proxy_pass http://api_backend;
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-Request-Id $http_x_request_id;
# Таймауты для graceful shutdown
proxy_connect_timeout 5s;
proxy_read_timeout 30s;
proxy_send_timeout 30s;
}
}
+13
View File
@@ -0,0 +1,13 @@
fastapi==0.115.0
uvicorn[standard]==0.30.6
sqlalchemy[asyncio]==2.0.35
asyncpg==0.29.0
pydantic-settings==2.5.2
redis==5.1.0
bcrypt==4.2.0
alembic==1.13.2
python-multipart==0.0.9
# === Новое для Lab 4 ===
minio==7.2.0
Pillow==10.4.0
python-magic==0.4.27