Add first lab code

This commit is contained in:
2026-10-09 14:57:52 +03:00
parent 65003b6119
commit d9fe67a8ce
24 changed files with 1040 additions and 9 deletions
View File
+13
View File
@@ -0,0 +1,13 @@
import os
import uvicorn
if __name__ == '__main__':
uvicorn.run(
'src.main:app',
host=os.getenv('APP_HOST', '0.0.0.0'),
port=int(os.getenv('APP_PORT', '8080')),
workers=1,
timeout_graceful_shutdown=5,
)
+27
View File
@@ -0,0 +1,27 @@
from typing import Optional
from fastapi import Header, Query
from .errors import APIError
from .store import store
def page_limit(limit: str = Query(default="50")) -> int:
if not limit.isascii() or not limit.isdecimal() or len(limit) > 3:
raise APIError(400, "invalid_request", "Неверный limit")
number = int(limit)
if not 1 <= number <= 100:
raise APIError(400, "invalid_request", "Неверный limit")
return number
def current_user(x_user_id: Optional[str] = Header(default=None, alias="X-User-Id")) -> dict:
if not x_user_id:
raise APIError(401, "unauthorized", "Нет действительной идентификации")
try:
return store.require_user(x_user_id)
except APIError as exc:
if exc.status_code == 400:
raise APIError(401, "unauthorized", "Нет действительной идентификации") from exc
raise
+50
View File
@@ -0,0 +1,50 @@
from fastapi import Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from starlette.exceptions import HTTPException as StarletteHTTPException
class APIError(Exception):
def __init__(self, status_code: int, code: str, message: str):
self.status_code = status_code
self.code = code
self.message = message
def error_response(request: Request, status_code: int, code: str, message: str) -> JSONResponse:
request_id = getattr(request.state, "request_id", "")
return JSONResponse(
status_code=status_code,
headers={"X-Request-Id": request_id},
content={
"error": {
"code": code,
"message": message,
"request_id": request_id,
}
},
)
def api_error_handler(request: Request, exc: APIError) -> JSONResponse:
response = error_response(request, exc.status_code, exc.code, exc.message)
if exc.status_code == 429:
response.headers['Retry-After'] = '1'
return response
def validation_error_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
return error_response(request, 400, "invalid_request", "Неверный запрос")
def http_error_handler(request: Request, exc: StarletteHTTPException) -> JSONResponse:
if exc.status_code == 404:
return error_response(request, 404, "not_found", "Объект не найден")
if exc.status_code == 405:
return error_response(request, 400, "invalid_request", "Метод не поддерживается")
else:
return error_response(request, exc.status_code, "invalid_request", "Неверный запрос")
def internal_error_handler(request: Request, exc: Exception) -> JSONResponse:
return error_response(request, 500, "internal_error", "Внутренняя ошибка")
+95
View File
@@ -0,0 +1,95 @@
import asyncio
import os
from dataclasses import dataclass
from starlette.requests import Request
from .errors import error_response
@dataclass(frozen=True)
class Limits:
max_users: int = 1000
max_chats: int = 1000
max_messages: int = 10000
max_text_bytes: int = 16 * 1024 * 1024
max_request_bytes: int = 64 * 1024
max_inflight: int = 32
message_rate: int = 1000
message_burst: int = 1000
@classmethod
def from_env(cls):
values = {}
for name, default in cls().__dict__.items():
value = int(os.getenv(name.upper(), str(default)))
if value < 1:
raise ValueError(f'{name.upper()} must be positive')
values[name] = value
return cls(**values)
limits = Limits.from_env()
class ResourceLimitMiddleware:
def __init__(self, app, settings=limits):
self.app = app
self.settings = settings
self.active = 0
async def __call__(self, scope, receive, send):
if scope['type'] != 'http' or scope['path'].startswith('/health/'):
return await self.app(scope, receive, send)
request = Request(scope)
async def reject(status, code, message):
response = error_response(request, status, code, message)
if status == 503:
response.headers['Retry-After'] = '1'
await response(scope, receive, send)
if self.active >= self.settings.max_inflight:
return await reject(503, 'unavailable', 'Слишком много одновременных запросов')
self.active += 1
try:
length = request.headers.get('content-length')
if length is not None:
try:
size = int(length)
if size < 0:
raise ValueError()
except ValueError:
return await reject(400, 'invalid_request', 'Неверный Content-Length')
if size > self.settings.max_request_bytes:
return await reject(413, 'payload_too_large', 'Тело запроса слишком большое')
body = bytearray()
try:
async with asyncio.timeout(5):
while True:
message = await receive()
if message['type'] == 'http.disconnect':
return
chunk = message.get('body', b'')
if len(body) + len(chunk) > self.settings.max_request_bytes:
return await reject(413, 'payload_too_large', 'Тело запроса слишком большое')
body.extend(chunk)
if not message.get('more_body', False):
break
except TimeoutError:
return await reject(503, 'unavailable', 'Истекло время чтения запроса')
delivered = False
async def buffered_receive():
nonlocal delivered
if not delivered:
delivered = True
return {'type': 'http.request', 'body': bytes(body), 'more_body': False}
return await receive()
await self.app(scope, buffered_receive, send)
finally:
self.active -= 1
+22
View File
@@ -0,0 +1,22 @@
from fastapi import FastAPI
from fastapi.exceptions import RequestValidationError
from starlette.exceptions import HTTPException
from .errors import APIError, api_error_handler, validation_error_handler, http_error_handler, internal_error_handler
from .middleware import RequestIdMiddleware
from .limits import ResourceLimitMiddleware
from .routers.health import router as health_router
from .routers.users import router as users_router
from .routers.chats import router as chats_router
app = FastAPI(title="MTUSI Messenger")
app.add_middleware(ResourceLimitMiddleware)
app.add_middleware(RequestIdMiddleware)
app.add_exception_handler(APIError, api_error_handler)
app.add_exception_handler(RequestValidationError, validation_error_handler)
app.add_exception_handler(HTTPException, http_error_handler)
app.add_exception_handler(Exception, internal_error_handler)
app.include_router(health_router)
app.include_router(users_router)
app.include_router(chats_router)
+30
View File
@@ -0,0 +1,30 @@
from uuid import uuid4
from starlette.responses import JSONResponse
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.requests import Request
class RequestIdMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request: Request, call_next):
request_id = request.headers.get("X-Request-Id", "").strip() or str(uuid4())
request.state.request_id = request_id
if request.method in {"POST", "PUT", "PATCH"} and request.url.path.startswith("/api/"):
content_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower()
if content_type != "application/json":
response = JSONResponse(
status_code=415,
content={
"error": {
"code": "unsupported_media_type",
"message": "Ожидается Content-Type application/json",
"request_id": request_id,
}
},
)
response.headers["X-Request-Id"] = request_id
return response
response = await call_next(request)
response.headers["X-Request-Id"] = request_id
return response
View File
+44
View File
@@ -0,0 +1,44 @@
from typing import Optional
from fastapi import APIRouter, Depends, Query, status
from ..dependencies import current_user, page_limit
from ..schemas.chat import Chat, ChatPage, CreateChat
from ..schemas.message import CreateMessage, Message, MessagePage
from ..store import store
router = APIRouter(prefix="/api/v1/chats", tags=["chats"])
@router.post("", response_model=Chat, status_code=status.HTTP_201_CREATED)
def create_chat(payload: CreateChat, user: dict = Depends(current_user)):
return store.create_chat(user["id"], payload.title, payload.member_ids)
@router.get("", response_model=ChatPage)
def list_chats(
limit: int = Depends(page_limit),
cursor: Optional[str] = Query(default=None, min_length=1),
user: dict = Depends(current_user),
):
return store.list_chats(user["id"], limit, cursor)
@router.get("/{chat_id}", response_model=Chat)
def get_chat(chat_id: str, user: dict = Depends(current_user)):
return store.get_chat_for_user(chat_id, user["id"])
@router.post("/{chat_id}/messages", response_model=Message, status_code=status.HTTP_201_CREATED)
def create_message(chat_id: str, payload: CreateMessage, user: dict = Depends(current_user)):
return store.create_message(chat_id, user["id"], payload.text)
@router.get("/{chat_id}/messages", response_model=MessagePage)
def list_messages(
chat_id: str,
limit: int = Depends(page_limit),
cursor: Optional[str] = Query(default=None, min_length=1),
user: dict = Depends(current_user),
):
return store.list_messages(chat_id, user["id"], limit, cursor)
+15
View File
@@ -0,0 +1,15 @@
from fastapi import APIRouter
from ..schemas.common import Health
router = APIRouter(prefix='/health')
@router.get("/live", response_model=Health)
def health_live():
return {"status": "ok"}
@router.get("/ready", response_model=Health)
def health_ready():
return {"status": "ok"}
+19
View File
@@ -0,0 +1,19 @@
from fastapi import APIRouter, Depends, status
from ..dependencies import current_user
from ..schemas.user import CreateUser, User
from ..store import store
router = APIRouter(prefix="/api/v1/users", tags=["users"])
@router.post("", response_model=User, status_code=status.HTTP_201_CREATED)
def create_user(payload: CreateUser):
return store.create_user(payload.username, payload.display_name)
@router.get("/me", response_model=User)
def get_current_user(user: dict = Depends(current_user)):
return user
View File
+35
View File
@@ -0,0 +1,35 @@
from typing import List, Optional
from pydantic import Field, StrictStr, field_validator
from .common import ContractModel
class CreateChat(ContractModel):
title: StrictStr = Field(min_length=1, max_length=100)
member_ids: List[StrictStr] = Field(min_length=1, max_length=100)
@field_validator("title")
def validate_title(cls, value):
if not value.strip():
raise ValueError("blank title")
return value
@field_validator("member_ids")
def validate_member_ids(cls, value):
if len(value) != len(set(value)):
raise ValueError("duplicate member_ids")
return value
class Chat(ContractModel):
id: str
title: str
member_ids: List[str]
created_at: str
class ChatPage(ContractModel):
items: List[Chat]
next_cursor: Optional[str]
+9
View File
@@ -0,0 +1,9 @@
from pydantic import BaseModel, ConfigDict
class ContractModel(BaseModel):
model_config = ConfigDict(extra="forbid")
class Health(ContractModel):
status: str
+29
View File
@@ -0,0 +1,29 @@
from typing import List, Optional
from pydantic import Field, StrictStr, field_validator
from .common import ContractModel
class CreateMessage(ContractModel):
text: StrictStr = Field(min_length=1, max_length=4000)
@field_validator("text")
def validate_text(cls, value):
if not value.strip():
raise ValueError("blank text")
return value
class Message(ContractModel):
id: str
chat_id: str
sender_id: str
text: str
created_at: str
class MessagePage(ContractModel):
items: List[Message]
next_cursor: Optional[str]
+33
View File
@@ -0,0 +1,33 @@
import re
from pydantic import Field, StrictStr, field_validator
from .common import ContractModel
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
class CreateUser(ContractModel):
username: StrictStr
display_name: StrictStr = Field(min_length=1, max_length=100)
@field_validator("username")
def validate_username(cls, value):
if not USERNAME_RE.fullmatch(value):
raise ValueError("invalid username")
return value
@field_validator("display_name")
def validate_display_name(cls, value):
if not value.strip():
raise ValueError("blank display_name")
return value
class User(ContractModel):
id: str
username: str
display_name: str = Field(min_length=1, max_length=100)
created_at: str
+218
View File
@@ -0,0 +1,218 @@
import base64
import json
import time
from datetime import datetime, timezone
from threading import RLock
from typing import Optional, Tuple
from uuid import UUID, uuid4
from .errors import APIError
from .limits import limits
def utc_now() -> str:
return datetime.now(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
def ensure_uuid(value: str) -> str:
try:
if not isinstance(value, str):
raise ValueError("UUID must be a string")
return str(UUID(value))
except (TypeError, ValueError) as exc:
raise APIError(400, "invalid_request", "Неверный UUID") from exc
class InMemoryStore:
def __init__(self, settings=limits):
self.settings = settings
self._lock = RLock()
self._users = {}
self._usernames = set()
self._chats = {}
self._messages = {}
self._message_count = 0
self._text_bytes = 0
self._tokens = float(settings.message_burst)
self._refilled_at = time.monotonic()
def create_user(self, username: str, display_name: str) -> dict:
with self._lock:
if username in self._usernames:
raise APIError(409, "conflict", "Имя пользователя уже занято")
if len(self._users) >= self.settings.max_users:
raise APIError(503, 'unavailable', 'Достигнут лимит пользователей')
user = {
"id": str(uuid4()),
"username": username,
"display_name": display_name,
"created_at": utc_now(),
}
self._users[user["id"]] = user
self._usernames.add(username)
return dict(user)
def get_user(self, user_id: str) -> Optional[dict]:
user_id = ensure_uuid(user_id)
with self._lock:
user = self._users.get(user_id)
return dict(user) if user else None
def require_user(self, user_id: str) -> dict:
user = self.get_user(user_id)
if not user:
raise APIError(401, "unauthorized", "Пользователь не авторизован")
return user
def create_chat(self, actor_id: str, title: str, member_ids: list[str]) -> dict:
actor_id = ensure_uuid(actor_id)
normalized_members = [ensure_uuid(member_id) for member_id in member_ids]
if len(normalized_members) != len(set(normalized_members)):
raise APIError(400, "invalid_request", "Участники не должны повторяться")
if actor_id not in normalized_members:
raise APIError(400, "invalid_request", "Создатель должен быть участником чата")
with self._lock:
if any(member_id not in self._users for member_id in normalized_members):
raise APIError(400, "invalid_request", "Неизвестный участник")
if len(self._chats) >= self.settings.max_chats:
raise APIError(503, 'unavailable', 'Достигнут лимит чатов')
chat = {
"id": str(uuid4()),
"title": title,
"member_ids": normalized_members,
"created_at": utc_now(),
}
self._chats[chat["id"]] = chat
self._messages[chat["id"]] = []
return self._copy_chat(chat)
def get_chat_for_user(self, chat_id: str, actor_id: str) -> dict:
chat_id = ensure_uuid(chat_id)
actor_id = ensure_uuid(actor_id)
with self._lock:
chat = self._chats.get(chat_id)
if not chat or actor_id not in chat["member_ids"]:
raise APIError(404, "not_found", "Объект не найден")
return self._copy_chat(chat)
def list_chats(self, actor_id: str, limit: int, cursor: Optional[str]) -> dict:
actor_id = ensure_uuid(actor_id)
after = self._decode_cursor(cursor, "chats", actor_id) if cursor else None
with self._lock:
chats = [
self._copy_chat(chat)
for chat in self._chats.values()
if actor_id in chat["member_ids"]
]
chats.sort(key=lambda item: (item["created_at"], item["id"]))
if after:
chats = [chat for chat in chats if (chat["created_at"], chat["id"]) > after]
page = chats[:limit]
next_cursor = None
if len(chats) > limit and page:
last = page[-1]
next_cursor = self._encode_cursor("chats", actor_id, last["created_at"], last["id"])
return {"items": page, "next_cursor": next_cursor}
def create_message(self, chat_id: str, actor_id: str, text: str) -> dict:
chat = self.get_chat_for_user(chat_id, actor_id)
try:
text_size = len(text.encode('utf-8'))
except UnicodeEncodeError as exc:
raise APIError(400, 'invalid_request', 'Некорректный Unicode') from exc
with self._lock:
if self._message_count >= self.settings.max_messages:
raise APIError(503, 'unavailable', 'Достигнут лимит сообщений')
if self._text_bytes + text_size > self.settings.max_text_bytes:
raise APIError(503, 'unavailable', 'Достигнут лимит объёма текста')
now = time.monotonic()
self._tokens = min(self.settings.message_burst,
self._tokens + (now - self._refilled_at) * self.settings.message_rate)
self._refilled_at = now
if self._tokens < 1:
raise APIError(429, 'rate_limited', 'Слишком частая отправка сообщений')
self._tokens -= 1
message = {
"id": str(uuid4()),
"chat_id": chat["id"],
"sender_id": ensure_uuid(actor_id),
"text": text,
"created_at": utc_now(),
}
self._messages[chat["id"]].append(message)
self._message_count += 1
self._text_bytes += text_size
return dict(message)
def list_messages(self, chat_id: str, actor_id: str, limit: int, cursor: Optional[str]) -> dict:
chat = self.get_chat_for_user(chat_id, actor_id)
after = self._decode_cursor(cursor, "messages", chat["id"]) if cursor else None
with self._lock:
messages = [dict(message) for message in self._messages.get(chat["id"], [])]
messages.sort(key=lambda item: (item["created_at"], item["id"]))
if after:
messages = [
message
for message in messages
if (message["created_at"], message["id"]) > after
]
page = messages[:limit]
next_cursor = None
if len(messages) > limit and page:
last = page[-1]
next_cursor = self._encode_cursor("messages", chat["id"], last["created_at"], last["id"])
return {"items": page, "next_cursor": next_cursor}
@staticmethod
def _copy_chat(chat: dict) -> dict:
copy = dict(chat)
copy["member_ids"] = list(chat["member_ids"])
return copy
@staticmethod
def _encode_cursor(resource: str, owner_id: str, created_at: str, item_id: str) -> str:
payload = {
"resource": resource,
"owner_id": owner_id,
"created_at": created_at,
"id": item_id,
}
raw = json.dumps(payload, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
@staticmethod
def _decode_cursor(cursor: str, resource: str, owner_id: str) -> Tuple[str, str]:
try:
padded = cursor + "=" * (-len(cursor) % 4)
payload = json.loads(base64.b64decode(padded.encode("ascii"), altchars=b"-_", validate=True).decode("utf-8"))
except (ValueError, UnicodeError, json.JSONDecodeError) as exc:
raise APIError(400, "invalid_request", "Неверный cursor") from exc
if not isinstance(payload, dict):
raise APIError(400, "invalid_request", "Неверный cursor")
if payload.get("resource") != resource or payload.get("owner_id") != owner_id:
raise APIError(400, "invalid_request", "Неверный cursor")
item_id = ensure_uuid(payload.get("id"))
created_at = payload.get("created_at")
if not isinstance(created_at, str) or not created_at:
raise APIError(400, "invalid_request", "Неверный cursor")
try:
parsed = datetime.fromisoformat(created_at.replace("Z", "+00:00"))
if not created_at.endswith("Z") or parsed.tzinfo != timezone.utc:
raise ValueError("Expected UTC timestamp")
created_at = parsed.isoformat(timespec="microseconds").replace("+00:00", "Z")
except ValueError as exc:
raise APIError(400, "invalid_request", "Неверный cursor") from exc
return created_at, item_id
store = InMemoryStore()