From 491ff37b2e99eeae9df3ccd2fc2881d2e187da99 Mon Sep 17 00:00:00 2001 From: Xenia Date: Mon, 19 Oct 2026 20:54:45 +0300 Subject: [PATCH] lab2: PostgreSQL, Redis sessions, Track 2 (Explain, Backup) and report --- Dockerfile | 21 ++ REPORT.md | 153 ++++++++++++-- app.py | 374 +++++++++++++++++++++++++++++++++ docker-compose.yml | 33 +++ evidence/00_environment.txt | 9 + evidence/01_persistence.txt | 8 + evidence/02_redis_ttl.txt | 6 + evidence/03_explain_track2.txt | 10 + evidence/04_track2_backup.txt | 11 + migrations/001_init.sql | 36 ++++ requirements.txt | 3 + tests/test_concurrent.py | 38 ++++ tests/test_extra.py | 117 +++++++++++ 13 files changed, 796 insertions(+), 23 deletions(-) create mode 100644 Dockerfile create mode 100644 app.py create mode 100644 docker-compose.yml create mode 100644 evidence/00_environment.txt create mode 100644 evidence/01_persistence.txt create mode 100644 evidence/02_redis_ttl.txt create mode 100644 evidence/03_explain_track2.txt create mode 100644 evidence/04_track2_backup.txt create mode 100644 migrations/001_init.sql create mode 100644 requirements.txt create mode 100644 tests/test_concurrent.py create mode 100644 tests/test_extra.py diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..8a7e194 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,21 @@ +FROM python:3.12-slim + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 + +WORKDIR /mtusi-messenger-lab2 + +RUN useradd -m -u 10001 appuser + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY app.py . + +USER appuser +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --retries=3 \ + CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/live', timeout=2)" || exit 1 + +CMD ["python", "app.py"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index e42f2b0..4b67cf0 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,144 @@ -# Отчёт — лабораторная 2 +# Отчёт — Лабораторная 2 (PostgreSQL, сессии и Redis/Valkey) -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- **Автор, группа:** Захарова Ксения Алексеевна, БВТ2302 +- **Целевая оценка:** 5 (выбран Трек 2: План запроса и восстановление) +- **Commit/PR:** TODO после публикации +- **Использованные источники, библиотеки и помощь ИИ:** + - Официальная документация PostgreSQL (EXPLAIN, pg_dump). + - Документация Redis/Valkey (TTL, AOF). + - Стандартная библиотека Python 3.12, библиотеки `psycopg2`, `bcrypt`, `redis`. +## 1. Запуск из чистого clone -## Запуск из чистого clone +### 1.1. Требования -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +- Docker Desktop (с плагином Docker Compose). +- Python 3.9+ (только для запуска клиентских тестов, например, `tests/smoke.py`). +- Свободные порты: `8080` (API), `5432` (PostgreSQL), `6379` (Redis). -## Архитектура и решения +### 1.2. Инструкция по развертыванию -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Все зависимости (БД, кэш, API) поднимаются из этого репозитория через Docker Compose. Наличие установленной локально БД не требуется. -## Доказательства критериев +```bash +git clone mtusi-messenger-lab2 +cd mtusi-messenger-lab2 +cp .env.example .env +docker compose --env-file .env up -d --build +for i in $(seq 1 30); do + curl -fsS http://localhost:8080/health/ready && break + sleep 1 +done +make test +``` + +### 1.3. Остановка и удаление данных + +Безопасная остановка с сохранением данных: + +```bash +docker compose down +``` + +Удаление volumes с БД и Redis: + +```bash +docker compose down -v +``` + +--- + +## 2. Архитектура и решения + +### 2.1. Схема процессов и хранилищ + +- **API (Python 3.12):** стандартная библиотека `http.server`, `ThreadingHTTPServer`, пул `psycopg2.pool.ThreadedConnectionPool` до 20 соединений. +- **PostgreSQL 16 (источник истины):** таблицы `users`, `chats`, `chat_members`, `messages`; транзакции `BEGIN/COMMIT/ROLLBACK`. +- **Redis/Valkey 7 (сессии):** ключи `session:` с TTL по умолчанию 3600 секунд; включено персистентное хранение. + +### 2.2. Переход от Lab 1 + +- Удален `X-User-Id`; бизнес-запросы требуют `Authorization: Bearer `. +- Добавлен `POST /api/v1/auth/sessions` с Basic Auth (`username:password` в Base64). +- Пароли хэшируются `bcrypt` с солью. +- Добавлена миграция `migrations/001_init.sql`, автоматически применяемая при инициализации PostgreSQL. + +### 2.3. Переменные окружения + +- `DB_HOST`, `DB_USER`, `DB_PASSWORD`, `DB_NAME` — подключение к PostgreSQL. +- `REDIS_HOST` — хост Redis. +- `SESSION_TTL_SECONDS` — TTL сессии. + +--- + +## 3. Доказательства критериев + +Все результаты сохранены в `evidence/` без токенов и персональных данных. | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| :--- | :--- | :--- | :--- | +| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/smoke.txt` | +| Persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | После рестарта БД и Redis токен успешно используется | `evidence/01_persistence.txt` | +| Транзакционность создания чата | Негативный тест | При ошибке в `member_ids` выполняется `ROLLBACK` | `tests/test_extra.py` | +| Гонка регистрации | Два одновременных POST `/users` | Один `201 Created`, второй `409 Conflict` | `tests/test_extra.py` | +| Redis TTL | `valkey-cli keys "*"` / `ttl` | `session:*` существует, TTL уменьшается | `evidence/02_redis_ttl.txt` | +| План запроса | `EXPLAIN (ANALYZE, BUFFERS)` | `Index Scan` 0.093 ms вместо `Seq Scan` 29.7 ms | `evidence/03_explain_track2.txt` | +| Отказ Redis | `docker compose stop redis` | `500 Internal Error`, анонимный доступ не разрешается | `evidence/05_failure_analysis.txt` | +| **Трек 2: Backup/Restore** | `pg_dump` → `down -v` → `psql -f` | 100 000 строк до и после | `evidence/04_track2_backup.txt` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +--- -## Эксперименты и отказы +## 4. Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +### 4.1. Исследование плана запроса и стоимости индекса -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +- **Гипотеза:** отсутствие индекса `(chat_id, created_at, id)` при росте истории сообщений приводит к деградации пагинации из-за полного сканирования таблицы. +- **Методика:** сгенерировано 100 000 сообщений через `generate_series`; использован `EXPLAIN (ANALYZE, BUFFERS)`. +- **С индексом:** `Index Scan`, **0.093 мс**, 5 страниц. +- **Без индекса:** `Seq Scan + Sort`, **29.751 мс**, 1241 страница. +- **Вывод:** индекс ускоряет пагинацию примерно в **320 раз**. -## Ограничения и следующие шаги +### 4.2. Резервное копирование и восстановление -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- **Гипотеза:** после удаления Docker Volume данные теряются без резервной копии, но `pg_dump` позволяет восстановить исходное состояние. +- **Методика:** `pg_dump` → `docker compose down -v` → чистый контейнер → восстановление через `psql`. +- Строк до сноса: **100 000**. +- Строк после восстановления: **100 000**. +- **RTO:** ~5 секунд. +- **Потеря данных:** 0 сообщений; дамп создавался на остановленной или стабильной системе. + +### 4.3. Анализ отказа Redis + +| Воздействие | Что ожидаем | Что наблюдали | Восстановление | +| :--- | :--- | :--- | :--- | +| `docker compose stop redis` | API не пропускает запросы без валидной сессии | `500 Internal Error`, сессии недоступны | `docker compose start redis` → система восстановилась, потери данных нет | + +--- + +## 5. Ограничения и следующие шаги + +### 5.1. Какие отказы выдерживает система + +- Перезапуск API, БД и Redis с сохранением именованных volumes — данные и сессии не теряются. +- Падение Redis — API не допускает пользователей без проверки токена. +- Нарушение уникальности `username` — `409 Conflict`. +- Ошибка транзакции создания чата — `ROLLBACK`, состояние остается консистентным. + +### 5.2. Ограничения и учебные упрощения + +- Docker Compose работает на одном Docker host и не обеспечивает отказоустойчивость при его потере. +- Пул соединений ограничен 20 соединениями. +- Трафик между API и БД не шифруется; TLS/mTLS планируется добавить позднее. + +### 5.3. Ответы на вопросы на защите + +1. **Что подтверждает COMMIT?** + `COMMIT` подтверждает успешное завершение транзакции. При `synchronous_commit = on` данные подтверждаются через WAL согласно настройкам PostgreSQL. + +2. **Где хранятся сессии и что происходит после restart Redis?** + Сессии хранятся в Redis. Благодаря volume и включенному персистентному сохранению они восстанавливаются после рестарта контейнера. При `FLUSHALL` сессии исчезнут, и пользователи получат `401 Unauthorized`. + +3. **Чем аутентификация отличается от доступа?** + Аутентификация определяет, кто пользователь — например, проверяет Bearer-токен. Авторизация определяет, какие ресурсы ему доступны — например, состоит ли он в `chat_members`. Валидный токен не дает права читать чужой чат. + +4. **Почему hash пароля и checksum разные?** + `bcrypt` предназначен для безопасного хранения паролей: он медленный и использует соль. `SHA-256` — быстрый детерминированный checksum/hash для проверки целостности, поэтому для хранения паролей он не подходит. diff --git a/app.py b/app.py new file mode 100644 index 0000000..3a766dd --- /dev/null +++ b/app.py @@ -0,0 +1,374 @@ +#!/usr/bin/env python3 +import base64 +import json +import os +import re +import secrets +import signal +import sys +import threading +import time +import traceback +import uuid +import bcrypt +import psycopg2 +import psycopg2.pool +import redis +from datetime import datetime, timezone, timedelta +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from urllib.parse import urlparse, parse_qs + +HOST = os.environ.get("APP_HOST", "0.0.0.0") +PORT = int(os.environ.get("APP_PORT", "8080")) +SESSION_TTL = int(os.environ.get("SESSION_TTL_SECONDS", 3600)) + +# Пул подключений к PostgreSQL +db_pool = psycopg2.pool.ThreadedConnectionPool( + 1, 20, + host=os.environ.get("DB_HOST", "localhost"), + user=os.environ.get("DB_USER", "postgres"), + password=os.environ.get("DB_PASSWORD", "secret"), + dbname=os.environ.get("DB_NAME", "messenger") +) + +# Подключение к Redis для сессий +redis_client = redis.Redis( + host=os.environ.get("REDIS_HOST", "localhost"), + port=6379, + decode_responses=True +) + +class APIError(Exception): + def __init__(self, status, code, message): + self.status = status + self.code = code + self.message = message + +def now_iso(): + return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ") + +def encode_cursor(resource_type, resource_id, item): + payload = {"r": resource_type, "id": resource_id, "ts": item["created_at"], "iid": item["id"]} + raw = json.dumps(payload, separators=(",", ":")).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=") + +def decode_cursor(cursor, resource_type, resource_id): + try: + padding = "=" * (-len(cursor) % 4) + raw = base64.urlsafe_b64decode(cursor + padding) + payload = json.loads(raw.decode("utf-8")) + if payload.get("r") != resource_type or payload.get("id") != resource_id: + raise ValueError() + return payload["ts"], payload["iid"] + except Exception: + raise APIError(400, "invalid_request", "Invalid cursor") + +def read_json(handler): + length = handler.headers.get("Content-Length") + if not length: raise APIError(400, "invalid_request", "Missing body") + raw = handler.rfile.read(int(length)) + try: return json.loads(raw.decode("utf-8")) + except Exception: raise APIError(400, "invalid_request", "Malformed JSON") + +def get_user_by_token(handler): + auth = handler.headers.get("Authorization") + if not auth or not auth.startswith("Bearer "): + raise APIError(401, "unauthorized", "Missing Bearer token") + token = auth.split(" ")[1] + + # Достаем user_id из Redis + user_id = redis_client.get(f"session:{token}") + if not user_id: + raise APIError(401, "unauthorized", "Invalid or expired token") + + conn = db_pool.getconn() + try: + 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 not row: raise APIError(401, "unauthorized", "User not found") + return { + "id": str(row[0]), "username": row[1], "display_name": row[2], + "created_at": row[3].strftime("%Y-%m-%dT%H:%M:%S.%fZ") + } + finally: + db_pool.putconn(conn) + +class Handler(BaseHTTPRequestHandler): + protocol_version = "HTTP/1.1" + server_version = "MessengerLab2/2.0" + + def do_GET(self): self.handle_request("GET") + def do_POST(self): self.handle_request("POST") + def do_DELETE(self): self.handle_request("DELETE") + + def handle_request(self, method): + request_id = str(uuid.uuid4()) + self._status = None + try: + parsed = urlparse(self.path) + path = parsed.path + query = parse_qs(parsed.query) + + if method == "GET" and path == "/health/live": + return self.send_json(200, {"status": "ok"}, request_id) + if method == "GET" and path == "/health/ready": + # Проверяем БД + try: + conn = db_pool.getconn() + with conn.cursor() as cur: cur.execute("SELECT 1") + db_pool.putconn(conn) + return self.send_json(200, {"status": "ok"}, request_id) + except Exception: + raise APIError(503, "unavailable", "DB not ready") + + if method == "POST" and path == "/api/v1/users": return self.create_user(request_id) + if method == "POST" and path == "/api/v1/auth/sessions": return self.create_session(request_id) + if method == "DELETE" and path == "/api/v1/auth/sessions/current": return self.delete_session(request_id) + if method == "GET" and path == "/api/v1/users/me": return self.get_me(request_id) + if method == "POST" and path == "/api/v1/chats": return self.create_chat(request_id) + if method == "GET" and path == "/api/v1/chats": return self.list_chats(request_id, query) + + m = re.fullmatch(r"/api/v1/chats/([^/]+)", path) + if m and method == "GET": return self.get_chat(request_id, m.group(1)) + + m = re.fullmatch(r"/api/v1/chats/([^/]+)/messages", path) + if m: + if method == "POST": return self.create_message(request_id, m.group(1)) + if method == "GET": return self.list_messages(request_id, m.group(1), query) + + raise APIError(404, "not_found", "Not found") + except APIError as exc: + self.send_error_json(exc.status, exc.code, exc.message, request_id) + except Exception: + self.log_error("Unhandled: %s", traceback.format_exc()) + self.send_error_json(500, "internal_error", "Internal error", request_id) + + def create_user(self, request_id): + body = read_json(self) + username = body.get("username") + display_name = body.get("display_name") + password = body.get("password") + if not username or not re.fullmatch(r"[a-z0-9_]{3,32}", username): + raise APIError(400, "invalid_request", "Invalid username") + if not password or len(password) < 8: + raise APIError(400, "invalid_request", "Password must be at least 8 chars") + + pw_hash = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8') + uid = str(uuid.uuid4()) + + conn = db_pool.getconn() + try: + with conn.cursor() as cur: + cur.execute( + "INSERT INTO users (id, username, display_name, password_hash) VALUES (%s, %s, %s, %s) RETURNING created_at", + (uid, username, display_name, pw_hash) + ) + created_at = cur.fetchone()[0] + conn.commit() + self.send_json(201, {"id": uid, "username": username, "display_name": display_name, "created_at": created_at.strftime("%Y-%m-%dT%H:%M:%SZ")}, request_id) + except psycopg2.errors.UniqueViolation: + conn.rollback() + raise APIError(409, "conflict", "Username taken") + finally: + db_pool.putconn(conn) + + def create_session(self, request_id): + auth = self.headers.get("Authorization") + if not auth or not auth.startswith("Basic "): + raise APIError(401, "unauthorized", "Missing Basic auth") + try: + decoded = base64.b64decode(auth.split(" ")[1]).decode('utf-8') + username, password = decoded.split(':', 1) + except Exception: + raise APIError(401, "unauthorized", "Invalid Basic format") + + conn = db_pool.getconn() + try: + with conn.cursor() as cur: + cur.execute("SELECT id, display_name, password_hash, created_at FROM users WHERE username = %s", (username,)) + row = cur.fetchone() + if not row or not bcrypt.checkpw(password.encode('utf-8'), row[2].encode('utf-8')): + raise APIError(401, "unauthorized", "Invalid credentials") + + token = secrets.token_urlsafe(32) + # Сохраняем сессию в Redis с TTL + redis_client.setex(f"session:{token}", SESSION_TTL, row[0]) + + expires_at = (datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL)).strftime("%Y-%m-%dT%H:%M:%SZ") + + self.send_json(201, { + "token": token, "token_type": "Bearer", "expires_at": expires_at, + "user": {"id": str(row[0]), "username": username, "display_name": row[1], "created_at": row[3].strftime("%Y-%m-%dT%H:%M:%SZ")} + }, request_id) + finally: + db_pool.putconn(conn) + + def delete_session(self, request_id): + auth = self.headers.get("Authorization") + if auth and auth.startswith("Bearer "): + token = auth.split(" ")[1] + redis_client.delete(f"session:{token}") + self.send_json(204, None, request_id) + else: + raise APIError(401, "unauthorized", "Missing Bearer") + + def get_me(self, request_id): + actor = get_user_by_token(self) + self.send_json(200, actor, request_id) + + def create_chat(self, request_id): + actor = get_user_by_token(self) + body = read_json(self) + title = body.get("title") + member_ids = body.get("member_ids") + if not title or not isinstance(member_ids, list): + raise APIError(400, "invalid_request", "Invalid body") + + cid = str(uuid.uuid4()) + conn = db_pool.getconn() + try: + with conn.cursor() as cur: + cur.execute("INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING created_at", (cid, title)) + created_at = cur.fetchone()[0] + for uid in member_ids: + cur.execute("INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", (cid, uid)) + conn.commit() + self.send_json(201, {"id": cid, "title": title, "member_ids": member_ids, "created_at": created_at.strftime("%Y-%m-%dT%H:%M:%SZ")}, request_id) + except Exception: + conn.rollback() + raise + finally: + db_pool.putconn(conn) + + def list_chats(self, request_id, query): + actor = get_user_by_token(self) + conn = db_pool.getconn() + try: + 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 cm.user_id = %s ORDER BY c.created_at DESC LIMIT 50 + """, (actor["id"],)) + rows = cur.fetchall() + items = [{"id": str(r[0]), "title": r[1], "created_at": r[2].strftime("%Y-%m-%dT%H:%M:%SZ")} for r in rows] + self.send_json(200, {"items": items, "next_cursor": None}, request_id) + finally: + db_pool.putconn(conn) + + def get_chat(self, request_id, chat_id): + actor = get_user_by_token(self) + conn = db_pool.getconn() + try: + 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, actor["id"])) + row = cur.fetchone() + if not row: raise APIError(404, "not_found", "Chat not found") + + cur.execute("SELECT user_id FROM chat_members WHERE chat_id = %s", (chat_id,)) + members = [str(r[0]) for r in cur.fetchall()] + + self.send_json(200, {"id": str(row[0]), "title": row[1], "member_ids": members, "created_at": row[2].strftime("%Y-%m-%dT%H:%M:%SZ")}, request_id) + finally: + db_pool.putconn(conn) + + def create_message(self, request_id, chat_id): + actor = get_user_by_token(self) + conn = db_pool.getconn() + try: + with conn.cursor() as cur: + # Проверяем членство + cur.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, actor["id"])) + if not cur.fetchone(): raise APIError(404, "not_found", "Chat not found") + + body = read_json(self) + text = body.get("text") + if not text: raise APIError(400, "invalid_request", "Empty text") + + mid = str(uuid.uuid4()) + cur.execute( + "INSERT INTO messages (id, chat_id, sender_id, text) VALUES (%s, %s, %s, %s) RETURNING created_at", + (mid, chat_id, actor["id"], text) + ) + created_at = cur.fetchone()[0] + conn.commit() + self.send_json(201, {"id": mid, "chat_id": chat_id, "sender_id": actor["id"], "text": text, "created_at": created_at.strftime("%Y-%m-%dT%H:%M:%SZ")}, request_id) + finally: + db_pool.putconn(conn) + + def list_messages(self, request_id, chat_id, query): + actor = get_user_by_token(self) + limit = int(query.get("limit", ["50"])[0]) + cursor = query.get("cursor", [None])[0] + + conn = db_pool.getconn() + try: + with conn.cursor() as cur: + cur.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, actor["id"])) + if not cur.fetchone(): raise APIError(404, "not_found", "Chat not found") + + if cursor: + ts, iid = decode_cursor(cursor, "messages", chat_id) + cur.execute(""" + SELECT id, sender_id, text, created_at FROM messages + WHERE chat_id = %s AND (created_at, id) > (%s, %s) + ORDER BY created_at, id LIMIT %s + """, (chat_id, ts, iid, limit + 1)) + else: + cur.execute(""" + SELECT id, sender_id, text, created_at FROM messages + WHERE chat_id = %s ORDER BY created_at, id LIMIT %s + """, (chat_id, limit + 1)) + + rows = cur.fetchall() + has_more = len(rows) > limit + rows = rows[:limit] + + items = [{"id": str(r[0]), "chat_id": chat_id, "sender_id": str(r[1]), "text": r[2], "created_at": r[3].strftime("%Y-%m-%dT%H:%M:%S.%fZ")} for r in rows] + next_cursor = encode_cursor("messages", chat_id, items[-1]) if has_more and items else None + + self.send_json(200, {"items": items, "next_cursor": next_cursor}, request_id) + finally: + db_pool.putconn(conn) + + def send_json(self, status, payload, request_id): + self._status = status + if status == 204: + self.send_response(204) + self.send_header("X-Request-Id", request_id) + self.end_headers() + return + body = json.dumps(payload, ensure_ascii=False).encode("utf-8") + self.send_response(status) + self.send_header("Content-Type", "application/json") + self.send_header("X-Request-Id", request_id) + self.send_header("Content-Length", str(len(body))) + self.end_headers() + self.wfile.write(body) + + def send_error_json(self, status, code, message, request_id): + self._status = status + body = json.dumps({"error": {"code": code, "message": message, "request_id": request_id}}, ensure_ascii=False).encode("utf-8") + self.send_response(status) + self.send_header("Content-Type", "application/json") + self.send_header("X-Request-Id", request_id) + self.send_header("Content-Length", str(len(body))) + self.end_headers() + self.wfile.write(body) + +def main(): + server = ThreadingHTTPServer((HOST, PORT), Handler) + def shutdown(signum, frame): + threading.Thread(target=server.shutdown, daemon=True).start() + signal.signal(signal.SIGTERM, shutdown) + signal.signal(signal.SIGINT, shutdown) + print(f"Listening on {HOST}:{PORT}", file=sys.stderr) + server.serve_forever() + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..9cbffa6 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,33 @@ +version: '3.8' + +services: + db: + image: postgres:16-alpine + environment: + POSTGRES_DB: messenger + POSTGRES_USER: postgres + POSTGRES_PASSWORD: secret + volumes: + - pgdata:/var/lib/postgresql/data + - ./migrations:/docker-entrypoint-initdb.d # Автоматически применит 001_init.sql + + redis: + image: valkey/valkey:7-alpine + volumes: + - redisdata:/data + + api: + build: . + ports: + - "8080:8080" + environment: + - DB_HOST=db + - DB_PASSWORD=secret + - REDIS_HOST=redis + depends_on: + - db + - redis + +volumes: + pgdata: + redisdata: \ No newline at end of file diff --git a/evidence/00_environment.txt b/evidence/00_environment.txt new file mode 100644 index 0000000..6d53396 --- /dev/null +++ b/evidence/00_environment.txt @@ -0,0 +1,9 @@ +=== Окружение === +Дата: 2026-10-19 20:30:41 +Коммит: 65003b61195361aac238f19c9bff0027ca58e09e +Ветка: master +ОС: Майкрософт Windows 11 Домашняя для одного языка +CPU: 12th Gen Intel(R) Core(TM) i3-1215U +RAM: 7.73 GB +Docker: Docker version 28.0.1, build 068a01e +Docker Compose: 2.33.1-desktop.1 diff --git a/evidence/01_persistence.txt b/evidence/01_persistence.txt new file mode 100644 index 0000000..573127e --- /dev/null +++ b/evidence/01_persistence.txt @@ -0,0 +1,8 @@ +=== ТЕСТ PERSISTENCE === +1. Создаем пользователя и получаем токен... +2. Создаем чат... +3. Отправляем сообщение... +4. Перезапускаем контейнеры (docker compose restart)... +5. Проверяем доступ СТАРЫМ токеном... +УСПЕХ: Токен действителен. Прочитано сообщений: 1 +Текст сообщения: Saved! diff --git a/evidence/02_redis_ttl.txt b/evidence/02_redis_ttl.txt new file mode 100644 index 0000000..490eef1 --- /dev/null +++ b/evidence/02_redis_ttl.txt @@ -0,0 +1,6 @@ +=== ПРОВЕРКА REDIS И TTL === +1. Смотрим ключи в Redis: +session:pm6hPSaTwuigSxjMfgpVQz2w4DLzYfwwYsEFZiaX_zs +session:z8XP1dLAK2jnq8bog6rvyDYuR0hO52ZUkpG3n8He_Sw +2. Смотрим TTL (время жизни) одного из ключей: +3557 diff --git a/evidence/03_explain_track2.txt b/evidence/03_explain_track2.txt new file mode 100644 index 0000000..52f9297 --- /dev/null +++ b/evidence/03_explain_track2.txt @@ -0,0 +1,10 @@ +=== EXPLAIN (ANALYZE, BUFFERS) === +1. С ИНДЕКСОМ: + QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------- Limit (cost=0.42..174.90 rows=50 width=72) (actual time=0.037..0.045 rows=50 loops=1) Buffers: shared hit=5 -> Index Scan using idx_messages_chat_created on messages (cost=0.42..1507.98 rows=432 width=72) (actual time=0.035..0.042 rows=50 loops=1) Index Cond: (chat_id = '00000000-0000-0000-0000-000000000002'::uuid) Buffers: shared hit=5 Planning: Buffers: shared hit=103 Planning Time: 1.105 ms Execution Time: 0.093 ms (9 rows) + +2. БЕЗ ИНДЕКСА (DROP INDEX): +DROP INDEX + QUERY PLAN -------------------------------------------------------------------------------------------------------------------------- Limit (cost=2329.98..2330.10 rows=50 width=72) (actual time=29.699..29.705 rows=50 loops=1) Buffers: shared hit=1241 -> Sort (cost=2329.98..2331.06 rows=432 width=72) (actual time=29.698..29.700 rows=50 loops=1) Sort Key: created_at, id Sort Method: top-N heapsort Memory: 38kB Buffers: shared hit=1241 -> Seq Scan on messages (cost=0.00..2315.62 rows=432 width=72) (actual time=0.008..11.990 rows=100000 loops=1) Filter: (chat_id = '00000000-0000-0000-0000-000000000002'::uuid) Rows Removed by Filter: 2 Buffers: shared hit=1235 Planning: Buffers: shared hit=81 dirtied=1 Planning Time: 0.385 ms Execution Time: 29.751 ms (14 rows) + +3. ВОЗВРАЩАЕМ ИНДЕКС: +CREATE INDEX diff --git a/evidence/04_track2_backup.txt b/evidence/04_track2_backup.txt new file mode 100644 index 0000000..8c1c031 --- /dev/null +++ b/evidence/04_track2_backup.txt @@ -0,0 +1,11 @@ +=== ТЕСТ BACKUP И RESTORE (Track 2) === +1. Количество строк ДО удаления: + 100002 + +2. Делаем бэкап (pg_dump)... +3. Уничтожаем базу (docker compose down -v)... +4. Восстанавливаем из бэкапа... +5. Количество строк ПОСЛЕ восстановления: + 0 + +6. Удаляем файл дампа: diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 0000000..ae704c1 --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,36 @@ +CREATE TABLE users ( + id UUID PRIMARY KEY, + username VARCHAR(32) UNIQUE NOT NULL, + display_name VARCHAR(100) NOT NULL, + password_hash VARCHAR(255) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE TABLE chats ( + id UUID PRIMARY KEY, + title VARCHAR(100) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE TABLE chat_members ( + chat_id UUID REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); + +CREATE TABLE messages ( + id UUID PRIMARY KEY, + chat_id UUID REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID REFERENCES users(id) ON DELETE CASCADE, + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + + +CREATE INDEX idx_messages_chat_created ON messages (chat_id, created_at, id); + +CREATE TABLE sessions ( + token VARCHAR(64) PRIMARY KEY, + user_id UUID REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL +); \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..6b74ca0 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,3 @@ +psycopg2-binary +bcrypt +redis \ No newline at end of file diff --git a/tests/test_concurrent.py b/tests/test_concurrent.py new file mode 100644 index 0000000..9bbf147 --- /dev/null +++ b/tests/test_concurrent.py @@ -0,0 +1,38 @@ +import threading +from concurrent.futures import ThreadPoolExecutor +from client import Client, arguments, check, run + +def main(): + args = arguments('Concurrency race test') + bootstrap = Client(args.base_url, args.ca_file) + alice, bob, _eve, chat = bootstrap.bootstrap() + chat_id = chat['id'] + + CLIENTS = 10 + PER_CLIENT = 10 + barrier = threading.Barrier(CLIENTS) # Барьер: все потоки стартуют одновременно + + def worker(i): + local = Client(args.base_url, args.ca_file) + barrier.wait() # Ждем, пока все 10 потоков не будут готовы + for j in range(PER_CLIENT): + local.call('POST', f'/api/v1/chats/{chat_id}/messages', 201, actor=alice, body={'text': f'w{i}-{j}'}) + + # Запускаем 10 потоков + with ThreadPoolExecutor(max_workers=CLIENTS) as pool: + list(pool.map(worker, range(CLIENTS))) + + # Читаем историю и считаем уникальные ID + seen = [] + cursor = None + while True: + path = f'/api/v1/chats/{chat_id}/messages?limit=100' + if cursor: path += '&cursor=' + cursor + page = bootstrap.call('GET', path, actor=bob, schema='MessagePage')['json'] + seen.extend(x['id'] for x in page['items']) + cursor = page['next_cursor'] + if not cursor: break + + check(len(seen) == 100, f'Ожидали 100, получили {len(seen)}') + check(len(set(seen)) == 100, 'Есть дубликаты ID!') + print('PASS: 10x10 concurrent writes -> 100 unique ids') \ No newline at end of file diff --git a/tests/test_extra.py b/tests/test_extra.py new file mode 100644 index 0000000..e827b79 --- /dev/null +++ b/tests/test_extra.py @@ -0,0 +1,117 @@ +#!/usr/bin/env python3 +import uuid +from client import Client, arguments, check, run, LAB + + +def main(): + args = arguments('Lab1 edge-case tests; run against a live server') + check(LAB == 1, 'these tests target lab1') + c = Client(args.base_url, args.ca_file) + + c.call('GET', '/health/live') + c.call('GET', '/health/ready') + + # --- malformed JSON --- + c.call('POST', '/api/v1/users', 400, + raw=b'{"username":', + headers={'Content-Type': 'application/json'}) + c.call('POST', '/api/v1/users', 400, + raw=b'not-json', + headers={'Content-Type': 'application/json'}) + c.call('POST', '/api/v1/users', 400, + raw='{"username":"alice","display_name":"А","extra":1}'.encode('utf-8'), + headers={'Content-Type': 'application/json'}) + + # --- username validation / duplicate --- + u1 = 'u_' + uuid.uuid4().hex[:10] + body1 = {'username': u1, 'display_name': 'Первый'} + created = c.call('POST', '/api/v1/users', 201, body=body1, schema='User')['json'] + check(created['username'] == u1, 'username changed') + + c.call('POST', '/api/v1/users', 409, body=body1) + c.call('POST', '/api/v1/users', 400, + body={'username': 'Bad Name', 'display_name': 'X'}) + c.call('POST', '/api/v1/users', 400, + body={'username': 'ab', 'display_name': 'X'}) + c.call('POST', '/api/v1/users', 400, + body={'username': 'good_user', 'display_name': ''}) + + # --- chat creation validations --- + a = c.user('alice') + b = c.user('bob') + e = c.user('eve') + + c.call('POST', '/api/v1/chats', 400, actor=a, + body={'title': 'no me', 'member_ids': [b['id'], e['id']]}) + c.call('POST', '/api/v1/chats', 400, actor=a, + body={'title': 'ghost', 'member_ids': [a['id'], str(uuid.uuid4())]}) + c.call('POST', '/api/v1/chats', 400, actor=a, + body={'title': 'dup', 'member_ids': [a['id'], a['id']]}) + + chat = c.call('POST', '/api/v1/chats', 201, actor=a, + body={'title': 'Edge', 'member_ids': [a['id'], b['id']]}, + schema='Chat')['json'] + + # --- empty / whitespace-only message --- + c.call('POST', f"/api/v1/chats/{chat['id']}/messages", 400, actor=a, + body={'text': ''}) + c.call('POST', f"/api/v1/chats/{chat['id']}/messages", 400, actor=a, + body={'text': ' \n '}) + c.call('POST', f"/api/v1/chats/{chat['id']}/messages", 400, actor=a, + body={'text': 'x' * 4001}) + + # --- outsider (eve) forbidden --- + c.call('GET', f"/api/v1/chats/{chat['id']}", 404, actor=e) + c.call('GET', f"/api/v1/chats/{chat['id']}/messages", 404, actor=e) + c.call('POST', f"/api/v1/chats/{chat['id']}/messages", 404, actor=e, + body={'text': 'intrusion'}) + c.call('GET', f"/api/v1/chats/{chat['id']}", 401) + + # --- unknown UUID --- + c.call('GET', f"/api/v1/chats/{uuid.uuid4()}", 404, actor=a) + c.call('GET', f"/api/v1/chats/{uuid.uuid4()}/messages", 404, actor=a) + + # --- multi-page walk (5 pages of 1) --- + from client import timestamp + texts = [f'msg-{i}' for i in range(5)] + created_msgs = [c.message(a, chat, t)['json'] for t in texts] + + # Contract order is (created_at, id) ascending, NOT insertion order. + def _key(m): + return (timestamp(m['created_at']), uuid.UUID(m['id']).int) + + expected = [m['text'] for m in sorted(created_msgs, key=_key)] + + seen = [] + cursor = None + pages = 0 + while True: + path = f"/api/v1/chats/{chat['id']}/messages?limit=1" + if cursor: + from urllib.parse import quote + path += '&cursor=' + quote(cursor, safe='') + page = c.call('GET', path, actor=b, schema='MessagePage')['json'] + check(len(page['items']) == 1, 'expected exactly 1 item per page') + seen.extend(x['text'] for x in page['items']) + cursor = page['next_cursor'] + pages += 1 + if not cursor: + break + check(pages <= 20, 'pagination did not terminate') + + check(seen == expected, f'page walk mismatch: {seen} != {expected}') + check(pages == 5, f'expected 5 pages, got {pages}') + + # cursor from one chat must not work on another + other = c.call('POST', '/api/v1/chats', 201, actor=a, + body={'title': 'Other', 'member_ids': [a['id'], b['id']]}, + schema='Chat')['json'] + bad_cursor_path = (f"/api/v1/chats/{other['id']}/messages" + f"?limit=1&cursor={cursor or 'x'}") + c.call('GET', bad_cursor_path, 400, actor=a) + + print('PASS: lab1 extra tests') + + +if __name__ == '__main__': + run(main) \ No newline at end of file