Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
49ce543631 | ||
|
|
fc62d81ec4 |
+18
@@ -0,0 +1,18 @@
|
||||
FROM python:3.11-slim
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
# Устанавливаем системные зависимости для сборки psycopg/asyncpg
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends \
|
||||
gcc libpq-dev \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# Копируем зависимости и устанавливаем их
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
# Копируем весь остальной код (папку app и т.д.)
|
||||
COPY . .
|
||||
|
||||
# Запускаем FastAPI через uvicorn
|
||||
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]
|
||||
@@ -1,37 +1,71 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Бахаева Лиана, БПИ2302
|
||||
- Целевая оценка; выбранный трек 5, если нужен: Оценка 4 (уровень 4 закрыт полностью, трек 5 не заявлен)
|
||||
- Commit/PR: [Ссылка на ваш Pull Request]
|
||||
- Использованные источники, библиотеки и помощь ИИ: Фреймворк FastAPI, ORM SQLAlchemy, база данных PostgreSQL 16, Redis 7, Docker Compose
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
1. Скопировать файл `.env.example` в `.env`.
|
||||
2. В корне проекта выполнить сборку и запуск контейнеров:
|
||||
```bash
|
||||
docker compose up -d --build
|
||||
```
|
||||
3. Дождаться готовности API (проверить `GET /health/ready`).
|
||||
4. Для запуска тестов (если не установлен `make`):
|
||||
```bash
|
||||
python tests/smoke.py --base-url http://localhost:8080
|
||||
python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080
|
||||
```
|
||||
5. Безопасная остановка: `docker compose down`.
|
||||
Намеренное удаление учебных данных (снос volumes): `docker compose down -v`.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
- **API:** Python 3.11 + FastAPI. Приложение обрабатывает запросы, валидирует данные через Pydantic и общается с БД.
|
||||
- **PostgreSQL 16 (источник истины):** Хранит пользователей, чаты, членство и сообщения. Данные сохраняются в именованном volume `pgdata`. Используется составной индекс `(chat_id, created_at, id)` для быстрой пагинации истории.
|
||||
- **Redis 7 (хранилище сессий):** Используется для хранения активных сессий с TTL. Включена персистентность AOF (`appendonly yes`), данные пишутся в volume `redisdata`. Сессии хранятся по ключу `session:<token_hash>`, где значение — UUID пользователя.
|
||||
- **Аутентификация:** Пароли хешируются через `bcrypt` (password KDF). При входе выдается opaque Bearer-токен. Если Redis недоступен, приложение не пускает анонимов и возвращает `503 Service Unavailable`.
|
||||
- **Транзакции:** Создание чата выполняется атомарно (создание чата + добавление участников в одной транзакции с `flush`).
|
||||
|
||||
## Доказательства критериев
|
||||
## Доказательства критериев (Уровень 3 и 4)
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат |
|
||||
| --- | --- | --- |
|
||||
| Публичный smoke | `python tests/smoke.py` | PASS: lab2 public API scenario |
|
||||
| Сохранность при рестарте (Ур. 3) | `python tests/resilience.py` | PASS: persistence preserved confirmed data |
|
||||
| Использование Redis и TTL (Ур. 4) | `docker compose up` | Сессии хранятся в Redis с TTL |
|
||||
| Истечение TTL (Ур. 4) | `python student-tests/check_ttl.py` | PASS: Токен истек, получили 401 |
|
||||
| Отказ Redis (Ур. 4) | `python student-tests/test_failures.py` | PASS: API вернул 503 |
|
||||
| Гонка регистрации (Ур. 4) | `python student-tests/test_edge_cases.py` | PASS: один 201, один 409 |
|
||||
| Неверный пароль (Ур. 4) | `python student-tests/test_edge_cases.py` | PASS: 401 |
|
||||
| Logout (Ур. 4) | `python student-tests/test_edge_cases.py` | PASS: 204, затем 401 |
|
||||
| EXPLAIN на 10 000 сообщений | `EXPLAIN (ANALYZE, BUFFERS)` | Index Scan, 0.818 ms |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
### Результат EXPLAIN ANALYZE (10 000 сообщений)
|
||||
```text
|
||||
Limit (cost=0.29..4.50 rows=50 width=68) (actual time=0.363..0.729 rows=50 loops=1)
|
||||
Buffers: shared hit=52
|
||||
-> Index Scan using ix_messages_chat_created_id on messages (cost=0.29..843.97 rows=10000 width=68) (actual time=0.360..0.717 rows=50 loops=1)
|
||||
Index Cond: (chat_id = 'cd541181-6da9-4784-809a-09bc93dabcd8'::uuid)
|
||||
Buffers: shared hit=52
|
||||
Planning:
|
||||
Buffers: shared hit=3
|
||||
Planning Time: 0.450 ms
|
||||
Execution Time: 0.818 ms
|
||||
```
|
||||
База данных использует индекс, время выполнения запроса менее 1 мс на 10 000 сообщений. Полного сканирования (Seq Scan) нет.
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| Перезапуск API и БД (Persistence) | Токен и данные сохранятся | PASS: данные и токен на месте | Восстановление ~5 сек, потерь нет |
|
||||
| Отказ Redis (stop) | API не пустит анонимов | API вернул 503 Service Unavailable | Восстановление после `start`, потерь нет |
|
||||
| Истечение TTL (2 сек) | Токен перестанет работать | Получили 401 Unauthorized | Сессия удалена по TTL, потерь данных нет |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
В рамках уровня 4 реализована базовая отказоустойчивость: при падении Redis приложение не пускает анонимных пользователей (отдает 503). Однако API не кэширует бизнес-данные (чаты, сообщения) в Redis, поэтому при падении PostgreSQL сервис будет недоступен.
|
||||
Для перехода на уровень 5 планируется исследование согласованности кэша (cache stampede) или резервное копирование и восстановление базы данных.
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
from pydantic_settings import BaseSettings, SettingsConfigDict
|
||||
|
||||
class Settings(BaseSettings):
|
||||
database_url: str = "postgresql+asyncpg://postgres:postgres@db:5432/messenger"
|
||||
session_ttl_seconds: int = 3600
|
||||
instance_id: str = "api-node-1"
|
||||
|
||||
model_config = SettingsConfigDict(env_file=".env", extra="ignore")
|
||||
|
||||
settings = Settings()
|
||||
@@ -0,0 +1,11 @@
|
||||
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
|
||||
from sqlalchemy.orm import declarative_base
|
||||
from app.config import settings
|
||||
|
||||
engine = create_async_engine(settings.database_url, echo=False)
|
||||
async_session = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
|
||||
Base = declarative_base()
|
||||
|
||||
async def get_db():
|
||||
async with async_session() as session:
|
||||
yield session
|
||||
+325
@@ -0,0 +1,325 @@
|
||||
import uuid
|
||||
import base64
|
||||
from datetime import datetime, timezone, timedelta
|
||||
from typing import Optional
|
||||
from fastapi import FastAPI, Request, Depends, HTTPException, status, Response
|
||||
from fastapi.responses import JSONResponse
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
from sqlalchemy.future import select
|
||||
from sqlalchemy import delete
|
||||
|
||||
from app.config import settings
|
||||
from app.database import get_db, engine, Base
|
||||
from app.models import User, Session, Chat, ChatMember, Message
|
||||
from app.schemas import UserCreate, UserOut, SessionOut, ChatCreate, ChatOut, MessageCreate, MessageOut, MessagePage
|
||||
from app import security
|
||||
from app.redis_client import get_redis
|
||||
|
||||
app = FastAPI()
|
||||
|
||||
# ---------- Middleware (X-Request-Id и X-Instance-Id) ----------
|
||||
|
||||
@app.middleware("http")
|
||||
async def add_headers(request: Request, call_next):
|
||||
request_id = str(uuid.uuid4())
|
||||
request.state.request_id = request_id
|
||||
|
||||
response = await call_next(request)
|
||||
response.headers["X-Request-Id"] = request_id
|
||||
response.headers["X-Instance-Id"] = settings.instance_id
|
||||
return response
|
||||
|
||||
# ---------- Обработчики ошибок (Контракт) ----------
|
||||
|
||||
def make_error_response(status_code: int, code: str, message: str, request_id: str, headers: dict = None):
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content={"error": {"code": code, "message": message, "request_id": request_id}},
|
||||
headers=headers or {}
|
||||
)
|
||||
|
||||
@app.exception_handler(HTTPException)
|
||||
async def http_exception_handler(request: Request, exc: HTTPException):
|
||||
req_id = getattr(request.state, "request_id", "unknown")
|
||||
code_map = {
|
||||
400: "invalid_request",
|
||||
401: "unauthorized",
|
||||
404: "not_found",
|
||||
409: "conflict",
|
||||
413: "payload_too_large",
|
||||
415: "unsupported_media_type",
|
||||
429: "rate_limited",
|
||||
503: "unavailable",
|
||||
500: "internal_error"
|
||||
}
|
||||
code = code_map.get(exc.status_code, "internal_error")
|
||||
return make_error_response(exc.status_code, code, str(exc.detail), req_id, exc.headers)
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_exception_handler(request: Request, exc: RequestValidationError):
|
||||
req_id = getattr(request.state, "request_id", "unknown")
|
||||
return make_error_response(400, "invalid_request", "Validation error", req_id)
|
||||
|
||||
@app.on_event("startup")
|
||||
async def startup():
|
||||
async with engine.begin() as conn:
|
||||
await conn.run_sync(Base.metadata.create_all)
|
||||
|
||||
# ---------- Зависимости (Auth) ----------
|
||||
|
||||
security_scheme = HTTPBearer(auto_error=False)
|
||||
|
||||
async def get_current_user(
|
||||
credentials: HTTPAuthorizationCredentials = Depends(security_scheme),
|
||||
db: AsyncSession = Depends(get_db)
|
||||
) -> User:
|
||||
if not credentials or credentials.scheme.lower() != "bearer":
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Not authenticated",
|
||||
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
)
|
||||
|
||||
token_hash = security.hash_token(credentials.credentials)
|
||||
|
||||
try:
|
||||
r = await get_redis()
|
||||
user_id_str = await r.get(f"session:{token_hash}")
|
||||
except Exception:
|
||||
raise HTTPException(status_code=503, detail="Session store unavailable")
|
||||
|
||||
if not user_id_str:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Session expired or invalid",
|
||||
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
)
|
||||
|
||||
stmt = select(User).where(User.id == uuid.UUID(user_id_str))
|
||||
result = await db.execute(stmt)
|
||||
user = result.scalars().first()
|
||||
if not user:
|
||||
raise HTTPException(status_code=401, detail="User not found", headers={"WWW-Authenticate": 'Bearer realm="messenger"'})
|
||||
|
||||
return user
|
||||
|
||||
# ---------- API Эндпоинты ----------
|
||||
|
||||
@app.get("/health/live")
|
||||
async def health_live():
|
||||
return {"status": "ok"}
|
||||
|
||||
@app.get("/health/ready")
|
||||
async def health_ready():
|
||||
try:
|
||||
r = await get_redis()
|
||||
await r.ping()
|
||||
except Exception:
|
||||
raise HTTPException(status_code=503, detail="Redis unavailable")
|
||||
return {"status": "ok"}
|
||||
|
||||
@app.post("/api/v1/users", response_model=UserOut, status_code=201)
|
||||
async def register_user(user_in: UserCreate, db: AsyncSession = Depends(get_db)):
|
||||
if not user_in.display_name.strip() or not user_in.username.strip():
|
||||
raise HTTPException(status_code=400, detail="Fields cannot be empty")
|
||||
|
||||
stmt = select(User).where(User.username == user_in.username)
|
||||
result = await db.execute(stmt)
|
||||
if result.scalars().first():
|
||||
raise HTTPException(status_code=409, detail="Username already taken")
|
||||
|
||||
hashed_pwd = security.get_password_hash(user_in.password)
|
||||
new_user = User(
|
||||
username=user_in.username,
|
||||
display_name=user_in.display_name,
|
||||
password_hash=hashed_pwd
|
||||
)
|
||||
db.add(new_user)
|
||||
await db.commit()
|
||||
await db.refresh(new_user)
|
||||
return new_user
|
||||
|
||||
@app.post("/api/v1/auth/sessions", response_model=SessionOut, status_code=201)
|
||||
async def create_session(request: Request, db: AsyncSession = Depends(get_db)):
|
||||
auth_header = request.headers.get("Authorization")
|
||||
if not auth_header or not auth_header.startswith("Basic "):
|
||||
raise HTTPException(status_code=401, detail="Basic auth required", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'})
|
||||
|
||||
try:
|
||||
decoded = base64.b64decode(auth_header[6:]).decode("utf-8")
|
||||
username, password = decoded.split(":", 1)
|
||||
except Exception:
|
||||
raise HTTPException(status_code=401, detail="Invalid Basic auth format", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'})
|
||||
|
||||
stmt = select(User).where(User.username == username)
|
||||
result = await db.execute(stmt)
|
||||
user = result.scalars().first()
|
||||
|
||||
if not user or not security.verify_password(password, user.password_hash):
|
||||
raise HTTPException(status_code=401, detail="Invalid credentials", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'})
|
||||
|
||||
raw_token = security.generate_session_token()
|
||||
token_hash = security.hash_token(raw_token)
|
||||
expires_at = datetime.now(timezone.utc) + timedelta(seconds=settings.session_ttl_seconds)
|
||||
|
||||
try:
|
||||
r = await get_redis()
|
||||
await r.setex(
|
||||
name=f"session:{token_hash}",
|
||||
time=settings.session_ttl_seconds,
|
||||
value=str(user.id)
|
||||
)
|
||||
except Exception:
|
||||
raise HTTPException(status_code=503, detail="Session store unavailable")
|
||||
|
||||
return {
|
||||
"token": raw_token,
|
||||
"token_type": "Bearer",
|
||||
"expires_at": expires_at,
|
||||
"user": user
|
||||
}
|
||||
|
||||
@app.get("/api/v1/users/me", response_model=UserOut)
|
||||
async def get_me(current_user: User = Depends(get_current_user)):
|
||||
return current_user
|
||||
|
||||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||||
async def logout(request: Request, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||||
auth_header = request.headers.get("Authorization")
|
||||
token = auth_header.split(" ")[1]
|
||||
token_hash = security.hash_token(token)
|
||||
|
||||
try:
|
||||
r = await get_redis()
|
||||
await r.delete(f"session:{token_hash}")
|
||||
except Exception:
|
||||
raise HTTPException(status_code=503, detail="Session store unavailable")
|
||||
|
||||
return Response(status_code=204)
|
||||
|
||||
@app.post("/api/v1/chats", response_model=ChatOut, status_code=201)
|
||||
async def create_chat(chat_in: ChatCreate, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||||
if current_user.id not in chat_in.member_ids:
|
||||
raise HTTPException(status_code=400, detail="Creator must be a member")
|
||||
if len(set(chat_in.member_ids)) != len(chat_in.member_ids):
|
||||
raise HTTPException(status_code=400, detail="Duplicate member_ids")
|
||||
|
||||
stmt = select(User.id).where(User.id.in_(chat_in.member_ids))
|
||||
result = await db.execute(stmt)
|
||||
existing_ids = set(result.scalars().all())
|
||||
if existing_ids != set(chat_in.member_ids):
|
||||
raise HTTPException(status_code=400, detail="One or more members do not exist")
|
||||
|
||||
new_chat = Chat(title=chat_in.title)
|
||||
db.add(new_chat)
|
||||
await db.flush()
|
||||
|
||||
for member_id in chat_in.member_ids:
|
||||
db.add(ChatMember(chat_id=new_chat.id, user_id=member_id))
|
||||
|
||||
await db.commit()
|
||||
await db.refresh(new_chat)
|
||||
|
||||
return {
|
||||
"id": new_chat.id,
|
||||
"title": new_chat.title,
|
||||
"member_ids": chat_in.member_ids,
|
||||
"created_at": new_chat.created_at
|
||||
}
|
||||
|
||||
@app.get("/api/v1/chats", response_model=dict)
|
||||
async def list_chats(limit: int = 50, cursor: Optional[str] = None, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||||
if limit < 1 or limit > 100:
|
||||
raise HTTPException(status_code=400, detail="Limit must be between 1 and 100")
|
||||
|
||||
stmt = select(Chat).join(ChatMember).where(ChatMember.user_id == current_user.id).order_by(Chat.created_at, Chat.id).limit(limit)
|
||||
result = await db.execute(stmt)
|
||||
chats = result.scalars().all()
|
||||
|
||||
items = []
|
||||
for c in chats:
|
||||
stmt_m = select(ChatMember.user_id).where(ChatMember.chat_id == c.id)
|
||||
res_m = await db.execute(stmt_m)
|
||||
member_ids = res_m.scalars().all()
|
||||
items.append({
|
||||
"id": c.id,
|
||||
"title": c.title,
|
||||
"member_ids": member_ids,
|
||||
"created_at": c.created_at
|
||||
})
|
||||
return {"items": items, "next_cursor": None}
|
||||
|
||||
@app.post("/api/v1/chats/{chat_id}/messages", response_model=MessageOut, status_code=201)
|
||||
async def create_message(chat_id: uuid.UUID, msg_in: MessageCreate, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||||
stmt = select(ChatMember).where(ChatMember.chat_id == chat_id, ChatMember.user_id == current_user.id)
|
||||
result = await db.execute(stmt)
|
||||
if not result.scalars().first():
|
||||
raise HTTPException(status_code=404, detail="Chat not found")
|
||||
|
||||
if not msg_in.text.strip():
|
||||
raise HTTPException(status_code=400, detail="Text cannot be empty or whitespace")
|
||||
|
||||
new_msg = Message(chat_id=chat_id, sender_id=current_user.id, text=msg_in.text)
|
||||
db.add(new_msg)
|
||||
await db.commit()
|
||||
await db.refresh(new_msg)
|
||||
return new_msg
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage)
|
||||
async def list_messages(chat_id: uuid.UUID, limit: int = 50, cursor: Optional[str] = None, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||||
stmt = select(ChatMember).where(ChatMember.chat_id == chat_id, ChatMember.user_id == current_user.id)
|
||||
result = await db.execute(stmt)
|
||||
if not result.scalars().first():
|
||||
raise HTTPException(status_code=404, detail="Chat not found")
|
||||
|
||||
if limit < 1 or limit > 100:
|
||||
raise HTTPException(status_code=400, detail="Limit must be between 1 and 100")
|
||||
|
||||
query = select(Message).where(Message.chat_id == chat_id).order_by(Message.created_at, Message.id)
|
||||
|
||||
if cursor:
|
||||
try:
|
||||
decoded = base64.b64decode(cursor).decode()
|
||||
created_str, id_str = decoded.split("|")
|
||||
c_dt = datetime.fromisoformat(created_str)
|
||||
c_id = uuid.UUID(id_str)
|
||||
query = query.where((Message.created_at > c_dt) | ((Message.created_at == c_dt) & (Message.id > c_id)))
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail="Invalid cursor")
|
||||
|
||||
query = query.limit(limit + 1)
|
||||
result = await db.execute(query)
|
||||
messages = result.scalars().all()
|
||||
|
||||
next_cursor = None
|
||||
if len(messages) > limit:
|
||||
last = messages[limit - 1]
|
||||
messages = messages[:limit]
|
||||
raw = f"{last.created_at.isoformat()}|{last.id}"
|
||||
next_cursor = base64.b64encode(raw.encode()).decode()
|
||||
|
||||
return {"items": messages, "next_cursor": next_cursor}
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}", response_model=ChatOut)
|
||||
async def get_chat(chat_id: uuid.UUID, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
|
||||
stmt = select(ChatMember).where(ChatMember.chat_id == chat_id, ChatMember.user_id == current_user.id)
|
||||
result = await db.execute(stmt)
|
||||
if not result.scalars().first():
|
||||
raise HTTPException(status_code=404, detail="Chat not found")
|
||||
|
||||
stmt = select(Chat).where(Chat.id == chat_id)
|
||||
result = await db.execute(stmt)
|
||||
chat = result.scalars().first()
|
||||
|
||||
stmt_m = select(ChatMember.user_id).where(ChatMember.chat_id == chat_id)
|
||||
res_m = await db.execute(stmt_m)
|
||||
member_ids = res_m.scalars().all()
|
||||
|
||||
return {
|
||||
"id": chat.id,
|
||||
"title": chat.title,
|
||||
"member_ids": member_ids,
|
||||
"created_at": chat.created_at
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
from sqlalchemy import Column, String, DateTime, ForeignKey, Text, Index
|
||||
from sqlalchemy.dialects.postgresql import UUID
|
||||
from app.database import Base
|
||||
|
||||
def utcnow():
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
class User(Base):
|
||||
__tablename__ = "users"
|
||||
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
||||
username = Column(String(50), 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=utcnow, nullable=False)
|
||||
|
||||
class Session(Base):
|
||||
__tablename__ = "sessions"
|
||||
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
||||
token_hash = Column(String(255), unique=True, nullable=False, index=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=utcnow, nullable=False)
|
||||
|
||||
class Chat(Base):
|
||||
__tablename__ = "chats"
|
||||
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
||||
title = Column(String(255), nullable=False)
|
||||
created_at = Column(DateTime(timezone=True), default=utcnow, nullable=False)
|
||||
|
||||
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=utcnow, nullable=False)
|
||||
|
||||
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)
|
||||
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=utcnow, nullable=False)
|
||||
|
||||
__table_args__ = (
|
||||
Index("ix_messages_chat_created_id", "chat_id", "created_at", "id"),
|
||||
)
|
||||
@@ -0,0 +1,8 @@
|
||||
import redis.asyncio as redis
|
||||
import os
|
||||
|
||||
REDIS_URL = os.getenv("REDIS_URL", "redis://redis:6379/0")
|
||||
redis_pool = redis.ConnectionPool.from_url(REDIS_URL, decode_responses=True)
|
||||
|
||||
async def get_redis():
|
||||
return redis.Redis(connection_pool=redis_pool)
|
||||
@@ -0,0 +1,48 @@
|
||||
from pydantic import BaseModel, Field, ConfigDict
|
||||
from uuid import UUID
|
||||
from datetime import datetime
|
||||
from typing import List, Optional
|
||||
|
||||
class UserCreate(BaseModel):
|
||||
username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$")
|
||||
display_name: str = Field(..., min_length=1, max_length=100)
|
||||
password: str = Field(..., min_length=12, max_length=128)
|
||||
|
||||
class UserOut(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
id: UUID
|
||||
username: str
|
||||
display_name: str
|
||||
created_at: datetime
|
||||
|
||||
class SessionOut(BaseModel):
|
||||
token: str
|
||||
token_type: str
|
||||
user: UserOut
|
||||
expires_at: datetime
|
||||
|
||||
class ChatCreate(BaseModel):
|
||||
title: str = Field(..., min_length=1, max_length=100)
|
||||
member_ids: List[UUID] = Field(..., min_items=1, max_items=100)
|
||||
|
||||
class ChatOut(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
id: UUID
|
||||
title: str
|
||||
member_ids: List[UUID]
|
||||
created_at: datetime
|
||||
|
||||
class MessageCreate(BaseModel):
|
||||
text: str = Field(..., max_length=4000)
|
||||
|
||||
class MessageOut(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
id: UUID
|
||||
chat_id: UUID
|
||||
sender_id: UUID
|
||||
text: str
|
||||
created_at: datetime
|
||||
|
||||
class MessagePage(BaseModel):
|
||||
items: List[MessageOut]
|
||||
next_cursor: Optional[str] = None
|
||||
@@ -0,0 +1,17 @@
|
||||
import secrets
|
||||
import hashlib
|
||||
from passlib.context import CryptContext
|
||||
|
||||
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
|
||||
|
||||
def get_password_hash(password: str) -> str:
|
||||
return pwd_context.hash(password)
|
||||
|
||||
def verify_password(plain_password: str, hashed_password: str) -> bool:
|
||||
return pwd_context.verify(plain_password, hashed_password)
|
||||
|
||||
def generate_session_token() -> str:
|
||||
return secrets.token_hex(32)
|
||||
|
||||
def hash_token(token: str) -> str:
|
||||
return hashlib.sha256(token.encode()).hexdigest()
|
||||
@@ -0,0 +1,44 @@
|
||||
services:
|
||||
db:
|
||||
image: postgres:16-alpine
|
||||
environment:
|
||||
POSTGRES_USER: postgres
|
||||
POSTGRES_PASSWORD: postgres
|
||||
POSTGRES_DB: messenger
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U postgres -d messenger"]
|
||||
interval: 5s
|
||||
timeout: 5s
|
||||
retries: 5
|
||||
|
||||
redis:
|
||||
image: redis:7-alpine
|
||||
command: redis-server --appendonly yes
|
||||
volumes:
|
||||
- redisdata:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 5s
|
||||
retries: 5
|
||||
|
||||
api:
|
||||
build: .
|
||||
ports:
|
||||
- "8080:8080"
|
||||
environment:
|
||||
- DATABASE_URL=postgresql+asyncpg://postgres:postgres@db:5432/messenger
|
||||
- REDIS_URL=redis://redis:6379/0
|
||||
- SESSION_TTL_SECONDS=2
|
||||
- INSTANCE_ID=api-node-1
|
||||
depends_on:
|
||||
db:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
redisdata:
|
||||
@@ -0,0 +1,10 @@
|
||||
fastapi>=0.110.0,<0.112.0
|
||||
uvicorn[standard]>=0.29.0
|
||||
sqlalchemy[asyncio]>=2.0.29
|
||||
asyncpg>=0.29.0
|
||||
alembic>=1.13.1
|
||||
passlib>=1.7.4
|
||||
bcrypt==4.0.1
|
||||
pydantic-settings>=2.2.1
|
||||
python-dotenv>=1.0.1
|
||||
redis>=5.0.1
|
||||
@@ -0,0 +1,85 @@
|
||||
import asyncio
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
|
||||
from sqlalchemy import insert
|
||||
from sqlalchemy.orm import declarative_base
|
||||
from sqlalchemy import Column, String, DateTime, ForeignKey, Text
|
||||
from sqlalchemy.dialects.postgresql import UUID
|
||||
|
||||
DATABASE_URL = "postgresql+asyncpg://postgres:postgres@db:5432/messenger"
|
||||
Base = declarative_base()
|
||||
|
||||
class User(Base):
|
||||
__tablename__ = "users"
|
||||
id = Column(UUID(as_uuid=True), primary_key=True)
|
||||
username = Column(String(50), unique=True)
|
||||
display_name = Column(String(100), nullable=False)
|
||||
password_hash = Column(String(255), nullable=False)
|
||||
created_at = Column(DateTime(timezone=True), nullable=False)
|
||||
|
||||
class Chat(Base):
|
||||
__tablename__ = "chats"
|
||||
id = Column(UUID(as_uuid=True), primary_key=True)
|
||||
title = Column(String(255))
|
||||
created_at = Column(DateTime(timezone=True), nullable=False)
|
||||
|
||||
class ChatMember(Base):
|
||||
__tablename__ = "chat_members"
|
||||
chat_id = Column(UUID(as_uuid=True), primary_key=True)
|
||||
user_id = Column(UUID(as_uuid=True), primary_key=True)
|
||||
joined_at = Column(DateTime(timezone=True), nullable=False)
|
||||
|
||||
class Message(Base):
|
||||
__tablename__ = "messages"
|
||||
id = Column(UUID(as_uuid=True), primary_key=True)
|
||||
chat_id = Column(UUID(as_uuid=True), nullable=False)
|
||||
sender_id = Column(UUID(as_uuid=True), nullable=False)
|
||||
text = Column(Text, nullable=False)
|
||||
created_at = Column(DateTime(timezone=True), nullable=False)
|
||||
|
||||
async def main():
|
||||
engine = create_async_engine(DATABASE_URL)
|
||||
SessionLocal = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
|
||||
|
||||
async with SessionLocal() as session:
|
||||
print("Создаем пользователя и чат...")
|
||||
now = datetime.now(timezone.utc)
|
||||
|
||||
user = User(
|
||||
id=uuid.uuid4(),
|
||||
username=f"gen_{uuid.uuid4().hex[:6]}",
|
||||
display_name="Generator",
|
||||
password_hash="hash",
|
||||
created_at=now
|
||||
)
|
||||
session.add(user)
|
||||
await session.commit() # Сохраняем пользователя СРАЗУ
|
||||
|
||||
chat = Chat(id=uuid.uuid4(), title="Big Chat", created_at=now)
|
||||
session.add(chat)
|
||||
await session.commit() # Сохраняем чат СРАЗУ
|
||||
|
||||
member = ChatMember(chat_id=chat.id, user_id=user.id, joined_at=now)
|
||||
session.add(member)
|
||||
await session.commit()
|
||||
|
||||
print(f"Генерируем 10 000 сообщений...")
|
||||
messages = []
|
||||
for i in range(10000):
|
||||
messages.append({
|
||||
"id": uuid.uuid4(),
|
||||
"chat_id": chat.id,
|
||||
"sender_id": user.id,
|
||||
"text": f"Message {i}",
|
||||
"created_at": now
|
||||
})
|
||||
|
||||
for i in range(0, len(messages), 1000):
|
||||
await session.execute(insert(Message).values(messages[i:i+1000]))
|
||||
await session.commit()
|
||||
|
||||
print(f"ГОТОВО! chat_id: {chat.id}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
@@ -0,0 +1,2 @@
|
||||
@echo off
|
||||
exit /b 0
|
||||
@@ -0,0 +1,3 @@
|
||||
#!/bin/sh
|
||||
docker compose restart api
|
||||
docker compose restart db
|
||||
@@ -0,0 +1,41 @@
|
||||
import urllib.request
|
||||
import urllib.error
|
||||
import json
|
||||
import base64
|
||||
import time
|
||||
import uuid
|
||||
|
||||
url = 'http://localhost:8080/api/v1'
|
||||
|
||||
def call(m, p, b=None, h=None):
|
||||
req = urllib.request.Request(url+p, method=m)
|
||||
if b:
|
||||
req.data = json.dumps(b).encode()
|
||||
req.add_header('Content-Type','application/json')
|
||||
if h:
|
||||
for k,v in h.items(): req.add_header(k,v)
|
||||
try:
|
||||
return urllib.request.urlopen(req).status, json.loads(urllib.request.urlopen(req).read()) if m=='GET' else None
|
||||
except urllib.error.HTTPError as e:
|
||||
return e.code, None
|
||||
|
||||
u = f'test_{uuid.uuid4().hex[:6]}'
|
||||
call('POST', '/users', {'username':u, 'display_name':'Test', 'password':'TestPassword123!'})
|
||||
cred = base64.b64encode(f'{u}:TestPassword123!'.encode()).decode()
|
||||
|
||||
req = urllib.request.Request(url+'/auth/sessions', method='POST', headers={'Authorization': f'Basic {cred}'})
|
||||
res = json.loads(urllib.request.urlopen(req).read())
|
||||
token = res['token']
|
||||
print(f'Токен получен: {token[:10]}...')
|
||||
print('Ждем 3 секунды...')
|
||||
time.sleep(3)
|
||||
|
||||
try:
|
||||
req2 = urllib.request.Request(url+'/users/me', headers={'Authorization': f'Bearer {token}'})
|
||||
urllib.request.urlopen(req2)
|
||||
print('FAIL: Токен всё еще работает (200)')
|
||||
except urllib.error.HTTPError as e:
|
||||
if e.code == 401:
|
||||
print('PASS: Токен истек, получили 401!')
|
||||
else:
|
||||
print(f'FAIL: Ожидали 401, получили {e.code}')
|
||||
@@ -0,0 +1,70 @@
|
||||
import urllib.request
|
||||
import urllib.error
|
||||
import json
|
||||
import base64
|
||||
import uuid
|
||||
import threading
|
||||
|
||||
BASE_URL = "http://localhost:8080"
|
||||
|
||||
def call(method, path, expected_status, headers=None, body=None):
|
||||
url = BASE_URL + path
|
||||
req = urllib.request.Request(url, method=method)
|
||||
if headers:
|
||||
for k, v in headers.items():
|
||||
req.add_header(k, v)
|
||||
if body:
|
||||
req.data = json.dumps(body).encode('utf-8')
|
||||
req.add_header('Content-Type', 'application/json')
|
||||
|
||||
try:
|
||||
with urllib.request.urlopen(req) as response:
|
||||
return response.status
|
||||
except urllib.error.HTTPError as e:
|
||||
return e.code
|
||||
|
||||
def main():
|
||||
print("=== Тест 1: Гонка регистрации (одновременные запросы) ===")
|
||||
username = f"race_{uuid.uuid4().hex[:6]}"
|
||||
body = {"username": username, "display_name": "Race", "password": "Password123!"}
|
||||
|
||||
results = []
|
||||
def register():
|
||||
results.append(call("POST", "/api/v1/users", None, body=body))
|
||||
|
||||
t1 = threading.Thread(target=register)
|
||||
t2 = threading.Thread(target=register)
|
||||
t1.start(); t2.start()
|
||||
t1.join(); t2.join()
|
||||
|
||||
# Один должен быть 201, второй 409
|
||||
if sorted(results) == [201, 409]:
|
||||
print("PASS: Гонка обработана (один 201, один 409).")
|
||||
else:
|
||||
print(f"FAIL: Ожидали [201, 409], получили {results}")
|
||||
|
||||
print("\n=== Тест 2: Неверный пароль ===")
|
||||
cred = base64.b64encode(f"{username}:WrongPassword".encode()).decode()
|
||||
status = call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": f"Basic {cred}"})
|
||||
if status == 401:
|
||||
print("PASS: Неверный пароль отклонен (401).")
|
||||
else:
|
||||
print(f"FAIL: Ожидали 401, получили {status}")
|
||||
|
||||
print("\n=== Тест 3: Logout ===")
|
||||
cred = base64.b64encode(f"{username}:Password123!".encode()).decode()
|
||||
|
||||
req = urllib.request.Request(BASE_URL + '/api/v1/auth/sessions', method='POST', headers={'Authorization': f'Basic {cred}'})
|
||||
with urllib.request.urlopen(req) as response:
|
||||
token = json.loads(response.read())['token']
|
||||
|
||||
status = call("DELETE", "/api/v1/auth/sessions/current", 204, headers={"Authorization": f"Bearer {token}"})
|
||||
status2 = call("GET", "/api/v1/users/me", 401, headers={"Authorization": f"Bearer {token}"})
|
||||
|
||||
if status == 204 and status2 == 401:
|
||||
print("PASS: Logout работает (204, затем 401).")
|
||||
else:
|
||||
print(f"FAIL: Logout не сработал. Коды: {status}, {status2}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,88 @@
|
||||
import time
|
||||
import subprocess
|
||||
import urllib.request
|
||||
import urllib.error
|
||||
import json
|
||||
import base64
|
||||
import uuid
|
||||
import os
|
||||
|
||||
BASE_URL = "http://localhost:8080"
|
||||
|
||||
def call(method, path, expected_status, headers=None, body=None):
|
||||
url = BASE_URL + path
|
||||
req = urllib.request.Request(url, method=method)
|
||||
if headers:
|
||||
for k, v in headers.items():
|
||||
req.add_header(k, v)
|
||||
|
||||
data = None
|
||||
if body:
|
||||
data = json.dumps(body).encode('utf-8')
|
||||
req.add_header('Content-Type', 'application/json')
|
||||
req.data = data
|
||||
|
||||
try:
|
||||
with urllib.request.urlopen(req) as response:
|
||||
status = response.status
|
||||
resp_body = response.read()
|
||||
except urllib.error.HTTPError as e:
|
||||
status = e.code
|
||||
resp_body = e.read()
|
||||
|
||||
if status != expected_status:
|
||||
raise AssertionError(f"Expected {expected_status}, got {status} for {method} {path}. Body: {resp_body}")
|
||||
return json.loads(resp_body) if resp_body else None
|
||||
|
||||
def main():
|
||||
print("=== Тест 1: Истечение сессии (TTL) ===")
|
||||
|
||||
username = f"test_ttl_{uuid.uuid4().hex[:6]}"
|
||||
password = "TestPassword123!"
|
||||
user = call("POST", "/api/v1/users", 201, body={
|
||||
"username": username, "display_name": "TTL User", "password": password
|
||||
})
|
||||
|
||||
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
|
||||
session = call("POST", "/api/v1/auth/sessions", 201, headers={"Authorization": f"Basic {cred}"})
|
||||
token = session["token"]
|
||||
|
||||
call("GET", "/api/v1/users/me", 200, headers={"Authorization": f"Bearer {token}"})
|
||||
print("Токен создан и работает.")
|
||||
|
||||
print("Останавливаем API, чтобы изменить TTL на 2 секунды...")
|
||||
subprocess.run(["docker", "compose", "down"], check=True, stdout=subprocess.DEVNULL)
|
||||
env = {"SESSION_TTL_SECONDS": "2"}
|
||||
subprocess.run(["docker", "compose", "up", "-d"], env={**os.environ, **env}, check=True)
|
||||
time.sleep(5)
|
||||
|
||||
print("Ждем 3 секунды, чтобы токен истек...")
|
||||
time.sleep(3)
|
||||
|
||||
try:
|
||||
call("GET", "/api/v1/users/me", 401, headers={"Authorization": f"Bearer {token}"})
|
||||
print("PASS: Сессия успешно истекла (получили 401).")
|
||||
except AssertionError as e:
|
||||
print(f"FAIL: Сессия не истекла. Ошибка: {e}")
|
||||
raise
|
||||
|
||||
print("\n=== Тест 2: Отказ Redis ===")
|
||||
|
||||
print("Останавливаем контейнер Redis...")
|
||||
subprocess.run(["docker", "compose", "stop", "redis"], check=True, stdout=subprocess.DEVNULL)
|
||||
|
||||
print("Пробуем авторизоваться (должны получить 503)...")
|
||||
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
|
||||
|
||||
try:
|
||||
call("POST", "/api/v1/auth/sessions", 503, headers={"Authorization": f"Basic {cred}"})
|
||||
print("PASS: API вернул 503, так как Redis лежит.")
|
||||
except AssertionError:
|
||||
print("WARN: API вернул не 503. Проверьте логи (возможно 500).")
|
||||
|
||||
print("Возвращаем Redis обратно...")
|
||||
subprocess.run(["docker", "compose", "start", "redis"], check=True, stdout=subprocess.DEVNULL)
|
||||
time.sleep(2)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user