Реализовал уровень 3: PostgreSQL, пароли и сохраняемые сессии

This commit is contained in:
2026-10-09 14:16:37 +03:00
parent 6e19f1d9f0
commit 6fba9410d5
24 changed files with 532 additions and 381 deletions
+4
View File
@@ -0,0 +1,4 @@
*.sh text eol=lf
*.py text eol=lf
*.sql text eol=lf
Dockerfile text eol=lf
+8 -22
View File
@@ -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"]
+7
View File
@@ -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)"
+38
View File
@@ -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:
+50
View File
@@ -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"
}
+9
View File
@@ -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 секунды.
+33
View File
@@ -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);
+24
View File
@@ -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
View File
@@ -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
+15
View File
@@ -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('Локальные секреты готовы; значения не выводятся.')
+3
View File
@@ -0,0 +1,3 @@
@echo off␍
cd /d "%~dp0.."␍
docker compose restart db api␍
+5
View File
@@ -0,0 +1,5 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
# Перезапускаем реальные процессы, сохраняя именованные тома.
docker compose restart db api
+23 -2
View File
@@ -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,
+10
View File
@@ -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)
+19
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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()
+4 -4
View File
@@ -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
View File
@@ -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
View File
@@ -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()
+2
View File
@@ -0,0 +1,2 @@
# Собственные проверки лабораторной 2
Исходные test_lab1.py, test_degradation.py и metrics_collector.py перенесены как история реализации lab1 и не являются проверками lab2: в них используется X-User-Id. Актуальные проверки lab2 описаны в REPORT.md.
+43
View File
@@ -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)