forked from mtusi2026/mtusi2026lab2
Compare commits
3
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
e5af5283f3 | ||
|
|
d96d8ecfc7 | ||
|
|
e0195cab89 |
+20
@@ -0,0 +1,20 @@
|
||||
FROM python:3.11-slim
|
||||
|
||||
# Устанавливаем curl для healthcheck
|
||||
RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
# Копируем зависимости
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
# Копируем исходный код
|
||||
COPY src/ ./src/
|
||||
|
||||
ENV HOST=0.0.0.0
|
||||
ENV PORT=8080
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"]
|
||||
@@ -1,37 +1,127 @@
|
||||
# Отчёт — лабораторная 2
|
||||
**Автор, группа:** Кашкарова Арина, БПИ2302
|
||||
**Целевая оценка:** 3
|
||||
**Commit/PR:** TODO
|
||||
**Использованные источники, библиотеки и помощь ИИ:** Python 3.11, FastAPI, Uvicorn, Pydantic, PostgreSQL 16.1, psycopg2-binary, bcrypt, Docker, Docker Compose. ИИ использовался для генерации начального скелета кода, отладки форматирования ответов под OpenAPI контракт и настройки Docker Compose.
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
|
||||
## Запуск из чистого clone
|
||||
**Prerequisites:** Python 3.9+, Docker, Docker Compose, Git.
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
1. **Клонирование и подготовка окружения:**
|
||||
```bash
|
||||
git clone https://gitea.privcloud.tech/ari_kash/mtusi2026lab2.git
|
||||
cd mtusi2026lab2
|
||||
python3 -m venv .venv
|
||||
source .venv/Scripts/activate
|
||||
pip install -r requirements.txt
|
||||
pip install -r requirements-dev.txt
|
||||
|
||||
2. Создание .env:
|
||||
```bash
|
||||
cp .env.example .env
|
||||
```
|
||||
|
||||
3. Сборка и запуск стенда (API + PostgreSQL):
|
||||
```bash
|
||||
docker compose up -d --build
|
||||
```
|
||||
|
||||
4. Ожидание готовности и проверка:
|
||||
```bash
|
||||
curl http://localhost:8080/health/ready
|
||||
```
|
||||
|
||||
5. Запуск тестов:
|
||||
```bash
|
||||
# Smoke test (базовый сценарий API)
|
||||
python tests/smoke.py --base-url "http://localhost:8080"
|
||||
# Test persistence (проверка сохранности данных после рестарта)
|
||||
python tests/resilience.py --mode persistence --action-script "scripts/restart.bat" --base-url "http://localhost:8080"
|
||||
```
|
||||
|
||||
6. Безопасная остановка и удаление учебных данных:
|
||||
```bash
|
||||
# Остановка контейнеров (данные сохраняются в volume)
|
||||
docker compose down
|
||||
|
||||
# Полное удаление включая volumes (сброс всех данных)
|
||||
docker compose down -v
|
||||
```
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Схема процессов и хранилищ
|
||||
Клиент → HTTP API (FastAPI) → PostgreSQL
|
||||
↓
|
||||
Сессии в PostgreSQL
|
||||
|
||||
Компоненты:
|
||||
- API процесс: Uvicorn + FastAPI, запущен как PID 1 в Docker-контейнере
|
||||
- PostgreSQL 16.1: Источник истины для всех данных (пользователи, чаты, сообщения, сессии)
|
||||
- Named volume: postgres_data:/var/lib/postgresql/data обеспечивает сохранность данных
|
||||
|
||||
Таблицы базы данных
|
||||
Схема включает 5 таблиц с ограничениями:
|
||||
1. users — пользователи (PK: id, UNIQUE: username)
|
||||
2. chats — чаты (PK: id)
|
||||
3. chat_members — участники чатов (PK: (chat_id, user_id), FK на users и chats)
|
||||
4. messages — сообщения (PK: id, FK на chats и users, индекс на (chat_id, created_at, id))
|
||||
5. sessions — сессии (PK: token, FK на users, TTL через expires_at)
|
||||
Миграции: Файл src/migrations/001_initial.sql запускается idempotently при старте приложения (CREATE TABLE IF NOT EXISTS).
|
||||
|
||||
Аутентификация и безопасность
|
||||
- Регистрация (POST /api/v1/users): Пароль хешируется через SHA-256 pre-hash + bcrypt (обход лимита 72 байт bcrypt)
|
||||
- Вход (POST /api/v1/auth/sessions): Basic authentication (username:password в base64)
|
||||
- Сессии: Opaque Bearer-токен с 256 битами энтропии (secrets.token_hex(32)), TTL = 3600 секунд
|
||||
- Защищённые endpoint: Требуют Authorization: Bearer <token>
|
||||
- Logout (DELETE /api/v1/auth/sessions/current): Удаляет сессию из БД
|
||||
|
||||
Транзакционные границы
|
||||
- Создание чата: Атомарная операция — вставка в chats и chat_members в одной транзакции
|
||||
- Все write-операции: Используют контекстный менеджер get_db() с commit/rollback
|
||||
- Параметризованные запросы: Все SQL-запросы используют %s placeholder для защиты от SQL-инъекций
|
||||
|
||||
Из lab1 были перенесены src/models.py src/__init__.py src/models.py Dockerfile и requierements.txt -- все эти файлы так же были изменены под задачу lab2
|
||||
|
||||
Соответствие .env.example
|
||||
- DATABASE_URL=postgresql://messenger:messenger_pass@postgres:5432/messenger — используется в docker-compose.yaml
|
||||
SESSION_TTL_SECONDS=3600 — читается в auth.py
|
||||
- Секреты (пароль БД) не зашиты в образ, передаются через переменные окружения
|
||||
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Публичный smoke | python tests/smoke.py --base-url "http://localhost:8080" | PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. | screenshots/lab2_smoke_pass.png |
|
||||
| Persistence test | python tests/resilience.py --mode persistence --action-script "scripts/restart.bat" --base-url "http://localhost:8080" | Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
(.venv) | screenshots/lab2_persistence_pass.png |
|
||||
| PostgreSQL с таблицами | docker compose exec postgres psql -U messenger -d messenger -c "\dt" | Показывает 5 таблиц: users, chats, chat_members, messages, sessions | screenshots/lab2_tables.png |
|
||||
| Миграции idempotently | Перезапуск API с теми же миграциями | Ошибок нет, данные не дублируются | — |
|
||||
| Атомарное создание чата | Создание чата с 3 участниками | Чат и все 3 записи в chat_members создаются атомарно | — |
|
||||
| Basic → Bearer | POST /api/v1/auth/sessions с Basic, затем GET /api/v1/users/me с Bearer | 201 Created с токеном, затем 200 OK с данными пользователя | — |
|
||||
| WWW-Authenticate заголовки | Запрос без Authorization к /api/v1/users/me | 401 Unauthorized с заголовком WWW-Authenticate: Bearer realm="messenger" | — |
|
||||
| Хеширование паролей |
|
||||
Проверка кода в auth.py | Используется bcrypt.hashpw() с SHA-256 pre-hash | src/auth.py |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| Перезапуск API и PostgreSQL (docker compose restart api postgres) | Все данные (пользователи, чаты, сообщения, сессии) сохраняются благодаря именованному volume postgres_data | После рестарта тот же Bearer-токен позволяет читать данные, созданные до рестарта | ~5-7 секунд на старт PostgreSQL + API. Данные не теряются |
|
||||
| Истечение сессии (TTL) |
|
||||
Установка SESSION_TTL_SECONDS=2, ожидание 3 секунды | Сессия становится недействительной, запросы возвращают 401 Unauthorized | Мгновенно после expiry |
|
||||
| Logout | DELETE /api/v1/auth/sessions/current, затем повтор запроса с тем же токеном | 204 No Content, затем 401 Unauthorized | Мгновенно. Сессия удаляется из БД |
|
||||
| Неверный пароль | POST /api/v1/auth/sessions с неправильным паролем | 401 Unauthorized с WWW-Authenticate: Basic realm="messenger" | Мгновенно |
|
||||
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Что реализовано и работает:
|
||||
✅ Все endpoint'ы lab1 перенесены с новой аутентификацией
|
||||
✅ PostgreSQL с миграциями, индексами и внешними ключами
|
||||
✅ Сессии сохраняются в PostgreSQL и переживают рестарт
|
||||
✅ Smoke test и persistence test проходят
|
||||
✅ WWW-Authenticate заголовки соответствуют контракту
|
||||
✅ Пароли хешируются bcrypt
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
services:
|
||||
api:
|
||||
build: .
|
||||
ports:
|
||||
- "8080:8080"
|
||||
environment:
|
||||
- DATABASE_URL=postgresql://messenger:messenger_pass@postgres:5432/messenger
|
||||
- SESSION_TTL_SECONDS=3600
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
test: ["CMD", "curl", "-f", "http://localhost:8080/health/ready"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
restart: unless-stopped
|
||||
|
||||
postgres:
|
||||
image: postgres:16.1
|
||||
environment:
|
||||
- POSTGRES_DB=messenger
|
||||
- POSTGRES_USER=messenger
|
||||
- POSTGRES_PASSWORD=messenger_pass
|
||||
volumes:
|
||||
- postgres_data:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U messenger"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
restart: unless-stopped
|
||||
|
||||
volumes:
|
||||
postgres_data:
|
||||
@@ -0,0 +1,6 @@
|
||||
fastapi==0.104.1
|
||||
uvicorn==0.24.0
|
||||
psycopg2-binary==2.9.9
|
||||
bcrypt==4.1.2
|
||||
python-multipart==0.0.6
|
||||
pydantic==2.5.0
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 17 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 13 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 21 KiB |
@@ -0,0 +1,15 @@
|
||||
@echo off
|
||||
cd /d %~dp0\..
|
||||
docker compose restart api postgres
|
||||
|
||||
set /a count=0
|
||||
:check_loop
|
||||
timeout /t 2 /nobreak >nul
|
||||
curl -s -f http://localhost:8080/health/ready >nul 2>&1
|
||||
if %errorlevel% equ 0 exit /b 0
|
||||
|
||||
set /a count+=1
|
||||
if %count% lss 15 goto check_loop
|
||||
|
||||
echo API failed to become ready
|
||||
exit /b 1
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
import os
|
||||
import hashlib
|
||||
import bcrypt
|
||||
import secrets
|
||||
from datetime import datetime, timezone, timedelta
|
||||
from typing import Optional, Dict, Any
|
||||
|
||||
|
||||
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
|
||||
|
||||
|
||||
def hash_password(password: str) -> str:
|
||||
"""Хешировать пароль: SHA-256 пре-хеширование + bcrypt (обход лимита 72 байт)"""
|
||||
pre_hash = hashlib.sha256(password.encode('utf-8')).digest()
|
||||
return bcrypt.hashpw(pre_hash, bcrypt.gensalt()).decode('utf-8')
|
||||
|
||||
|
||||
def verify_password(password: str, password_hash: str) -> bool:
|
||||
"""Проверить пароль"""
|
||||
pre_hash = hashlib.sha256(password.encode('utf-8')).digest()
|
||||
return bcrypt.checkpw(pre_hash, password_hash.encode('utf-8'))
|
||||
|
||||
|
||||
def generate_token() -> str:
|
||||
"""Сгенерировать случайный токен сессии (256 бит энтропии)"""
|
||||
return secrets.token_hex(32) # 64 символа = 256 бит
|
||||
|
||||
|
||||
def create_session(db_conn, user_id: str) -> Dict[str, Any]:
|
||||
"""Создать новую сессию в БД"""
|
||||
token = generate_token()
|
||||
expires_at = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL_SECONDS)
|
||||
|
||||
with db_conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"INSERT INTO sessions (token, user_id, expires_at) VALUES (%s, %s, %s)",
|
||||
(token, user_id, expires_at)
|
||||
)
|
||||
db_conn.commit()
|
||||
|
||||
return {
|
||||
"token": token,
|
||||
"expires_at": expires_at.strftime('%Y-%m-%dT%H:%M:%SZ')
|
||||
}
|
||||
|
||||
|
||||
def get_session(db_conn, token: str) -> Optional[Dict[str, Any]]:
|
||||
"""Получить действительную сессию по токену"""
|
||||
with db_conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT token, user_id, expires_at FROM sessions WHERE token = %s AND expires_at > NOW()",
|
||||
(token,)
|
||||
)
|
||||
return cur.fetchone()
|
||||
|
||||
|
||||
def delete_session(db_conn, token: str):
|
||||
"""Удалить сессию (logout)"""
|
||||
with db_conn.cursor() as cur:
|
||||
cur.execute("DELETE FROM sessions WHERE token = %s", (token,))
|
||||
db_conn.commit()
|
||||
+295
@@ -0,0 +1,295 @@
|
||||
import os
|
||||
import psycopg2
|
||||
from psycopg2.extras import RealDictCursor
|
||||
from typing import Optional, List, Dict, Any, Tuple
|
||||
from contextlib import contextmanager
|
||||
from uuid import uuid4
|
||||
from datetime import datetime, timezone
|
||||
|
||||
|
||||
DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://messenger:messenger_pass@localhost:5432/messenger")
|
||||
|
||||
|
||||
def get_db_connection():
|
||||
"""Создать подключение к PostgreSQL"""
|
||||
return psycopg2.connect(DATABASE_URL, cursor_factory=RealDictCursor)
|
||||
|
||||
|
||||
@contextmanager
|
||||
def get_db():
|
||||
"""Контекстный менеджер для работы с БД"""
|
||||
conn = get_db_connection()
|
||||
try:
|
||||
yield conn
|
||||
conn.commit()
|
||||
except Exception:
|
||||
conn.rollback()
|
||||
raise
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
|
||||
def init_db():
|
||||
"""Инициализировать БД (запустить миграции idempotently)"""
|
||||
migration_path = os.path.join(os.path.dirname(__file__), "migrations", "001_initial.sql")
|
||||
with open(migration_path, "r") as f:
|
||||
migration_sql = f.read()
|
||||
|
||||
with get_db() as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute(migration_sql)
|
||||
|
||||
|
||||
class PostgresStore:
|
||||
"""Store layer для PostgreSQL — заменяет InMemoryStore из Lab 1"""
|
||||
|
||||
def create_user(self, username: str, display_name: str, password_hash: str) -> dict:
|
||||
with get_db() as conn:
|
||||
with conn.cursor() as cur:
|
||||
# Проверяем уникальность username
|
||||
cur.execute("SELECT id FROM users WHERE username = %s", (username,))
|
||||
if cur.fetchone():
|
||||
raise ValueError("username_already_exists")
|
||||
|
||||
user_id = str(uuid4())
|
||||
now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
|
||||
|
||||
cur.execute(
|
||||
"INSERT INTO users (id, username, display_name, password_hash, created_at) "
|
||||
"VALUES (%s, %s, %s, %s, %s)",
|
||||
(user_id, username, display_name, password_hash, now)
|
||||
)
|
||||
|
||||
return {
|
||||
"id": user_id,
|
||||
"username": username,
|
||||
"display_name": display_name,
|
||||
"created_at": now
|
||||
}
|
||||
|
||||
def get_user(self, user_id: str) -> Optional[dict]:
|
||||
with get_db() as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
|
||||
(user_id,)
|
||||
)
|
||||
row = cur.fetchone()
|
||||
if row:
|
||||
# Преобразуем datetime в строку ISO8601
|
||||
row["created_at"] = row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ')
|
||||
return row
|
||||
|
||||
def get_user_by_username(self, username: str) -> Optional[dict]:
|
||||
with get_db() as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = %s",
|
||||
(username,)
|
||||
)
|
||||
row = cur.fetchone()
|
||||
if row:
|
||||
# Преобразуем datetime в строку ISO8601
|
||||
row["created_at"] = row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ')
|
||||
return row
|
||||
|
||||
def create_chat(self, title: str, member_ids: List[str], creator_id: str) -> dict:
|
||||
with get_db() as conn:
|
||||
with conn.cursor() as cur:
|
||||
# Проверяем, что все участники существуют
|
||||
for member_id in member_ids:
|
||||
cur.execute("SELECT id FROM users WHERE id = %s", (member_id,))
|
||||
if not cur.fetchone():
|
||||
raise ValueError("user_not_found")
|
||||
|
||||
# Проверяем, что создатель входит в список участников
|
||||
if creator_id not in member_ids:
|
||||
raise ValueError("creator_not_in_members")
|
||||
|
||||
# Проверяем уникальность member_ids
|
||||
if len(member_ids) != len(set(member_ids)):
|
||||
raise ValueError("duplicate_members")
|
||||
|
||||
chat_id = str(uuid4())
|
||||
now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
|
||||
|
||||
# Атомарно: создаём чат и всех участников в одной транзакции
|
||||
cur.execute(
|
||||
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)",
|
||||
(chat_id, title, now)
|
||||
)
|
||||
|
||||
for member_id in member_ids:
|
||||
cur.execute(
|
||||
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
|
||||
(chat_id, member_id)
|
||||
)
|
||||
|
||||
return {
|
||||
"id": chat_id,
|
||||
"title": title,
|
||||
"member_ids": member_ids,
|
||||
"created_at": now
|
||||
}
|
||||
|
||||
def get_chat(self, chat_id: str, user_id: str) -> Optional[dict]:
|
||||
with get_db() as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT c.id, c.title, c.created_at "
|
||||
"FROM chats c "
|
||||
"JOIN chat_members cm ON c.id = cm.chat_id "
|
||||
"WHERE c.id = %s AND cm.user_id = %s",
|
||||
(chat_id, user_id)
|
||||
)
|
||||
chat = cur.fetchone()
|
||||
if not chat:
|
||||
return None
|
||||
|
||||
# Получаем список участников
|
||||
cur.execute(
|
||||
"SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id",
|
||||
(chat_id,)
|
||||
)
|
||||
members = [row["user_id"] for row in cur.fetchall()]
|
||||
|
||||
return {
|
||||
"id": chat["id"],
|
||||
"title": chat["title"],
|
||||
"member_ids": members,
|
||||
"created_at": chat["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ')
|
||||
}
|
||||
|
||||
def list_chats(self, user_id: str, limit: int = 50, cursor: Optional[str] = None) -> Tuple[List[dict], Optional[str]]:
|
||||
with get_db() as conn:
|
||||
with conn.cursor() as cur:
|
||||
query = """
|
||||
SELECT c.id, c.title, c.created_at
|
||||
FROM chats c
|
||||
JOIN chat_members cm ON c.id = cm.chat_id
|
||||
WHERE cm.user_id = %s
|
||||
"""
|
||||
params = [user_id]
|
||||
|
||||
if cursor:
|
||||
cursor_parts = cursor.split(",", 1)
|
||||
if len(cursor_parts) == 2:
|
||||
cursor_time, cursor_id = cursor_parts
|
||||
query += " AND (c.created_at, c.id) > (%s::timestamptz, %s::uuid)"
|
||||
params.extend([cursor_time, cursor_id])
|
||||
|
||||
query += " ORDER BY c.created_at, c.id LIMIT %s"
|
||||
params.append(limit + 1) # Берём на 1 больше для определения has_more
|
||||
|
||||
cur.execute(query, params)
|
||||
rows = cur.fetchall()
|
||||
|
||||
has_more = len(rows) > limit
|
||||
page_rows = rows[:limit]
|
||||
|
||||
chats = []
|
||||
for row in page_rows:
|
||||
cur.execute(
|
||||
"SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id",
|
||||
(row["id"],)
|
||||
)
|
||||
members = [m["user_id"] for m in cur.fetchall()]
|
||||
chats.append({
|
||||
"id": row["id"],
|
||||
"title": row["title"],
|
||||
"member_ids": members,
|
||||
"created_at": row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ')
|
||||
})
|
||||
|
||||
next_cursor = None
|
||||
if has_more and chats:
|
||||
last = page_rows[-1]
|
||||
next_cursor = f"{last['created_at'].strftime('%Y-%m-%dT%H:%M:%SZ')},{last['id']}"
|
||||
|
||||
return chats, next_cursor
|
||||
|
||||
def create_message(self, chat_id: str, sender_id: str, text: str) -> dict:
|
||||
with get_db() as conn:
|
||||
with conn.cursor() as cur:
|
||||
# Проверяем, что чат существует и отправитель является участником
|
||||
cur.execute(
|
||||
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
||||
(chat_id, sender_id)
|
||||
)
|
||||
if not cur.fetchone():
|
||||
cur.execute("SELECT id FROM chats WHERE id = %s", (chat_id,))
|
||||
if cur.fetchone():
|
||||
raise ValueError("sender_not_in_chat")
|
||||
raise ValueError("chat_not_found")
|
||||
|
||||
message_id = str(uuid4())
|
||||
now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
|
||||
|
||||
cur.execute(
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text, created_at) "
|
||||
"VALUES (%s, %s, %s, %s, %s)",
|
||||
(message_id, chat_id, sender_id, text, now)
|
||||
)
|
||||
|
||||
return {
|
||||
"id": message_id,
|
||||
"chat_id": chat_id,
|
||||
"sender_id": sender_id,
|
||||
"text": text,
|
||||
"created_at": now
|
||||
}
|
||||
|
||||
def list_messages(self, chat_id: str, user_id: str, limit: int = 50, cursor: Optional[str] = None) -> Tuple[List[dict], Optional[str]]:
|
||||
with get_db() as conn:
|
||||
with conn.cursor() as cur:
|
||||
# Проверяем, что пользователь является участником чата
|
||||
cur.execute(
|
||||
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
||||
(chat_id, user_id)
|
||||
)
|
||||
if not cur.fetchone():
|
||||
cur.execute("SELECT id FROM chats WHERE id = %s", (chat_id,))
|
||||
if cur.fetchone():
|
||||
raise ValueError("user_not_in_chat")
|
||||
raise ValueError("chat_not_found")
|
||||
|
||||
query = """
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = %s
|
||||
"""
|
||||
params = [chat_id]
|
||||
|
||||
if cursor:
|
||||
cursor_parts = cursor.split(",", 1)
|
||||
if len(cursor_parts) == 2:
|
||||
cursor_time, cursor_id = cursor_parts
|
||||
query += " AND (created_at, id) > (%s::timestamptz, %s::uuid)"
|
||||
params.extend([cursor_time, cursor_id])
|
||||
|
||||
query += " ORDER BY created_at, id LIMIT %s"
|
||||
params.append(limit + 1)
|
||||
|
||||
cur.execute(query, params)
|
||||
rows = cur.fetchall()
|
||||
|
||||
has_more = len(rows) > limit
|
||||
page_rows = rows[:limit]
|
||||
|
||||
messages = [{
|
||||
"id": row["id"],
|
||||
"chat_id": row["chat_id"],
|
||||
"sender_id": row["sender_id"],
|
||||
"text": row["text"],
|
||||
"created_at": row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ')
|
||||
} for row in page_rows]
|
||||
|
||||
next_cursor = None
|
||||
if has_more and messages:
|
||||
last = page_rows[-1]
|
||||
next_cursor = f"{last['created_at'].strftime('%Y-%m-%dT%H:%M:%SZ')},{last['id']}"
|
||||
|
||||
return messages, next_cursor
|
||||
|
||||
|
||||
store = PostgresStore()
|
||||
+305
@@ -0,0 +1,305 @@
|
||||
import base64
|
||||
from fastapi import FastAPI, Request, HTTPException, Query
|
||||
from fastapi.responses import JSONResponse, Response
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from typing import Optional
|
||||
from uuid import uuid4
|
||||
from .models import (
|
||||
CreateUserRequest, CreateChatRequest, CreateMessageRequest,
|
||||
UserResponse, ChatResponse, MessageResponse, ChatPage, MessagePage,
|
||||
SessionResponse, HealthResponse
|
||||
)
|
||||
from .database import store, init_db, get_db_connection
|
||||
from .auth import hash_password, verify_password, create_session, get_session, delete_session
|
||||
|
||||
app = FastAPI()
|
||||
|
||||
# Инициализация БД при старте
|
||||
@app.on_event("startup")
|
||||
async def startup_event():
|
||||
init_db()
|
||||
|
||||
|
||||
# Middleware для генерации X-Request-Id
|
||||
@app.middleware("http")
|
||||
async def add_request_id(request: Request, call_next):
|
||||
request_id = str(uuid4())
|
||||
request.state.request_id = request_id
|
||||
response = await call_next(request)
|
||||
response.headers["X-Request-Id"] = request_id
|
||||
return response
|
||||
|
||||
|
||||
# Обработчик ошибок валидации Pydantic (422 → 400)
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_exception_handler(request: Request, exc: RequestValidationError):
|
||||
request_id = getattr(request.state, "request_id", str(uuid4()))
|
||||
content = {
|
||||
"error": {
|
||||
"code": "invalid_request",
|
||||
"message": "Неверный формат запроса, неверные типы данных или лишние поля",
|
||||
"request_id": request_id
|
||||
}
|
||||
}
|
||||
return JSONResponse(status_code=400, content=content)
|
||||
|
||||
|
||||
# Глобальный обработчик HTTP ошибок
|
||||
@app.exception_handler(HTTPException)
|
||||
async def http_exception_handler(request: Request, exc: HTTPException):
|
||||
request_id = getattr(request.state, "request_id", str(uuid4()))
|
||||
|
||||
# Копируем headers из HTTPException, если они есть
|
||||
headers = dict(exc.headers) if exc.headers else {}
|
||||
|
||||
# Если нет WWW-Authenticate, добавляем по умолчанию для 401
|
||||
if exc.status_code == 401 and "WWW-Authenticate" not in headers:
|
||||
if "/auth/sessions" in str(request.url.path):
|
||||
headers["WWW-Authenticate"] = 'Basic realm="messenger", charset="UTF-8"'
|
||||
else:
|
||||
headers["WWW-Authenticate"] = 'Bearer realm="messenger"'
|
||||
|
||||
if isinstance(exc.detail, dict) and "error" in exc.detail:
|
||||
content = exc.detail
|
||||
content["error"]["request_id"] = request_id
|
||||
else:
|
||||
code_map = {
|
||||
400: "invalid_request", 401: "unauthorized", 404: "not_found",
|
||||
409: "conflict", 413: "payload_too_large", 415: "unsupported_media_type",
|
||||
429: "rate_limited", 500: "internal_error", 503: "unavailable"
|
||||
}
|
||||
code = code_map.get(exc.status_code, "invalid_request")
|
||||
content = {
|
||||
"error": {
|
||||
"code": code,
|
||||
"message": str(exc.detail),
|
||||
"request_id": request_id
|
||||
}
|
||||
}
|
||||
|
||||
return JSONResponse(status_code=exc.status_code, content=content, headers=headers)
|
||||
|
||||
|
||||
# Вспомогательная функция для получения текущего пользователя из Bearer токена
|
||||
async def get_current_user_from_request(request: Request) -> dict:
|
||||
auth_header = request.headers.get("Authorization")
|
||||
if not auth_header or not auth_header.startswith("Bearer "):
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Missing or invalid Authorization header",
|
||||
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
)
|
||||
|
||||
token = auth_header[7:] # Убираем "Bearer "
|
||||
|
||||
conn = get_db_connection()
|
||||
try:
|
||||
session = get_session(conn, token)
|
||||
if not session:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Invalid or expired session",
|
||||
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
)
|
||||
|
||||
user = store.get_user(session["user_id"])
|
||||
if not user:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="User not found",
|
||||
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
)
|
||||
|
||||
return user
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
# --- Health endpoints ---
|
||||
@app.get("/health/live", response_model=HealthResponse)
|
||||
async def health_live():
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.get("/health/ready", response_model=HealthResponse)
|
||||
async def health_ready():
|
||||
try:
|
||||
conn = get_db_connection()
|
||||
conn.close()
|
||||
return {"status": "ok"}
|
||||
except Exception:
|
||||
raise HTTPException(status_code=503, detail="Database unavailable")
|
||||
|
||||
|
||||
# --- Auth endpoints ---
|
||||
@app.post("/api/v1/auth/sessions", response_model=SessionResponse, status_code=201)
|
||||
async def create_session_endpoint(request: Request):
|
||||
# Проверяем Basic auth
|
||||
auth_header = request.headers.get("Authorization")
|
||||
if not auth_header or not auth_header.startswith("Basic "):
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Missing Basic authentication",
|
||||
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
|
||||
)
|
||||
|
||||
try:
|
||||
# Декодируем base64(username:password)
|
||||
decoded = base64.b64decode(auth_header[6:]).decode('utf-8')
|
||||
# Пароль может содержать двоеточие, поэтому split только по первому
|
||||
username, password = decoded.split(":", 1)
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail="Invalid Basic authentication format")
|
||||
|
||||
# Валидация username (ASCII [a-z0-9_]{3,32})
|
||||
import re
|
||||
if not re.match(r'^[a-z0-9_]{3,32}$', username):
|
||||
raise HTTPException(status_code=400, detail="Invalid username format")
|
||||
|
||||
# Валидация пароля (12-128 code points)
|
||||
if len(password) < 12 or len(password) > 128:
|
||||
raise HTTPException(status_code=400, detail="Password must be 12-128 characters")
|
||||
|
||||
# Ищем пользователя
|
||||
user = store.get_user_by_username(username)
|
||||
if not user:
|
||||
raise HTTPException(status_code=401, detail="Invalid credentials")
|
||||
|
||||
# Проверяем пароль
|
||||
if not verify_password(password, user["password_hash"]):
|
||||
raise HTTPException(status_code=401, detail="Invalid credentials")
|
||||
|
||||
# Создаём сессию
|
||||
conn = get_db_connection()
|
||||
try:
|
||||
session_data = create_session(conn, user["id"])
|
||||
|
||||
return {
|
||||
"token": session_data["token"],
|
||||
"token_type": "Bearer",
|
||||
"expires_at": session_data["expires_at"],
|
||||
"user": {
|
||||
"id": user["id"],
|
||||
"username": user["username"],
|
||||
"display_name": user["display_name"],
|
||||
"created_at": user["created_at"]
|
||||
}
|
||||
}
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
|
||||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||||
async def revoke_session(request: Request):
|
||||
user = await get_current_user_from_request(request)
|
||||
|
||||
auth_header = request.headers.get("Authorization")
|
||||
token = auth_header[7:] # Убираем "Bearer "
|
||||
|
||||
conn = get_db_connection()
|
||||
try:
|
||||
delete_session(conn, token)
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
# --- Users endpoints ---
|
||||
@app.post("/api/v1/users", response_model=UserResponse, status_code=201)
|
||||
async def create_user(request_body: CreateUserRequest):
|
||||
try:
|
||||
password_hash = hash_password(request_body.password)
|
||||
user = store.create_user(
|
||||
request_body.username,
|
||||
request_body.display_name,
|
||||
password_hash
|
||||
)
|
||||
return user
|
||||
except ValueError as e:
|
||||
if str(e) == "username_already_exists":
|
||||
raise HTTPException(status_code=409, detail="Username already exists")
|
||||
raise HTTPException(status_code=400, detail=str(e))
|
||||
|
||||
|
||||
@app.get("/api/v1/users/me", response_model=UserResponse)
|
||||
async def get_current_user(request: Request):
|
||||
user = await get_current_user_from_request(request)
|
||||
return user
|
||||
|
||||
|
||||
# --- Chats endpoints ---
|
||||
@app.post("/api/v1/chats", response_model=ChatResponse, status_code=201)
|
||||
async def create_chat(request_body: CreateChatRequest, request: Request):
|
||||
user = await get_current_user_from_request(request)
|
||||
|
||||
try:
|
||||
chat = store.create_chat(request_body.title, request_body.member_ids, user["id"])
|
||||
return chat
|
||||
except ValueError as e:
|
||||
if str(e) == "user_not_found":
|
||||
raise HTTPException(status_code=400, detail="One or more members not found")
|
||||
if str(e) == "creator_not_in_members":
|
||||
raise HTTPException(status_code=400, detail="Creator must be in member list")
|
||||
if str(e) == "duplicate_members":
|
||||
raise HTTPException(status_code=400, detail="Duplicate member IDs")
|
||||
raise HTTPException(status_code=400, detail=str(e))
|
||||
|
||||
|
||||
@app.get("/api/v1/chats", response_model=ChatPage)
|
||||
async def list_chats(
|
||||
request: Request,
|
||||
limit: int = Query(default=50, ge=1, le=100),
|
||||
cursor: Optional[str] = Query(default=None, min_length=1)
|
||||
):
|
||||
user = await get_current_user_from_request(request)
|
||||
chats, next_cursor = store.list_chats(user["id"], limit, cursor)
|
||||
return {"items": chats, "next_cursor": next_cursor}
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}", response_model=ChatResponse)
|
||||
async def get_chat(chat_id: str, request: Request):
|
||||
user = await get_current_user_from_request(request)
|
||||
chat = store.get_chat(chat_id, user["id"])
|
||||
if not chat:
|
||||
raise HTTPException(status_code=404, detail="Chat not found")
|
||||
return chat
|
||||
|
||||
|
||||
# --- Messages endpoints ---
|
||||
@app.post("/api/v1/chats/{chat_id}/messages", response_model=MessageResponse, status_code=201)
|
||||
async def create_message(
|
||||
chat_id: str,
|
||||
request_body: CreateMessageRequest,
|
||||
request: Request
|
||||
):
|
||||
user = await get_current_user_from_request(request)
|
||||
|
||||
try:
|
||||
message = store.create_message(chat_id, user["id"], request_body.text)
|
||||
return message
|
||||
except ValueError as e:
|
||||
if str(e) == "chat_not_found":
|
||||
raise HTTPException(status_code=404, detail="Chat not found")
|
||||
if str(e) == "sender_not_in_chat":
|
||||
raise HTTPException(status_code=404, detail="User not in chat")
|
||||
raise HTTPException(status_code=400, detail=str(e))
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage)
|
||||
async def list_messages(
|
||||
chat_id: str,
|
||||
request: Request,
|
||||
limit: int = Query(default=50, ge=1, le=100),
|
||||
cursor: Optional[str] = Query(default=None, min_length=1)
|
||||
):
|
||||
user = await get_current_user_from_request(request)
|
||||
|
||||
try:
|
||||
messages, next_cursor = store.list_messages(chat_id, user["id"], limit, cursor)
|
||||
return {"items": messages, "next_cursor": next_cursor}
|
||||
except ValueError as e:
|
||||
if str(e) == "chat_not_found":
|
||||
raise HTTPException(status_code=404, detail="Chat not found")
|
||||
if str(e) == "user_not_in_chat":
|
||||
raise HTTPException(status_code=404, detail="User not in chat")
|
||||
raise HTTPException(status_code=400, detail=str(e))
|
||||
@@ -0,0 +1,51 @@
|
||||
-- Миграция 001: начальная схема для MTUSI Messenger Lab 2
|
||||
-- Запускать idempotently (безопасно повторять)
|
||||
|
||||
-- Таблица пользователей
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
username VARCHAR(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
display_name VARCHAR(100) NOT NULL CHECK (length(display_name) >= 1),
|
||||
password_hash TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
||||
);
|
||||
|
||||
-- Таблица чатов
|
||||
CREATE TABLE IF NOT EXISTS chats (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
title VARCHAR(100) NOT NULL CHECK (length(title) >= 1),
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
||||
);
|
||||
|
||||
-- Таблица участников чата
|
||||
CREATE TABLE IF NOT EXISTS chat_members (
|
||||
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
-- Таблица сообщений
|
||||
CREATE TABLE IF NOT EXISTS messages (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
text TEXT NOT NULL CHECK (length(text) >= 1 AND length(text) <= 4000),
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
||||
);
|
||||
|
||||
-- Таблица сессий
|
||||
CREATE TABLE IF NOT EXISTS sessions (
|
||||
token TEXT PRIMARY KEY,
|
||||
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
expires_at TIMESTAMPTZ NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
||||
);
|
||||
|
||||
-- Индекс для cursor-based пагинации сообщений
|
||||
CREATE INDEX IF NOT EXISTS idx_messages_chat_created ON messages(chat_id, created_at, id);
|
||||
|
||||
-- Индекс для очистки истёкших сессий
|
||||
CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions(expires_at);
|
||||
|
||||
-- Индекс для быстрого поиска чатов пользователя
|
||||
CREATE INDEX IF NOT EXISTS idx_chat_members_user ON chat_members(user_id);
|
||||
@@ -0,0 +1,97 @@
|
||||
from datetime import datetime, timezone
|
||||
from typing import Optional, List
|
||||
from pydantic import BaseModel, Field, field_validator
|
||||
import re
|
||||
|
||||
|
||||
class CreateUserRequest(BaseModel):
|
||||
username: str = Field(..., min_length=3, max_length=32)
|
||||
display_name: str = Field(..., min_length=1, max_length=100)
|
||||
password: str = Field(..., min_length=12, max_length=128)
|
||||
|
||||
@field_validator('username')
|
||||
@classmethod
|
||||
def validate_username(cls, v):
|
||||
if not re.match(r'^[a-z0-9_]{3,32}$', v):
|
||||
raise ValueError('username должен содержать только a-z, 0-9, _ (3-32 символа)')
|
||||
return v
|
||||
|
||||
@field_validator('display_name')
|
||||
@classmethod
|
||||
def validate_display_name(cls, v):
|
||||
if not v.strip():
|
||||
raise ValueError('display_name не может состоять только из пробелов')
|
||||
return v
|
||||
|
||||
@field_validator('password')
|
||||
@classmethod
|
||||
def validate_password(cls, v):
|
||||
if not v.strip():
|
||||
raise ValueError('password не может состоять только из пробелов')
|
||||
return v
|
||||
|
||||
|
||||
class CreateChatRequest(BaseModel):
|
||||
title: str = Field(..., min_length=1, max_length=100)
|
||||
member_ids: List[str] = Field(..., min_length=1, max_length=100)
|
||||
|
||||
@field_validator('title')
|
||||
@classmethod
|
||||
def validate_title(cls, v):
|
||||
if not v.strip():
|
||||
raise ValueError('title не может состоять только из пробелов')
|
||||
return v
|
||||
|
||||
|
||||
class CreateMessageRequest(BaseModel):
|
||||
text: str = Field(..., min_length=1, max_length=4000)
|
||||
|
||||
@field_validator('text')
|
||||
@classmethod
|
||||
def validate_text(cls, v):
|
||||
if not v.strip():
|
||||
raise ValueError('text не может состоять только из пробелов')
|
||||
return v
|
||||
|
||||
|
||||
class UserResponse(BaseModel):
|
||||
id: str
|
||||
username: str
|
||||
display_name: str
|
||||
created_at: str
|
||||
|
||||
|
||||
class ChatResponse(BaseModel):
|
||||
id: str
|
||||
title: str
|
||||
member_ids: List[str]
|
||||
created_at: str
|
||||
|
||||
|
||||
class MessageResponse(BaseModel):
|
||||
id: str
|
||||
chat_id: str
|
||||
sender_id: str
|
||||
text: str
|
||||
created_at: str
|
||||
|
||||
|
||||
class ChatPage(BaseModel):
|
||||
items: List[ChatResponse]
|
||||
next_cursor: Optional[str] = None
|
||||
|
||||
|
||||
class MessagePage(BaseModel):
|
||||
items: List[MessageResponse]
|
||||
next_cursor: Optional[str] = None
|
||||
|
||||
|
||||
class SessionResponse(BaseModel):
|
||||
token: str
|
||||
token_type: str = "Bearer"
|
||||
expires_at: str
|
||||
user: UserResponse
|
||||
|
||||
|
||||
class HealthResponse(BaseModel):
|
||||
status: str = "ok"
|
||||
Reference in New Issue
Block a user