ЛР 2 - БВТ2303 - Болотов - на 4 #130

Closed
Bernilai wants to merge 1 commits from Bernilai/mtusi2026lab2:solution/bvt2303-bolotov into master
34 changed files with 2252 additions and 41 deletions
+34 -4
View File
@@ -1,20 +1,50 @@
# VCS / CI
.git
.github
# Secrets and local env
.env
.env.*
!.env.example
secrets
certs
volumes
data
backups
*.key
*.pem
*.p12
*.pfx
*.jks
# Local / runtime junk
.venv
venv
__pycache__
*.py[cod]
*.egg-info
.pytest_cache
.mypy_cache
.ruff_cache
node_modules
evidence
.DS_Store
Thumbs.db
# Lab artifacts not needed at runtime
evidence
volumes
data
backups
docs
student-tests
tests
scripts
examples
contracts
REPORT.md
README.md
COURSE.md
CONTRIBUTING.md
MAINTAINERS.md
Dockerfile.example
requirements-dev.txt
*.md
# Keep only what the image needs: requirements.txt + src/
+2 -4
View File
@@ -1,11 +1,9 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
# Secrets are mounted as Docker Compose files under ./secrets/ (not committed).
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
SESSION_STORE=redis
CACHE_URL_FILE=/run/secrets/cache_url
+14 -14
View File
@@ -1,18 +1,18 @@
## Лабораторная 2
Автор / группа: TODO
Целевая оценка (3/4/5): TODO
Трек 5, если заявлен: TODO
Автор / группа: Болотов Илья / БВТ2303
Целевая оценка (3/4/5): 4
Трек 5, если заявлен: —
Что реализовано и что перенесено: TODO
Команды запуска из чистого clone: TODO
Результаты проверок и ссылка на REPORT.md: TODO
Ограничения / известные ошибки: TODO
Источники и использование ИИ: TODO
Что реализовано и что перенесено: минимум lab1 (FastAPI messenger) перенесён из `mtusi2026lab1-fork` ветки `solution/bvt2303-bolotov`; PostgreSQL + миграции, Argon2id, Basic→Bearer (Redis AOF), Compose, `scripts/restart.sh`, student-tests, evidence.
Команды запуска из чистого clone: см. `REPORT.md` (secrets + `docker compose up -d --build`, затем smoke / persistence).
Результаты проверок и ссылка на REPORT.md: `REPORT.md`; `evidence/check.txt`, `smoke.txt`, `persistence.txt`, `student-tests.txt` (в т.ч. deps + expiry TTL=2), `explain.txt` (Index Scan, 10 000).
Ограничения / известные ошибки: целевая оценка 4 (без трека 5); сессии теряются при удалении volume Redis; один Docker-host; Postgres на `127.0.0.1:5432` только для локального IDE.
Источники и использование ИИ: FastAPI, psycopg, redis-py, argon2-cffi; ИИ при переносе и реализации lab2.
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
- [ ] make check и make test выполнены; приложен реальный вывод.
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
- [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [x] Контракт и публичные тесты не ослаблены.
- [x] make check и make test выполнены; приложен реальный вывод.
- [x] Сценарии отказов/безопасности своего уровня воспроизведены.
- [x] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
+30
View File
@@ -0,0 +1,30 @@
# Pinned base image (lab2). Update digest when bumping Python.
FROM python:3.12.8-slim-bookworm AS runtime
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
APP_HOST=0.0.0.0 \
APP_PORT=8080 \
PYTHONPATH=/app/src \
MIGRATIONS_DIR=/app/migrations
WORKDIR /app
RUN groupadd --system --gid 10001 app \
&& useradd --system --uid 10001 --gid app --home /app --shell /usr/sbin/nologin app
COPY --chown=app:app requirements.txt .
RUN pip install --no-cache-dir --upgrade pip==24.3.1 \
&& pip install --no-cache-dir --retries 10 --timeout 60 -r requirements.txt
COPY --chown=app:app src ./src
COPY --chown=app:app migrations ./migrations
USER app
EXPOSE 8080
HEALTHCHECK --interval=5s --timeout=3s --start-period=15s --retries=5 \
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"
CMD ["python", "-m", "messenger"]
+5 -2
View File
@@ -4,10 +4,10 @@ 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 student-test
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes; student-test: own suite"
check:
$(PYTHON) scripts/check_contract.py
@@ -24,3 +24,6 @@ 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)
student-test:
$(PYTHON) student-tests/run_all.py
+71 -17
View File
@@ -1,37 +1,91 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Болотов Илья, БВТ2303
- Целевая оценка; выбранный трек 5, если нужен: **4** (трек 5 не выбран)
- Ветка: `solution/bvt2303-bolotov`
- Использованные источники, библиотеки и помощь ИИ: FastAPI, Uvicorn, psycopg3 (+pool), redis-py, argon2-cffi; перенос и адаптация lab1 с помощью ИИ; публичные материалы курса (README, contracts).
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
**Prerequisites:** Docker Desktop (Engine), Docker Compose v2+. Локальный Python на хосте не обязателен для стенда (smoke можно запускать из контейнера `python:3.12-slim`).
```sh
cp .env.example .env
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
# Дождаться healthy у api (или GET /health/ready → 200)
```
Проверки (с хоста, если есть Python 3.9+):
```sh
python -m pip install -r requirements-dev.txt # только для make validate
make check
make test BASE_URL=http://127.0.0.1:8080
# persistence (Linux/macOS; на Windows — Git Bash / WSL, chmod +x):
chmod +x scripts/restart.sh
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8080
```
Без локального Python — smoke из контейнера:
```sh
docker run --rm --network host -v "$PWD:/work" -w /work python:3.12.8-slim-bookworm \
python tests/smoke.py --base-url http://127.0.0.1:8080
```
На Windows Docker Desktop вместо `--network host` используйте `host.docker.internal`:
```powershell
docker run --rm -v "${PWD}:/work" -w /work python:3.12.8-slim-bookworm `
python tests/smoke.py --base-url http://host.docker.internal:8080
```
Остановка без удаления данных: `docker compose --env-file .env down`
Удаление учебных volumes: `docker compose --env-file .env down -v` (осознанно).
Версии образов: `python:3.12.8-slim-bookworm`, `postgres:16.6-bookworm`, `redis:7.4.2-bookworm`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
Клиент → API (FastAPI/Uvicorn) → PostgreSQL (источник истины: users/chats/members/messages)
↘ Redis (opaque sessions + TTL, AOF everysec)
```
- **Перенесено из lab1** (`mtusi2026lab1-fork`, ветка `solution/bvt2303-bolotov`): структура `src/messenger`, стиль ошибок/cursor, non-root Dockerfile, student-tests каркас.
- **Изменено в lab2:** in-memory store → PostgreSQL; `X-User-Id` → Bearer; регистрация с password (Argon2id); `POST /auth/sessions` (Basic); logout; Compose + volumes; миграции `migrations/001_init.sql`.
- **Сессии:** единственное хранилище — Redis (`sess:<token>`), TTL = `SESSION_TTL_SECONDS` (по умолчанию 3600). Persistence — AOF (`appendonly yes`, `appendfsync everysec`), чтобы действующие сессии переживали `compose restart`. Источник истины для домена — PostgreSQL; Redis — сессии.
- **Транзакции:** создание чата + members в одной транзакции; при неизвестном member — rollback. Уникальность `username` — UNIQUE + 409 на гонке.
- **Пул:** psycopg_pool max 10, `connect_timeout=5`, `statement_timeout=5000`.
- **Индекс истории:** `idx_messages_chat_created_id ON messages (chat_id, created_at, id)` — keyset `(created_at, id)`.
- **Конфиг:** URL хранилищ через Docker secrets files; `SESSION_TTL_SECONDS` из `.env`. Postgres на стенде доступен с хоста на `127.0.0.1:5432` (loopback) для локального IDE.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Offline check | `python scripts/check_contract.py` | PASS skeleton | `evidence/check.txt` |
| Публичный smoke | `python tests/smoke.py --base-url http://127.0.0.1:8080` | PASS lab2 | `evidence/smoke.txt` |
| Persistence restart | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd` (Windows) / `scripts/restart.sh` (Unix) | PASS: session + messages after restart | `evidence/persistence.txt` |
| Собственные тесты | `RUN_DEPS_TEST=1 python student-tests/run_all.py` + expiry при `SESSION_TTL_SECONDS=2` | 18 OK в основном прогоне (auth, race, deps); expiry PASS при TTL=2 | `evidence/student-tests.txt` |
| EXPLAIN индекса (≥10 000) | `evidence/seed_explain.sql` через `psql` | Index Scan using `idx_messages_chat_created_id`, SEEDED 10 000 | `evidence/explain.txt` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `scripts/restart.sh` (restart postgres+redis+api, volumes сохранены) | прежний token и сообщения живы | persistence-тест PASS | ≤90 с на hook + ready |
| logout | 401 на том же token | PASS в smoke | — |
| неверный пароль пользователя API | 401 + WWW-Authenticate Basic | PASS student-tests | — |
| недоступность Redis/Postgres | `/health/ready` → 503; бизнес-запросы не принимают анонима | PASS: `RUN_DEPS_TEST=1` (`test_deps.*`) | — |
| короткий TTL (`SESSION_TTL_SECONDS=2`) | 401 после истечения | PASS: `test_session_expiry_if_short_ttl` при TTL=2 | см. низ `evidence/student-tests.txt` |
## Ограничения и следующие шаги
Ограничения измерения: smoke/persistence и student-tests — функциональные проверки, не нагрузочный бенчмарк.
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
## Ограничения
- Трек 5 (cache stampede / 100k + backup) не выполнялся — целевая оценка 4.
- Один Docker-host не даёт HA при потере хоста.
- Redis — единственное хранилище сессий: без AOF сессии терялись бы при restart; с AOF стенд выдерживает проверяемый restart.
- На машине без Python 3.x smoke запускается через образ `python:3.12.8-slim-bookworm`.
+99
View File
@@ -0,0 +1,99 @@
# Runnable lab2 stack: API + PostgreSQL + Redis (sessions, AOF).
services:
postgres:
image: postgres:16.6-bookworm
environment:
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
POSTGRES_DB: messenger
secrets:
- postgres_password
ports:
# Local-only for IDE clients (PyCharm Database tool); not for remote exposure.
- "127.0.0.1:5432:5432"
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 10
start_period: 10s
networks:
- labnet
redis:
image: redis:7.4.2-bookworm
command:
- redis-server
- --appendonly
- "yes"
- --appendfsync
- everysec
- --dir
- /data
volumes:
- redisdata:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
start_period: 5s
networks:
- labnet
api:
build:
context: .
dockerfile: Dockerfile
image: mtusi-messenger:lab2
ports:
- "127.0.0.1:8080:8080"
environment:
APP_HOST: "0.0.0.0"
APP_PORT: "8080"
APP_ENV: lab
SESSION_TTL_SECONDS: "${SESSION_TTL_SECONDS:-3600}"
SESSION_STORE: redis
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
MIGRATIONS_DIR: /app/migrations
secrets:
- database_url
- cache_url
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
healthcheck:
test:
[
"CMD",
"python",
"-c",
"import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)",
]
interval: 5s
timeout: 3s
retries: 12
start_period: 20s
networks:
- labnet
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
volumes:
pgdata:
redisdata:
networks:
labnet:
driver: bridge
+1
View File
@@ -0,0 +1 @@
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+10
View File
@@ -0,0 +1,10 @@
-- Seed ≥10k messages then EXPLAIN the keyset history query.
-- Run: docker compose exec -T postgres psql -U messenger -d messenger -f - < evidence/explain.sql
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = (SELECT id FROM chats LIMIT 1)
AND (created_at, id) > ('1970-01-01'::timestamptz, '00000000-0000-0000-0000-000000000000'::uuid)
ORDER BY created_at ASC, id ASC
LIMIT 50;
Binary file not shown.
+9
View File
@@ -0,0 +1,9 @@
Docker Desktop / Engine (compose lab2 stack)
Images: python:3.12.8-slim-bookworm, postgres:16.6-bookworm, redis:7.4.2-bookworm
API image: mtusi-messenger:lab2
Target grade: 4
Branch: solution/bvt2303-bolotov
Tests: check PASS, smoke PASS, persistence PASS
Student-tests: RUN_DEPS_TEST=1 (18 OK) + expiry at SESSION_TTL_SECONDS=2 PASS
EXPLAIN: Index Scan on idx_messages_chat_created_id, SEEDED 10000 (evidence/explain.txt)
Postgres for IDE: 127.0.0.1:5432 (compose.yaml, loopback only)
+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.
+45
View File
@@ -0,0 +1,45 @@
CREATE EXTENSION IF NOT EXISTS pgcrypto;
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES (
'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
'explain_seed_user',
'Explain',
'$argon2id$v=19$m=65536,t=3,p=4$YWFhYWFhYWFhYWFhYWFhYQ$YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWE',
now()
)
ON CONFLICT (username) DO NOTHING;
INSERT INTO chats (id, title, created_at)
VALUES ('bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb', 'explain-chat', now())
ON CONFLICT (id) DO NOTHING;
INSERT INTO chat_members (chat_id, user_id)
VALUES ('bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb', 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa')
ON CONFLICT DO NOTHING;
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(),
'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
'msg-' || g,
timestamptz '2026-01-01 00:00:00Z' + (g * interval '1 millisecond')
FROM generate_series(1::integer, 12000::integer) AS g
WHERE NOT EXISTS (
SELECT 1 FROM messages WHERE chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb' LIMIT 1
);
SELECT count(*) AS message_count
FROM messages
WHERE chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb'
AND (created_at, id) > (
'1970-01-01'::timestamptz,
'00000000-0000-0000-0000-000000000000'::uuid
)
ORDER BY created_at ASC, id ASC
LIMIT 50;
+1
View File
@@ -0,0 +1 @@
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
Binary file not shown.
+48
View File
@@ -0,0 +1,48 @@
-- Lab2 schema: users, chats, membership, messages.
-- Applied once via schema_migrations; safe to re-run application bootstrap.
CREATE TABLE IF NOT EXISTS schema_migrations (
version TEXT PRIMARY KEY,
applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
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,
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_username_unique UNIQUE (username)
);
CREATE TABLE IF NOT EXISTS chats (
id UUID PRIMARY KEY,
title TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
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),
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX IF NOT EXISTS idx_chat_members_user
ON chat_members (user_id, chat_id);
CREATE TABLE IF NOT EXISTS messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id),
text TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
-- Keyset pagination by (created_at, id) within a chat; avoids full history scan.
CREATE INDEX IF NOT EXISTS idx_messages_chat_created_id
ON messages (chat_id, created_at ASC, id ASC);
-- List chats for a user ordered by chat created_at/id.
CREATE INDEX IF NOT EXISTS idx_chats_created_id
ON chats (created_at ASC, id ASC);
+6
View File
@@ -0,0 +1,6 @@
fastapi==0.115.6
uvicorn[standard]==0.32.1
pydantic==2.10.3
psycopg[binary,pool]==3.2.4
redis==5.2.1
argon2-cffi==23.1.0
+16
View File
@@ -0,0 +1,16 @@
@echo off
setlocal
cd /d "%~dp0\.."
docker compose --env-file .env restart postgres redis api
if errorlevel 1 exit /b 1
set /a i=0
:wait
docker compose --env-file .env exec -T api python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)" >nul 2>&1
if not errorlevel 1 exit /b 0
set /a i+=1
if %i% geq 60 (
echo restart: API not ready within 60s >&2
exit /b 1
)
timeout /t 1 /nobreak >nul
goto wait
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
set -eu
# Restart API and all state stores while preserving volumes.
# Readiness is waited by tests/resilience.py separately (do not block here forever).
cd "$(dirname "$0")/.."
docker compose --env-file .env restart postgres redis api
exit 0
+74
View File
@@ -0,0 +1,74 @@
#!/usr/bin/env python3
"""Seed >=10k messages and print EXPLAIN (ANALYZE, BUFFERS) for keyset page."""
from __future__ import annotations
import uuid
from datetime import datetime, timezone
import psycopg
from psycopg.rows import dict_row
def utc_now():
return datetime.now(timezone.utc).replace(microsecond=0)
def main() -> None:
url = open("/run/secrets/database_url", encoding="utf-8").read().strip()
with psycopg.connect(url, row_factory=dict_row) as conn:
with conn.transaction():
u1, u2 = uuid.uuid4(), uuid.uuid4()
now = utc_now()
conn.execute(
"""
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES (%s, %s, %s, %s, %s)
""",
(u1, f"explain_a_{u1.hex[:8]}", "A", "x", now),
)
conn.execute(
"""
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES (%s, %s, %s, %s, %s)
""",
(u2, f"explain_b_{u2.hex[:8]}", "B", "x", now),
)
chat = uuid.uuid4()
conn.execute(
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)",
(chat, "explain", now),
)
conn.execute(
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s), (%s, %s)",
(chat, u1, chat, u2),
)
rows = [(uuid.uuid4(), chat, u1, f"m{i}", now) for i in range(10000)]
with conn.cursor() as cur:
cur.executemany(
"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES (%s, %s, %s, %s, %s)
""",
rows,
)
mid = rows[5000][0]
plan = 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 ASC, id ASC
LIMIT 51
""",
(chat, now, mid),
).fetchall()
for row in plan:
print(next(iter(row.values())))
print("CHAT_ID", chat)
print("SEEDED", 10000)
if __name__ == "__main__":
main()
+3
View File
@@ -0,0 +1,3 @@
"""Messenger API for lab2 (PostgreSQL + Redis sessions)."""
__version__ = "2.0.0"
+30
View File
@@ -0,0 +1,30 @@
"""Run the messenger HTTP server."""
from __future__ import annotations
import sys
from pathlib import Path
_SRC = Path(__file__).resolve().parents[1]
if str(_SRC) not in sys.path:
sys.path.insert(0, str(_SRC))
import uvicorn
from messenger import config
def main() -> None:
uvicorn.run(
"messenger.app:app",
host=config.app_host(),
port=config.app_port(),
log_level="info",
access_log=False,
timeout_keep_alive=5,
timeout_graceful_shutdown=8,
)
if __name__ == "__main__":
main()
+632
View File
@@ -0,0 +1,632 @@
"""HTTP API: PostgreSQL messenger with Basic→Bearer sessions (lab2)."""
from __future__ import annotations
import asyncio
import base64
import json
import logging
import re
import signal
import uuid
from contextlib import asynccontextmanager
from datetime import datetime, timezone
from typing import Any, List, Optional, Tuple
from fastapi import FastAPI, Header, Query, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse, Response
from starlette.exceptions import HTTPException as StarletteHTTPException
from messenger import db, sessions
from messenger.sessions import SessionStoreError
from messenger.store import Store, StoreUnavailable, format_ts
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}\Z")
UUID_RE = re.compile(
r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\Z"
)
BODY_READ_TIMEOUT_S = 5.0
PASSWORD_MIN = 12
PASSWORD_MAX = 128
store = Store()
ready = False
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s %(levelname)s %(message)s",
)
log = logging.getLogger("messenger")
def mark_not_ready(*_args):
global ready
if ready:
ready = False
log.info("readiness disabled; draining in-flight requests")
def _chain_signal(previous):
def handler(signum, frame):
mark_not_ready()
if callable(previous) and previous not in (signal.SIG_DFL, signal.SIG_IGN):
previous(signum, frame)
return handler
@asynccontextmanager
async def lifespan(_app: FastAPI):
try:
signal.signal(signal.SIGTERM, _chain_signal(signal.getsignal(signal.SIGTERM)))
signal.signal(signal.SIGINT, _chain_signal(signal.getsignal(signal.SIGINT)))
except (ValueError, OSError) as exc:
log.warning("signal handlers not installed: %s", exc)
global ready
db.init_pool()
db.apply_migrations()
sessions.init_client()
ready = True
log.info("messenger started")
yield
mark_not_ready()
sessions.close_client()
db.close_pool()
log.info("messenger stopped")
def request_id_from(request: Request) -> str:
incoming = request.headers.get("x-request-id")
if incoming and incoming.strip():
return incoming.strip()[:128]
return str(uuid.uuid4())
def error_body(code: str, message: str, request_id: str) -> dict:
return {"error": {"code": code, "message": message, "request_id": request_id}}
def error_response(
status: int,
code: str,
message: str,
request_id: str,
www_authenticate: Optional[str] = None,
) -> JSONResponse:
headers = {"X-Request-Id": request_id}
if www_authenticate:
headers["WWW-Authenticate"] = www_authenticate
return JSONResponse(
status_code=status,
content=error_body(code, message, request_id),
headers=headers,
)
def is_blank(value: str) -> bool:
return value.strip() == ""
def has_nul(value: str) -> bool:
# PostgreSQL text cannot store U+0000; reject explicitly (400), never 500/503.
return "\x00" in value
def has_lone_surrogate(value: str) -> bool:
return any(0xD800 <= ord(ch) <= 0xDFFF for ch in value)
def codepoint_len(value: str) -> int:
return len(value)
def parse_uuid(value: str) -> Optional[str]:
if not isinstance(value, str) or not UUID_RE.match(value):
return None
try:
return str(uuid.UUID(value))
except ValueError:
return None
def encode_cursor(resource: str, created_at: datetime, item_id: str) -> str:
raw = f"{resource}|{created_at.strftime('%Y-%m-%dT%H:%M:%SZ')}|{item_id}"
return base64.urlsafe_b64encode(raw.encode("utf-8")).decode("ascii")
def decode_cursor(cursor: str, expected_resource: str) -> Tuple[datetime, uuid.UUID]:
try:
raw = base64.urlsafe_b64decode(cursor.encode("ascii")).decode("utf-8")
resource, ts, item_id = raw.split("|", 2)
if resource != expected_resource:
raise ValueError("wrong resource")
created_at = datetime.strptime(ts, "%Y-%m-%dT%H:%M:%SZ").replace(
tzinfo=timezone.utc
)
return created_at, uuid.UUID(item_id)
except Exception as exc:
raise ValueError("invalid cursor") from exc
app = FastAPI(
title="MTUSI Messenger lab2",
docs_url=None,
redoc_url=None,
lifespan=lifespan,
)
@app.middleware("http")
async def add_request_id_and_gate(request: Request, call_next):
rid = request_id_from(request)
request.state.request_id = rid
path = request.url.path
if not ready and path not in ("/health/live",):
if path == "/health/ready":
return error_response(503, "unavailable", "Shutting down", rid)
return error_response(503, "unavailable", "Service unavailable", rid)
response = await call_next(request)
if "X-Request-Id" not in response.headers:
response.headers["X-Request-Id"] = rid
log.info(
"%s %s -> %s request_id=%s",
request.method,
path,
response.status_code,
rid,
)
return response
class ApiError(Exception):
def __init__(
self,
status: int,
code: str,
message: str,
www_authenticate: Optional[str] = None,
):
self.status = status
self.code = code
self.message = message
self.www_authenticate = www_authenticate
@app.exception_handler(ApiError)
async def api_error_handler(request: Request, exc: ApiError):
rid = getattr(request.state, "request_id", None) or request_id_from(request)
return error_response(
exc.status, exc.code, exc.message, rid, www_authenticate=exc.www_authenticate
)
@app.exception_handler(RequestValidationError)
async def validation_handler(request: Request, exc: RequestValidationError):
rid = getattr(request.state, "request_id", None) or request_id_from(request)
return error_response(400, "invalid_request", "Invalid request", rid)
@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
rid = getattr(request.state, "request_id", None) or request_id_from(request)
if exc.status_code == 404:
return error_response(404, "not_found", "Not found", rid)
if exc.status_code == 405:
return error_response(400, "invalid_request", "Method not allowed", rid)
return error_response(exc.status_code, "invalid_request", "Request failed", rid)
@app.exception_handler(StoreUnavailable)
async def store_unavailable_handler(request: Request, exc: StoreUnavailable):
rid = getattr(request.state, "request_id", None) or request_id_from(request)
return error_response(503, "unavailable", "Database unavailable", rid)
@app.exception_handler(SessionStoreError)
async def session_store_unavailable_handler(request: Request, exc: SessionStoreError):
rid = getattr(request.state, "request_id", None) or request_id_from(request)
return error_response(503, "unavailable", "Session store unavailable", rid)
@app.exception_handler(Exception)
async def unhandled_handler(request: Request, exc: Exception):
rid = getattr(request.state, "request_id", None) or request_id_from(request)
log.exception("unhandled error request_id=%s", rid)
return error_response(500, "internal_error", "Internal error", rid)
async def read_json_object(request: Request) -> Any:
content_type = request.headers.get("content-type", "")
media = content_type.split(";")[0].strip().lower()
if media and media != "application/json":
raise ApiError(415, "unsupported_media_type", "Unsupported media type")
try:
body = await asyncio.wait_for(request.body(), timeout=BODY_READ_TIMEOUT_S)
except asyncio.TimeoutError:
raise ApiError(400, "invalid_request", "Request body timeout")
if not body:
raise ApiError(400, "invalid_request", "Empty body")
try:
data = json.loads(body.decode("utf-8"))
except (UnicodeDecodeError, json.JSONDecodeError):
raise ApiError(400, "invalid_request", "Malformed JSON")
if not isinstance(data, dict):
raise ApiError(400, "invalid_request", "JSON object required")
return data
def require_bearer(authorization: Optional[str]) -> Tuple[str, str]:
"""Return (user_id, token). X-User-Id is ignored."""
bearer_challenge = 'Bearer realm="messenger"'
if not authorization or not authorization.strip():
raise ApiError(
401, "unauthorized", "Missing bearer token", www_authenticate=bearer_challenge
)
parts = authorization.strip().split(None, 1)
if len(parts) != 2 or parts[0].lower() != "bearer" or not parts[1].strip():
# Basic on business endpoints must not work.
raise ApiError(
401, "unauthorized", "Invalid authorization", www_authenticate=bearer_challenge
)
token = parts[1].strip()
try:
session = sessions.get_session(token)
except SessionStoreError:
raise ApiError(503, "unavailable", "Session store unavailable")
if session is None:
raise ApiError(
401, "unauthorized", "Invalid or expired session", www_authenticate=bearer_challenge
)
user_id = session["user_id"]
user = store.get_user(user_id)
if user is None:
raise ApiError(
401, "unauthorized", "Invalid or expired session", www_authenticate=bearer_challenge
)
return user_id, token
def require_chat_member(chat_id_raw: str, user_id: str):
chat_id = parse_uuid(chat_id_raw)
if chat_id is None:
raise ApiError(400, "invalid_request", "Invalid chat_id")
chat = store.get_chat(chat_id)
if chat is None or user_id not in chat.member_ids:
raise ApiError(404, "not_found", "Chat not found")
return chat
def parse_limit(limit: Optional[int]) -> int:
if limit is None:
return 50
if not isinstance(limit, int) or isinstance(limit, bool) or limit < 1 or limit > 100:
raise ApiError(400, "invalid_request", "Invalid limit")
return limit
def validate_display_text(value: Any, field: str, max_len: int) -> str:
if not isinstance(value, str) or is_blank(value) or has_nul(value):
raise ApiError(400, "invalid_request", f"Invalid {field}")
if has_lone_surrogate(value):
raise ApiError(400, "invalid_request", f"Invalid {field}")
length = codepoint_len(value)
if length < 1 or length > max_len:
raise ApiError(400, "invalid_request", f"Invalid {field}")
return value
def validate_password(value: Any) -> str:
# Required strings must not be whitespace-only (contracts/README).
if not isinstance(value, str) or is_blank(value) or has_nul(value):
raise ApiError(400, "invalid_request", "Invalid password")
if has_lone_surrogate(value):
raise ApiError(400, "invalid_request", "Invalid password")
length = codepoint_len(value)
if length < PASSWORD_MIN or length > PASSWORD_MAX:
raise ApiError(400, "invalid_request", "Invalid password")
return value
def parse_basic_credentials(authorization: Optional[str]) -> Tuple[str, str]:
challenge = 'Basic realm="messenger", charset="UTF-8"'
if not authorization or not authorization.strip():
raise ApiError(
401, "unauthorized", "Invalid credentials", www_authenticate=challenge
)
parts = authorization.strip().split(None, 1)
if len(parts) != 2 or parts[0].lower() != "basic":
raise ApiError(
401, "unauthorized", "Invalid credentials", www_authenticate=challenge
)
try:
decoded = base64.b64decode(parts[1].strip(), validate=True).decode("utf-8")
except Exception:
raise ApiError(
401, "unauthorized", "Invalid credentials", www_authenticate=challenge
)
if ":" not in decoded:
raise ApiError(
401, "unauthorized", "Invalid credentials", www_authenticate=challenge
)
username, password = decoded.split(":", 1)
# Username ASCII-only per contract; password may contain ':'.
if not username or any(ord(ch) > 127 for ch in username):
raise ApiError(
401, "unauthorized", "Invalid credentials", www_authenticate=challenge
)
return username, password
@app.get("/health/live")
async def liveness(request: Request):
rid = request.state.request_id
return JSONResponse(content={"status": "ok"}, headers={"X-Request-Id": rid})
@app.get("/health/ready")
async def readiness(request: Request):
rid = request.state.request_id
if not ready:
return error_response(503, "unavailable", "Not ready", rid)
if not db.ping() or not sessions.ping():
return error_response(503, "unavailable", "Dependency unavailable", rid)
return JSONResponse(content={"status": "ok"}, headers={"X-Request-Id": rid})
@app.post("/api/v1/users")
async def register_user(request: Request):
rid = request.state.request_id
data = await read_json_object(request)
allowed = {"username", "display_name", "password"}
if set(data.keys()) - allowed:
raise ApiError(400, "invalid_request", "Unexpected fields")
if "username" not in data or "display_name" not in data or "password" not in data:
raise ApiError(400, "invalid_request", "Missing required fields")
username = data["username"]
display_name = data["display_name"]
if (
not isinstance(username, str)
or is_blank(username)
or has_lone_surrogate(username)
or not USERNAME_RE.match(username)
):
raise ApiError(400, "invalid_request", "Invalid username")
display_name = validate_display_text(display_name, "display_name", 100)
password = validate_password(data["password"])
try:
user = store.create_user(username, display_name, password)
except KeyError:
raise ApiError(409, "conflict", "Username already taken")
return JSONResponse(
status_code=201,
content=user.to_dict(),
headers={"X-Request-Id": rid},
)
@app.post("/api/v1/auth/sessions")
async def create_session(request: Request):
rid = request.state.request_id
challenge = 'Basic realm="messenger", charset="UTF-8"'
# Contract: Basic only, no JSON body (even with valid credentials).
try:
raw_body = await asyncio.wait_for(request.body(), timeout=BODY_READ_TIMEOUT_S)
except asyncio.TimeoutError:
raise ApiError(400, "invalid_request", "Request body timeout")
if raw_body and raw_body.strip():
raise ApiError(400, "invalid_request", "Login must not include a body")
username, password = parse_basic_credentials(
request.headers.get("authorization")
)
# Uniform 401 for wrong user / wrong password (no user enumeration).
user = store.get_user_by_username(username)
if user is None or not store.verify_password(user.password_hash, password):
raise ApiError(
401, "unauthorized", "Invalid credentials", www_authenticate=challenge
)
try:
session = sessions.create_session(user.id)
except SessionStoreError:
raise ApiError(503, "unavailable", "Session store unavailable")
body = {
"token": session["token"],
"token_type": "Bearer",
"expires_at": session["expires_at"],
"user": user.to_dict(),
}
return JSONResponse(
status_code=201, content=body, headers={"X-Request-Id": rid}
)
@app.delete("/api/v1/auth/sessions/current")
async def logout(
request: Request,
authorization: Optional[str] = Header(default=None, alias="Authorization"),
):
rid = request.state.request_id
_user_id, token = require_bearer(authorization)
try:
sessions.revoke_session(token)
except SessionStoreError:
raise ApiError(503, "unavailable", "Session store unavailable")
return Response(status_code=204, headers={"X-Request-Id": rid})
@app.get("/api/v1/users/me")
async def current_user(
request: Request,
authorization: Optional[str] = Header(default=None, alias="Authorization"),
):
rid = request.state.request_id
user_id, _token = require_bearer(authorization)
user = store.get_user(user_id)
assert user is not None
return JSONResponse(content=user.to_dict(), headers={"X-Request-Id": rid})
@app.post("/api/v1/chats")
async def create_chat(
request: Request,
authorization: Optional[str] = Header(default=None, alias="Authorization"),
):
rid = request.state.request_id
user_id, _token = require_bearer(authorization)
data = await read_json_object(request)
allowed = {"title", "member_ids"}
if set(data.keys()) - allowed:
raise ApiError(400, "invalid_request", "Unexpected fields")
if "title" not in data or "member_ids" not in data:
raise ApiError(400, "invalid_request", "Missing required fields")
title = validate_display_text(data["title"], "title", 100)
member_ids = data["member_ids"]
if not isinstance(member_ids, list) or not member_ids or len(member_ids) > 100:
raise ApiError(400, "invalid_request", "Invalid member_ids")
parsed: List[str] = []
seen = set()
for mid in member_ids:
if not isinstance(mid, str):
raise ApiError(400, "invalid_request", "Invalid member_ids")
uid = parse_uuid(mid)
if uid is None:
raise ApiError(400, "invalid_request", "Invalid member_ids")
if uid in seen:
raise ApiError(400, "invalid_request", "Duplicate member_ids")
seen.add(uid)
parsed.append(uid)
if user_id not in seen:
raise ApiError(400, "invalid_request", "Caller must be a member")
try:
chat = store.create_chat(title, parsed)
except KeyError:
raise ApiError(400, "invalid_request", "Unknown member")
return JSONResponse(
status_code=201,
content=chat.to_dict(),
headers={"X-Request-Id": rid},
)
@app.get("/api/v1/chats")
async def list_chats(
request: Request,
authorization: Optional[str] = Header(default=None, alias="Authorization"),
limit: Optional[int] = Query(default=None),
cursor: Optional[str] = Query(default=None),
):
rid = request.state.request_id
user_id, _token = require_bearer(authorization)
lim = parse_limit(limit)
resource = f"chats:{user_id}"
cursor_key = None
if cursor is not None:
if not cursor:
raise ApiError(400, "invalid_request", "Invalid cursor")
try:
cursor_ts, cursor_id = decode_cursor(cursor, resource)
except ValueError:
raise ApiError(400, "invalid_request", "Invalid cursor")
if not store.chat_exists_for_user(user_id, cursor_ts, cursor_id):
raise ApiError(400, "invalid_request", "Invalid cursor")
cursor_key = (cursor_ts, cursor_id)
chats, more = store.list_chats_for_user(user_id, lim, cursor_key)
next_cursor = None
if more and chats:
last = chats[-1]
next_cursor = encode_cursor(resource, last.created_at, last.id)
return JSONResponse(
content={"items": [c.to_dict() for c in chats], "next_cursor": next_cursor},
headers={"X-Request-Id": rid},
)
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(
chat_id: str,
request: Request,
authorization: Optional[str] = Header(default=None, alias="Authorization"),
):
rid = request.state.request_id
user_id, _token = require_bearer(authorization)
chat = require_chat_member(chat_id, user_id)
return JSONResponse(content=chat.to_dict(), headers={"X-Request-Id": rid})
@app.post("/api/v1/chats/{chat_id}/messages")
async def create_message(
chat_id: str,
request: Request,
authorization: Optional[str] = Header(default=None, alias="Authorization"),
):
rid = request.state.request_id
user_id, _token = require_bearer(authorization)
chat = require_chat_member(chat_id, user_id)
data = await read_json_object(request)
allowed = {"text"}
if set(data.keys()) - allowed:
raise ApiError(400, "invalid_request", "Unexpected fields")
if "text" not in data:
raise ApiError(400, "invalid_request", "Missing text")
text = data["text"]
if (
not isinstance(text, str)
or is_blank(text)
or has_nul(text)
or has_lone_surrogate(text)
or codepoint_len(text) > 4000
):
raise ApiError(400, "invalid_request", "Invalid text")
try:
message = store.create_message(chat.id, user_id, text)
except ValueError:
raise ApiError(400, "invalid_request", "Invalid text")
return JSONResponse(
status_code=201,
content=message.to_dict(),
headers={"X-Request-Id": rid},
)
@app.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(
chat_id: str,
request: Request,
authorization: Optional[str] = Header(default=None, alias="Authorization"),
limit: Optional[int] = Query(default=None),
cursor: Optional[str] = Query(default=None),
):
rid = request.state.request_id
user_id, _token = require_bearer(authorization)
chat = require_chat_member(chat_id, user_id)
lim = parse_limit(limit)
resource = f"messages:{chat.id}"
cursor_key = None
if cursor is not None:
if not cursor:
raise ApiError(400, "invalid_request", "Invalid cursor")
try:
cursor_ts, cursor_id = decode_cursor(cursor, resource)
except ValueError:
raise ApiError(400, "invalid_request", "Invalid cursor")
if not store.message_exists(chat.id, cursor_ts, cursor_id):
raise ApiError(400, "invalid_request", "Invalid cursor")
cursor_key = (cursor_ts, cursor_id)
messages, has_more = store.list_messages(chat.id, lim, cursor_key)
next_cursor = None
if has_more and messages:
last = messages[-1]
next_cursor = encode_cursor(resource, last.created_at, last.id)
return JSONResponse(
content={
"items": [m.to_dict() for m in messages],
"next_cursor": next_cursor,
},
headers={"X-Request-Id": rid},
)
def create_app() -> FastAPI:
return app
+64
View File
@@ -0,0 +1,64 @@
"""Runtime configuration from environment / secret files."""
from __future__ import annotations
import os
from pathlib import Path
def _read_secret(env_key: str, file_key: str, default: str | None = None) -> str:
file_path = os.environ.get(file_key, "").strip()
if file_path:
path = Path(file_path)
if path.is_file():
return path.read_text(encoding="utf-8").strip()
value = os.environ.get(env_key, "").strip()
if value:
return value
if default is not None:
return default
raise RuntimeError(f"Missing secret: set {env_key} or {file_key}")
def database_url() -> str:
return _read_secret("DATABASE_URL", "DATABASE_URL_FILE")
def cache_url() -> str:
return _read_secret("CACHE_URL", "CACHE_URL_FILE")
def session_ttl_seconds() -> int:
raw = os.environ.get("SESSION_TTL_SECONDS", "3600").strip()
try:
value = int(raw)
except ValueError as exc:
raise RuntimeError("SESSION_TTL_SECONDS must be an integer") from exc
if value < 1:
raise RuntimeError("SESSION_TTL_SECONDS must be >= 1")
return value
def app_host() -> str:
return os.environ.get("APP_HOST", "0.0.0.0")
def app_port() -> int:
return int(os.environ.get("APP_PORT", "8080"))
def migrations_dir() -> Path:
override = os.environ.get("MIGRATIONS_DIR", "").strip()
if override:
return Path(override)
# /app/migrations in container; repo-root/migrations for local runs.
here = Path(__file__).resolve()
candidates = [
Path("/app/migrations"),
here.parents[2] / "migrations",
Path.cwd() / "migrations",
]
for path in candidates:
if path.is_dir():
return path
return candidates[0]
+107
View File
@@ -0,0 +1,107 @@
"""PostgreSQL connection pool and versioned migrations."""
from __future__ import annotations
import logging
import re
from pathlib import Path
from typing import List, Optional
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
from messenger import config
log = logging.getLogger("messenger.db")
_pool: Optional[ConnectionPool] = None
def get_pool() -> ConnectionPool:
if _pool is None:
raise RuntimeError("Database pool is not initialized")
return _pool
def init_pool() -> ConnectionPool:
global _pool
if _pool is not None:
return _pool
url = config.database_url()
_pool = ConnectionPool(
conninfo=url,
min_size=1,
max_size=10,
kwargs={
"row_factory": dict_row,
"connect_timeout": 5,
"options": "-c statement_timeout=5000",
},
open=True,
timeout=10,
)
return _pool
def close_pool() -> None:
global _pool
if _pool is not None:
_pool.close()
_pool = None
def _split_sql(script: str) -> List[str]:
"""Split SQL file into statements (no procedure bodies in our migrations)."""
# Drop line comments.
cleaned = re.sub(r"--[^\n]*", "", script)
parts = []
for chunk in cleaned.split(";"):
stmt = chunk.strip()
if stmt:
parts.append(stmt)
return parts
def apply_migrations(migrations_path: Optional[Path] = None) -> None:
path = migrations_path or config.migrations_dir()
sql_files = sorted(path.glob("*.sql"))
if not sql_files:
raise RuntimeError(f"No migrations found in {path}")
pool = get_pool()
with pool.connection() as conn:
with conn.transaction():
conn.execute(
"""
CREATE TABLE IF NOT EXISTS schema_migrations (
version TEXT PRIMARY KEY,
applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
)
"""
)
for sql_file in sql_files:
version = sql_file.name
row = conn.execute(
"SELECT 1 AS ok FROM schema_migrations WHERE version = %s",
(version,),
).fetchone()
if row:
log.info("migration already applied: %s", version)
continue
script = sql_file.read_text(encoding="utf-8")
for stmt in _split_sql(script):
conn.execute(stmt)
conn.execute(
"INSERT INTO schema_migrations (version) VALUES (%s)",
(version,),
)
log.info("applied migration: %s", version)
def ping() -> bool:
try:
with get_pool().connection() as conn:
conn.execute("SELECT 1")
return True
except Exception as exc:
log.warning("postgres ping failed: %s", type(exc).__name__)
return False
+136
View File
@@ -0,0 +1,136 @@
"""Opaque Bearer sessions in Redis with TTL (durable via Redis AOF)."""
from __future__ import annotations
import json
import logging
import secrets
from datetime import datetime, timedelta, timezone
from typing import Optional
import redis
from messenger import config
log = logging.getLogger("messenger.sessions")
_client: Optional[redis.Redis] = None
TOKEN_BYTES = 32 # 256-bit entropy
KEY_PREFIX = "sess:"
def utc_now() -> datetime:
return datetime.now(timezone.utc).replace(microsecond=0)
def format_ts(value: datetime) -> str:
if value.tzinfo is None:
value = value.replace(tzinfo=timezone.utc)
return value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
def parse_ts(value: str) -> datetime:
return datetime.strptime(value, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
def init_client() -> redis.Redis:
global _client
if _client is not None:
return _client
url = config.cache_url()
_client = redis.Redis.from_url(
url,
decode_responses=True,
socket_connect_timeout=3,
socket_timeout=3,
health_check_interval=30,
)
return _client
def close_client() -> None:
global _client
if _client is not None:
try:
_client.close()
except Exception:
pass
_client = None
def get_client() -> redis.Redis:
if _client is None:
raise RuntimeError("Redis client is not initialized")
return _client
def ping() -> bool:
try:
return bool(get_client().ping())
except Exception as exc:
log.warning("redis ping failed: %s", type(exc).__name__)
return False
class SessionStoreError(Exception):
"""Raised when Redis is unavailable for session operations."""
def create_session(user_id: str) -> dict:
ttl = config.session_ttl_seconds()
token = secrets.token_urlsafe(TOKEN_BYTES)
now = utc_now()
expires_at = now + timedelta(seconds=ttl)
payload = {
"user_id": user_id,
"expires_at": format_ts(expires_at),
"created_at": format_ts(now),
}
key = KEY_PREFIX + token
try:
client = get_client()
# SET with EX: Redis is sole session store; AOF keeps it across restart.
client.set(key, json.dumps(payload), ex=ttl)
except redis.RedisError as exc:
raise SessionStoreError("session store unavailable") from exc
return {
"token": token,
"token_type": "Bearer",
"expires_at": payload["expires_at"],
"user_id": user_id,
}
def get_session(token: str) -> Optional[dict]:
if not token:
return None
key = KEY_PREFIX + token
try:
raw = get_client().get(key)
except redis.RedisError as exc:
raise SessionStoreError("session store unavailable") from exc
if not raw:
return None
try:
data = json.loads(raw)
expires_at = parse_ts(data["expires_at"])
except (ValueError, KeyError, TypeError, json.JSONDecodeError):
return None
if expires_at <= utc_now():
try:
get_client().delete(key)
except redis.RedisError:
pass
return None
return data
def revoke_session(token: str) -> bool:
if not token:
return False
key = KEY_PREFIX + token
try:
return bool(get_client().delete(key))
except redis.RedisError as exc:
raise SessionStoreError("session store unavailable") from exc
+363
View File
@@ -0,0 +1,363 @@
"""PostgreSQL repository: users, chats, membership, messages."""
from __future__ import annotations
import uuid
from dataclasses import dataclass
from datetime import datetime, timezone
from typing import List, Optional, Tuple
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError
from psycopg import Error as PsycopgError
from psycopg import errors as pg_errors
from messenger.db import get_pool
_ph = PasswordHasher()
class StoreUnavailable(Exception):
"""Raised when PostgreSQL is unreachable or timed out."""
def utc_now() -> datetime:
return datetime.now(timezone.utc).replace(microsecond=0)
def format_ts(value: datetime) -> str:
if value.tzinfo is None:
value = value.replace(tzinfo=timezone.utc)
return value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
@dataclass
class User:
id: str
username: str
display_name: str
created_at: datetime
password_hash: str = ""
def to_dict(self) -> dict:
return {
"id": self.id,
"username": self.username,
"display_name": self.display_name,
"created_at": format_ts(self.created_at),
}
@dataclass
class Chat:
id: str
title: str
member_ids: List[str]
created_at: datetime
def to_dict(self) -> dict:
return {
"id": self.id,
"title": self.title,
"member_ids": list(self.member_ids),
"created_at": format_ts(self.created_at),
}
@dataclass
class Message:
id: str
chat_id: str
sender_id: str
text: str
created_at: datetime
def to_dict(self) -> dict:
return {
"id": self.id,
"chat_id": self.chat_id,
"sender_id": self.sender_id,
"text": self.text,
"created_at": format_ts(self.created_at),
}
def _row_user(row: dict) -> User:
return User(
id=str(row["id"]),
username=row["username"],
display_name=row["display_name"],
created_at=row["created_at"],
password_hash=row.get("password_hash", ""),
)
def _row_message(row: dict) -> Message:
return Message(
id=str(row["id"]),
chat_id=str(row["chat_id"]),
sender_id=str(row["sender_id"]),
text=row["text"],
created_at=row["created_at"],
)
class Store:
def hash_password(self, password: str) -> str:
return _ph.hash(password)
def verify_password(self, password_hash: str, password: str) -> bool:
try:
return _ph.verify(password_hash, password)
except VerifyMismatchError:
return False
except Exception:
return False
def create_user(self, username: str, display_name: str, password: str) -> User:
user_id = uuid.uuid4()
created = utc_now()
password_hash = self.hash_password(password)
try:
with get_pool().connection() as conn:
with conn.transaction():
conn.execute(
"""
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES (%s, %s, %s, %s, %s)
""",
(user_id, username, display_name, password_hash, created),
)
except (pg_errors.UniqueViolation, pg_errors.IntegrityError) as exc:
raise KeyError("username_taken") from exc
except PsycopgError as exc:
raise StoreUnavailable("database unavailable") from exc
return User(
id=str(user_id),
username=username,
display_name=display_name,
created_at=created,
)
def get_user(self, user_id: str) -> Optional[User]:
try:
with get_pool().connection() as conn:
row = conn.execute(
"""
SELECT id, username, display_name, password_hash, created_at
FROM users WHERE id = %s
""",
(user_id,),
).fetchone()
except PsycopgError as exc:
raise StoreUnavailable("database unavailable") from exc
return _row_user(row) if row else None
def get_user_by_username(self, username: str) -> Optional[User]:
try:
with get_pool().connection() as conn:
row = conn.execute(
"""
SELECT id, username, display_name, password_hash, created_at
FROM users WHERE username = %s
""",
(username,),
).fetchone()
except PsycopgError as exc:
raise StoreUnavailable("database unavailable") from exc
return _row_user(row) if row else None
def create_chat(self, title: str, member_ids: List[str]) -> Chat:
chat_id = uuid.uuid4()
created = utc_now()
try:
with get_pool().connection() as conn:
with conn.transaction():
# Atomic membership check + insert; rollback if any member missing.
rows = conn.execute(
"SELECT id FROM users WHERE id = ANY(%s::uuid[])",
(member_ids,),
).fetchall()
found = {str(r["id"]) for r in rows}
if found != set(member_ids):
raise KeyError("unknown_member")
conn.execute(
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)",
(chat_id, title, created),
)
for mid in member_ids:
conn.execute(
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
(chat_id, mid),
)
except KeyError:
raise
except PsycopgError as exc:
raise StoreUnavailable("database unavailable") from exc
return Chat(
id=str(chat_id),
title=title,
member_ids=list(member_ids),
created_at=created,
)
def get_chat(self, chat_id: str) -> Optional[Chat]:
try:
with get_pool().connection() as conn:
row = conn.execute(
"SELECT id, title, created_at FROM chats WHERE id = %s",
(chat_id,),
).fetchone()
if not row:
return None
members = conn.execute(
"""
SELECT user_id FROM chat_members
WHERE chat_id = %s
ORDER BY user_id
""",
(chat_id,),
).fetchall()
except PsycopgError as exc:
raise StoreUnavailable("database unavailable") from exc
return Chat(
id=str(row["id"]),
title=row["title"],
member_ids=[str(m["user_id"]) for m in members],
created_at=row["created_at"],
)
def list_chats_for_user(
self,
user_id: str,
limit: int,
cursor: Optional[Tuple[datetime, uuid.UUID]],
) -> Tuple[List[Chat], Optional[str]]:
params: list = [user_id]
where = "cm.user_id = %s"
if cursor is not None:
where += " AND (c.created_at, c.id) > (%s, %s)"
params.extend([cursor[0], cursor[1]])
params.append(limit + 1)
try:
with get_pool().connection() as conn:
rows = conn.execute(
f"""
SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members cm ON cm.chat_id = c.id
WHERE {where}
ORDER BY c.created_at ASC, c.id ASC
LIMIT %s
""",
params,
).fetchall()
chats: List[Chat] = []
for row in rows[:limit]:
members = conn.execute(
"""
SELECT user_id FROM chat_members
WHERE chat_id = %s
ORDER BY user_id
""",
(row["id"],),
).fetchall()
chats.append(
Chat(
id=str(row["id"]),
title=row["title"],
member_ids=[str(m["user_id"]) for m in members],
created_at=row["created_at"],
)
)
except PsycopgError as exc:
raise StoreUnavailable("database unavailable") from exc
has_more = len(rows) > limit
return chats, "more" if has_more else None
def create_message(self, chat_id: str, sender_id: str, text: str) -> Message:
msg_id = uuid.uuid4()
created = utc_now()
try:
with get_pool().connection() as conn:
with conn.transaction():
conn.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES (%s, %s, %s, %s, %s)
""",
(msg_id, chat_id, sender_id, text, created),
)
except pg_errors.DataError as exc:
# e.g. unexpected encoding issues after validation
raise ValueError("invalid_text") from exc
except PsycopgError as exc:
raise StoreUnavailable("database unavailable") from exc
return Message(
id=str(msg_id),
chat_id=chat_id,
sender_id=sender_id,
text=text,
created_at=created,
)
def list_messages(
self,
chat_id: str,
limit: int,
cursor: Optional[Tuple[datetime, uuid.UUID]],
) -> Tuple[List[Message], bool]:
params: list = [chat_id]
where = "chat_id = %s"
if cursor is not None:
where += " AND (created_at, id) > (%s, %s)"
params.extend([cursor[0], cursor[1]])
params.append(limit + 1)
try:
with get_pool().connection() as conn:
rows = conn.execute(
f"""
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE {where}
ORDER BY created_at ASC, id ASC
LIMIT %s
""",
params,
).fetchall()
except PsycopgError as exc:
raise StoreUnavailable("database unavailable") from exc
messages = [_row_message(r) for r in rows[:limit]]
return messages, len(rows) > limit
def message_exists(self, chat_id: str, created_at: datetime, item_id: uuid.UUID) -> bool:
try:
with get_pool().connection() as conn:
row = conn.execute(
"""
SELECT 1 AS ok FROM messages
WHERE chat_id = %s AND created_at = %s AND id = %s
""",
(chat_id, created_at, item_id),
).fetchone()
except PsycopgError as exc:
raise StoreUnavailable("database unavailable") from exc
return bool(row)
def chat_exists_for_user(
self, user_id: str, created_at: datetime, item_id: uuid.UUID
) -> bool:
try:
with get_pool().connection() as conn:
row = conn.execute(
"""
SELECT 1 AS ok
FROM chats c
JOIN chat_members cm ON cm.chat_id = c.id
WHERE cm.user_id = %s AND c.created_at = %s AND c.id = %s
""",
(user_id, created_at, item_id),
).fetchone()
except PsycopgError as exc:
raise StoreUnavailable("database unavailable") from exc
return bool(row)
+11
View File
@@ -0,0 +1,11 @@
# Собственные проверки (lab2)
Требуется уже запущенный стенд (`compose up`).
```sh
# из корня репозитория, внутри контейнера python или локально:
cd student-tests
BASE_URL=http://127.0.0.1:8080 python run_all.py
```
Для проверки expiry поднимите API с `SESSION_TTL_SECONDS=2` и повторите `test_sessions`.
+64
View File
@@ -0,0 +1,64 @@
"""Minimal HTTP helpers for student tests (stdlib only)."""
from __future__ import annotations
import base64
import json
import os
import urllib.error
import urllib.request
import uuid
BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/")
def call(method, path, expected=None, body=None, token=None, headers=None, raw=None):
h = {"Accept": "application/json"}
if token:
h["Authorization"] = "Bearer " + token
if body is not None:
raw = json.dumps(body, ensure_ascii=False).encode("utf-8")
h["Content-Type"] = "application/json"
h.update(headers or {})
req = urllib.request.Request(BASE_URL + path, data=raw, headers=h, method=method)
try:
resp = urllib.request.urlopen(req, timeout=30)
except urllib.error.HTTPError as err:
resp = err
data = resp.read()
status = resp.code
if expected is not None:
assert status == expected, (
f"{method} {path}: expected {expected}, got {status}: {data[:200]!r}"
)
payload = None
ctype = resp.headers.get_content_type()
if ctype == "application/json" and data:
payload = json.loads(data.decode("utf-8"))
assert resp.headers.get("X-Request-Id"), "missing X-Request-Id"
return {"status": status, "headers": resp.headers, "json": payload, "bytes": data}
def register(label: str):
username = f"st_{label}_{uuid.uuid4().hex[:10]}"
password = "T3st-" + uuid.uuid4().hex
body = {
"username": username,
"display_name": f"Student {label}",
"password": password,
}
user = call("POST", "/api/v1/users", 201, body=body)["json"]
credential = base64.b64encode(f"{username}:{password}".encode()).decode()
session = call(
"POST",
"/api/v1/auth/sessions",
201,
headers={"Authorization": "Basic " + credential},
)["json"]
return {
"id": user["id"],
"user": user,
"token": session["token"],
"registration": body,
}
+41
View File
@@ -0,0 +1,41 @@
#!/usr/bin/env python3
"""Run all student tests against a live API (BASE_URL)."""
from __future__ import annotations
import importlib
import sys
import traceback
MODULES = [
"test_api",
"test_concurrency",
"test_sessions",
"test_deps",
]
def main() -> int:
failed = 0
passed = 0
for name in MODULES:
mod = importlib.import_module(name)
tests = [getattr(mod, n) for n in dir(mod) if n.startswith("test_")]
for fn in tests:
label = f"{name}.{fn.__name__}"
try:
fn()
print("OK", label)
passed += 1
except Exception as exc:
failed += 1
print("FAIL", label, ":", exc)
traceback.print_exc()
print(f"Summary: {passed} passed, {failed} failed")
return 1 if failed else 0
if __name__ == "__main__":
sys.path.insert(0, ".")
raise SystemExit(main())
+159
View File
@@ -0,0 +1,159 @@
"""Grade 3/4 API checks: auth, conflict, X-User-Id ignored, logout."""
from __future__ import annotations
import base64
import time
import uuid
from helpers import call, register
def test_username_conflict():
a = register("conflict")
body = dict(a["registration"])
call("POST", "/api/v1/users", 409, body=body)
def test_wrong_password():
a = register("wrongpw")
bad = base64.b64encode(
(a["registration"]["username"] + ":wrong-password-xx").encode()
).decode()
resp = call(
"POST",
"/api/v1/auth/sessions",
401,
headers={"Authorization": "Basic " + bad},
)
assert resp["headers"].get("WWW-Authenticate", "").lower().startswith("basic")
def test_x_user_id_ignored():
a = register("xu")
b = register("xv")
me = call(
"GET",
"/api/v1/users/me",
200,
token=a["token"],
headers={"X-User-Id": b["id"]},
)["json"]
assert me["id"] == a["id"]
def test_basic_on_business_rejected():
a = register("basicbiz")
cred = base64.b64encode(
(a["registration"]["username"] + ":" + a["registration"]["password"]).encode()
).decode()
call(
"GET",
"/api/v1/users/me",
401,
headers={"Authorization": "Basic " + cred},
)
def test_logout_revokes():
a = register("logout")
call("DELETE", "/api/v1/auth/sessions/current", 204, token=a["token"])
call("GET", "/api/v1/users/me", 401, token=a["token"])
def test_chat_requires_caller_member():
a = register("owner")
b = register("peer")
call(
"POST",
"/api/v1/chats",
400,
token=a["token"],
body={"title": "no me", "member_ids": [b["id"]]},
)
def test_unknown_member_rolls_back():
a = register("atom")
fake = str(uuid.uuid4())
call(
"POST",
"/api/v1/chats",
400,
token=a["token"],
body={"title": "bad", "member_ids": [a["id"], fake]},
)
def test_whitespace_only_password_rejected():
# Maintainer remark: required strings must not be whitespace-only.
body = {
"username": "ws_" + uuid.uuid4().hex[:10],
"display_name": "Spaces",
"password": " " * 12,
}
call("POST", "/api/v1/users", 400, body=body)
def test_nul_in_text_rejected():
a = register("nul")
peer = register("nulb")
chat = call(
"POST",
"/api/v1/chats",
201,
token=a["token"],
body={"title": "nul-chat", "member_ids": [a["id"], peer["id"]]},
)["json"]
call(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
400,
token=a["token"],
body={"text": "hello\u0000world"},
)
def test_login_rejects_json_body():
a = register("bodylogin")
cred = base64.b64encode(
(a["registration"]["username"] + ":" + a["registration"]["password"]).encode()
).decode()
call(
"POST",
"/api/v1/auth/sessions",
400,
body={"unexpected": True},
headers={"Authorization": "Basic " + cred},
)
def test_invalid_basic_encoding_is_401():
# Maintainer remark: malformed Basic must be 401, not 500.
call(
"POST",
"/api/v1/auth/sessions",
401,
headers={"Authorization": "Basic " + base64.b64encode("é".encode()).decode()},
)
def test_unsupported_media_type():
a = register("ctype")
peer = register("ctypeb")
chat = call(
"POST",
"/api/v1/chats",
201,
token=a["token"],
body={"title": "ctype", "member_ids": [a["id"], peer["id"]]},
)["json"]
raw = b'{"text":"x"}'
call(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
415,
token=a["token"],
raw=raw,
headers={"Content-Type": "text/plain"},
)
+66
View File
@@ -0,0 +1,66 @@
"""Concurrent registration race and parallel messages."""
from __future__ import annotations
import concurrent.futures
import uuid
from helpers import BASE_URL, call, register
def test_parallel_messages_unique():
a = register("par")
b = register("parb")
chat = call(
"POST",
"/api/v1/chats",
201,
token=a["token"],
body={"title": "parallel", "member_ids": [a["id"], b["id"]]},
)["json"]
def send(i: int):
return call(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
201,
token=a["token"],
body={"text": f"msg-{i}"},
)["json"]["id"]
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as pool:
ids = list(pool.map(send, range(100)))
assert len(ids) == len(set(ids)) == 100
def test_username_race_one_winner():
username = "race_" + uuid.uuid4().hex[:12]
password = "T3st-" + uuid.uuid4().hex
body = {
"username": username,
"display_name": "Race",
"password": password,
}
def attempt(_):
import json
import urllib.error
import urllib.request
raw = json.dumps(body).encode("utf-8")
req = urllib.request.Request(
BASE_URL + "/api/v1/users",
data=raw,
headers={"Content-Type": "application/json", "Accept": "application/json"},
method="POST",
)
try:
resp = urllib.request.urlopen(req, timeout=30)
except urllib.error.HTTPError as err:
resp = err
return resp.code
with concurrent.futures.ThreadPoolExecutor(max_workers=8) as pool:
codes = list(pool.map(attempt, range(8)))
assert codes.count(201) == 1, codes
assert codes.count(409) == 7, codes
+68
View File
@@ -0,0 +1,68 @@
"""Dependency failure checks (Redis/Postgres). Optional: RUN_DEPS_TEST=1."""
from __future__ import annotations
import os
import subprocess
import time
from helpers import BASE_URL, call, register
def _compose(*args: str) -> None:
cmd = ["docker", "compose", "--env-file", ".env", *args]
subprocess.check_call(cmd, cwd=os.path.join(os.path.dirname(__file__), ".."))
def _wait_ready(timeout_s: int = 60) -> None:
deadline = time.time() + timeout_s
while time.time() < deadline:
try:
if call("GET", "/health/ready")["status"] == 200:
return
except Exception:
pass
time.sleep(1)
raise AssertionError("stack did not become ready in time")
def test_redis_stop_returns_503_or_unready():
if os.environ.get("RUN_DEPS_TEST") != "1":
print("SKIP test_redis_stop_returns_503_or_unready (set RUN_DEPS_TEST=1)")
return
actor = register("deps")
_compose("stop", "redis")
time.sleep(2)
try:
ready = call("GET", "/health/ready")
assert ready["status"] == 503, ready["status"]
me = call("GET", "/api/v1/users/me", token=actor["token"])
assert me["status"] in (401, 503)
finally:
_compose("start", "redis")
_wait_ready()
def test_postgres_stop_returns_503():
# Maintainer remark (level 4): cover PostgreSQL unavailability like Redis.
if os.environ.get("RUN_DEPS_TEST") != "1":
print("SKIP test_postgres_stop_returns_503 (set RUN_DEPS_TEST=1)")
return
actor = register("deps_pg")
_compose("stop", "postgres")
time.sleep(2)
try:
ready = call("GET", "/health/ready")
assert ready["status"] == 503, ready["status"]
# Authenticated business path must fail fast as 503 (not hang / not 500).
me = call("GET", "/api/v1/users/me", token=actor["token"])
assert me["status"] == 503, me["status"]
hist = call(
"GET",
f"/api/v1/chats/{actor['id']}/messages",
token=actor["token"],
)
assert hist["status"] in (400, 404, 503), hist["status"]
finally:
_compose("start", "postgres")
_wait_ready(90)
+34
View File
@@ -0,0 +1,34 @@
"""Session expiry (short TTL) — run against stack with SESSION_TTL_SECONDS=2."""
from __future__ import annotations
import base64
import os
import time
from helpers import call, register
def test_session_expiry_if_short_ttl():
ttl = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
if ttl > 5:
print("SKIP expiry: SESSION_TTL_SECONDS=%s (need <=5 for this test)" % ttl)
return
a = register("expire")
time.sleep(ttl + 1.5)
call("GET", "/api/v1/users/me", 401, token=a["token"])
def test_login_after_register():
a = register("relogin")
cred = base64.b64encode(
(a["registration"]["username"] + ":" + a["registration"]["password"]).encode()
).decode()
session = call(
"POST",
"/api/v1/auth/sessions",
201,
headers={"Authorization": "Basic " + cred},
)["json"]
assert session["token_type"] == "Bearer"
assert session["user"]["id"] == a["id"]