From e0195cab89804db67b2ab18a010fe35205b868c4 Mon Sep 17 00:00:00 2001 From: Arina Date: Wed, 11 Nov 2026 18:42:24 +0300 Subject: [PATCH 1/3] =?UTF-8?q?=D0=9F=D0=BE=D0=B4=D0=B3=D1=80=D1=83=D0=B7?= =?UTF-8?q?=D0=BA=D0=B0=20lab1=20=D0=B4=D0=BB=D1=8F=20=D0=BD=D0=B0=D1=87?= =?UTF-8?q?=D0=B0=D0=BB=D0=B0=20=D1=80=D0=B0=D0=B1=D0=BE=D1=82=D1=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Dockerfile | 20 ++++ requirements.txt | 28 +++++ src/__init__.py | 0 src/main.py | 174 +++++++++++++++++++++++++++++++ src/models.py | 264 +++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 486 insertions(+) create mode 100644 Dockerfile create mode 100644 requirements.txt create mode 100644 src/__init__.py create mode 100644 src/main.py create mode 100644 src/models.py diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..6e5896ec --- /dev/null +++ b/Dockerfile @@ -0,0 +1,20 @@ +FROM python:3.11-slim + +# Рабочая директория внутри контейнера +WORKDIR /app + +# Сначала копируем зависимости, чтобы Docker кэшировал этот слой +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +# Копируем исходный код приложения +COPY src/ ./src/ + +# Переменные окружения по умолчанию +ENV HOST=0.0.0.0 +ENV PORT=8080 + +EXPOSE 8080 + +# Запуск сервера как главного процесса контейнера +CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"] \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..dee5e11f --- /dev/null +++ b/requirements.txt @@ -0,0 +1,28 @@ +annotated-doc==0.0.5 +annotated-types==0.8.0 +anyio==4.16.0 +certifi==2026.10.23 +click==8.5.1 +colorama==0.4.6 +fastapi==0.162.2 +h11==0.16.0 +httpcore==1.0.9 +httptools==0.9.0 +httpx==0.28.1 +idna==3.20 +iniconfig==2.3.1 +opentelemetry-api==1.45.2 +packaging==26.3 +pluggy==1.7.0 +pydantic==2.14.3 +pydantic_core==2.50.4 +Pygments==2.21.0 +pytest==9.2.0 +python-dotenv==1.2.4 +PyYAML==6.0.3 +starlette==1.10.0 +typing-inspection==0.4.5 +typing_extensions==4.16.0 +uvicorn==0.54.0 +watchfiles==1.3.0 +websockets==17.4 diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..1f37bb6d --- /dev/null +++ b/src/main.py @@ -0,0 +1,174 @@ +from fastapi import FastAPI, Request, HTTPException, Header, Query +from fastapi.responses import JSONResponse +from fastapi.exceptions import RequestValidationError +from typing import Optional +from uuid import uuid4 +from .models import ( + store, CreateUserRequest, CreateChatRequest, CreateMessageRequest, + UserResponse, ChatResponse, MessageResponse, ChatPage, MessagePage, + HealthResponse +) + +app = FastAPI() + +# Middleware для генерации и проброса X-Request-Id +@app.middleware("http") +async def add_request_id(request: Request, call_next): + request_id = str(uuid4()) + request.state.request_id = request_id + response = await call_next(request) + response.headers["X-Request-Id"] = request_id + return response + +# Обработчик ошибок валидации Pydantic (меняет стандартный 422 на 400 по контракту) +@app.exception_handler(RequestValidationError) +async def validation_exception_handler(request: Request, exc: RequestValidationError): + request_id = getattr(request.state, "request_id", str(uuid4())) + content = { + "error": { + "code": "invalid_request", + "message": "Неверный формат запроса, неверные типы данных или лишние поля", + "request_id": request_id + } + } + return JSONResponse(status_code=400, content=content) + +# Глобальный обработчик HTTP ошибок +@app.exception_handler(HTTPException) +async def http_exception_handler(request: Request, exc: HTTPException): + request_id = getattr(request.state, "request_id", str(uuid4())) + + if isinstance(exc.detail, dict) and "error" in exc.detail: + content = exc.detail + content["error"]["request_id"] = request_id + else: + code_map = { + 400: "invalid_request", 401: "unauthorized", 404: "not_found", + 409: "conflict", 413: "payload_too_large", 415: "unsupported_media_type", + 429: "rate_limited", 500: "internal_error", 503: "unavailable" + } + code = code_map.get(exc.status_code, "invalid_request") + content = { + "error": { + "code": code, + "message": str(exc.detail), + "request_id": request_id + } + } + return JSONResponse(status_code=exc.status_code, content=content) + +# --- Health endpoints --- +@app.get("/health/live", response_model=HealthResponse) +async def health_live(): + return {"status": "ok"} + +@app.get("/health/ready", response_model=HealthResponse) +async def health_ready(): + return {"status": "ok"} + +# --- Users --- +@app.post("/api/v1/users", response_model=UserResponse, status_code=201) +async def create_user(request: CreateUserRequest): + try: + user = await store.create_user(request.username, request.display_name) + return user + except ValueError as e: + if str(e) == "username_already_exists": + raise HTTPException(status_code=409, detail="Username already exists") + raise HTTPException(status_code=400, detail=str(e)) + +@app.get("/api/v1/users/me", response_model=UserResponse) +async def get_current_user(x_user_id: str = Header(None, alias="X-User-Id")): + if not x_user_id: + raise HTTPException(status_code=401, detail="Missing X-User-Id header") + user = await store.get_user(x_user_id) + if not user: + raise HTTPException(status_code=401, detail="User not found") + return user + +# --- Chats --- +@app.post("/api/v1/chats", response_model=ChatResponse, status_code=201) +async def create_chat(request: CreateChatRequest, x_user_id: str = Header(None, alias="X-User-Id")): + if not x_user_id: + raise HTTPException(status_code=401, detail="Missing X-User-Id header") + if not await store.get_user(x_user_id): + raise HTTPException(status_code=401, detail="User not found") + + try: + chat = await store.create_chat(request.title, request.member_ids, x_user_id) + return chat + except ValueError as e: + if str(e) == "user_not_found": + raise HTTPException(status_code=400, detail="One or more members not found") + if str(e) == "creator_not_in_members": + raise HTTPException(status_code=400, detail="Creator must be in member list") + if str(e) == "duplicate_members": + raise HTTPException(status_code=400, detail="Duplicate member IDs") + raise HTTPException(status_code=400, detail=str(e)) + +@app.get("/api/v1/chats", response_model=ChatPage) +async def list_chats( + x_user_id: str = Header(None, alias="X-User-Id"), + limit: int = Query(default=50, ge=1, le=100), # Строгая валидация! + cursor: Optional[str] = Query(default=None, min_length=1) +): + if not x_user_id: + raise HTTPException(status_code=401, detail="Missing X-User-Id header") + if not await store.get_user(x_user_id): + raise HTTPException(status_code=401, detail="User not found") + + chats, next_cursor = await store.list_chats(x_user_id, limit, cursor) + return {"items": chats, "next_cursor": next_cursor} + +@app.get("/api/v1/chats/{chat_id}", response_model=ChatResponse) +async def get_chat(chat_id: str, x_user_id: str = Header(None, alias="X-User-Id")): + if not x_user_id: + raise HTTPException(status_code=401, detail="Missing X-User-Id header") + chat = await store.get_chat(chat_id, x_user_id) + if not chat: + raise HTTPException(status_code=404, detail="Chat not found") + return chat + +# --- Messages --- +@app.post("/api/v1/chats/{chat_id}/messages", response_model=MessageResponse, status_code=201) +async def create_message( + chat_id: str, + request: CreateMessageRequest, + x_user_id: str = Header(None, alias="X-User-Id") +): + if not x_user_id: + raise HTTPException(status_code=401, detail="Missing X-User-Id header") + if not await store.get_user(x_user_id): + raise HTTPException(status_code=401, detail="User not found") + + try: + message = await store.create_message(chat_id, x_user_id, request.text) + return message + except ValueError as e: + if str(e) == "chat_not_found": + raise HTTPException(status_code=404, detail="Chat not found") + if str(e) == "sender_not_in_chat": + raise HTTPException(status_code=404, detail="User not in chat") # 404 вместо 403 по контракту + raise HTTPException(status_code=400, detail=str(e)) + +@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage) +async def list_messages( + chat_id: str, + x_user_id: str = Header(None, alias="X-User-Id"), + limit: int = Query(default=50, ge=1, le=100), # Строгая валидация! + cursor: Optional[str] = Query(default=None, min_length=1) +): + if not x_user_id: + raise HTTPException(status_code=401, detail="Missing X-User-Id header") + if not await store.get_user(x_user_id): + raise HTTPException(status_code=401, detail="User not found") + + try: + messages, next_cursor = await store.list_messages(chat_id, x_user_id, limit, cursor) + return {"items": messages, "next_cursor": next_cursor} + except ValueError as e: + if str(e) == "chat_not_found": + raise HTTPException(status_code=404, detail="Chat not found") + if str(e) == "user_not_in_chat": + raise HTTPException(status_code=404, detail="User not in chat") + raise HTTPException(status_code=400, detail=str(e)) \ No newline at end of file diff --git a/src/models.py b/src/models.py new file mode 100644 index 00000000..37847c0e --- /dev/null +++ b/src/models.py @@ -0,0 +1,264 @@ +from datetime import datetime, timezone +from typing import Optional, Dict, List +from uuid import uuid4 +import asyncio +from pydantic import BaseModel, Field, field_validator +import re + + +class CreateUserRequest(BaseModel): + username: str = Field(..., min_length=3, max_length=32) + display_name: str = Field(..., min_length=1, max_length=100) + + @field_validator('username') + @classmethod + def validate_username(cls, v): + if not re.match(r'^[a-z0-9_]{3,32}$', v): + raise ValueError('username должен содержать только a-z, 0-9, _ (3-32 символа)') + return v + + @field_validator('display_name') + @classmethod + def validate_display_name(cls, v): + if not v.strip(): + raise ValueError('display_name не может состоять только из пробелов') + return v + +class CreateChatRequest(BaseModel): + title: str = Field(..., min_length=1, max_length=100) + member_ids: List[str] = Field(..., min_length=1, max_length=100) + + @field_validator('title') + @classmethod + def validate_title(cls, v): + if not v.strip(): + raise ValueError('title не может состоять только из пробелов') + return v + +class CreateMessageRequest(BaseModel): + text: str = Field(..., min_length=1, max_length=4000) + + @field_validator('text') + @classmethod + def validate_text(cls, v): + if not v.strip(): + raise ValueError('text не может состоять только из пробелов') + return v + + +class UserResponse(BaseModel): + id: str + username: str + display_name: str + created_at: str + +class ChatResponse(BaseModel): + id: str + title: str + member_ids: List[str] + created_at: str + +class MessageResponse(BaseModel): + id: str + chat_id: str + sender_id: str + text: str + created_at: str + +class ChatPage(BaseModel): + items: List[ChatResponse] + next_cursor: Optional[str] = None + +class MessagePage(BaseModel): + items: List[MessageResponse] + next_cursor: Optional[str] = None + +class HealthResponse(BaseModel): + status: str = "ok" + +class ErrorResponse(BaseModel): + error: dict + + +class InMemoryStore: + def __init__(self): + self._lock = asyncio.Lock() + self.users: Dict[str, dict] = {} # id -> user + self.chats: Dict[str, dict] = {} # id -> chat + self.messages: Dict[str, List[dict]] = {} # chat_id -> [messages] + self.usernames: Dict[str, str] = {} # username -> user_id (для проверки уникальности) + + + async def create_user(self, username: str, display_name: str) -> dict: + async with self._lock: + if username in self.usernames: + raise ValueError("username_already_exists") + + user_id = str(uuid4()) + now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') + + user = { + "id": user_id, + "username": username, + "display_name": display_name, + "created_at": now + } + + self.users[user_id] = user + self.usernames[username] = user_id + + return user + + async def get_user(self, user_id: str) -> Optional[dict]: + async with self._lock: + return self.users.get(user_id) + + async def get_user_by_username(self, username: str) -> Optional[dict]: + async with self._lock: + user_id = self.usernames.get(username) + if user_id: + return self.users.get(user_id) + return None + + + async def create_chat(self, title: str, member_ids: List[str], creator_id: str) -> dict: + async with self._lock: + # Проверяем, что все участники существуют + for member_id in member_ids: + if member_id not in self.users: + raise ValueError("user_not_found") + + # Проверяем, что создатель входит в список участников + if creator_id not in member_ids: + raise ValueError("creator_not_in_members") + + # Проверяем уникальность member_ids + if len(member_ids) != len(set(member_ids)): + raise ValueError("duplicate_members") + + chat_id = str(uuid4()) + now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') + + chat = { + "id": chat_id, + "title": title, + "member_ids": member_ids, + "created_at": now + } + + self.chats[chat_id] = chat + self.messages[chat_id] = [] + + return chat + + async def get_chat(self, chat_id: str, user_id: str) -> Optional[dict]: + async with self._lock: + chat = self.chats.get(chat_id) + if not chat: + return None + + # Проверяем, что пользователь является участником + if user_id not in chat["member_ids"]: + return None + + return chat + + async def list_chats(self, user_id: str, limit: int = 50, cursor: Optional[str] = None) -> tuple: + async with self._lock: + # Получаем все чаты пользователя + user_chats = [ + chat for chat in self.chats.values() + if user_id in chat["member_ids"] + ] + + # Сортируем по (created_at, id) + user_chats.sort(key=lambda c: (c["created_at"], c["id"])) + + # Применяем cursor + if cursor: + # cursor — это "created_at,id" последнего элемента предыдущей страницы + cursor_parts = cursor.split(",", 1) + if len(cursor_parts) == 2: + cursor_time, cursor_id = cursor_parts + user_chats = [ + c for c in user_chats + if (c["created_at"], c["id"]) > (cursor_time, cursor_id) + ] + + # Ограничиваем количество + has_more = len(user_chats) > limit + page = user_chats[:limit] + + # Формируем next_cursor + next_cursor = None + if has_more and page: + last_item = page[-1] + next_cursor = f"{last_item['created_at']},{last_item['id']}" + + return page, next_cursor + + + async def create_message(self, chat_id: str, sender_id: str, text: str) -> dict: + async with self._lock: + # Проверяем, что чат существует + if chat_id not in self.chats: + raise ValueError("chat_not_found") + + # Проверяем, что отправитель является участником чата + chat = self.chats[chat_id] + if sender_id not in chat["member_ids"]: + raise ValueError("sender_not_in_chat") + + message_id = str(uuid4()) + now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') + + message = { + "id": message_id, + "chat_id": chat_id, + "sender_id": sender_id, + "text": text, + "created_at": now + } + + self.messages[chat_id].append(message) + + return message + + async def list_messages(self, chat_id: str, user_id: str, limit: int = 50, cursor: Optional[str] = None) -> tuple: + async with self._lock: + # Проверяем, что чат существует и пользователь является участником + chat = self.chats.get(chat_id) + if not chat: + raise ValueError("chat_not_found") + + if user_id not in chat["member_ids"]: + raise ValueError("user_not_in_chat") + + messages = self.messages.get(chat_id, []) + + # Сортируем по (created_at, id) + messages.sort(key=lambda m: (m["created_at"], m["id"])) + + # Применяем cursor + if cursor: + cursor_parts = cursor.split(",", 1) + if len(cursor_parts) == 2: + cursor_time, cursor_id = cursor_parts + messages = [ + m for m in messages + if (m["created_at"], m["id"]) > (cursor_time, cursor_id) + ] + + # Ограничиваем количество + has_more = len(messages) > limit + page = messages[:limit] + + # Формируем next_cursor + next_cursor = None + if has_more and page: + last_item = page[-1] + next_cursor = f"{last_item['created_at']},{last_item['id']}" + + return page, next_cursor + +store = InMemoryStore() \ No newline at end of file -- 2.54.0 From d96d8ecfc7023fe5f031e3079622a581039dde8d Mon Sep 17 00:00:00 2001 From: Arina Date: Wed, 11 Nov 2026 21:52:43 +0300 Subject: [PATCH 2/3] =?UTF-8?q?=D0=A0=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=B0?= =?UTF-8?q?=D1=86=D0=B8=D1=8F=20=D1=81=20PostgreSQL=20=D0=B8=20session-bas?= =?UTF-8?q?ed=20auth?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Dockerfile | 10 +- docker-compose.yaml | 35 ++++ requirements.txt | 34 +--- scripts/restart.bat | 15 ++ src/auth.py | 61 +++++++ src/database.py | 295 +++++++++++++++++++++++++++++++++ src/main.py | 239 ++++++++++++++++++++------ src/migrations/001_initial.sql | 51 ++++++ src/models.py | 223 ++++--------------------- 9 files changed, 681 insertions(+), 282 deletions(-) create mode 100644 docker-compose.yaml create mode 100644 scripts/restart.bat create mode 100644 src/auth.py create mode 100644 src/database.py create mode 100644 src/migrations/001_initial.sql diff --git a/Dockerfile b/Dockerfile index 6e5896ec..51c0d3ed 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,20 +1,20 @@ FROM python:3.11-slim -# Рабочая директория внутри контейнера +# Устанавливаем curl для healthcheck +RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/* + WORKDIR /app -# Сначала копируем зависимости, чтобы Docker кэшировал этот слой +# Копируем зависимости COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt -# Копируем исходный код приложения +# Копируем исходный код COPY src/ ./src/ -# Переменные окружения по умолчанию ENV HOST=0.0.0.0 ENV PORT=8080 EXPOSE 8080 -# Запуск сервера как главного процесса контейнера CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"] \ No newline at end of file diff --git a/docker-compose.yaml b/docker-compose.yaml new file mode 100644 index 00000000..1f4b53a5 --- /dev/null +++ b/docker-compose.yaml @@ -0,0 +1,35 @@ +services: + api: + build: . + ports: + - "8080:8080" + environment: + - DATABASE_URL=postgresql://messenger:messenger_pass@postgres:5432/messenger + - SESSION_TTL_SECONDS=3600 + depends_on: + postgres: + condition: service_healthy + healthcheck: + test: ["CMD", "curl", "-f", "http://localhost:8080/health/ready"] + interval: 5s + timeout: 3s + retries: 5 + restart: unless-stopped + + postgres: + image: postgres:16.1 + environment: + - POSTGRES_DB=messenger + - POSTGRES_USER=messenger + - POSTGRES_PASSWORD=messenger_pass + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger"] + interval: 5s + timeout: 3s + retries: 5 + restart: unless-stopped + +volumes: + postgres_data: \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index dee5e11f..2f55caaf 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,28 +1,6 @@ -annotated-doc==0.0.5 -annotated-types==0.8.0 -anyio==4.16.0 -certifi==2026.10.23 -click==8.5.1 -colorama==0.4.6 -fastapi==0.162.2 -h11==0.16.0 -httpcore==1.0.9 -httptools==0.9.0 -httpx==0.28.1 -idna==3.20 -iniconfig==2.3.1 -opentelemetry-api==1.45.2 -packaging==26.3 -pluggy==1.7.0 -pydantic==2.14.3 -pydantic_core==2.50.4 -Pygments==2.21.0 -pytest==9.2.0 -python-dotenv==1.2.4 -PyYAML==6.0.3 -starlette==1.10.0 -typing-inspection==0.4.5 -typing_extensions==4.16.0 -uvicorn==0.54.0 -watchfiles==1.3.0 -websockets==17.4 +fastapi==0.104.1 +uvicorn==0.24.0 +psycopg2-binary==2.9.9 +bcrypt==4.1.2 +python-multipart==0.0.6 +pydantic==2.5.0 \ No newline at end of file diff --git a/scripts/restart.bat b/scripts/restart.bat new file mode 100644 index 00000000..9a57e077 --- /dev/null +++ b/scripts/restart.bat @@ -0,0 +1,15 @@ +@echo off +cd /d %~dp0\.. +docker compose restart api postgres + +set /a count=0 +:check_loop +timeout /t 2 /nobreak >nul +curl -s -f http://localhost:8080/health/ready >nul 2>&1 +if %errorlevel% equ 0 exit /b 0 + +set /a count+=1 +if %count% lss 15 goto check_loop + +echo API failed to become ready +exit /b 1 \ No newline at end of file diff --git a/src/auth.py b/src/auth.py new file mode 100644 index 00000000..14b2fe86 --- /dev/null +++ b/src/auth.py @@ -0,0 +1,61 @@ +import os +import hashlib +import bcrypt +import secrets +from datetime import datetime, timezone, timedelta +from typing import Optional, Dict, Any + + +SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600")) + + +def hash_password(password: str) -> str: + """Хешировать пароль: SHA-256 пре-хеширование + bcrypt (обход лимита 72 байт)""" + pre_hash = hashlib.sha256(password.encode('utf-8')).digest() + return bcrypt.hashpw(pre_hash, bcrypt.gensalt()).decode('utf-8') + + +def verify_password(password: str, password_hash: str) -> bool: + """Проверить пароль""" + pre_hash = hashlib.sha256(password.encode('utf-8')).digest() + return bcrypt.checkpw(pre_hash, password_hash.encode('utf-8')) + + +def generate_token() -> str: + """Сгенерировать случайный токен сессии (256 бит энтропии)""" + return secrets.token_hex(32) # 64 символа = 256 бит + + +def create_session(db_conn, user_id: str) -> Dict[str, Any]: + """Создать новую сессию в БД""" + token = generate_token() + expires_at = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL_SECONDS) + + with db_conn.cursor() as cur: + cur.execute( + "INSERT INTO sessions (token, user_id, expires_at) VALUES (%s, %s, %s)", + (token, user_id, expires_at) + ) + db_conn.commit() + + return { + "token": token, + "expires_at": expires_at.strftime('%Y-%m-%dT%H:%M:%SZ') + } + + +def get_session(db_conn, token: str) -> Optional[Dict[str, Any]]: + """Получить действительную сессию по токену""" + with db_conn.cursor() as cur: + cur.execute( + "SELECT token, user_id, expires_at FROM sessions WHERE token = %s AND expires_at > NOW()", + (token,) + ) + return cur.fetchone() + + +def delete_session(db_conn, token: str): + """Удалить сессию (logout)""" + with db_conn.cursor() as cur: + cur.execute("DELETE FROM sessions WHERE token = %s", (token,)) + db_conn.commit() \ No newline at end of file diff --git a/src/database.py b/src/database.py new file mode 100644 index 00000000..134ab938 --- /dev/null +++ b/src/database.py @@ -0,0 +1,295 @@ +import os +import psycopg2 +from psycopg2.extras import RealDictCursor +from typing import Optional, List, Dict, Any, Tuple +from contextlib import contextmanager +from uuid import uuid4 +from datetime import datetime, timezone + + +DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://messenger:messenger_pass@localhost:5432/messenger") + + +def get_db_connection(): + """Создать подключение к PostgreSQL""" + return psycopg2.connect(DATABASE_URL, cursor_factory=RealDictCursor) + + +@contextmanager +def get_db(): + """Контекстный менеджер для работы с БД""" + conn = get_db_connection() + try: + yield conn + conn.commit() + except Exception: + conn.rollback() + raise + finally: + conn.close() + + +def init_db(): + """Инициализировать БД (запустить миграции idempotently)""" + migration_path = os.path.join(os.path.dirname(__file__), "migrations", "001_initial.sql") + with open(migration_path, "r") as f: + migration_sql = f.read() + + with get_db() as conn: + with conn.cursor() as cur: + cur.execute(migration_sql) + + +class PostgresStore: + """Store layer для PostgreSQL — заменяет InMemoryStore из Lab 1""" + + def create_user(self, username: str, display_name: str, password_hash: str) -> dict: + with get_db() as conn: + with conn.cursor() as cur: + # Проверяем уникальность username + cur.execute("SELECT id FROM users WHERE username = %s", (username,)) + if cur.fetchone(): + raise ValueError("username_already_exists") + + user_id = str(uuid4()) + now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') + + cur.execute( + "INSERT INTO users (id, username, display_name, password_hash, created_at) " + "VALUES (%s, %s, %s, %s, %s)", + (user_id, username, display_name, password_hash, now) + ) + + return { + "id": user_id, + "username": username, + "display_name": display_name, + "created_at": now + } + + def get_user(self, user_id: str) -> Optional[dict]: + with get_db() as conn: + with conn.cursor() as cur: + cur.execute( + "SELECT id, username, display_name, created_at FROM users WHERE id = %s", + (user_id,) + ) + row = cur.fetchone() + if row: + # Преобразуем datetime в строку ISO8601 + row["created_at"] = row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') + return row + + def get_user_by_username(self, username: str) -> Optional[dict]: + with get_db() as conn: + with conn.cursor() as cur: + cur.execute( + "SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = %s", + (username,) + ) + row = cur.fetchone() + if row: + # Преобразуем datetime в строку ISO8601 + row["created_at"] = row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') + return row + + def create_chat(self, title: str, member_ids: List[str], creator_id: str) -> dict: + with get_db() as conn: + with conn.cursor() as cur: + # Проверяем, что все участники существуют + for member_id in member_ids: + cur.execute("SELECT id FROM users WHERE id = %s", (member_id,)) + if not cur.fetchone(): + raise ValueError("user_not_found") + + # Проверяем, что создатель входит в список участников + if creator_id not in member_ids: + raise ValueError("creator_not_in_members") + + # Проверяем уникальность member_ids + if len(member_ids) != len(set(member_ids)): + raise ValueError("duplicate_members") + + chat_id = str(uuid4()) + now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') + + # Атомарно: создаём чат и всех участников в одной транзакции + cur.execute( + "INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)", + (chat_id, title, now) + ) + + for member_id in member_ids: + cur.execute( + "INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", + (chat_id, member_id) + ) + + return { + "id": chat_id, + "title": title, + "member_ids": member_ids, + "created_at": now + } + + def get_chat(self, chat_id: str, user_id: str) -> Optional[dict]: + with get_db() as conn: + with conn.cursor() as cur: + cur.execute( + "SELECT c.id, c.title, c.created_at " + "FROM chats c " + "JOIN chat_members cm ON c.id = cm.chat_id " + "WHERE c.id = %s AND cm.user_id = %s", + (chat_id, user_id) + ) + chat = cur.fetchone() + if not chat: + return None + + # Получаем список участников + cur.execute( + "SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id", + (chat_id,) + ) + members = [row["user_id"] for row in cur.fetchall()] + + return { + "id": chat["id"], + "title": chat["title"], + "member_ids": members, + "created_at": chat["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') + } + + def list_chats(self, user_id: str, limit: int = 50, cursor: Optional[str] = None) -> Tuple[List[dict], Optional[str]]: + with get_db() as conn: + with conn.cursor() as cur: + query = """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members cm ON c.id = cm.chat_id + WHERE cm.user_id = %s + """ + params = [user_id] + + if cursor: + cursor_parts = cursor.split(",", 1) + if len(cursor_parts) == 2: + cursor_time, cursor_id = cursor_parts + query += " AND (c.created_at, c.id) > (%s::timestamptz, %s::uuid)" + params.extend([cursor_time, cursor_id]) + + query += " ORDER BY c.created_at, c.id LIMIT %s" + params.append(limit + 1) # Берём на 1 больше для определения has_more + + cur.execute(query, params) + rows = cur.fetchall() + + has_more = len(rows) > limit + page_rows = rows[:limit] + + chats = [] + for row in page_rows: + cur.execute( + "SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id", + (row["id"],) + ) + members = [m["user_id"] for m in cur.fetchall()] + chats.append({ + "id": row["id"], + "title": row["title"], + "member_ids": members, + "created_at": row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') + }) + + next_cursor = None + if has_more and chats: + last = page_rows[-1] + next_cursor = f"{last['created_at'].strftime('%Y-%m-%dT%H:%M:%SZ')},{last['id']}" + + return chats, next_cursor + + def create_message(self, chat_id: str, sender_id: str, text: str) -> dict: + with get_db() as conn: + with conn.cursor() as cur: + # Проверяем, что чат существует и отправитель является участником + cur.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, sender_id) + ) + if not cur.fetchone(): + cur.execute("SELECT id FROM chats WHERE id = %s", (chat_id,)) + if cur.fetchone(): + raise ValueError("sender_not_in_chat") + raise ValueError("chat_not_found") + + message_id = str(uuid4()) + now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') + + cur.execute( + "INSERT INTO messages (id, chat_id, sender_id, text, created_at) " + "VALUES (%s, %s, %s, %s, %s)", + (message_id, chat_id, sender_id, text, now) + ) + + return { + "id": message_id, + "chat_id": chat_id, + "sender_id": sender_id, + "text": text, + "created_at": now + } + + def list_messages(self, chat_id: str, user_id: str, limit: int = 50, cursor: Optional[str] = None) -> Tuple[List[dict], Optional[str]]: + with get_db() as conn: + with conn.cursor() as cur: + # Проверяем, что пользователь является участником чата + cur.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, user_id) + ) + if not cur.fetchone(): + cur.execute("SELECT id FROM chats WHERE id = %s", (chat_id,)) + if cur.fetchone(): + raise ValueError("user_not_in_chat") + raise ValueError("chat_not_found") + + query = """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s + """ + params = [chat_id] + + if cursor: + cursor_parts = cursor.split(",", 1) + if len(cursor_parts) == 2: + cursor_time, cursor_id = cursor_parts + query += " AND (created_at, id) > (%s::timestamptz, %s::uuid)" + params.extend([cursor_time, cursor_id]) + + query += " ORDER BY created_at, id LIMIT %s" + params.append(limit + 1) + + cur.execute(query, params) + rows = cur.fetchall() + + has_more = len(rows) > limit + page_rows = rows[:limit] + + messages = [{ + "id": row["id"], + "chat_id": row["chat_id"], + "sender_id": row["sender_id"], + "text": row["text"], + "created_at": row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') + } for row in page_rows] + + next_cursor = None + if has_more and messages: + last = page_rows[-1] + next_cursor = f"{last['created_at'].strftime('%Y-%m-%dT%H:%M:%SZ')},{last['id']}" + + return messages, next_cursor + + +store = PostgresStore() \ No newline at end of file diff --git a/src/main.py b/src/main.py index 1f37bb6d..1d5bdd25 100644 --- a/src/main.py +++ b/src/main.py @@ -1,17 +1,26 @@ -from fastapi import FastAPI, Request, HTTPException, Header, Query -from fastapi.responses import JSONResponse +import base64 +from fastapi import FastAPI, Request, HTTPException, Query +from fastapi.responses import JSONResponse, Response from fastapi.exceptions import RequestValidationError from typing import Optional from uuid import uuid4 from .models import ( - store, CreateUserRequest, CreateChatRequest, CreateMessageRequest, + CreateUserRequest, CreateChatRequest, CreateMessageRequest, UserResponse, ChatResponse, MessageResponse, ChatPage, MessagePage, - HealthResponse + SessionResponse, HealthResponse ) +from .database import store, init_db, get_db_connection +from .auth import hash_password, verify_password, create_session, get_session, delete_session app = FastAPI() -# Middleware для генерации и проброса X-Request-Id +# Инициализация БД при старте +@app.on_event("startup") +async def startup_event(): + init_db() + + +# Middleware для генерации X-Request-Id @app.middleware("http") async def add_request_id(request: Request, call_next): request_id = str(uuid4()) @@ -20,7 +29,8 @@ async def add_request_id(request: Request, call_next): response.headers["X-Request-Id"] = request_id return response -# Обработчик ошибок валидации Pydantic (меняет стандартный 422 на 400 по контракту) + +# Обработчик ошибок валидации Pydantic (422 → 400) @app.exception_handler(RequestValidationError) async def validation_exception_handler(request: Request, exc: RequestValidationError): request_id = getattr(request.state, "request_id", str(uuid4())) @@ -33,11 +43,22 @@ async def validation_exception_handler(request: Request, exc: RequestValidationE } return JSONResponse(status_code=400, content=content) + # Глобальный обработчик HTTP ошибок @app.exception_handler(HTTPException) async def http_exception_handler(request: Request, exc: HTTPException): request_id = getattr(request.state, "request_id", str(uuid4())) + # Копируем headers из HTTPException, если они есть + headers = dict(exc.headers) if exc.headers else {} + + # Если нет WWW-Authenticate, добавляем по умолчанию для 401 + if exc.status_code == 401 and "WWW-Authenticate" not in headers: + if "/auth/sessions" in str(request.url.path): + headers["WWW-Authenticate"] = 'Basic realm="messenger", charset="UTF-8"' + else: + headers["WWW-Authenticate"] = 'Bearer realm="messenger"' + if isinstance(exc.detail, dict) and "error" in exc.detail: content = exc.detail content["error"]["request_id"] = request_id @@ -55,47 +76,164 @@ async def http_exception_handler(request: Request, exc: HTTPException): "request_id": request_id } } - return JSONResponse(status_code=exc.status_code, content=content) + + return JSONResponse(status_code=exc.status_code, content=content, headers=headers) + + +# Вспомогательная функция для получения текущего пользователя из Bearer токена +async def get_current_user_from_request(request: Request) -> dict: + auth_header = request.headers.get("Authorization") + if not auth_header or not auth_header.startswith("Bearer "): + raise HTTPException( + status_code=401, + detail="Missing or invalid Authorization header", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'} + ) + + token = auth_header[7:] # Убираем "Bearer " + + conn = get_db_connection() + try: + session = get_session(conn, token) + if not session: + raise HTTPException( + status_code=401, + detail="Invalid or expired session", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'} + ) + + user = store.get_user(session["user_id"]) + if not user: + raise HTTPException( + status_code=401, + detail="User not found", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'} + ) + + return user + finally: + conn.close() # --- Health endpoints --- @app.get("/health/live", response_model=HealthResponse) async def health_live(): return {"status": "ok"} + @app.get("/health/ready", response_model=HealthResponse) async def health_ready(): - return {"status": "ok"} - -# --- Users --- -@app.post("/api/v1/users", response_model=UserResponse, status_code=201) -async def create_user(request: CreateUserRequest): try: - user = await store.create_user(request.username, request.display_name) + conn = get_db_connection() + conn.close() + return {"status": "ok"} + except Exception: + raise HTTPException(status_code=503, detail="Database unavailable") + + +# --- Auth endpoints --- +@app.post("/api/v1/auth/sessions", response_model=SessionResponse, status_code=201) +async def create_session_endpoint(request: Request): + # Проверяем Basic auth + auth_header = request.headers.get("Authorization") + if not auth_header or not auth_header.startswith("Basic "): + raise HTTPException( + status_code=401, + detail="Missing Basic authentication", + headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'} + ) + + try: + # Декодируем base64(username:password) + decoded = base64.b64decode(auth_header[6:]).decode('utf-8') + # Пароль может содержать двоеточие, поэтому split только по первому + username, password = decoded.split(":", 1) + except Exception: + raise HTTPException(status_code=400, detail="Invalid Basic authentication format") + + # Валидация username (ASCII [a-z0-9_]{3,32}) + import re + if not re.match(r'^[a-z0-9_]{3,32}$', username): + raise HTTPException(status_code=400, detail="Invalid username format") + + # Валидация пароля (12-128 code points) + if len(password) < 12 or len(password) > 128: + raise HTTPException(status_code=400, detail="Password must be 12-128 characters") + + # Ищем пользователя + user = store.get_user_by_username(username) + if not user: + raise HTTPException(status_code=401, detail="Invalid credentials") + + # Проверяем пароль + if not verify_password(password, user["password_hash"]): + raise HTTPException(status_code=401, detail="Invalid credentials") + + # Создаём сессию + conn = get_db_connection() + try: + session_data = create_session(conn, user["id"]) + + return { + "token": session_data["token"], + "token_type": "Bearer", + "expires_at": session_data["expires_at"], + "user": { + "id": user["id"], + "username": user["username"], + "display_name": user["display_name"], + "created_at": user["created_at"] + } + } + finally: + conn.close() + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +async def revoke_session(request: Request): + user = await get_current_user_from_request(request) + + auth_header = request.headers.get("Authorization") + token = auth_header[7:] # Убираем "Bearer " + + conn = get_db_connection() + try: + delete_session(conn, token) + finally: + conn.close() + + return Response(status_code=204) + + +# --- Users endpoints --- +@app.post("/api/v1/users", response_model=UserResponse, status_code=201) +async def create_user(request_body: CreateUserRequest): + try: + password_hash = hash_password(request_body.password) + user = store.create_user( + request_body.username, + request_body.display_name, + password_hash + ) return user except ValueError as e: if str(e) == "username_already_exists": raise HTTPException(status_code=409, detail="Username already exists") raise HTTPException(status_code=400, detail=str(e)) + @app.get("/api/v1/users/me", response_model=UserResponse) -async def get_current_user(x_user_id: str = Header(None, alias="X-User-Id")): - if not x_user_id: - raise HTTPException(status_code=401, detail="Missing X-User-Id header") - user = await store.get_user(x_user_id) - if not user: - raise HTTPException(status_code=401, detail="User not found") +async def get_current_user(request: Request): + user = await get_current_user_from_request(request) return user -# --- Chats --- + +# --- Chats endpoints --- @app.post("/api/v1/chats", response_model=ChatResponse, status_code=201) -async def create_chat(request: CreateChatRequest, x_user_id: str = Header(None, alias="X-User-Id")): - if not x_user_id: - raise HTTPException(status_code=401, detail="Missing X-User-Id header") - if not await store.get_user(x_user_id): - raise HTTPException(status_code=401, detail="User not found") +async def create_chat(request_body: CreateChatRequest, request: Request): + user = await get_current_user_from_request(request) try: - chat = await store.create_chat(request.title, request.member_ids, x_user_id) + chat = store.create_chat(request_body.title, request_body.member_ids, user["id"]) return chat except ValueError as e: if str(e) == "user_not_found": @@ -106,65 +244,58 @@ async def create_chat(request: CreateChatRequest, x_user_id: str = Header(None, raise HTTPException(status_code=400, detail="Duplicate member IDs") raise HTTPException(status_code=400, detail=str(e)) + @app.get("/api/v1/chats", response_model=ChatPage) async def list_chats( - x_user_id: str = Header(None, alias="X-User-Id"), - limit: int = Query(default=50, ge=1, le=100), # Строгая валидация! + request: Request, + limit: int = Query(default=50, ge=1, le=100), cursor: Optional[str] = Query(default=None, min_length=1) ): - if not x_user_id: - raise HTTPException(status_code=401, detail="Missing X-User-Id header") - if not await store.get_user(x_user_id): - raise HTTPException(status_code=401, detail="User not found") - - chats, next_cursor = await store.list_chats(x_user_id, limit, cursor) + user = await get_current_user_from_request(request) + chats, next_cursor = store.list_chats(user["id"], limit, cursor) return {"items": chats, "next_cursor": next_cursor} + @app.get("/api/v1/chats/{chat_id}", response_model=ChatResponse) -async def get_chat(chat_id: str, x_user_id: str = Header(None, alias="X-User-Id")): - if not x_user_id: - raise HTTPException(status_code=401, detail="Missing X-User-Id header") - chat = await store.get_chat(chat_id, x_user_id) +async def get_chat(chat_id: str, request: Request): + user = await get_current_user_from_request(request) + chat = store.get_chat(chat_id, user["id"]) if not chat: raise HTTPException(status_code=404, detail="Chat not found") return chat -# --- Messages --- + +# --- Messages endpoints --- @app.post("/api/v1/chats/{chat_id}/messages", response_model=MessageResponse, status_code=201) async def create_message( chat_id: str, - request: CreateMessageRequest, - x_user_id: str = Header(None, alias="X-User-Id") + request_body: CreateMessageRequest, + request: Request ): - if not x_user_id: - raise HTTPException(status_code=401, detail="Missing X-User-Id header") - if not await store.get_user(x_user_id): - raise HTTPException(status_code=401, detail="User not found") + user = await get_current_user_from_request(request) try: - message = await store.create_message(chat_id, x_user_id, request.text) + message = store.create_message(chat_id, user["id"], request_body.text) return message except ValueError as e: if str(e) == "chat_not_found": raise HTTPException(status_code=404, detail="Chat not found") if str(e) == "sender_not_in_chat": - raise HTTPException(status_code=404, detail="User not in chat") # 404 вместо 403 по контракту + raise HTTPException(status_code=404, detail="User not in chat") raise HTTPException(status_code=400, detail=str(e)) + @app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage) async def list_messages( chat_id: str, - x_user_id: str = Header(None, alias="X-User-Id"), - limit: int = Query(default=50, ge=1, le=100), # Строгая валидация! + request: Request, + limit: int = Query(default=50, ge=1, le=100), cursor: Optional[str] = Query(default=None, min_length=1) ): - if not x_user_id: - raise HTTPException(status_code=401, detail="Missing X-User-Id header") - if not await store.get_user(x_user_id): - raise HTTPException(status_code=401, detail="User not found") + user = await get_current_user_from_request(request) try: - messages, next_cursor = await store.list_messages(chat_id, x_user_id, limit, cursor) + messages, next_cursor = store.list_messages(chat_id, user["id"], limit, cursor) return {"items": messages, "next_cursor": next_cursor} except ValueError as e: if str(e) == "chat_not_found": diff --git a/src/migrations/001_initial.sql b/src/migrations/001_initial.sql new file mode 100644 index 00000000..30df30d5 --- /dev/null +++ b/src/migrations/001_initial.sql @@ -0,0 +1,51 @@ +-- Миграция 001: начальная схема для MTUSI Messenger Lab 2 +-- Запускать idempotently (безопасно повторять) + +-- Таблица пользователей +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + username VARCHAR(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name VARCHAR(100) NOT NULL CHECK (length(display_name) >= 1), + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +-- Таблица чатов +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + title VARCHAR(100) NOT NULL CHECK (length(title) >= 1), + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +-- Таблица участников чата +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); + +-- Таблица сообщений +CREATE TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + text TEXT NOT NULL CHECK (length(text) >= 1 AND length(text) <= 4000), + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +-- Таблица сессий +CREATE TABLE IF NOT EXISTS sessions ( + token TEXT PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +-- Индекс для cursor-based пагинации сообщений +CREATE INDEX IF NOT EXISTS idx_messages_chat_created ON messages(chat_id, created_at, id); + +-- Индекс для очистки истёкших сессий +CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions(expires_at); + +-- Индекс для быстрого поиска чатов пользователя +CREATE INDEX IF NOT EXISTS idx_chat_members_user ON chat_members(user_id); \ No newline at end of file diff --git a/src/models.py b/src/models.py index 37847c0e..2db90f1c 100644 --- a/src/models.py +++ b/src/models.py @@ -1,7 +1,5 @@ from datetime import datetime, timezone -from typing import Optional, Dict, List -from uuid import uuid4 -import asyncio +from typing import Optional, List from pydantic import BaseModel, Field, field_validator import re @@ -9,14 +7,15 @@ import re class CreateUserRequest(BaseModel): username: str = Field(..., min_length=3, max_length=32) display_name: str = Field(..., min_length=1, max_length=100) - + password: str = Field(..., min_length=12, max_length=128) + @field_validator('username') @classmethod def validate_username(cls, v): if not re.match(r'^[a-z0-9_]{3,32}$', v): raise ValueError('username должен содержать только a-z, 0-9, _ (3-32 символа)') return v - + @field_validator('display_name') @classmethod def validate_display_name(cls, v): @@ -24,10 +23,18 @@ class CreateUserRequest(BaseModel): raise ValueError('display_name не может состоять только из пробелов') return v + @field_validator('password') + @classmethod + def validate_password(cls, v): + if not v.strip(): + raise ValueError('password не может состоять только из пробелов') + return v + + class CreateChatRequest(BaseModel): title: str = Field(..., min_length=1, max_length=100) member_ids: List[str] = Field(..., min_length=1, max_length=100) - + @field_validator('title') @classmethod def validate_title(cls, v): @@ -35,9 +42,10 @@ class CreateChatRequest(BaseModel): raise ValueError('title не может состоять только из пробелов') return v + class CreateMessageRequest(BaseModel): text: str = Field(..., min_length=1, max_length=4000) - + @field_validator('text') @classmethod def validate_text(cls, v): @@ -52,12 +60,14 @@ class UserResponse(BaseModel): display_name: str created_at: str + class ChatResponse(BaseModel): id: str title: str member_ids: List[str] created_at: str + class MessageResponse(BaseModel): id: str chat_id: str @@ -65,200 +75,23 @@ class MessageResponse(BaseModel): text: str created_at: str + class ChatPage(BaseModel): items: List[ChatResponse] next_cursor: Optional[str] = None + class MessagePage(BaseModel): items: List[MessageResponse] next_cursor: Optional[str] = None + +class SessionResponse(BaseModel): + token: str + token_type: str = "Bearer" + expires_at: str + user: UserResponse + + class HealthResponse(BaseModel): - status: str = "ok" - -class ErrorResponse(BaseModel): - error: dict - - -class InMemoryStore: - def __init__(self): - self._lock = asyncio.Lock() - self.users: Dict[str, dict] = {} # id -> user - self.chats: Dict[str, dict] = {} # id -> chat - self.messages: Dict[str, List[dict]] = {} # chat_id -> [messages] - self.usernames: Dict[str, str] = {} # username -> user_id (для проверки уникальности) - - - async def create_user(self, username: str, display_name: str) -> dict: - async with self._lock: - if username in self.usernames: - raise ValueError("username_already_exists") - - user_id = str(uuid4()) - now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') - - user = { - "id": user_id, - "username": username, - "display_name": display_name, - "created_at": now - } - - self.users[user_id] = user - self.usernames[username] = user_id - - return user - - async def get_user(self, user_id: str) -> Optional[dict]: - async with self._lock: - return self.users.get(user_id) - - async def get_user_by_username(self, username: str) -> Optional[dict]: - async with self._lock: - user_id = self.usernames.get(username) - if user_id: - return self.users.get(user_id) - return None - - - async def create_chat(self, title: str, member_ids: List[str], creator_id: str) -> dict: - async with self._lock: - # Проверяем, что все участники существуют - for member_id in member_ids: - if member_id not in self.users: - raise ValueError("user_not_found") - - # Проверяем, что создатель входит в список участников - if creator_id not in member_ids: - raise ValueError("creator_not_in_members") - - # Проверяем уникальность member_ids - if len(member_ids) != len(set(member_ids)): - raise ValueError("duplicate_members") - - chat_id = str(uuid4()) - now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') - - chat = { - "id": chat_id, - "title": title, - "member_ids": member_ids, - "created_at": now - } - - self.chats[chat_id] = chat - self.messages[chat_id] = [] - - return chat - - async def get_chat(self, chat_id: str, user_id: str) -> Optional[dict]: - async with self._lock: - chat = self.chats.get(chat_id) - if not chat: - return None - - # Проверяем, что пользователь является участником - if user_id not in chat["member_ids"]: - return None - - return chat - - async def list_chats(self, user_id: str, limit: int = 50, cursor: Optional[str] = None) -> tuple: - async with self._lock: - # Получаем все чаты пользователя - user_chats = [ - chat for chat in self.chats.values() - if user_id in chat["member_ids"] - ] - - # Сортируем по (created_at, id) - user_chats.sort(key=lambda c: (c["created_at"], c["id"])) - - # Применяем cursor - if cursor: - # cursor — это "created_at,id" последнего элемента предыдущей страницы - cursor_parts = cursor.split(",", 1) - if len(cursor_parts) == 2: - cursor_time, cursor_id = cursor_parts - user_chats = [ - c for c in user_chats - if (c["created_at"], c["id"]) > (cursor_time, cursor_id) - ] - - # Ограничиваем количество - has_more = len(user_chats) > limit - page = user_chats[:limit] - - # Формируем next_cursor - next_cursor = None - if has_more and page: - last_item = page[-1] - next_cursor = f"{last_item['created_at']},{last_item['id']}" - - return page, next_cursor - - - async def create_message(self, chat_id: str, sender_id: str, text: str) -> dict: - async with self._lock: - # Проверяем, что чат существует - if chat_id not in self.chats: - raise ValueError("chat_not_found") - - # Проверяем, что отправитель является участником чата - chat = self.chats[chat_id] - if sender_id not in chat["member_ids"]: - raise ValueError("sender_not_in_chat") - - message_id = str(uuid4()) - now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') - - message = { - "id": message_id, - "chat_id": chat_id, - "sender_id": sender_id, - "text": text, - "created_at": now - } - - self.messages[chat_id].append(message) - - return message - - async def list_messages(self, chat_id: str, user_id: str, limit: int = 50, cursor: Optional[str] = None) -> tuple: - async with self._lock: - # Проверяем, что чат существует и пользователь является участником - chat = self.chats.get(chat_id) - if not chat: - raise ValueError("chat_not_found") - - if user_id not in chat["member_ids"]: - raise ValueError("user_not_in_chat") - - messages = self.messages.get(chat_id, []) - - # Сортируем по (created_at, id) - messages.sort(key=lambda m: (m["created_at"], m["id"])) - - # Применяем cursor - if cursor: - cursor_parts = cursor.split(",", 1) - if len(cursor_parts) == 2: - cursor_time, cursor_id = cursor_parts - messages = [ - m for m in messages - if (m["created_at"], m["id"]) > (cursor_time, cursor_id) - ] - - # Ограничиваем количество - has_more = len(messages) > limit - page = messages[:limit] - - # Формируем next_cursor - next_cursor = None - if has_more and page: - last_item = page[-1] - next_cursor = f"{last_item['created_at']},{last_item['id']}" - - return page, next_cursor - -store = InMemoryStore() \ No newline at end of file + status: str = "ok" \ No newline at end of file -- 2.54.0 From e5af5283f3db7e9261159f76627b82b80e9c33d2 Mon Sep 17 00:00:00 2001 From: Arina Date: Wed, 11 Nov 2026 23:02:03 +0300 Subject: [PATCH 3/3] =?UTF-8?q?=D0=BD=D0=B0=D0=BF=D0=B8=D1=81=D0=B0=D0=BD?= =?UTF-8?q?=20REPORT.md,=20=D0=BF=D0=BE=D0=B4=D0=B3=D0=BE=D1=82=D0=BE?= =?UTF-8?q?=D0=B2=D0=BA=D0=B0=20=D0=BA=20PR?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 124 ++++++++++++++++++++++---- screenshots/lab2_persistence_pass.png | Bin 0 -> 17739 bytes screenshots/lab2_smoke_pass.png | Bin 0 -> 12955 bytes screenshots/lab2_tables.png | Bin 0 -> 21865 bytes 4 files changed, 107 insertions(+), 17 deletions(-) create mode 100644 screenshots/lab2_persistence_pass.png create mode 100644 screenshots/lab2_smoke_pass.png create mode 100644 screenshots/lab2_tables.png diff --git a/REPORT.md b/REPORT.md index e42f2b05..30f87207 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,127 @@ # Отчёт — лабораторная 2 +**Автор, группа:** Кашкарова Арина, БПИ2302 +**Целевая оценка:** 3 +**Commit/PR:** TODO +**Использованные источники, библиотеки и помощь ИИ:** Python 3.11, FastAPI, Uvicorn, Pydantic, PostgreSQL 16.1, psycopg2-binary, bcrypt, Docker, Docker Compose. ИИ использовался для генерации начального скелета кода, отладки форматирования ответов под OpenAPI контракт и настройки Docker Compose. -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO ## Запуск из чистого clone +**Prerequisites:** Python 3.9+, Docker, Docker Compose, Git. -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +1. **Клонирование и подготовка окружения:** + ```bash + git clone https://gitea.privcloud.tech/ari_kash/mtusi2026lab2.git + cd mtusi2026lab2 + python3 -m venv .venv + source .venv/Scripts/activate + pip install -r requirements.txt + pip install -r requirements-dev.txt + +2. Создание .env: + ```bash + cp .env.example .env + ``` + +3. Сборка и запуск стенда (API + PostgreSQL): + ```bash + docker compose up -d --build + ``` + +4. Ожидание готовности и проверка: + ```bash + curl http://localhost:8080/health/ready + ``` + +5. Запуск тестов: + ```bash + # Smoke test (базовый сценарий API) + python tests/smoke.py --base-url "http://localhost:8080" + # Test persistence (проверка сохранности данных после рестарта) + python tests/resilience.py --mode persistence --action-script "scripts/restart.bat" --base-url "http://localhost:8080" + ``` + +6. Безопасная остановка и удаление учебных данных: + ```bash + # Остановка контейнеров (данные сохраняются в volume) + docker compose down + + # Полное удаление включая volumes (сброс всех данных) + docker compose down -v + ``` ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Схема процессов и хранилищ +Клиент → HTTP API (FastAPI) → PostgreSQL + ↓ + Сессии в PostgreSQL + +Компоненты: +- API процесс: Uvicorn + FastAPI, запущен как PID 1 в Docker-контейнере +- PostgreSQL 16.1: Источник истины для всех данных (пользователи, чаты, сообщения, сессии) +- Named volume: postgres_data:/var/lib/postgresql/data обеспечивает сохранность данных + +Таблицы базы данных +Схема включает 5 таблиц с ограничениями: +1. users — пользователи (PK: id, UNIQUE: username) +2. chats — чаты (PK: id) +3. chat_members — участники чатов (PK: (chat_id, user_id), FK на users и chats) +4. messages — сообщения (PK: id, FK на chats и users, индекс на (chat_id, created_at, id)) +5. sessions — сессии (PK: token, FK на users, TTL через expires_at) +Миграции: Файл src/migrations/001_initial.sql запускается idempotently при старте приложения (CREATE TABLE IF NOT EXISTS). + +Аутентификация и безопасность +- Регистрация (POST /api/v1/users): Пароль хешируется через SHA-256 pre-hash + bcrypt (обход лимита 72 байт bcrypt) +- Вход (POST /api/v1/auth/sessions): Basic authentication (username:password в base64) +- Сессии: Opaque Bearer-токен с 256 битами энтропии (secrets.token_hex(32)), TTL = 3600 секунд +- Защищённые endpoint: Требуют Authorization: Bearer +- Logout (DELETE /api/v1/auth/sessions/current): Удаляет сессию из БД + +Транзакционные границы +- Создание чата: Атомарная операция — вставка в chats и chat_members в одной транзакции +- Все write-операции: Используют контекстный менеджер get_db() с commit/rollback +- Параметризованные запросы: Все SQL-запросы используют %s placeholder для защиты от SQL-инъекций + +Из lab1 были перенесены src/models.py src/__init__.py src/models.py Dockerfile и requierements.txt -- все эти файлы так же были изменены под задачу lab2 + +Соответствие .env.example +- DATABASE_URL=postgresql://messenger:messenger_pass@postgres:5432/messenger — используется в docker-compose.yaml +SESSION_TTL_SECONDS=3600 — читается в auth.py +- Секреты (пароль БД) не зашиты в образ, передаются через переменные окружения + ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | python tests/smoke.py --base-url "http://localhost:8080" | PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. | screenshots/lab2_smoke_pass.png | +| Persistence test | python tests/resilience.py --mode persistence --action-script "scripts/restart.bat" --base-url "http://localhost:8080" | Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +(.venv) | screenshots/lab2_persistence_pass.png | +| PostgreSQL с таблицами | docker compose exec postgres psql -U messenger -d messenger -c "\dt" | Показывает 5 таблиц: users, chats, chat_members, messages, sessions | screenshots/lab2_tables.png | +| Миграции idempotently | Перезапуск API с теми же миграциями | Ошибок нет, данные не дублируются | — | +| Атомарное создание чата | Создание чата с 3 участниками | Чат и все 3 записи в chat_members создаются атомарно | — | +| Basic → Bearer | POST /api/v1/auth/sessions с Basic, затем GET /api/v1/users/me с Bearer | 201 Created с токеном, затем 200 OK с данными пользователя | — | +| WWW-Authenticate заголовки | Запрос без Authorization к /api/v1/users/me | 401 Unauthorized с заголовком WWW-Authenticate: Bearer realm="messenger" | — | +| Хеширование паролей | +Проверка кода в auth.py | Используется bcrypt.hashpw() с SHA-256 pre-hash | src/auth.py | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. - | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Перезапуск API и PostgreSQL (docker compose restart api postgres) | Все данные (пользователи, чаты, сообщения, сессии) сохраняются благодаря именованному volume postgres_data | После рестарта тот же Bearer-токен позволяет читать данные, созданные до рестарта | ~5-7 секунд на старт PostgreSQL + API. Данные не теряются | +| Истечение сессии (TTL) | +Установка SESSION_TTL_SECONDS=2, ожидание 3 секунды | Сессия становится недействительной, запросы возвращают 401 Unauthorized | Мгновенно после expiry | +| Logout | DELETE /api/v1/auth/sessions/current, затем повтор запроса с тем же токеном | 204 No Content, затем 401 Unauthorized | Мгновенно. Сессия удаляется из БД | +| Неверный пароль | POST /api/v1/auth/sessions с неправильным паролем | 401 Unauthorized с WWW-Authenticate: Basic realm="messenger" | Мгновенно | + ## Ограничения и следующие шаги - -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Что реализовано и работает: +✅ Все endpoint'ы lab1 перенесены с новой аутентификацией +✅ PostgreSQL с миграциями, индексами и внешними ключами +✅ Сессии сохраняются в PostgreSQL и переживают рестарт +✅ Smoke test и persistence test проходят +✅ WWW-Authenticate заголовки соответствуют контракту +✅ Пароли хешируются bcrypt diff --git a/screenshots/lab2_persistence_pass.png b/screenshots/lab2_persistence_pass.png new file mode 100644 index 0000000000000000000000000000000000000000..9a23fe2cdfa4059c339cde5643824a6103db9d78 GIT binary patch literal 17739 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 H(P8 zF`4^s^o|(#VNNbgEisvD&a)h@Pg~pNCO7GXt~~{r?Vdp=&ZfxA+@yvYJ{WAw;aTvO z>gZ9-5tBmNry3PCUphwm(oR}NCH0NCKzu)Yblyr1+WQ^PqdtG31vY=-j_3-)y)4T% z(-Wyx3lE=CgEnK8bQS}hPfo|!`$bj* z@$b462JOHpn@w`@Qv7g4k!_%#uJ;R`+67Jel&YW^Uj%|wv>+FeDKf6d}UU`Y6MNYdN?y4XVa!x94S2-modA5P4R~*8t1%=fj&6 z%-qqJxCr2ngpAkExa|5Zrc6RGZ`?SQ>UGuDiLh``r98f>6f_O2PS9}bNlY_m#SO*- z*PhVotvsOKDNa%+RjWLd^svcLh=nOYg>2x3vz8CVtMOUhNyp~gG+$00MsBR-XXrxI zvVy)5E}2_x}duFMpFV{RgVU;V8P1$p0yD(NbX*|F_x|LL2gbA@y4F!P`xFzZZG; zCi`<$`0+35STi(num|nI>ikiD;QQ2@72wpRi}ntS)ZwpN?Zz7IA?@f1&@WfYtC*;K zzv57*$eC~XCWOln6Y&J#%3-s3&azr z5bqWY33L-hqr!*|4T;@RWI{+f-8wah6895o`Qf+sr-i!A_(h-=R8saioWb>!kpaQe{O!Rj?}WTOt>_kNe&hRR zXc6pgwc;x@Q+e(T|A|w`N>+QLpSm#K>!O zmabyb+OhB#FvFL3lOEj}Z{Z#~lT>`}u*~Rf^Fv9}b>|_IlpqDh@yjC`S^P%1tbW(F zUXw)GwMP6L#a#ZR>uF0Zd3pKG5;z?V2>rU26F~Bcxob8q4@E?VLZcQn<`M-N9N>WK zX#Qg?zyim(GH?)_dqmN5>{H0vxc<0fYkk0qjeO^(8Zy4KQ|uEMY%k5%su%75*x2fT zHitdtlCb|qc2`{V<*ddJx6S$fto}0#e+mOW4#=HbUHp9u^i5!Sb|}JCT|Tg+#?5+Z zC)sQ^CW*cgy8ppn=$-wqt?v9&K`RvSiuJbjI#cb4?#|x;Q znu6|kAbsPSPJW|Ye0%4Lr)$P4V|^6z0LG=1k6zC((|9QQS(bbJ!p`{Cm5T_44BwNW z0>+gh(^ibW`66R`r_i`GV#bc=Ba~Iz&ozElvK6jJ;MkQ%*qL0&sGq&m3KHxTe#ISq zKa76qVq02}WpY|{>!N0;GkL_^?%!-CxkxuH75~>3ms!=H!bN5O)o1hNi6gPOOk}9q z+lcURM!|xn?f!nan1G_x9!Ppc(6F)>uPw*xM9h_G2HKkdsRLp~HQ-sHAD3TpQTnp^ zReJ~`fDpK4i!6tXanD9xODuweV^WG{+Q_`P*okAR)IA_KwuVE1q!}WRligCpCMDcYpJ5Ye*n#WOghkO_oit)9Bqi&Zzt2{4d6EN)y;26^ zxACJ)UV{2-x&3h3vKkQrc|uk(f6JI_)C*tqEVFr2B)qjEyMXXYG{9x}pYp_1J&Lo4 zO#g^@gd8`?@3Sd-q9eV#`9jO;0wx>#N%2r|^SC?+RVCqbZP_eu{P3MNW|Wb92wwl6 zjFKsW*K=0$6W1))una%k7AvbQI}QzQQMg!Cd7_Sm2U=u|mcFYrCKh?8u^DGol953%#eVHd&v5(>ezXZ9+_VzUrv28+bFPmkO5HXz z(H}f=d$-4d9^XhcErri2px;GXi$*1yPol)(zWEs(EOy21cPKnp?=8T&6uh!g@C>&T zGSde5u0bYGh#4N{d0!m3;{_YC;k_3ghV&bvG9!%SoJf*Cbm@vn3X~PR+#Bq;eSn4f zQwd2pD!zXoSy-ihGwQN52ge-lYNWsBaqzPm`cB`eKm_>{CCAxtvO}<>suk~>8Y#ql#_$tY*C`fO3 zo(P4=4s_DM-d7R_w)jc?HNzs_ZO(pQo_PNr<+_6rt;pn%!dYY}7%%*iRUG^jj`WpU z^j_vS_6x-nd{xW(^7p~Ys}`+ALk5_gn{k;pj&ZP-sr=!dLc?OTB(oIQUrj0)IhO7< zFk5sB&j4ys|6xrG+0G!HF&=74_-Y$3I(6VMM>=ylSVY!iAOn6jT%h zneHqVxJKdiLgk*3)SFm*AoHicN8HgnUfPQA+ot-L9WiXLwrU0<@ZG2@@b}E8Ok;WE z!B)vRdl4~uv0B$y!TK-Xzne*I#AX-dqVbxDwtD2=T*wQng+tc7A({B1m&sdqH1~Sz zb{cRf_qn?;_XjSAn{u1CXgrTP<3+8hXFT4?-cU(LmW>NAc8N~Z-uwDWQ+wbhoTf9Y zkUk>TJLwvcDK2$-`L|!rpe?RettunD$OQ_Ttfh<&b}T&n?8d*+1Gr85Fc-C%XDFDn zQ;aZ!#v&-x_O5c2+H2I$t2QW3zQR?tP*@n0qNVT(UfbaWlMlJu25;UcX;CvbcecR= zi_Lr5%mw}o-U!n9pSGdZRt3Ys1gj0#b@}AeS@60s<HXdheq>n2fq@@H!09iVYUK~U*Il463B{Uf>? zwPNPDmPc@!a=$fZvFm5SJ7z#fCvDg@{+*Uu^s5H*g@1XFflf?{StXzQtOvYzr}bw9 z!=ctzScR&~m7Gn2BEds}TXXsj;f?6YBMW2y@t@NRRyb7*oG#6Sc*i^EN>`zZb%g-(#qCDt5z(DftD*{4gw>V;S%Gf--1-cs-UA|nwntad`!yCLS6&2xC z>I^zh*RdSf4?zs}iM53D9Vr!(&+R1pV0&dUIrQ-IJHg*h@_+X<4@bvkPLY+jjPBi& zf>&<$_iDbF+KE>xV%0#of0SFtgod!lU7Pq1$>j70g;%ykAJ#@!UFSEuoFHB9n}rTV zE1c5o9usONGfK%p;_NfGh7jWoGUwr?6nf-0j3nyO3D;bEH+e_7Co0a@wZSpnb{cDikgy3sB!{f3HvlD}O`qqPGJ5 z@?4#NbXRPJi=B0Q&0;5(66+o|dwX}z*TRDE_MpGw{`wviP;E6nWya3*jn?bo?@f9? z;RX+fVxOo{L{lm%gaXw?) zs*Eujw0R;CFE%t2^T|GZUMsQ4W59o=q{6?JMhV)9Ga+?WmawyiSW~Q{Kf>|VT<^slyCEDe9wPZEnH48+S78{%&x&Gscr&~1p zLxdb|+?zEMA!_JrZ8k_yc{Hlo93DBp=kkRL8C=JV+~~+NucX)Gg%dG2i~4Q&4}H>- zd2R|@k@Eg&`fx7Rrrb9<_z%URMf;~mFqWtnzQgV)v%7E3K8AVPUZQ>Uey-_E^PPnL z!?yyw|6ja|>wncx{;$TuS4z*9{pZ?fGH6Kuo5_`^h?v1;tvA1Zbgn|ann{5#@FOWe z#s2Vn`1dQZ-l?T8)LLV}*{cj2$K8C;sag}qFRy#$?ImA?{?8!1c$^YcwOZez$s|VO z!+j&HLy{Dlf51(*<=L-rdnomPCvYmMf>TW1lklv~I^_6^bu~u9_klRX*ughQCjVz< zGVkHy)R72^8QaY>e-!?*o@Bdj1^*BDJdllV?yV*1sLr78=m-qn2FV*n;7*~j7;egl z5?Z7zf#QwWDgHkbi}j8mL}F^IDH;V}qzvgCa=`(pWVhuqk^{>hCXbQy8)rQFOCigw z(L8t~@tmvT^hM~}P?<8FWxJ@i z$;ZYB5lqN#n`wx(Tjp3&;f+9i|Anbw?o4>U5IsBR7j$I6XhmCZZM)|BVgL{HxhwEr zkDM}2VHVfh1q4!8j_;Ff%VS060Fdn7jMe_M?dN&Lu<`dTwfV2~KeJkZ(KNj}sq(WI z1i<0(o(A~w!U*GkEjA$Z$qOM#jrVH=GPw3NkqDy#b{aw=k1aP`$*+W}svQnlO7^~_ zhg19i+z4$dKV~uDSvFKj|Bq~_m9{dr;e{{qYZ26&kVzWQc_TwO2?sI%Gu0sYR?g{y zB>8ILRnxC9&);K~!rN$npSAp1mGtM?_73yfNXY~x->Qk^vw#-o%mH=HujBp=*XIi} zXTi6_T}Iv?Cu>ngZZrSS>{J;h9PB&L(RJ(3RoDpCp3Q!sXfy$)`o|ZGQd~}dN_uxc zXip>8wobS^PH-vgZRjfH@=L4!a7K7?=f=|-OcQ4x0}htCT|A+X%<=?0J15uLP#fas z!pWx?G)?+7%YqXNxZx(eV}*>_@SlFJ;P<5Xgvh5CC9>IjgkFG#ZJvQz0d~4DUvorO zF0pWCW$=6Wccs#VlT%Hjm*l;)Yg@;Yz8oHyE)$C!SZ7F7h$*uwOt$X*7gE+2n*>_4 zdwPLIsYv^xX)K^+(O?sw%v1c@z{S9`ujGoIZTim3pl*hf+;8@ZIYw~jiDmdKI;Vst02SQfBLDyZ literal 0 HcmV?d00001 diff --git a/screenshots/lab2_smoke_pass.png b/screenshots/lab2_smoke_pass.png new file mode 100644 index 0000000000000000000000000000000000000000..a8086386cade01889191a7619e85324bf9fcd12f GIT binary patch literal 12955 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,%)`@Tfu~KN7g1#%cRD$u(whk*4As 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 Vb5sq&|4;(>_+Cl6;+;X@{{dnb8&LoN literal 0 HcmV?d00001 diff --git a/screenshots/lab2_tables.png b/screenshots/lab2_tables.png new file mode 100644 index 0000000000000000000000000000000000000000..949d14da1fc3692c200ad4aa98c9130c1dfd402f GIT binary patch literal 21865 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 UdLI?R=TQ+>W_G4k2aYEE3GhAE{Qv*} literal 0 HcmV?d00001 -- 2.54.0