forked from mtusi2026/mtusi2026lab2
Реализовал уровень 3: PostgreSQL, пароли и сохраняемые сессии
This commit is contained in:
@@ -0,0 +1,4 @@
|
||||
*.sh text eol=lf
|
||||
*.py text eol=lf
|
||||
*.sql text eol=lf
|
||||
Dockerfile text eol=lf
|
||||
+8
-22
@@ -1,26 +1,12 @@
|
||||
# syntax=docker/dockerfile:1
|
||||
FROM python:3.11-slim-bookworm
|
||||
|
||||
FROM python:3.11.10-slim-bookworm
|
||||
WORKDIR /app
|
||||
|
||||
# Create non-root user
|
||||
# Приложение работает без прав root.
|
||||
RUN groupadd -r appuser && useradd -r -g appuser appuser
|
||||
|
||||
# Install dependencies first for layer caching
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
# Copy application source
|
||||
COPY src/ ./src/
|
||||
|
||||
# Switch to non-root user
|
||||
COPY requirements.lock.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.lock.txt
|
||||
COPY src/ src/
|
||||
COPY migrations/ migrations/
|
||||
USER appuser
|
||||
|
||||
# Healthcheck
|
||||
HEALTHCHECK --interval=30s --timeout=5s --start-period=5s --retries=3 \
|
||||
CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/live')" || exit 1
|
||||
|
||||
HEALTHCHECK --interval=5s --timeout=5s --start-period=15s --retries=5 CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready')"
|
||||
EXPOSE 8080
|
||||
|
||||
# Uvicorn handles SIGTERM gracefully (default timeout 10s)
|
||||
CMD ["python", "-m", "uvicorn", "src.app:app", "--host", "0.0.0.0", "--port", "8080", "--log-level", "info"]
|
||||
CMD ["sh", "-c", "python -m src.migrate && exec python -m uvicorn src.app:app --host 0.0.0.0 --port 8080 --timeout-graceful-shutdown 8"]
|
||||
|
||||
@@ -24,3 +24,10 @@ load:
|
||||
test-persistence:
|
||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
|
||||
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
.PHONY: student-test bootstrap
|
||||
bootstrap:
|
||||
$(PYTHON) scripts/bootstrap.py
|
||||
|
||||
student-test:
|
||||
$(PYTHON) student-tests/test_lab2.py --base-url "$(BASE_URL)"
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
name: lyakhonov-lab2
|
||||
services:
|
||||
db:
|
||||
image: postgres:16.6-alpine
|
||||
environment:
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/db_password
|
||||
secrets: [db_password]
|
||||
volumes: [postgres_data:/var/lib/postgresql/data]
|
||||
healthcheck:
|
||||
test: [CMD-SHELL, "pg_isready -U messenger -d messenger"]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 30
|
||||
cpus: 1
|
||||
mem_limit: 512m
|
||||
api:
|
||||
build: .
|
||||
image: lyakhonov-messenger:lab2
|
||||
environment:
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
secrets: [database_url]
|
||||
ports: ["127.0.0.1:8080:8080"]
|
||||
depends_on:
|
||||
db:
|
||||
condition: service_healthy
|
||||
cpus: 1
|
||||
mem_limit: 512m
|
||||
stop_grace_period: 10s
|
||||
secrets:
|
||||
db_password:
|
||||
file: ./secrets/db_password
|
||||
database_url:
|
||||
file: ./secrets/database_url
|
||||
volumes:
|
||||
postgres_data:
|
||||
@@ -0,0 +1,50 @@
|
||||
{
|
||||
"commands": [
|
||||
{
|
||||
"command": "python scripts/check_contract.py",
|
||||
"output": "PASS: offline skeleton structure, local refs and Python syntax; application NOT tested."
|
||||
},
|
||||
{
|
||||
"command": "python tests/smoke.py",
|
||||
"output": "PASS: lab2 public API scenario; infrastructure and grading evidence remain separate."
|
||||
},
|
||||
{
|
||||
"command": "python student-tests/test_lab2.py",
|
||||
"output": "PASS: strict validation, access, cursor binding, 100 messages / 10 clients, complete pagination"
|
||||
},
|
||||
{
|
||||
"command": "python tests/resilience.py --mode persistence --action-script scripts/restart.cmd",
|
||||
"output": "Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.\nPASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence."
|
||||
}
|
||||
],
|
||||
"before": [
|
||||
{
|
||||
"Name": "/lyakhonov-lab2-api-1",
|
||||
"RestartCount": 0,
|
||||
"started_at": "2026-10-09T11:15:56.676676381Z",
|
||||
"image": "lyakhonov-messenger:lab2"
|
||||
},
|
||||
{
|
||||
"Name": "/lyakhonov-lab2-db-1",
|
||||
"RestartCount": 0,
|
||||
"started_at": "2026-10-09T11:15:56.130807797Z",
|
||||
"image": "postgres:16.6-alpine"
|
||||
}
|
||||
],
|
||||
"after": [
|
||||
{
|
||||
"Name": "/lyakhonov-lab2-api-1",
|
||||
"RestartCount": 0,
|
||||
"started_at": "2026-10-09T11:16:33.449311224Z",
|
||||
"image": "lyakhonov-messenger:lab2"
|
||||
},
|
||||
{
|
||||
"Name": "/lyakhonov-lab2-db-1",
|
||||
"RestartCount": 0,
|
||||
"started_at": "2026-10-09T11:16:33.058063917Z",
|
||||
"image": "postgres:16.6-alpine"
|
||||
}
|
||||
],
|
||||
"migration_repeat": "PASS: repeated migration completed without applying migration twice",
|
||||
"migration_versions": "001_initial.sql"
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
# Схема PostgreSQL
|
||||
|
||||
Пользователь имеет уникальное имя и хеш Argon2id. Чат и строки участников создаются в одной транзакции; ошибка любого FK откатывает весь чат. Сообщение связано с чатом, отправителем и членством составным FK. Удаление данных через API отсутствует.
|
||||
|
||||
Сессия хранит SHA-256 случайного 256-битного токена и абсолютное время окончания; SHA-256 применяется к токену, а пароль обрабатывается Argon2id. Logout удаляет строку. Внешний API не возвращает хеши.
|
||||
|
||||
Индекс messages_history_idx (chat_id, created_at, id) обслуживает WHERE chat_id = ? AND (created_at,id) > (?,?) ORDER BY created_at,id LIMIT ?. Запрашиваются limit+1 строка, чтобы определить наличие следующей страницы. PostgreSQL timestamptz сохраняет микросекунды; UUID разрешает совпадения времени. Между страницами нет общего snapshot.
|
||||
|
||||
Миграции выполняются под advisory lock в транзакции; schema_migrations предотвращает повторное применение. Пул ограничен десятью подключениями и 32 ожидающими; получение подключения — 3 секунды, statement_timeout — 3 секунды, lock_timeout — 2 секунды.
|
||||
@@ -0,0 +1,33 @@
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username varchar(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
display_name varchar(100) NOT NULL CHECK (length(btrim(display_name)) > 0),
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title varchar(100) NOT NULL CHECK (length(btrim(title)) > 0),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats(id),
|
||||
user_id uuid NOT NULL REFERENCES users(id),
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats(id),
|
||||
sender_id uuid NOT NULL REFERENCES users(id),
|
||||
text varchar(4000) NOT NULL CHECK (length(btrim(text)) > 0),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members(chat_id, user_id)
|
||||
);
|
||||
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
|
||||
CREATE TABLE sessions (
|
||||
token_hash char(64) PRIMARY KEY,
|
||||
user_id uuid NOT NULL REFERENCES users(id),
|
||||
expires_at timestamptz NOT NULL
|
||||
);
|
||||
CREATE INDEX sessions_expiry_idx ON sessions (expires_at);
|
||||
@@ -0,0 +1,24 @@
|
||||
annotated-types==0.8.0
|
||||
anyio==4.15.1
|
||||
argon2-cffi==23.1.0
|
||||
argon2-cffi-bindings==26.1.0
|
||||
cffi==2.1.1
|
||||
click==8.5.0
|
||||
fastapi==0.115.0
|
||||
h11==0.16.0
|
||||
httptools==0.8.0
|
||||
idna==3.20
|
||||
psycopg==3.2.3
|
||||
psycopg-binary==3.2.3
|
||||
psycopg-pool==3.2.4
|
||||
pycparser==3.1
|
||||
pydantic==2.9.2
|
||||
pydantic_core==2.23.4
|
||||
python-dotenv==1.2.4
|
||||
PyYAML==6.0.3
|
||||
starlette==0.38.6
|
||||
typing_extensions==4.16.0
|
||||
uvicorn==0.32.0
|
||||
uvloop==0.23.0
|
||||
watchfiles==1.3.0
|
||||
websockets==17.2
|
||||
+3
-2
@@ -1,5 +1,6 @@
|
||||
fastapi==0.115.0
|
||||
uvicorn[standard]==0.32.0
|
||||
pydantic==2.9.2
|
||||
python-multipart==0.0.12
|
||||
matplotlib==3.9.2
|
||||
psycopg[binary]==3.2.3
|
||||
psycopg-pool==3.2.4
|
||||
argon2-cffi==23.1.0
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
"""Создать локальные секреты, не перезаписывая существующие."""
|
||||
from pathlib import Path
|
||||
import secrets
|
||||
|
||||
root = Path(__file__).resolve().parents[1]
|
||||
folder = root / 'secrets'
|
||||
folder.mkdir(exist_ok=True)
|
||||
password_file = folder / 'db_password'
|
||||
if not password_file.exists():
|
||||
password_file.write_text(secrets.token_hex(24), encoding='utf-8')
|
||||
url_file = folder / 'database_url'
|
||||
if not url_file.exists():
|
||||
password = password_file.read_text(encoding='utf-8').strip()
|
||||
url_file.write_text(f'postgresql://messenger:{password}@db:5432/messenger', encoding='utf-8')
|
||||
print('Локальные секреты готовы; значения не выводятся.')
|
||||
@@ -0,0 +1,3 @@
|
||||
@echo off␍
|
||||
cd /d "%~dp0.."␍
|
||||
docker compose restart db api␍
|
||||
Executable
+5
@@ -0,0 +1,5 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
# Перезапускаем реальные процессы, сохраняя именованные тома.
|
||||
docker compose restart db api
|
||||
+23
-2
@@ -1,4 +1,8 @@
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
import psycopg
|
||||
from psycopg_pool import PoolTimeout
|
||||
from starlette.concurrency import run_in_threadpool
|
||||
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
@@ -13,7 +17,24 @@ from src.storage import storage
|
||||
|
||||
def create_app() -> FastAPI:
|
||||
"""Создать и настроить приложение FastAPI."""
|
||||
app = FastAPI(title="MTUSI Messenger Lab1", version="1.1.0")
|
||||
@asynccontextmanager
|
||||
async def lifespan(app):
|
||||
await run_in_threadpool(storage.pool.open, wait=True)
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
await run_in_threadpool(storage.pool.close)
|
||||
|
||||
app = FastAPI(title="MTUSI Messenger Lab2", version="1.2.0", lifespan=lifespan)
|
||||
|
||||
@app.exception_handler(psycopg.OperationalError)
|
||||
@app.exception_handler(psycopg.errors.QueryCanceled)
|
||||
@app.exception_handler(PoolTimeout)
|
||||
async def dependency_error(request, exc):
|
||||
return JSONResponse(status_code=503, content=ErrorResponse(error={
|
||||
"code": "unavailable", "message": "хранилище временно недоступно",
|
||||
"request_id": request.state.request_id}).model_dump(),
|
||||
headers={"X-Request-Id": request.state.request_id})
|
||||
|
||||
@app.middleware("http")
|
||||
async def add_request_id(request: Request, call_next):
|
||||
@@ -50,7 +71,7 @@ def create_app() -> FastAPI:
|
||||
return JSONResponse(
|
||||
status_code=exc.status_code,
|
||||
content=exc.detail,
|
||||
headers={"X-Request-Id": request_id},
|
||||
headers={"X-Request-Id": request_id, **(exc.headers or {})},
|
||||
)
|
||||
return JSONResponse(
|
||||
status_code=exc.status_code,
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
"""Настройки окружения и чтение секретов из файлов."""
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
def setting(name, default=None):
|
||||
path = os.getenv(name + '_FILE')
|
||||
if path:
|
||||
return Path(path).read_text(encoding='utf-8').strip()
|
||||
return os.getenv(name, default)
|
||||
@@ -0,0 +1,19 @@
|
||||
"""Версионируемые миграции: одна транзакция, блокировка от параллельного запуска."""
|
||||
from pathlib import Path
|
||||
import psycopg
|
||||
from src.config import setting
|
||||
|
||||
|
||||
def main():
|
||||
with psycopg.connect(setting('DATABASE_URL'), connect_timeout=5) as conn:
|
||||
conn.execute('SELECT pg_advisory_xact_lock(2301002)')
|
||||
conn.execute('CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY)')
|
||||
for path in sorted(Path('/app/migrations' if Path('/app/migrations').exists() else 'migrations').glob('*.sql')):
|
||||
if not conn.execute('SELECT 1 FROM schema_migrations WHERE version=%s', (path.name,)).fetchone():
|
||||
conn.execute(path.read_text(encoding='utf-8'))
|
||||
conn.execute('INSERT INTO schema_migrations VALUES (%s)', (path.name,))
|
||||
print('Применена миграция:', path.name)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
+11
-3
@@ -1,5 +1,6 @@
|
||||
from datetime import datetime, timezone
|
||||
from typing import Optional
|
||||
import uuid
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field, field_validator
|
||||
|
||||
@@ -36,8 +37,9 @@ class User(BaseModel):
|
||||
|
||||
class CreateUser(BaseModel):
|
||||
"""Данные для создания пользователя."""
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
model_config = ConfigDict(extra="forbid", strict=True)
|
||||
|
||||
password: str = Field(..., min_length=12, max_length=128)
|
||||
username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$")
|
||||
display_name: str = Field(..., min_length=1, max_length=100)
|
||||
|
||||
@@ -60,11 +62,17 @@ class Chat(BaseModel):
|
||||
|
||||
class CreateChat(BaseModel):
|
||||
"""Данные для создания чата."""
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
model_config = ConfigDict(extra="forbid", strict=True)
|
||||
|
||||
title: str = Field(..., min_length=1, max_length=100)
|
||||
member_ids: list[str] = Field(..., min_length=1, max_length=100)
|
||||
|
||||
@field_validator("member_ids")
|
||||
@classmethod
|
||||
def valid_members(cls, values):
|
||||
"""Проверить UUID и привести их к единому представлению."""
|
||||
return [str(uuid.UUID(value)) for value in values]
|
||||
|
||||
@field_validator("title")
|
||||
@classmethod
|
||||
def title_not_whitespace_only(cls, v: str) -> str:
|
||||
@@ -85,7 +93,7 @@ class Message(BaseModel):
|
||||
|
||||
class CreateMessage(BaseModel):
|
||||
"""Данные для отправки сообщения."""
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
model_config = ConfigDict(extra="forbid", strict=True)
|
||||
|
||||
text: str = Field(..., min_length=1, max_length=4000)
|
||||
|
||||
|
||||
+6
-6
@@ -10,14 +10,14 @@ router = APIRouter()
|
||||
|
||||
|
||||
@router.post("/api/v1/chats", response_model=Chat, status_code=201)
|
||||
async def create_chat(
|
||||
def create_chat(
|
||||
request: Request,
|
||||
body: CreateChat,
|
||||
x_user_id: str | None = Header(None, alias="X-User-Id"),
|
||||
):
|
||||
"""Создать чат. Создатель обязательно должен входить в member_ids."""
|
||||
request_id = get_request_id(request)
|
||||
require_user(request, x_user_id)
|
||||
x_user_id = require_user(request)
|
||||
|
||||
try:
|
||||
chat = storage.create_chat(body.title, body.member_ids, x_user_id)
|
||||
@@ -35,7 +35,7 @@ async def create_chat(
|
||||
|
||||
|
||||
@router.get("/api/v1/chats", response_model=ChatPage)
|
||||
async def list_chats(
|
||||
def list_chats(
|
||||
request: Request,
|
||||
x_user_id: str | None = Header(None, alias="X-User-Id"),
|
||||
limit: int = 50,
|
||||
@@ -43,7 +43,7 @@ async def list_chats(
|
||||
):
|
||||
"""Список чатов текущего пользователя с курсорной пагинацией."""
|
||||
request_id = get_request_id(request)
|
||||
require_user(request, x_user_id)
|
||||
x_user_id = require_user(request)
|
||||
|
||||
if limit < 1 or limit > 100:
|
||||
raise HTTPException(
|
||||
@@ -62,14 +62,14 @@ async def list_chats(
|
||||
|
||||
|
||||
@router.get("/api/v1/chats/{chat_id}", response_model=Chat)
|
||||
async def get_chat(
|
||||
def get_chat(
|
||||
request: Request,
|
||||
chat_id: UUID,
|
||||
x_user_id: str | None = Header(None, alias="X-User-Id"),
|
||||
):
|
||||
"""Получить чат по id. Доступен только участникам чата (чужой — 404)."""
|
||||
request_id = get_request_id(request)
|
||||
require_user(request, x_user_id)
|
||||
x_user_id = require_user(request)
|
||||
|
||||
chat_id_str = str(chat_id)
|
||||
chat = storage.get_chat(chat_id_str)
|
||||
|
||||
+20
-28
@@ -1,37 +1,29 @@
|
||||
"""Общие утилиты для всех роутов API.
|
||||
|
||||
Вынесено сюда, чтобы не повторять в каждом файле роутов (DRY).
|
||||
"""
|
||||
"""Общие ошибки и проверка Bearer-сессии; X-User-Id не используется."""
|
||||
from fastapi import HTTPException, Request
|
||||
|
||||
from src.models import ErrorResponse
|
||||
from src.storage import storage
|
||||
|
||||
|
||||
def make_error(code: str, message: str, request_id: str) -> ErrorResponse:
|
||||
"""Собрать стандартный ответ об ошибке по контракту API."""
|
||||
return ErrorResponse(error={"code": code, "message": message, "request_id": request_id})
|
||||
def make_error(code, message, request_id):
|
||||
return ErrorResponse(error={'code': code, 'message': message, 'request_id': request_id})
|
||||
|
||||
|
||||
def get_request_id(request: Request) -> str:
|
||||
"""Достать X-Request-Id из middleware. Если нет — сгенерировать новый."""
|
||||
return getattr(request.state, "request_id", "") or str(id(request))
|
||||
def get_request_id(request):
|
||||
return request.state.request_id
|
||||
|
||||
|
||||
def require_user(request: Request, x_user_id: str | None) -> str:
|
||||
"""Проверить, что пользователь передал валидный X-User-Id.
|
||||
Возвращает user_id или выбрасывает HTTPException(401).
|
||||
"""
|
||||
request_id = get_request_id(request)
|
||||
if not x_user_id:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail=make_error("unauthorized", "отсутствует идентификатор пользователя", request_id).model_dump(),
|
||||
)
|
||||
user = storage.get_user(x_user_id)
|
||||
if not user:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail=make_error("unauthorized", "недействительный идентификатор пользователя", request_id).model_dump(),
|
||||
)
|
||||
return x_user_id
|
||||
def unauthorized(request, basic=False):
|
||||
challenge = 'Basic realm="messenger", charset="UTF-8"' if basic else 'Bearer realm="messenger"'
|
||||
raise HTTPException(401, detail=make_error('unauthorized', 'неверные учётные данные', get_request_id(request)).model_dump(), headers={'WWW-Authenticate': challenge})
|
||||
|
||||
|
||||
def require_user(request: Request, ignored=None):
|
||||
authorization = request.headers.get('Authorization', '')
|
||||
parts = authorization.split()
|
||||
if len(parts) != 2 or parts[0].lower() != 'bearer':
|
||||
unauthorized(request)
|
||||
user_id = storage.session_user(parts[1])
|
||||
if not user_id:
|
||||
unauthorized(request)
|
||||
request.state.token = parts[1]
|
||||
return user_id
|
||||
|
||||
+10
-19
@@ -1,30 +1,21 @@
|
||||
"""Жизнь процесса и готовность критичного хранилища проверяются отдельно."""
|
||||
from fastapi import APIRouter
|
||||
|
||||
from src.models import Health
|
||||
from src.storage import storage
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.get("/health/live")
|
||||
async def liveness() -> Health:
|
||||
"""Проверка жизни процесса. Всегда возвращает 200, если процесс работает."""
|
||||
return Health(status="ok")
|
||||
@router.get('/health/live')
|
||||
def liveness():
|
||||
return Health()
|
||||
|
||||
|
||||
@router.get("/health/ready")
|
||||
async def readiness() -> Health:
|
||||
"""Проверка готовности принимать трафик.
|
||||
|
||||
Для lab1 возвращает 200, так как нет внешних зависимостей.
|
||||
В следующих лабах здесь будет проверка БД и других сервисов.
|
||||
"""
|
||||
return Health(status="ok")
|
||||
@router.get('/health/ready')
|
||||
def readiness():
|
||||
storage.ready()
|
||||
return Health()
|
||||
|
||||
|
||||
@router.get("/stats")
|
||||
async def stats():
|
||||
"""Текущая статистика сервера: количество пользователей, чатов, сообщений,
|
||||
а также метрики rate limiting'а для наблюдения за деградацией.
|
||||
"""
|
||||
@router.get('/stats')
|
||||
def stats():
|
||||
return storage.get_stats()
|
||||
|
||||
@@ -10,7 +10,7 @@ router = APIRouter()
|
||||
|
||||
|
||||
@router.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=201)
|
||||
async def create_message(
|
||||
def create_message(
|
||||
request: Request,
|
||||
chat_id: UUID,
|
||||
body: CreateMessage,
|
||||
@@ -18,7 +18,7 @@ async def create_message(
|
||||
):
|
||||
"""Отправить сообщение в чат. Отправитель определяется по X-User-Id."""
|
||||
request_id = get_request_id(request)
|
||||
require_user(request, x_user_id)
|
||||
x_user_id = require_user(request)
|
||||
|
||||
chat_id_str = str(chat_id)
|
||||
chat = storage.get_chat(chat_id_str)
|
||||
@@ -39,7 +39,7 @@ async def create_message(
|
||||
|
||||
|
||||
@router.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage)
|
||||
async def list_messages(
|
||||
def list_messages(
|
||||
request: Request,
|
||||
chat_id: UUID,
|
||||
x_user_id: str | None = Header(None, alias="X-User-Id"),
|
||||
@@ -48,7 +48,7 @@ async def list_messages(
|
||||
):
|
||||
"""История сообщений чата с курсорной пагинацией. Доступно только участникам."""
|
||||
request_id = get_request_id(request)
|
||||
require_user(request, x_user_id)
|
||||
x_user_id = require_user(request)
|
||||
|
||||
chat_id_str = str(chat_id)
|
||||
chat = storage.get_chat(chat_id_str)
|
||||
|
||||
+40
-42
@@ -1,51 +1,49 @@
|
||||
from fastapi import APIRouter, Header, HTTPException, Request
|
||||
|
||||
"""Регистрация, вход, текущий пользователь и отзыв сессии."""
|
||||
import base64
|
||||
import binascii
|
||||
from fastapi import APIRouter, Request, Response, HTTPException
|
||||
from src.models import CreateUser, User
|
||||
from src.routes.common import get_request_id, make_error
|
||||
from src.storage import ConflictError, LimitExceeded, storage
|
||||
from src.routes.common import get_request_id, make_error, require_user, unauthorized
|
||||
from src.storage import ConflictError, storage
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.post("/api/v1/users", response_model=User, status_code=201)
|
||||
async def register_user(request: Request, body: CreateUser):
|
||||
"""Создать нового пользователя. Публичный endpoint, не требует авторизации."""
|
||||
request_id = get_request_id(request)
|
||||
@router.post('/api/v1/users', response_model=User, status_code=201)
|
||||
def register_user(request: Request, body: CreateUser):
|
||||
try:
|
||||
user = storage.create_user(body.username, body.display_name)
|
||||
return user
|
||||
except ConflictError as e:
|
||||
raise HTTPException(
|
||||
status_code=409,
|
||||
detail=make_error("conflict", str(e), request_id).model_dump(),
|
||||
)
|
||||
except LimitExceeded as e:
|
||||
raise HTTPException(
|
||||
status_code=429,
|
||||
detail=make_error("rate_limited", str(e), request_id).model_dump(),
|
||||
)
|
||||
return storage.create_user(body.username,body.display_name,body.password)
|
||||
except ConflictError as exc:
|
||||
raise HTTPException(409,detail=make_error('conflict',str(exc),get_request_id(request)).model_dump())
|
||||
|
||||
|
||||
@router.get("/api/v1/users/me", response_model=User)
|
||||
async def current_user(
|
||||
request: Request,
|
||||
x_user_id: str | None = Header(None, alias="X-User-Id"),
|
||||
):
|
||||
"""Получить текущего пользователя по заголовку X-User-Id.
|
||||
@router.post('/api/v1/auth/sessions', status_code=201)
|
||||
async def login(request: Request):
|
||||
if await request.body():
|
||||
raise HTTPException(400, detail=make_error('invalid_request','тело запроса не допускается',get_request_id(request)).model_dump())
|
||||
parts = request.headers.get('Authorization','').split()
|
||||
try:
|
||||
if len(parts) != 2 or parts[0].lower() != 'basic':
|
||||
unauthorized(request, basic=True)
|
||||
username,password = base64.b64decode(parts[1],validate=True).decode('utf-8').split(':',1)
|
||||
username.encode('ascii')
|
||||
except (ValueError, UnicodeError, binascii.Error):
|
||||
unauthorized(request,basic=True)
|
||||
# Вычисление KDF и синхронные запросы выполняются вне цикла событий.
|
||||
from starlette.concurrency import run_in_threadpool
|
||||
result = await run_in_threadpool(storage.login,username,password)
|
||||
if not result:
|
||||
unauthorized(request,basic=True)
|
||||
return result
|
||||
|
||||
Это учебный механизм: любой клиент может выдать себя за другого,
|
||||
зная UUID пользователя. Настоящая аутентификация появится позже.
|
||||
"""
|
||||
request_id = get_request_id(request)
|
||||
if not x_user_id:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail=make_error("unauthorized", "отсутствует идентификатор пользователя", request_id).model_dump(),
|
||||
)
|
||||
user = storage.get_user(x_user_id)
|
||||
if not user:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail=make_error("unauthorized", "недействительный идентификатор пользователя", request_id).model_dump(),
|
||||
)
|
||||
return user
|
||||
|
||||
@router.get('/api/v1/users/me',response_model=User)
|
||||
def current_user(request: Request):
|
||||
return storage.get_user(require_user(request))
|
||||
|
||||
|
||||
@router.delete('/api/v1/auth/sessions/current',status_code=204)
|
||||
def logout(request: Request):
|
||||
require_user(request)
|
||||
storage.logout(request.state.token)
|
||||
return Response(status_code=204)
|
||||
|
||||
+145
-253
@@ -1,55 +1,60 @@
|
||||
"""PostgreSQL — источник истины; каждый контекст подключения завершает транзакцию."""
|
||||
import base64
|
||||
import binascii
|
||||
from datetime import datetime
|
||||
from datetime import datetime, timezone
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import secrets
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from src.models import Chat, Message, User, utc_now
|
||||
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import VerifyMismatchError, VerificationError, InvalidHashError
|
||||
from psycopg.errors import UniqueViolation, ForeignKeyViolation
|
||||
from psycopg.rows import dict_row
|
||||
from psycopg_pool import ConnectionPool
|
||||
from src.config import setting
|
||||
from src.models import User, Chat, Message
|
||||
|
||||
_CURSOR_FIELDS = {"scope", "resource_id", "created_at", "id"}
|
||||
PASSWORDS = PasswordHasher()
|
||||
DUMMY_HASH = PASSWORDS.hash('synthetic-dummy-password')
|
||||
|
||||
|
||||
class StorageLimits:
|
||||
"""Лимиты хранилища для защиты от перегрузки (трек 2)."""
|
||||
class ValidationError(Exception):
|
||||
"""Неверный запрос."""
|
||||
|
||||
|
||||
class ConflictError(Exception):
|
||||
"""Имя уже занято."""
|
||||
|
||||
|
||||
class LimitExceeded(Exception):
|
||||
"""Перегрузка сервера."""
|
||||
|
||||
|
||||
class NotFoundError(Exception):
|
||||
"""Объект отсутствует или недоступен."""
|
||||
|
||||
|
||||
def timestamp(value):
|
||||
return value.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z')
|
||||
|
||||
|
||||
def public_row(row):
|
||||
return {k: timestamp(v) if isinstance(v, datetime) else str(v) if isinstance(v, uuid.UUID) else v
|
||||
for k, v in row.items() if k != 'password_hash'}
|
||||
|
||||
|
||||
class PostgresStorage:
|
||||
def __init__(self):
|
||||
self.max_users = int(os.getenv("MAX_USERS", "1000"))
|
||||
self.max_chats = int(os.getenv("MAX_CHATS", "1000"))
|
||||
self.max_messages_total = int(os.getenv("MAX_MESSAGES", "10000"))
|
||||
self.max_messages_per_chat = int(os.getenv("MAX_MESSAGES_PER_CHAT", "1000"))
|
||||
self.max_request_queue = int(os.getenv("MAX_REQUEST_QUEUE", "100"))
|
||||
self.max_messages_per_second = float(os.getenv("MAX_MESSAGES_PER_SECOND", "10.0"))
|
||||
|
||||
|
||||
class InMemoryStorage:
|
||||
"""Хранилище данных в оперативной памяти.
|
||||
|
||||
Все данные живут внутри одного процесса и исчезают при перезапуске.
|
||||
Это требование текущей лабораторной — научиться работать с контейнерами
|
||||
без внешних баз данных.
|
||||
|
||||
Для защиты от гонок используется threading.RLock.
|
||||
"""
|
||||
def __init__(self):
|
||||
self._users: dict[str, User] = {}
|
||||
self._users_by_username: dict[str, str] = {}
|
||||
self._chats: dict[str, Chat] = {}
|
||||
self._messages: dict[str, Message] = {}
|
||||
self._chat_messages: dict[str, list[str]] = {}
|
||||
self._lock = threading.RLock()
|
||||
self._limits = StorageLimits()
|
||||
self._request_count = 0
|
||||
|
||||
# Token bucket для ограничения сообщений в секунду (трек 2)
|
||||
self._message_tokens = self._limits.max_messages_per_second
|
||||
self._last_token_update = time.monotonic()
|
||||
|
||||
# Метрики для наблюдения за деградацией
|
||||
self._rate_limited_count = 0
|
||||
self._total_message_attempts = 0
|
||||
self.pool = ConnectionPool(setting('DATABASE_URL', ''), min_size=1, max_size=10,
|
||||
timeout=3, max_waiting=32, open=False, check=ConnectionPool.check_connection,
|
||||
kwargs={'row_factory': dict_row, 'connect_timeout': 3,
|
||||
'options': '-c statement_timeout=3000 -c lock_timeout=2000'})
|
||||
self._lock = threading.Lock()
|
||||
self._requests = 0
|
||||
|
||||
@staticmethod
|
||||
def _encode_cursor(scope: str, resource_id: str, created_at: str, item_id: str) -> str:
|
||||
@@ -95,245 +100,132 @@ class InMemoryStorage:
|
||||
try:
|
||||
uuid.UUID(payload["resource_id"])
|
||||
uuid.UUID(payload["id"])
|
||||
datetime.strptime(payload["created_at"], "%Y-%m-%dT%H:%M:%SZ")
|
||||
datetime.fromisoformat(payload["created_at"].replace("Z", "+00:00"))
|
||||
except ValueError:
|
||||
raise ValidationError("некорректный cursor")
|
||||
|
||||
return payload["created_at"], payload["id"]
|
||||
|
||||
# --- Пользователи ---
|
||||
|
||||
def create_user(self, username: str, display_name: str) -> User:
|
||||
"""Создать пользователя. Проверяет лимит и уникальность username."""
|
||||
with self._lock:
|
||||
if len(self._users) >= self._limits.max_users:
|
||||
raise LimitExceeded("превышен лимит пользователей")
|
||||
if username in self._users_by_username:
|
||||
raise ConflictError(f"username '{username}' уже занят")
|
||||
def create_user(self, username, display_name, password):
|
||||
password_hash = PASSWORDS.hash(password)
|
||||
try:
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute('INSERT INTO users (id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING id,username,display_name,created_at',
|
||||
(uuid.uuid4(), username, display_name, password_hash)).fetchone()
|
||||
return User(**public_row(row))
|
||||
except UniqueViolation:
|
||||
raise ConflictError('имя пользователя уже занято') from None
|
||||
|
||||
user = User(
|
||||
id=str(uuid.uuid4()),
|
||||
username=username,
|
||||
display_name=display_name,
|
||||
created_at=utc_now(),
|
||||
)
|
||||
self._users[user.id] = user
|
||||
self._users_by_username[user.username] = user.id
|
||||
return user
|
||||
def get_user(self, user_id):
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute('SELECT id,username,display_name,created_at FROM users WHERE id=%s', (user_id,)).fetchone()
|
||||
return User(**public_row(row)) if row else None
|
||||
|
||||
def get_user(self, user_id: str) -> User | None:
|
||||
"""Найти пользователя по UUID."""
|
||||
with self._lock:
|
||||
return self._users.get(user_id)
|
||||
def login(self, username, password):
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute('SELECT * FROM users WHERE username=%s', (username,)).fetchone()
|
||||
try:
|
||||
PASSWORDS.verify(row['password_hash'] if row else DUMMY_HASH, password)
|
||||
except (VerifyMismatchError, VerificationError, InvalidHashError):
|
||||
return None
|
||||
if not row:
|
||||
return None
|
||||
token = secrets.token_urlsafe(32)
|
||||
with self.pool.connection() as conn:
|
||||
session = conn.execute("INSERT INTO sessions VALUES (%s,%s,clock_timestamp() + %s * interval '1 second') RETURNING expires_at",
|
||||
(self.token_hash(token), row['id'], int(os.getenv('SESSION_TTL_SECONDS', '3600')))).fetchone()
|
||||
return {'token': token, 'token_type': 'Bearer', 'expires_at': timestamp(session['expires_at']), 'user': User(**public_row(row)).model_dump()}
|
||||
|
||||
# --- Чаты ---
|
||||
@staticmethod
|
||||
def token_hash(token):
|
||||
return hashlib.sha256(token.encode()).hexdigest()
|
||||
|
||||
def create_chat(self, title: str, member_ids: list[str], creator_id: str) -> Chat:
|
||||
"""Создать чат. Проверяет существование участников и лимиты."""
|
||||
with self._lock:
|
||||
if len(self._chats) >= self._limits.max_chats:
|
||||
raise LimitExceeded("превышен лимит чатов")
|
||||
def session_user(self, token):
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute('SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at > clock_timestamp()', (self.token_hash(token),)).fetchone()
|
||||
return str(row['user_id']) if row else None
|
||||
|
||||
seen = set()
|
||||
for mid in member_ids:
|
||||
if mid not in self._users:
|
||||
raise ValidationError(f"пользователь {mid} не существует")
|
||||
if mid in seen:
|
||||
raise ValidationError("дублирующиеся member_ids")
|
||||
seen.add(mid)
|
||||
def logout(self, token):
|
||||
with self.pool.connection() as conn:
|
||||
conn.execute('DELETE FROM sessions WHERE token_hash=%s', (self.token_hash(token),))
|
||||
|
||||
if creator_id not in seen:
|
||||
raise ValidationError("создатель должен входить в member_ids")
|
||||
def create_chat(self, title, member_ids, creator_id):
|
||||
if len(set(member_ids)) != len(member_ids) or creator_id not in member_ids:
|
||||
raise ValidationError('неверный список участников')
|
||||
chat_id = uuid.uuid4()
|
||||
try:
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute('INSERT INTO chats (id,title) VALUES (%s,%s) RETURNING *', (chat_id,title)).fetchone()
|
||||
for member in member_ids:
|
||||
conn.execute('INSERT INTO chat_members VALUES (%s,%s)', (chat_id,member))
|
||||
return Chat(**public_row(row), member_ids=sorted(member_ids))
|
||||
except ForeignKeyViolation:
|
||||
raise ValidationError('участник не существует') from None
|
||||
|
||||
chat = Chat(
|
||||
id=str(uuid.uuid4()),
|
||||
title=title,
|
||||
member_ids=member_ids,
|
||||
created_at=utc_now(),
|
||||
)
|
||||
self._chats[chat.id] = chat
|
||||
self._chat_messages[chat.id] = []
|
||||
return chat
|
||||
|
||||
def get_chat(self, chat_id: str) -> Chat | None:
|
||||
"""Найти чат по UUID."""
|
||||
with self._lock:
|
||||
return self._chats.get(chat_id)
|
||||
|
||||
def list_chats_for_user(self, user_id: str, cursor: str | None, limit: int) -> tuple[list[Chat], str | None]:
|
||||
"""Список чатов пользователя с курсорной пагинацией."""
|
||||
with self._lock:
|
||||
chats = [
|
||||
chat for chat in self._chats.values()
|
||||
if user_id in chat.member_ids
|
||||
]
|
||||
chats.sort(key=lambda c: (c.created_at, c.id))
|
||||
def get_chat(self, chat_id):
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute('SELECT * FROM chats WHERE id=%s', (chat_id,)).fetchone()
|
||||
if not row:
|
||||
return None
|
||||
members = conn.execute('SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id', (chat_id,)).fetchall()
|
||||
return Chat(**public_row(row), member_ids=[str(x['user_id']) for x in members])
|
||||
|
||||
def list_chats_for_user(self, user_id, cursor, limit):
|
||||
with self.pool.connection() as conn:
|
||||
params = [user_id]
|
||||
boundary = ''
|
||||
if cursor is not None:
|
||||
cursor_time, cursor_id = self._decode_cursor(cursor, "chats", user_id)
|
||||
cursor_chat = self._chats.get(cursor_id)
|
||||
if (
|
||||
cursor_chat is None
|
||||
or user_id not in cursor_chat.member_ids
|
||||
or cursor_chat.created_at != cursor_time
|
||||
):
|
||||
raise ValidationError("некорректный cursor")
|
||||
chats = [
|
||||
c for c in chats
|
||||
if (c.created_at, c.id) > (cursor_time, cursor_id)
|
||||
]
|
||||
when, item = self._decode_cursor(cursor, 'chats', user_id)
|
||||
marker = conn.execute('SELECT c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE c.id=%s AND m.user_id=%s', (item,user_id)).fetchone()
|
||||
if not marker or timestamp(marker['created_at']) != when:
|
||||
raise ValidationError('некорректный cursor')
|
||||
boundary = ' AND (c.created_at,c.id) > (%s,%s)'
|
||||
params += [when,item]
|
||||
rows = conn.execute('SELECT c.* FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s' + boundary + ' ORDER BY c.created_at,c.id LIMIT %s', params+[limit+1]).fetchall()
|
||||
page = [self.get_chat(str(row['id'])) for row in rows[:limit]]
|
||||
next_cursor = self._encode_cursor('chats',user_id,page[-1].created_at,page[-1].id) if len(rows)>limit else None
|
||||
return page,next_cursor
|
||||
|
||||
page = chats[:limit]
|
||||
next_cursor = None
|
||||
if len(page) == limit and len(chats) > limit:
|
||||
last = page[-1]
|
||||
next_cursor = self._encode_cursor("chats", user_id, last.created_at, last.id)
|
||||
|
||||
return page, next_cursor
|
||||
|
||||
# --- Сообщения ---
|
||||
|
||||
def _refill_message_tokens(self):
|
||||
"""Пополнить токены bucket'а пропорционально прошедшему времени."""
|
||||
now = time.monotonic()
|
||||
elapsed = now - self._last_token_update
|
||||
if elapsed > 0:
|
||||
self._message_tokens = min(
|
||||
self._limits.max_messages_per_second,
|
||||
self._message_tokens + elapsed * self._limits.max_messages_per_second,
|
||||
)
|
||||
self._last_token_update = now
|
||||
|
||||
def acquire_message_token(self) -> bool:
|
||||
"""Попытаться взять токен из bucket'а для отправки сообщения.
|
||||
|
||||
Возвращает True, если токен есть и сообщение можно отправить.
|
||||
False означает превышение rate limit → 429.
|
||||
"""
|
||||
with self._lock:
|
||||
self._total_message_attempts += 1
|
||||
self._refill_message_tokens()
|
||||
if self._message_tokens >= 1.0:
|
||||
self._message_tokens -= 1.0
|
||||
return True
|
||||
self._rate_limited_count += 1
|
||||
return False
|
||||
|
||||
def create_message(self, chat_id: str, sender_id: str, text: str) -> Message:
|
||||
"""Отправить сообщение. Проверяет лимиты и права доступа."""
|
||||
with self._lock:
|
||||
chat = self._chats.get(chat_id)
|
||||
if not chat:
|
||||
raise NotFoundError("чат не найден")
|
||||
if sender_id not in chat.member_ids:
|
||||
raise NotFoundError("чат не найден")
|
||||
|
||||
chat_msg_ids = self._chat_messages.get(chat_id, [])
|
||||
if len(chat_msg_ids) >= self._limits.max_messages_per_chat:
|
||||
raise LimitExceeded("превышен лимит сообщений в чате")
|
||||
if len(self._messages) >= self._limits.max_messages_total:
|
||||
raise LimitExceeded("превышен общий лимит сообщений")
|
||||
|
||||
# Проверяем rate limit (сообщений в секунду)
|
||||
if not self.acquire_message_token():
|
||||
raise LimitExceeded("превышен лимит сообщений в секунду")
|
||||
|
||||
msg = Message(
|
||||
id=str(uuid.uuid4()),
|
||||
chat_id=chat_id,
|
||||
sender_id=sender_id,
|
||||
text=text,
|
||||
created_at=utc_now(),
|
||||
)
|
||||
self._messages[msg.id] = msg
|
||||
chat_msg_ids.append(msg.id)
|
||||
return msg
|
||||
|
||||
def list_messages(self, chat_id: str, cursor: str | None, limit: int) -> tuple[list[Message], str | None]:
|
||||
"""История сообщений чата с курсорной пагинацией."""
|
||||
with self._lock:
|
||||
chat_msg_ids = self._chat_messages.get(chat_id, [])
|
||||
messages = [self._messages[mid] for mid in chat_msg_ids]
|
||||
messages.sort(key=lambda m: (m.created_at, m.id))
|
||||
def create_message(self, chat_id, sender_id, text):
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute('INSERT INTO messages (id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING *', (uuid.uuid4(),chat_id,sender_id,text)).fetchone()
|
||||
return Message(**public_row(row))
|
||||
|
||||
def list_messages(self, chat_id, cursor, limit):
|
||||
with self.pool.connection() as conn:
|
||||
params = [chat_id]
|
||||
boundary = ''
|
||||
if cursor is not None:
|
||||
cursor_time, cursor_id = self._decode_cursor(cursor, "messages", chat_id)
|
||||
cursor_message = self._messages.get(cursor_id)
|
||||
if (
|
||||
cursor_message is None
|
||||
or cursor_message.chat_id != chat_id
|
||||
or cursor_message.created_at != cursor_time
|
||||
):
|
||||
raise ValidationError("некорректный cursor")
|
||||
messages = [
|
||||
m for m in messages
|
||||
if (m.created_at, m.id) > (cursor_time, cursor_id)
|
||||
]
|
||||
when,item = self._decode_cursor(cursor,'messages',chat_id)
|
||||
marker = conn.execute('SELECT created_at FROM messages WHERE id=%s AND chat_id=%s', (item,chat_id)).fetchone()
|
||||
if not marker or timestamp(marker['created_at']) != when:
|
||||
raise ValidationError('некорректный cursor')
|
||||
boundary = ' AND (created_at,id) > (%s,%s)'
|
||||
params += [when,item]
|
||||
rows = conn.execute('SELECT * FROM messages WHERE chat_id=%s' + boundary + ' ORDER BY created_at,id LIMIT %s', params+[limit+1]).fetchall()
|
||||
page = [Message(**public_row(row)) for row in rows[:limit]]
|
||||
next_cursor = self._encode_cursor('messages',chat_id,page[-1].created_at,page[-1].id) if len(rows)>limit else None
|
||||
return page,next_cursor
|
||||
|
||||
page = messages[:limit]
|
||||
next_cursor = None
|
||||
if len(page) == limit and len(messages) > limit:
|
||||
last = page[-1]
|
||||
next_cursor = self._encode_cursor("messages", chat_id, last.created_at, last.id)
|
||||
def ready(self):
|
||||
with self.pool.connection() as conn:
|
||||
conn.execute('SELECT 1 FROM schema_migrations LIMIT 1')
|
||||
|
||||
return page, next_cursor
|
||||
|
||||
# --- Очередь запросов (трек 2: управляемая деградация) ---
|
||||
|
||||
def acquire_request_slot(self) -> bool:
|
||||
"""Занять слот в очереди запросов. False = переполнение → 503."""
|
||||
def acquire_request_slot(self):
|
||||
with self._lock:
|
||||
if self._request_count >= self._limits.max_request_queue:
|
||||
if self._requests >= 100:
|
||||
return False
|
||||
self._request_count += 1
|
||||
self._requests += 1
|
||||
return True
|
||||
|
||||
def release_request_slot(self):
|
||||
"""Освободить слот в очереди запросов."""
|
||||
with self._lock:
|
||||
self._request_count = max(0, self._request_count - 1)
|
||||
self._requests -= 1
|
||||
|
||||
# --- Статистика ---
|
||||
|
||||
def get_stats(self) -> dict:
|
||||
"""Текущая статистика хранилища и метрики деградации."""
|
||||
with self._lock:
|
||||
self._refill_message_tokens()
|
||||
return {
|
||||
"users": len(self._users),
|
||||
"chats": len(self._chats),
|
||||
"messages": len(self._messages),
|
||||
"requests_in_flight": self._request_count,
|
||||
"rate_limit": {
|
||||
"max_messages_per_second": self._limits.max_messages_per_second,
|
||||
"available_tokens": round(self._message_tokens, 2),
|
||||
},
|
||||
"metrics": {
|
||||
"total_message_attempts": self._total_message_attempts,
|
||||
"rate_limited_count": self._rate_limited_count,
|
||||
},
|
||||
}
|
||||
def get_stats(self):
|
||||
with self.pool.connection() as conn:
|
||||
return {table: conn.execute('SELECT count(*) AS n FROM '+table).fetchone()['n'] for table in ('users','chats','messages')}
|
||||
|
||||
|
||||
class ValidationError(Exception):
|
||||
"""Неверные входные данные — HTTP 400."""
|
||||
pass
|
||||
|
||||
|
||||
class NotFoundError(Exception):
|
||||
"""Ресурс не найден или недоступен — HTTP 404."""
|
||||
pass
|
||||
|
||||
|
||||
class ConflictError(Exception):
|
||||
"""Конфликт, например дублирующийся username — HTTP 409."""
|
||||
pass
|
||||
|
||||
|
||||
class LimitExceeded(Exception):
|
||||
"""Превышен лимит ресурсов — HTTP 429 или 503."""
|
||||
pass
|
||||
|
||||
|
||||
# Единственное хранилище на весь процесс
|
||||
storage = InMemoryStorage()
|
||||
storage = PostgresStorage()
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
# Собственные проверки лабораторной 2
|
||||
Исходные test_lab1.py, test_degradation.py и metrics_collector.py перенесены как история реализации lab1 и не являются проверками lab2: в них используется X-User-Id. Актуальные проверки lab2 описаны в REPORT.md.
|
||||
@@ -0,0 +1,43 @@
|
||||
"""Негативные сценарии, курсоры и конкурентная запись через реальный HTTP API."""
|
||||
import concurrent.futures
|
||||
import sys
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
from urllib.parse import quote
|
||||
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'tests'))
|
||||
from client import Client, arguments, check, run
|
||||
|
||||
|
||||
def main():
|
||||
args=arguments('Собственные проверки лабораторной 2')
|
||||
c=Client(args.base_url,args.ca_file)
|
||||
alice,bob,eve,chat=c.bootstrap()
|
||||
path='/api/v1/chats/'+chat['id']+'/messages'
|
||||
c.call('POST','/api/v1/users',400,body={'username':'short','display_name':'Тест','password':'short'})
|
||||
c.call('POST',path,400,actor=alice,body={'text':'hello','sender_id':bob['id']})
|
||||
c.call('POST',path,400,actor=alice,body={'text':' '})
|
||||
c.call('GET','/api/v1/chats/not-a-uuid',400,actor=alice)
|
||||
c.call('POST',path,404,actor=eve,body={'text':'чужое'})
|
||||
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as pool:
|
||||
sent=list(pool.map(lambda i: c.message(alice,chat,'Параллельное '+str(i))['json'],range(100)))
|
||||
expected={m['id'] for m in sent}
|
||||
received=[]
|
||||
cursor=None
|
||||
while True:
|
||||
url=path+'?limit=7'+('&cursor='+quote(cursor,safe='') if cursor else '')
|
||||
page=c.call('GET',url,actor=bob,schema='MessagePage')['json']
|
||||
received.extend(m['id'] for m in page['items'])
|
||||
cursor=page['next_cursor']
|
||||
if cursor is None:
|
||||
break
|
||||
check(len(received)==100 and set(received)==expected,'потеря или дубликат сообщения')
|
||||
page=c.call('GET',path+'?limit=1',actor=alice,schema='MessagePage')['json']
|
||||
other=c.call('POST','/api/v1/chats',201,actor=alice,body={'title':'Другой','member_ids':[alice['id']]},schema='Chat')['json']
|
||||
c.call('GET','/api/v1/chats/'+other['id']+'/messages?cursor='+quote(page['next_cursor'],safe=''),400,actor=alice)
|
||||
for bad in ['', 'not-base64', 'e30=']:
|
||||
c.call('GET',path+'?cursor='+quote(bad,safe=''),400,actor=alice)
|
||||
print('PASS: strict validation, access, cursor binding, 100 messages / 10 clients, complete pagination')
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
run(main)
|
||||
Reference in New Issue
Block a user