From df31f4a9fb12cdc7f362db68ee73d41472047421 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A7=D0=B8=D0=BD=D1=8F=D0=B5=D0=B2=D0=B0?= Date: Fri, 6 Nov 2026 22:37:31 +0300 Subject: [PATCH 1/4] =?UTF-8?q?=D0=A0=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=BE?= =?UTF-8?q?=D0=B2=D0=B0=D1=82=D1=8C=20=D0=BB=D0=B0=D0=B1=D0=BE=D1=80=D0=B0?= =?UTF-8?q?=D1=82=D0=BE=D1=80=D0=BD=D1=83=D1=8E=202=20=D0=BD=D0=B0=20?= =?UTF-8?q?=D0=BE=D1=86=D0=B5=D0=BD=D0=BA=D1=83=204?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PostgreSQL как источник истины, непрозрачные сессии в Redis с TTL и AOF, миграции под advisory lock, пул и таймауты, проверки гонки/отката/отказов и отчёт с evidence. --- .env.example | 27 +- .gitattributes | 6 + Dockerfile | 31 ++ Makefile | 16 +- REPORT.md | 149 +++++++- app/__init__.py | 1 + app/config.py | 72 ++++ app/db.py | 118 ++++++ app/errors.py | 36 ++ app/main.py | 491 +++++++++++++++++++++++++ app/sessions.py | 101 +++++ app/validation.py | 143 +++++++ compose.yaml | 82 +++++ evidence/auth_negative.txt | 1 + evidence/check.txt | 1 + evidence/containers-after-restart.txt | 4 + evidence/containers-before-restart.txt | 4 + evidence/edge_cases.txt | 19 + evidence/expiry.txt | 1 + evidence/explain_history.txt | 16 + evidence/fault_matrix.txt | 5 + evidence/load.json | 17 + evidence/load.txt | 17 + evidence/persistence.txt | 2 + evidence/pool_settings.txt | 8 + evidence/race_username.txt | 1 + evidence/redis.txt | 10 + evidence/rollback_chat.txt | 1 + evidence/schema.txt | 36 ++ evidence/smoke.txt | 1 + migrations/001_init.sql | 51 +++ requirements.txt | 5 + scripts/restart.cmd | 10 + scripts/restart.sh | 12 + student-tests/README.md | 31 ++ student-tests/auth_negative.py | 58 +++ student-tests/common.py | 76 ++++ student-tests/expiry.py | 35 ++ student-tests/explain_history.py | 101 +++++ student-tests/fault_matrix.py | 102 +++++ student-tests/pool_settings.py | 38 ++ student-tests/race_username.py | 45 +++ student-tests/rollback_chat.py | 86 +++++ 43 files changed, 2045 insertions(+), 22 deletions(-) create mode 100644 .gitattributes create mode 100644 Dockerfile create mode 100644 app/__init__.py create mode 100644 app/config.py create mode 100644 app/db.py create mode 100644 app/errors.py create mode 100644 app/main.py create mode 100644 app/sessions.py create mode 100644 app/validation.py create mode 100644 compose.yaml create mode 100644 evidence/auth_negative.txt create mode 100644 evidence/check.txt create mode 100644 evidence/containers-after-restart.txt create mode 100644 evidence/containers-before-restart.txt create mode 100644 evidence/edge_cases.txt create mode 100644 evidence/expiry.txt create mode 100644 evidence/explain_history.txt create mode 100644 evidence/fault_matrix.txt create mode 100644 evidence/load.json create mode 100644 evidence/load.txt create mode 100644 evidence/persistence.txt create mode 100644 evidence/pool_settings.txt create mode 100644 evidence/race_username.txt create mode 100644 evidence/redis.txt create mode 100644 evidence/rollback_chat.txt create mode 100644 evidence/schema.txt create mode 100644 evidence/smoke.txt create mode 100644 migrations/001_init.sql create mode 100644 requirements.txt create mode 100644 scripts/restart.cmd create mode 100755 scripts/restart.sh create mode 100644 student-tests/README.md create mode 100644 student-tests/auth_negative.py create mode 100644 student-tests/common.py create mode 100644 student-tests/expiry.py create mode 100644 student-tests/explain_history.py create mode 100644 student-tests/fault_matrix.py create mode 100644 student-tests/pool_settings.py create mode 100644 student-tests/race_username.py create mode 100644 student-tests/rollback_chat.py diff --git a/.env.example b/.env.example index 714c8076..9b31151e 100644 --- a/.env.example +++ b/.env.example @@ -1,11 +1,24 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. +# Copy to .env for a LOCAL synthetic test environment; never commit .env. +# These values are examples for an isolated stand, not real credentials. APP_HOST=0.0.0.0 APP_PORT=8080 +API_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 + +POSTGRES_DB=messenger +POSTGRES_USER=messenger +# Replace this local-only value before starting the stand. +POSTGRES_PASSWORD=change-me-local-synthetic-password +DATABASE_URL=postgresql://messenger:change-me-local-synthetic-password@postgres:5432/messenger +CACHE_URL=redis://redis:6379/0 + +# Bounded PostgreSQL pool and timeouts. +DB_POOL_MIN=1 +DB_POOL_MAX=10 +DB_POOL_ACQUIRE_TIMEOUT_SECONDS=3 +DB_CONNECT_TIMEOUT_SECONDS=3 +DB_STATEMENT_TIMEOUT_MS=5000 +REDIS_CONNECT_TIMEOUT_SECONDS=2 +REDIS_SOCKET_TIMEOUT_SECONDS=2 +MAX_BODY_BYTES=1048576 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..822563d3 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,6 @@ +* text=auto +*.sh text eol=lf +*.cmd text eol=crlf +Dockerfile text eol=lf +Makefile text eol=lf +*.sql text eol=lf diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..a3d938fa --- /dev/null +++ b/Dockerfile @@ -0,0 +1,31 @@ +# Runtime image for the lab2 API. The base tag is pinned; dependencies are +# installed from requirements.txt, never from a mutable latest tag. + +FROM python:3.12.7-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PIP_NO_CACHE_DIR=1 \ + PIP_DISABLE_PIP_VERSION_CHECK=1 + +WORKDIR /app + +RUN groupadd --system --gid 10001 app \ + && useradd --system --uid 10001 --gid app --home-dir /app --shell /usr/sbin/nologin app + +COPY requirements.txt ./ +RUN python -m pip install --requirement requirements.txt + +COPY app ./app +COPY migrations ./migrations +COPY student-tests ./student-tests + +USER app +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=20s --retries=6 \ + CMD ["python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).read()"] + +# One process with a bounded thread pool is enough for lab2. The database +# pool itself fixes the number of PostgreSQL connections. +CMD ["gunicorn", "--bind=0.0.0.0:8080", "--workers=1", "--threads=8", "--timeout=30", "--graceful-timeout=10", "--access-logfile=-", "--error-logfile=-", "app.main:app"] diff --git a/Makefile b/Makefile index 9ecb223e..e75e621f 100644 --- a/Makefile +++ b/Makefile @@ -4,10 +4,17 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence +.PHONY: help check validate test load test-persistence up down test-student test-expiry help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" + @echo "up/down: local compose stack; test-student: negative/race checks; test-expiry: short-TTL check" + +up: + docker compose --env-file .env up -d --build + +down: + docker compose --env-file .env down check: $(PYTHON) scripts/check_contract.py @@ -24,3 +31,10 @@ load: test-persistence: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +test-student: + $(PYTHON) student-tests/auth_negative.py --base-url "$(BASE_URL)" + $(PYTHON) student-tests/race_username.py --base-url "$(BASE_URL)" + +test-expiry: + $(PYTHON) student-tests/expiry.py --base-url "$(BASE_URL)" diff --git a/REPORT.md b/REPORT.md index e42f2b05..c92a3b2f 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,158 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Чиняева, БВТ2301 +- Целевая оценка: **4**; трек 5 не заявлен. +- Commit/PR: заполняется после публикации ветки `solution/BVT2301-Chinyaeva` и открытия MR. +- Использованные источники, библиотеки и помощь ИИ: официальная документация PostgreSQL + (транзакции, EXPLAIN, keyset pagination), Redis (AOF/expiry), RFC 7617 (Basic), Flask, + psycopg 3, redis-py, argon2-cffi, gunicorn. ИИ-ассистент использовался для генерации + черновика кода, проверки контракта и подготовки отчёта; все команды и результаты ниже + воспроизведены на локальном стенде. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Стенд проверялся на Windows 11 + Docker Desktop 29.9.2 (16 logical CPU, ~15.2 GiB +доступно Docker). Образы закреплены тегами, `latest` не используется: + +| Роль | Образ/рантайм | Порт/volume | +| --- | --- | --- | +| API | `python:3.12.7-slim-bookworm`, gunicorn 23.0.0, Flask 3.1.0 | `8080` (публикуется Docker) | +| PostgreSQL | `postgres:16.4-alpine` | `5432` внутри сети, `pgdata` | +| Redis | `redis:7.4.0-alpine`, AOF `everysec` | `6379` внутри сети, `redisdata` | + +```sh +git clone +cd mtusi2026lab2-Chinyaeva + +# Локальные синтетические credentials; .env находится в .gitignore. +cp .env.example .env + +docker compose --env-file .env up -d --build +# ждать готовности, не только /health/live: +until curl -fsS http://localhost:8080/health/ready; do sleep 1; done + +make test BASE_URL=http://localhost:8080 +make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8080 +``` + +На проверочной машине порт 8080 был занят WSL, поэтому локально использовался +`API_PORT=18080` в `.env`; это единственное отличие от команд выше. `restart.sh` +предназначен для Linux/macOS, `restart.cmd` — эквивалент для Windows. Оба выполняют +`docker compose restart` и **не удаляют volumes**. + +Остановка и намеренное удаление учебных данных: + +```sh +docker compose --env-file .env down # остановка, данные сохраняются +docker compose --env-file .env down -v # ТОЛЬКО осознанный сброс volumes +rm .env # локальные credentials +``` + +Секреты не попадают в Git: `.env`, `secrets/`, `*.key`, `*.pem` уже перечислены в +`.gitignore`; `compose.yaml` получает `DATABASE_URL`/`CACHE_URL` из окружения. +`postgres` и `redis` не публикуют порты на хост, API общается с ними по внутренней сети. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +client --HTTP--> api (gunicorn/Flask, 1 process, 8 threads) + |-- PostgreSQL: users, chats, chat_members, messages (источник истины) + '-- Redis: session: -> {user_id, expires_at}, TTL +``` + +- **PostgreSQL — источник истины** для пользователей, чатов, членства и сообщений. + Все запросы параметризованы (`%s`), SQL собирается только из фиксированных фрагментов. +- **Redis — хранилище активных сессий.** В ключ пишется SHA-256 от bearer-токена, сам + токен в Redis не хранится. `SESSION_TTL_SECONDS` (по умолчанию 3600) — единственная + политика продления: TTL не скользит и не продлевается рестартом. Logout удаляет ключ. + Источник истины для сессий — Redis; для пользователей/сообщений — PostgreSQL. Если + Redis потеряет данные, пользователи и сообщения останутся, но сессии станут + недействительными (401). AOF `appendfsync everysec` + `redisdata` переживают + штатный рестарт; при потере питания возможна потеря до ~1 секунды последних записей. +- **Миграции** лежат в `migrations/001_init.sql` и применяются при старте API под + `pg_advisory_lock`; версия фиксируется в `schema_migrations`, повторный запуск + пропускает уже применённую миграцию и не дублирует данные. +- **Транзакционные границы.** Создание чата и всех `chat_members` — одна транзакция; + сбой вставки участника откатывает чат (проверено инъекцией trigger). Регистрация + опирается на `UNIQUE(username)`; конкурентная гонка даёт один `201`, остальные `409`. +- **Пул и таймауты.** `psycopg_pool` 1–10 соединений, acquire timeout 3 с; + `statement_timeout=5s`, `idle_in_transaction_session_timeout=10s`, + `lock_timeout=3s`; Redis socket/connect timeout 2 с. При недоступности зависимости + API возвращает ограниченный `503 unavailable`, а не `200`/`401` с анонимным доступом. +- **Индексы.** `messages(chat_id, created_at, id)` обслуживает keyset-запрос + `WHERE chat_id=? AND (created_at,id)>(?,?) ORDER BY created_at,id LIMIT ?`. + `chats(created_at,id)` — порядок списка чатов; `chat_members(user_id,chat_id)` — + выборка чатов пользователя; `users.username` уникален. +- **Ошибки и заголовки.** Каждый ответ, включая 204/health/ошибки, содержит + `X-Request-Id`; тело ошибки — `{"error":{"code","message","request_id"}}` с тем же + `request_id`. Basic принимается только на `POST /auth/sessions`; бизнес-endpoint + требуют Bearer. `X-User-Id` игнорируется. Пароли — Argon2id (argon2-cffi), не SHA-256. ## Доказательства критериев +Все команды выполнялись 2026-11-06 на указанном стенде; файлы лежат в `evidence/`. + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Offline-структура и синтаксис | `python scripts/check_contract.py` (`make check`) | `PASS: offline skeleton structure...` | `evidence/check.txt` | +| Публичный smoke уровня 3 | `python tests/smoke.py --base-url http://localhost:18080` | `PASS: lab2 public API scenario` | `evidence/smoke.txt` | +| Все данные и сессия переживают рестарт API+БД+Redis | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://localhost:18080` | `PASS: persistence preserved confirmed data and existing session`; контейнеры до/после рестарта | `evidence/persistence.txt`, `evidence/containers-before-restart.txt`, `evidence/containers-after-restart.txt` | +| PostgreSQL: таблицы, PK/FK, уникальность, миграции | `psql`-запросы к `information_schema`/`pg_indexes`/`schema_migrations` | 5 таблиц, 9 индексов, `001_init`; повторный старт не дублирует | `evidence/schema.txt` | +| Redis/Valkey с TTL и persistence | `redis-cli INFO persistence`, `DBSIZE`, `TTL session:*` | `aof_enabled:1`, `aof_last_write_status:ok`, TTL сессии ~3486 с | `evidence/redis.txt` | +| Ограниченный пул и SQL-таймауты | `docker compose exec -T api python student-tests/pool_settings.py` | `statement_timeout=5s`, pool 1–10, acquire timeout 3 с | `evidence/pool_settings.txt` | +| Гонка регистрации username | `python student-tests/race_username.py --workers 8` | ровно один `201`, семь `409`, затем успешный вход | `evidence/race_username.txt` | +| Откат составной операции | `docker compose exec -T api python student-tests/rollback_chat.py` | после сбоя вставки участника чата нет; следующий чат создаётся | `evidence/rollback_chat.txt` | +| Индекс истории и EXPLAIN на ≥10 000 сообщений | `docker compose exec -T api python student-tests/explain_history.py` | `Index Scan using messages_chat_created_at_id_idx`, `rows=51`, `shared hit=4`, 0.124 ms | `evidence/explain_history.txt` | +| Expiry при коротком TTL | API с `SESSION_TTL_SECONDS=10`, `python student-tests/expiry.py --wait 12` | свежая сессия `200`, через 12 с — `401` + Bearer challenge | `evidence/expiry.txt` | +| Неверный пароль, Basic на бизнес-endpoint, logout | `python student-tests/auth_negative.py` | `401 Basic` / `401 Bearer` / `204`, повторный logout `401` | `evidence/auth_negative.txt` | +| Недоступность Redis и PostgreSQL | `python student-tests/fault_matrix.py` | в обоих случаях `503 unavailable`; после старта Redis readiness 0.48 с, PostgreSQL 3.01 с; тот же токен снова `200` | `evidence/fault_matrix.txt` | +| Граничные случаи контракта | локальный edge-сценарий | extra fields/пустое тело/неизвестный участник/чужой cursor/4001 символ — `400`; лимит ровно `limit` даёт `next_cursor=null` | `evidence/edge_cases.txt` | +| Нагрузочный профиль (не доказательство capacity) | `python tests/load.py --duration 15 --concurrency 4 --output evidence/load.json` | 2599 успешных POST, 0 ошибок, 172.7 RPS, p50 22.96 ms / p95 38.87 ms / p99 44.76 ms | `evidence/load.json`, `evidence/load.txt` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +### Комментарии к доказательствам + +- `explain_history.txt` получен после `ANALYZE` на 10 000 сообщениях в одном чате. + План — `Index Scan`, а не `Seq Scan`; на страницу читается 51 строка, а не вся история. + Это подтверждает отсутствие полного скана на каждую страницу. +- `fault_matrix.txt` отдельно показывает, что при отказе Redis уже выданный bearer-токен + не превращается в анонимный доступ: запрос возвращает `503`, а после восстановления + AOF тот же токен снова даёт `200`. +- `persistence.txt` дополнен `containers-*.txt`: в `after` все три контейнера имеют + статус `Up` с малым временем работы, то есть hook действительно перезапустил API, + PostgreSQL и Redis, а не только приложение. +- `evidence/redis.txt` содержит только хэш ключа сессии (`session:`), не токен. + В отчёте и evidence нет паролей, токенов и приватных ключей. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Стенд: один Docker host, API + PostgreSQL + Redis в одной Compose-сети; синтетические +пользователи и сообщения. Это не проверка HA и не production-сертификат. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `docker compose restart` (API+PostgreSQL+Redis), volumes сохранены | данные и прежний токен живы | `PASS` persistence; контейнеры перезапущены | данные не потеряны; TTL сессии не продлён рестартом | +| Остановка Redis | readiness/запросы с Bearer — `503`, не `200` и не доверенный аноним | `503 unavailable` на `/health/ready` и `/users/me` | после `start redis` readiness 0.48 с; тот же токен `200` (AOF) | +| Остановка PostgreSQL | readiness/запросы — `503` | `503 unavailable` на `/health/ready` и `/users/me` | после `start postgres` readiness 3.01 с; тот же токен `200` | +| Инъекция ошибки во вставку `chat_members` | чат не должен остаться | API вернул ограниченный `500 internal_error`, строки чата нет | целостность восстановлена откатом транзакции | +| 8 одновременных регистраций одного username | ровно один пользователь | один `201`, семь `409 conflict` | дубликатов нет | + +Ограничения измерения нагрузки: `tests/load.py` — closed-loop генератор, клиент и +сервер на одном хосте; 172.7 RPS отражают HTTP-подтверждения в этом стенде, а не +предел PostgreSQL. В отчёте нет универсального проходного RPS. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Один API-процесс и один Docker host: отказ хоста, потеря БД или единственного Redis + не компенсируются. Горизонтальное масштабирование и LB — задача lab3. +- Redis хранит только сессии; при полной потере AOF активные сессии исчезнут, но + пользователи, чаты и сообщения в PostgreSQL останутся. Это осознанная граница: + сессия — не бизнес-данные. +- AOF `everysec` допускает потерю до ~1 секунды последних сессионных записей при + аварийном завершении хоста; штатный рестарт проверен. Для production нужен + отдельный анализ durability/backup. +- HTTP без TLS допустим только для локального изолированного стенда с синтетическими + данными; для удалённой демонстрации нужен TLS (lab7). +- Нет rate limiting, публичного поиска пользователей, WebSocket и UI — они не входят + в обязательный минимум lab2. +- Следующий шаг для lab3: ≥2 API-реплики, общий LB, `Idempotency-Key` и `X-Instance-Id`, + проверка failover и отсутствия дублей. diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..edec7955 --- /dev/null +++ b/app/__init__.py @@ -0,0 +1 @@ +# Messenger API for MTUSI high-load course, laboratory 2. diff --git a/app/config.py b/app/config.py new file mode 100644 index 00000000..aef01da1 --- /dev/null +++ b/app/config.py @@ -0,0 +1,72 @@ +"""Runtime configuration. + +The application never embeds credentials. Local Compose passes environment +variables from an ignored .env file; *_FILE variants are accepted as well so a +container platform can mount secrets without copying them into the image. +""" +from __future__ import annotations + +import os +from dataclasses import dataclass +from pathlib import Path + + +def _value(name: str, fallback_name: str | None = None, default: str | None = None) -> str: + raw = os.environ.get(name) + if raw: + return raw + if fallback_name: + filename = os.environ.get(fallback_name) + if filename: + path = Path(filename) + text = path.read_text(encoding="utf-8").strip() + if text: + return text + if default is not None: + return default + raise RuntimeError(f"missing required configuration: {name}") + + +def _positive_int(name: str, default: int) -> int: + raw = os.environ.get(name, str(default)) + try: + value = int(raw) + except ValueError as exc: + raise RuntimeError(f"{name} must be an integer") from exc + if value < 1: + raise RuntimeError(f"{name} must be positive") + return value + + +@dataclass(frozen=True) +class Settings: + database_url: str + cache_url: str + session_ttl_seconds: int + db_pool_min: int + db_pool_max: int + db_pool_acquire_timeout: float + db_connect_timeout: int + db_statement_timeout_ms: int + redis_connect_timeout: float + redis_socket_timeout: float + max_body_bytes: int + + +def load_settings() -> Settings: + return Settings( + database_url=_value("DATABASE_URL", "DATABASE_URL_FILE"), + cache_url=_value("CACHE_URL", "CACHE_URL_FILE"), + session_ttl_seconds=_positive_int("SESSION_TTL_SECONDS", 3600), + db_pool_min=_positive_int("DB_POOL_MIN", 1), + db_pool_max=_positive_int("DB_POOL_MAX", 10), + db_pool_acquire_timeout=float(os.environ.get("DB_POOL_ACQUIRE_TIMEOUT_SECONDS", "3")), + db_connect_timeout=_positive_int("DB_CONNECT_TIMEOUT_SECONDS", 3), + db_statement_timeout_ms=_positive_int("DB_STATEMENT_TIMEOUT_MS", 5000), + redis_connect_timeout=float(os.environ.get("REDIS_CONNECT_TIMEOUT_SECONDS", "2")), + redis_socket_timeout=float(os.environ.get("REDIS_SOCKET_TIMEOUT_SECONDS", "2")), + max_body_bytes=_positive_int("MAX_BODY_BYTES", 1024 * 1024), + ) + + +settings = load_settings() diff --git a/app/db.py b/app/db.py new file mode 100644 index 00000000..b8229577 --- /dev/null +++ b/app/db.py @@ -0,0 +1,118 @@ +"""PostgreSQL access: bounded pool, timeouts, and versioned migrations.""" +from __future__ import annotations + +import logging +import threading +import time +from pathlib import Path + +import psycopg +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool + +from .config import settings + +log = logging.getLogger("messenger.db") +MIGRATIONS_DIR = Path(__file__).resolve().parents[1] / "migrations" +LOCK_ID = 0x4D545553 # stable application-wide advisory lock + +_pool: ConnectionPool | None = None +_pool_lock = threading.Lock() +_migrated = threading.Event() +_started = False +_start_lock = threading.Lock() + + +def _create_pool() -> ConnectionPool: + options = ( + f"-c statement_timeout={settings.db_statement_timeout_ms} " + "-c idle_in_transaction_session_timeout=10000 " + "-c lock_timeout=3000" + ) + return ConnectionPool( + conninfo=settings.database_url, + min_size=settings.db_pool_min, + max_size=settings.db_pool_max, + timeout=settings.db_pool_acquire_timeout, + open=False, + kwargs={ + "row_factory": dict_row, + "connect_timeout": settings.db_connect_timeout, + "application_name": "mtusi-messenger-lab2", + "options": options, + }, + ) + + +def pool() -> ConnectionPool: + global _pool + with _pool_lock: + if _pool is None: + _pool = _create_pool() + return _pool + + +def apply_migrations() -> None: + """Apply every migration exactly once. + + A session-level advisory lock serialises concurrent API workers/restarts. + Each migration and its schema_migrations row share one transaction. + """ + with pool().connection() as conn: + conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,)) + try: + conn.execute( + """ + CREATE TABLE IF NOT EXISTS schema_migrations ( + version text PRIMARY KEY, + applied_at timestamptz NOT NULL DEFAULT clock_timestamp() + ) + """ + ) + applied = { + row["version"] + for row in conn.execute("SELECT version FROM schema_migrations").fetchall() + } + for path in sorted(MIGRATIONS_DIR.glob("*.sql")): + version = path.stem + if version in applied: + continue + log.info("applying migration %s", version) + conn.execute(path.read_text(encoding="utf-8")) + conn.execute( + "INSERT INTO schema_migrations(version) VALUES (%s)", (version,) + ) + finally: + conn.execute("SELECT pg_advisory_unlock(%s)", (LOCK_ID,)) + + +def start_background_initialisation() -> None: + """Open the pool and migrate without making /health/live depend on PostgreSQL.""" + global _started + with _start_lock: + if _started: + return + _started = True + + def run() -> None: + backoff = 0.5 + opened = False + while True: + try: + if not opened: + pool().open(wait=True, timeout=5) + opened = True + apply_migrations() + _migrated.set() + log.info("database pool is ready and schema is migrated") + return + except Exception as exc: # startup is retried; request path stays bounded + log.warning("database initialisation is not ready: %s", type(exc).__name__) + time.sleep(backoff) + backoff = min(backoff * 2, 5.0) + + threading.Thread(target=run, name="db-init", daemon=True).start() + + +def is_migrated() -> bool: + return _migrated.is_set() diff --git a/app/errors.py b/app/errors.py new file mode 100644 index 00000000..cce3352f --- /dev/null +++ b/app/errors.py @@ -0,0 +1,36 @@ +"""Typed public errors. Internal details never cross the HTTP boundary.""" +from __future__ import annotations + + +class ApiError(Exception): + def __init__(self, status: int, code: str, message: str, headers: dict[str, str] | None = None): + super().__init__(message) + self.status = status + self.code = code + self.message = message + self.headers = headers or {} + + +def bad_request(message: str = "Некорректный запрос") -> ApiError: + return ApiError(400, "invalid_request", message) + + +def unauthorized(*, basic: bool = False) -> ApiError: + challenge = ( + 'Basic realm="messenger", charset="UTF-8"' + if basic + else 'Bearer realm="messenger"' + ) + return ApiError(401, "unauthorized", "Требуется аутентификация", {"WWW-Authenticate": challenge}) + + +def not_found(message: str = "Объект не найден") -> ApiError: + return ApiError(404, "not_found", message) + + +def conflict(message: str = "Конфликт") -> ApiError: + return ApiError(409, "conflict", message) + + +def unavailable(message: str = "Сервис временно недоступен") -> ApiError: + return ApiError(503, "unavailable", message) diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..5b93b169 --- /dev/null +++ b/app/main.py @@ -0,0 +1,491 @@ +"""HTTP API for laboratory 2 (PostgreSQL + opaque sessions in Redis).""" +from __future__ import annotations + +import json +import logging +import time +import uuid +from datetime import datetime, timezone + +import psycopg +import psycopg_pool +import redis +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerifyMismatchError +from flask import Flask, Response, g, request + +from . import db, sessions +from .config import settings +from .errors import ApiError, bad_request, conflict, not_found, unauthorized, unavailable +from .validation import ( + cursor_time, + decode_cursor, + display_name, + encode_cursor, + exact_keys, + json_object, + limit_arg, + message_text, + non_blank, + password, + username, + uuid_list, + uuid_value, +) + +logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s") +log = logging.getLogger("messenger.api") + +app = Flask(__name__) +app.config["MAX_CONTENT_LENGTH"] = settings.max_body_bytes +hasher = PasswordHasher() + + +# --------------------------------------------------------------------------- +# Response helpers and middleware +# --------------------------------------------------------------------------- + +def _json(payload: object, status: int = 200, headers: dict[str, str] | None = None) -> Response: + body = json.dumps(payload, ensure_ascii=False, separators=(",", ":")) + response = Response(body, status=status, mimetype="application/json") + for key, value in (headers or {}).items(): + response.headers[key] = value + return response + + +def _error_response(error: ApiError, request_id: str) -> Response: + return _json( + { + "error": { + "code": error.code, + "message": error.message, + "request_id": request_id, + } + }, + error.status, + error.headers, + ) + + +@app.before_request +def _request_context() -> None: + g.request_id = uuid.uuid4().hex + g.started_at = time.monotonic() + db.start_background_initialisation() + + +@app.after_request +def _response_headers(response: Response) -> Response: + response.headers["X-Request-Id"] = g.get("request_id", uuid.uuid4().hex) + response.headers["Cache-Control"] = "no-store" + return response + + +@app.errorhandler(ApiError) +def _handle_api_error(error: ApiError) -> Response: + return _error_response(error, g.get("request_id", uuid.uuid4().hex)) + + +@app.errorhandler(413) +def _handle_too_large(_error: object) -> Response: + return _error_response( + ApiError(413, "payload_too_large", "Тело запроса слишком велико"), + g.get("request_id", uuid.uuid4().hex), + ) + + +@app.errorhandler(404) +def _handle_not_found(_error: object) -> Response: + return _error_response(not_found(), g.get("request_id", uuid.uuid4().hex)) + + +@app.errorhandler(405) +def _handle_method(_error: object) -> Response: + return _error_response(bad_request("Метод не поддерживается"), g.get("request_id", uuid.uuid4().hex)) + + +@app.errorhandler(Exception) +def _handle_unexpected(error: Exception) -> Response: + request_id = g.get("request_id", uuid.uuid4().hex) + if isinstance(error, (psycopg.OperationalError, psycopg_pool.PoolTimeout, psycopg_pool.PoolClosed)): + log.warning("database unavailable on %s %s: %s", request.method, request.path, type(error).__name__) + return _error_response(unavailable("База данных недоступна"), request_id) + if isinstance(error, redis.RedisError): + log.warning("session store unavailable on %s %s: %s", request.method, request.path, type(error).__name__) + return _error_response(unavailable("Хранилище сессий недоступно"), request_id) + log.exception("unhandled error on %s %s", request.method, request.path) + return _error_response( + ApiError(500, "internal_error", "Внутренняя ошибка сервера"), request_id + ) + + +# --------------------------------------------------------------------------- +# Serialisation +# --------------------------------------------------------------------------- + +def format_time(value: datetime) -> str: + return value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ") + + +def user_json(row: dict) -> dict: + return { + "id": str(row["id"]), + "username": row["username"], + "display_name": row["display_name"], + "created_at": format_time(row["created_at"]), + } + + +def chat_json(row: dict) -> dict: + member_ids = sorted(str(item) for item in (row.get("member_ids") or [])) + return { + "id": str(row["id"]), + "title": row["title"], + "member_ids": member_ids, + "created_at": format_time(row["created_at"]), + } + + +def message_json(row: dict) -> dict: + return { + "id": str(row["id"]), + "chat_id": str(row["chat_id"]), + "sender_id": str(row["sender_id"]), + "text": row["text"], + "created_at": format_time(row["created_at"]), + } + + +# --------------------------------------------------------------------------- +# Authentication +# --------------------------------------------------------------------------- + +def _bearer_token() -> str: + header = request.headers.get("Authorization", "") + parts = header.split(None, 1) + if len(parts) != 2 or parts[0].lower() != "bearer" or not parts[1].strip(): + raise unauthorized() + return parts[1].strip() + + +def current_user() -> dict: + cached = g.get("current_user") + if cached is not None: + return cached + token = _bearer_token() + user_id, token_digest = sessions.resolve(token) + if not user_id: + raise unauthorized() + try: + parsed = uuid.UUID(user_id) + except ValueError as exc: + raise unauthorized() from exc + with db.pool().connection() as conn: + row = conn.execute( + "SELECT id, username, display_name, created_at FROM users WHERE id = %s", + (parsed,), + ).fetchone() + if row is None: + sessions.revoke(token_digest) + raise unauthorized() + g.current_user = row + g.session_token_digest = token_digest + return row + + +def _basic_credentials() -> tuple[str, str]: + header = request.headers.get("Authorization", "") + parts = header.split(None, 1) + if len(parts) != 2 or parts[0].lower() != "basic": + raise unauthorized(basic=True) + import base64 + + try: + decoded = base64.b64decode(parts[1].strip(), validate=True).decode("utf-8") + except (ValueError, UnicodeError) as exc: + raise unauthorized(basic=True) from exc + name, separator, secret = decoded.partition(":") + if not separator or not name or not secret: + raise unauthorized(basic=True) + if len(name) > 32 or any(ord(char) > 127 for char in name): + raise unauthorized(basic=True) + return name, secret + + +def _authenticate_basic() -> dict: + name, secret = _basic_credentials() + with db.pool().connection() as conn: + row = conn.execute( + "SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = %s", + (name,), + ).fetchone() + if row is None: + raise unauthorized(basic=True) + try: + hasher.verify(row["password_hash"], secret) + except (VerifyMismatchError, InvalidHashError): + raise unauthorized(basic=True) + return row + + +# --------------------------------------------------------------------------- +# Health +# --------------------------------------------------------------------------- + +@app.get("/health/live") +def health_live() -> Response: + return _json({"status": "ok"}) + + +@app.get("/health/ready") +def health_ready() -> Response: + if not db.is_migrated(): + raise unavailable("База данных ещё не готова") + try: + with db.pool().connection(timeout=1.0) as conn: + conn.execute("SELECT 1") + except Exception as exc: + raise unavailable("База данных недоступна") from exc + sessions.ping() + return _json({"status": "ok"}) + + +# --------------------------------------------------------------------------- +# Users and sessions +# --------------------------------------------------------------------------- + +@app.post("/api/v1/users") +def register_user() -> Response: + body = json_object(request, settings.max_body_bytes) + exact_keys(body, ("username", "display_name", "password")) + name = username(body["username"]) + shown_name = display_name(body["display_name"]) + secret = password(body["password"]) + user_id = uuid.uuid4() + try: + with db.pool().connection() as conn: + row = conn.execute( + """ + INSERT INTO users (id, username, display_name, password_hash) + VALUES (%s, %s, %s, %s) + RETURNING id, username, display_name, created_at + """, + (user_id, name, shown_name, hasher.hash(secret)), + ).fetchone() + except psycopg.errors.UniqueViolation as exc: + raise conflict("Username уже занят") from exc + return _json(user_json(row), 201) + + +@app.post("/api/v1/auth/sessions") +def create_session() -> Response: + row = _authenticate_basic() + token, expires_at = sessions.create(str(row["id"])) + return _json( + { + "token": token, + "token_type": "Bearer", + "expires_at": format_time(expires_at), + "user": user_json(row), + }, + 201, + ) + + +@app.delete("/api/v1/auth/sessions/current") +def revoke_session() -> Response: + current_user() # authentication must happen before revocation + sessions.revoke(g.session_token_digest) + return Response(status=204) + + +@app.get("/api/v1/users/me") +def current_user_endpoint() -> Response: + return _json(user_json(current_user())) + + +# --------------------------------------------------------------------------- +# Chats +# --------------------------------------------------------------------------- + +def _require_chat_member(chat_id: uuid.UUID, user_id: uuid.UUID) -> None: + with db.pool().connection() as conn: + row = conn.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, user_id), + ).fetchone() + if row is None: + raise not_found() + + +@app.post("/api/v1/chats") +def create_chat() -> Response: + actor = current_user() + body = json_object(request, settings.max_body_bytes) + exact_keys(body, ("title", "member_ids")) + title = non_blank(body["title"], "title", 1, 100) + member_ids = uuid_list(body["member_ids"], "member_ids") + actor_id = str(actor["id"]) + if actor_id not in member_ids: + raise bad_request("Создатель должен входить в member_ids") + + member_uuids = [uuid.UUID(item) for item in member_ids] + chat_id = uuid.uuid4() + with db.pool().connection() as conn: + existing = conn.execute( + "SELECT id FROM users WHERE id = ANY(%s)", (member_uuids,) + ).fetchall() + if len(existing) != len(member_uuids): + raise bad_request("Указан неизвестный участник") + row = conn.execute( + "INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING id, title, created_at", + (chat_id, title), + ).fetchone() + with conn.cursor() as cursor: + cursor.executemany( + "INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", + [(chat_id, member) for member in member_uuids], + ) + payload = dict(row) + payload["member_ids"] = member_uuids + return _json(chat_json(payload), 201) + + +@app.get("/api/v1/chats") +def list_chats() -> Response: + actor = current_user() + limit = limit_arg(request.args.get("limit")) + cursor = decode_cursor(request.args.get("cursor")) + parameters: list[object] = [actor["id"]] + predicate = "" + if cursor is not None: + if cursor.get("kind") != "chats" or cursor.get("user_id") != str(actor["id"]): + raise bad_request("Некорректный cursor") + try: + cursor_created = cursor_time(cursor.get("created_at")) + cursor_id = uuid_value(cursor.get("id"), "cursor") + except ApiError: + raise bad_request("Некорректный cursor") + predicate = "AND (c.created_at, c.id) > (%s, %s)" + parameters.extend([cursor_created, cursor_id]) + parameters.append(limit + 1) + query = f""" + SELECT c.id, c.title, c.created_at, + ARRAY( + SELECT cm.user_id FROM chat_members cm + WHERE cm.chat_id = c.id ORDER BY cm.user_id + ) AS member_ids + FROM chats c + JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s + WHERE TRUE {predicate} + ORDER BY c.created_at, c.id + LIMIT %s + """ + with db.pool().connection() as conn: + rows = conn.execute(query, tuple(parameters)).fetchall() + page = rows[:limit] + next_cursor = None + if len(rows) > limit and page: + last = page[-1] + next_cursor = encode_cursor( + { + "v": 1, + "kind": "chats", + "user_id": str(actor["id"]), + "created_at": format_time(last["created_at"]), + "id": str(last["id"]), + } + ) + return _json({"items": [chat_json(row) for row in page], "next_cursor": next_cursor}) + + +@app.get("/api/v1/chats/") +def get_chat(chat_id: str) -> Response: + actor = current_user() + parsed_chat_id = uuid_value(chat_id, "chat_id") + with db.pool().connection() as conn: + row = conn.execute( + """ + SELECT c.id, c.title, c.created_at, + ARRAY( + SELECT cm.user_id FROM chat_members cm + WHERE cm.chat_id = c.id ORDER BY cm.user_id + ) AS member_ids + FROM chats c + JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s + WHERE c.id = %s + """, + (actor["id"], parsed_chat_id), + ).fetchone() + if row is None: + raise not_found() + return _json(chat_json(row)) + + +# --------------------------------------------------------------------------- +# Messages +# --------------------------------------------------------------------------- + +@app.post("/api/v1/chats//messages") +def create_message(chat_id: str) -> Response: + actor = current_user() + parsed_chat_id = uuid_value(chat_id, "chat_id") + _require_chat_member(parsed_chat_id, actor["id"]) + body = json_object(request, settings.max_body_bytes) + exact_keys(body, ("text",)) + text = message_text(body["text"]) + with db.pool().connection() as conn: + row = conn.execute( + """ + INSERT INTO messages (id, chat_id, sender_id, text) + VALUES (%s, %s, %s, %s) + RETURNING id, chat_id, sender_id, text, created_at + """, + (uuid.uuid4(), parsed_chat_id, actor["id"], text), + ).fetchone() + return _json(message_json(row), 201) + + +@app.get("/api/v1/chats//messages") +def list_messages(chat_id: str) -> Response: + actor = current_user() + parsed_chat_id = uuid_value(chat_id, "chat_id") + _require_chat_member(parsed_chat_id, actor["id"]) + limit = limit_arg(request.args.get("limit")) + cursor = decode_cursor(request.args.get("cursor")) + parameters: list[object] = [parsed_chat_id] + predicate = "" + if cursor is not None: + if cursor.get("kind") != "messages" or cursor.get("chat_id") != str(parsed_chat_id): + raise bad_request("Некорректный cursor") + try: + cursor_created = cursor_time(cursor.get("created_at")) + cursor_id = uuid_value(cursor.get("id"), "cursor") + except ApiError: + raise bad_request("Некорректный cursor") + predicate = "AND (created_at, id) > (%s, %s)" + parameters.extend([cursor_created, cursor_id]) + parameters.append(limit + 1) + query = f""" + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s {predicate} + ORDER BY created_at, id + LIMIT %s + """ + with db.pool().connection() as conn: + rows = conn.execute(query, tuple(parameters)).fetchall() + page = rows[:limit] + next_cursor = None + if len(rows) > limit and page: + last = page[-1] + next_cursor = encode_cursor( + { + "v": 1, + "kind": "messages", + "chat_id": str(parsed_chat_id), + "created_at": format_time(last["created_at"]), + "id": str(last["id"]), + } + ) + return _json({"items": [message_json(row) for row in page], "next_cursor": next_cursor}) diff --git a/app/sessions.py b/app/sessions.py new file mode 100644 index 00000000..96363f6b --- /dev/null +++ b/app/sessions.py @@ -0,0 +1,101 @@ +"""Opaque bearer sessions stored in Redis/Valkey with a TTL. + +PostgreSQL is the source of truth for users/chats/messages. Redis is the +authoritative store for *active sessions*; its append-only file and named +volume make those sessions survive a restart. The raw bearer token is never +stored: only a SHA-256 digest is used as the Redis key. +""" +from __future__ import annotations + +import hashlib +import json +import secrets +from datetime import datetime, timedelta, timezone + +import redis + +from .config import settings +from .errors import unavailable + +_client: redis.Redis | None = None + + +def client() -> redis.Redis: + global _client + if _client is None: + _client = redis.Redis.from_url( + settings.cache_url, + decode_responses=True, + socket_connect_timeout=settings.redis_connect_timeout, + socket_timeout=settings.redis_socket_timeout, + retry_on_timeout=False, + health_check_interval=30, + ) + return _client + + +def digest(token: str) -> str: + return hashlib.sha256(token.encode("utf-8")).hexdigest() + + +def _key(token_digest: str) -> str: + return "session:" + token_digest + + +def create(user_id: str) -> tuple[str, datetime]: + token = secrets.token_urlsafe(32) # 256 bits of entropy, opaque to clients + ttl = settings.session_ttl_seconds + expires_at = datetime.now(timezone.utc) + timedelta(seconds=ttl) + payload = json.dumps( + {"user_id": user_id, "expires_at": expires_at.isoformat().replace("+00:00", "Z")}, + separators=(",", ":"), + ) + try: + client().setex(_key(digest(token)), ttl, payload) + except redis.RedisError as exc: + raise unavailable("Хранилище сессий недоступно") from exc + return token, expires_at + + +def resolve(token: str) -> tuple[str, str]: + """Return (user_id, token_digest) or raise a bounded 503 error.""" + token_digest = digest(token) + try: + raw = client().get(_key(token_digest)) + except redis.RedisError as exc: + raise unavailable("Хранилище сессий недоступно") from exc + if not raw: + return "", token_digest + try: + data = json.loads(raw) + user_id = str(data["user_id"]) + expires_at = datetime.fromisoformat(str(data["expires_at"]).replace("Z", "+00:00")) + except (ValueError, KeyError, TypeError): + return "", token_digest + if expires_at <= datetime.now(timezone.utc): + revoke(token_digest) + return "", token_digest + return user_id, token_digest + + +def revoke(token_digest: str) -> None: + try: + client().delete(_key(token_digest)) + except redis.RedisError as exc: + raise unavailable("Хранилище сессий недоступно") from exc + + +def ping() -> None: + try: + if not client().ping(): + raise unavailable("Хранилище сессий недоступно") + except redis.RedisError as exc: + raise unavailable("Хранилище сессий недоступно") from exc + + +def seconds_left(token_digest: str) -> int: + try: + value = client().ttl(_key(token_digest)) + except redis.RedisError: + return 0 + return max(0, int(value)) diff --git a/app/validation.py b/app/validation.py new file mode 100644 index 00000000..9c6e5e5f --- /dev/null +++ b/app/validation.py @@ -0,0 +1,143 @@ +"""Strict parsing shared by HTTP handlers. + +The contract requires rejection of extra JSON fields, wrong types and +whitespace-only required strings. Validation happens before any SQL. +""" +from __future__ import annotations + +import base64 +import binascii +import json +import re +import uuid +from datetime import datetime, timezone + +from flask import Request + +from .errors import ApiError, bad_request + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") +INTEGER_RE = re.compile(r"^[0-9]+$") + + +def json_object(request: Request, max_bytes: int) -> dict: + if request.mimetype != "application/json": + raise bad_request("Ожидается application/json") + raw = request.get_data(cache=False) + if not raw: + raise bad_request("Тело запроса обязательно") + if len(raw) > max_bytes: + raise ApiError(413, "payload_too_large", "Тело запроса слишком велико") + try: + value = json.loads(raw) + except (ValueError, UnicodeError) as exc: + raise bad_request("Некорректный JSON") from exc + if not isinstance(value, dict): + raise bad_request("Ожидается JSON-объект") + return value + + +def exact_keys(value: dict, required: tuple[str, ...], optional: tuple[str, ...] = ()) -> None: + allowed = set(required) | set(optional) + if not set(required).issubset(value) or set(value) - allowed: + raise bad_request("Неверный набор полей") + + +def text_field(value: object, name: str, minimum: int, maximum: int) -> str: + if not isinstance(value, str): + raise bad_request(f"Поле {name} должно быть строкой") + if not (minimum <= len(value) <= maximum): + raise bad_request(f"Поле {name} имеет недопустимую длину") + return value + + +def non_blank(value: object, name: str, minimum: int, maximum: int) -> str: + result = text_field(value, name, minimum, maximum) + if not result.strip(): + raise bad_request(f"Поле {name} не должно быть пустым") + return result + + +def username(value: object) -> str: + result = text_field(value, "username", 3, 32) + if USERNAME_RE.fullmatch(result) is None: + raise bad_request("Недопустимый username") + return result + + +def display_name(value: object) -> str: + return non_blank(value, "display_name", 1, 100) + + +def password(value: object) -> str: + result = text_field(value, "password", 12, 128) + return result + + +def message_text(value: object) -> str: + return non_blank(value, "text", 1, 4000) + + +def uuid_list(value: object, name: str, minimum: int = 1, maximum: int = 100) -> list[str]: + if not isinstance(value, list): + raise bad_request(f"Поле {name} должно быть массивом") + if not (minimum <= len(value) <= maximum): + raise bad_request(f"Поле {name} имеет недопустимую длину") + parsed: list[str] = [] + for item in value: + parsed.append(str(uuid_value(item, name))) + if len(set(parsed)) != len(parsed): + raise bad_request(f"Поле {name} содержит дубликаты") + return parsed + + +def uuid_value(value: object, name: str = "id") -> uuid.UUID: + if not isinstance(value, str): + raise bad_request(f"Поле {name} должно быть UUID") + try: + return uuid.UUID(value) + except (ValueError, AttributeError) as exc: + raise bad_request(f"Поле {name} должно быть UUID") from exc + + +def limit_arg(raw: str | None, default: int = 50) -> int: + if raw is None: + return default + if INTEGER_RE.fullmatch(raw) is None: + raise bad_request("limit должен быть целым числом") + value = int(raw) + if not (1 <= value <= 100): + raise bad_request("limit должен быть в диапазоне 1..100") + return value + + +def encode_cursor(payload: dict) -> str: + raw = json.dumps(payload, separators=(",", ":"), ensure_ascii=False).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=") + + +def decode_cursor(raw: str | None) -> dict | None: + if raw is None: + return None + if not raw or len(raw) > 4096: + raise bad_request("Некорректный cursor") + padded = raw + "=" * (-len(raw) % 4) + try: + data = json.loads(base64.urlsafe_b64decode(padded.encode("ascii"))) + except (ValueError, UnicodeError, AttributeError, binascii.Error) as exc: + raise bad_request("Некорректный cursor") from exc + if not isinstance(data, dict): + raise bad_request("Некорректный cursor") + return data + + +def cursor_time(value: object) -> datetime: + if not isinstance(value, str): + raise bad_request("Некорректный cursor") + try: + result = datetime.fromisoformat(value.replace("Z", "+00:00")) + except ValueError as exc: + raise bad_request("Некорректный cursor") from exc + if result.tzinfo is None: + raise bad_request("Некорректный cursor") + return result.astimezone(timezone.utc) diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..9dc85a00 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,82 @@ +# Local synthetic stand for laboratory 2. +# Copy .env.example to .env and change the local password before use. +# The password is read from .env at Compose time and is never committed. + +name: mtusi-lab2 + +services: + postgres: + image: postgres:16.4-alpine + restart: unless-stopped + environment: + POSTGRES_DB: ${POSTGRES_DB:-messenger} + POSTGRES_USER: ${POSTGRES_USER:-messenger} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env} + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"] + interval: 3s + timeout: 3s + retries: 20 + networks: + - backend + + redis: + image: redis:7.4.0-alpine + restart: unless-stopped + # Sessions are the only Redis data. AOF + the named volume keep active + # sessions across an API/Redis restart; TTL remains the expiry authority. + command: + - redis-server + - --appendonly + - "yes" + - --appendfsync + - everysec + - --dir + - /data + volumes: + - redisdata:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 3s + timeout: 3s + retries: 20 + networks: + - backend + + api: + build: + context: . + dockerfile: Dockerfile + restart: unless-stopped + environment: + APP_ENV: lab + DATABASE_URL: ${DATABASE_URL:?set DATABASE_URL in .env} + CACHE_URL: ${CACHE_URL:-redis://redis:6379/0} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DB_POOL_MIN: ${DB_POOL_MIN:-1} + DB_POOL_MAX: ${DB_POOL_MAX:-10} + DB_POOL_ACQUIRE_TIMEOUT_SECONDS: ${DB_POOL_ACQUIRE_TIMEOUT_SECONDS:-3} + DB_CONNECT_TIMEOUT_SECONDS: ${DB_CONNECT_TIMEOUT_SECONDS:-3} + DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000} + REDIS_CONNECT_TIMEOUT_SECONDS: ${REDIS_CONNECT_TIMEOUT_SECONDS:-2} + REDIS_SOCKET_TIMEOUT_SECONDS: ${REDIS_SOCKET_TIMEOUT_SECONDS:-2} + MAX_BODY_BYTES: ${MAX_BODY_BYTES:-1048576} + ports: + - "${API_PORT:-8080}:8080" + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + networks: + - backend + +volumes: + pgdata: + redisdata: + +networks: + backend: + driver: bridge diff --git a/evidence/auth_negative.txt b/evidence/auth_negative.txt new file mode 100644 index 00000000..05d004bd --- /dev/null +++ b/evidence/auth_negative.txt @@ -0,0 +1 @@ +PASS: wrong password, Basic rejection, logout and token reuse checks diff --git a/evidence/check.txt b/evidence/check.txt new file mode 100644 index 00000000..b62af9c5 --- /dev/null +++ b/evidence/check.txt @@ -0,0 +1 @@ +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. diff --git a/evidence/containers-after-restart.txt b/evidence/containers-after-restart.txt new file mode 100644 index 00000000..ba70e04d --- /dev/null +++ b/evidence/containers-after-restart.txt @@ -0,0 +1,4 @@ +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-lab2-api-1 mtusi-lab2-api "gunicorn --bind=0.0тАж" api 23 seconds ago Up 1 second (health: starting) 0.0.0.0:18080->8080/tcp, [::]:18080->8080/tcp +mtusi-lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.sтАж" postgres 12 minutes ago Up 2 seconds (health: starting) 5432/tcp +mtusi-lab2-redis-1 redis:7.4.0-alpine "docker-entrypoint.sтАж" redis 12 minutes ago Up 2 seconds (health: starting) 6379/tcp diff --git a/evidence/containers-before-restart.txt b/evidence/containers-before-restart.txt new file mode 100644 index 00000000..a39e7f14 --- /dev/null +++ b/evidence/containers-before-restart.txt @@ -0,0 +1,4 @@ +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-lab2-api-1 mtusi-lab2-api "gunicorn --bind=0.0тАж" api 19 seconds ago Up 17 seconds (healthy) 0.0.0.0:18080->8080/tcp, [::]:18080->8080/tcp +mtusi-lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.sтАж" postgres 12 minutes ago Up About a minute (healthy) 5432/tcp +mtusi-lab2-redis-1 redis:7.4.0-alpine "docker-entrypoint.sтАж" redis 12 minutes ago Up About a minute (healthy) 6379/tcp diff --git a/evidence/edge_cases.txt b/evidence/edge_cases.txt new file mode 100644 index 00000000..5e3788f7 --- /dev/null +++ b/evidence/edge_cases.txt @@ -0,0 +1,19 @@ +empty users body 400 invalid_request +extra user field 400 invalid_request +chat1 201 None +chat2 201 None +unknown member 400 invalid_request +caller missing 400 invalid_request +duplicate member 400 invalid_request +invalid chat uuid 400 invalid_request +message 201 None +message 201 None +page exactly limit 200 2 None +chat1 page 200 None +chat1 page had no next cursor +chat page 1 200 1 True +chat page 2 200 1 False +blank text 400 invalid_request +too long text 400 invalid_request +sender_id rejected 400 invalid_request +EDGE PASS diff --git a/evidence/expiry.txt b/evidence/expiry.txt new file mode 100644 index 00000000..1e9b8bbf --- /dev/null +++ b/evidence/expiry.txt @@ -0,0 +1 @@ +PASS: expired session is rejected with 401 and Bearer challenge diff --git a/evidence/explain_history.txt b/evidence/explain_history.txt new file mode 100644 index 00000000..deb9fba3 --- /dev/null +++ b/evidence/explain_history.txt @@ -0,0 +1,16 @@ +# EXPLAIN (ANALYZE, BUFFERS) for keyset history pagination +generated_at_utc: 2026-11-06T19:27:08.308823Z +messages_in_chat: 10000 +chat_id: 009edfde-74bf-4dd7-8e55-a665d2d6f38a +query: WHERE chat_id = ? AND (created_at, id) > (?, ?) ORDER BY created_at, id LIMIT 51 + +Limit (cost=0.29..94.71 rows=51 width=78) (actual time=0.020..0.029 rows=51 loops=1) + Buffers: shared hit=4 + -> Index Scan using messages_chat_created_at_id_idx on messages (cost=0.29..926.01 rows=500 width=78) (actual time=0.019..0.025 rows=51 loops=1) + Index Cond: ((chat_id = '009edfde-74bf-4dd7-8e55-a665d2d6f38a'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:09.501+00'::timestamp with time zone, 'd8f60f44-b107-4f1a-bae2-4fcf80d33d70'::uuid))) + Buffers: shared hit=4 +Planning: + Buffers: shared hit=6 +Planning Time: 0.138 ms +Execution Time: 0.124 ms +PASS: index used on 10000 messages; evidence written to /tmp/explain_history.txt diff --git a/evidence/fault_matrix.txt b/evidence/fault_matrix.txt new file mode 100644 index 00000000..90276fe4 --- /dev/null +++ b/evidence/fault_matrix.txt @@ -0,0 +1,5 @@ +OBSERVED: redis down: readiness=503, bearer request=503 +OBSERVED: redis up: readiness=200 in 0.48s, same token=200 (AOF persistence) +OBSERVED: postgres down: readiness=503, bearer request=503 +OBSERVED: postgres up: readiness=200 in 3.01s, same token=200 +PASS: dependency loss produced only bounded 503 responses; no anonymous trust diff --git a/evidence/load.json b/evidence/load.json new file mode 100644 index 00000000..796874c2 --- /dev/null +++ b/evidence/load.json @@ -0,0 +1,17 @@ +{ + "lab": 2, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 15.0, + "elapsed_seconds": 15.047, + "concurrency": 4, + "successful_requests": 2599, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 172.728, + "successful_latency_ms": { + "p50": 22.956, + "p95": 38.873, + "p99": 44.759 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/load.txt b/evidence/load.txt new file mode 100644 index 00000000..796874c2 --- /dev/null +++ b/evidence/load.txt @@ -0,0 +1,17 @@ +{ + "lab": 2, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 15.0, + "elapsed_seconds": 15.047, + "concurrency": 4, + "successful_requests": 2599, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 172.728, + "successful_latency_ms": { + "p50": 22.956, + "p95": 38.873, + "p99": 44.759 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..749fd29b --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,2 @@ +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/pool_settings.txt b/evidence/pool_settings.txt new file mode 100644 index 00000000..e2454fc2 --- /dev/null +++ b/evidence/pool_settings.txt @@ -0,0 +1,8 @@ +statement_timeout = 5s +idle_in_transaction_session_timeout = 10s +lock_timeout = 3s +pool_min = 1 +pool_max = 10 +pool_size = 1 +pool_available = 1 +PASS: bounded pool and SQL timeouts are active diff --git a/evidence/race_username.txt b/evidence/race_username.txt new file mode 100644 index 00000000..4dcfc113 --- /dev/null +++ b/evidence/race_username.txt @@ -0,0 +1 @@ +PASS: 8 concurrent registrations produced exactly one user and one session diff --git a/evidence/redis.txt b/evidence/redis.txt new file mode 100644 index 00000000..3ab73591 --- /dev/null +++ b/evidence/redis.txt @@ -0,0 +1,10 @@ + +rdb_last_save_time:1793993503 +aof_enabled:1 +aof_rewrite_in_progress:0 +aof_last_write_status:ok + + +23 +sample_session_key=session:0ca7134c5787318eb96bdeca133253f826477b52413ccd3f7f905f9aed20007d +sample_session_ttl_seconds=3486 diff --git a/evidence/rollback_chat.txt b/evidence/rollback_chat.txt new file mode 100644 index 00000000..45da8026 --- /dev/null +++ b/evidence/rollback_chat.txt @@ -0,0 +1 @@ +PASS: failed membership insert rolled back the chat; subsequent create is atomic diff --git a/evidence/schema.txt b/evidence/schema.txt new file mode 100644 index 00000000..3202901a --- /dev/null +++ b/evidence/schema.txt @@ -0,0 +1,36 @@ +TABLES + table_name +------------------- + chat_members + chats + messages + schema_migrations + users +(5 rows) + +INDEXES + indexname | indexdef +---------------------------------+------------------------------------------------------------------------------------------------------- + chat_members_pkey | CREATE UNIQUE INDEX chat_members_pkey ON public.chat_members USING btree (chat_id, user_id) + chat_members_user_chat_idx | CREATE INDEX chat_members_user_chat_idx ON public.chat_members USING btree (user_id, chat_id) + chats_created_at_id_idx | CREATE INDEX chats_created_at_id_idx ON public.chats USING btree (created_at, id) + chats_pkey | CREATE UNIQUE INDEX chats_pkey ON public.chats USING btree (id) + messages_chat_created_at_id_idx | CREATE INDEX messages_chat_created_at_id_idx ON public.messages USING btree (chat_id, created_at, id) + messages_pkey | CREATE UNIQUE INDEX messages_pkey ON public.messages USING btree (id) + schema_migrations_pkey | CREATE UNIQUE INDEX schema_migrations_pkey ON public.schema_migrations USING btree (version) + users_pkey | CREATE UNIQUE INDEX users_pkey ON public.users USING btree (id) + users_username_key | CREATE UNIQUE INDEX users_username_key ON public.users USING btree (username) +(9 rows) + +MIGRATIONS + version | applied_at +----------+------------------------------- + 001_init | 2026-11-06 19:22:16.209767+00 +(1 row) + +COUNTS + users | chats | members | messages +-------+-------+---------+---------- + 34 | 11 | 18 | 22635 +(1 row) + diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..92154196 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1 @@ +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..c741c20b --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,51 @@ +-- Laboratory 2 initial schema. +-- PostgreSQL is the source of truth for users, chats, membership and messages. + +CREATE TABLE IF NOT EXISTS users ( + id uuid PRIMARY KEY, + username text NOT NULL, + display_name text NOT NULL, + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT users_username_key UNIQUE (username), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_length CHECK (char_length(display_name) BETWEEN 1 AND 100) +); + +CREATE TABLE IF NOT EXISTS chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT chats_title_length CHECK (char_length(title) BETWEEN 1 AND 100) +); + +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, + joined_at timestamptz NOT NULL DEFAULT clock_timestamp(), + PRIMARY KEY (chat_id, user_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) ON DELETE RESTRICT, + text text NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT messages_text_length CHECK (char_length(text) BETWEEN 1 AND 4000) +); + +-- Reverse membership lookup: "my chats, newest last". +CREATE INDEX IF NOT EXISTS chat_members_user_chat_idx + ON chat_members (user_id, chat_id); + +-- Chat page ordering and keyset pagination. +CREATE INDEX IF NOT EXISTS chats_created_at_id_idx + ON chats (created_at, id); + +-- The only history access path: +-- WHERE chat_id = ? AND (created_at, id) > (?, ?) +-- ORDER BY created_at, id LIMIT ? +-- It supports the range scan without reading the whole chat history. +CREATE INDEX IF NOT EXISTS messages_chat_created_at_id_idx + ON messages (chat_id, created_at, id); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..e47067e0 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,5 @@ +Flask==3.1.0 +gunicorn==23.0.0 +psycopg[binary,pool]==3.2.3 +redis==5.2.1 +argon2-cffi==23.1.0 diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..54728644 --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,10 @@ +@echo off +rem Restart API and all state stores without deleting named volumes. +setlocal +cd /d "%~dp0.." +if not exist ".env" ( + echo missing .env; copy .env.example and set local synthetic credentials 1>&2 + exit /b 2 +) +docker compose --env-file .env restart +exit /b %errorlevel% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..1306bd42 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,12 @@ +#!/bin/sh +# Restart API and ALL state stores without deleting named volumes. +# The public persistence test polls /health/ready itself, so this hook only +# performs the restart and returns non-zero on a Compose error. +set -eu +ROOT=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd) +cd "$ROOT" +if [ ! -f .env ]; then + echo "missing .env; copy .env.example and set local synthetic credentials" >&2 + exit 2 +fi +docker compose --env-file .env restart diff --git a/student-tests/README.md b/student-tests/README.md new file mode 100644 index 00000000..a8bf322e --- /dev/null +++ b/student-tests/README.md @@ -0,0 +1,31 @@ +# Студенческие проверки уровня 4 + +Все проверки, кроме `rollback_chat.py` и `explain_history.py`, запускаются на +хосте и обращаются к API по HTTP. Две проверки используют `psycopg` и запускаются +внутри контейнера `api`, где зависимость уже установлена. + +```sh +# 1. Негативная аутентификация и logout +python student-tests/auth_negative.py --base-url http://localhost:8080 + +# 2. Гонка регистрации одного username +python student-tests/race_username.py --base-url http://localhost:8080 --workers 8 + +# 3. Откат составной операции (внутри контейнера) +docker compose exec -T api python student-tests/rollback_chat.py + +# 4. EXPLAIN на 10 000 сообщений (внутри контейнера) +docker compose exec -T api python student-tests/explain_history.py \ + --output /tmp/explain_history.txt + +# 5. Отказы Redis и PostgreSQL (с хоста; управляет docker compose) +python student-tests/fault_matrix.py + +# 6. Истечение сессии: API должен быть запущен с коротким TTL +# SESSION_TTL_SECONDS=2 docker compose up -d --force-recreate api +python student-tests/expiry.py --wait 4 +``` + +`fault_matrix.py` останавливает `redis`/`postgres` и обязательно запускает их +обратно в `finally`. Он проверяет только ограниченные `503`, отсутствие +доверенного анонимного доступа и сохранность сессии после рестарта Redis с AOF. diff --git a/student-tests/auth_negative.py b/student-tests/auth_negative.py new file mode 100644 index 00000000..3ae34f04 --- /dev/null +++ b/student-tests/auth_negative.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 +"""Wrong password, Basic-on-business-endpoint, logout and reuse checks.""" +from __future__ import annotations + +import argparse +import base64 + +from common import HttpClient, assert_status, error_code + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--base-url", default="http://localhost:8080") + args = parser.parse_args() + client = HttpClient(args.base_url) + user, registration = client.register() + + wrong = base64.b64encode( + (registration["username"] + ":wrong-password-value").encode("utf-8") + ).decode("ascii") + status, headers, payload, _ = client.call( + "POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + wrong} + ) + assert_status(status, 401, "wrong password") + assert error_code(payload) == "unauthorized" + assert headers.get("WWW-Authenticate", "").lower().startswith("basic") + + good = base64.b64encode( + (registration["username"] + ":" + registration["password"]).encode("utf-8") + ).decode("ascii") + status, headers, _, _ = client.call( + "GET", "/api/v1/users/me", headers={"Authorization": "Basic " + good} + ) + assert_status(status, 401, "Basic on business endpoint") + assert headers.get("WWW-Authenticate", "").lower().startswith("bearer") + + session = client.login(registration) + token = session["token"] + status, _, me, _ = client.call("GET", "/api/v1/users/me", token=token) + assert_status(status, 200, "login") + assert me["id"] == user["id"] + + status, _, _, raw = client.call("DELETE", "/api/v1/auth/sessions/current", token=token) + assert_status(status, 204, "logout") + assert raw == b"", "204 must have an empty body" + + status, headers, payload, _ = client.call("GET", "/api/v1/users/me", token=token) + assert_status(status, 401, "token after logout") + assert error_code(payload) == "unauthorized" + assert headers.get("WWW-Authenticate", "").lower().startswith("bearer") + + status, _, _, _ = client.call("DELETE", "/api/v1/auth/sessions/current", token=token) + assert_status(status, 401, "second logout") + print("PASS: wrong password, Basic rejection, logout and token reuse checks") + + +if __name__ == "__main__": + main() diff --git a/student-tests/common.py b/student-tests/common.py new file mode 100644 index 00000000..bbb4761a --- /dev/null +++ b/student-tests/common.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python3 +"""Small standard-library HTTP helpers for the student checks.""" +from __future__ import annotations + +import base64 +import json +import os +import uuid +import urllib.error +import urllib.request + +BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/") + + +class HttpClient: + def __init__(self, base_url: str | None = None): + self.base = (base_url or BASE_URL).rstrip("/") + + def call(self, method: str, path: str, body=None, token: str | None = None, headers=None): + h = {"Accept": "application/json"} + data = None + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + h["Content-Type"] = "application/json" + if token: + h["Authorization"] = "Bearer " + token + h.update(headers or {}) + request = urllib.request.Request(self.base + path, data=data, headers=h, method=method) + try: + response = urllib.request.urlopen(request, timeout=10) + except urllib.error.HTTPError as error: + response = error + with response: + raw = response.read() + payload = None + if raw: + try: + payload = json.loads(raw) + except ValueError: + payload = None + return response.code, response.headers, payload, raw + + def register(self) -> tuple[dict, dict]: + suffix = uuid.uuid4().hex[:12] + registration = { + "username": "st_" + suffix, + "display_name": "Студент " + suffix, + "password": "T3st-" + uuid.uuid4().hex, + } + status, _headers, user, _raw = self.call("POST", "/api/v1/users", registration) + if status != 201: + raise AssertionError(f"registration failed: HTTP {status}") + return user, registration + + def login(self, registration: dict) -> dict: + credential = base64.b64encode( + (registration["username"] + ":" + registration["password"]).encode("utf-8") + ).decode("ascii") + status, _headers, session, _raw = self.call( + "POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + credential} + ) + if status != 201: + raise AssertionError(f"login failed: HTTP {status}") + return session + + +def assert_status(actual: int, expected: int, label: str) -> None: + if actual != expected: + raise AssertionError(f"{label}: expected HTTP {expected}, received {actual}") + + +def error_code(payload) -> str | None: + if not isinstance(payload, dict): + return None + error = payload.get("error") + return error.get("code") if isinstance(error, dict) else None diff --git a/student-tests/expiry.py b/student-tests/expiry.py new file mode 100644 index 00000000..d48da0f6 --- /dev/null +++ b/student-tests/expiry.py @@ -0,0 +1,35 @@ +#!/usr/bin/env python3 +"""Expiry check: run against an API with SESSION_TTL_SECONDS=2 (or pass --wait).""" +from __future__ import annotations + +import argparse +import time + +from common import HttpClient, assert_status, error_code + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--base-url", default="http://localhost:8080") + parser.add_argument("--wait", type=float, default=3.0) + args = parser.parse_args() + + client = HttpClient(args.base_url) + user, registration = client.register() + session = client.login(registration) + token = session["token"] + + status, headers, payload, _ = client.call("GET", "/api/v1/users/me", token=token) + assert_status(status, 200, "fresh session") + assert payload["id"] == user["id"], "wrong current user" + + time.sleep(args.wait) + status, headers, payload, _ = client.call("GET", "/api/v1/users/me", token=token) + assert_status(status, 401, "expired session") + assert error_code(payload) == "unauthorized", "expired session must be unauthorized" + assert headers.get("WWW-Authenticate", "").lower().startswith("bearer"), "missing Bearer challenge" + print("PASS: expired session is rejected with 401 and Bearer challenge") + + +if __name__ == "__main__": + main() diff --git a/student-tests/explain_history.py b/student-tests/explain_history.py new file mode 100644 index 00000000..d7c7df0b --- /dev/null +++ b/student-tests/explain_history.py @@ -0,0 +1,101 @@ +#!/usr/bin/env python3 +"""Create 10 000 synthetic messages and record EXPLAIN (ANALYZE, BUFFERS). + +Run inside the API container (psycopg is installed there): + docker compose exec -T api python student-tests/explain_history.py \ + --output /app/evidence/explain_history.txt + +The evidence directory is mounted read-only in the container, so the example +below is normally executed with a writable bind mount or copied out. +""" +from __future__ import annotations + +import argparse +import os +import uuid +from datetime import datetime, timezone +from pathlib import Path + +import psycopg + +MESSAGES = 10_000 + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--database-url", default=os.environ.get("DATABASE_URL")) + parser.add_argument("--output", default="evidence/explain_history.txt") + parser.add_argument("--messages", type=int, default=MESSAGES) + args = parser.parse_args() + if not args.database_url: + raise SystemExit("DATABASE_URL is required") + + tag = uuid.uuid4().hex[:10] + user_id = uuid.uuid4() + chat_id = uuid.uuid4() + with psycopg.connect(args.database_url) as conn: + conn.execute( + "INSERT INTO users (id, username, display_name, password_hash) VALUES (%s, %s, %s, %s)", + (user_id, "perf_" + tag, "Performance synthetic", "not-a-real-password-hash"), + ) + conn.execute("INSERT INTO chats (id, title) VALUES (%s, %s)", (chat_id, "perf-" + tag)) + conn.execute( + "INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", (chat_id, user_id) + ) + conn.execute( + """ + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + SELECT gen_random_uuid(), %s, %s, 'synthetic message ' || g, + timestamptz '2026-01-01 00:00:00+00' + (g || ' milliseconds')::interval + FROM generate_series(1, %s) AS g + """, + (chat_id, user_id, args.messages), + ) + total = conn.execute( + "SELECT count(*) FROM messages WHERE chat_id = %s", (chat_id,) + ).fetchone()[0] + conn.execute("ANALYZE messages") + cursor = conn.execute( + """ + SELECT created_at, id FROM messages + WHERE chat_id = %s ORDER BY created_at, id + OFFSET %s LIMIT 1 + """, + (chat_id, max(0, args.messages - 500)), + ).fetchone() + plan_rows = conn.execute( + """ + EXPLAIN (ANALYZE, BUFFERS) + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s AND (created_at, id) > (%s, %s) + ORDER BY created_at, id + LIMIT 51 + """, + (chat_id, cursor[0], cursor[1]), + ).fetchall() + conn.commit() + + plan = "\n".join(row[0] for row in plan_rows) + if "messages_chat_created_at_id_idx" not in plan: + raise AssertionError("history query did not use the keyset index:\n" + plan) + if "Seq Scan" in plan: + raise AssertionError("history query performed a sequential scan:\n" + plan) + + header = ( + "# EXPLAIN (ANALYZE, BUFFERS) for keyset history pagination\n" + f"generated_at_utc: {datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z')}\n" + f"messages_in_chat: {total}\n" + f"chat_id: {chat_id}\n" + "query: WHERE chat_id = ? AND (created_at, id) > (?, ?) " + "ORDER BY created_at, id LIMIT 51\n\n" + ) + output = Path(args.output) + output.parent.mkdir(parents=True, exist_ok=True) + output.write_text(header + plan + "\n", encoding="utf-8") + print(header + plan) + print(f"PASS: index used on {total} messages; evidence written to {output}") + + +if __name__ == "__main__": + main() diff --git a/student-tests/fault_matrix.py b/student-tests/fault_matrix.py new file mode 100644 index 00000000..a066fc3b --- /dev/null +++ b/student-tests/fault_matrix.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +"""Dependency-failure matrix: Redis and PostgreSQL outages must be bounded. + +The check uses the local Compose project. It stops one dependency, verifies +503 (never 200 and never a trusted anonymous request), starts it again, waits +for readiness and confirms the original bearer session still works after the +Redis restart (AOF persistence). +""" +from __future__ import annotations + +import argparse +import os +import subprocess +import time +from pathlib import Path + +from common import HttpClient, assert_status, error_code + +ROOT = Path(__file__).resolve().parents[1] + + +def compose(*args: str) -> None: + subprocess.run( + ["docker", "compose", "--env-file", ".env", *args], + cwd=ROOT, + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + ) + + +def wait_ready(client: HttpClient, expected: int, seconds: float = 90) -> None: + deadline = time.monotonic() + seconds + last = None + while time.monotonic() < deadline: + try: + status, _, _, _ = client.call("GET", "/health/ready") + last = status + if status == expected: + return + except OSError: + last = "connection error" + time.sleep(0.5) + raise AssertionError(f"readiness did not become {expected}; last={last}") + + +def expect_503(client: HttpClient, path: str, token: str | None, label: str) -> None: + status, _headers, payload, _raw = client.call("GET", path, token=token) + if status != 503: + raise AssertionError(f"{label}: expected 503, received {status}") + if error_code(payload) != "unavailable": + raise AssertionError(f"{label}: expected unavailable error code") + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--base-url", default="http://localhost:8080") + args = parser.parse_args() + client = HttpClient(args.base_url) + user, registration = client.register() + session = client.login(registration) + token = session["token"] + + results = [] + try: + compose("stop", "redis") + expect_503(client, "/health/ready", None, "Redis down readiness") + expect_503(client, "/api/v1/users/me", token, "Redis down authenticated request") + results.append("redis down: readiness=503, bearer request=503") + started = time.monotonic() + compose("start", "redis") + wait_ready(client, 200) + redis_recovery = round(time.monotonic() - started, 2) + status, _, me, _ = client.call("GET", "/api/v1/users/me", token=token) + assert_status(status, 200, "session after Redis restart") + if me["id"] != user["id"]: + raise AssertionError("session identity changed after Redis restart") + results.append(f"redis up: readiness=200 in {redis_recovery}s, same token=200 (AOF persistence)") + + compose("stop", "postgres") + time.sleep(1) + expect_503(client, "/health/ready", None, "PostgreSQL down readiness") + expect_503(client, "/api/v1/users/me", token, "PostgreSQL down authenticated request") + results.append("postgres down: readiness=503, bearer request=503") + started = time.monotonic() + compose("start", "postgres") + wait_ready(client, 200) + postgres_recovery = round(time.monotonic() - started, 2) + status, _, me, _ = client.call("GET", "/api/v1/users/me", token=token) + assert_status(status, 200, "session after PostgreSQL restart") + results.append(f"postgres up: readiness=200 in {postgres_recovery}s, same token=200") + finally: + compose("start", "redis") + compose("start", "postgres") + + for line in results: + print("OBSERVED:", line) + print("PASS: dependency loss produced only bounded 503 responses; no anonymous trust") + + +if __name__ == "__main__": + main() diff --git a/student-tests/pool_settings.py b/student-tests/pool_settings.py new file mode 100644 index 00000000..21d47b24 --- /dev/null +++ b/student-tests/pool_settings.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +"""Print the effective PostgreSQL timeouts and pool limits. + +Run inside the API container: + docker compose exec -T api python student-tests/pool_settings.py +""" +from __future__ import annotations + +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) + +from app import db + + +def main() -> None: + db.pool().open(wait=True, timeout=5) + db.apply_migrations() + with db.pool().connection() as conn: + statement = conn.execute("SHOW statement_timeout").fetchone()["statement_timeout"] + idle = conn.execute("SHOW idle_in_transaction_session_timeout").fetchone()[ + "idle_in_transaction_session_timeout" + ] + lock = conn.execute("SHOW lock_timeout").fetchone()["lock_timeout"] + stats = db.pool().get_stats() + print("statement_timeout =", statement) + print("idle_in_transaction_session_timeout =", idle) + print("lock_timeout =", lock) + print("pool_min =", stats["pool_min"]) + print("pool_max =", stats["pool_max"]) + print("pool_size =", stats["pool_size"]) + print("pool_available =", stats["pool_available"]) + print("PASS: bounded pool and SQL timeouts are active") + + +if __name__ == "__main__": + main() diff --git a/student-tests/race_username.py b/student-tests/race_username.py new file mode 100644 index 00000000..c2c30e6a --- /dev/null +++ b/student-tests/race_username.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python3 +"""Concurrent registration with the same username: one 201, the rest 409.""" +from __future__ import annotations + +import argparse +import uuid +from concurrent.futures import ThreadPoolExecutor + +from common import HttpClient, assert_status, error_code + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--base-url", default="http://localhost:8080") + parser.add_argument("--workers", type=int, default=8) + args = parser.parse_args() + client = HttpClient(args.base_url) + username = "race_" + uuid.uuid4().hex[:16] + body = { + "username": username, + "display_name": "Race candidate", + "password": "T3st-" + uuid.uuid4().hex, + } + + def register(_index: int): + status, _, payload, _ = client.call("POST", "/api/v1/users", body) + return status, error_code(payload) + + with ThreadPoolExecutor(max_workers=args.workers) as executor: + results = list(executor.map(register, range(args.workers))) + + statuses = [status for status, _code in results] + if statuses.count(201) != 1 or statuses.count(409) != args.workers - 1: + raise AssertionError(f"expected one 201 and {args.workers - 1} conflicts, got {statuses}") + for status, code in results: + if status == 409 and code != "conflict": + raise AssertionError("409 must carry conflict code") + + session = client.login(body) + assert session["user"]["username"] == username + print(f"PASS: {args.workers} concurrent registrations produced exactly one user and one session") + + +if __name__ == "__main__": + main() diff --git a/student-tests/rollback_chat.py b/student-tests/rollback_chat.py new file mode 100644 index 00000000..46804f21 --- /dev/null +++ b/student-tests/rollback_chat.py @@ -0,0 +1,86 @@ +#!/usr/bin/env python3 +"""Prove that a failure after the chat insert rolls back the whole chat. + +Run inside the API container (psycopg is installed there): + docker compose exec -T api python student-tests/rollback_chat.py + +A temporary trigger aborts the second chat_members insert. The API must +return a bounded 500 and leave no chat row, because chat + membership share +one transaction. +""" +from __future__ import annotations + +import argparse +import os +import uuid + +import psycopg + +from common import HttpClient, assert_status, error_code + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--base-url", default="http://localhost:8080") + parser.add_argument("--database-url", default=os.environ.get("DATABASE_URL")) + args = parser.parse_args() + if not args.database_url: + raise SystemExit("DATABASE_URL is required") + + client = HttpClient(args.base_url) + actor, actor_registration = client.register() + victim, _victim_registration = client.register() + session = client.login(actor_registration) + token = session["token"] + + title = "rollback-" + uuid.uuid4().hex + function_name = "test_fail_member_" + uuid.uuid4().hex[:8] + victim_id = str(uuid.UUID(victim["id"])) + + with psycopg.connect(args.database_url, autocommit=True) as conn: + conn.execute( + f""" + CREATE FUNCTION {function_name}() RETURNS trigger AS $$ + BEGIN + IF NEW.user_id = '{victim_id}'::uuid THEN + RAISE EXCEPTION 'injected membership failure'; + END IF; + RETURN NEW; + END + $$ LANGUAGE plpgsql + """ + ) + conn.execute( + f"CREATE TRIGGER {function_name} BEFORE INSERT ON chat_members " + f"FOR EACH ROW EXECUTE FUNCTION {function_name}()" + ) + try: + status, _, payload, _ = client.call( + "POST", + "/api/v1/chats", + {"title": title, "member_ids": [actor["id"], victim["id"]]}, + token=token, + ) + assert_status(status, 500, "injected membership failure") + if error_code(payload) != "internal_error": + raise AssertionError("unexpected error code for injected failure") + rows = conn.execute("SELECT count(*) FROM chats WHERE title = %s", (title,)).fetchone() + if rows[0] != 0: + raise AssertionError("chat survived a failed membership transaction") + finally: + conn.execute(f"DROP TRIGGER IF EXISTS {function_name} ON chat_members") + conn.execute(f"DROP FUNCTION IF EXISTS {function_name}()") + + status, _, chat, _ = client.call( + "POST", + "/api/v1/chats", + {"title": title + "-ok", "member_ids": [actor["id"], victim["id"]]}, + token=token, + ) + assert_status(status, 201, "chat after trigger cleanup") + assert set(chat["member_ids"]) == {actor["id"], victim["id"]} + print("PASS: failed membership insert rolled back the chat; subsequent create is atomic") + + +if __name__ == "__main__": + main() -- 2.54.0 From 762f6cf7af9fd2d0970247f389419a28cb897874 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A7=D0=B8=D0=BD=D1=8F=D0=B5=D0=B2=D0=B0?= Date: Fri, 6 Nov 2026 22:38:35 +0300 Subject: [PATCH 2/4] =?UTF-8?q?=D0=A3=D0=BA=D0=B0=D0=B7=D0=B0=D1=82=D1=8C?= =?UTF-8?q?=20MR=20=D0=B8=20=D0=BA=D0=BE=D0=BC=D0=BC=D0=B8=D1=82=20=D1=80?= =?UTF-8?q?=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=B0=D1=86=D0=B8=D0=B8=20=D0=B2?= =?UTF-8?q?=20=D0=BE=D1=82=D1=87=D1=91=D1=82=D0=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/REPORT.md b/REPORT.md index c92a3b2f..0aa37897 100644 --- a/REPORT.md +++ b/REPORT.md @@ -2,7 +2,9 @@ - Автор, группа: Чиняева, БВТ2301 - Целевая оценка: **4**; трек 5 не заявлен. -- Commit/PR: заполняется после публикации ветки `solution/BVT2301-Chinyaeva` и открытия MR. +- Commit/PR: ветка `solution/BVT2301-Chinyaeva`; MR #1 — + https://gitea.privcloud.tech/aliror/mtusi2026lab2-Chinyaeva/pulls/1. + Основной коммит реализации: `df31f4a`. - Использованные источники, библиотеки и помощь ИИ: официальная документация PostgreSQL (транзакции, EXPLAIN, keyset pagination), Redis (AOF/expiry), RFC 7617 (Basic), Flask, psycopg 3, redis-py, argon2-cffi, gunicorn. ИИ-ассистент использовался для генерации -- 2.54.0 From 23a10e53f06aa3dec883aa0e760aa1deb016fd50 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A7=D0=B8=D0=BD=D1=8F=D0=B5=D0=B2=D0=B0?= Date: Fri, 6 Nov 2026 22:39:10 +0300 Subject: [PATCH 3/4] =?UTF-8?q?=D0=A3=D1=82=D0=BE=D1=87=D0=BD=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20=D1=81=D0=B8=D0=BD=D1=85=D1=80=D0=BE=D0=BD=D0=B8=D0=B7?= =?UTF-8?q?=D0=B0=D1=86=D0=B8=D1=8E=20=D0=BF=D0=B0=D1=80=D0=BE=D0=BB=D1=8F?= =?UTF-8?q?=20=D0=B2=20=D0=BF=D1=80=D0=B8=D0=BC=D0=B5=D1=80=D0=B5=20=D0=BE?= =?UTF-8?q?=D0=BA=D1=80=D1=83=D0=B6=D0=B5=D0=BD=D0=B8=D1=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env.example | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.env.example b/.env.example index 9b31151e..27bcf398 100644 --- a/.env.example +++ b/.env.example @@ -8,7 +8,8 @@ SESSION_TTL_SECONDS=3600 POSTGRES_DB=messenger POSTGRES_USER=messenger -# Replace this local-only value before starting the stand. +# Replace this local-only value before starting the stand; use the SAME value +# inside DATABASE_URL below (kept explicit for readability of the example). POSTGRES_PASSWORD=change-me-local-synthetic-password DATABASE_URL=postgresql://messenger:change-me-local-synthetic-password@postgres:5432/messenger CACHE_URL=redis://redis:6379/0 -- 2.54.0 From 2cb2d21bdde4dbf68bc8bf2b6d5f731a989722b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A7=D0=B8=D0=BD=D1=8F=D0=B5=D0=B2=D0=B0?= Date: Fri, 6 Nov 2026 22:41:19 +0300 Subject: [PATCH 4/4] =?UTF-8?q?=D0=A1=D0=BE=D1=81=D0=BB=D0=B0=D1=82=D1=8C?= =?UTF-8?q?=D1=81=D1=8F=20=D0=BD=D0=B0=20PR=20=D0=B2=20=D0=B8=D1=81=D1=85?= =?UTF-8?q?=D0=BE=D0=B4=D0=BD=D1=8B=D0=B9=20=D1=80=D0=B5=D0=BF=D0=BE=D0=B7?= =?UTF-8?q?=D0=B8=D1=82=D0=BE=D1=80=D0=B8=D0=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/REPORT.md b/REPORT.md index 0aa37897..18197da3 100644 --- a/REPORT.md +++ b/REPORT.md @@ -2,8 +2,8 @@ - Автор, группа: Чиняева, БВТ2301 - Целевая оценка: **4**; трек 5 не заявлен. -- Commit/PR: ветка `solution/BVT2301-Chinyaeva`; MR #1 — - https://gitea.privcloud.tech/aliror/mtusi2026lab2-Chinyaeva/pulls/1. +- Commit/PR: ветка `solution/BVT2301-Chinyaeva` в форке; PR #157 в исходный + репозиторий курса — https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/157. Основной коммит реализации: `df31f4a`. - Использованные источники, библиотеки и помощь ИИ: официальная документация PostgreSQL (транзакции, EXPLAIN, keyset pagination), Redis (AOF/expiry), RFC 7617 (Basic), Flask, -- 2.54.0