forked from mtusi2026/mtusi2026lab2
lab2: PostgreSQL, Redis sessions, Track 2 (Explain, Backup) and report
This commit is contained in:
+21
@@ -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"]
|
||||
@@ -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 <URL_вашего_форка> 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:<token>` с TTL по умолчанию 3600 секунд; включено персистентное хранение.
|
||||
|
||||
### 2.2. Переход от Lab 1
|
||||
|
||||
- Удален `X-User-Id`; бизнес-запросы требуют `Authorization: Bearer <token>`.
|
||||
- Добавлен `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 для проверки целостности, поэтому для хранения паролей он не подходит.
|
||||
|
||||
@@ -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()
|
||||
@@ -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:
|
||||
@@ -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
|
||||
@@ -0,0 +1,8 @@
|
||||
=== ТЕСТ PERSISTENCE ===
|
||||
1. Создаем пользователя и получаем токен...
|
||||
2. Создаем чат...
|
||||
3. Отправляем сообщение...
|
||||
4. Перезапускаем контейнеры (docker compose restart)...
|
||||
5. Проверяем доступ СТАРЫМ токеном...
|
||||
УСПЕХ: Токен действителен. Прочитано сообщений: 1
|
||||
Текст сообщения: Saved!
|
||||
@@ -0,0 +1,6 @@
|
||||
=== ПРОВЕРКА REDIS И TTL ===
|
||||
1. Смотрим ключи в Redis:
|
||||
session:pm6hPSaTwuigSxjMfgpVQz2w4DLzYfwwYsEFZiaX_zs
|
||||
session:z8XP1dLAK2jnq8bog6rvyDYuR0hO52ZUkpG3n8He_Sw
|
||||
2. Смотрим TTL (время жизни) одного из ключей:
|
||||
3557
|
||||
@@ -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
|
||||
@@ -0,0 +1,11 @@
|
||||
=== ТЕСТ BACKUP И RESTORE (Track 2) ===
|
||||
1. Количество строк ДО удаления:
|
||||
100002
|
||||
|
||||
2. Делаем бэкап (pg_dump)...
|
||||
3. Уничтожаем базу (docker compose down -v)...
|
||||
4. Восстанавливаем из бэкапа...
|
||||
5. Количество строк ПОСЛЕ восстановления:
|
||||
0
|
||||
|
||||
6. Удаляем файл дампа:
|
||||
@@ -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
|
||||
);
|
||||
@@ -0,0 +1,3 @@
|
||||
psycopg2-binary
|
||||
bcrypt
|
||||
redis
|
||||
@@ -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')
|
||||
@@ -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)
|
||||
Reference in New Issue
Block a user