Реализовать лабораторную 2: API мессенджера с PostgreSQL и кэшем сессий

FastAPI-сервис с opaque-сессиями (Argon2id, SHA-256 фингерпринт), PostgreSQL как источником истины, Valkey как кэшем сессий, keyset-пагинацией, пулом соединений и таймаутами. Добавлены миграции, compose-стенд, скрипт рестарта, студенческие проверки и evidence.
This commit is contained in:
drunkdiente
2026-10-23 12:17:00 +03:00
parent 65003b6119
commit 0dd3ecfb7c
31 changed files with 1495 additions and 14 deletions
+25
View File
@@ -0,0 +1,25 @@
FROM python:3.12.7-slim
ENV PYTHONUNBUFFERED=1 \
PYTHONDONTWRITEBYTECODE=1 \
PIP_NO_CACHE_DIR=1 \
PYTHONPATH=/app/src
WORKDIR /app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
COPY src ./src
COPY migrations ./migrations
RUN groupadd --system app && useradd --system --gid app --uid 10001 app \
&& chown -R app:app /app
USER app
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=25s --retries=6 \
CMD python -c "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/live', timeout=2).status == 200 else 1)"
CMD ["python", "-m", "app"]
+142 -14
View File
@@ -1,37 +1,165 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Автор, группа: Ким Владимир, БВТ2302
- Целевая оценка; 3
(Redis/Valkey как кэш сессий, параметризованные запросы и пул, индекс истории с EXPLAIN на 10 000
сообщениях, автоматические проверки expiry/logout/гонки/отказа).
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Использованные источники, библиотеки: FastAPI 0.115.6, Uvicorn 0.34.0,
psycopg2-binary 2.9.10, redis 5.2.1, argon2-cffi 23.1.0; PostgreSQL 16.4, Valkey 7.2.6.
Все решения проверены запуском стенда. Первичные материалы: см. README курса.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Prerequisites: Docker Engine/Desktop с Compose v2 и доступом к сети для сборки образа.
Версии зафиксированы: Python 3.12.7-slim (образ `python:3.12.7-slim`), `postgres:16.4`,
`valkey/valkey:7.2.6`. Никаких хостовых БД/Redis не требуется.
```sh
# 1. Локальные синтетические секреты (файл в .gitignore, в Git не попадает)
cp .env.example .env
# заполните как минимум POSTGRES_USER/POSTGRES_PASSWORD/POSTGRES_DB,
# APP_HOST/APP_PORT/APP_ENV/SESSION_TTL_SECONDS/SESSION_STORE, DB_POOL_MIN/DB_POOL_MAX
# 2. Проверка конфигурации и сборка
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
# 3. Дождаться готовности (миграции применяются автоматически при старте API)
until curl -fsS http://localhost:8080/health/ready; do sleep 1; done
# 4. Проверки
python scripts/check_contract.py # = make check
python tests/smoke.py --base-url http://localhost:8080 # = make test
python tests/resilience.py --mode persistence --action-script scripts/restart.sh \
--base-url http://localhost:8080 # = make test-persistence
python tests/load.py --duration 30 --concurrency 4 --output evidence/load.json
# 5. Безопасная остановка (volumes сохраняются)
docker compose --env-file .env stop
# 6. Намеренное удаление только учебных данных
docker compose --env-file .env down -v
```
На Windows хук `scripts/restart.sh` (POSIX) запускается через `scripts/restart.cmd`
(та же команда `docker compose restart`); проверка сохранности при этом эквивалентна.
`make` в среде разработки отсутствовал, поэтому в отчёте приведены эквивалентные python-команды.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
Клиент --HTTP--> API (FastAPI/Uvicorn, python:3.12.7-slim, non-root)
| psycopg2 pool (bounded, statement_timeout)
v
PostgreSQL 16.4 <-- источник истины: users, chats, chat_members,
(named volume pgdata) messages, sessions, schema_migrations
^
| cache-aside (TTL = остаток жизни сессии)
Valkey 7.2.6 (named volume valkeydata, AOF) <-- кэш сессий
```
- **Источник истины** — PostgreSQL. Пользователи, чаты, членство, сообщения и **сессии**
хранятся в БД, поэтому данные и действующие сессии переживают рестарт API и хранилищ.
- **Сессии**: opaque-токен (`secrets.token_urlsafe(32)`, ≥256 бит). В БД пишется только
SHA-256-фингерпринт токена (сам токен не хранится). Срок жизни задаёт `SESSION_TTL_SECONDS`
(по умолчанию 3600). Отзыв — `revoked_at` + удаление ключа из кэша.
- **Пароли**: Argon2id (`argon2-cffi`). Пароль никогда не возвращается в `User`.
- **Valkey/Redis — кэш, а не источник истины.** При каждом аутентифицированном запросе сначала
проверяется кэш (`sess:<sha256>`); промах или недоступность кэша → запрос к PostgreSQL.
TTL кэша равен остатку жизни сессии, инвалидация — при logout/отзыве. Так как истина в БД,
потеря кэша не приводит к потере данных, а анонимный запрос не принимается доверенным.
- **Транзакционные границы**: регистрация пользователя и создание сессии — одиночные INSERT;
создание чата — одна транзакция (проверка существования участников + INSERT чата +
INSERT участников); отправка сообщения — проверка членства и INSERT в одной транзакции.
Гонка регистрации одинакового username разрешается уникальным ограничением `users.username`,
нарушение перехватывается и превращается в `409 conflict`.
- **Ограничения и валидация**: длина и формат полей проверяются приложением (код-поинты) и
дублируются CHECK-ограничениями БД; лишние поля и неверные типы → `400`; `additionalProperties:false`
соблюдается для всех ответов.
- **Пагинация истории** — keyset по `(created_at, id)` по возрастанию, курсор непрозрачный и
привязан к ресурсу (`chat_id`/`user_id`); выборка `LIMIT n+1` определяет `next_cursor` без
полного сканирования истории.
### Соответствие `.env.example` реальной конфигурации
| `.env.example` | Реальная переменная | Смысл |
| --- | --- | --- |
| `APP_HOST` / `APP_PORT` | то же | bind-адрес/порт Uvicorn |
| `APP_ENV` | то же | метка окружения (лог) |
| `SESSION_TTL_SECONDS` | то же | TTL сессии, по умолчанию 3600 |
| `SESSION_STORE` | то же | `postgres` или `postgres+redis` |
| `DATABASE_URL_FILE` | `DATABASE_URL` **или** `DATABASE_URL_FILE` | DSN PostgreSQL (поддержаны оба способа) |
| `CACHE_URL_FILE` | `CACHE_URL` **или** `CACHE_URL_FILE` | DSN Valkey/Redis (кэш) |
| — | `DB_POOL_MIN` / `DB_POOL_MAX` | границы пула соединений |
Приложение читает значение напрямую из переменной, а при её отсутствии — из файла,
указанного в `*_FILE` (совместимо с Docker secrets). Секретов в Git нет: `.env` в `.gitignore`.
### Роли инфраструктуры
| Роль | service | Образ (пиннинг) | healthcheck | volume | сеть | credentials |
| --- | --- | --- | --- | --- | --- | --- |
| api | `api` | сборка из `Dockerfile` (python:3.12.7-slim) | `HEALTHCHECK` + `/health/live` | — | `backend` | env из `.env` |
| postgres | `postgres` | `postgres:16.4` | `pg_isready` | `pgdata` | `backend` | `POSTGRES_*` из `.env` |
| cache | `valkey` | `valkey/valkey:7.2.6` | `valkey-cli ping` | `valkeydata` (AOF) | `backend` | `CACHE_URL` из `.env` |
Bootstrap: миграции `migrations/*.sql` применяются самим API при старте (таблица
`schema_migrations`, advisory lock). Повторный запуск не дублирует данные.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Структура skeleton | `python scripts/check_contract.py` | `PASS: offline skeleton structure...` | `evidence/check.txt` |
| Публичный smoke | `python tests/smoke.py --base-url http://localhost:8080` | `PASS: lab2 public API scenario` | `evidence/smoke.txt` |
| Данные и сессия переживают рестарт | `python tests/resilience.py --mode persistence --action-script scripts/restart.sh ...` | `PASS: persistence preserved confirmed data and existing session`; StartedAt всех контейнеров изменился, volumes сохранены | `evidence/persistence.txt` |
| PostgreSQL = источник истины, ключи, уникальность, миграции с нуля | миграция `migrations/0001_init.sql` + лог старта API | `applied migration 0001_init`; таблицы/индексы создаются на пустом volume | `evidence/persistence.txt` |
| Атомарное создание чата | код `store.create_chat` + одна транзакция | rollback при неизвестном участнике; гонка username → `409` | `student-tests/test_lab2.py` |
| Basic только на `POST /auth/sessions`, остальное — Bearer, expiry и отзыв | `student-tests/test_lab2.py` | wrong password `401` (Basic), `X-User-Id` не работает, logout `204`→`401` (Bearer) | `evidence/cache_outage.txt` |
| Истечение сессии при коротком TTL | `--expiry` c `SESSION_TTL_SECONDS=2` | `PASS: session expired after 2s TTL` | `evidence/expiry_check.txt` |
| Параметризованные запросы, пул, таймауты (уровень 4) | код `db.py`/`store.py` | пул `ThreadedConnectionPool`, `statement_timeout`, все SQL параметризованы | код |
| Индекс истории обоснован EXPLAIN на ≥10 000 сообщений (уровень 4) | `student-tests/perf_explain.sql` | `Index Scan using messages_chat_created_id_idx`, 5 буферов, 0.028 ms против Seq Scan 361 буфер, 2.550 ms | `evidence/explain.txt`, `evidence/explain_no_index.txt` |
| Отказ Redis/БД (уровень 4) | `--cache-check` и `stop postgres` | аутентификация живёт без кэша; `/health/ready` и аутентифицированные запросы → `503 unavailable` при недоступной БД, `/health/live` → `200` | `evidence/cache_outage.txt`, `evidence/dependency_outage.txt` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Оборудование: один Docker-host (Windows, Docker Desktop 29.4.3, Linux engine), образы без
явных CPU/RAM-лимитов. Прогрев не выделялся; данные синтетические.
Нагрузка (closed-loop POST сообщений, `tests/load.py`, см. `evidence/load.json`):
| Профиль | Длительность | Concurrency | Успешные RPS | Ошибки | p50 | p95 | p99 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 4 воркера | 15 с | 4 | 236.6 | 0 (0.0) | 16.0 ms | 32.0 ms | 47.0 ms |
Ограничения измерения: генератор закрытого контура ограничен клиентом и подвержен coordinated
omission; latency только по успешным запросам; это пропускная способность HTTP-подтверждений, а
не счётчик COMMIT.
План запроса (10 000 сообщений в чате, keyset-страница):
| Вариант | План | Buffers | Execution |
| --- | --- | --- | --- |
| С индексом | `Index Scan using messages_chat_created_id_idx` | shared hit=5 | 0.028 ms |
| Без индекса (indexscan off) | `Seq Scan` + `Sort` | shared hit=361 | 2.550 ms |
Отказы:
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `docker compose restart` (api+postgres+valkey, volumes сохранены) | данные и прежний токен доступны | те же чат/сообщение по прежнему токену | рестарт всех контейнеров; потерь нет |
| Остановка Valkey (кэш) | аутентификация продолжает работать через БД | `/users/me` по прежнему токену → `200` | кэш пересоберётся сам; потерь нет |
| Остановка PostgreSQL | `/health/ready` деградирует | `/health/ready` → `503 unavailable`, аутентифицированный запрос → `503 unavailable`, `/health/live` → `200` | `200` после старта БД; потерь нет |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Учебное упрощение: один Docker-host; эксперимент **не** даёт отказоустойчивости к потере
самого host, а единственная БД и отсутствие LB/реплик не делают стенд HA. Redis выбран как
кэш, а не единственное хранилище сессий, поэтому его потеря безопасна.
- Durability PostgreSQL определяется настройками по умолчанию образа; отдельно проверялось
сохранение при рестарте контейнеров с сохранением volume, а не при потере диска.
- Не реализовано (вне минимума этой лабы): изменение участников/удаление сообщений, rate limiting,
идемпотентность отправки (`Idempotency-Key`) и `X-Instance-Id` — это переходы lab3+.
- Уровень 4 подтверждён частично: кэш сессий, пул/таймауты, индекс и отказы проверены; отдельный
«трек 5» (согласованность кэша или backup/restore) не заявлен и не измерялся.
+6
View File
@@ -0,0 +1,6 @@
services:
api:
environment:
SESSION_TTL_SECONDS: 2
ports:
- "8081:8080"
+57
View File
@@ -0,0 +1,57 @@
name: mtusi-lab2
services:
postgres:
image: postgres:16.4
environment:
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
POSTGRES_DB: ${POSTGRES_DB}
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
interval: 5s
timeout: 3s
retries: 20
networks: [backend]
valkey:
image: valkey/valkey:7.2.6
command: ["valkey-server", "--appendonly", "yes", "--save", "", "--appendfsync", "everysec"]
volumes:
- valkeydata:/data
healthcheck:
test: ["CMD", "valkey-cli", "ping"]
interval: 5s
timeout: 3s
retries: 20
networks: [backend]
api:
build: .
depends_on:
postgres:
condition: service_healthy
valkey:
condition: service_healthy
environment:
APP_HOST: ${APP_HOST}
APP_PORT: ${APP_PORT}
APP_ENV: ${APP_ENV}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS}
SESSION_STORE: ${SESSION_STORE}
DB_POOL_MIN: ${DB_POOL_MIN}
DB_POOL_MAX: ${DB_POOL_MAX}
DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
CACHE_URL: redis://valkey:6379/0
ports:
- "${APP_PORT}:${APP_PORT}"
networks: [backend]
volumes:
pgdata:
valkeydata:
networks:
backend:
+6
View File
@@ -0,0 +1,6 @@
PASS: wrong password -> 401 with Basic challenge
PASS: X-User-Id ignored for authentication
PASS: logout revokes the session
PASS: concurrent registration -> one 201 and seven 409
PASS: authentication survives a cache outage
PASS: student lab2 checks completed
+1
View File
@@ -0,0 +1 @@
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+7
View File
@@ -0,0 +1,7 @@
== postgres stopped ==
{"status":"ok"} [HTTP 200]
{"error":{"code":"unavailable","message":"Хранилище недоступно","request_id":"d4ff2da4d2ca40f59b9a3e9986f8fbe2"}} [HTTP 503]
{"error":{"code":"unavailable","message":"Хранилище недоступно","request_id":"7a513917f13846c89194b62f5c1f5e2f"}} [HTTP 503]
== postgres restarted ==
{"status":"ok"} [HTTP 200]
{"error":{"code":"unauthorized","message":"Требуется аутентификация","request_id":"6ce854c975964caab1cf0c6d65adabc5"}} [HTTP 401]
+6
View File
@@ -0,0 +1,6 @@
PASS: wrong password -> 401 with Basic challenge
PASS: X-User-Id ignored for authentication
PASS: logout revokes the session
PASS: concurrent registration -> one 201 and seven 409
PASS: session expired after 2s TTL
PASS: student lab2 checks completed
+37
View File
@@ -0,0 +1,37 @@
INSERT 0 0
INSERT 0 0
INSERT 0 0
INSERT 0 10000
ANALYZE
=== message count ===
messages
----------
10000
(1 row)
=== EXPLAIN (ANALYZE, BUFFERS): keyset page in the middle of history ===
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..17.91 rows=50 width=70) (actual time=0.006..0.014 rows=50 loops=1)
Buffers: shared hit=5
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.42..1719.51 rows=4913 width=70) (actual time=0.006..0.011 rows=50 loops=1)
Index Cond: ((chat_id = '00000000-0000-4000-8000-0000000000aa'::uuid) AND (ROW(created_at, id) > ROW((now() - '01:23:20'::interval), '00000000-0000-4000-8000-000000000000'::uuid)))
Buffers: shared hit=5
Planning:
Buffers: shared hit=20
Planning Time: 0.056 ms
Execution Time: 0.028 ms
(9 rows)
=== EXPLAIN (ANALYZE, BUFFERS): first page (no cursor) ===
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.41..11.29 rows=50 width=70) (actual time=21.930..21.937 rows=50 loops=1)
Buffers: shared hit=266 read=126 dirtied=126
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.41..2176.76 rows=10000 width=70) (actual time=21.929..21.933 rows=50 loops=1)
Index Cond: (chat_id = '00000000-0000-4000-8000-0000000000aa'::uuid)
Buffers: shared hit=266 read=126 dirtied=126
Planning Time: 0.022 ms
Execution Time: 21.948 ms
(7 rows)
+22
View File
@@ -0,0 +1,22 @@
SET
SET
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=903.23..903.36 rows=50 width=70) (actual time=2.525..2.529 rows=50 loops=1)
Buffers: shared hit=361
-> Sort (cost=903.23..915.49 rows=4903 width=70) (actual time=2.525..2.526 rows=50 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 38kB
Buffers: shared hit=361
-> Seq Scan on messages (cost=0.00..740.36 rows=4903 width=70) (actual time=0.617..2.086 rows=4982 loops=1)
Filter: ((chat_id = '00000000-0000-4000-8000-0000000000aa'::uuid) AND (ROW(created_at, id) > ROW((now() - '01:23:20'::interval), '00000000-0000-4000-8000-000000000000'::uuid)))
Rows Removed by Filter: 12145
Buffers: shared hit=355
Planning:
Buffers: shared hit=106
Planning Time: 0.203 ms
Execution Time: 2.550 ms
(14 rows)
RESET
RESET
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 15.0,
"elapsed_seconds": 15.016,
"concurrency": 4,
"successful_requests": 3553,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 236.614,
"successful_latency_ms": {
"p50": 16.0,
"p95": 32.0,
"p99": 47.0
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+2
View File
@@ -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.
+1
View File
@@ -0,0 +1 @@
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+46
View File
@@ -0,0 +1,46 @@
CREATE TABLE IF NOT EXISTS users (
id uuid PRIMARY KEY,
username text NOT NULL UNIQUE,
display_name text NOT NULL,
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now(),
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_len 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 now(),
CONSTRAINT chats_title_len 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,
added_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX IF NOT EXISTS chat_members_user_idx 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,
created_at timestamptz NOT NULL DEFAULT now(),
CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000)
);
CREATE INDEX IF NOT EXISTS messages_chat_created_id_idx 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,
created_at timestamptz NOT NULL DEFAULT now(),
expires_at timestamptz NOT NULL,
revoked_at timestamptz
);
CREATE INDEX IF NOT EXISTS sessions_user_idx ON sessions (user_id);
+5
View File
@@ -0,0 +1,5 @@
fastapi==0.115.6
uvicorn==0.34.0
psycopg2-binary==2.9.10
redis==5.2.1
argon2-cffi==23.1.0
+8
View File
@@ -0,0 +1,8 @@
@echo off
cd /d "%~dp0.."
if not exist .env (
echo restart.cmd: .env is missing ^(copy .env.example and fill it^) 1>&2
exit /b 1
)
docker compose --env-file .env restart
exit /b %ERRORLEVEL%
+10
View File
@@ -0,0 +1,10 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
if [ ! -f .env ]; then
echo "restart.sh: .env is missing (copy .env.example and fill it)" >&2
exit 1
fi
docker compose --env-file .env restart
View File
+7
View File
@@ -0,0 +1,7 @@
import uvicorn
from .config import settings
from .main import app
if __name__ == "__main__":
uvicorn.run(app, host=settings.host, port=settings.port, log_level="info", access_log=False)
+276
View File
@@ -0,0 +1,276 @@
import json
import logging
import re
import uuid
from datetime import datetime, timedelta, timezone
import psycopg2
from fastapi import APIRouter, Request
from fastapi.responses import JSONResponse, Response
from . import db, store
from .cache import session_cache
from .config import settings
from .errors import ApiError, conflict, invalid, not_found, unauthorized
from .security import (
bearer_token,
hash_password,
new_token,
parse_basic,
token_fingerprint,
verify_password,
)
from .serialization import (
chat_json,
decode_cursor,
encode_cursor,
iso,
message_json,
user_json,
)
logger = logging.getLogger("app.api")
router = APIRouter()
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
DEFAULT_LIMIT = 50
MAX_LIMIT = 100
async def read_json(request, allowed, required):
body = await request.body()
if not body:
raise invalid("Ожидается JSON-тело")
content_type = request.headers.get("content-type", "")
if content_type and "application/json" not in content_type.lower():
raise ApiError(415, "unsupported_media_type", "Ожидается application/json")
try:
data = json.loads(body.decode("utf-8"))
except (ValueError, UnicodeDecodeError):
raise invalid("Некорректный JSON")
if not isinstance(data, dict):
raise invalid("Ожидается JSON-объект")
if set(data) - set(allowed):
raise invalid("Лишние поля запроса")
if set(required) - set(data):
raise invalid("Отсутствуют обязательные поля")
return data
def valid_username(value):
return isinstance(value, str) and USERNAME_RE.match(value) is not None
def valid_required_text(value, max_length):
return isinstance(value, str) and 1 <= len(value) <= max_length and value.strip() != ""
def valid_password(value):
return isinstance(value, str) and 12 <= len(value) <= 128
def parse_uuid(value):
try:
return str(uuid.UUID(value))
except (ValueError, AttributeError, TypeError):
raise invalid("Некорректный UUID")
def parse_limit(raw):
if raw is None:
return DEFAULT_LIMIT
try:
value = int(raw)
except (ValueError, TypeError):
raise invalid("Некорректный limit")
if value < 1 or value > MAX_LIMIT:
raise invalid("Некорректный limit")
return value
def authenticate(request):
token = bearer_token(request.headers.get("authorization"))
if not token:
raise unauthorized()
fingerprint = token_fingerprint(token)
cached = session_cache.get(fingerprint)
if cached and isinstance(cached.get("uid"), str):
return cached["uid"]
with db.cursor() as cur:
row = store.get_valid_session(cur, fingerprint)
if not row:
raise unauthorized()
user_id = str(row["user_id"])
ttl = int((row["expires_at"] - datetime.now(timezone.utc)).total_seconds())
session_cache.set(fingerprint, user_id, ttl)
return user_id
@router.post("/api/v1/users")
async def register_user(request: Request):
data = await read_json(
request,
allowed={"username", "display_name", "password"},
required={"username", "display_name", "password"},
)
username = data.get("username")
display_name = data.get("display_name")
password = data.get("password")
if not valid_username(username):
raise invalid("Некорректный username")
if not valid_required_text(display_name, 100):
raise invalid("Некорректный display_name")
if not valid_password(password):
raise invalid("Некорректный пароль")
user_id = str(uuid.uuid4())
password_hash = hash_password(password)
try:
with db.cursor(commit=True) as cur:
row = store.create_user(cur, user_id, username, display_name, password_hash)
except psycopg2.errors.UniqueViolation:
raise conflict("username уже занят")
return JSONResponse(status_code=201, content=user_json(row))
@router.post("/api/v1/auth/sessions")
async def create_session(request: Request):
credentials = parse_basic(request.headers.get("authorization"))
if credentials is None:
raise unauthorized()
username, password = credentials
with db.cursor() as cur:
user = store.get_user_by_username(cur, username)
if not user or not verify_password(user["password_hash"], password):
raise unauthorized()
token = new_token()
fingerprint = token_fingerprint(token)
expires_at = datetime.now(timezone.utc) + timedelta(seconds=settings.session_ttl)
with db.cursor(commit=True) as cur:
store.create_session(cur, fingerprint, str(user["id"]), expires_at)
session_cache.set(fingerprint, str(user["id"]), settings.session_ttl)
return JSONResponse(
status_code=201,
content={
"token": token,
"token_type": "Bearer",
"expires_at": iso(expires_at),
"user": user_json(user),
},
)
@router.delete("/api/v1/auth/sessions/current")
async def revoke_current(request: Request):
authenticate(request)
fingerprint = token_fingerprint(bearer_token(request.headers.get("authorization")))
with db.cursor(commit=True) as cur:
store.revoke_session(cur, fingerprint)
session_cache.delete(fingerprint)
return Response(status_code=204)
@router.get("/api/v1/users/me")
async def current_user(request: Request):
user_id = authenticate(request)
with db.cursor() as cur:
user = store.get_user_by_id(cur, user_id)
if not user:
raise unauthorized()
return JSONResponse(status_code=200, content=user_json(user))
@router.post("/api/v1/chats")
async def create_chat(request: Request):
user_id = authenticate(request)
data = await read_json(
request, allowed={"title", "member_ids"}, required={"title", "member_ids"}
)
title = data.get("title")
member_ids = data.get("member_ids")
if not valid_required_text(title, 100):
raise invalid("Некорректный title")
if not isinstance(member_ids, list) or not 1 <= len(member_ids) <= 100:
raise invalid("Некорректный member_ids")
normalized = []
for value in member_ids:
if not isinstance(value, str):
raise invalid("member_ids должен содержать UUID")
normalized.append(parse_uuid(value))
if len(set(normalized)) != len(normalized):
raise invalid("Дубликаты участников")
if user_id not in normalized:
raise invalid("Вызывающий должен входить в member_ids")
with db.cursor(commit=True) as cur:
row = store.create_chat(cur, str(uuid.uuid4()), title, normalized)
return JSONResponse(status_code=201, content=chat_json(row, sorted(normalized)))
@router.get("/api/v1/chats")
async def list_chats(request: Request):
user_id = authenticate(request)
limit = parse_limit(request.query_params.get("limit"))
cursor = request.query_params.get("cursor")
after = decode_cursor(cursor, "c", user_id) if cursor else None
with db.cursor() as cur:
rows = store.list_chats(cur, user_id, after, limit + 1)
has_more = len(rows) > limit
rows = rows[:limit]
members = store.chat_members(cur, [str(row["id"]) for row in rows])
items = [chat_json(row, members.get(str(row["id"]), [])) for row in rows]
next_cursor = None
if has_more and rows:
last = rows[-1]
next_cursor = encode_cursor("c", user_id, iso(last["created_at"]), str(last["id"]))
return JSONResponse(status_code=200, content={"items": items, "next_cursor": next_cursor})
@router.get("/api/v1/chats/{chat_id}")
async def get_chat(chat_id: str, request: Request):
user_id = authenticate(request)
cid = parse_uuid(chat_id)
with db.cursor() as cur:
if not store.is_member(cur, cid, user_id):
raise not_found()
row = store.get_chat(cur, cid)
members = store.chat_members(cur, [cid])
if not row:
raise not_found()
return JSONResponse(status_code=200, content=chat_json(row, members.get(cid, [])))
@router.post("/api/v1/chats/{chat_id}/messages")
async def create_message(chat_id: str, request: Request):
user_id = authenticate(request)
cid = parse_uuid(chat_id)
with db.cursor() as cur:
if not store.is_member(cur, cid, user_id):
raise not_found()
data = await read_json(request, allowed={"text"}, required={"text"})
text = data.get("text")
if not valid_required_text(text, 4000):
raise invalid("Некорректный text")
with db.cursor(commit=True) as cur:
row = store.create_message(cur, str(uuid.uuid4()), cid, user_id, text)
return JSONResponse(status_code=201, content=message_json(row))
@router.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(chat_id: str, request: Request):
user_id = authenticate(request)
cid = parse_uuid(chat_id)
limit = parse_limit(request.query_params.get("limit"))
cursor = request.query_params.get("cursor")
after = decode_cursor(cursor, "m", cid) if cursor else None
with db.cursor() as cur:
if not store.is_member(cur, cid, user_id):
raise not_found()
rows = store.list_messages(cur, cid, after, limit + 1)
has_more = len(rows) > limit
rows = rows[:limit]
items = [message_json(row) for row in rows]
next_cursor = None
if has_more and rows:
last = rows[-1]
next_cursor = encode_cursor("m", cid, iso(last["created_at"]), str(last["id"]))
return JSONResponse(status_code=200, content={"items": items, "next_cursor": next_cursor})
+53
View File
@@ -0,0 +1,53 @@
import json
import logging
import redis
from .config import settings
logger = logging.getLogger("app.cache")
PREFIX = "sess:"
class SessionCache:
def __init__(self, url):
self.client = None
if url:
self.client = redis.Redis.from_url(
url, socket_connect_timeout=1, socket_timeout=1, decode_responses=True
)
def get(self, fingerprint):
if self.client is None:
return None
try:
value = self.client.get(PREFIX + fingerprint)
except redis.RedisError as exc:
logger.warning("cache get failed: %s", type(exc).__name__)
return None
if not value:
return None
try:
return json.loads(value)
except ValueError:
return None
def set(self, fingerprint, user_id, ttl_seconds):
if self.client is None or ttl_seconds <= 0:
return
try:
self.client.setex(PREFIX + fingerprint, ttl_seconds, json.dumps({"uid": user_id}))
except redis.RedisError as exc:
logger.warning("cache set failed: %s", type(exc).__name__)
def delete(self, fingerprint):
if self.client is None:
return
try:
self.client.delete(PREFIX + fingerprint)
except redis.RedisError as exc:
logger.warning("cache delete failed: %s", type(exc).__name__)
session_cache = SessionCache(settings.cache_url)
+34
View File
@@ -0,0 +1,34 @@
import os
from pathlib import Path
def _secret(value_name, file_name):
value = os.environ.get(value_name)
if value:
return value.strip()
path = os.environ.get(file_name)
if path:
candidate = Path(path)
if candidate.is_file():
return candidate.read_text(encoding="utf-8").strip()
return None
class Settings:
def __init__(self):
self.host = os.environ.get("APP_HOST", "0.0.0.0")
self.port = int(os.environ.get("APP_PORT", "8080"))
self.app_env = os.environ.get("APP_ENV", "lab")
self.session_ttl = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
self.session_store = os.environ.get("SESSION_STORE", "postgres")
self.database_url = _secret("DATABASE_URL", "DATABASE_URL_FILE")
self.cache_url = _secret("CACHE_URL", "CACHE_URL_FILE")
self.pool_min = int(os.environ.get("DB_POOL_MIN", "1"))
self.pool_max = int(os.environ.get("DB_POOL_MAX", "10"))
self.db_statement_timeout_ms = int(os.environ.get("DB_STATEMENT_TIMEOUT_MS", "5000"))
self.db_connect_timeout_s = int(os.environ.get("DB_CONNECT_TIMEOUT_SECONDS", "5"))
default_migrations = Path(__file__).resolve().parents[2] / "migrations"
self.migrations_dir = os.environ.get("MIGRATIONS_DIR", str(default_migrations))
settings = Settings()
+107
View File
@@ -0,0 +1,107 @@
import logging
from contextlib import contextmanager
from pathlib import Path
import psycopg2
import psycopg2.extras
from psycopg2 import pool as pg_pool
from .config import settings
from .errors import unavailable
logger = logging.getLogger("app.db")
MIGRATION_LOCK = 727001
_pool = None
def init_pool():
global _pool
if not settings.database_url:
raise RuntimeError("DATABASE_URL / DATABASE_URL_FILE is not configured")
_pool = pg_pool.ThreadedConnectionPool(
settings.pool_min,
settings.pool_max,
settings.database_url,
options="-c statement_timeout={} -c application_name=messenger-api".format(
settings.db_statement_timeout_ms
),
connect_timeout=settings.db_connect_timeout_s,
)
logger.info("database pool ready (min=%d max=%d)", settings.pool_min, settings.pool_max)
def close_pool():
global _pool
if _pool is not None:
_pool.closeall()
_pool = None
@contextmanager
def cursor(commit=False):
if _pool is None:
raise unavailable("Хранилище недоступно")
try:
conn = _pool.getconn()
except psycopg2.Error as exc:
logger.warning("database connection unavailable: %s", type(exc).__name__)
raise unavailable("Хранилище недоступно") from None
discard = False
try:
cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
try:
yield cur
if commit:
conn.commit()
else:
conn.rollback()
finally:
cur.close()
except (psycopg2.OperationalError, psycopg2.InterfaceError) as exc:
discard = True
logger.warning("database connection lost: %s", type(exc).__name__)
raise unavailable("Хранилище недоступно") from None
except Exception:
try:
conn.rollback()
except Exception:
pass
raise
finally:
_pool.putconn(conn, close=discard)
def ping():
with cursor() as cur:
cur.execute("SELECT 1")
cur.fetchone()
def run_migrations():
directory = Path(settings.migrations_dir)
files = sorted(directory.glob("*.sql"))
conn = _pool.getconn()
try:
with conn.cursor() as cur:
cur.execute("SELECT pg_advisory_lock(%s)", (MIGRATION_LOCK,))
cur.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
"version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())"
)
cur.execute("SELECT version FROM schema_migrations")
applied = {row[0] for row in cur.fetchall()}
for path in files:
version = path.stem
if version in applied:
continue
cur.execute(path.read_text(encoding="utf-8"))
cur.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (version,))
logger.info("applied migration %s", version)
cur.execute("SELECT pg_advisory_unlock(%s)", (MIGRATION_LOCK,))
conn.commit()
except Exception:
conn.rollback()
raise
finally:
_pool.putconn(conn)
+26
View File
@@ -0,0 +1,26 @@
class ApiError(Exception):
def __init__(self, status, code, message):
super().__init__(message)
self.status = status
self.code = code
self.message = message
def invalid(message="Некорректный запрос"):
return ApiError(400, "invalid_request", message)
def unauthorized(message="Требуется аутентификация"):
return ApiError(401, "unauthorized", message)
def not_found(message="Объект не найден или недоступен"):
return ApiError(404, "not_found", message)
def conflict(message="Конфликт состояния"):
return ApiError(409, "conflict", message)
def unavailable(message="Сервис временно недоступен"):
return ApiError(503, "unavailable", message)
+115
View File
@@ -0,0 +1,115 @@
import logging
import uuid
from contextlib import asynccontextmanager
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from starlette.exceptions import HTTPException as StarletteHTTPException
from . import db
from .api import router
from .config import settings
from .errors import ApiError
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
logger = logging.getLogger("app")
INSTANCE_ID = uuid.uuid4().hex[:12]
@asynccontextmanager
async def lifespan(_app):
db.init_pool()
db.run_migrations()
logger.info(
"instance %s ready (env=%s, ttl=%ss, session_store=%s)",
INSTANCE_ID,
settings.app_env,
settings.session_ttl,
settings.session_store,
)
yield
db.close_pool()
app = FastAPI(
title="MTUSI Messenger — lab 2",
version="1.2.0",
lifespan=lifespan,
docs_url=None,
redoc_url=None,
openapi_url=None,
)
def error_payload(request, code, message):
request_id = getattr(request.state, "request_id", None) or uuid.uuid4().hex
return {"error": {"code": code, "message": message, "request_id": request_id}}
def challenge_for(request):
if request.url.path == "/api/v1/auth/sessions":
return 'Basic realm="messenger", charset="UTF-8"'
return 'Bearer realm="messenger"'
@app.middleware("http")
async def request_context(request: Request, call_next):
request_id = request.headers.get("x-request-id") or uuid.uuid4().hex
request.state.request_id = request_id
try:
response = await call_next(request)
except ApiError as exc:
response = JSONResponse(status_code=exc.status, content=error_payload(request, exc.code, exc.message))
if exc.status == 401:
response.headers["WWW-Authenticate"] = challenge_for(request)
except Exception:
logger.exception("unhandled error")
response = JSONResponse(
status_code=500, content=error_payload(request, "internal_error", "Внутренняя ошибка")
)
response.headers["X-Request-Id"] = request_id
response.headers["X-Instance-Id"] = INSTANCE_ID
return response
@app.exception_handler(ApiError)
async def handle_api_error(request: Request, exc: ApiError):
response = JSONResponse(status_code=exc.status, content=error_payload(request, exc.code, exc.message))
if exc.status == 401:
response.headers["WWW-Authenticate"] = challenge_for(request)
return response
@app.exception_handler(StarletteHTTPException)
async def handle_http_error(request: Request, exc: StarletteHTTPException):
mapping = {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
405: "invalid_request",
415: "unsupported_media_type",
}
code = mapping.get(exc.status_code, "invalid_request")
response = JSONResponse(status_code=exc.status_code, content=error_payload(request, code, "Ошибка запроса"))
if exc.status_code == 401:
response.headers["WWW-Authenticate"] = challenge_for(request)
return response
@app.get("/health/live")
async def health_live():
return JSONResponse(status_code=200, content={"status": "ok"})
@app.get("/health/ready")
async def health_ready():
try:
db.ping()
except Exception as exc:
logger.warning("readiness check failed: %s", type(exc).__name__)
raise ApiError(503, "unavailable", "Хранилище недоступно")
return JSONResponse(status_code=200, content={"status": "ok"})
app.include_router(router)
+59
View File
@@ -0,0 +1,59 @@
import base64
import hashlib
import secrets
from argon2 import PasswordHasher
from argon2.exceptions import Argon2Error
_hasher = PasswordHasher()
def hash_password(password):
return _hasher.hash(password)
def verify_password(password_hash, password):
try:
return _hasher.verify(password_hash, password)
except Argon2Error:
return False
except Exception:
return False
def new_token():
return secrets.token_urlsafe(32)
def token_fingerprint(token):
return hashlib.sha256(token.encode("utf-8")).hexdigest()
def parse_basic(header):
if not header:
return None
parts = header.split(" ", 1)
if len(parts) != 2 or parts[0].lower() != "basic":
return None
try:
raw = base64.b64decode(parts[1].strip(), validate=True)
except Exception:
return None
try:
decoded = raw.decode("utf-8")
except UnicodeDecodeError:
return None
if ":" not in decoded:
return None
username, password = decoded.split(":", 1)
return username, password
def bearer_token(header):
if not header:
return None
parts = header.split(" ", 1)
if len(parts) != 2 or parts[0].lower() != "bearer":
return None
token = parts[1].strip()
return token or None
+66
View File
@@ -0,0 +1,66 @@
import base64
import json
import uuid
from datetime import datetime, timezone
from .errors import invalid
def iso(value):
if value.tzinfo is None:
value = value.replace(tzinfo=timezone.utc)
return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
def user_json(row):
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": iso(row["created_at"]),
}
def chat_json(row, member_ids):
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": member_ids,
"created_at": iso(row["created_at"]),
}
def message_json(row):
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": iso(row["created_at"]),
}
def encode_cursor(kind, scope, created_at, item_id):
payload = {"k": kind, "s": scope, "t": created_at, "i": item_id}
raw = json.dumps(payload, separators=(",", ":")).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
def decode_cursor(value, kind, scope):
try:
padded = value + "=" * (-len(value) % 4)
data = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")).decode("utf-8"))
except Exception:
raise invalid("Некорректный cursor")
if not isinstance(data, dict) or data.get("k") != kind or data.get("s") != scope:
raise invalid("Некорректный cursor")
created_at = data.get("t")
item_id = data.get("i")
if not isinstance(created_at, str) or not isinstance(item_id, str):
raise invalid("Некорректный cursor")
try:
uuid.UUID(item_id)
datetime.fromisoformat(created_at.replace("Z", "+00:00"))
except (ValueError, AttributeError):
raise invalid("Некорректный cursor")
return created_at, item_id
+135
View File
@@ -0,0 +1,135 @@
from .errors import invalid
def create_user(cur, user_id, username, display_name, password_hash):
cur.execute(
"INSERT INTO users (id, username, display_name, password_hash) "
"VALUES (%s, %s, %s, %s) RETURNING id, username, display_name, created_at",
(user_id, username, display_name, password_hash),
)
return cur.fetchone()
def get_user_by_username(cur, username):
cur.execute(
"SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = %s",
(username,),
)
return cur.fetchone()
def get_user_by_id(cur, user_id):
cur.execute(
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
(user_id,),
)
return cur.fetchone()
def create_session(cur, fingerprint, user_id, expires_at):
cur.execute(
"INSERT INTO sessions (token_hash, user_id, expires_at) VALUES (%s, %s, %s)",
(fingerprint, user_id, expires_at),
)
def get_valid_session(cur, fingerprint):
cur.execute(
"SELECT user_id, expires_at FROM sessions "
"WHERE token_hash = %s AND revoked_at IS NULL AND expires_at > now()",
(fingerprint,),
)
return cur.fetchone()
def revoke_session(cur, fingerprint):
cur.execute(
"UPDATE sessions SET revoked_at = now() WHERE token_hash = %s AND revoked_at IS NULL",
(fingerprint,),
)
return cur.rowcount
def is_member(cur, chat_id, user_id):
cur.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat_id, user_id),
)
return cur.fetchone() is not None
def create_chat(cur, chat_id, title, member_ids):
cur.execute(
"SELECT id FROM users WHERE id = ANY(%s::uuid[])",
(list(member_ids),),
)
found = {str(row["id"]) for row in cur.fetchall()}
if found != set(member_ids):
raise invalid("Неизвестные участники чата")
cur.execute(
"INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING id, title, created_at",
(chat_id, title),
)
row = cur.fetchone()
cur.executemany(
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
[(chat_id, member) for member in member_ids],
)
return row
def get_chat(cur, chat_id):
cur.execute("SELECT id, title, created_at FROM chats WHERE id = %s", (chat_id,))
return cur.fetchone()
def chat_members(cur, chat_ids):
if not chat_ids:
return {}
cur.execute(
"SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY(%s::uuid[]) "
"ORDER BY chat_id, user_id",
(list(chat_ids),),
)
result = {}
for row in cur.fetchall():
result.setdefault(str(row["chat_id"]), []).append(str(row["user_id"]))
return result
def list_chats(cur, user_id, after, limit):
sql = (
"SELECT c.id, c.title, c.created_at FROM chats c "
"JOIN chat_members m ON m.chat_id = c.id WHERE m.user_id = %s"
)
params = [user_id]
if after is not None:
sql += " AND (c.created_at, c.id) > (%s::timestamptz, %s::uuid)"
params.extend([after[0], after[1]])
sql += " ORDER BY c.created_at ASC, c.id ASC LIMIT %s"
params.append(limit)
cur.execute(sql, params)
return cur.fetchall()
def create_message(cur, message_id, chat_id, sender_id, text):
cur.execute(
"INSERT INTO messages (id, chat_id, sender_id, text) VALUES (%s, %s, %s, %s) "
"RETURNING id, chat_id, sender_id, text, created_at",
(message_id, chat_id, sender_id, text),
)
return cur.fetchone()
def list_messages(cur, chat_id, after, limit):
sql = (
"SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s"
)
params = [chat_id]
if after is not None:
sql += " AND (created_at, id) > (%s::timestamptz, %s::uuid)"
params.extend([after[0], after[1]])
sql += " ORDER BY created_at ASC, id ASC LIMIT %s"
params.append(limit)
cur.execute(sql, params)
return cur.fetchall()
+32
View File
@@ -0,0 +1,32 @@
# Студенческие проверки (lab 2)
Дополняют публичный `tests/smoke.py`, не ослабляя его. Только стандартная библиотека.
```sh
# негативные и конкурентные проверки на работающем стенде
python student-tests/test_lab2.py --base-url http://localhost:8080
# проверка истечения сессии при коротком TTL (см. compose.expiry.yaml)
docker compose -f compose.yaml -f compose.expiry.yaml up -d --no-deps api
python student-tests/test_lab2.py --base-url http://localhost:8081 --expiry
docker compose up -d --no-deps api # вернуть обычный TTL
# обход кэша при недоступности Valkey (останавливает/запускает valkey)
python student-tests/test_lab2.py --base-url http://localhost:8080 --cache-check
```
Что проверяется:
- неверный пароль → одинаковый `401` и `WWW-Authenticate: Basic`;
- `X-User-Id` сам по себе не аутентифицирует и не подменяет владельца Bearer-сессии;
- logout отзывает токен (`204`, затем `401` с `WWW-Authenticate: Bearer`);
- гонка регистрации одного username: ровно один `201`, остальные `409`;
- истечение сессии по короткому `SESSION_TTL_SECONDS` (`--expiry`);
- недоступность Valkey не ломает аутентификацию, источник истины — PostgreSQL (`--cache-check`).
`perf_explain.sql` наполняет один чат 10 000 синтетических сообщений и печатает
`EXPLAIN (ANALYZE, BUFFERS)` для keyset-пагинации:
```sh
Get-Content -Raw student-tests/perf_explain.sql | docker compose exec -T postgres psql -U messenger -d messenger
```
+44
View File
@@ -0,0 +1,44 @@
INSERT INTO users (id, username, display_name, password_hash)
VALUES ('00000000-0000-4000-8000-000000000001', 'perf_user_1', 'Perf One', 'synthetic'),
('00000000-0000-4000-8000-000000000002', 'perf_user_2', 'Perf Two', 'synthetic')
ON CONFLICT (id) DO NOTHING;
INSERT INTO chats (id, title)
VALUES ('00000000-0000-4000-8000-0000000000aa', 'Perf chat')
ON CONFLICT (id) DO NOTHING;
INSERT INTO chat_members (chat_id, user_id)
VALUES ('00000000-0000-4000-8000-0000000000aa', '00000000-0000-4000-8000-000000000001')
ON CONFLICT DO NOTHING;
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(),
'00000000-0000-4000-8000-0000000000aa',
'00000000-0000-4000-8000-000000000001',
'perf message ' || g,
now() - (g || ' seconds')::interval
FROM generate_series(1, 10000) AS g;
ANALYZE messages;
\echo === message count ===
SELECT count(*) AS messages FROM messages
WHERE chat_id = '00000000-0000-4000-8000-0000000000aa';
\echo === EXPLAIN (ANALYZE, BUFFERS): keyset page in the middle of history ===
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '00000000-0000-4000-8000-0000000000aa'
AND (created_at, id) > (now() - interval '5000 seconds',
'00000000-0000-4000-8000-000000000000'::uuid)
ORDER BY created_at ASC, id ASC
LIMIT 50;
\echo === EXPLAIN (ANALYZE, BUFFERS): first page (no cursor) ===
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '00000000-0000-4000-8000-0000000000aa'
ORDER BY created_at ASC, id ASC
LIMIT 50;
+143
View File
@@ -0,0 +1,143 @@
#!/usr/bin/env python3
import argparse
import base64
import json
import subprocess
import threading
import time
import urllib.error
import urllib.request
import uuid
class Failure(AssertionError):
pass
def check(condition, message):
if not condition:
raise Failure(message)
def call(base, method, path, body=None, token=None, basic=None, headers=None):
h = {"Accept": "application/json"}
if token:
h["Authorization"] = "Bearer " + token
if basic:
h["Authorization"] = "Basic " + base64.b64encode(basic.encode("utf-8")).decode("ascii")
data = None
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
h["Content-Type"] = "application/json"
h.update(headers or {})
request = urllib.request.Request(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()
return response.code, response.headers, raw
def register(base, username, password):
return call(base, "POST", "/api/v1/users", body={
"username": username, "display_name": "Студент " + username, "password": password})
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--expiry", action="store_true", help="expect a short SESSION_TTL_SECONDS")
parser.add_argument("--cache-check", action="store_true", help="stop Valkey via docker compose")
parser.add_argument("--compose-dir", default=".")
args = parser.parse_args()
base = args.base_url.rstrip("/")
tag = uuid.uuid4().hex[:10]
password = "T3st-" + uuid.uuid4().hex
status, _, raw = register(base, "u_neg_" + tag, password)
check(status == 201, "registration failed: %d" % status)
user = json.loads(raw)
status, headers, _ = call(base, "POST", "/api/v1/auth/sessions",
basic="u_neg_%s:%s" % (tag, "wrong-password-123"))
check(status == 401, "wrong password must be 401, got %d" % status)
check(headers.get("WWW-Authenticate", "").lower().startswith("basic"), "missing Basic challenge")
print("PASS: wrong password -> 401 with Basic challenge")
status, _, raw = call(base, "POST", "/api/v1/auth/sessions",
basic="u_neg_%s:%s" % (tag, password))
check(status == 201, "login failed: %d" % status)
token = json.loads(raw)["token"]
status, _, _ = call(base, "GET", "/api/v1/users/me", headers={"X-User-Id": user["id"]})
check(status == 401, "X-User-Id must not authenticate, got %d" % status)
other = json.loads(register(base, "u_neg2_" + tag, password)[2])
status, _, raw = call(base, "GET", "/api/v1/users/me", token=token, headers={"X-User-Id": other["id"]})
check(status == 200 and json.loads(raw)["id"] == user["id"], "X-User-Id overrode bearer identity")
print("PASS: X-User-Id ignored for authentication")
status, _, raw = call(base, "DELETE", "/api/v1/auth/sessions/current", token=token)
check(status == 204 and not raw, "logout must be 204 without body, got %d" % status)
status, headers, _ = call(base, "GET", "/api/v1/users/me", token=token)
check(status == 401, "revoked token must be 401, got %d" % status)
check(headers.get("WWW-Authenticate", "").lower().startswith("bearer"), "missing Bearer challenge")
print("PASS: logout revokes the session")
race_username = "u_race_" + tag
results = []
lock = threading.Lock()
barrier = threading.Barrier(8)
def attempt():
barrier.wait()
code, _, _ = register(base, race_username, password)
with lock:
results.append(code)
threads = [threading.Thread(target=attempt) for _ in range(8)]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
check(results.count(201) == 1, "exactly one registration must succeed: %s" % sorted(results))
check(results.count(409) == 7, "losers must get 409: %s" % sorted(results))
print("PASS: concurrent registration -> one 201 and seven 409")
if args.expiry:
status, _, raw = call(base, "POST", "/api/v1/auth/sessions",
basic="u_neg_%s:%s" % (tag, password))
check(status == 201, "login failed: %d" % status)
short = json.loads(raw)
expires = short["expires_at"]
from datetime import datetime, timezone
ttl = (datetime.fromisoformat(expires.replace("Z", "+00:00")) - datetime.now(timezone.utc)).total_seconds()
check(ttl < 60, "run this with a short SESSION_TTL_SECONDS (ttl=%.1fs)" % ttl)
time.sleep(max(0.0, ttl) + 1.5)
status, _, _ = call(base, "GET", "/api/v1/users/me", token=short["token"])
check(status == 401, "expired session must be 401, got %d" % status)
print("PASS: session expired after %.0fs TTL" % ttl)
if args.cache_check:
status, _, raw = call(base, "POST", "/api/v1/auth/sessions",
basic="u_neg_%s:%s" % (tag, password))
token = json.loads(raw)["token"]
subprocess.run(["docker", "compose", "stop", "valkey"], cwd=args.compose_dir, check=True,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
try:
status, _, _ = call(base, "GET", "/api/v1/users/me", token=token)
check(status == 200, "auth must keep working without the cache, got %d" % status)
print("PASS: authentication survives a cache outage")
finally:
subprocess.run(["docker", "compose", "start", "valkey"], cwd=args.compose_dir, check=True,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
print("PASS: student lab2 checks completed")
if __name__ == "__main__":
try:
main()
except Failure as error:
print("FAIL:", error)
raise SystemExit(1)