lab2: PostgreSQL, Redis sessions, Track 2 (Explain, Backup) and report

This commit is contained in:
2026-10-19 20:54:45 +03:00
parent 65003b6119
commit 491ff37b2e
13 changed files with 796 additions and 23 deletions
+21
View File
@@ -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"]
+130 -23
View File
@@ -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 для проверки целостности, поэтому для хранения паролей он не подходит.
+374
View File
@@ -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()
+33
View File
@@ -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:
+9
View File
@@ -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
+8
View File
@@ -0,0 +1,8 @@
=== ТЕСТ PERSISTENCE ===
1. Создаем пользователя и получаем токен...
2. Создаем чат...
3. Отправляем сообщение...
4. Перезапускаем контейнеры (docker compose restart)...
5. Проверяем доступ СТАРЫМ токеном...
УСПЕХ: Токен действителен. Прочитано сообщений: 1
Текст сообщения: Saved!
+6
View File
@@ -0,0 +1,6 @@
=== ПРОВЕРКА REDIS И TTL ===
1. Смотрим ключи в Redis:
session:pm6hPSaTwuigSxjMfgpVQz2w4DLzYfwwYsEFZiaX_zs
session:z8XP1dLAK2jnq8bog6rvyDYuR0hO52ZUkpG3n8He_Sw
2. Смотрим TTL (время жизни) одного из ключей:
3557
+10
View File
@@ -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
+11
View File
@@ -0,0 +1,11 @@
=== ТЕСТ BACKUP И RESTORE (Track 2) ===
1. Количество строк ДО удаления:
100002
2. Делаем бэкап (pg_dump)...
3. Уничтожаем базу (docker compose down -v)...
4. Восстанавливаем из бэкапа...
5. Количество строк ПОСЛЕ восстановления:
0
6. Удаляем файл дампа:
+36
View File
@@ -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
);
+3
View File
@@ -0,0 +1,3 @@
psycopg2-binary
bcrypt
redis
+38
View File
@@ -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')
+117
View File
@@ -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)