ЛР 2 — БПИ2304 — Яковлев — на 3 #189

Closed
tankist wants to merge 2 commits from tankist/mtusi2026lab2:solution/BPI2304-Yakovlev into master
15 changed files with 1035 additions and 21 deletions
+14 -6
View File
@@ -1,11 +1,19 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
# Values below are placeholders, not secrets. Choose your own local values.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
# Compose / PostgreSQL (lab2 level 3: sessions also live in PostgreSQL)
POSTGRES_USER=messenger
POSTGRES_PASSWORD=replace-with-local-synthetic-password
POSTGRES_DB=messenger
DATABASE_URL=postgresql://messenger:replace-with-local-synthetic-password@db:5432/messenger
# Alternative for deployments that mount a secret file instead of an env variable:
# DATABASE_URL_FILE=/run/secrets/database_url
# Optional on level 3. Not used by this solution (SESSION_STORE=postgres).
# SESSION_STORE=postgres
# CACHE_URL_FILE=/run/secrets/cache_url
+16
View File
@@ -0,0 +1,16 @@
FROM python:3.12-slim
ENV PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 PIP_NO_CACHE_DIR=1
WORKDIR /opt/app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
COPY app/ ./app/
COPY migrations/ ./migrations/
RUN useradd --create-home --uid 10001 appuser && chown -R appuser:appuser /opt/app
USER appuser
EXPOSE 8080
CMD ["python", "-m", "app"]
+92 -15
View File
@@ -1,37 +1,114 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Яковлев Матвей Дмитриевич, БПИ2304
- Целевая оценка; выбранный трек 5, если нужен: 3
- Commit/PR: ветка: (solution/BPI2304-Yakovlev); MR: (https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/189)
- Использованные источники, библиотеки и помощь ИИ: Python 3.12, FastAPI 0.135.3, Uvicorn 0.44.0, psycopg 3.3.3, PostgreSQL 16-alpine, Dockerfile из репозитория; версии закреплены в `requirements.txt`, `compose.yaml` и `Dockerfile`. При подготовке использовалась помощь Claude.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Требуется Docker с Compose. Секреты создаются локально и в Git не попадают (`.env` игнорируется).
```sh
git clone <url-вашего-fork> && cd <каталог>
cp .env.example .env
# В .env задайте синтетические локальные POSTGRES_USER / POSTGRES_PASSWORD /
# POSTGRES_DB / DATABASE_URL. Пример: postgresql://messenger:<password>@db:5432/messenger
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
curl -i http://localhost:8080/health/ready # 200 {"status":"ok"}
python tests/smoke.py --base-url http://localhost:8080
```
Без Docker (для отладки): задайте `DATABASE_URL` на доступный PostgreSQL, создайте БД.
`python -m venv .venv && .venv/bin/pip install -r requirements.txt && .venv/bin/python -m app`.
Миграции применяются при старте приложения; повторный запуск ничего не дублирует
(`schema_migrations` хранит список применённых файлов).
Остановка и безопасная работа с данными:
```sh
docker compose --env-file .env stop api db # данные остаются в volume pgdata
docker compose --env-file .env start api db
# Явное намеренное удаление учебных данных (не используется в тестах):
docker compose --env-file .env down -v
```
Проверка сохранности (перезапуск API **и** PostgreSQL с сохранением volume):
```sh
# Linux/macOS:
make test-persistence ACTION_SCRIPT=scripts/restart.sh
# Windows (локально):
python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://localhost:8080
```
Полный вывод команд — `evidence/lifecycle.txt`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Клиент → FastAPI/Uvicorn (один процесс, один worker) → PostgreSQL 16.
- **Источник истины** — PostgreSQL. Все обязательные данные (пользователи, чаты,
участники, сообщения, сессии) хранятся в таблицах; процесс не держит их копию.
Приложение использует небольшой пул соединений (`DB_POOL_MAX`, по умолчанию 8)
с таймаутом подключения 3 с.
- `migrations/001_init.sql` — версионируемая схема: PK/FK, `UNIQUE(username)`,
CHECK-ограничения длины/формата, индексы `ix_chat_members_user`,
`ix_messages_history (chat_id, created_at, id)`, `ix_sessions_expiry`.
Применяется один раз, фиксируется в `schema_migrations`.
- **Транзакции**: регистрация пользователя, создание чата (проверка участников + chat
+ все membership-строки) и отправка сообщения выполняются в одной транзакции;
при ошибке — rollback. Уникальность username и включение вызывающего в `member_ids`
проверяются до вставки.
- **Аутентификация lab2**: `POST /auth/sessions` принимает только Basic; пароль
проверяется библиотечным KDF `hashlib.scrypt` (n=2^14, r=8, p=1, соль 16 байт,
256-битный вывод) — не SHA-256 и не plaintext. Сессия — непрозрачный токен
(256 бит entropy, `urlsafe_b64encode(os.urandom(32))`); в БД хранится только
SHA-256 хэш токена, `expires_at` и `user_id`. TTL задаётся `SESSION_TTL_SECONDS`
(по умолчанию 3600). Бизнес-endpoint'ы принимают только `Bearer`; `X-User-Id`
игнорируется. Logout удаляет строку сессии. Basic на бизнес-endpoint и неверный
Bearer получают 401 с корректным `WWW-Authenticate`.
- **Пагинация** — keyset по `(created_at, id)`; курсор — base64url JSON с привязкой
к типу ресурса и ID чата/пользователя, поэтому курсор другого чата даёт 400.
Индекс `ix_messages_history` позволяет читать одну страницу без полного scan истории.
- **Отказы**: `/health/ready` делает `SELECT 1` и возвращает 503 в общем формате
ошибки, если БД недоступна. `X-Request-Id` есть в каждом ответе; `X-Instance-Id`
стабилен для процесса. `POST /users` с занятым username → 409, чужой чат и
несуществующий чат → одинаковый 404.
- Соответствие `.env.example`: переменные `DATABASE_URL` / `DATABASE_URL_FILE`
и `SESSION_TTL_SECONDS`; `SESSION_STORE=postgres` — level 3, Redis/Valkey не
используется (уровень 4 не заявляется).
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke | `python tests/smoke.py --base-url http://localhost:8080` | `PASS: lab2 public API scenario...` | `evidence/lifecycle.txt`, раздел 4 |
| Данные и сессии переживают рестарт API+БД | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` (на Windows — `scripts/restart.cmd`) | `PASS: persistence preserved confirmed data and existing session`; старый Bearer-токен читает те же данные; счётчики строк до/после рестарта, `schema_migrations` без повторов | `evidence/lifecycle.txt`, разделы 3, 6, 7 |
| PostgreSQL, FK/PK/UNIQUE, миграции с нуля | `docker compose up -d --build`; `psql ... SELECT` | две таблицы миграций/данных созданы с чистого volume; `001_init.sql` применён один раз | `evidence/lifecycle.txt`, разделы 1, 3 |
| Basic только на /auth/sessions, Bearer на остальных, expiry и logout | публичный smoke: 401 на Basic для `/users/me`, 401 на `X-User-Id`, проверка `X-User-Id` поверх Bearer, logout → 401 | PASS | `evidence/lifecycle.txt`, раздел 4 |
| Пароли хешируются password KDF | `python -m unittest discover -s student-tests` | 9 тестов OK: scrypt, соли, UTF-8 пароль с `:` | `evidence/lifecycle.txt`, раздел 8 |
| Атомарное создание чата, rollback и курсор | smoke + собственные юнит-тесты | PASS; курсор привязан к чату, мусор отклоняется | `evidence/lifecycle.txt`, разделы 4, 8 |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Не проводились (целевая оценка 3). Для уровня 5 потребовались бы отдельные
исследования согласованности кэша или плана запросов — в этой работе не заявлены.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Перезапуск API и PostgreSQL с сохранением `pgdata` | пользователи, чаты, сообщения и действующая сессия остаются; токен работает | подтверждённые данные и тот же Bearer-токен прочитаны после рестарта; `schema_migrations` без повторов | автоматический hook + ожидание готовности; потеря данных — 0 |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Уровень 4 не реализован: Redis/Valkey не подключается (`SESSION_STORE=postgres`),
нет отдельного теста expiry при коротком TTL и автоматической проверки отказа БД —
эти пункты требует оценка 4.
- Один процесс API: `created_at` назначается сервером, порядок страниц определяется
`(created_at, id)`; при параллельной вставке возможны одинаковые метки времени,
но детерминированный second key (`id`) исключает потери/дубли при обходе неизменной истории.
- Хранение сессий в PostgreSQL означает, что рестарт БД сохраняет сессии только
вместе с volume `pgdata`; `down -v` удаляет их намеренно.
- Для удалённой демонстрации нужен TLS: HTTP допускается только для локального
изолированного стенда с синтетическими данными.
+1
View File
@@ -0,0 +1 @@
"""Messenger lab2: PostgreSQL-backed API."""
+13
View File
@@ -0,0 +1,13 @@
"""Local entry point: python -m app"""
import os
import uvicorn
if __name__ == "__main__":
uvicorn.run(
"app.main:app",
host=os.environ.get("APP_HOST", "0.0.0.0"),
port=int(os.environ.get("APP_PORT", "8080")),
workers=1, # in-process ordering/cursors; PostgreSQL is the shared source of truth
log_level=os.environ.get("LOG_LEVEL", "info"),
)
+146
View File
@@ -0,0 +1,146 @@
"""PostgreSQL access: small bounded connection pool, versioned migrations, row helpers."""
import logging
import os
import queue
from contextlib import contextmanager
from datetime import timezone
from pathlib import Path
import psycopg
from psycopg.rows import dict_row
log = logging.getLogger("messenger.db")
ROOT = Path(__file__).resolve().parents[1]
MIGRATIONS = ROOT / "migrations"
def _read_secret(path):
if not path:
return None
value = Path(path).read_text(encoding="utf-8").strip()
if not value:
raise RuntimeError("secret file is empty: " + path)
return value
def database_url():
"""Prefer a mounted secret file; fall back to an environment variable for local runs."""
url = _read_secret(os.environ.get("DATABASE_URL_FILE"))
if url:
return url
url = os.environ.get("DATABASE_URL")
if not url:
raise RuntimeError("DATABASE_URL or DATABASE_URL_FILE is required")
return url
class Database:
"""A tiny FIFO pool. Each request borrows one connection and returns it."""
def __init__(self):
self._pool = None
self.dsn = None
def start(self):
self.dsn = database_url()
size = int(os.environ.get("DB_POOL_MAX", "8"))
self._pool = queue.Queue(maxsize=size)
for _ in range(size):
self._pool.put(self._connect())
self.migrate()
def _connect(self):
return psycopg.connect(self.dsn, connect_timeout=3, row_factory=dict_row, autocommit=True)
def stop(self):
if self._pool is None:
return
while not self._pool.empty():
try:
self._pool.get_nowait().close()
except queue.Empty:
break
self._pool = None
@contextmanager
def connection(self):
conn = self._pool.get(timeout=5)
try:
yield conn
finally:
self._pool.put(conn)
@contextmanager
def transaction(self):
with self.connection() as conn:
# Explicit BEGIN/COMMIT; rollback on any exception.
conn.execute("BEGIN")
try:
yield conn
except BaseException:
conn.execute("ROLLBACK")
raise
else:
conn.execute("COMMIT")
def ready(self):
try:
with self.connection() as conn:
conn.execute("SELECT 1").fetchone()
return True
except Exception:
log.exception("readiness check failed")
return False
def migrate(self):
"""Apply *.sql in name order, at most once each; restart-safe with the same volume."""
with self.transaction() as conn:
conn.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
"name TEXT PRIMARY KEY, applied_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp())"
)
applied = {r["name"] for r in conn.execute("SELECT name FROM schema_migrations").fetchall()}
for path in sorted(MIGRATIONS.glob("*.sql")):
if path.name in applied:
continue
conn.execute(path.read_text(encoding="utf-8"))
conn.execute("INSERT INTO schema_migrations(name) VALUES (%s)", (path.name,))
log.info("applied migration %s", path.name)
db = Database()
def utc_text(value):
"""RFC 3339 UTC with an explicit Z and microsecond precision."""
value = value.astimezone(timezone.utc)
return value.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def user_public(row):
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": utc_text(row["created_at"]),
}
def chat_public(row):
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": [str(x) for x in (row["member_ids"] or [])],
"created_at": utc_text(row["created_at"]),
}
def message_public(row):
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": utc_text(row["created_at"]),
}
+433
View File
@@ -0,0 +1,433 @@
"""Lab2 messenger HTTP layer. Contract: contracts/openapi.json.
State lives in PostgreSQL: users, chats, memberships, messages and sessions.
Basic is accepted only on POST /auth/sessions; every other protected route needs Bearer.
"""
import base64
import binascii
import datetime as dt
import json
import logging
import os
import re
import uuid
from contextlib import asynccontextmanager
import psycopg
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse, Response
from starlette.datastructures import MutableHeaders
from starlette.exceptions import HTTPException as StarletteHTTPException
from .db import chat_public, db, message_public, user_public, utc_text
from .security import bearer_token, hash_password, parse_basic, token_hash, verify_password
log = logging.getLogger("messenger")
MAX_BODY_BYTES = 1 << 20
DEFAULT_LIMIT, MAX_LIMIT = 50, 100
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}\Z")
UUID_RE = re.compile(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\Z")
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
INSTANCE_ID = os.environ.get("INSTANCE_ALIAS") or uuid.uuid4().hex[:12]
UTC = dt.timezone.utc
class ApiError(Exception):
def __init__(self, status, code, message, headers=None):
self.status, self.code, self.message, self.headers = status, code, message, headers
def bad_request(message):
return ApiError(400, "invalid_request", message)
def unauthorized(challenge, message="Требуется действительная аутентификация"):
return ApiError(401, "unauthorized", message, {"WWW-Authenticate": challenge})
def not_found():
return ApiError(404, "not_found", "Объект не найден")
def error_response(status, code, message, request_id, headers=None):
body = {"error": {"code": code, "message": message, "request_id": request_id}}
return JSONResponse(body, status_code=status, headers=headers)
class RequestContextMiddleware:
"""Add X-Request-Id (and X-Instance-Id) to every response, including errors and health."""
def __init__(self, app):
self.app = app
async def __call__(self, scope, receive, send):
if scope["type"] != "http":
await self.app(scope, receive, send)
return
request_id = str(uuid.uuid4())
scope.setdefault("state", {})["request_id"] = request_id
started = False
async def send_with_id(message):
nonlocal started
if message["type"] == "http.response.start":
started = True
headers = MutableHeaders(scope=message)
headers["X-Request-Id"] = request_id
headers["X-Instance-Id"] = INSTANCE_ID
await send(message)
try:
await self.app(scope, receive, send_with_id)
except Exception:
log.exception("unhandled error request_id=%s", request_id)
if not started:
response = error_response(500, "internal_error", "Внутренняя ошибка сервера", request_id)
await response(scope, receive, send_with_id)
@asynccontextmanager
async def lifespan(app):
db.start()
try:
yield
finally:
db.stop()
app = FastAPI(title="Messenger lab2", docs_url=None, redoc_url=None, openapi_url=None, lifespan=lifespan)
app.add_middleware(RequestContextMiddleware)
@app.exception_handler(ApiError)
async def handle_api_error(request: Request, exc: ApiError):
return error_response(exc.status, exc.code, exc.message, request.state.request_id, exc.headers)
@app.exception_handler(StarletteHTTPException)
async def handle_http_exception(request: Request, exc: StarletteHTTPException):
if exc.status_code == 404:
code, message = "not_found", "Объект не найден"
elif exc.status_code < 500:
code, message = "invalid_request", "Некорректный запрос"
else:
code, message = "internal_error", "Внутренняя ошибка сервера"
return error_response(exc.status_code, code, message, request.state.request_id, exc.headers)
@app.exception_handler(RequestValidationError)
async def handle_validation_error(request: Request, exc: RequestValidationError):
return error_response(400, "invalid_request", "Некорректный запрос", request.state.request_id)
# ---------- validation helpers ----------
def clean_string(data, field, max_len):
value = data.get(field)
if not isinstance(value, str):
raise bad_request("Поле %s должно быть строкой" % field)
if not value.strip() or len(value) > max_len:
raise bad_request("Поле %s должно содержать от 1 до %d символов" % (field, max_len))
return value
def parse_uuid(value, what):
if not isinstance(value, str) or not UUID_RE.fullmatch(value):
raise bad_request("Некорректный UUID: %s" % what)
return value.lower()
async def read_json_object(request, allowed):
declared = request.headers.get("content-length", "")
if declared.isdigit() and int(declared) > MAX_BODY_BYTES:
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое")
content_type = request.headers.get("content-type", "").split(";")[0].strip().lower()
if content_type and content_type != "application/json":
raise ApiError(415, "unsupported_media_type", "Ожидается application/json")
body = bytearray()
async for chunk in request.stream():
body += chunk
if len(body) > MAX_BODY_BYTES:
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое")
try:
data = json.loads(bytes(body).decode("utf-8"))
except (UnicodeDecodeError, ValueError):
raise bad_request("Тело запроса не является корректным JSON") from None
if not isinstance(data, dict):
raise bad_request("Тело запроса должно быть JSON-объектом")
if set(data) != set(allowed):
raise bad_request("Ожидаемые поля: " + ", ".join(sorted(allowed)))
return data
def page_params(request):
query = request.query_params
raw_limit = query.getlist("limit")
if len(raw_limit) > 1 or len(query.getlist("cursor")) > 1:
raise bad_request("Параметры limit и cursor можно указать только один раз")
limit = DEFAULT_LIMIT
if raw_limit:
text = raw_limit[0]
if not (text.isascii() and text.isdigit()) or not 1 <= int(text) <= MAX_LIMIT:
raise bad_request("limit должен быть целым числом от 1 до %d" % MAX_LIMIT)
limit = int(text)
return limit, query.get("cursor") or None
def encode_cursor(kind, scope, created_at, item_id):
raw = json.dumps(
{"k": kind, "s": scope,
"t": int(created_at.timestamp() * 1_000_000),
"i": uuid.UUID(str(item_id)).int},
separators=(",", ":"),
)
return base64.urlsafe_b64encode(raw.encode()).decode().rstrip("=")
def decode_cursor(text, kind, scope):
try:
data = json.loads(base64.urlsafe_b64decode(text + "=" * (-len(text) % 4)))
t, i = data["t"], data["i"]
valid = (data["k"] == kind and data["s"] == scope
and type(t) is int and type(i) is int and t >= 0 and i >= 0)
if not valid:
raise ValueError
return dt.datetime.fromtimestamp(t / 1_000_000, tz=UTC), uuid.UUID(int=i)
except (ValueError, KeyError, TypeError, binascii.Error, OverflowError):
raise bad_request("Некорректный cursor") from None
def page_response(items, limit, kind, scope, rows):
"""items are public JSON dicts; rows are the raw DB rows used for the opaque cursor."""
more = len(items) > limit
window = items[:limit]
last = rows[limit - 1] if more and len(rows) >= limit else None
cursor = (encode_cursor(kind, scope, last["created_at"], last["id"])
if last is not None else None)
return JSONResponse({"items": window, "next_cursor": cursor})
# ---------- authentication and resource access ----------
def current_user(request):
"""Lab2: only an opaque Bearer session identifies the caller; X-User-Id is ignored."""
token = bearer_token(request.headers.get("authorization"))
if not token:
raise unauthorized(BEARER_CHALLENGE)
with db.connection() as conn:
row = conn.execute(
"SELECT u.id, u.username, u.display_name, u.created_at "
"FROM sessions s JOIN users u ON u.id = s.user_id "
"WHERE s.token_hash = %s AND s.expires_at > clock_timestamp()",
(token_hash(token),),
).fetchone()
if row is None:
raise unauthorized(BEARER_CHALLENGE)
return user_public(row)
def authenticated_chat(request, chat_id):
user = current_user(request)
chat_uuid = parse_uuid(chat_id, "chat_id")
with db.connection() as conn:
row = conn.execute(
"SELECT c.id, c.title, c.created_at, "
"array_agg(m.user_id ORDER BY m.user_id) AS member_ids "
"FROM chats c JOIN chat_members m ON m.chat_id = c.id "
"WHERE c.id = %s AND m.user_id = %s GROUP BY c.id",
(chat_uuid, uuid.UUID(user["id"])),
).fetchone()
if row is None:
raise not_found() # unknown and foreign chats look identical
return user, chat_public(row)
# ---------- health ----------
@app.get("/health/live")
async def live():
return {"status": "ok"}
@app.get("/health/ready")
async def ready():
if not db.ready():
raise ApiError(503, "unavailable", "Хранилище данных недоступно")
return {"status": "ok"}
# ---------- users and sessions ----------
@app.post("/api/v1/users")
async def register_user(request: Request):
data = await read_json_object(request, ("username", "display_name", "password"))
username = data["username"]
if not isinstance(username, str) or not USERNAME_RE.fullmatch(username):
raise bad_request("username должен соответствовать [a-z0-9_]{3,32}")
display_name = clean_string(data, "display_name", 100)
password = data["password"]
if not isinstance(password, str) or not 12 <= len(password) <= 128:
raise bad_request("password должен содержать от 12 до 128 символов")
user_id = uuid.uuid4()
try:
with db.transaction() as conn:
conn.execute(
"INSERT INTO users(id, username, display_name, password_hash) VALUES (%s,%s,%s,%s)",
(user_id, username, display_name, hash_password(password)),
)
row = conn.execute("SELECT * FROM users WHERE id = %s", (user_id,)).fetchone()
except psycopg.errors.UniqueViolation:
raise ApiError(409, "conflict", "Имя пользователя уже занято") from None
return JSONResponse(user_public(row), status_code=201)
@app.post("/api/v1/auth/sessions")
async def create_session(request: Request):
credential = parse_basic(request.headers.get("authorization"))
if credential is None:
raise unauthorized(BASIC_CHALLENGE, "Неверные учетные данные")
username, password = credential
with db.connection() as conn:
row = conn.execute("SELECT * FROM users WHERE username = %s", (username,)).fetchone()
if row is None or not verify_password(password, row["password_hash"]):
raise unauthorized(BASIC_CHALLENGE, "Неверные учетные данные")
token = base64.urlsafe_b64encode(os.urandom(32)).decode().rstrip("=")
ttl = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
expires_at = dt.datetime.now(UTC) + dt.timedelta(seconds=ttl)
with db.transaction() as conn:
conn.execute(
"INSERT INTO sessions(token_hash, user_id, expires_at) VALUES (%s,%s,%s)",
(token_hash(token), row["id"], expires_at),
)
return JSONResponse({
"token": token,
"token_type": "Bearer",
"expires_at": utc_text(expires_at),
"user": user_public(row),
}, status_code=201)
@app.delete("/api/v1/auth/sessions/current")
async def revoke_session(request: Request):
token = bearer_token(request.headers.get("authorization"))
if not token:
raise unauthorized(BEARER_CHALLENGE)
with db.transaction() as conn:
result = conn.execute(
"DELETE FROM sessions WHERE token_hash = %s AND expires_at > clock_timestamp()",
(token_hash(token),),
)
if result.rowcount == 0:
raise unauthorized(BEARER_CHALLENGE)
return Response(status_code=204)
@app.get("/api/v1/users/me")
async def get_me(request: Request):
return current_user(request)
# ---------- chats ----------
@app.post("/api/v1/chats")
async def create_chat(request: Request):
user = current_user(request)
data = await read_json_object(request, ("title", "member_ids"))
title = clean_string(data, "title", 100)
raw_members = data["member_ids"]
if not isinstance(raw_members, list) or not 1 <= len(raw_members) <= 100:
raise bad_request("member_ids должен быть списком из 1–100 UUID")
members = [parse_uuid(m, "member_ids") for m in raw_members]
if len(set(members)) != len(members):
raise bad_request("member_ids содержит дубликаты")
if user["id"] not in members:
raise bad_request("member_ids должен содержать вызывающего пользователя")
chat_id = uuid.uuid4()
member_uuids = [uuid.UUID(x) for x in members]
try:
with db.transaction() as conn:
found = conn.execute(
"SELECT id FROM users WHERE id = ANY(%s::uuid[])", (member_uuids,)
).fetchall()
if len(found) != len(member_uuids):
raise bad_request("member_ids содержит неизвестного пользователя")
conn.execute("INSERT INTO chats(id, title) VALUES (%s,%s)", (chat_id, title))
for member in member_uuids:
conn.execute(
"INSERT INTO chat_members(chat_id, user_id) VALUES (%s,%s)",
(chat_id, member),
)
row = conn.execute(
"SELECT c.id, c.title, c.created_at, array_agg(m.user_id ORDER BY m.user_id) AS member_ids "
"FROM chats c JOIN chat_members m ON m.chat_id = c.id WHERE c.id = %s GROUP BY c.id",
(chat_id,),
).fetchone()
except psycopg.errors.ForeignKeyViolation:
raise bad_request("member_ids содержит неизвестного пользователя") from None
return JSONResponse(chat_public(row), status_code=201)
@app.get("/api/v1/chats")
async def list_chats(request: Request):
user = current_user(request)
limit, cursor = page_params(request)
after = decode_cursor(cursor, "chats", user["id"]) if cursor else None
sql = (
"SELECT c.id, c.title, c.created_at, array_agg(m.user_id ORDER BY m.user_id) AS member_ids "
"FROM chats c JOIN chat_members m ON m.chat_id = c.id WHERE m.user_id = %s"
)
params = [uuid.UUID(user["id"])]
if after:
sql += " AND (c.created_at, c.id) > (%s, %s::uuid)"
params.extend([after[0], after[1]])
sql += " GROUP BY c.id ORDER BY c.created_at, c.id LIMIT %s"
params.append(limit + 1)
with db.connection() as conn:
rows = conn.execute(sql, params).fetchall()
items = [chat_public(r) for r in rows]
return page_response(items, limit, "chats", user["id"], rows)
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(chat_id: str, request: Request):
_, chat = authenticated_chat(request, chat_id)
return chat
# ---------- messages ----------
@app.post("/api/v1/chats/{chat_id}/messages")
async def create_message(chat_id: str, request: Request):
user, chat = authenticated_chat(request, chat_id)
data = await read_json_object(request, ("text",))
text = clean_string(data, "text", 4000)
message_id = uuid.uuid4()
with db.transaction() as conn:
conn.execute(
"INSERT INTO messages(id, chat_id, sender_id, text) VALUES (%s,%s,%s,%s)",
(message_id, uuid.UUID(chat["id"]), uuid.UUID(user["id"]), text),
)
row = conn.execute("SELECT * FROM messages WHERE id = %s", (message_id,)).fetchone()
return JSONResponse(message_public(row), status_code=201)
@app.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(chat_id: str, request: Request):
_, chat = authenticated_chat(request, chat_id)
limit, cursor = page_params(request)
after = decode_cursor(cursor, "messages", chat["id"]) if cursor else None
sql = "SELECT * FROM messages WHERE chat_id = %s"
params = [uuid.UUID(chat["id"])]
if after:
sql += " AND (created_at, id) > (%s, %s::uuid)"
params.extend([after[0], after[1]])
sql += " ORDER BY created_at, id LIMIT %s"
params.append(limit + 1)
with db.connection() as conn:
rows = conn.execute(sql, params).fetchall()
items = [message_public(r) for r in rows]
return page_response(items, limit, "messages", chat["id"], rows)
+66
View File
@@ -0,0 +1,66 @@
"""Password KDF and HTTP credential parsing (Basic / opaque Bearer)."""
import base64
import binascii
import hashlib
import hmac
import os
import re
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}\Z")
SCRYPT_N = 2 ** 14
SCRYPT_R = 8
SCRYPT_P = 1
SCRYPT_LEN = 32
def hash_password(password):
salt = os.urandom(16)
derived = hashlib.scrypt(
password.encode("utf-8"), salt=salt, n=SCRYPT_N, r=SCRYPT_R, p=SCRYPT_P, dklen=SCRYPT_LEN
)
return "scrypt$%d$%d$%d$%s$%s" % (
SCRYPT_N, SCRYPT_R, SCRYPT_P, salt.hex(), derived.hex()
)
def verify_password(password, stored):
try:
scheme, n, r, p, salt_hex, digest_hex = stored.split("$")
if scheme != "scrypt":
return False
derived = hashlib.scrypt(
password.encode("utf-8"),
salt=bytes.fromhex(salt_hex),
n=int(n), r=int(r), p=int(p), dklen=len(bytes.fromhex(digest_hex)),
)
return hmac.compare_digest(derived, bytes.fromhex(digest_hex))
except (ValueError, TypeError):
return False
def token_hash(token):
return hashlib.sha256(token.encode("utf-8")).hexdigest()
def parse_basic(header):
"""Return (username, password) or None. Colon inside the password is allowed."""
if not header or not header.lower().startswith("basic "):
return None
encoded = header[6:].strip()
try:
raw = base64.b64decode(encoded, validate=True).decode("utf-8")
except (ValueError, UnicodeDecodeError, binascii.Error):
return None
if ":" not in raw:
return None
username, password = raw.split(":", 1)
if not USERNAME_RE.fullmatch(username) or not 12 <= len(password) <= 128:
return None
return username, password
def bearer_token(header):
if not header or not header.lower().startswith("bearer "):
return None
token = header[7:].strip()
return token or None
+42
View File
@@ -0,0 +1,42 @@
# Reproducible local stack for lab2 (level 3): API + PostgreSQL, named volume.
# Copy .env.example to .env and set synthetic local credentials before `docker compose up`.
services:
db:
image: postgres:16-alpine
restart: unless-stopped
environment:
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set a synthetic local password in .env}
POSTGRES_DB: ${POSTGRES_DB:-messenger}
volumes:
- pgdata:/var/lib/postgresql/data
ports:
- "127.0.0.1:5432:5432"
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}"]
interval: 3s
timeout: 3s
retries: 20
api:
build: .
restart: unless-stopped
environment:
APP_HOST: 0.0.0.0
APP_PORT: 8080
APP_ENV: lab
DATABASE_URL: ${DATABASE_URL:?set DATABASE_URL in .env}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
ports:
- "8080:8080"
depends_on:
db:
condition: service_healthy
healthcheck:
test: ["CMD", "python", "-c", "import os,urllib.request; urllib.request.urlopen('http://127.0.0.1:%s/health/ready' % os.environ.get('APP_PORT','8080'), timeout=2)"]
interval: 5s
timeout: 3s
retries: 20
volumes:
pgdata:
+78
View File
@@ -0,0 +1,78 @@
=== 1. Start from a clean clone ===
$ cp .env.example .env # local synthetic credentials only; .env is gitignored
$ docker compose --env-file .env config --quiet
config --quiet: OK
$ docker compose --env-file .env up -d --build
Image postgres:16-alpine Pulled
Image mtusi2026lab2-api Built
Volume mtusi2026lab2_pgdata Created
Container mtusi2026lab2-db-1 Healthy
Container mtusi2026lab2-api-1 Started
=== 2. Readiness ===
$ curl.exe -s -i http://localhost:8080/health/ready
HTTP/1.1 200 OK
content-type: application/json
x-request-id: d59c51aa-1532-4c02-a24c-6a1091942bc2
x-instance-id: e37ad21ced60
{"status":"ok"}
=== 3. State BEFORE restart ===
$ docker compose --env-file .env ps
NAME IMAGE SERVICE STATUS
mtusi2026lab2-api-1 mtusi2026lab2-api api Up (health: starting)
mtusi2026lab2-db-1 postgres:16-alpine db Up (healthy)
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c \
'SELECT (SELECT count(*) FROM users) users, (SELECT count(*) FROM sessions) sessions,
(SELECT count(*) FROM chats) chats, (SELECT count(*) FROM messages) messages;'
users | sessions | chats | messages
-------+----------+-------+----------
15 | 14 | 4 | 6
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c \
'SELECT name FROM schema_migrations ORDER BY name;'
name
--------------
001_init.sql
=== 4. Public smoke ===
$ python tests/smoke.py --base-url http://localhost:8080
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
=== 5. Explicit restart hook (API + PostgreSQL, volumes preserved) ===
$ scripts/restart.sh # Linux/macOS
$ scripts\restart.cmd # Windows local run
cd <repo>; docker compose --env-file .env restart db api
# no down -v, no flush, no re-seed
=== 6. State AFTER restart ===
$ docker compose --env-file .env ps
NAME IMAGE SERVICE STATUS
mtusi2026lab2-api-1 mtusi2026lab2-api api Up (health: starting)
mtusi2026lab2-db-1 postgres:16-alpine db Up (health: starting)
# Both containers were actually restarted; mtusi2026lab2_pgdata volume was kept.
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c \
'SELECT (SELECT count(*) FROM users) users, ... ;'
users | sessions | chats | messages
-------+----------+-------+----------
18 | 16 | 5 | 8
# Counts grew because smoke and the persistence test create new synthetic users each run.
# Earlier rows were not deleted; the migration list is unchanged (001_init.sql only),
# which confirms migrations were not re-applied.
=== 7. Persistence test with the SAME Bearer token after restart ===
$ python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://localhost:8080
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
=== 8. Own unit tests ===
$ python -m unittest discover -s student-tests -p 'test_*.py' -v
Ran 9 tests ... OK
# covers: scrypt KDF/salts, UTF-8 password with colon, Basic/Bearer parsing,
# opaque token hashing, keyset cursor round-trip and tamper rejection.
=== 9. Offline checks ===
$ python scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+42
View File
@@ -0,0 +1,42 @@
-- Lab2 initial schema. Applied once by app/db.py; safe to keep volumes on restart.
-- Source of truth for users, chats, memberships, messages and sessions is PostgreSQL.
CREATE TABLE IF NOT EXISTS users (
id UUID PRIMARY KEY,
username TEXT NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name TEXT NOT NULL CHECK (length(display_name) BETWEEN 1 AND 100),
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE IF NOT EXISTS chats (
id UUID PRIMARY KEY,
title TEXT NOT NULL CHECK (length(title) BETWEEN 1 AND 100),
created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE IF NOT EXISTS chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX IF NOT EXISTS ix_chat_members_user ON chat_members (user_id, chat_id);
CREATE TABLE IF NOT EXISTS messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id),
text TEXT NOT NULL CHECK (length(text) BETWEEN 1 AND 4000),
created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);
-- Keyset pagination reads strictly one (created_at, id) window; no full-history scan.
CREATE INDEX IF NOT EXISTS ix_messages_history ON messages (chat_id, created_at, id);
CREATE TABLE IF NOT EXISTS sessions (
token_hash TEXT PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at TIMESTAMPTZ NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);
CREATE INDEX IF NOT EXISTS ix_sessions_user ON sessions (user_id);
CREATE INDEX IF NOT EXISTS ix_sessions_expiry ON sessions (expires_at);
+3
View File
@@ -0,0 +1,3 @@
fastapi==0.135.3
uvicorn==0.44.0
psycopg[binary]==3.3.3
+5
View File
@@ -0,0 +1,5 @@
@echo off
REM Windows equivalent of scripts/restart.sh for the local persistence hook.
cd /d "%~dp0.."
docker compose --env-file .env restart db api
exit /b %ERRORLEVEL%
+8
View File
@@ -0,0 +1,8 @@
#!/bin/sh
set -eu
# Explicit persistence hook for lab2.
# Restart the API and the PostgreSQL storage that holds users, messages and sessions.
# Volumes are preserved: no down -v, no flush, no re-seed. Exit 0 when the action is done;
# the public test waits for /health/ready separately.
cd "$(dirname "$0")/.."
docker compose restart db api
+76
View File
@@ -0,0 +1,76 @@
"""Own tests for the security helpers and keyset cursors (stdlib unittest)."""
import base64
import datetime as dt
import sys
import unittest
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from app import main as api
from app.security import (bearer_token, hash_password, parse_basic,
token_hash, verify_password)
class PasswordTests(unittest.TestCase):
def test_kdf_round_trip_and_uniqueness(self):
first = hash_password("T3st-passphrase-123")
second = hash_password("T3st-passphrase-123")
self.assertNotEqual(first, second, "salt must be unique")
self.assertTrue(first.startswith("scrypt$"))
self.assertTrue(verify_password("T3st-passphrase-123", first))
self.assertFalse(verify_password("wrong-password", first))
def test_unicode_and_colon_password(self):
secret = "пароль:с:двоеточием-123"
stored = hash_password(secret)
self.assertTrue(verify_password(secret, stored))
self.assertFalse(verify_password("пароль", stored))
class CredentialTests(unittest.TestCase):
def test_basic_colon_inside_password(self):
raw = "u_alice_123:T3st-with:colon-12345"
header = "Basic " + base64.b64encode(raw.encode()).decode()
self.assertEqual(parse_basic(header), ("u_alice_123", "T3st-with:colon-12345"))
def test_basic_rejects_short_password_and_bad_scheme(self):
raw = "u_alice_123:short"
self.assertIsNone(parse_basic("Basic " + base64.b64encode(raw.encode()).decode()))
self.assertIsNone(parse_basic("Bearer abcdef"))
def test_bearer_only(self):
self.assertEqual(bearer_token("Bearer abc"), "abc")
self.assertIsNone(bearer_token("Basic abc"))
self.assertIsNone(bearer_token(None))
def test_token_hash_is_stable_and_not_the_token(self):
token = "s" * 43
self.assertEqual(token_hash(token), token_hash(token))
self.assertNotEqual(token_hash(token), token)
class CursorTests(unittest.TestCase):
def test_round_trip(self):
created = dt.datetime(2026, 11, 16, 12, 0, 0, 123456, tzinfo=dt.timezone.utc)
item_id = uuid.uuid4()
encoded = api.encode_cursor("messages", "scope-1", created, item_id)
back_created, back_id = api.decode_cursor(encoded, "messages", "scope-1")
self.assertEqual(back_created, created)
self.assertEqual(back_id, item_id)
def test_wrong_scope_rejected(self):
created = dt.datetime.now(dt.timezone.utc)
encoded = api.encode_cursor("messages", "chat-A", created, uuid.uuid4())
with self.assertRaises(api.ApiError):
api.decode_cursor(encoded, "messages", "chat-B")
def test_garbage_rejected(self):
with self.assertRaises(api.ApiError):
api.decode_cursor("not-a-cursor", "messages", "chat-A")
if __name__ == "__main__":
unittest.main(verbosity=2)